pax_global_header00006660000000000000000000000064150612743400014514gustar00rootroot0000000000000052 comment=914883a682b93f320eb714d9ae5c9fa3f9fcf4a5 prism-1.5.1/000077500000000000000000000000001506127434000126525ustar00rootroot00000000000000prism-1.5.1/.editorconfig000066400000000000000000000005661506127434000153360ustar00rootroot00000000000000root = true [*] end_of_line = lf insert_final_newline = true trim_trailing_whitespace = true [*.{c,h}] indent_style = space indent_size = 4 tab_width = 8 [{*.rb,*.gemspec,Rakefile,*.yml}] indent_style = space indent_size = 2 [{*.java,*.java.erb}] indent_style = space indent_size = 4 [{*[Mm]akefile*,*.mak,*.mk,depend}] indent_style = tab indent_size = 4 tab_width = 4 prism-1.5.1/.git-blame-ignore-revs000066400000000000000000000001221506127434000167450ustar00rootroot00000000000000ac3dec89a67626450b07b266cc8514bc8d6ce4f6 82e659a752f73ccb23f5585f13aae4bedc09485f prism-1.5.1/.gitattributes000066400000000000000000000014621506127434000155500ustar00rootroot00000000000000templates/**/*.c.erb linguist-language=C templates/**/*.h.erb linguist-language=C templates/**/*.java.erb linguist-language=Java templates/**/*.rb.erb linguist-language=Ruby test/prism/fixtures/seattlerb/**/*.txt linguist-vendored test/prism/fixtures/unparser/**/*.txt linguist-vendored test/prism/fixtures/whitequark/**/*.txt linguist-vendored test/prism/snapshots/**/*.txt linguist-generated # All .rb files should have LF line ending, even on Windows, regardless of the git config core.autocrlf value. # All .txt should have their line endings as committed in the repository (there are some intentional CR in there), # regardless of the git config core.autocrlf value. # See https://docs.github.com/en/get-started/getting-started-with-git/configuring-git-to-handle-line-endings **/*.rb text eol=lf **/*.txt -text prism-1.5.1/.github/000077500000000000000000000000001506127434000142125ustar00rootroot00000000000000prism-1.5.1/.github/dependabot.yml000066400000000000000000000013601506127434000170420ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: 'github-actions' directory: '/' schedule: interval: 'weekly' groups: action-deps: patterns: - "*" - package-ecosystem: 'maven' directory: '/java-wasm' schedule: interval: 'weekly' groups: java-deps: patterns: - "*" - package-ecosystem: 'bundler' directories: - '/gemfiles/2.7' - '/gemfiles/3.0' - '/gemfiles/3.1' - '/gemfiles/3.2' - '/gemfiles/3.3' - '/gemfiles/3.4' - '/gemfiles/3.5' - '/gemfiles/jruby' - '/gemfiles/truffleruby' - '/gemfiles/typecheck' schedule: interval: 'weekly' groups: ruby-deps: patterns: - "*" prism-1.5.1/.github/workflows/000077500000000000000000000000001506127434000162475ustar00rootroot00000000000000prism-1.5.1/.github/workflows/build-artifacts.yml000066400000000000000000000017431506127434000220540ustar00rootroot00000000000000name: Build Library Artifacts concurrency: group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} cancel-in-progress: true on: release: types: [created] workflow_dispatch: jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: '3.3' bundler-cache: true - name: Build library run: bundle exec rake templates - name: Package libprism source run: | mkdir -p build/libprism-src cp -r src build/libprism-src/src cp -r include build/libprism-src/include cp Makefile build/libprism-src/Makefile tar -czf build/libprism-src.tar.gz -C build libprism-src - name: Upload to release if: github.event_name == 'release' env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} uses: softprops/action-gh-release@v2 with: files: build/libprism-src.tar.gz prism-1.5.1/.github/workflows/cpp-bindings.yml000066400000000000000000000012761506127434000213550ustar00rootroot00000000000000name: C++ bindings on: push: paths: - ".github/workflows/cpp-bindings.yml" - "include/" - "src/" - "cpp/" - "*akefile*" branches: - main pull_request: jobs: test: name: test strategy: fail-fast: false runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: head bundler-cache: true - name: Compile prism run: bundle exec rake compile - name: Compile C++ run: g++ -o ./cpp_test cpp/test.cpp build/static/*.o build/static/util/*.o -Iinclude - name: Run C++ run: ./cpp_test prism-1.5.1/.github/workflows/cruby-bindings.yml000066400000000000000000000025521506127434000217150ustar00rootroot00000000000000name: CRuby bindings concurrency: group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} cancel-in-progress: true on: push: branches: - main pull_request: jobs: test-all: runs-on: ubuntu-24.04 steps: - name: Set up latest ruby head uses: ruby/setup-ruby@v1 with: ruby-version: head bundler: none - uses: actions/checkout@v5 with: repository: ruby/ruby path: ruby/ruby fetch-depth: 1 - name: Install libraries run: | set -x sudo apt-get update -q || : sudo apt-get install --no-install-recommends -q -y build-essential libssl-dev libyaml-dev libreadline6-dev zlib1g-dev libncurses5-dev libffi-dev libgdbm-dev autoconf ruby - uses: actions/checkout@v5 with: path: ruby/prism fetch-depth: 1 - run: tool/sync_default_gems.rb prism working-directory: ruby/ruby - name: Build Ruby run: | ruby tool/downloader.rb -d tool -e gnu config.guess config.sub autoconf ./configure -C --disable-install-doc make -j2 working-directory: ruby/ruby - name: make test-all run: make -j2 -s test-all TESTS="prism ruby/test_syntax.rb ruby/test_compile_prism.rb --no-retry" working-directory: ruby/ruby prism-1.5.1/.github/workflows/documentation.yml000066400000000000000000000021711506127434000216440ustar00rootroot00000000000000name: Documentation concurrency: group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} cancel-in-progress: true on: push: branches: - main pull_request: jobs: check: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: "3.3" bundler-cache: true - name: Set up Rust uses: dtolnay/rust-toolchain@master with: toolchain: stable - name: Install doxygen and dependencies run: | sudo apt-get update sudo apt-get install doxygen graphviz - name: Generate the templates run: bundle exec rake templates - name: Check ruby coverage run: bundle exec rake rdoc:coverage - name: Check C coverage run: doxygen Doxyfile - name: Check Java coverage run: javadoc -Xdoclint:all,-missing -d ../doc/java -subpackages * working-directory: java - name: Generate Rust documentation run: | bundle exec rake cargo:build cargo doc --no-deps --target-dir ../doc/rust working-directory: rust prism-1.5.1/.github/workflows/github-pages.yml000066400000000000000000000041011506127434000213450ustar00rootroot00000000000000name: GitHub pages on: # Runs on pushes targeting the default branch push: branches: - main # Allows you to run this workflow manually from the Actions tab workflow_dispatch: # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages permissions: contents: read pages: write id-token: write # Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued. # However, do NOT cancel in-progress runs as we want to allow these production deployments to complete. concurrency: group: "pages" cancel-in-progress: false jobs: build: if: github.repository == 'ruby/prism' runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v5 - name: Setup Ruby uses: ruby/setup-ruby@v1 with: ruby-version: "3.2" bundler-cache: true - name: Set up Rust uses: dtolnay/rust-toolchain@master with: toolchain: stable - name: Install doxygen and dependencies run: | sudo apt-get update sudo apt-get install doxygen graphviz - name: Setup Pages id: pages uses: actions/configure-pages@v5 - name: Template source files run: bundle exec rake templates - name: Build with RDoc run: bundle exec rake rdoc - name: Build with Doxygen run: doxygen Doxyfile - name: Build with JavaDoc run: javadoc -Xdoclint:all,-missing -d ../doc/java -subpackages * working-directory: java - name: Build with rustdoc run: | bundle exec rake cargo:build cargo doc --no-deps --target-dir ../doc/rust working-directory: rust - name: Upload artifact uses: actions/upload-pages-artifact@v4 with: path: doc deploy: environment: name: github-pages url: ${{ steps.deployment.outputs.page_url }} runs-on: ubuntu-latest needs: build steps: - name: Deploy to GitHub Pages id: deployment uses: actions/deploy-pages@v4 prism-1.5.1/.github/workflows/java-wasm-bindings.yml000066400000000000000000000023761506127434000224630ustar00rootroot00000000000000name: Java WASM bindings on: push: paths: - ".github/workflows/java-wasm-bindings.yml" - "include/" - "src/" - "*akefile*" branches: - main pull_request: jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: head bundler-cache: true - name: rake templates run: PRISM_EXCLUDE_PRETTYPRINT=1 PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS=1 bundle exec rake templates - name: Set up WASI-SDK run: | wget https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-25/wasi-sdk-25.0-x86_64-linux.tar.gz tar xvf wasi-sdk-25.0-x86_64-linux.tar.gz - name: Build the project run: make java-wasm WASI_SDK_PATH=$(pwd)/wasi-sdk-25.0-x86_64-linux - name: Set up Java uses: actions/setup-java@v5 with: distribution: 'temurin' java-version: '17' cache: maven - name: Run the tests run: mvn -B install working-directory: java-wasm - uses: actions/upload-artifact@v4 with: name: prism.wasm path: java-wasm/src/test/resources/prism.wasm prism-1.5.1/.github/workflows/javascript-bindings.yml000066400000000000000000000021211506127434000227270ustar00rootroot00000000000000name: JavaScript bindings on: push: paths: - ".github/workflows/javascript-bindings.yml" - "include/" - "src/" - "*akefile*" branches: - main pull_request: jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: head bundler-cache: true - name: rake templates run: bundle exec rake templates - name: Set up WASI-SDK run: | wget https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-25/wasi-sdk-25.0-x86_64-linux.tar.gz tar xvf wasi-sdk-25.0-x86_64-linux.tar.gz - name: Build the project run: make wasm WASI_SDK_PATH=$(pwd)/wasi-sdk-25.0-x86_64-linux - uses: actions/upload-artifact@v4 with: name: prism.wasm path: javascript/src/prism.wasm - uses: actions/setup-node@v5 with: node-version: 20.x - name: Run the tests run: npm test working-directory: javascript prism-1.5.1/.github/workflows/main.yml000066400000000000000000000237071506127434000177270ustar00rootroot00000000000000name: Main concurrency: group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} cancel-in-progress: true on: push: branches: - main pull_request: jobs: lint: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: "3.4" bundler-cache: true - name: Lint run: bundle exec rake lint template: runs-on: ubuntu-latest env: BUNDLE_GEMFILE: gemfiles/2.7/Gemfile steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: "2.7.0" bundler-cache: true - name: Generate templates run: bundle exec rake templates env: LANG: "C" typecheck: runs-on: ubuntu-latest env: BUNDLE_GEMFILE: gemfiles/typecheck/Gemfile steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: "3.4" bundler-cache: true - name: Check Sorbet run: bundle exec rake typecheck:tapioca typecheck:sorbet - name: Check Steep run: bundle exec rake typecheck:steep - name: Check field kinds run: rm lib/prism/node.rb && CHECK_FIELD_KIND=true bundle exec rake build: strategy: fail-fast: false matrix: os: - ubuntu-latest - ubuntu-24.04-arm - macos-latest # - windows-latest <-- failing with fiddle error, temporarily disabled runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: head bundler-cache: true - name: Run Ruby tests run: bundle exec rake shell: bash build-ibm: if: github.repository == 'ruby/prism' strategy: fail-fast: false matrix: os: - ubuntu-24.04-ppc64le - ubuntu-24.04-s390x runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v5 - name: Set up Ruby run: | sudo apt-get update sudo apt-get install ruby-full bundler libyaml-dev - name: Install dependencies run: sudo bundle install --jobs 2 - name: Run Ruby tests run: bundle exec rake shell: bash build-ffi: strategy: fail-fast: false matrix: target: - { ruby: "head", gemfile: "3.5" } - { ruby: "jruby-10.0.0.0", gemfile: "jruby" } # https://github.com/jruby/jruby/issues/8923 - { ruby: "truffleruby", gemfile: "truffleruby" } runs-on: ubuntu-latest env: PRISM_FFI_BACKEND: "true" BUNDLE_GEMFILE: gemfiles/${{ matrix.target.gemfile }}/Gemfile steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: ${{ matrix.target.ruby }} bundler-cache: true - name: Run Ruby tests run: bundle exec rake build-without-assertions: strategy: fail-fast: false matrix: os: [ubuntu-22.04, ubuntu-24.04] runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: head bundler-cache: true - name: Run Ruby tests run: bundle exec rake compile_no_debug test build-debug: strategy: fail-fast: false matrix: os: - ubuntu-latest - ubuntu-24.04-arm - macos-latest # - windows-latest <-- failing with fiddle error, temporarily disabled runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: head bundler-cache: true - name: Run Ruby tests run: bundle exec rake env: PRISM_BUILD_DEBUG: "1" build-minimal: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: head bundler-cache: true - name: Run Ruby tests run: bundle exec rake compile_minimal test env: PRISM_BUILD_MINIMAL: "1" build-java: runs-on: ubuntu-latest env: JRUBY_OPTS: "--dev" steps: - uses: actions/checkout@v5 - name: Set up JRuby uses: ruby/setup-ruby@v1 with: ruby-version: jruby bundler-cache: true - name: Run Java Loader test run: PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS=1 JRUBY_OPTS="-J-ea" bundle exec rake test:java_loader lex-ruby: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: head bundler-cache: true - name: Lex ruby/ruby run: bundle exec rake lex:ruby lex-discourse: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: head bundler-cache: true - name: Lex discourse/discourse run: bundle exec rake lex:discourse lex-top-100: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: head bundler-cache: true - name: Lex Top 100 Gems run: bundle exec rake lex:topgems - name: Parse Top 100 Gems run: bundle exec rake parse:topgems - name: Serialized size stats with all fields run: bundle exec rake serialized_size:topgems - name: Recompile with only semantic fields run: PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS=1 bundle exec rake clobber compile - name: Serialized size stats with only semantic fields run: bundle exec rake serialized_size:topgems memcheck: runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v5 - name: Install valgrind run: | sudo apt-get update sudo apt-get install -y valgrind - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: head bundler-cache: true - name: Run Ruby tests with valgrind run: bundle exec rake test:valgrind gem-package: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - uses: ruby/setup-ruby@v1 with: ruby-version: head bundler-cache: true - run: bundle config --local frozen false - run: bundle exec rake build:dev - uses: actions/upload-artifact@v4 with: name: gem-package path: pkg retention-days: 1 gem-install: needs: ["gem-package"] strategy: fail-fast: false matrix: target: - { ruby: "2.7", os: "ubuntu-latest", gemfile: "2.7" } - { ruby: "3.0", os: "ubuntu-latest", gemfile: "3.0" } - { ruby: "3.1", os: "ubuntu-latest", gemfile: "3.1" } - { ruby: "3.2", os: "ubuntu-latest", gemfile: "3.2" } - { ruby: "3.3", os: "ubuntu-latest", gemfile: "3.3" } - { ruby: "3.4", os: "ubuntu-latest", gemfile: "3.4" } - { ruby: "head", os: "ubuntu-latest", gemfile: "3.5" } - { ruby: "jruby-10.0.0.0", os: "ubuntu-latest", gemfile: "jruby" } # https://github.com/jruby/jruby/issues/8923 - { ruby: "truffleruby", os: "ubuntu-latest", gemfile: "truffleruby" } - { ruby: "2.7", os: "macos-latest", gemfile: "2.7" } - { ruby: "3.0", os: "macos-latest", gemfile: "3.0" } - { ruby: "3.1", os: "macos-latest", gemfile: "3.1" } - { ruby: "3.2", os: "macos-latest", gemfile: "3.2" } - { ruby: "3.3", os: "macos-latest", gemfile: "3.3" } - { ruby: "3.4", os: "macos-latest", gemfile: "3.4" } - { ruby: "head", os: "macos-latest", gemfile: "3.5" } - { ruby: "jruby-10.0.0.0", os: "macos-latest", gemfile: "jruby" } # https://github.com/jruby/jruby/issues/8923 - { ruby: "truffleruby", os: "macos-latest", gemfile: "truffleruby" } - { ruby: "2.7", os: "windows-latest", gemfile: "2.7" } - { ruby: "3.0", os: "windows-latest", gemfile: "3.0" } - { ruby: "3.1", os: "windows-latest", gemfile: "3.1" } - { ruby: "3.2", os: "windows-latest", gemfile: "3.2" } - { ruby: "3.3", os: "windows-latest", gemfile: "3.3" } - { ruby: "3.4", os: "windows-latest", gemfile: "3.4" } # - { ruby: "head", os: "windows-latest", gemfile: "3.5" } <-- failing certs, temporarily disabled - { ruby: "jruby-10.0.0.0", os: "windows-latest", gemfile: "jruby" } # https://github.com/jruby/jruby/issues/8923 env: BUNDLE_GEMFILE: gemfiles/${{ matrix.target.gemfile }}/Gemfile runs-on: ${{ matrix.target.os }} steps: - uses: actions/checkout@v5 - uses: ruby/setup-ruby@v1 with: ruby-version: ${{ matrix.target.ruby }} - uses: actions/download-artifact@v5 with: name: gem-package path: pkg - run: | gem install --local pkg/prism-*.gem gem list -d prism shell: bash - name: Run tests run: | bundle install rm -rf lib ext # ensure we don't use the local files rake test shell: bash gcc-analyzer: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: head bundler-cache: true - name: Run build with gcc-analyzer enabled run: | CFLAGS='-fanalyzer' bundle exec rake compile clang-analyzer: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: head bundler-cache: true - name: Install clang-analyzer run: sudo apt-get install -y clang-tools - name: Run build with clang-analyzer run: | scan-build bundle exec rake compile 2>&1 | tee /tmp/scan_build_output.log grep -q 'scan-build: No bugs found.' /tmp/scan_build_output.log prism-1.5.1/.github/workflows/rust-bindings.yml000066400000000000000000000075661506127434000216000ustar00rootroot00000000000000name: Rust bindings on: push: paths: - ".github/workflows/rust-bindings.yml" - "include/" - "src/" - "rust/" - "*akefile*" branches: - main pull_request: env: RUSTFLAGS: "-D warnings" jobs: test: name: cargo:test strategy: fail-fast: false matrix: os: [ubuntu-latest, macos-latest, windows-latest] runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: 3.4 bundler-cache: true - name: Set up Rust uses: dtolnay/rust-toolchain@master with: toolchain: stable targets: wasm32-wasip1 - uses: actions/cache@v4 with: path: | ~/.cargo/registry ~/.cargo/git target key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }} restore-keys: | ${{ runner.os }}-cargo-${{ hashFiles('Cargo.toml') }} ${{ runner.os }}-cargo - name: Run tests run: bundle exec rake cargo:test - name: Run examples if: ${{ matrix.os != 'windows-latest' }} run: bundle exec rake cargo:examples lint: name: cargo:lint strategy: fail-fast: false runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: 3.4 bundler-cache: true - name: Set up Rust uses: dtolnay/rust-toolchain@master with: toolchain: stable components: clippy, rustfmt - uses: actions/cache@v4 with: path: | ~/.cargo/registry ~/.cargo/git target key: ${{ runner.os }}-cargo--${{ hashFiles('**/Cargo.toml') }} restore-keys: | ${{ runner.os }}-cargo-${{ hashFiles('Cargo.toml') }} ${{ runner.os }}-cargo - name: rake cargo:build run: bundle exec rake cargo:build - name: rake cargo:lint run: bundle exec rake cargo:lint sanitize: name: cargo:sanitize:${{ matrix.sanitizer }} runs-on: ubuntu-latest strategy: fail-fast: false matrix: sanitizer: [address] steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: 3.4 bundler-cache: true - name: rake cargo:build run: bundle exec rake cargo:build - uses: dtolnay/rust-toolchain@master with: toolchain: nightly target: "x86_64-unknown-linux-gnu" components: "rust-src" - name: Test with sanitizer run: bundle exec rake cargo:sanitize:${{ matrix.sanitizer }} # We need to figure out what to do here. When you run publish it checks # against the latest version published to crates, which means if we have any # breaking changes in the bindings then this fails. # # publish: # name: cargo:publish # strategy: # fail-fast: false # runs-on: ubuntu-latest # steps: # - uses: actions/checkout@v3 # - name: Set up Ruby # uses: ruby/setup-ruby@v1 # with: # ruby-version: head # bundler-cache: true # - name: Set up Rust # uses: dtolnay/rust-toolchain@master # with: # toolchain: "1.71.1" # targets: wasm32-wasip1 # - uses: actions/cache@v4 # with: # path: | # ~/.cargo/registry # ~/.cargo/git # target # key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }} # restore-keys: | # ${{ runner.os }}-cargo-${{ hashFiles('Cargo.toml') }} # ${{ runner.os }}-cargo # - name: Publish crates (dry-run) # run: bundle exec rake cargo:publish:dry prism-1.5.1/.gitignore000066400000000000000000000023541506127434000146460ustar00rootroot00000000000000/.bundle/ /.idea/ /.yardoc /_yardoc/ /coverage/ /doc/c/ /doc/java/ /doc/rb/ /doc/rust/ /pkg/ /spec/reports/ /top-100-gems/ tmp/ /vendor/bundle /build/ /lib/prism/prism.* /lib/prism.bundle /lib/prism.so /test.rb .DS_Store *.dSYM /*.iml *~ test.c a.out out.svg /ext/prism/api_node.c /fuzz/output/ /gemfiles/typecheck/bin/ /include/prism/ast.h /include/prism/diagnostic.h /javascript/node_modules/ /javascript/package-lock.json /javascript/src/deserialize.js /javascript/src/nodes.js /javascript/src/visitor.js /javascript/src/prism.wasm /javascript/src/*.d.ts /java/org/prism/AbstractNodeVisitor.java /java/org/prism/Loader.java /java/org/prism/Nodes.java /lib/prism/compiler.rb /lib/prism/dispatcher.rb /lib/prism/dot_visitor.rb /lib/prism/dsl.rb /lib/prism/inspect_visitor.rb /lib/prism/mutation_compiler.rb /lib/prism/node.rb /lib/prism/reflection.rb /lib/prism/serialize.rb /lib/prism/visitor.rb /sorbet/ /src/diagnostic.c /src/node.c /src/prettyprint.c /src/serialize.c /src/token_type.c /src/**/*.o /sig/prism.rbs /sig/prism/dsl.rbs /sig/prism/mutation_compiler.rbs /sig/prism/node.rbs /sig/prism/visitor.rbs /sig/prism/_private/dot_visitor.rbs /rbi/prism/dsl.rbi /rbi/prism/node.rbi /rbi/prism/visitor.rbi compile_commands.json .cache/ .vscode/ tags prism-1.5.1/BSDmakefile000066400000000000000000000046661506127434000147170ustar00rootroot00000000000000# GNU makefile proxy script for BSD make # # Written and maintained by Mahmoud Al-Qudsi # Copyright NeoSmart Technologies 2014-2019 # Obtain updates from # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # 1. Redistributions of source code must retain the above copyright notice, this # list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. JARG = GMAKE = "gmake" # When gmake is called from another make instance, -w is automatically added # which causes extraneous messages about directory changes to be emitted. # Running with --no-print-directory silences these messages. GARGS = "--no-print-directory" .if "$(.MAKE.JOBS)" != "" JARG = -j$(.MAKE.JOBS) .endif # bmake prefers out-of-source builds and tries to cd into ./obj (among others) # where possible. GNU Make doesn't, so override that value. .OBJDIR: ./ # The GNU convention is to use the lowercased `prefix` variable/macro to # specify the installation directory. Humor them. GPREFIX = "" .if defined(PREFIX) && ! defined(prefix) GPREFIX = 'prefix = "$(PREFIX)"' .endif .BEGIN: .SILENT which $(GMAKE) || printf "Error: GNU Make is required!\n\n" 1>&2 && false .PHONY: FRC $(.TARGETS): FRC $(GMAKE) $(GPREFIX) $(GARGS) $(.TARGETS:S,.DONE,,) $(JARG) .DONE .DEFAULT: .SILENT $(GMAKE) $(GPREFIX) $(GARGS) $(.TARGETS:S,.DONE,,) $(JARG) prism-1.5.1/CHANGELOG.md000066400000000000000000001156031506127434000144710ustar00rootroot00000000000000# Changelog All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html). ## [Unreleased] ## [1.5.1] - 2025-09-13 ### Changed - Revert of a bug introduced with static literal flags on interpolated strings. ## [1.5.0] - 2025-09-12 ### Added - Add `Prism::Translation::ParserCurrent`. - Add `Integer::to_u32_digits` for the Rust API. - Add `pm_comment_type_t` field for the Rust API. - Support leading logical operators for CRuby 3.5+. ### Changed - Mark Prism as ractor-safe. - Enforce a minimum version for the parser translation layer. - Many fixes to the parser translation layer. - Accept a newline after the `defined?` keyword. - Reject `true && not true`. - Make `it = it` assign nil to match parse.y behavior [Bug #21139]. - Some fixes to the ruby parser translation layer. - Ensure call nodes have the correct ending location. - Reject `foo && return bar`. ## [1.4.0] - 2025-03-18 ### Added - Support `3.5` as a version option. - Many, many compatibility fixes for the parser translation layer. - Handle escapes in named capture names. - The `freeze` option is added to the various `Prism::` APIs to deeply freeze the AST. - Properly support `it` for the parser and ruby_parser translation layers. - Track the `then` keyword on `rescue` nodes. - Add a `multiple_statements?` flag to parentheses nodes to support desired `defined?` behavior. ### Changed - The strings used in the AST are now frozen. - Fixed handling escaped characters after control sequences in character literals. - Fix reading off the end of an unterminated global variable. - Raise a syntax error for defining `[]=` with endless method syntax. - Increase value of `PRISM_DEPTH_MAXIMUM` to `10000`. - Freeze `Prism::VERSION`. - Fix up rescue modifier precedence. ## [1.3.0] - 2024-12-21 ### Added - Introduce `Prism::StringQuery`. - Introduce `Prism::Relocation`. - Track `do` keyword for `WhileNode` and `UntilNode`. - Change the way the gem is built to rely on `mkmf` instead of `make`. - Lots more documentation on node fields. ### Changed - Properly add an error for `def @foo; end`. - Properly add an error for `foo(**, *)`. - Fix up regression in string parsing in `RubyParser` translation. - Reject invalid dot method call after match expression. - Reject invalid operator after match expression. - Fix up %-literals delimited by newlines. - Properly add an error for `-> { _1; -> { _1 } }`. - Reject blocks and keywords in index writes. ## [1.2.0] - 2024-10-10 ### Added - Introduce `Prism::CodeUnitsCache`. ### Changed - Properly handle lexing global variables that begin with `$-`. - Properly reject invalid multi writes within parentheses. - Fix unary `*` binding power. - Set `contains_keywords` flag for implicit `gets` calls when `-p` is used. - Properly reject invalid non-associative operator patterns. - Do not warn about unused variables declared on negative lines. ## [1.1.0] - 2024-10-02 ### Added - Explicitly type each child node field in the Ruby API. - Add the `main_script` option to the parse APIs, which controls whether or not shebangs are considered. - Add the `partial_script` options to the parse APIs, which controls whether or not jumps that would otherwise be considered invalid are allowed. This is useful for parsing things like ERB sources, where you know it will be evaluated in a different context. Note that this functionality is replacing the previous idiom of passing in a list of scopes to indicate an `eval` context, because that behavior has changed upstream in `ruby/ruby`. - Add `ArgumentsNode#contains_multiple_splats?`. - Add `ArgumentsNode#contains_forwarding?`. - Accept all valid Ruby versions for the `version` option on parse APIs. - Accept version shorthands like `"3.3"` and `"3.4"` for the `version` option on parse APIs. - Support a max depth to protect against malicious payloads without hitting the stack limit. ### Changed - Fix some token incompatibilities in the `parser` translation. - Fix up parsing tempfiles on Windows. - Fix up handling UTF-8 characters in file paths on Windows. - Do not warn for a `\r` at the end of a shebang on Windows. - Properly handle erroring for parsing a directory on Windows. - When a numbered reference is out of range, warn instead of raise. - Allow returns in default parameter values. - Reject many more invalid syntax patterns. ## [1.0.0] - 2024-08-28 ### Added - Add `Node#breadth_first_search`. - Add `Node#node_id`. - Add `ArgumentsNode#contains_splat?`. - Passing the special value `false` for the `encoding` option tells Prism to ignore magic encoding comments. - Expose flags on every node type (allows checking static literal and newline). - Implement mismatched indentation warning. - Add C API for receiving a callback when parsing shebangs with additional flags. ### Changed - **BREAKING**: Some fields are renamed that had illogical names. The previous names all now emit deprecation warnings. - `CaseMatchNode#consequent` was renamed to `CaseMatchNode#else_clause` - `CaseNode#consequent` was renamed to `CaseNode#else_clause` - `IfNode#consequent` was renamed to `IfNode#subsequent` - `RescueNode#consequent` was renamed to `RescueNode#subsequent` - `UnlessNode#consequent` was renamed to `UnlessNode#else_clause` - Block exits are now allowed in loop predicates (e.g., `while _ && break do end`). - Multi-writes are now disallowed when not at the statement level. - Ensure that range operators are non-associative. - (JavaScript) Correctly deserialize encoded strings. - Properly support parsing regular expressions in extended mode. - Use gmake on FreeBSD. - Parsing streams now handles NUL bytes in the middle of the stream. - Properly detect invalid returns. ## [0.30.0] - 2024-06-07 ### Added - More correctly raise mixed encoding errors. - Implement ambiguous binary operator warning. - Fix up regexp escapes with control and meta characters. - Fix up support for the `it` implicit local variable. - Heredoc identifiers now properly disallow CLRF. - Errors added for void value expressions in begin clauses. - Many updates to more closely match the `parser` gem in parser translation. - Many errors added for invalid regular expressions. ### Changed - Handle parser translation missing the `parser` gem. - Handle ruby_parser translation missing the `ruby_parser` gem. - Various error messages have been updated to more closely match CRuby. - `RationalNode` now has a `numerator` and `denominator` field instead of a `numeric` field. For the Ruby API we provide a `RationalNode#numeric` method for backwards-compatibility. ## [0.29.0] - 2024-05-10 ### Added - Added `Prism::CallNode#full_message_loc`, which gives the location including the `=` if there is one. - A warning for when `# shareable_constant_value` is not used on its own line. - An error for invalid implicit local variable writes. - Implicit hash patterns in array patterns are disallowed. - We now validate that Unicode escape sequences are not surrogates. ### Changed - All fields named `operator` have been renamed to `binary_operator` for `*OperatorWriteNode` nodes. This is to make it easier to provide C++ support. In the Ruby API, the old fields are aliased to the new fields with a deprecation warning. - Many updated error messages to more closely match CRuby. - We ensure keyword parameters do not end in `!` or `?`. - Fixed some escaping in string literals with control sequences and hex escapes. - Fix a bug with RBS types when used outside the `ruby/prism` codebase. ## [0.28.0] - 2024-05-03 ### Added - Nested hashes will now warn for duplicated keys, as in: `{ foo: 1, **{ foo: 2 } }`. - `Prism::ReturnNode` now has a flag on it to indicate if it is redundant. - `Prism::Location#slice_lines` and `Prism::Node#slice_lines` are now provided to slice the source code of a node including the content before the node on the same line that it starts on and the content after the node on the same line that it ends on. - Symbols with invalid byte sequences now give errors. - You can now pass `"3.3.1"` to the `version:` parameter on all `Prism.*` APIs. - `Prism::Source#lines`, `Prism::Location#source_lines`, `Prism::Node#source_lines`, and `Prism::Node#script_lines` are now provided, which will all return the source code of the source as an array of strings. - `Prism::ASCIISource` is now provided, which is a subclass of `Prism::Source` but specialized to increase performance when the source is entirely ASCII. - Prism now provides errors when parsing Ruby 3.4+ syntax for index expressions with keywords or blocks. - Prism now provides an error when `**nil` is used after other keyword parameters. - Prism now provides errors when safe navigation is used in call target expressions, e.g., `foo&.bar, = 1`. - `Prism::Node#tunnel` is now provided, which returns an array of nodes starting at the current node that contain a given line and column. ### Changed - All translation layers now assume an eval context, which means they will not return errors for invalid jumps like `yield`. - `Prism::Node#inspect` now uses a queue instead of recursion to avoid stack overflows. - Prism now more closely mirrors CRuby interpolation semantics, which means you could potentially have a static literal string that directly interpolates another static literal string. - The shipped RBI sorbet types no longer use generics. - `Prism::ConstantPathNode#child` and `Prism::ConstantTargetNode#child` are now deprecated, replaced by two new fields on these nodes: `name` and `name_loc`. ## [0.27.0] - 2024-04-23 ### Added - Implemented `===` for each of the nodes, which will check if equality but ignore the specific ranges of locations. ### Changed - Fix translation of `ItParametersNode` for parser translation. - Fix translation of `dstr` for ruby_parser translation. - Do not allow omitted hash values whose keys end with `!` or `?`. - Split up `Prism::ParseResult` into `Prism::Result` with subclasses `Prism::ParseResult`, `Prism::LexResult`, `Prism::ParseLexResult`, and `Prism::LexCompat::Result`. - Change reflection classes to have only a single `IntegerField` class and rename `DoubleField` to `FloatField`. - Fall back to default `AR` and `CC` in `Makefile`. - Use GC-able symbols for the syntax tree to avoid adding to the global symbol table. - Fix a bug with karatsuba_multiply that would result in a stack overflow. - Fix parser translation when looking for tokens with `srange_find`. ## [0.26.0] - 2024-04-18 ### Added - Add `Prism::Node::fields`, which returns a list of `Prism::Reflection::Field` objects representing the fields of the node class. This is useful in metaprogramming contexts. - `Prism::Location#chop`, for removing the last byte from a location. - The void statement warning is now implemented. - The unreachable statement warning is now implemented. - A syntax error has been added for block arguments on yields, e.g., `yield(&foo)`. ### Changed - Better fidelity to `parser` when translating heredocs with interpolation. - Fixed `RBI` and `RBS` types for `Prism::parse_*` signatures. - Remove some incorrect warnings about unused local variables. - More closely match CRuby error messages for global variables. - Fix an issue with `parser` translation when line continuations are found in string literals. ## [0.25.0] - 2024-04-05 ### Added - `Prism::Translation::Ripper` is now able to mirror all of the Ripper APIs. - `Prism::Location#leading_comments` and `Prism::Location#trailing_comments` is added. - `Prism::Comment#slice` is added. - Warn for writing literal values in conditional predicates. - Check for `_POSIX_MAPPED_FILES` before using `mmap`. - `Prism::ItParametersNode` is added, to support `-> { it }`. - Parse integer and float literal values onto the tree. - Warn on duplicated hash keys and duplicated when clauses. - Ship much improved `RBI` and `RBS` types. - Support for the `-p`, `-n`, `-a`, and `-l` command line switches. - Warn on integer literals in flip-flops. - Support BSD make. - Add `Prism::WhenNode#then_keyword_loc`. - Support custom allocation functions through the `PRISM_XALLOCATOR` define. - Warn for certain keywrods at the end of the line. - Provide `pm_visit_node`, a C visitor API. - `Prism::parse_stream` is added, which works for any Ruby `IO` object. - Provide flags for regular expression literals for their derived encoding. - Provide flags for whether or not an interpolated string literal is frozen. - Add `Prism::StringNode.mutable?` for when a string is explicitly mutable, to support delineating chilled strings. - Warn for incorrect character literal syntax. - Warn for chained comparison operators. - Warn for `**` interpreted as an argument prefix. - Warn for `&` interpreted as an argument prefix. - `Prism::ShareableConstantNode` added to support ractors. - Warn for frozen string literals found after tokens. - Support `PRISM_BUILD_MINIMAL` to provide only the minimal necessary functionality to reduce the binary size. - Handle CLRF inside heredocs, strings, and regular expressions. - Mark inner strings in interpolated strings as frozen. - Support the `-x` command line switch. - Error messages now much more closely mirror CRuby. - Provide syntax errors for invalid block exits (`break`, `next`, `retry`, and `yield`). - Warn on unused local variables. - Do not syntax error on default parameter values that only write to the parameter. ### Changed - Many improvements to the compatibility with the `whitequark/parser` translation. - Accept newlines before pattern terminators `)` or `]`. - `Prism::Node#start_offset` and `Prism::Node#end_offset` are now much more efficient. - Read files using `fread` instead of `mmap` when we're going to keep around the source through the Ruby API. - Fix `Sexp#line_max` setting in the `seattlerb/ruby_parser` translation layer. - Allow spaces before the encoding comment. ## [0.24.0] - 2024-02-15 ### Added - More support for `Prism::Translation::Ripper` is added. - Support multiple versions for `Prism::Translation::Parser`. - Improved memory usage in the FFI backend. - Very large speed and memory improvements for creating the Ruby AST. ### Changed - Fix location for empty symbol in hash key. - Fix parsing a rescue modifier on the value of an assignment when the LHS is a method call with arguments and no parentheses. ## [0.23.0] - 2024-02-14 ### Added - More support for `Prism::RipperCompat` is added. - A significantly faster offset cache for `Prism::Translation::Parser` is added for files with multibyte characters. - `Prism::Translation::RubyParser` is added. - `Prism::ConstantPathTarget#full_name` is added. - `version: "3.4.0"` is added as an option that is an alias for `version: "latest"`. - Four new APIs are added to `Prism::Location`: - `Prism::Location#start_code_units_offset` - `Prism::Location#end_code_units_offset` - `Prism::Location#start_code_units_column` - `Prism::Location#end_code_units_column` - Invalid multibyte characters are now validated within strings, lists, and heredocs. ### Changed - When defining `def !@`, the `name_loc` was previously only pointing to `!`, but now includes the `@`. The `name` is the same. - `Prism::RipperCompat` has been moved to `Prism::Translation::Ripper`. - Many of the error messages that prism produces have been changed to match the error messages that CRuby produces. ## [0.22.0] - 2024-02-07 ### Added - More support for `Prism::RipperCompat` is added. - Support for Ruby 2.7 has been added, and the minimum Ruby requirement has been lowered to 2.7. ### Changed - The error for an invalid source encoding has a new `:argument` level to indicate it raises an argument error. - `BeginNode` nodes that are used when a class, singleton class, module, method definition, or block have an inline `rescue`/`ensure`/`else` now have their opening locations set to the beginning of the respective keyword. - Improved error messages for invalid characters. - `Prism.parse_file` and similar APIs will raise more appropriate errors when the file does not exist or cannot be mapped. - Correctly handle the `recover` parameter for `Prism::Translation::Parser`. ## [0.21.0] - 2024-02-05 ### Added - Add the `pm_constant_pool_find` API for finding a constant. ### Changed - Fixes for `Prism::Translation::Parser`. - Ensure all errors flow through `parser.diagnostics.process`. - Fix the find pattern node. - Fix block forwarding with `NumberedParametersNode`. - Ensure we can parse strings with invalid bytes for the encoding. - Fix hash pairs in pattern matching. - Properly reject operator writes on operator calls, e.g., `a.+ -= b`. - Fix multi-byte escapes. - Handle missing body in `begin` within the receiver of a method call. ## [0.20.0] - 2024-02-01 ### Added - String literal hash keys are now marked as frozen as static literal. - `IndexTargetNode` now always has the `ATTRIBUTE_WRITE` flag. - `Call*Node` nodes now have an `IGNORE_VISIBILITY` flag. - We now support the `it` default parameter. - Errors and warnings now have levels associated with them. - Symbols now have correct encoding flags. - We have now merged `parser-prism` in, which provides translation to the `whitequark/parser` AST. - We now emit errors for invalid method definition receivers. ### Changed - We now emit errors on invalid pinned local variables. - When passed scopes, it is now assumed that the innermost scope is the current binding. - We now provide better error recovery for non terminated heredocs. - Fix for `RationalNode#value` for non-decimal integers. - Unary symbols `!@` and `~@` now unescape to `!` and `~`, respectively. - `frozen_string_literal: false` now works properly. ### Removed - We've removed the `locals_body_index` field. - We've removed the `verbose` option on the various parse APIs. Warnings are now always emitted with their associated level so that consumers can decide how to handle them. ## [0.19.0] - 2023-12-14 ### Added - `ArrayNode` now has a `contains_splat?` flag if it has a splatted element in it. - All of the remaining encodings have been implemented. - Allow forwarding `&` in a method that has a `...` parameter. - Many statements that are found in non-statement positions are being properly rejected now. - Void values are now properly checked. - Referencing a parameter in its own default value is now properly rejected. - `DATA`/`__END__` is now parsed as its own field on parse result (`data_loc`) as opposed to as a comment. - Blank `*` now properly forwards into arrays. - `ImplicitRestNode` is introduced to represent the implicit rest of a destructure. - We now support negative start lines. - `StringNode#heredoc?`, `InterpolatedStringNode#heredoc?`, `XStringNode#heredoc?`, and `InterpolatedXStringNode#heredoc?` are introduced. - `NumberedParametersNode` is introduced to represent the implicit set of parameters when numbered parameters are used. - `Prism::parse_success?` and `Prism::parse_failure?` are introduced to bypass reifying the AST. - We now emit a warning for constant assignments in method definitions. - We now provide flags on strings and xstrings to indicate the correct encoding. - The hash pattern `rest` field now more accurately parses `**` and `**nil`. - The equality operators are now properly parsed as non-associative. ### Changed - **BREAKING**: Many fields have changed positions within their nodes. This impacts the C API and the Ruby API if you are manually creating nodes through the initializer. - **BREAKING**: Almost all of the error messages have been updated to begin with lowercase characters to match ruby/spec. - Unterminated strings with only plain content are now always `StringNode` as opposed to `InterpolatedStringNode` - **BREAKING**: Call node has been split up when it is in the target position into `CallTargetNode` and `IndexTargetNode`. ## [0.18.0] - 2023-11-21 ### Added - The `ParametersNode#signature` method is added, which returns the same thing as `Method#parameters`. - Visitor functionality has been added to the JavaScript API. - The `Node#to_dot` API has been added to convert syntax trees to Graphviz digraphs. - `IfNode` and `UnlessNode` now have a `then_keyword_loc` field. - Many more encodings are now supported. - Some new `Location` APIs have been added for dealing with characters instead of bytes, which are: `start_character_offset`, `end_character_offset`, `start_character_column`, and `end_character_column`. - A warning has been added for when `END {}` is used within a method. - `ConstantPathNode#full_name{,_parts}` will now raise an error if the receiver of the constant path is not itself a constant. - The `in` keyword and the `=>` operator now respect non-associativity. - The `..` and `...` operators now properly respect non-associativity. ### Changed - Previously `...` in blocks was accepted, but it is now properly rejected. - **BREAKING**: `librubyparser.*` has been renamed to `libprism.*` in the C API. - We now properly reject floats with exponent and rational suffixes. - We now properly reject void value expressions. - **BREAKING**: The `--disable-static` option has been removed from the C extension. - The rescue modifier keyword is now properly parsed in terms of precedence. - We now properly reject defining a numbered parameter method. - **BREAKING**: `MatchWriteNode` now has a list of `targets`, which are local variable target nodes. This is instead of `locals` which was a constant list. This is to support writing to local variables outside the current scope. It has the added benefit of providing location information for the local variable targets. - **BREAKING**: `CaseNode` has been split into `CaseNode` and `CaseMatchNode`, the latter is used for `case ... in` expressions. - **BREAKING**: `StringConcatNode` has been removed in favor of using `InterpolatedStringNode` as a list. ## [0.17.1] - 2023-11-03 ### Changed - Do not use constant nesting in RBI files. ## [0.17.0] - 2023-11-03 ### Added - We now properly support forwarding arguments into arrays, like `def foo(*) = [*]`. - We now have much better documentation for the C and Ruby APIs. - We now properly provide an error message when attempting to assign to numbered parameters from within regular expression named capture groups, as in `/(?<_1>)/ =~ ""`. ### Changed - **BREAKING**: `KeywordParameterNode` is split into `OptionalKeywordParameterNode` and `RequiredKeywordParameterNode`. `RequiredKeywordParameterNode` has no `value` field. - **BREAKING**: Most of the `Prism::` APIs now accept a bunch of keyword options. The options we now support are: `filepath`, `encoding`, `line`, `frozen_string_literal`, `verbose`, and `scopes`. See [the pull request](https://github.com/ruby/prism/pull/1763) for more details. - **BREAKING**: Comments are now split into three different classes instead of a single class, and the `type` field has been removed. They are: `InlineComment`, `EmbDocComment`, and `DATAComment`. ## [0.16.0] - 2023-10-30 ### Added - `InterpolatedMatchLastLineNode#options` and `MatchLastLineNode#options` are added, which are the same methods as are exposed on `InterpolatedRegularExpressionNode` and `RegularExpressionNode`. - The project can now be compiled with `wasi-sdk` to expose a WebAssembly interface. - `ArgumentsNode#keyword_splat?` is added to indicate if the arguments node has a keyword splat. - The C API `pm_prettyprint` has a much improved output which lines up closely with `Node#inspect`. - Prism now ships with `RBS` and `RBI` type signatures (in the `/sig` and `/rbi` directories, respectively). - `Prism::parse_comments` and `Prism::parse_file_comments` APIs are added to extract only the comments from the source code. ### Changed - **BREAKING**: `Multi{Target,Write}Node#targets` is split up now into `lefts`, `rest`, and `rights`. This is to avoid having to scan the list in the case that there are splat nodes. - Some bugs are fixed on `Multi{Target,Write}Node` accidentally creating additional nesting when not necessary. - **BREAKING**: `RequiredDestructuredParameterNode` has been removed in favor of using `MultiTargetNode` in those places. - **BREAKING**: `HashPatternNode#assocs` has been renamed to `HashPatternNode#elements`. `HashPatternNode#kwrest` has been renamed to `HashPatternNode#rest`. ## [0.15.1] - 2023-10-18 ### Changed - Fix compilation warning on assigning to bitfield. ## [0.15.0] - 2023-10-18 ### Added - `BackReferenceReadNode#name` is now provided. - `Index{Operator,And,Or}WriteNode` are introduced, split out from `Call{Operator,And,Or}WriteNode` when the method is `[]`. ### Changed - Ensure `PM_NODE_FLAG_COMMON_MASK` into a constant expression to fix compile errors. - `super(&arg)` is now fixed. - Ensure the last encoding flag on regular expressions wins. - Fix the common whitespace calculation when embedded expressions begin on a line. - Capture groups in regular expressions now scan the unescaped version to get the correct local variables. - `*` and `&` are added to the local table when `...` is found in the parameters of a method definition. ## [0.14.0] - 2023-10-13 ### Added - Syntax errors are added for invalid lambda local semicolon placement. - Lambda locals are now checked for duplicate names. - Destructured parameters are now checked for duplicate names. - `Constant{Read,Path,PathTarget}Node#full_name` and `Constant{Read,Path,PathTarget}Node#full_name_parts` are added to walk constant paths for you to find the full name of the constant. - Syntax errors are added when assigning to a numbered parameter. - `Node::type` is added, which matches the `Node#type` API. - Magic comments are now parsed as part of the parsing process and a new field is added in the form of `ParseResult#magic_comments` to access them. ### Changed - **BREAKING**: `Call*Node#name` methods now return symbols instead of strings. - **BREAKING**: For loops now have their index value considered as part of the body, so depths of local variable assignments will be increased by 1. - Tilde heredocs now split up their lines into multiple string nodes to make them easier to dedent. ## [0.13.0] - 2023-09-29 ### Added - `BEGIN {}` blocks are only allowed at the top-level, and will now provide a syntax error if they are not. - Numbered parameters are not allowed in block parameters, and will now provide a syntax error if they are. - Many more Ruby modules and classes are now documented. Also, many have been moved into their own files and autoloaded so that initial boot time of the gem is much faster. - `PM_TOKEN_METHOD_NAME` is introduced, used to indicate an identifier that if definitely a method name because it has an `!` or `?` at the end. - In the C API, arrays, assocs, and hashes now can have the `PM_NODE_FLAG_STATIC_LITERAL` flag attached if they can be compiled statically. This is used in CRuby, for example, to determine if a `duphash`/`duparray` instruction can be used as opposed to a `newhash`/`newarray`. - `Node#type` is introduced, which returns a symbol representing the type of the node. This is useful for case comparisons when you have to compare against multiple types. ### Changed - **BREAKING**: Everything has been renamed to `prism` instead of `yarp`. The `yp_`/`YP_` prefix in the C API has been changed to `pm_`/`PM_`. For the most part, everything should be find/replaceable. - **BREAKING**: `BlockArgumentNode` nodes now go into the `block` field on `CallNode` nodes, in addition to the `BlockNode` nodes that used to be there. Hopefully this makes it more consistent to compile/deal with in general, but it does mean it can be a surprising breaking change. - Escaped whitespace in `%w` lists is now properly unescaped. - `Node#pretty_print` now respects pretty print indentation. - `Dispatcher` was previously firing `_leave` events in the incorrect order. This has now been fixed. - **BREAKING**: `Visitor` has now been split into `Visitor` and `Compiler`. The visitor visits nodes but doesn't return anything from the visit methods. It is suitable for taking action based on the tree, but not manipulating the tree itself. The `Compiler` visits nodes and returns the computed value up the tree. It is suitable for compiling the tree into another format. As such, `MutationVisitor` has been renamed to `MutationCompiler`. ## [0.12.0] - 2023-09-15 ### Added - `RegularExpressionNode#options` and `InterpolatedRegularExpressionNode#options` are now provided. These return integers that match up to the `Regexp#options` API. - Greatly improved `Node#inspect` and `Node#pretty_print` APIs. - `MatchLastLineNode` and `InterpolatedMatchLastLineNode` are introduced to represent using a regular expression as the predicate of an `if` or `unless` statement. - `IntegerNode` now has a base flag on it. - Heredocs that were previously `InterpolatedStringNode` and `InterpolatedXStringNode` nodes without any actual interpolation are now `StringNode` and `XStringNode`, respectively. - `StringNode` now has a `frozen?` flag on it, which respects the `frozen_string_literal` magic comment. - Numbered parameters are now supported, and are properly represented using `LocalVariableReadNode` nodes. - `ImplicitNode` is introduced, which wraps implicit calls, local variable reads, or constant reads in omitted hash values. - `YARP::Dispatcher` is introduced, which provides a way for multiple objects to listen for certain events on the AST while it is being walked. This is effectively a way to implement a more efficient visitor pattern when you have many different uses for the AST. ### Changed - **BREAKING**: Flags fields are now marked as private, to ensure we can change their implementation under the hood. Actually querying should be through the accessor methods. - **BREAKING**: `AliasNode` is now split into `AliasMethodNode` and `AliasGlobalVariableNode`. - Method definitions on local variables is now correctly handled. - Unary minus precedence has been fixed. - Concatenating character literals with string literals is now fixed. - Many more invalid syntaxes are now properly rejected. - **BREAKING**: Comments now no longer include their trailing newline. ## [0.11.0] - 2023-09-08 ### Added - `Node#inspect` is much improved. - `YARP::Pattern` is introduced, which can construct procs to match against nodes. - `BlockLocalVariableNode` is introduced to take the place of the locations array on `BlockParametersNode`. - `ParseResult#attach_comments!` is now provided to attach comments to locations in the tree. - `MultiTargetNode` is introduced as the target of multi writes and for loops. - `Node#comment_targets` is introduced to return the list of objects that can have attached comments. ### Changed - **BREAKING**: `GlobalVariable*Node#name` now returns a symbol. - **BREAKING**: `Constant*Node#name` now returns a symbol. - **BREAKING**: `BlockParameterNode`, `KeywordParameterNode`, `KeywordRestParameterNode`, `RestParameterNode`, `DefNode` all have their `name` methods returning symbols now. - **BREAKING**: `ClassNode#name` and `ModuleNode#name` now return symbols. - **BREAKING**: `Location#end_column` is now exclusive instead of inclusive. - `Location#slice` now returns a properly encoded string. - `CallNode#operator_loc` is now `CallNode#call_operator_loc`. - `CallOperatorAndWriteNode` is renamed to `CallAndWriteNode` and its structure has changed. - `CallOperatorOrWriteNode` is renamed to `CallOrWriteNode` and its structure has changed. ## [0.10.0] - 2023-09-01 ### Added - `InstanceVariable*Node` and `ClassVariable*Node` objects now have their `name` returning a Symbol. This is because they are now part of the constant pool. - `NumberedReferenceReadNode` now has a `number` field, which returns an Integer. ### Changed - **BREAKING**: Various `operator_id` and `constant_id` fields have been renamed to `operator` and `name`, respectively. See [09d0a144](https://github.com/ruby/yarp/commit/09d0a144dfd519c5b5f96f0b6ee95d256e2cb1a6) for details. - `%w`, `%W`, `%i`, `%I`, `%q`, and `%Q` literals can now span around the contents of a heredoc. - **BREAKING**: All of the public C APIs that accept the source string now accept `const uint8_t *` as opposed to `const char *`. ## [0.9.0] - 2023-08-25 ### Added - Regular expressions can now be bound by `\n`, `\r`, and a combination of `\r\n`. - Strings delimited by `%`, `%q`, and `%Q` can now be bound by `\n`, `\r`, and a combination of `\r\n`. - `IntegerNode#value` now returns the value of the integer as a Ruby `Integer`. - `FloatNode#value` now returns the value of the float as a Ruby `Float`. - `RationalNode#value` now returns the value of the rational as a Ruby `Rational`. - `ImaginaryNode#value` now returns the value of the imaginary as a Ruby `Complex`. - `ClassNode#name` is now a string that returns the name of just the class, without the namespace. - `ModuleNode#name` is now a string that returns the name of just the module, without the namespace. - Regular expressions and strings found after a heredoc declaration but before the heredoc body are now parsed correctly. - The serialization API now supports shared strings, which should help reduce the size of the serialized AST. - `*Node#copy` is introduced, which returns a copy of the node with the given overrides. - `Location#copy` is introduced, which returns a copy of the location with the given overrides. - `DesugarVisitor` is introduced, which provides a simpler AST for use in tools that want to process fewer node types. - `{ClassVariable,Constant,ConstantPath,GlobalVariable,InstanceVariable,LocalVariable}TargetNode` are introduced. These nodes represent the target of writes in locations where a value cannot be provided, like a multi write or a rescue reference. - `UntilNode#closing_loc` and `WhileNode#closing_loc` are now provided. - `Location#join` is now provided, which joins two locations together. - `YARP::parse_lex` and `YARP::parse_lex_file` are introduced to parse and lex in one result. ### Changed - When there is a magic encoding comment, the encoding of the first token's source string is now properly reencoded. - Constants followed by unary `&` are now properly parsed as a call with a passed block argument. - Escaping multi-byte characters in a string literal will now properly escape the entire character. - `YARP.lex_compat` now has more accurate behavior when a byte-order mark is present in the file. - **BREAKING**: `AndWriteNode`, `OrWriteNode`, and `OperatorWriteNode` have been split back up into their `0.7.0` versions. - We now properly support spaces between the `encoding` and `=`/`:` in a magic encoding comment. - We now properly parse `-> foo: bar do end`. ## [0.8.0] - 2023-08-18 ### Added - Some performance improvements when converting from the C AST to the Ruby AST. - Two rust crates have been added: `yarp-sys` and `yarp`. They are as yet unpublished. ### Changed - Escaped newlines in strings and heredocs are now handled more correctly. - Dedenting heredocs that result in empty string nodes will now drop those string nodes from the list. - Beginless and endless ranges in conditional expressions now properly form a flip flop node. - `%` at the end of files no longer crashes. - Location information has been corrected for `if/elsif` chains that have no `else`. - `__END__` at the very end of the file was previously parsed as an identifier, but is now correct. - **BREAKING**: Nodes that reference `&&=`, `||=`, and other writing operators have been consolidated. Previously, they were separate individual nodes. Now they are a tree with the target being the left-hand side and the value being the right-hand side with a joining `AndWriteNode`, `OrWriteNode`, or `OperatorWriteNode` in the middle. This impacts all of the nodes that match this pattern: `{ClassVariable,Constant,ConstantPath,GlobalVariable,InstanceVariable,LocalVariable}Operator{And,Or,}WriteNode`. - **BREAKING**: `BlockParametersNode`, `ClassNode`, `DefNode`, `LambdaNode`, `ModuleNode`, `ParenthesesNode`, and `SingletonClassNode` have had their `statements` field renamed to `body` to give a hint that it might not be a `StatementsNode` (it could also be a `BeginNode`). ## [0.7.0] - 2023-08-14 ### Added - We now have an explicit `FlipFlopNode`. It has the same flags as `RangeNode`. - We now have a syntax error when implicit and explicit blocks are passed to a method call. - `Node#slice` is now implemented, for retrieving the slice of the source code corresponding to a node. - We now support the `utf8-mac` encoding. - Predicate methods have been added for nodes that have flags. For example `CallNode#safe_navigation?` and `RangeNode#exclude_end?`. - The gem now functions on JRuby and TruffleRuby, thanks to a new FFI backend. - Comments are now part of the serialization API. ### Changed - Autotools has been removed from the build system, so when the gem is installed it will no longer need to go through a configure step. - The AST for `foo = *bar` has changed to have an explicit array on the right hand side, rather than a splat node. This is more consistent with how other parsers handle this. - **BREAKING**: `RangeNodeFlags` has been renamed to `RangeFlags`. - Unary minus on number literals is now parsed as part of the literal, rather than a call to a unary operator. This is more consistent with how other parsers handle this. ## [0.6.0] - 2023-08-09 ### Added - 🎉 Initial release! 🎉 [unreleased]: https://github.com/ruby/prism/compare/v1.5.1...HEAD [1.5.1]: https://github.com/ruby/prism/compare/v1.5.0...v1.5.1 [1.5.0]: https://github.com/ruby/prism/compare/v1.4.0...v1.5.0 [1.4.0]: https://github.com/ruby/prism/compare/v1.3.0...v1.4.0 [1.3.0]: https://github.com/ruby/prism/compare/v1.2.0...v1.3.0 [1.2.0]: https://github.com/ruby/prism/compare/v1.1.0...v1.2.0 [1.1.0]: https://github.com/ruby/prism/compare/v1.0.0...v1.1.0 [1.0.0]: https://github.com/ruby/prism/compare/v0.30.0...v1.0.0 [0.30.0]: https://github.com/ruby/prism/compare/v0.29.0...v0.30.0 [0.29.0]: https://github.com/ruby/prism/compare/v0.28.0...v0.29.0 [0.28.0]: https://github.com/ruby/prism/compare/v0.27.0...v0.28.0 [0.27.0]: https://github.com/ruby/prism/compare/v0.26.0...v0.27.0 [0.26.0]: https://github.com/ruby/prism/compare/v0.25.0...v0.26.0 [0.25.0]: https://github.com/ruby/prism/compare/v0.24.0...v0.25.0 [0.24.0]: https://github.com/ruby/prism/compare/v0.23.0...v0.24.0 [0.23.0]: https://github.com/ruby/prism/compare/v0.22.0...v0.23.0 [0.22.0]: https://github.com/ruby/prism/compare/v0.21.0...v0.22.0 [0.21.0]: https://github.com/ruby/prism/compare/v0.20.0...v0.21.0 [0.20.0]: https://github.com/ruby/prism/compare/v0.19.0...v0.20.0 [0.19.0]: https://github.com/ruby/prism/compare/v0.18.0...v0.19.0 [0.18.0]: https://github.com/ruby/prism/compare/v0.17.1...v0.18.0 [0.17.1]: https://github.com/ruby/prism/compare/v0.17.0...v0.17.1 [0.17.0]: https://github.com/ruby/prism/compare/v0.16.0...v0.17.0 [0.16.0]: https://github.com/ruby/prism/compare/v0.15.1...v0.16.0 [0.15.1]: https://github.com/ruby/prism/compare/v0.15.0...v0.15.1 [0.15.0]: https://github.com/ruby/prism/compare/v0.14.0...v0.15.0 [0.14.0]: https://github.com/ruby/prism/compare/v0.13.0...v0.14.0 [0.13.0]: https://github.com/ruby/prism/compare/v0.12.0...v0.13.0 [0.12.0]: https://github.com/ruby/prism/compare/v0.11.0...v0.12.0 [0.11.0]: https://github.com/ruby/prism/compare/v0.10.0...v0.11.0 [0.10.0]: https://github.com/ruby/prism/compare/v0.9.0...v0.10.0 [0.9.0]: https://github.com/ruby/prism/compare/v0.8.0...v0.9.0 [0.8.0]: https://github.com/ruby/prism/compare/v0.7.0...v0.8.0 [0.7.0]: https://github.com/ruby/prism/compare/v0.6.0...v0.7.0 [0.6.0]: https://github.com/ruby/prism/compare/d60531...v0.6.0 prism-1.5.1/CODE_OF_CONDUCT.md000066400000000000000000000064351506127434000154610ustar00rootroot00000000000000# Contributor Covenant Code of Conduct ## Our Pledge In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation. ## Our Standards Examples of behavior that contributes to creating a positive environment include: - Using welcoming and inclusive language - Being respectful of differing viewpoints and experiences - Gracefully accepting constructive criticism - Focusing on what is best for the community - Showing empathy towards other community members Examples of unacceptable behavior by participants include: - The use of sexualized language or imagery and unwelcome sexual attention or advances - Trolling, insulting/derogatory comments, and personal or political attacks - Public or private harassment - Publishing others' private information, such as a physical or electronic address, without explicit permission - Other conduct which could reasonably be considered inappropriate in a professional setting ## Our Responsibilities Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior. Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. ## Scope This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. ## Enforcement Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at opensource@shopify.com. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately. Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership. ## Attribution This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html [homepage]: https://www.contributor-covenant.org For answers to common questions about this code of conduct, see https://www.contributor-covenant.org/faq prism-1.5.1/CONTRIBUTING.md000066400000000000000000000046111506127434000151050ustar00rootroot00000000000000# Contributing Thank you for your interest in contributing to prism! Below are a couple of ways that you can help out. ## Discussions The discussions page on the GitHub repository are open. If you have a question or want to discuss the project, feel free to open a new discussion or comment on an existing one. This is the best place to ask questions about the project. ## Code If you want to contribute code, please first open or contribute to a discussion. A lot of the project is in flux, and we want to make sure that you are contributing to the right place. Once you have a discussion going, you can open a pull request with your changes. We will review your code and get it merged in. ## Tests We could always use more tests! One of the biggest challenges of this project is building up a big test suite. If you want to contribute tests, feel free to open a pull request. These will get merged in as soon as possible. The `test` Rake task will not compile libraries or the C extension, and this is intentional (to make testing against an installed version easier). If you want to test your changes, please make sure you're also running either the task: ``` sh bundle exec rake ``` or explicitly running the `compile` task: ``` sh bundle exec rake compile test # or to just compile the C extension ... bundle exec rake compile:prism test ``` To test the rust bindings (with caveats about setting up your Rust environment properly first): ``` sh bundle exec rake compile test:rust ``` ## Documentation We could always use more documentation! If you want to contribute documentation, feel free to open a pull request. These will get merged in as soon as possible. Documenting functions or methods is always useful, but we also need more guides and tutorials. If you have an idea for a guide or tutorial, feel free to open an issue and we can discuss it. ## Developing To get `clangd` support in the editor for development, generate the compilation database. This command will create an ignored `compile_commands.json` file at the project root, which is used by clangd to provide functionality. You will need `bear` which can be installed on macOS with `brew install bear`. ```sh bundle exec rake bear ``` ## Debugging Some useful rake tasks: - `test:valgrind` runs the test suite under valgrind to look for illegal memory access or memory leaks - `test:gdb` and `test:lldb` run the test suite under those debuggers prism-1.5.1/Doxyfile000066400000000000000000000020271506127434000143610ustar00rootroot00000000000000# Doxyfile 1.9.5 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project. # # All text after a double hash (##) is considered a comment and is placed in # front of the TAG it is preceding. # # All text after a single hash (#) is considered a comment and will be ignored. # The format is: # TAG = value [value, ...] # For lists, items can also be appended using: # TAG += value [value, ...] # Values that contain spaces should be placed between quotes (\" \"). # # Note: # # Use doxygen to compare the used configuration file with the template # configuration file: # doxygen -x [configFile] PROJECT_NAME = "Prism Ruby parser" OUTPUT_DIRECTORY = doc JAVADOC_AUTOBRIEF = YES OPTIMIZE_OUTPUT_FOR_C = YES INPUT = src src/util include include/prism include/prism/util HTML_OUTPUT = c SORT_MEMBER_DOCS = NO GENERATE_LATEX = NO WARN_NO_PARAMDOC = YES WARN_AS_ERROR = FAIL_ON_WARNINGS DOT_GRAPH_MAX_NODES = 200 prism-1.5.1/Gemfile000066400000000000000000000004571506127434000141530ustar00rootroot00000000000000# frozen_string_literal: true source "https://rubygems.org" gemspec gem "benchmark-ips" gem "rake" gem "rake-compiler" gem "test-unit" platforms :mri, :mswin, :mingw, :x64_mingw do gem "ffi" gem "parser" gem "ruby_memcheck" gem "ruby_parser" gem "rdoc" end gem "onigmo", platforms: :ruby prism-1.5.1/Gemfile.lock000066400000000000000000000016421506127434000150770ustar00rootroot00000000000000PATH remote: . specs: prism (1.5.1) GEM remote: https://rubygems.org/ specs: ast (2.4.3) benchmark-ips (2.14.0) date (3.4.1) erb (5.0.2) ffi (1.17.2) mini_portile2 (2.8.9) nokogiri (1.18.9) mini_portile2 (~> 2.8.2) racc (~> 1.4) onigmo (0.1.0) parser (3.3.9.0) ast (~> 2.4.1) racc power_assert (2.0.5) psych (5.2.6) date stringio racc (1.8.1) rake (13.3.0) rake-compiler (1.3.0) rake rdoc (6.14.2) erb psych (>= 4.0.0) ruby_memcheck (3.0.1) nokogiri ruby_parser (3.21.1) racc (~> 1.5) sexp_processor (~> 4.16) sexp_processor (4.17.3) stringio (3.1.7) test-unit (3.7.0) power_assert PLATFORMS ruby DEPENDENCIES benchmark-ips ffi onigmo parser prism! rake rake-compiler rdoc ruby_memcheck ruby_parser test-unit BUNDLED WITH 2.5.16 prism-1.5.1/LICENSE.md000066400000000000000000000020451506127434000142570ustar00rootroot00000000000000Copyright 2022-present, Shopify Inc. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. prism-1.5.1/Makefile000066400000000000000000000105031506127434000143110ustar00rootroot00000000000000 # V=0 quiet, V=1 verbose. other values don't work. V = 0 V0 = $(V:0=) Q1 = $(V:1=) Q = $(Q1:0=@) ECHO1 = $(V:1=@ :) ECHO = $(ECHO1:0=@ echo) FUZZ_OUTPUT_DIR = $(CURDIR)/fuzz/output SOEXT ?= $(shell ruby -e 'puts RbConfig::CONFIG["SOEXT"]') CPPFLAGS := -Iinclude $(CPPFLAGS) CFLAGS := -g -O2 -std=c99 -Wall -Werror -Wextra -Wpedantic -Wundef -Wconversion -Wno-missing-braces -fPIC -fvisibility=hidden -Wimplicit-fallthrough $(CFLAGS) JAVA_WASM_CFLAGS := -g -Oz -std=c99 -Wall -Werror -Wextra -Wpedantic -Wundef -Wconversion -Wno-missing-braces -fPIC -fvisibility=hidden -Wimplicit-fallthrough $(JAVA_WASM_CFLAGS) CC ?= cc AR ?= ar WASI_SDK_PATH := /opt/wasi-sdk MAKEDIRS ?= mkdir -p RMALL ?= rm -f -r HEADERS := $(wildcard include/*.h include/*/*.h include/*/*/*.h') SOURCES := $(wildcard src/*.c src/*/*.c) SHARED_OBJECTS := $(subst src/,build/shared/,$(SOURCES:.c=.o)) STATIC_OBJECTS := $(subst src/,build/static/,$(SOURCES:.c=.o)) all: shared static shared: build/libprism.$(SOEXT) static: build/libprism.a wasm: javascript/src/prism.wasm java-wasm: java-wasm/src/test/resources/prism.wasm build/libprism.$(SOEXT): $(SHARED_OBJECTS) $(ECHO) "linking $@ with $(CC)" $(Q) $(CC) $(DEBUG_FLAGS) $(CFLAGS) -shared -o $@ $(SHARED_OBJECTS) build/libprism.a: $(STATIC_OBJECTS) $(ECHO) "building $@ with $(AR)" $(Q) $(AR) $(ARFLAGS) $@ $(STATIC_OBJECTS) $(Q1:0=>/dev/null) javascript/src/prism.wasm: Makefile $(SOURCES) $(HEADERS) $(ECHO) "building $@" $(Q) $(WASI_SDK_PATH)/bin/clang --sysroot=$(WASI_SDK_PATH)/share/wasi-sysroot/ $(DEBUG_FLAGS) -DPRISM_EXPORT_SYMBOLS -D_WASI_EMULATED_MMAN -lwasi-emulated-mman $(CPPFLAGS) $(CFLAGS) -Wl,--export-all -Wl,--no-entry -mexec-model=reactor -o $@ $(SOURCES) java-wasm/src/test/resources/prism.wasm: Makefile $(SOURCES) $(HEADERS) $(ECHO) "building $@" $(Q) $(WASI_SDK_PATH)/bin/clang $(DEBUG_FLAGS) -DPRISM_EXCLUDE_PRETTYPRINT -DPRISM_EXPORT_SYMBOLS -D_WASI_EMULATED_MMAN -lwasi-emulated-mman $(CPPFLAGS) $(JAVA_WASM_CFLAGS) -Wl,--export-all -Wl,--no-entry -mexec-model=reactor -lc++ -lc++abi -o $@ $(SOURCES) build/shared/%.o: src/%.c Makefile $(HEADERS) $(ECHO) "compiling $@" $(Q) $(MAKEDIRS) $(@D) $(Q) $(CC) $(DEBUG_FLAGS) -DPRISM_EXPORT_SYMBOLS $(CPPFLAGS) $(CFLAGS) -c -o $@ $< build/static/%.o: src/%.c Makefile $(HEADERS) $(ECHO) "compiling $@" $(Q) $(MAKEDIRS) $(@D) $(Q) $(CC) $(DEBUG_FLAGS) $(CPPFLAGS) $(CFLAGS) -c -o $@ $< build/fuzz.%: $(SOURCES) fuzz/%.c fuzz/fuzz.c $(ECHO) "building $* fuzzer" $(Q) $(MAKEDIRS) $(@D) $(ECHO) "building main fuzz binary" $(Q) AFL_HARDEN=1 afl-clang-lto $(DEBUG_FLAGS) $(CPPFLAGS) $(CFLAGS) $(FUZZ_FLAGS) -O0 -fsanitize-ignorelist=fuzz/asan.ignore -fsanitize=fuzzer,address -ggdb3 -std=c99 -Iinclude -o $@ $^ $(ECHO) "building cmplog binary" $(Q) AFL_HARDEN=1 AFL_LLVM_CMPLOG=1 afl-clang-lto $(DEBUG_FLAGS) $(CPPFLAGS) $(CFLAGS) $(FUZZ_FLAGS) -O0 -fsanitize-ignorelist=fuzz/asan.ignore -fsanitize=fuzzer,address -ggdb3 -std=c99 -Iinclude -o $@.cmplog $^ build/fuzz.heisenbug.%: $(SOURCES) fuzz/%.c fuzz/heisenbug.c $(Q) AFL_HARDEN=1 afl-clang-lto $(DEBUG_FLAGS) $(CPPFLAGS) $(CFLAGS) $(FUZZ_FLAGS) -O0 -fsanitize-ignorelist=fuzz/asan.ignore -fsanitize=fuzzer,address -ggdb3 -std=c99 -Iinclude -o $@ $^ fuzz-debug: $(ECHO) "entering debug shell" $(Q) docker run -it --rm -e HISTFILE=/prism/fuzz/output/.bash_history -v $(CURDIR):/prism -v $(FUZZ_OUTPUT_DIR):/fuzz_output prism/fuzz fuzz-docker-build: fuzz/docker/Dockerfile $(ECHO) "building docker image" $(Q) docker build -t prism/fuzz fuzz/docker/ fuzz-run-%: FORCE fuzz-docker-build $(ECHO) "generating templates" $(Q) bundle exec rake templates $(ECHO) "running $* fuzzer" $(Q) docker run --rm -v $(CURDIR):/prism prism/fuzz /bin/bash -c "FUZZ_FLAGS=\"$(FUZZ_FLAGS)\" make build/fuzz.$*" $(ECHO) "starting AFL++ run" $(Q) $(MAKEDIRS) $(FUZZ_OUTPUT_DIR)/$* $(Q) docker run -it --rm -v $(CURDIR):/prism -v $(FUZZ_OUTPUT_DIR):/fuzz_output prism/fuzz /bin/bash -c "./fuzz/$*.sh /fuzz_output/$*" FORCE: fuzz-clean: $(Q) $(RMALL) fuzz/output clean: $(Q) $(RMALL) build .PHONY: clean fuzz-clean all-no-debug: DEBUG_FLAGS := -DNDEBUG=1 all-no-debug: OPTFLAGS := -O3 all-no-debug: all minimal: CFLAGS := $(CFLAGS) -DPRISM_BUILD_MINIMAL minimal: all run: Makefile $(STATIC_OBJECTS) $(HEADERS) test.c $(ECHO) "compiling test.c" $(Q) $(CC) $(CPPFLAGS) $(CFLAGS) $(STATIC_OBJECTS) test.c $(ECHO) "running test.c" $(Q) ./a.out prism-1.5.1/README.md000066400000000000000000000142171506127434000141360ustar00rootroot00000000000000

Prism Ruby parser

Prism Ruby parser
This is a parser for the Ruby programming language. It is designed to be portable, error tolerant, and maintainable. It is written in C99 and has no dependencies. ## Overview The repository contains the infrastructure for both a shared library (libprism) and a native CRuby extension. The shared library has no bindings to CRuby itself, and so can be used by other projects. The native CRuby extension links against `ruby.h`, and so is suitable in the context of CRuby. ``` . ├── Makefile configuration to compile the shared library and native tests ├── Rakefile configuration to compile the native extension and run the Ruby tests ├── bin │   ├── lex runs the lexer on a file or string, prints the tokens, and compares to ripper │   ├── parse runs the parse on a file or string and prints the AST │   └── prism a CLI for development and debugging ├── config.yml specification for tokens and nodes in the tree ├── doc documentation website ├── docs markdown documentation about the project ├── ext │   └── prism │   ├── extconf.rb configuration to generate the Makefile for the native extension │   └── extension.c the native extension that interacts with libprism ├── fuzz files related to fuzz testing ├── gemfiles gemfiles used by different Ruby versions in CI ├── include │   ├── prism header files for the shared library │   └── prism.h main header file for the shared library ├── java Java bindings for the shared library ├── java-wasm Java WASM bindings for the shared library ├── javascript JavaScript WASM bindings for the shared library ├── lib │   ├── prism Ruby library files │   └── prism.rb main entrypoint for the Ruby library ├── rakelib various Rake tasks for the project ├── rbi RBI type signatures for the Ruby library ├── rust │   ├── ruby-prism Rustified crate for the shared library │   └── ruby-prism-sys FFI binding for Rust ├── sample │ └── prism Sample code that uses the Ruby API for documentation purposes ├── sig RBS type signatures for the Ruby library ├── src │   ├── util various utility files │   └── prism.c main entrypoint for the shared library ├── templates contains ERB templates generated by templates/template.rb │   └── template.rb generates code from the nodes and tokens configured by config.yml └── test └── prism ├── fixtures Ruby code used for testing └── snapshots snapshots of generated syntax trees corresponding to fixtures ``` ## Getting started To compile the shared library, you will need: * C99 compiler * GNU make * Ruby 2.7.0 or later Once you have these dependencies, run: ``` bundle install ``` to fetch the Ruby dependencies. Finally, run: ``` bundle exec rake compile ``` to compile the shared library. It will be built in the `build` directory. To test that everything is working, run: ``` bin/parse -e "1 + 2" ``` to see the syntax tree for the expression `1 + 2`. ## Contributing See the [CONTRIBUTING.md](CONTRIBUTING.md) file for more information. We additionally have documentation about the overall design of the project as well as various subtopics. * [Build system](docs/build_system.md) * [Configuration](docs/configuration.md) * [CRuby compilation](docs/cruby_compilation.md) * [Design](docs/design.md) * [Encoding](docs/encoding.md) * [Fuzzing](docs/fuzzing.md) * [Heredocs](docs/heredocs.md) * [JavaScript](docs/javascript.md) * [Local variable depth](docs/local_variable_depth.md) * [Mapping](docs/mapping.md) * [Parser translation](docs/parser_translation.md) * [Parsing rules](docs/parsing_rules.md) * [Releasing](docs/releasing.md) * [Ripper translation](docs/ripper_translation.md) * [Ruby API](docs/ruby_api.md) * [RubyParser translation](docs/ruby_parser_translation.md) * [Serialization](docs/serialization.md) * [Testing](docs/testing.md) ## Examples Prism has been integrated into the majority of Ruby runtimes, many libraries, and some applications. Below is a list of some of the projects that use Prism: ### Runtimes * [CRuby](https://github.com/ruby/ruby/pull/7964) (via C) * [Garnet](https://github.com/camertron/garnet-js) (via WASM) * [JRuby](https://github.com/jruby/jruby/pull/8103) (via Java) * [Natalie](https://github.com/natalie-lang/natalie/pull/1213) (via C++ and Ruby) * [Opal](https://github.com/opal/opal/pull/2642) (via Ruby and WASM) * [TruffleRuby](https://github.com/oracle/truffleruby/issues/3117) (via Java) ### Libraries * [dispersion](https://github.com/joeldrapper/dispersion) * [minifyrb](https://github.com/koic/minifyrb) * [packwerk](https://github.com/Shopify/packwerk/pull/388) (via parser translator) * [rbi](https://github.com/Shopify/rbi) * [rails](https://github.com/rails/rails) * [parsing renders](https://github.com/rails/rails/pull/49438) * [parsing rdoc](https://github.com/rails/rails/pull/50870) * [parsing tests](https://github.com/rails/rails/pull/51006) * [repl_type_completor](https://github.com/ruby/repl_type_completor) * [rubocop](https://docs.rubocop.org/rubocop/configuration.html#setting-the-parser-engine) (via parser translator) * [ruby-lsp](https://github.com/Shopify/ruby-lsp) * [smart_todo](https://github.com/Shopify/smart_todo/pull/69) * [sorbet-eraser](https://github.com/kddnewton/sorbet-eraser/pull/25) * [synvert](https://github.com/xinminlabs/synvert-core-ruby) * [typeprof](https://github.com/ruby/typeprof) ### Applications * [gem.sh](https://github.com/marcoroth/gem.sh/pull/96) * [Sorbet](https://github.com/sorbet/sorbet) prism-1.5.1/Rakefile000066400000000000000000000043511506127434000143220ustar00rootroot00000000000000# frozen_string_literal: true require "bundler/gem_tasks" require "rake/clean" task default: %i[compile test] require_relative "templates/template" desc "Generate all ERB template based files" task templates: Prism::Template::TEMPLATES make = RUBY_PLATFORM.match?(/openbsd|freebsd/) ? "gmake" : "make" task(make: :templates) { sh(make) } task(make_no_debug: :templates) { sh("#{make} all-no-debug") } task(make_minimal: :templates) { sh("#{make} minimal") } task compile: :make task compile_no_debug: %i[make_no_debug compile] task compile_minimal: %i[make_minimal compile] # decorate the gem build task with prerequisites task build: [:check_manifest, :templates] # the C extension task "compile:prism" => ["templates"] # must be before the ExtensionTask is created if RUBY_ENGINE == "ruby" and !ENV["PRISM_FFI_BACKEND"] require "rake/extensiontask" Rake::ExtensionTask.new(:compile) do |ext| ext.name = "prism" ext.ext_dir = "ext/prism" ext.lib_dir = "lib/prism" ext.gem_spec = Gem::Specification.load("prism.gemspec") end elsif RUBY_ENGINE == "jruby" require "rake/javaextensiontask" # This compiles java to make sure any templating changes produces valid code. Rake::JavaExtensionTask.new(:compile) do |ext| ext.name = "prism" ext.ext_dir = "java" ext.lib_dir = "tmp" ext.source_version = "1.8" ext.target_version = "1.8" ext.gem_spec = Gem::Specification.load("prism.gemspec") end end # So `rake clobber` will delete generated files CLOBBER.concat(Prism::Template::TEMPLATES) CLOBBER.concat(["build"]) CLOBBER << "lib/prism/prism.#{RbConfig::CONFIG["DLEXT"]}" Prism::Template::TEMPLATES.each do |filepath| desc "Generate #{filepath}" file filepath => ["templates/#{filepath}.erb", "templates/template.rb", "config.yml"] do |t| Prism::Template.render(t.name) end end namespace :build do task :dev_version_set do filepath = File.expand_path("prism.gemspec", __dir__) File.write(filepath, File.read(filepath).sub(/spec\.version = ".+?"/, %Q{spec.version = "9999.9.9"})) end task :dev_version_clear do sh "git checkout -- prism.gemspec Gemfile.lock" end desc "Build a development version of the gem" task dev: ["build:dev_version_set", "build", "build:dev_version_clear"] end prism-1.5.1/Steepfile000066400000000000000000000010441506127434000145140ustar00rootroot00000000000000# frozen_string_literal: true target :lib do signature "sig" library "cgi" # in lib/prism/dot_visitor.rb (Prism::DotVisitor) check "lib" # TODO: Type-checking these files is still WIP ignore "lib/prism/desugar_compiler.rb" ignore "lib/prism/lex_compat.rb" ignore "lib/prism/serialize.rb" ignore "lib/prism/ffi.rb" ignore "lib/prism/translation" ignore "lib/prism/polyfill/append_as_bytes.rb" ignore "lib/prism/polyfill/byteindex.rb" ignore "lib/prism/polyfill/scan_byte.rb" ignore "lib/prism/polyfill/unpack1.rb" end prism-1.5.1/bin/000077500000000000000000000000001506127434000134225ustar00rootroot00000000000000prism-1.5.1/bin/lex000077500000000000000000000000431506127434000141350ustar00rootroot00000000000000#!/bin/sh exec bin/prism lex "$@" prism-1.5.1/bin/parse000077500000000000000000000000451506127434000144610ustar00rootroot00000000000000#!/bin/sh exec bin/prism parse "$@" prism-1.5.1/bin/prism000077500000000000000000000316211506127434000145050ustar00rootroot00000000000000#!/usr/bin/env ruby # frozen_string_literal: true $:.unshift(File.expand_path("../lib", __dir__)) require "prism" module Prism class CLI def run(argv) case argv.shift when "benchmark" then benchmark(argv) when "bundle" then bundle(argv) when "console" then console when "dot" then dot(argv) when "encoding" then encoding(argv) when "error" then error(argv) when "lex" then lex(argv) when "locals" then locals(argv) when "parse" then parse(argv) when "parser" then parser(argv) when "ripper" then ripper(argv) when "rubyparser" then rubyparser(argv) when "repl" then repl else puts <<~TXT Usage: bin/prism benchmark [source_file] bin/prism bundle [...] bin/prism console bin/prism dot [source] bin/prism encoding [encoding] bin/prism error [name] [source] bin/prism lex [source] bin/prism locals [source] bin/prism parse [source] bin/prism parser [source] bin/prism ripper [source] bin/prism rubyparser [source] bin/prism repl TXT end end private ############################################################################ # Commands ############################################################################ # bin/prism benchmark [source_file] def benchmark(argv) require "benchmark/ips" require "parser/current" require "ripper" require "ruby_parser" filepath = argv.fetch(0) { File.expand_path("../lib/prism/node.rb", __dir__) } source = File.read(filepath) Benchmark.ips do |x| x.report("Prism") do Prism.parse(source, filepath: filepath) end x.report("Ripper::SexpBuilder") do Ripper.sexp_raw(source, filepath) end x.report("Prism::Translation::Ripper::SexpBuilder") do Prism::Translation::Ripper.sexp_raw(source, filepath) end x.report("Parser::CurrentRuby") do Parser::CurrentRuby.parse(source, filepath) end x.report("Prism::Translation::Parser") do Prism::Translation::Parser.parse(source, filepath) end x.report("RubyParser") do RubyParser.new.parse(source, filepath) end x.report("Prism::Translation::RubyParser") do Prism::Translation::RubyParser.new.parse(source, filepath) end x.compare! end end # bin/prism bundle [...] def bundle(argv) [ ["3.1", ["3.1"]], ["3.2", ["3.2"]], ["3.3", ["3.3"]], ["3.4", ["3.4", "typecheck"]], ["3.5", ["3.5"]], ["jruby", ["jruby"]], ["truffleruby", ["truffleruby"]] ].each do |ruby_version, gemfiles| gemfiles.each do |gemfile| system( { "BUNDLE_GEMFILE" => File.expand_path("../gemfiles/#{gemfile}/Gemfile", __dir__) }, "chruby-exec", ruby_version, "--", "bundle", *argv, exception: true, chdir: File.expand_path("../", __dir__) ) rescue RuntimeError => error warn("\e[31;m#{ruby_version} (#{gemfile}): #{error.message}\e[m") end end end # bin/prism console def console require "irb" IRB.start(__FILE__) end # bin/prism dot [source] def dot(argv) result = parse_source(argv) node = result.value path = if argv.first&.match?(/\A[\w\.]+\z/) argv.first.split(".") else %w[statements body first] end path.each do |field| node = node.public_send(field) end File.write( "out.svg", IO.popen("dot -Tsvg", "w+") do |file| file.write(node.to_dot) file.close_write file.read end ) end # bin/prism encoding [encoding] def encoding(argv) found = Encoding.find(argv.shift) found = Encoding::ASCII_8BIT if found == Encoding::US_ASCII if !found.ascii_compatible? warn("Encoding `#{found.name}' is not ASCII compatible") exit(1) end lookup_table(found) unicode_lists(found) if found == Encoding::UTF_8 || found == Encoding::UTF8_MAC end # bin/prism error [name] [source] def error(argv) name = argv.shift source = nil filepath = File.expand_path("../test/prism/errors/#{name}.txt", __dir__) if argv.empty? raise "Expected #{filepath} to exist" unless File.file?(filepath) source = File.read(filepath, binmode: true, external_encoding: Encoding::UTF_8) source = source.lines.grep_v(/^\s*\^/).join.gsub(/\n*\z/, "") else if File.file?(filepath) counter = 1 begin current = "#{File.dirname(filepath)}/#{File.basename(filepath, ".txt")}_#{counter += 1}.txt" end while File.file?(current) filepath = current end source, _ = read_source(argv) end result = Prism.parse(source) raise "Expected #{source.inspect} to have errors" if result.success? File.write(filepath, result.errors_format) end # bin/prism lex [source] def lex(argv) source, filepath = read_source(argv) ripper_value = begin Prism.lex_ripper(source) rescue ArgumentError, SyntaxError # If Ripper raises a syntax error, we want to continue as if it didn't # return any tokens at all. prism won't raise a syntax error, so it's # nicer to still be able to see the tokens that prism generated. [] end prism_compat = Prism.lex_compat(source, filepath: filepath) prism = Prism.lex(source, filepath: filepath) if prism_compat.failure? puts "Errors lexing:" prism_compat.errors.map do |error| print "- [#{error.location.start_line},#{error.location.start_column}-" print "#{error.location.end_line},#{error.location.end_column}] " puts "\e[1;31m#{error.message}\e[0m" end puts "\n" end pattern = "%-64s %-64s %-64s" puts pattern % ["Ripper lex", "Prism compat lex", "Prism lex"] puts pattern % ["-" * 64, "-" * 64, "-" * 64] prism_compat_value = prism_compat.value prism_value = prism.value [ripper_value.length, prism_compat_value.length, prism_value.length].max.times do |index| parts = [ripper_value[index], prism_compat_value[index], nil] unless prism_value[index].nil? prism_token = prism_value[index][0] location = prism_token.location parts[2] = [[location.start_line, location.start_column], prism_token.type, location.slice] end if parts[0] != parts[1] puts "\033[1;31m#{pattern}\033[0m" % parts.map(&:inspect) elsif ENV["VERBOSE"] puts "\033[38;5;102m#{pattern}\033[0m" % parts.map(&:inspect) end end end # bin/prism locals [source] def locals(argv) source, _ = read_source(argv) puts "CRuby:" p Debug.cruby_locals(source) puts "Prism:" p Debug.prism_locals(source) end # bin/prism parse [source] def parse(argv) result = parse_source(argv) parts = {} parts["Comments"] = result.comments if result.comments.any? parts["Magic comments"] = result.magic_comments if result.magic_comments.any? parts["Warnings"] = result.warnings if result.warnings.any? parts["Errors"] = result.errors if result.errors.any? parts["DATA"] = result.data_loc if result.data_loc if parts.empty? puts result.value.inspect else parts["AST"] = result.value parts.each_with_index do |(key, value), index| puts if index > 0 puts "#{key}:" pp value end end end # bin/prism parser [source] def parser(argv) require "parser/ruby34" source, filepath = read_source(argv) buffer = Parser::Source::Buffer.new(filepath, 1) buffer.source = source puts "Parser:" parser_parse(Parser::Ruby34.new, buffer) puts "Prism:" parser_parse(Prism::Translation::Parser34.new, buffer) end # bin/prism ripper [source] def ripper(argv) require "ripper" source, _ = read_source(argv) ripper = Ripper.sexp_raw(source) prism = Prism::Translation::Ripper.sexp_raw(source) puts "Ripper:" pp ripper puts "Prism:" pp prism puts "Output is #{ripper == prism ? "" : "not "}identical" end # bin/prism rubyparser [source] def rubyparser(argv) require "ruby_parser" source, filepath = read_source(argv) ruby_parser = RubyParser.new.parse(source, filepath) prism = Prism::Translation::RubyParser.parse(source, filepath) puts "RubyParser:" pp ruby_parser puts "Prism:" pp prism end # bin/prism repl def repl loop do print "Prism> " input = gets break if input.nil? result = Prism.parse(input.chomp) statements_node = result.value.statements statements = statements_node.body result.errors.each { |e| p(e) } p(statements.one? ? statements.first : statements) end end ############################################################################ # Helpers ############################################################################ # Parse a Parser::Source::Buffer with a given parser. def parser_parse(parser, buffer) diagnostics = [] parser.diagnostics.consumer = -> (diagnostic) { diagnostics << diagnostic } parser_ast, _, parser_tokens = parser.tokenize(buffer, true) pp diagnostics if diagnostics.any? pp parser_ast pp parser_tokens end # Generate the list of values that will be used in a lookup table for a # given encoding. def lookup_table_values(encoding) (0...256).each_slice(16).map.with_index do |slice, row_index| slice.map do |codepoint| character = codepoint.chr(encoding) values = 0 values |= (1 << 0) if character.match?(/[[:alpha:]]/) values |= (1 << 1) if character.match?(/[[:alnum:]]/) values |= (1 << 2) if character.match?(/[[:upper:]]/) values rescue RangeError 0 end end end # Generate a lookup table for a given encoding. def lookup_table(encoding) encoding_values = lookup_table_values(encoding) if encoding_values == lookup_table_values(Encoding::US_ASCII) puts "static const uint8_t pm_encoding_ascii_table[256] = {" else puts "static const uint8_t pm_encoding_#{encoding.name.downcase}_table[256] = {" end puts "// #{(0...16).map { |value| value.to_s(16).upcase }.join(" ")}" encoding_values.each_with_index do |row, row_index| puts " #{row.join(", ")}, // #{row_index.to_s(16).upcase}x" end puts "};" end # Generate lists of unicode codepoints for a given encoding. def unicode_lists(encoding) encoding = Encoding::UTF_8 range = (0x100..0xD7FF).to_a.concat((0xE000..0x10FFFF).to_a) { alpha: /[[:alpha:]]/, alnum: /[[:alnum:]]/, isupper: /[[:upper:]]/ }.map do |kind, regex| codepoints = range.select { |codepoint| codepoint.chr(encoding).match?(regex) } previous = nil groups = codepoints.slice_before do |codepoint| (!previous.nil? && (codepoint - previous) != 1).tap { previous = codepoint } end matched = groups.flat_map do |group| ["0x#{group.first.to_s(16).upcase}", "0x#{group.last.to_s(16).upcase}"] end puts "\n#define UNICODE_#{kind.upcase}_CODEPOINTS_LENGTH #{matched.length}" puts "unicode_codepoint_t unicode_#{kind}_codepoints[UNICODE_#{kind.upcase}_CODEPOINTS_LENGTH] = {" matched.each_slice(2) { |slice| puts " #{slice.join(", ")}," } puts "};" end end # Parse the source code indicated by the command-line arguments. def parse_source(argv) command_line = +"" command_line << argv.shift[1] while argv.first&.match?(/^-[alnpx]$/) case argv.first when "-e" command_line << argv.shift[1] Prism.parse(argv.shift, command_line: command_line) when nil Prism.parse_file("test.rb", command_line: command_line) else Prism.parse_file(argv.shift, command_line: command_line) end end # Get the source code indicated by the command-line arguments. def read_source(argv) case argv.first when "-e" argv.shift [argv.shift, "-e"] when nil [File.read("test.rb"), "test.rb"] else filepath = argv.shift [File.read(filepath), filepath] end end end end Prism::CLI.new.run(ARGV) prism-1.5.1/config.yml000066400000000000000000003723721506127434000146600ustar00rootroot00000000000000errors: - ALIAS_ARGUMENT - ALIAS_ARGUMENT_NUMBERED_REFERENCE - AMPAMPEQ_MULTI_ASSIGN - ARGUMENT_AFTER_BLOCK - ARGUMENT_AFTER_FORWARDING_ELLIPSES - ARGUMENT_BARE_HASH - ARGUMENT_BLOCK_FORWARDING - ARGUMENT_BLOCK_MULTI - ARGUMENT_CONFLICT_AMPERSAND - ARGUMENT_CONFLICT_STAR - ARGUMENT_CONFLICT_STAR_STAR - ARGUMENT_FORMAL_CLASS - ARGUMENT_FORMAL_CONSTANT - ARGUMENT_FORMAL_GLOBAL - ARGUMENT_FORMAL_IVAR - ARGUMENT_FORWARDING_UNBOUND - ARGUMENT_NO_FORWARDING_AMPERSAND - ARGUMENT_NO_FORWARDING_ELLIPSES - ARGUMENT_NO_FORWARDING_STAR - ARGUMENT_NO_FORWARDING_STAR_STAR - ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT - ARGUMENT_SPLAT_AFTER_SPLAT - ARGUMENT_TERM_PAREN - ARGUMENT_UNEXPECTED_BLOCK - ARRAY_ELEMENT - ARRAY_EXPRESSION - ARRAY_EXPRESSION_AFTER_STAR - ARRAY_SEPARATOR - ARRAY_TERM - BEGIN_LONELY_ELSE - BEGIN_TERM - BEGIN_UPCASE_BRACE - BEGIN_UPCASE_TERM - BEGIN_UPCASE_TOPLEVEL - BLOCK_PARAM_LOCAL_VARIABLE - BLOCK_PARAM_PIPE_TERM - BLOCK_TERM_BRACE - BLOCK_TERM_END - CANNOT_PARSE_EXPRESSION - CANNOT_PARSE_STRING_PART - CASE_EXPRESSION_AFTER_CASE - CASE_EXPRESSION_AFTER_WHEN - CASE_MATCH_MISSING_PREDICATE - CASE_MISSING_CONDITIONS - CASE_TERM - CLASS_IN_METHOD - CLASS_NAME - CLASS_SUPERCLASS - CLASS_TERM - CLASS_UNEXPECTED_END - CLASS_VARIABLE_BARE - CONDITIONAL_ELSIF_PREDICATE - CONDITIONAL_IF_PREDICATE - CONDITIONAL_PREDICATE_TERM - CONDITIONAL_TERM - CONDITIONAL_TERM_ELSE - CONDITIONAL_UNLESS_PREDICATE - CONDITIONAL_UNTIL_PREDICATE - CONDITIONAL_WHILE_PREDICATE - CONSTANT_PATH_COLON_COLON_CONSTANT - DEF_ENDLESS - DEF_ENDLESS_SETTER - DEF_NAME - DEF_PARAMS_TERM - DEF_PARAMS_TERM_PAREN - DEF_RECEIVER - DEF_RECEIVER_TERM - DEF_TERM - DEFINED_EXPRESSION - EMBDOC_TERM - EMBEXPR_END - EMBVAR_INVALID - END_UPCASE_BRACE - END_UPCASE_TERM - ESCAPE_INVALID_CONTROL - ESCAPE_INVALID_CONTROL_REPEAT - ESCAPE_INVALID_HEXADECIMAL - ESCAPE_INVALID_META - ESCAPE_INVALID_META_REPEAT - ESCAPE_INVALID_UNICODE - ESCAPE_INVALID_UNICODE_CM_FLAGS - ESCAPE_INVALID_UNICODE_LIST - ESCAPE_INVALID_UNICODE_LITERAL - ESCAPE_INVALID_UNICODE_LONG - ESCAPE_INVALID_UNICODE_SHORT - ESCAPE_INVALID_UNICODE_TERM - EXPECT_ARGUMENT - EXPECT_EOL_AFTER_STATEMENT - EXPECT_EXPRESSION_AFTER_AMPAMPEQ - EXPECT_EXPRESSION_AFTER_COMMA - EXPECT_EXPRESSION_AFTER_EQUAL - EXPECT_EXPRESSION_AFTER_LESS_LESS - EXPECT_EXPRESSION_AFTER_LPAREN - EXPECT_EXPRESSION_AFTER_OPERATOR - EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ - EXPECT_EXPRESSION_AFTER_QUESTION - EXPECT_EXPRESSION_AFTER_SPLAT - EXPECT_EXPRESSION_AFTER_SPLAT_HASH - EXPECT_EXPRESSION_AFTER_STAR - EXPECT_FOR_DELIMITER - EXPECT_IDENT_REQ_PARAMETER - EXPECT_IN_DELIMITER - EXPECT_LPAREN_AFTER_NOT_LPAREN - EXPECT_LPAREN_AFTER_NOT_OTHER - EXPECT_LPAREN_REQ_PARAMETER - EXPECT_MESSAGE - EXPECT_RBRACKET - EXPECT_RPAREN - EXPECT_RPAREN_AFTER_MULTI - EXPECT_RPAREN_REQ_PARAMETER - EXPECT_SINGLETON_CLASS_DELIMITER - EXPECT_STRING_CONTENT - EXPECT_WHEN_DELIMITER - EXPRESSION_BARE_HASH - EXPRESSION_NOT_WRITABLE - EXPRESSION_NOT_WRITABLE_ENCODING - EXPRESSION_NOT_WRITABLE_FALSE - EXPRESSION_NOT_WRITABLE_FILE - EXPRESSION_NOT_WRITABLE_LINE - EXPRESSION_NOT_WRITABLE_NIL - EXPRESSION_NOT_WRITABLE_NUMBERED - EXPRESSION_NOT_WRITABLE_SELF - EXPRESSION_NOT_WRITABLE_TRUE - FLOAT_PARSE - FOR_COLLECTION - FOR_IN - FOR_INDEX - FOR_TERM - GLOBAL_VARIABLE_BARE - HASH_EXPRESSION_AFTER_LABEL - HASH_KEY - HASH_ROCKET - HASH_TERM - HASH_VALUE - HEREDOC_IDENTIFIER - HEREDOC_TERM - INCOMPLETE_QUESTION_MARK - INCOMPLETE_VARIABLE_CLASS - INCOMPLETE_VARIABLE_CLASS_3_3 - INCOMPLETE_VARIABLE_INSTANCE - INCOMPLETE_VARIABLE_INSTANCE_3_3 - INSTANCE_VARIABLE_BARE - INVALID_BLOCK_EXIT - INVALID_CHARACTER - INVALID_COMMA - INVALID_ENCODING_MAGIC_COMMENT - INVALID_ESCAPE_CHARACTER - INVALID_FLOAT_EXPONENT - INVALID_LOCAL_VARIABLE_READ - INVALID_LOCAL_VARIABLE_WRITE - INVALID_MULTIBYTE_CHAR - INVALID_MULTIBYTE_CHARACTER - INVALID_MULTIBYTE_ESCAPE - INVALID_NUMBER_BINARY - INVALID_NUMBER_DECIMAL - INVALID_NUMBER_FRACTION - INVALID_NUMBER_HEXADECIMAL - INVALID_NUMBER_OCTAL - INVALID_NUMBER_UNDERSCORE_INNER - INVALID_NUMBER_UNDERSCORE_TRAILING - INVALID_PERCENT - INVALID_PERCENT_EOF - INVALID_PRINTABLE_CHARACTER - INVALID_RETRY_AFTER_ELSE - INVALID_RETRY_AFTER_ENSURE - INVALID_RETRY_WITHOUT_RESCUE - INVALID_SYMBOL - INVALID_VARIABLE_GLOBAL - INVALID_VARIABLE_GLOBAL_3_3 - INVALID_YIELD - IT_NOT_ALLOWED_NUMBERED - IT_NOT_ALLOWED_ORDINARY - LAMBDA_OPEN - LAMBDA_TERM_BRACE - LAMBDA_TERM_END - LIST_I_LOWER_ELEMENT - LIST_I_LOWER_TERM - LIST_I_UPPER_ELEMENT - LIST_I_UPPER_TERM - LIST_W_LOWER_ELEMENT - LIST_W_LOWER_TERM - LIST_W_UPPER_ELEMENT - LIST_W_UPPER_TERM - MALLOC_FAILED - MIXED_ENCODING - MODULE_IN_METHOD - MODULE_NAME - MODULE_TERM - MULTI_ASSIGN_MULTI_SPLATS - MULTI_ASSIGN_UNEXPECTED_REST - NESTING_TOO_DEEP - NO_LOCAL_VARIABLE - NON_ASSOCIATIVE_OPERATOR - NOT_EXPRESSION - NUMBER_LITERAL_UNDERSCORE - NUMBERED_PARAMETER_INNER_BLOCK - NUMBERED_PARAMETER_IT - NUMBERED_PARAMETER_ORDINARY - NUMBERED_PARAMETER_OUTER_BLOCK - OPERATOR_MULTI_ASSIGN - OPERATOR_WRITE_ARGUMENTS - OPERATOR_WRITE_BLOCK - PARAMETER_ASSOC_SPLAT_MULTI - PARAMETER_BLOCK_MULTI - PARAMETER_CIRCULAR - PARAMETER_FORWARDING_AFTER_REST - PARAMETER_METHOD_NAME - PARAMETER_NAME_DUPLICATED - PARAMETER_NO_DEFAULT - PARAMETER_NO_DEFAULT_KW - PARAMETER_NUMBERED_RESERVED - PARAMETER_ORDER - PARAMETER_SPLAT_MULTI - PARAMETER_STAR - PARAMETER_UNEXPECTED_FWD - PARAMETER_UNEXPECTED_NO_KW - PARAMETER_WILD_LOOSE_COMMA - PATTERN_ARRAY_MULTIPLE_RESTS - PATTERN_CAPTURE_DUPLICATE - PATTERN_EXPRESSION_AFTER_BRACKET - PATTERN_EXPRESSION_AFTER_COMMA - PATTERN_EXPRESSION_AFTER_HROCKET - PATTERN_EXPRESSION_AFTER_IN - PATTERN_EXPRESSION_AFTER_KEY - PATTERN_EXPRESSION_AFTER_PAREN - PATTERN_EXPRESSION_AFTER_PIN - PATTERN_EXPRESSION_AFTER_PIPE - PATTERN_EXPRESSION_AFTER_RANGE - PATTERN_EXPRESSION_AFTER_REST - PATTERN_FIND_MISSING_INNER - PATTERN_HASH_IMPLICIT - PATTERN_HASH_KEY - PATTERN_HASH_KEY_DUPLICATE - PATTERN_HASH_KEY_INTERPOLATED - PATTERN_HASH_KEY_LABEL - PATTERN_HASH_KEY_LOCALS - PATTERN_IDENT_AFTER_HROCKET - PATTERN_LABEL_AFTER_COMMA - PATTERN_REST - PATTERN_TERM_BRACE - PATTERN_TERM_BRACKET - PATTERN_TERM_PAREN - PIPEPIPEEQ_MULTI_ASSIGN - REGEXP_ENCODING_OPTION_MISMATCH - REGEXP_INCOMPAT_CHAR_ENCODING - REGEXP_INVALID_UNICODE_RANGE - REGEXP_NON_ESCAPED_MBC - REGEXP_PARSE_ERROR - REGEXP_TERM - REGEXP_UNKNOWN_OPTIONS - REGEXP_UTF8_CHAR_NON_UTF8_REGEXP - RESCUE_EXPRESSION - RESCUE_MODIFIER_VALUE - RESCUE_TERM - RESCUE_VARIABLE - RETURN_INVALID - SCRIPT_NOT_FOUND - SINGLETON_FOR_LITERALS - STATEMENT_ALIAS - STATEMENT_POSTEXE_END - STATEMENT_PREEXE_BEGIN - STATEMENT_UNDEF - STRING_CONCATENATION - STRING_INTERPOLATED_TERM - STRING_LITERAL_EOF - STRING_LITERAL_TERM - SYMBOL_INVALID - SYMBOL_TERM_DYNAMIC - SYMBOL_TERM_INTERPOLATED - TERNARY_COLON - TERNARY_EXPRESSION_FALSE - TERNARY_EXPRESSION_TRUE - UNARY_DISALLOWED - UNARY_RECEIVER - UNDEF_ARGUMENT - UNEXPECTED_BLOCK_ARGUMENT - UNEXPECTED_INDEX_BLOCK - UNEXPECTED_INDEX_KEYWORDS - UNEXPECTED_LABEL - UNEXPECTED_MULTI_WRITE - UNEXPECTED_RANGE_OPERATOR - UNEXPECTED_SAFE_NAVIGATION - UNEXPECTED_TOKEN_CLOSE_CONTEXT - UNEXPECTED_TOKEN_IGNORE - UNTIL_TERM - VOID_EXPRESSION - WHILE_TERM - WRITE_TARGET_IN_METHOD - WRITE_TARGET_READONLY - WRITE_TARGET_UNEXPECTED - XSTRING_TERM warnings: - AMBIGUOUS_BINARY_OPERATOR - AMBIGUOUS_FIRST_ARGUMENT_MINUS - AMBIGUOUS_FIRST_ARGUMENT_PLUS - AMBIGUOUS_PREFIX_AMPERSAND - AMBIGUOUS_PREFIX_STAR - AMBIGUOUS_PREFIX_STAR_STAR - AMBIGUOUS_SLASH - COMPARISON_AFTER_COMPARISON - DOT_DOT_DOT_EOL - EQUAL_IN_CONDITIONAL - EQUAL_IN_CONDITIONAL_3_3 - END_IN_METHOD - DUPLICATED_HASH_KEY - DUPLICATED_WHEN_CLAUSE - FLOAT_OUT_OF_RANGE - IGNORED_FROZEN_STRING_LITERAL - INDENTATION_MISMATCH - INTEGER_IN_FLIP_FLOP - INVALID_CHARACTER - INVALID_MAGIC_COMMENT_VALUE - INVALID_NUMBERED_REFERENCE - KEYWORD_EOL - LITERAL_IN_CONDITION_DEFAULT - LITERAL_IN_CONDITION_VERBOSE - SHAREABLE_CONSTANT_VALUE_LINE - SHEBANG_CARRIAGE_RETURN - UNEXPECTED_CARRIAGE_RETURN - UNREACHABLE_STATEMENT - UNUSED_LOCAL_VARIABLE - VOID_STATEMENT tokens: # The order of the tokens at the beginning is important, because we use them # for a lookup table. - name: EOF value: 1 comment: final token in the file - name: BRACE_RIGHT comment: "}" - name: COMMA comment: "," - name: EMBEXPR_END comment: "}" - name: KEYWORD_DO comment: "do" - name: KEYWORD_ELSE comment: "else" - name: KEYWORD_ELSIF comment: "elsif" - name: KEYWORD_END comment: "end" - name: KEYWORD_ENSURE comment: "ensure" - name: KEYWORD_IN comment: "in" - name: KEYWORD_RESCUE comment: "rescue" - name: KEYWORD_THEN comment: "then" - name: KEYWORD_WHEN comment: "when" - name: NEWLINE comment: "a newline character outside of other tokens" - name: PARENTHESIS_RIGHT comment: ")" - name: SEMICOLON comment: ";" # Tokens from here on are not used for lookup, and can be in any order. - name: AMPERSAND comment: "&" - name: AMPERSAND_AMPERSAND comment: "&&" - name: AMPERSAND_AMPERSAND_EQUAL comment: "&&=" - name: AMPERSAND_DOT comment: "&." - name: AMPERSAND_EQUAL comment: "&=" - name: BACKTICK comment: "`" - name: BACK_REFERENCE comment: "a back reference" - name: BANG comment: "! or !@" - name: BANG_EQUAL comment: "!=" - name: BANG_TILDE comment: "!~" - name: BRACE_LEFT comment: "{" - name: BRACKET_LEFT comment: "[" - name: BRACKET_LEFT_ARRAY comment: "[ for the beginning of an array" - name: BRACKET_LEFT_RIGHT comment: "[]" - name: BRACKET_LEFT_RIGHT_EQUAL comment: "[]=" - name: BRACKET_RIGHT comment: "]" - name: CARET comment: "^" - name: CARET_EQUAL comment: "^=" - name: CHARACTER_LITERAL comment: "a character literal" - name: CLASS_VARIABLE comment: "a class variable" - name: COLON comment: ":" - name: COLON_COLON comment: "::" - name: COMMENT comment: "a comment" - name: CONSTANT comment: "a constant" - name: DOT comment: "the . call operator" - name: DOT_DOT comment: "the .. range operator" - name: DOT_DOT_DOT comment: "the ... range operator or forwarding parameter" - name: EMBDOC_BEGIN comment: "=begin" - name: EMBDOC_END comment: "=end" - name: EMBDOC_LINE comment: "a line inside of embedded documentation" - name: EMBEXPR_BEGIN comment: "#{" - name: EMBVAR comment: "#" - name: EQUAL comment: "=" - name: EQUAL_EQUAL comment: "==" - name: EQUAL_EQUAL_EQUAL comment: "===" - name: EQUAL_GREATER comment: "=>" - name: EQUAL_TILDE comment: "=~" - name: FLOAT comment: "a floating point number" - name: FLOAT_IMAGINARY comment: "a floating pointer number with an imaginary suffix" - name: FLOAT_RATIONAL comment: "a floating pointer number with a rational suffix" - name: FLOAT_RATIONAL_IMAGINARY comment: "a floating pointer number with a rational and imaginary suffix" - name: GLOBAL_VARIABLE comment: "a global variable" - name: GREATER comment: ">" - name: GREATER_EQUAL comment: ">=" - name: GREATER_GREATER comment: ">>" - name: GREATER_GREATER_EQUAL comment: ">>=" - name: HEREDOC_END comment: "the end of a heredoc" - name: HEREDOC_START comment: "the start of a heredoc" - name: IDENTIFIER comment: "an identifier" - name: IGNORED_NEWLINE comment: "an ignored newline" - name: INSTANCE_VARIABLE comment: "an instance variable" - name: INTEGER comment: "an integer (any base)" - name: INTEGER_IMAGINARY comment: "an integer with an imaginary suffix" - name: INTEGER_RATIONAL comment: "an integer with a rational suffix" - name: INTEGER_RATIONAL_IMAGINARY comment: "an integer with a rational and imaginary suffix" - name: KEYWORD_ALIAS comment: "alias" - name: KEYWORD_AND comment: "and" - name: KEYWORD_BEGIN comment: "begin" - name: KEYWORD_BEGIN_UPCASE comment: "BEGIN" - name: KEYWORD_BREAK comment: "break" - name: KEYWORD_CASE comment: "case" - name: KEYWORD_CLASS comment: "class" - name: KEYWORD_DEF comment: "def" - name: KEYWORD_DEFINED comment: "defined?" - name: KEYWORD_DO_LOOP comment: "do keyword for a predicate in a while, until, or for loop" - name: KEYWORD_END_UPCASE comment: "END" - name: KEYWORD_FALSE comment: "false" - name: KEYWORD_FOR comment: "for" - name: KEYWORD_IF comment: "if" - name: KEYWORD_IF_MODIFIER comment: "if in the modifier form" - name: KEYWORD_MODULE comment: "module" - name: KEYWORD_NEXT comment: "next" - name: KEYWORD_NIL comment: "nil" - name: KEYWORD_NOT comment: "not" - name: KEYWORD_OR comment: "or" - name: KEYWORD_REDO comment: "redo" - name: KEYWORD_RESCUE_MODIFIER comment: "rescue in the modifier form" - name: KEYWORD_RETRY comment: "retry" - name: KEYWORD_RETURN comment: "return" - name: KEYWORD_SELF comment: "self" - name: KEYWORD_SUPER comment: "super" - name: KEYWORD_TRUE comment: "true" - name: KEYWORD_UNDEF comment: "undef" - name: KEYWORD_UNLESS comment: "unless" - name: KEYWORD_UNLESS_MODIFIER comment: "unless in the modifier form" - name: KEYWORD_UNTIL comment: "until" - name: KEYWORD_UNTIL_MODIFIER comment: "until in the modifier form" - name: KEYWORD_WHILE comment: "while" - name: KEYWORD_WHILE_MODIFIER comment: "while in the modifier form" - name: KEYWORD_YIELD comment: "yield" - name: KEYWORD___ENCODING__ comment: "__ENCODING__" - name: KEYWORD___FILE__ comment: "__FILE__" - name: KEYWORD___LINE__ comment: "__LINE__" - name: LABEL comment: "a label" - name: LABEL_END comment: "the end of a label" - name: LAMBDA_BEGIN comment: "{" - name: LESS comment: "<" - name: LESS_EQUAL comment: "<=" - name: LESS_EQUAL_GREATER comment: "<=>" - name: LESS_LESS comment: "<<" - name: LESS_LESS_EQUAL comment: "<<=" - name: METHOD_NAME comment: "a method name" - name: MINUS comment: "-" - name: MINUS_EQUAL comment: "-=" - name: MINUS_GREATER comment: "->" - name: NUMBERED_REFERENCE comment: "a numbered reference to a capture group in the previous regular expression match" - name: PARENTHESIS_LEFT comment: "(" - name: PARENTHESIS_LEFT_PARENTHESES comment: "( for a parentheses node" - name: PERCENT comment: "%" - name: PERCENT_EQUAL comment: "%=" - name: PERCENT_LOWER_I comment: "%i" - name: PERCENT_LOWER_W comment: "%w" - name: PERCENT_LOWER_X comment: "%x" - name: PERCENT_UPPER_I comment: "%I" - name: PERCENT_UPPER_W comment: "%W" - name: PIPE comment: "|" - name: PIPE_EQUAL comment: "|=" - name: PIPE_PIPE comment: "||" - name: PIPE_PIPE_EQUAL comment: "||=" - name: PLUS comment: "+" - name: PLUS_EQUAL comment: "+=" - name: QUESTION_MARK comment: "?" - name: REGEXP_BEGIN comment: "the beginning of a regular expression" - name: REGEXP_END comment: "the end of a regular expression" - name: SLASH comment: "/" - name: SLASH_EQUAL comment: "/=" - name: STAR comment: "*" - name: STAR_EQUAL comment: "*=" - name: STAR_STAR comment: "**" - name: STAR_STAR_EQUAL comment: "**=" - name: STRING_BEGIN comment: "the beginning of a string" - name: STRING_CONTENT comment: "the contents of a string" - name: STRING_END comment: "the end of a string" - name: SYMBOL_BEGIN comment: "the beginning of a symbol" - name: TILDE comment: "~ or ~@" - name: UAMPERSAND comment: "unary &" - name: UCOLON_COLON comment: "unary ::" - name: UDOT_DOT comment: "unary .. operator" - name: UDOT_DOT_DOT comment: "unary ... operator" - name: UMINUS comment: "-@" - name: UMINUS_NUM comment: "-@ for a number" - name: UPLUS comment: "+@" - name: USTAR comment: "unary *" - name: USTAR_STAR comment: "unary **" - name: WORDS_SEP comment: "a separator between words in a list" - name: __END__ comment: "marker for the point in the file at which the parser should stop" - name: MISSING comment: "a token that was expected but not found" - name: NOT_PROVIDED comment: "a token that was not present but it is okay" flags: - name: ArgumentsNodeFlags values: - name: CONTAINS_FORWARDING comment: "if the arguments contain forwarding" - name: CONTAINS_KEYWORDS comment: "if the arguments contain keywords" - name: CONTAINS_KEYWORD_SPLAT comment: "if the arguments contain a keyword splat" - name: CONTAINS_SPLAT comment: "if the arguments contain a splat" - name: CONTAINS_MULTIPLE_SPLATS comment: "if the arguments contain multiple splats" comment: Flags for arguments nodes. - name: ArrayNodeFlags values: - name: CONTAINS_SPLAT comment: "if array contains splat nodes" comment: Flags for array nodes. - name: CallNodeFlags values: - name: SAFE_NAVIGATION comment: "&. operator" - name: VARIABLE_CALL comment: "a call that could have been a local variable" - name: ATTRIBUTE_WRITE comment: "a call that is an attribute write, so the value being written should be returned" - name: IGNORE_VISIBILITY comment: "a call that ignores method visibility" comment: Flags for call nodes. - name: EncodingFlags values: - name: FORCED_UTF8_ENCODING comment: "internal bytes forced the encoding to UTF-8" - name: FORCED_BINARY_ENCODING comment: "internal bytes forced the encoding to binary" comment: Flags for nodes that have unescaped content. - name: IntegerBaseFlags values: - name: BINARY comment: "0b prefix" - name: DECIMAL comment: "0d or no prefix" - name: OCTAL comment: "0o or 0 prefix" - name: HEXADECIMAL comment: "0x prefix" comment: Flags for integer nodes that correspond to the base of the integer. - name: InterpolatedStringNodeFlags values: - name: FROZEN comment: "frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'`" - name: MUTABLE comment: "mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'`" comment: Flags for interpolated string nodes that indicated mutability if they are also marked as literals. - name: KeywordHashNodeFlags values: - name: SYMBOL_KEYS comment: "a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments" comment: Flags for keyword hash nodes. - name: LoopFlags values: - name: BEGIN_MODIFIER comment: "a loop after a begin statement, so the body is executed first before the condition" comment: Flags for while and until loop nodes. - name: ParameterFlags values: - name: REPEATED_PARAMETER comment: "a parameter name that has been repeated in the method signature" comment: Flags for parameter nodes. - name: ParenthesesNodeFlags values: - name: MULTIPLE_STATEMENTS comment: "parentheses that contain multiple potentially void statements" comment: Flags for parentheses nodes. - name: RangeFlags values: - name: EXCLUDE_END comment: "... operator" comment: Flags for range and flip-flop nodes. - name: RegularExpressionFlags values: - name: IGNORE_CASE comment: "i - ignores the case of characters when matching" - name: EXTENDED comment: "x - ignores whitespace and allows comments in regular expressions" - name: MULTI_LINE comment: "m - allows $ to match the end of lines within strings" - name: ONCE comment: "o - only interpolates values into the regular expression once" - name: EUC_JP comment: "e - forces the EUC-JP encoding" - name: ASCII_8BIT comment: "n - forces the ASCII-8BIT encoding" - name: WINDOWS_31J comment: "s - forces the Windows-31J encoding" - name: UTF_8 comment: "u - forces the UTF-8 encoding" - name: FORCED_UTF8_ENCODING comment: "internal bytes forced the encoding to UTF-8" - name: FORCED_BINARY_ENCODING comment: "internal bytes forced the encoding to binary" - name: FORCED_US_ASCII_ENCODING comment: "internal bytes forced the encoding to US-ASCII" comment: Flags for regular expression and match last line nodes. - name: ShareableConstantNodeFlags values: - name: LITERAL comment: "constant writes that should be modified with shareable constant value literal" - name: EXPERIMENTAL_EVERYTHING comment: "constant writes that should be modified with shareable constant value experimental everything" - name: EXPERIMENTAL_COPY comment: "constant writes that should be modified with shareable constant value experimental copy" comment: Flags for shareable constant nodes. - name: StringFlags values: - name: FORCED_UTF8_ENCODING comment: "internal bytes forced the encoding to UTF-8" - name: FORCED_BINARY_ENCODING comment: "internal bytes forced the encoding to binary" - name: FROZEN comment: "frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`" - name: MUTABLE comment: "mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`" comment: Flags for string nodes. - name: SymbolFlags values: - name: FORCED_UTF8_ENCODING comment: "internal bytes forced the encoding to UTF-8" - name: FORCED_BINARY_ENCODING comment: "internal bytes forced the encoding to binary" - name: FORCED_US_ASCII_ENCODING comment: "internal bytes forced the encoding to US-ASCII" comment: Flags for symbol nodes. nodes: - name: AliasGlobalVariableNode fields: - name: new_name type: node kind: - GlobalVariableReadNode - BackReferenceReadNode - NumberedReferenceReadNode comment: | Represents the new name of the global variable that can be used after aliasing. alias $foo $bar ^^^^ - name: old_name type: node kind: - GlobalVariableReadNode - BackReferenceReadNode - NumberedReferenceReadNode - on error: SymbolNode # alias $a b - on error: MissingNode # alias $a 42 comment: | Represents the old name of the global variable that can be used before aliasing. alias $foo $bar ^^^^ - name: keyword_loc type: location comment: | The location of the `alias` keyword. alias $foo $bar ^^^^^ comment: | Represents the use of the `alias` keyword to alias a global variable. alias $foo $bar ^^^^^^^^^^^^^^^ - name: AliasMethodNode fields: - name: new_name type: node kind: - SymbolNode - InterpolatedSymbolNode comment: | Represents the new name of the method that will be aliased. alias foo bar ^^^ alias :foo :bar ^^^^ alias :"#{foo}" :"#{bar}" ^^^^^^^^^ - name: old_name type: node kind: - SymbolNode - InterpolatedSymbolNode - on error: GlobalVariableReadNode # alias a $b - on error: MissingNode # alias a 42 comment: | Represents the old name of the method that will be aliased. alias foo bar ^^^ alias :foo :bar ^^^^ alias :"#{foo}" :"#{bar}" ^^^^^^^^^ - name: keyword_loc type: location comment: | Represents the location of the `alias` keyword. alias foo bar ^^^^^ comment: | Represents the use of the `alias` keyword to alias a method. alias foo bar ^^^^^^^^^^^^^ - name: AlternationPatternNode fields: - name: left type: node kind: pattern expression comment: | Represents the left side of the expression. foo => bar | baz ^^^ - name: right type: node kind: pattern expression comment: | Represents the right side of the expression. foo => bar | baz ^^^ - name: operator_loc type: location comment: | Represents the alternation operator location. foo => bar | baz ^ comment: | Represents an alternation pattern in pattern matching. foo => bar | baz ^^^^^^^^^ - name: AndNode fields: - name: left type: node kind: non-void expression comment: | Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). left and right ^^^^ 1 && 2 ^ - name: right type: node kind: Node comment: | Represents the right side of the expression. left && right ^^^^^ 1 and 2 ^ - name: operator_loc type: location comment: | The location of the `and` keyword or the `&&` operator. left and right ^^^ comment: | Represents the use of the `&&` operator or the `and` keyword. left and right ^^^^^^^^^^^^^^ - name: ArgumentsNode flags: ArgumentsNodeFlags fields: - name: arguments type: node[] kind: non-void expression comment: | The list of arguments, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). foo(bar, baz) ^^^^^^^^ comment: | Represents a set of arguments to a method or a keyword. return foo, bar, baz ^^^^^^^^^^^^^ - name: ArrayNode flags: ArrayNodeFlags fields: - name: elements type: node[] kind: non-void expression comment: Represent the list of zero or more [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression) within the array. - name: opening_loc type: location? comment: | Represents the optional source location for the opening token. [1,2,3] # "[" %w[foo bar baz] # "%w[" %I(apple orange banana) # "%I(" foo = 1, 2, 3 # nil - name: closing_loc type: location? comment: | Represents the optional source location for the closing token. [1,2,3] # "]" %w[foo bar baz] # "]" %I(apple orange banana) # ")" foo = 1, 2, 3 # nil comment: | Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i. [1, 2, 3] ^^^^^^^^^ - name: ArrayPatternNode fields: - name: constant type: node? kind: - ConstantPathNode - ConstantReadNode comment: | Represents the optional constant preceding the Array foo in Bar[] ^^^ foo in Bar[1, 2, 3] ^^^ foo in Bar::Baz[1, 2, 3] ^^^^^^^^ - name: requireds type: node[] kind: pattern expression comment: | Represents the required elements of the array pattern. foo in [1, 2] ^ ^ - name: rest type: node? kind: pattern expression comment: | Represents the rest element of the array pattern. foo in *bar ^^^^ - name: posts type: node[] kind: pattern expression comment: | Represents the elements after the rest element of the array pattern. foo in *bar, baz ^^^ - name: opening_loc type: location? comment: | Represents the opening location of the array pattern. foo in [1, 2] ^ - name: closing_loc type: location? comment: | Represents the closing location of the array pattern. foo in [1, 2] ^ comment: | Represents an array pattern in pattern matching. foo in 1, 2 ^^^^^^^^^^^ foo in [1, 2] ^^^^^^^^^^^^^ foo in *bar ^^^^^^^^^^^ foo in Bar[] ^^^^^^^^^^^^ foo in Bar[1, 2, 3] ^^^^^^^^^^^^^^^^^^^ - name: AssocNode fields: - name: key type: node kind: non-void expression comment: | The key of the association. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). { a: b } ^ { foo => bar } ^^^ { def a; end => 1 } ^^^^^^^^^^ - name: value type: node kind: non-void expression comment: | The value of the association, if present. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). { foo => bar } ^^^ { x: 1 } ^ - name: operator_loc type: location? comment: | The location of the `=>` operator, if present. { foo => bar } ^^ comment: | Represents a hash key/value pair. { a => b } ^^^^^^ - name: AssocSplatNode fields: - name: value type: node? kind: non-void expression comment: | The value to be splatted, if present. Will be missing when keyword rest argument forwarding is used. { **foo } ^^^ - name: operator_loc type: location comment: | The location of the `**` operator. { **x } ^^ comment: | Represents a splat in a hash literal. { **foo } ^^^^^ - name: BackReferenceReadNode fields: - name: name type: constant comment: | The name of the back-reference variable, including the leading `$`. $& # name `:$&` $+ # name `:$+` comment: | Represents reading a reference to a field in the previous match. $' ^^ - name: BeginNode fields: - name: begin_keyword_loc type: location? comment: | Represents the location of the `begin` keyword. begin x end ^^^^^ - name: statements type: node? kind: StatementsNode comment: | Represents the statements within the begin block. begin x end ^ - name: rescue_clause type: node? kind: RescueNode comment: | Represents the rescue clause within the begin block. begin x; rescue y; end ^^^^^^^^ - name: else_clause type: node? kind: ElseNode comment: | Represents the else clause within the begin block. begin x; rescue y; else z; end ^^^^^^ - name: ensure_clause type: node? kind: EnsureNode comment: | Represents the ensure clause within the begin block. begin x; ensure y; end ^^^^^^^^ - name: end_keyword_loc type: location? comment: | Represents the location of the `end` keyword. begin x end ^^^ newline: false comment: | Represents a begin statement. begin foo end ^^^^^ - name: BlockArgumentNode fields: - name: expression type: node? kind: non-void expression comment: | The expression that is being passed as a block argument. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). foo(&args) ^^^^^ - name: operator_loc type: location comment: | Represents the location of the `&` operator. foo(&args) ^ comment: | Represents a block argument using `&`. bar(&args) ^^^^^^^^^^ - name: BlockLocalVariableNode flags: ParameterFlags fields: - name: name type: constant comment: | The name of the block local variable. a { |; b| } # name `:b` ^ comment: | Represents a block local variable. a { |; b| } ^ - name: BlockNode fields: - name: locals type: constant[] comment: | The local variables declared in the block. [1, 2, 3].each { |i| puts x } # locals: [:i] ^ - name: parameters type: node? kind: - BlockParametersNode - NumberedParametersNode - ItParametersNode comment: | The parameters of the block. [1, 2, 3].each { |i| puts x } ^^^ [1, 2, 3].each { puts _1 } ^^^^^^^^^^^ [1, 2, 3].each { puts it } ^^^^^^^^^^^ - name: body type: node? kind: - StatementsNode - BeginNode comment: | The body of the block. [1, 2, 3].each { |i| puts x } ^^^^^^ - name: opening_loc type: location comment: | Represents the location of the opening `|`. [1, 2, 3].each { |i| puts x } ^ - name: closing_loc type: location comment: | Represents the location of the closing `|`. [1, 2, 3].each { |i| puts x } ^ comment: | Represents a block of ruby code. [1, 2, 3].each { |i| puts x } ^^^^^^^^^^^^^^ - name: BlockParameterNode flags: ParameterFlags fields: - name: name type: constant? comment: | The name of the block parameter. def a(&b) # name `:b` ^ end - name: name_loc type: location? comment: | Represents the location of the block parameter name. def a(&b) ^ - name: operator_loc type: location comment: | Represents the location of the `&` operator. def a(&b) ^ end comment: | Represents a block parameter of a method, block, or lambda definition. def a(&b) ^^ end - name: BlockParametersNode fields: - name: parameters type: node? kind: ParametersNode comment: | Represents the parameters of the block. -> (a, b = 1; local) { } ^^^^^^^^ foo do |a, b = 1; local| ^^^^^^^^ end - name: locals type: node[] kind: BlockLocalVariableNode comment: | Represents the local variables of the block. -> (a, b = 1; local) { } ^^^^^ foo do |a, b = 1; local| ^^^^^ end - name: opening_loc type: location? comment: | Represents the opening location of the block parameters. -> (a, b = 1; local) { } ^ foo do |a, b = 1; local| ^ end - name: closing_loc type: location? comment: | Represents the closing location of the block parameters. -> (a, b = 1; local) { } ^ foo do |a, b = 1; local| ^ end comment: | Represents a block's parameters declaration. -> (a, b = 1; local) { } ^^^^^^^^^^^^^^^^^ foo do |a, b = 1; local| ^^^^^^^^^^^^^^^^^ end - name: BreakNode fields: - name: arguments type: node? kind: ArgumentsNode comment: | The arguments to the break statement, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). break foo ^^^ - name: keyword_loc type: location comment: | The location of the `break` keyword. break foo ^^^^^ comment: | Represents the use of the `break` keyword. break foo ^^^^^^^^^ - name: CallAndWriteNode flags: CallNodeFlags fields: - name: receiver type: node? kind: non-void expression comment: | The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). foo.bar &&= value ^^^ - name: call_operator_loc type: location? comment: | Represents the location of the call operator. foo.bar &&= value ^ - name: message_loc type: location? comment: | Represents the location of the message. foo.bar &&= value ^^^ - name: read_name type: constant comment: | Represents the name of the method being called. foo.bar &&= value # read_name `:bar` ^^^ - name: write_name type: constant comment: | Represents the name of the method being written to. foo.bar &&= value # write_name `:bar=` ^^^ - name: operator_loc type: location comment: | Represents the location of the operator. foo.bar &&= value ^^^ - name: value type: node kind: non-void expression comment: | Represents the value being assigned. foo.bar &&= value ^^^^^ comment: | Represents the use of the `&&=` operator on a call. foo.bar &&= value ^^^^^^^^^^^^^^^^^ - name: CallNode flags: CallNodeFlags fields: - name: receiver type: node? kind: non-void expression comment: | The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). foo.bar ^^^ +foo ^^^ foo + bar ^^^ - name: call_operator_loc type: location? comment: | Represents the location of the call operator. foo.bar ^ foo&.bar ^^ - name: name type: constant comment: | Represents the name of the method being called. foo.bar # name `:foo` ^^^ - name: message_loc type: location? comment: | Represents the location of the message. foo.bar ^^^ - name: opening_loc type: location? comment: | Represents the location of the left parenthesis. foo(bar) ^ - name: arguments type: node? kind: ArgumentsNode comment: | Represents the arguments to the method call. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). foo(bar) ^^^ - name: closing_loc type: location? comment: | Represents the location of the right parenthesis. foo(bar) ^ - name: block type: node? kind: - BlockNode - BlockArgumentNode comment: | Represents the block that is being passed to the method. foo { |a| a } ^^^^^^^^^ comment: | Represents a method call, in all of the various forms that can take. foo ^^^ foo() ^^^^^ +foo ^^^^ foo + bar ^^^^^^^^^ foo.bar ^^^^^^^ foo&.bar ^^^^^^^^ - name: CallOperatorWriteNode flags: CallNodeFlags fields: - name: receiver type: node? kind: non-void expression comment: | The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). foo.bar += value ^^^ - name: call_operator_loc type: location? comment: | Represents the location of the call operator. foo.bar += value ^ - name: message_loc type: location? comment: | Represents the location of the message. foo.bar += value ^^^ - name: read_name type: constant comment: | Represents the name of the method being called. foo.bar += value # read_name `:bar` ^^^ - name: write_name type: constant comment: | Represents the name of the method being written to. foo.bar += value # write_name `:bar=` ^^^ - name: binary_operator type: constant comment: | Represents the binary operator being used. foo.bar += value # binary_operator `:+` ^ - name: binary_operator_loc type: location comment: | Represents the location of the binary operator. foo.bar += value ^^ - name: value type: node kind: non-void expression comment: | Represents the value being assigned. foo.bar += value ^^^^^ comment: | Represents the use of an assignment operator on a call. foo.bar += baz ^^^^^^^^^^^^^^ - name: CallOrWriteNode flags: CallNodeFlags fields: - name: receiver type: node? kind: non-void expression comment: | The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). foo.bar ||= value ^^^ - name: call_operator_loc type: location? comment: | Represents the location of the call operator. foo.bar ||= value ^ - name: message_loc type: location? comment: | Represents the location of the message. foo.bar ||= value ^^^ - name: read_name type: constant comment: | Represents the name of the method being called. foo.bar ||= value # read_name `:bar` ^^^ - name: write_name type: constant comment: | Represents the name of the method being written to. foo.bar ||= value # write_name `:bar=` ^^^ - name: operator_loc type: location comment: | Represents the location of the operator. foo.bar ||= value ^^^ - name: value type: node kind: non-void expression comment: | Represents the value being assigned. foo.bar ||= value ^^^^^ comment: | Represents the use of the `||=` operator on a call. foo.bar ||= value ^^^^^^^^^^^^^^^^^ - name: CallTargetNode flags: CallNodeFlags fields: - name: receiver type: node kind: non-void expression comment: | The object that the method is being called on. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). foo.bar = 1 ^^^ - name: call_operator_loc type: location comment: | Represents the location of the call operator. foo.bar = 1 ^ - name: name type: constant comment: | Represents the name of the method being called. foo.bar = 1 # name `:foo` ^^^ - name: message_loc type: location comment: | Represents the location of the message. foo.bar = 1 ^^^ comment: | Represents assigning to a method call. foo.bar, = 1 ^^^^^^^ begin rescue => foo.bar ^^^^^^^ end for foo.bar in baz do end ^^^^^^^ - name: CapturePatternNode fields: - name: value type: node kind: pattern expression comment: | Represents the value to capture. foo => bar ^^^ - name: target type: node kind: LocalVariableTargetNode comment: | Represents the target of the capture. foo => bar ^^^ - name: operator_loc type: location comment: | Represents the location of the `=>` operator. foo => bar ^^ comment: | Represents assigning to a local variable in pattern matching. foo => [bar => baz] ^^^^^^^^^^^^ - name: CaseMatchNode fields: - name: predicate type: node? kind: non-void expression comment: | Represents the predicate of the case match. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). case true; in false; end ^^^^ - name: conditions type: node[] kind: InNode comment: | Represents the conditions of the case match. case true; in false; end ^^^^^^^^ - name: else_clause type: node? kind: ElseNode comment: | Represents the else clause of the case match. case true; in false; else; end ^^^^ - name: case_keyword_loc type: location comment: | Represents the location of the `case` keyword. case true; in false; end ^^^^ - name: end_keyword_loc type: location comment: | Represents the location of the `end` keyword. case true; in false; end ^^^ comment: | Represents the use of a case statement for pattern matching. case true in false end ^^^^^^^^^ - name: CaseNode fields: - name: predicate type: node? kind: non-void expression comment: | Represents the predicate of the case statement. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). case true; when false; end ^^^^ - name: conditions type: node[] kind: WhenNode comment: | Represents the conditions of the case statement. case true; when false; end ^^^^^^^^^^ - name: else_clause type: node? kind: ElseNode comment: | Represents the else clause of the case statement. case true; when false; else; end ^^^^ - name: case_keyword_loc type: location comment: | Represents the location of the `case` keyword. case true; when false; end ^^^^ - name: end_keyword_loc type: location comment: | Represents the location of the `end` keyword. case true; when false; end ^^^ comment: | Represents the use of a case statement. case true when false end ^^^^^^^^^^ - name: ClassNode fields: - name: locals type: constant[] - name: class_keyword_loc type: location comment: | Represents the location of the `class` keyword. class Foo end ^^^^^ - name: constant_path type: node kind: - ConstantReadNode - ConstantPathNode - on error: CallNode # class 0.X end - name: inheritance_operator_loc type: location? comment: | Represents the location of the `<` operator. class Foo < Bar ^ - name: superclass type: node? kind: non-void expression comment: | Represents the superclass of the class. class Foo < Bar ^^^ - name: body type: node? kind: - StatementsNode - BeginNode comment: | Represents the body of the class. class Foo foo ^^^ - name: end_keyword_loc type: location comment: | Represents the location of the `end` keyword. class Foo end ^^^ - name: name type: constant comment: | The name of the class. class Foo end # name `:Foo` comment: | Represents a class declaration involving the `class` keyword. class Foo end ^^^^^^^^^^^^^ - name: ClassVariableAndWriteNode fields: - name: name type: constant comment: | The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers). @@target &&= value # name `:@@target` ^^^^^^^^ - name: name_loc type: location comment: | Represents the location of the variable name. @@target &&= value ^^^^^^^^ - name: operator_loc type: location comment: | Represents the location of the `&&=` operator. @@target &&= value ^^^ - name: value type: node kind: non-void expression comment: | Represents the value being assigned. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@target &&= value ^^^^^ comment: | Represents the use of the `&&=` operator for assignment to a class variable. @@target &&= value ^^^^^^^^^^^^^^^^^^ - name: ClassVariableOperatorWriteNode fields: - name: name type: constant - name: name_loc type: location - name: binary_operator_loc type: location - name: value type: node kind: non-void expression - name: binary_operator type: constant comment: | Represents assigning to a class variable using an operator that isn't `=`. @@target += value ^^^^^^^^^^^^^^^^^ - name: ClassVariableOrWriteNode fields: - name: name type: constant - name: name_loc type: location - name: operator_loc type: location - name: value type: node kind: non-void expression comment: | Represents the use of the `||=` operator for assignment to a class variable. @@target ||= value ^^^^^^^^^^^^^^^^^^ - name: ClassVariableReadNode fields: - name: name type: constant comment: | The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers). @@abc # name `:@@abc` @@_test # name `:@@_test` comment: | Represents referencing a class variable. @@foo ^^^^^ - name: ClassVariableTargetNode fields: - name: name type: constant comment: | Represents writing to a class variable in a context that doesn't have an explicit value. @@foo, @@bar = baz ^^^^^ ^^^^^ - name: ClassVariableWriteNode fields: - name: name type: constant comment: | The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers). @@abc = 123 # name `@@abc` @@_test = :test # name `@@_test` - name: name_loc type: location comment: | The location of the variable name. @@foo = :bar ^^^^^ - name: value type: node kind: non-void expression comment: | The value to write to the class variable. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@foo = :bar ^^^^ @@_xyz = 123 ^^^ - name: operator_loc type: location comment: | The location of the `=` operator. @@foo = :bar ^ comment: | Represents writing to a class variable. @@foo = 1 ^^^^^^^^^ - name: ConstantAndWriteNode fields: - name: name type: constant - name: name_loc type: location - name: operator_loc type: location - name: value type: node kind: non-void expression comment: | Represents the use of the `&&=` operator for assignment to a constant. Target &&= value ^^^^^^^^^^^^^^^^ - name: ConstantOperatorWriteNode fields: - name: name type: constant - name: name_loc type: location - name: binary_operator_loc type: location - name: value type: node kind: non-void expression - name: binary_operator type: constant comment: | Represents assigning to a constant using an operator that isn't `=`. Target += value ^^^^^^^^^^^^^^^ - name: ConstantOrWriteNode fields: - name: name type: constant - name: name_loc type: location - name: operator_loc type: location - name: value type: node kind: non-void expression comment: | Represents the use of the `||=` operator for assignment to a constant. Target ||= value ^^^^^^^^^^^^^^^^ - name: ConstantPathAndWriteNode fields: - name: target type: node kind: ConstantPathNode - name: operator_loc type: location - name: value type: node kind: non-void expression comment: | Represents the use of the `&&=` operator for assignment to a constant path. Parent::Child &&= value ^^^^^^^^^^^^^^^^^^^^^^^ - name: ConstantPathNode fields: - name: parent type: node? kind: non-void expression comment: | The left-hand node of the path, if present. It can be `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). It will be `nil` when the constant lookup is at the root of the module tree. Foo::Bar ^^^ self::Test ^^^^ a.b::C ^^^ - name: name type: constant? comment: The name of the constant being accessed. This could be `nil` in the event of a syntax error. - name: delimiter_loc type: location comment: | The location of the `::` delimiter. ::Foo ^^ One::Two ^^ - name: name_loc type: location comment: | The location of the name of the constant. ::Foo ^^^ One::Two ^^^ comment: | Represents accessing a constant through a path of `::` operators. Foo::Bar ^^^^^^^^ - name: ConstantPathOperatorWriteNode fields: - name: target type: node kind: ConstantPathNode - name: binary_operator_loc type: location - name: value type: node kind: non-void expression - name: binary_operator type: constant comment: | Represents assigning to a constant path using an operator that isn't `=`. Parent::Child += value ^^^^^^^^^^^^^^^^^^^^^^ - name: ConstantPathOrWriteNode fields: - name: target type: node kind: ConstantPathNode - name: operator_loc type: location - name: value type: node kind: non-void expression comment: | Represents the use of the `||=` operator for assignment to a constant path. Parent::Child ||= value ^^^^^^^^^^^^^^^^^^^^^^^ - name: ConstantPathTargetNode fields: - name: parent type: node? kind: non-void expression - name: name type: constant? - name: delimiter_loc type: location - name: name_loc type: location comment: | Represents writing to a constant path in a context that doesn't have an explicit value. Foo::Foo, Bar::Bar = baz ^^^^^^^^ ^^^^^^^^ - name: ConstantPathWriteNode fields: - name: target type: node kind: ConstantPathNode comment: | A node representing the constant path being written to. Foo::Bar = 1 ^^^^^^^^ ::Foo = :abc ^^^^^ - name: operator_loc type: location comment: | The location of the `=` operator. ::ABC = 123 ^ - name: value type: node kind: non-void expression comment: | The value to write to the constant path. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). FOO::BAR = :abc ^^^^ comment: | Represents writing to a constant path. ::Foo = 1 ^^^^^^^^^ Foo::Bar = 1 ^^^^^^^^^^^^ ::Foo::Bar = 1 ^^^^^^^^^^^^^^ - name: ConstantReadNode fields: - name: name type: constant comment: | The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants). X # name `:X` SOME_CONSTANT # name `:SOME_CONSTANT` comment: | Represents referencing a constant. Foo ^^^ - name: ConstantTargetNode fields: - name: name type: constant comment: | Represents writing to a constant in a context that doesn't have an explicit value. Foo, Bar = baz ^^^ ^^^ - name: ConstantWriteNode fields: - name: name type: constant comment: | The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants). Foo = :bar # name `:Foo` XYZ = 1 # name `:XYZ` - name: name_loc type: location comment: | The location of the constant name. FOO = 1 ^^^ - name: value type: node kind: non-void expression comment: | The value to write to the constant. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). FOO = :bar ^^^^ MyClass = Class.new ^^^^^^^^^ - name: operator_loc type: location comment: | The location of the `=` operator. FOO = :bar ^ comment: | Represents writing to a constant. Foo = 1 ^^^^^^^ - name: DefNode fields: - name: name type: constant - name: name_loc type: location - name: receiver type: node? kind: non-void expression - name: parameters type: node? kind: ParametersNode - name: body type: node? kind: - StatementsNode - BeginNode - name: locals type: constant[] - name: def_keyword_loc type: location - name: operator_loc type: location? - name: lparen_loc type: location? - name: rparen_loc type: location? - name: equal_loc type: location? - name: end_keyword_loc type: location? comment: | Represents a method definition. def method end ^^^^^^^^^^ - name: DefinedNode fields: - name: lparen_loc type: location? - name: value type: node kind: Node # More than non-void expression as defined?(return) is allowed, yet defined?(BEGIN{}) is SyntaxError - name: rparen_loc type: location? - name: keyword_loc type: location comment: | Represents the use of the `defined?` keyword. defined?(a) ^^^^^^^^^^^ - name: ElseNode fields: - name: else_keyword_loc type: location - name: statements type: node? kind: StatementsNode - name: end_keyword_loc type: location? comment: | Represents an `else` clause in a `case`, `if`, or `unless` statement. if a then b else c end ^^^^^^^^^^ - name: EmbeddedStatementsNode fields: - name: opening_loc type: location - name: statements type: node? kind: StatementsNode - name: closing_loc type: location comment: | Represents an interpolated set of statements. "foo #{bar}" ^^^^^^ - name: EmbeddedVariableNode fields: - name: operator_loc type: location - name: variable type: node kind: - InstanceVariableReadNode - ClassVariableReadNode - GlobalVariableReadNode - BackReferenceReadNode - NumberedReferenceReadNode comment: | Represents an interpolated variable. "foo #@bar" ^^^^^ - name: EnsureNode fields: - name: ensure_keyword_loc type: location - name: statements type: node? kind: StatementsNode - name: end_keyword_loc type: location comment: | Represents an `ensure` clause in a `begin` statement. begin foo ensure ^^^^^^ bar end - name: FalseNode comment: | Represents the use of the literal `false` keyword. false ^^^^^ - name: FindPatternNode fields: - name: constant type: node? kind: - ConstantPathNode - ConstantReadNode comment: | Represents the optional constant preceding the pattern foo in Foo(*bar, baz, *qux) ^^^ - name: left type: node kind: SplatNode comment: | Represents the first wildcard node in the pattern. foo in *bar, baz, *qux ^^^^ foo in Foo(*bar, baz, *qux) ^^^^ - name: requireds type: node[] kind: pattern expression comment: | Represents the nodes in between the wildcards. foo in *bar, baz, *qux ^^^ foo in Foo(*bar, baz, 1, *qux) ^^^^^^ - name: right type: node kind: - SplatNode - on error: MissingNode comment: | Represents the second wildcard node in the pattern. foo in *bar, baz, *qux ^^^^ foo in Foo(*bar, baz, *qux) ^^^^ - name: opening_loc type: location? comment: | The location of the opening brace. foo in [*bar, baz, *qux] ^ foo in Foo(*bar, baz, *qux) ^ - name: closing_loc type: location? comment: | The location of the closing brace. foo in [*bar, baz, *qux] ^ foo in Foo(*bar, baz, *qux) ^ comment: | Represents a find pattern in pattern matching. foo in *bar, baz, *qux ^^^^^^^^^^^^^^^ foo in [*bar, baz, *qux] ^^^^^^^^^^^^^^^^^ foo in Foo(*bar, baz, *qux) ^^^^^^^^^^^^^^^^^^^^ foo => *bar, baz, *qux ^^^^^^^^^^^^^^^ - name: FlipFlopNode flags: RangeFlags fields: - name: left type: node? kind: non-void expression - name: right type: node? kind: non-void expression - name: operator_loc type: location comment: | Represents the use of the `..` or `...` operators to create flip flops. baz if foo .. bar ^^^^^^^^^^ - name: FloatNode fields: - name: value type: double comment: The value of the floating point number as a Float. comment: | Represents a floating point number literal. 1.0 ^^^ - name: ForNode fields: - name: index type: node kind: - LocalVariableTargetNode - InstanceVariableTargetNode - ClassVariableTargetNode - GlobalVariableTargetNode - ConstantTargetNode - ConstantPathTargetNode - CallTargetNode - IndexTargetNode - MultiTargetNode - on error: BackReferenceReadNode # for $& in a end - on error: NumberedReferenceReadNode # for $1 in a end - on error: MissingNode # for in 1..10; end comment: | The index expression for `for` loops. for i in a end ^ - name: collection type: node kind: non-void expression comment: | The collection to iterate over. for i in a end ^ - name: statements type: node? kind: StatementsNode comment: | Represents the body of statements to execute for each iteration of the loop. for i in a foo(i) ^^^^^^ end - name: for_keyword_loc type: location comment: | The location of the `for` keyword. for i in a end ^^^ - name: in_keyword_loc type: location comment: | The location of the `in` keyword. for i in a end ^^ - name: do_keyword_loc type: location? comment: | The location of the `do` keyword, if present. for i in a do end ^^ - name: end_keyword_loc type: location comment: | The location of the `end` keyword. for i in a end ^^^ comment: | Represents the use of the `for` keyword. for i in a end ^^^^^^^^^^^^^^ - name: ForwardingArgumentsNode comment: | Represents forwarding all arguments to this method to another method. def foo(...) bar(...) ^^^ end - name: ForwardingParameterNode comment: | Represents the use of the forwarding parameter in a method, block, or lambda declaration. def foo(...) ^^^ end - name: ForwardingSuperNode fields: - name: block type: node? kind: BlockNode comment: | Represents the use of the `super` keyword without parentheses or arguments. super ^^^^^ - name: GlobalVariableAndWriteNode fields: - name: name type: constant - name: name_loc type: location - name: operator_loc type: location - name: value type: node kind: non-void expression comment: | Represents the use of the `&&=` operator for assignment to a global variable. $target &&= value ^^^^^^^^^^^^^^^^^ - name: GlobalVariableOperatorWriteNode fields: - name: name type: constant - name: name_loc type: location - name: binary_operator_loc type: location - name: value type: node kind: non-void expression - name: binary_operator type: constant comment: | Represents assigning to a global variable using an operator that isn't `=`. $target += value ^^^^^^^^^^^^^^^^ - name: GlobalVariableOrWriteNode fields: - name: name type: constant - name: name_loc type: location - name: operator_loc type: location - name: value type: node kind: non-void expression comment: | Represents the use of the `||=` operator for assignment to a global variable. $target ||= value ^^^^^^^^^^^^^^^^^ - name: GlobalVariableReadNode fields: - name: name type: constant comment: | The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol. $foo # name `:$foo` $_Test # name `:$_Test` comment: | Represents referencing a global variable. $foo ^^^^ - name: GlobalVariableTargetNode fields: - name: name type: constant comment: | Represents writing to a global variable in a context that doesn't have an explicit value. $foo, $bar = baz ^^^^ ^^^^ - name: GlobalVariableWriteNode fields: - name: name type: constant comment: | The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol. $foo = :bar # name `:$foo` $_Test = 123 # name `:$_Test` - name: name_loc type: location comment: | The location of the global variable's name. $foo = :bar ^^^^ - name: value type: node kind: non-void expression comment: | The value to write to the global variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). $foo = :bar ^^^^ $-xyz = 123 ^^^ - name: operator_loc type: location comment: | The location of the `=` operator. $foo = :bar ^ comment: | Represents writing to a global variable. $foo = 1 ^^^^^^^^ - name: HashNode fields: - name: opening_loc type: location comment: | The location of the opening brace. { a => b } ^ - name: elements type: node[] kind: - AssocNode - AssocSplatNode comment: | The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s. { a: b } ^^^^ { **foo } ^^^^^ - name: closing_loc type: location comment: | The location of the closing brace. { a => b } ^ comment: | Represents a hash literal. { a => b } ^^^^^^^^^^ - name: HashPatternNode fields: - name: constant type: node? kind: - ConstantPathNode - ConstantReadNode comment: | Represents the optional constant preceding the Hash. foo => Bar[a: 1, b: 2] ^^^ foo => Bar::Baz[a: 1, b: 2] ^^^^^^^^ - name: elements type: node[] kind: AssocNode comment: | Represents the explicit named hash keys and values. foo => { a: 1, b:, ** } ^^^^^^^^ - name: rest type: node? kind: - AssocSplatNode - NoKeywordsParameterNode comment: | Represents the rest of the Hash keys and values. This can be named, unnamed, or explicitly forbidden via `**nil`, this last one results in a `NoKeywordsParameterNode`. foo => { a: 1, b:, **c } ^^^ foo => { a: 1, b:, ** } ^^ foo => { a: 1, b:, **nil } ^^^^^ - name: opening_loc type: location? comment: | The location of the opening brace. foo => { a: 1 } ^ foo => Bar[a: 1] ^ - name: closing_loc type: location? comment: | The location of the closing brace. foo => { a: 1 } ^ foo => Bar[a: 1] ^ comment: | Represents a hash pattern in pattern matching. foo => { a: 1, b: 2 } ^^^^^^^^^^^^^^ foo => { a: 1, b: 2, **c } ^^^^^^^^^^^^^^^^^^^ foo => Bar[a: 1, b: 2] ^^^^^^^^^^^^^^^ foo in { a: 1, b: 2 } ^^^^^^^^^^^^^^ - name: IfNode fields: - name: if_keyword_loc type: location? comment: | The location of the `if` keyword if present. bar if foo ^^ The `if_keyword_loc` field will be `nil` when the `IfNode` represents a ternary expression. - name: predicate type: node kind: non-void expression comment: | The node for the condition the `IfNode` is testing. if foo ^^^ bar end bar if foo ^^^ foo ? bar : baz ^^^ - name: then_keyword_loc type: location? comment: | The location of the `then` keyword (if present) or the `?` in a ternary expression, `nil` otherwise. if foo then bar end ^^^^ a ? b : c ^ - name: statements type: node? kind: StatementsNode comment: | Represents the body of statements that will be executed when the predicate is evaluated as truthy. Will be `nil` when no body is provided. if foo bar ^^^ baz ^^^ end - name: subsequent type: node? kind: - ElseNode - IfNode comment: | Represents an `ElseNode` or an `IfNode` when there is an `else` or an `elsif` in the `if` statement. if foo bar elsif baz ^^^^^^^^^ qux ^^^ end ^^^ if foo then bar else baz end ^^^^^^^^^^^^ - name: end_keyword_loc type: location? comment: | The location of the `end` keyword if present, `nil` otherwise. if foo bar end ^^^ newline: predicate comment: | Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression. bar if foo ^^^^^^^^^^ if foo then bar end ^^^^^^^^^^^^^^^^^^^ foo ? bar : baz ^^^^^^^^^^^^^^^ - name: ImaginaryNode fields: - name: numeric type: node kind: - FloatNode - IntegerNode - RationalNode comment: | Represents an imaginary number literal. 1.0i ^^^^ - name: ImplicitNode fields: - name: value type: node kind: - LocalVariableReadNode - CallNode - ConstantReadNode - LocalVariableTargetNode comment: | Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source. { foo: } ^^^^ { Foo: } ^^^^ foo in { bar: } ^^^^ - name: ImplicitRestNode comment: | Represents using a trailing comma to indicate an implicit rest parameter. foo { |bar,| } ^ foo in [bar,] ^ for foo, in bar do end ^ foo, = bar ^ - name: InNode fields: - name: pattern type: node kind: pattern expression - name: statements type: node? kind: StatementsNode - name: in_loc type: location - name: then_loc type: location? comment: | Represents the use of the `in` keyword in a case statement. case a; in b then c end ^^^^^^^^^^^ - name: IndexAndWriteNode flags: CallNodeFlags fields: - name: receiver type: node? kind: non-void expression - name: call_operator_loc type: location? - name: opening_loc type: location - name: arguments type: node? kind: ArgumentsNode - name: closing_loc type: location - name: block type: node? kind: BlockArgumentNode # foo[&b] &&= value, only valid on Ruby < 3.4 - name: operator_loc type: location - name: value type: node kind: non-void expression comment: | Represents the use of the `&&=` operator on a call to the `[]` method. foo.bar[baz] &&= value ^^^^^^^^^^^^^^^^^^^^^^ - name: IndexOperatorWriteNode flags: CallNodeFlags fields: - name: receiver type: node? kind: non-void expression - name: call_operator_loc type: location? - name: opening_loc type: location - name: arguments type: node? kind: ArgumentsNode - name: closing_loc type: location - name: block type: node? kind: BlockArgumentNode # foo[&b] += value, only valid on Ruby < 3.4 - name: binary_operator type: constant - name: binary_operator_loc type: location - name: value type: node kind: non-void expression comment: | Represents the use of an assignment operator on a call to `[]`. foo.bar[baz] += value ^^^^^^^^^^^^^^^^^^^^^ - name: IndexOrWriteNode flags: CallNodeFlags fields: - name: receiver type: node? kind: non-void expression - name: call_operator_loc type: location? - name: opening_loc type: location - name: arguments type: node? kind: ArgumentsNode - name: closing_loc type: location - name: block type: node? kind: BlockArgumentNode # foo[&b] ||= value, only valid on Ruby < 3.4 - name: operator_loc type: location - name: value type: node kind: non-void expression comment: | Represents the use of the `||=` operator on a call to `[]`. foo.bar[baz] ||= value ^^^^^^^^^^^^^^^^^^^^^^ - name: IndexTargetNode flags: CallNodeFlags fields: - name: receiver type: node kind: non-void expression - name: opening_loc type: location - name: arguments type: node? kind: ArgumentsNode - name: closing_loc type: location - name: block type: node? kind: BlockArgumentNode # foo[&b], = 1, only valid on Ruby < 3.4 comment: | Represents assigning to an index. foo[bar], = 1 ^^^^^^^^ begin rescue => foo[bar] ^^^^^^^^ end for foo[bar] in baz do end ^^^^^^^^ - name: InstanceVariableAndWriteNode fields: - name: name type: constant - name: name_loc type: location - name: operator_loc type: location - name: value type: node kind: non-void expression comment: | Represents the use of the `&&=` operator for assignment to an instance variable. @target &&= value ^^^^^^^^^^^^^^^^^ - name: InstanceVariableOperatorWriteNode fields: - name: name type: constant - name: name_loc type: location - name: binary_operator_loc type: location - name: value type: node kind: non-void expression - name: binary_operator type: constant comment: | Represents assigning to an instance variable using an operator that isn't `=`. @target += value ^^^^^^^^^^^^^^^^ - name: InstanceVariableOrWriteNode fields: - name: name type: constant - name: name_loc type: location - name: operator_loc type: location - name: value type: node kind: non-void expression comment: | Represents the use of the `||=` operator for assignment to an instance variable. @target ||= value ^^^^^^^^^^^^^^^^^ - name: InstanceVariableReadNode fields: - name: name type: constant comment: | The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers). @x # name `:@x` @_test # name `:@_test` comment: | Represents referencing an instance variable. @foo ^^^^ - name: InstanceVariableTargetNode fields: - name: name type: constant comment: | Represents writing to an instance variable in a context that doesn't have an explicit value. @foo, @bar = baz ^^^^ ^^^^ - name: InstanceVariableWriteNode fields: - name: name type: constant comment: | The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers). @x = :y # name `:@x` @_foo = "bar" # name `@_foo` - name: name_loc type: location comment: | The location of the variable name. @_x = 1 ^^^ - name: value type: node kind: non-void expression comment: | The value to write to the instance variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @foo = :bar ^^^^ @_x = 1234 ^^^^ - name: operator_loc type: location comment: | The location of the `=` operator. @x = y ^ comment: | Represents writing to an instance variable. @foo = 1 ^^^^^^^^ - name: IntegerNode flags: IntegerBaseFlags fields: - name: value type: integer comment: The value of the integer literal as a number. comment: | Represents an integer number literal. 1 ^ - name: InterpolatedMatchLastLineNode flags: RegularExpressionFlags fields: - name: opening_loc type: location - name: parts type: node[] kind: - StringNode - EmbeddedStatementsNode - EmbeddedVariableNode - name: closing_loc type: location newline: parts comment: | Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object. if /foo #{bar} baz/ then end ^^^^^^^^^^^^^^^^ - name: InterpolatedRegularExpressionNode flags: RegularExpressionFlags fields: - name: opening_loc type: location - name: parts type: node[] kind: - StringNode - EmbeddedStatementsNode - EmbeddedVariableNode - name: closing_loc type: location newline: parts comment: | Represents a regular expression literal that contains interpolation. /foo #{bar} baz/ ^^^^^^^^^^^^^^^^ - name: InterpolatedStringNode flags: InterpolatedStringNodeFlags fields: - name: opening_loc type: location? - name: parts type: node[] kind: - StringNode - EmbeddedStatementsNode - EmbeddedVariableNode - InterpolatedStringNode # `"a" "#{b}"` - on error: XStringNode # `<<`FOO` "bar" - name: closing_loc type: location? newline: parts comment: | Represents a string literal that contains interpolation. "foo #{bar} baz" ^^^^^^^^^^^^^^^^ - name: InterpolatedSymbolNode fields: - name: opening_loc type: location? - name: parts type: node[] kind: - StringNode - EmbeddedStatementsNode - EmbeddedVariableNode - name: closing_loc type: location? newline: parts comment: | Represents a symbol literal that contains interpolation. :"foo #{bar} baz" ^^^^^^^^^^^^^^^^^ - name: InterpolatedXStringNode fields: - name: opening_loc type: location - name: parts type: node[] kind: - StringNode - EmbeddedStatementsNode - EmbeddedVariableNode - name: closing_loc type: location newline: parts comment: | Represents an xstring literal that contains interpolation. `foo #{bar} baz` ^^^^^^^^^^^^^^^^ - name: ItLocalVariableReadNode comment: | Represents reading from the implicit `it` local variable. -> { it } ^^ - name: ItParametersNode comment: | Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda. -> { it + it } ^^^^^^^^^^^^^^ - name: KeywordHashNode flags: KeywordHashNodeFlags fields: - name: elements type: node[] kind: - AssocNode - AssocSplatNode comment: | Represents a hash literal without opening and closing braces. foo(a: b) ^^^^ - name: KeywordRestParameterNode flags: ParameterFlags fields: - name: name type: constant? - name: name_loc type: location? - name: operator_loc type: location comment: | Represents a keyword rest parameter to a method, block, or lambda definition. def a(**b) ^^^ end - name: LambdaNode fields: - name: locals type: constant[] - name: operator_loc type: location - name: opening_loc type: location - name: closing_loc type: location - name: parameters type: node? kind: - BlockParametersNode - NumberedParametersNode - ItParametersNode - name: body type: node? kind: - StatementsNode - BeginNode comment: | Represents using a lambda literal (not the lambda method call). ->(value) { value * 2 } ^^^^^^^^^^^^^^^^^^^^^^^ - name: LocalVariableAndWriteNode fields: - name: name_loc type: location - name: operator_loc type: location - name: value type: node kind: non-void expression - name: name type: constant - name: depth type: uint32 comment: | Represents the use of the `&&=` operator for assignment to a local variable. target &&= value ^^^^^^^^^^^^^^^^ - name: LocalVariableOperatorWriteNode fields: - name: name_loc type: location - name: binary_operator_loc type: location - name: value type: node kind: non-void expression - name: name type: constant - name: binary_operator type: constant - name: depth type: uint32 comment: | Represents assigning to a local variable using an operator that isn't `=`. target += value ^^^^^^^^^^^^^^^ - name: LocalVariableOrWriteNode fields: - name: name_loc type: location - name: operator_loc type: location - name: value type: node kind: non-void expression - name: name type: constant - name: depth type: uint32 comment: | Represents the use of the `||=` operator for assignment to a local variable. target ||= value ^^^^^^^^^^^^^^^^ - name: LocalVariableReadNode fields: - name: name type: constant comment: | The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers). x # name `:x` _Test # name `:_Test` Note that this can also be an underscore followed by a number for the default block parameters. _1 # name `:_1` - name: depth type: uint32 comment: | The number of visible scopes that should be searched to find the origin of this local variable. foo = 1; foo # depth 0 bar = 2; tap { bar } # depth 1 The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md). comment: | Represents reading a local variable. Note that this requires that a local variable of the same name has already been written to in the same scope, otherwise it is parsed as a method call. foo ^^^ - name: LocalVariableTargetNode fields: - name: name type: constant - name: depth type: uint32 comment: | Represents writing to a local variable in a context that doesn't have an explicit value. foo, bar = baz ^^^ ^^^ foo => baz ^^^ - name: LocalVariableWriteNode fields: - name: name type: constant comment: | The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers). foo = :bar # name `:foo` abc = 123 # name `:abc` - name: depth type: uint32 comment: | The number of semantic scopes we have to traverse to find the declaration of this variable. foo = 1 # depth 0 tap { foo = 1 } # depth 1 The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md). - name: name_loc type: location comment: | The location of the variable name. foo = :bar ^^^ - name: value type: node kind: non-void expression comment: | The value to write to the local variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). foo = :bar ^^^^ abc = 1234 ^^^^ Note that since the name of a local variable is known before the value is parsed, it is valid for a local variable to appear within the value of its own write. foo = foo - name: operator_loc type: location comment: | The location of the `=` operator. x = :y ^ comment: | Represents writing to a local variable. foo = 1 ^^^^^^^ - name: MatchLastLineNode flags: RegularExpressionFlags fields: - name: opening_loc type: location - name: content_loc type: location - name: closing_loc type: location - name: unescaped type: string comment: | Represents a regular expression literal used in the predicate of a conditional to implicitly match against the last line read by an IO object. if /foo/i then end ^^^^^^ - name: MatchPredicateNode fields: - name: value type: node kind: non-void expression - name: pattern type: node kind: pattern expression - name: operator_loc type: location comment: | Represents the use of the modifier `in` operator. foo in bar ^^^^^^^^^^ - name: MatchRequiredNode fields: - name: value type: node kind: non-void expression comment: | Represents the left-hand side of the operator. foo => bar ^^^ - name: pattern type: node kind: pattern expression comment: | Represents the right-hand side of the operator. The type of the node depends on the expression. Anything that looks like a local variable name (including `_`) will result in a `LocalVariableTargetNode`. foo => a # This is equivalent to writing `a = foo` ^ Using an explicit `Array` or combining expressions with `,` will result in a `ArrayPatternNode`. This can be preceded by a constant. foo => [a] ^^^ foo => a, b ^^^^ foo => Bar[a, b] ^^^^^^^^^ If the array pattern contains at least two wildcard matches, a `FindPatternNode` is created instead. foo => *, 1, *a ^^^^^ Using an explicit `Hash` or a constant with square brackets and hash keys in the square brackets will result in a `HashPatternNode`. foo => { a: 1, b: } foo => Bar[a: 1, b:] foo => Bar[**] To use any variable that needs run time evaluation, pinning is required. This results in a `PinnedVariableNode` foo => ^a ^^ Similar, any expression can be used with pinning. This results in a `PinnedExpressionNode`. foo => ^(a + 1) Anything else will result in the regular node for that expression, for example a `ConstantReadNode`. foo => CONST - name: operator_loc type: location comment: | The location of the operator. foo => bar ^^ comment: | Represents the use of the `=>` operator. foo => bar ^^^^^^^^^^ - name: MatchWriteNode fields: - name: call type: node kind: CallNode - name: targets type: node[] kind: LocalVariableTargetNode comment: | Represents writing local variables using a regular expression match with named capture groups. /(?bar)/ =~ baz ^^^^^^^^^^^^^^^^^^^^ - name: MissingNode comment: | Represents a node that is missing from the source and results in a syntax error. - name: ModuleNode fields: - name: locals type: constant[] - name: module_keyword_loc type: location - name: constant_path type: node kind: - ConstantReadNode - ConstantPathNode - on error: MissingNode # module Parent module end - name: body type: node? kind: - StatementsNode - BeginNode - name: end_keyword_loc type: location - name: name type: constant comment: | Represents a module declaration involving the `module` keyword. module Foo end ^^^^^^^^^^^^^^ - name: MultiTargetNode fields: - name: lefts type: node[] kind: - LocalVariableTargetNode - InstanceVariableTargetNode - ClassVariableTargetNode - GlobalVariableTargetNode - ConstantTargetNode - ConstantPathTargetNode - CallTargetNode - IndexTargetNode - MultiTargetNode - RequiredParameterNode # def m((a,b)); end - on error: BackReferenceReadNode # a, (b, $&) = z - on error: NumberedReferenceReadNode # a, (b, $1) = z comment: | Represents the targets expressions before a splat node. a, (b, c, *) = 1, 2, 3, 4, 5 ^^^^ The splat node can be absent, in that case all target expressions are in the left field. a, (b, c) = 1, 2, 3, 4, 5 ^^^^ - name: rest type: node? kind: - ImplicitRestNode - SplatNode comment: | Represents a splat node in the target expression. a, (b, *c) = 1, 2, 3, 4 ^^ The variable can be empty, this results in a `SplatNode` with a `nil` expression field. a, (b, *) = 1, 2, 3, 4 ^ If the `*` is omitted, this field will contain an `ImplicitRestNode` a, (b,) = 1, 2, 3, 4 ^ - name: rights type: node[] kind: - LocalVariableTargetNode - InstanceVariableTargetNode - ClassVariableTargetNode - GlobalVariableTargetNode - ConstantTargetNode - ConstantPathTargetNode - CallTargetNode - IndexTargetNode - MultiTargetNode - RequiredParameterNode # def m((*,b)); end - on error: BackReferenceReadNode # a, (*, $&) = z - on error: NumberedReferenceReadNode # a, (*, $1) = z comment: | Represents the targets expressions after a splat node. a, (*, b, c) = 1, 2, 3, 4, 5 ^^^^ - name: lparen_loc type: location? comment: | The location of the opening parenthesis. a, (b, c) = 1, 2, 3 ^ - name: rparen_loc type: location? comment: | The location of the closing parenthesis. a, (b, c) = 1, 2, 3 ^ comment: | Represents a multi-target expression. a, (b, c) = 1, 2, 3 ^^^^^^ This can be a part of `MultiWriteNode` as above, or the target of a `for` loop for a, b in [[1, 2], [3, 4]] ^^^^ - name: MultiWriteNode fields: - name: lefts type: node[] kind: - LocalVariableTargetNode - InstanceVariableTargetNode - ClassVariableTargetNode - GlobalVariableTargetNode - ConstantTargetNode - ConstantPathTargetNode - CallTargetNode - IndexTargetNode - MultiTargetNode - on error: BackReferenceReadNode # $&, = z - on error: NumberedReferenceReadNode # $1, = z comment: | Represents the targets expressions before a splat node. a, b, * = 1, 2, 3, 4, 5 ^^^^ The splat node can be absent, in that case all target expressions are in the left field. a, b, c = 1, 2, 3, 4, 5 ^^^^^^^ - name: rest type: node? kind: - ImplicitRestNode - SplatNode comment: | Represents a splat node in the target expression. a, b, *c = 1, 2, 3, 4 ^^ The variable can be empty, this results in a `SplatNode` with a `nil` expression field. a, b, * = 1, 2, 3, 4 ^ If the `*` is omitted, this field will contain an `ImplicitRestNode` a, b, = 1, 2, 3, 4 ^ - name: rights type: node[] kind: - LocalVariableTargetNode - InstanceVariableTargetNode - ClassVariableTargetNode - GlobalVariableTargetNode - ConstantTargetNode - ConstantPathTargetNode - CallTargetNode - IndexTargetNode - MultiTargetNode - on error: BackReferenceReadNode # *, $& = z - on error: NumberedReferenceReadNode # *, $1 = z comment: | Represents the targets expressions after a splat node. a, *, b, c = 1, 2, 3, 4, 5 ^^^^ - name: lparen_loc type: location? comment: | The location of the opening parenthesis. (a, b, c) = 1, 2, 3 ^ - name: rparen_loc type: location? comment: | The location of the closing parenthesis. (a, b, c) = 1, 2, 3 ^ - name: operator_loc type: location comment: | The location of the operator. a, b, c = 1, 2, 3 ^ - name: value type: node kind: non-void expression comment: | The value to write to the targets. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). a, b, c = 1, 2, 3 ^^^^^^^ comment: | Represents a write to a multi-target expression. a, b, c = 1, 2, 3 ^^^^^^^^^^^^^^^^^ - name: NextNode fields: - name: arguments type: node? kind: ArgumentsNode - name: keyword_loc type: location comment: | Represents the use of the `next` keyword. next 1 ^^^^^^ - name: NilNode comment: | Represents the use of the `nil` keyword. nil ^^^ - name: NoKeywordsParameterNode fields: - name: operator_loc type: location - name: keyword_loc type: location comment: | Represents the use of `**nil` inside method arguments. def a(**nil) ^^^^^ end - name: NumberedParametersNode fields: - name: maximum type: uint8 comment: | Represents an implicit set of parameters through the use of numbered parameters within a block or lambda. -> { _1 + _2 } ^^^^^^^^^^^^^^ - name: NumberedReferenceReadNode fields: - name: number type: uint32 comment: | The (1-indexed, from the left) number of the capture group. Numbered references that are too large result in this value being `0`. $1 # number `1` $5432 # number `5432` $4294967296 # number `0` comment: | Represents reading a numbered reference to a capture in the previous match. $1 ^^ - name: OptionalKeywordParameterNode flags: ParameterFlags fields: - name: name type: constant - name: name_loc type: location - name: value type: node kind: non-void expression comment: | Represents an optional keyword parameter to a method, block, or lambda definition. def a(b: 1) ^^^^ end - name: OptionalParameterNode flags: ParameterFlags fields: - name: name type: constant - name: name_loc type: location - name: operator_loc type: location - name: value type: node kind: non-void expression comment: | Represents an optional parameter to a method, block, or lambda definition. def a(b = 1) ^^^^^ end - name: OrNode fields: - name: left type: node kind: non-void expression comment: | Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). left or right ^^^^ 1 || 2 ^ - name: right type: node kind: Node comment: | Represents the right side of the expression. left || right ^^^^^ 1 or 2 ^ - name: operator_loc type: location comment: | The location of the `or` keyword or the `||` operator. left or right ^^ comment: | Represents the use of the `||` operator or the `or` keyword. left or right ^^^^^^^^^^^^^ - name: ParametersNode fields: - name: requireds type: node[] kind: - RequiredParameterNode - MultiTargetNode - name: optionals type: node[] kind: OptionalParameterNode - name: rest type: node? kind: - RestParameterNode - ImplicitRestNode # Only in block parameters - name: posts type: node[] kind: - RequiredParameterNode - MultiTargetNode # On parsing error of `f(**kwargs, ...)` or `f(**nil, ...)`, the keyword_rest value is moved here: - on error: KeywordRestParameterNode - on error: NoKeywordsParameterNode # On parsing error of `f(..., ...)`, the first forwarding parameter is moved here: - on error: ForwardingParameterNode - name: keywords type: node[] kind: - RequiredKeywordParameterNode - OptionalKeywordParameterNode - name: keyword_rest type: node? kind: - KeywordRestParameterNode - ForwardingParameterNode - NoKeywordsParameterNode - name: block type: node? kind: BlockParameterNode comment: | Represents the list of parameters on a method, block, or lambda definition. def a(b, c, d) ^^^^^^^ end - name: ParenthesesNode flags: ParenthesesNodeFlags fields: - name: body type: node? kind: non-void expression # Usually a StatementsNode but not always e.g. `1 in (..10)` - name: opening_loc type: location - name: closing_loc type: location newline: false comment: | Represents a parenthesized expression (10 + 34) ^^^^^^^^^ - name: PinnedExpressionNode fields: - name: expression type: node kind: non-void expression comment: | The expression used in the pinned expression foo in ^(bar) ^^^ - name: operator_loc type: location comment: | The location of the `^` operator foo in ^(bar) ^ - name: lparen_loc type: location comment: | The location of the opening parenthesis. foo in ^(bar) ^ - name: rparen_loc type: location comment: | The location of the closing parenthesis. foo in ^(bar) ^ comment: | Represents the use of the `^` operator for pinning an expression in a pattern matching expression. foo in ^(bar) ^^^^^^ - name: PinnedVariableNode fields: - name: variable type: node kind: - LocalVariableReadNode - InstanceVariableReadNode - ClassVariableReadNode - GlobalVariableReadNode # foo in ^$a - BackReferenceReadNode # foo in ^$& - NumberedReferenceReadNode # foo in ^$1 - ItLocalVariableReadNode # proc { 1 in ^it } - on error: MissingNode # foo in ^Bar comment: | The variable used in the pinned expression foo in ^bar ^^^ - name: operator_loc type: location comment: | The location of the `^` operator foo in ^bar ^ comment: | Represents the use of the `^` operator for pinning a variable in a pattern matching expression. foo in ^bar ^^^^ - name: PostExecutionNode fields: - name: statements type: node? kind: StatementsNode - name: keyword_loc type: location - name: opening_loc type: location - name: closing_loc type: location comment: | Represents the use of the `END` keyword. END { foo } ^^^^^^^^^^^ - name: PreExecutionNode fields: - name: statements type: node? kind: StatementsNode - name: keyword_loc type: location - name: opening_loc type: location - name: closing_loc type: location comment: | Represents the use of the `BEGIN` keyword. BEGIN { foo } ^^^^^^^^^^^^^ - name: ProgramNode fields: - name: locals type: constant[] - name: statements type: node kind: StatementsNode comment: The top level node of any parse tree. - name: RangeNode flags: RangeFlags fields: - name: left type: node? kind: non-void expression comment: | The left-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). 1... ^ hello...goodbye ^^^^^ - name: right type: node? kind: non-void expression comment: | The right-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). ..5 ^ 1...foo ^^^ If neither right-hand or left-hand side was included, this will be a MissingNode. - name: operator_loc type: location comment: | The location of the `..` or `...` operator. comment: | Represents the use of the `..` or `...` operators. 1..2 ^^^^ c if a =~ /left/ ... b =~ /right/ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - name: RationalNode flags: IntegerBaseFlags fields: - name: numerator type: integer comment: | The numerator of the rational number. 1.5r # numerator 3 - name: denominator type: integer comment: | The denominator of the rational number. 1.5r # denominator 2 comment: | Represents a rational number literal. 1.0r ^^^^ - name: RedoNode comment: | Represents the use of the `redo` keyword. redo ^^^^ - name: RegularExpressionNode flags: RegularExpressionFlags fields: - name: opening_loc type: location - name: content_loc type: location - name: closing_loc type: location - name: unescaped type: string comment: | Represents a regular expression literal with no interpolation. /foo/i ^^^^^^ - name: RequiredKeywordParameterNode flags: ParameterFlags fields: - name: name type: constant - name: name_loc type: location comment: | Represents a required keyword parameter to a method, block, or lambda definition. def a(b: ) ^^ end - name: RequiredParameterNode flags: ParameterFlags fields: - name: name type: constant comment: | Represents a required parameter to a method, block, or lambda definition. def a(b) ^ end - name: RescueModifierNode fields: - name: expression type: node kind: Node - name: keyword_loc type: location - name: rescue_expression type: node kind: Node newline: expression comment: | Represents an expression modified with a rescue. foo rescue nil ^^^^^^^^^^^^^^ - name: RescueNode fields: - name: keyword_loc type: location - name: exceptions type: node[] kind: non-void expression - name: operator_loc type: location? - name: reference type: node? kind: - LocalVariableTargetNode - InstanceVariableTargetNode - ClassVariableTargetNode - GlobalVariableTargetNode - ConstantTargetNode - ConstantPathTargetNode - CallTargetNode - IndexTargetNode - on error: BackReferenceReadNode # => begin; rescue => $&; end - on error: NumberedReferenceReadNode # => begin; rescue => $1; end - on error: MissingNode # begin; rescue =>; end - name: then_keyword_loc type: location? - name: statements type: node? kind: StatementsNode - name: subsequent type: node? kind: RescueNode comment: | Represents a rescue statement. begin rescue Foo, *splat, Bar => ex foo ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ end `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `reference` field. - name: RestParameterNode flags: ParameterFlags fields: - name: name type: constant? - name: name_loc type: location? - name: operator_loc type: location comment: | Represents a rest parameter to a method, block, or lambda definition. def a(*b) ^^ end - name: RetryNode comment: | Represents the use of the `retry` keyword. retry ^^^^^ - name: ReturnNode fields: - name: keyword_loc type: location - name: arguments type: node? kind: ArgumentsNode comment: | Represents the use of the `return` keyword. return 1 ^^^^^^^^ - name: SelfNode comment: | Represents the `self` keyword. self ^^^^ - name: ShareableConstantNode flags: ShareableConstantNodeFlags fields: - name: write type: node kind: - ConstantWriteNode - ConstantAndWriteNode - ConstantOrWriteNode - ConstantOperatorWriteNode - ConstantPathWriteNode - ConstantPathAndWriteNode - ConstantPathOrWriteNode - ConstantPathOperatorWriteNode comment: The constant write that should be modified with the shareability state. comment: | This node wraps a constant write to indicate that when the value is written, it should have its shareability state modified. # shareable_constant_value: literal C = { a: 1 } ^^^^^^^^^^^^ - name: SingletonClassNode fields: - name: locals type: constant[] - name: class_keyword_loc type: location - name: operator_loc type: location - name: expression type: node kind: non-void expression - name: body type: node? kind: - StatementsNode - BeginNode - name: end_keyword_loc type: location comment: | Represents a singleton class declaration involving the `class` keyword. class << self end ^^^^^^^^^^^^^^^^^ - name: SourceEncodingNode comment: | Represents the use of the `__ENCODING__` keyword. __ENCODING__ ^^^^^^^^^^^^ - name: SourceFileNode flags: StringFlags fields: - name: filepath type: string comment: Represents the file path being parsed. This corresponds directly to the `filepath` option given to the various `Prism::parse*` APIs. comment: | Represents the use of the `__FILE__` keyword. __FILE__ ^^^^^^^^ - name: SourceLineNode comment: | Represents the use of the `__LINE__` keyword. __LINE__ ^^^^^^^^ - name: SplatNode fields: - name: operator_loc type: location - name: expression type: node? kind: non-void expression comment: | Represents the use of the splat operator. [*a] ^^ - name: StatementsNode fields: - name: body type: node[] kind: Node comment: | Represents a set of statements contained within some scope. foo; bar; baz ^^^^^^^^^^^^^ - name: StringNode flags: StringFlags fields: - name: opening_loc type: location? - name: content_loc type: location - name: closing_loc type: location? - name: unescaped type: string comment: | Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string. "foo" ^^^^^ %w[foo] ^^^ "foo #{bar} baz" ^^^^ ^^^^ - name: SuperNode fields: - name: keyword_loc type: location - name: lparen_loc type: location? - name: arguments type: node? kind: ArgumentsNode - name: rparen_loc type: location? - name: block type: node? kind: - BlockNode - BlockArgumentNode comment: | Represents the use of the `super` keyword with parentheses or arguments. super() ^^^^^^^ super foo, bar ^^^^^^^^^^^^^^ - name: SymbolNode flags: SymbolFlags fields: - name: opening_loc type: location? - name: value_loc type: location? - name: closing_loc type: location? - name: unescaped type: string comment: | Represents a symbol literal or a symbol contained within a `%i` list. :foo ^^^^ %i[foo] ^^^ - name: TrueNode comment: | Represents the use of the literal `true` keyword. true ^^^^ - name: UndefNode fields: - name: names type: node[] kind: - SymbolNode - InterpolatedSymbolNode - name: keyword_loc type: location comment: | Represents the use of the `undef` keyword. undef :foo, :bar, :baz ^^^^^^^^^^^^^^^^^^^^^^ - name: UnlessNode fields: - name: keyword_loc type: location comment: | The location of the `unless` keyword. unless cond then bar end ^^^^^^ bar unless cond ^^^^^^ - name: predicate type: node kind: non-void expression comment: | The condition to be evaluated for the unless expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). unless cond then bar end ^^^^ bar unless cond ^^^^ - name: then_keyword_loc type: location? comment: | The location of the `then` keyword, if present. unless cond then bar end ^^^^ - name: statements type: node? kind: StatementsNode comment: | The body of statements that will executed if the unless condition is falsey. Will be `nil` if no body is provided. unless cond then bar end ^^^ - name: else_clause type: node? kind: ElseNode comment: | The else clause of the unless expression, if present. unless cond then bar else baz end ^^^^^^^^ - name: end_keyword_loc type: location? comment: | The location of the `end` keyword, if present. unless cond then bar end ^^^ newline: predicate comment: | Represents the use of the `unless` keyword, either in the block form or the modifier form. bar unless foo ^^^^^^^^^^^^^^ unless foo then bar end ^^^^^^^^^^^^^^^^^^^^^^^ - name: UntilNode flags: LoopFlags fields: - name: keyword_loc type: location - name: do_keyword_loc type: location? - name: closing_loc type: location? - name: predicate type: node kind: non-void expression - name: statements type: node? kind: StatementsNode newline: predicate comment: | Represents the use of the `until` keyword, either in the block form or the modifier form. bar until foo ^^^^^^^^^^^^^ until foo do bar end ^^^^^^^^^^^^^^^^^^^^ - name: WhenNode fields: - name: keyword_loc type: location - name: conditions type: node[] kind: non-void expression - name: then_keyword_loc type: location? - name: statements type: node? kind: StatementsNode comment: | Represents the use of the `when` keyword within a case statement. case true when true ^^^^^^^^^ end - name: WhileNode flags: LoopFlags fields: - name: keyword_loc type: location - name: do_keyword_loc type: location? - name: closing_loc type: location? - name: predicate type: node kind: non-void expression - name: statements type: node? kind: StatementsNode newline: predicate comment: | Represents the use of the `while` keyword, either in the block form or the modifier form. bar while foo ^^^^^^^^^^^^^ while foo do bar end ^^^^^^^^^^^^^^^^^^^^ - name: XStringNode flags: EncodingFlags fields: - name: opening_loc type: location - name: content_loc type: location - name: closing_loc type: location - name: unescaped type: string comment: | Represents an xstring literal with no interpolation. `foo` ^^^^^ - name: YieldNode fields: - name: keyword_loc type: location - name: lparen_loc type: location? - name: arguments type: node? kind: ArgumentsNode - name: rparen_loc type: location? comment: | Represents the use of the `yield` keyword. yield 1 ^^^^^^^ prism-1.5.1/cpp/000077500000000000000000000000001506127434000134345ustar00rootroot00000000000000prism-1.5.1/cpp/test.cpp000066400000000000000000000007611506127434000151230ustar00rootroot00000000000000extern "C" { #include "prism.h" } #include int main() { pm_parser_t parser; pm_parser_init(&parser, reinterpret_cast("1 + 2"), 5, NULL); pm_node_t *root = pm_parse(&parser); pm_buffer_t buffer = { 0 }; pm_prettyprint(&buffer, &parser, root); pm_buffer_append_byte(&buffer, '\0'); std::cout << buffer.value << std::endl; pm_buffer_free(&buffer); pm_node_destroy(&parser, root); pm_parser_free(&parser); return 0; } prism-1.5.1/doc/000077500000000000000000000000001506127434000134175ustar00rootroot00000000000000prism-1.5.1/doc/favicon.ico000066400000000000000000000202341506127434000155410ustar00rootroot00000000000000  (& (N( @ R ‹¬ ‡Ø ç©å¡Ú œÌ ”¾‘® ŽžŽ’| j ’Y“I •:‘,œ ¡ Ÿª ”¥ šÿ •ÿ ‹ÿœÿ®ÿ¬ÿ ©ÿ¥ÿ  ÿ œÿ™ÿ ™ÿ ™ÿ”ÿ‘ÿÿ‰ÿ‡ùˆï†ã‹ÖŽÈ –¹ž© ¬™+-ʼn<9Ýx'§ ›‚ ¨ÿ ”ÿ ‘ÿ ‘ÿ¨ÿ ¨ÿ¦ÿ¢ÿÿ˜ÿ•ÿ‘ÿÿ Œÿ ›ÿ¡ÿ¤ÿ«ÿ´ÿ½ÿÆÿ$ Ñÿ)$Üÿ/'æÿ4-îÿ?6úÿC<úÿ)Äÿ$©M ¡ šò  ÿ šÿ –ÿ £ÿ·ÿ ²ÿ§ÿ¢ÿ žÿ™ÿ•ÿ’ÿÿ‚ÿÿ °ÿÀÿÁÿÆÿ Ëÿ$Ðÿ'Ôÿ)!Øÿ,#Üÿ2'æÿ/'ßÿ –ÿ–ÿ82à[ œM ¦ÿ Ÿÿ Ÿÿ ÿºÿÂÿÀÿ ®ÿ¢ÿ Ÿÿšÿ–ÿ“ÿÿ†ÿÿ‚ÿ ÿ¶ÿºÿ¾ÿÃÿÇÿ"Ìÿ(×ÿ$Ìÿ‘ÿ{ÿ¬ÿ:.ïn œt §ÿ ¢ÿ  ÿ¬ÿ%*Ïÿ#'Ëÿ"'Ìÿ¼ÿ£ÿ  ÿ›ÿ—ÿ“ÿÿŒÿŠÿ…ÿÿÿ °ÿ·ÿ¹ÿ¾ÿÈÿ»ÿ‹ÿ‚ÿÿµÿ5)í‚ ¤~ §ÿ£ÿ £ÿ#'Çÿ08Ýÿ+2Öÿ*1Öÿ'+Ðÿ¨ÿ¡ÿÿ˜ÿ•ÿ”ÿ‘ÿŽÿŠÿ‡ÿÿˆÿ ªÿ ´ÿ¹ÿ¬ÿˆÿ…ÿˆÿÿ¼ÿ."䕽p ­ÿ ¡ÿ°ÿFMßÿDLáÿ>Fßÿ:BÞÿ8AàÿµÿŸÿ žÿšÿ›ÿ˜ÿ•ÿ‘ÿÿ‰ÿ†ÿ}ÿ€ÿ ¤ÿ ¢ÿˆÿˆÿ‰ÿˆÿ‚ÿÀÿ(ק"Èb¿ÿÿ=<Êÿnvêÿ`gäÿ[bãÿW]âÿW`çÿ63Èÿ Ÿÿ Ÿÿžÿžÿšÿ–ÿ’ÿÿˆÿ…ÿ…þþ’ÿ†ÿ‹ÿŠÿ‰ÿ‰ÿ…ÿÀÿ!͹!,ÍV*Óÿ²ÿžêÿ¦ªñÿ•™íÿŠëÿ€†éÿ{ƒëÿbdÝÿ¤ÿ Ÿÿ›ÿšÿ—ÿ“ÿÿþ•þþ¤þ®ÿ‘ÿzÿŠÿ‹ÿŠÿˆÿ‰ÿ½ÿÁÊ*4ÒI%Ùÿ‚ˆäÿÿÿÿÿôôþÿîîýÿçèýÿÔÖúÿÀÃõÿ¶ºôÿ0%´ÿ•ÿ‘ÿ“ÿ—ÿœÿ¢ÿ§ÿªÿ©ÿ¨ÿ¨ÿŠÿ|ÿ~ÿ‹ÿ‹ÿˆÿŒÿ·ÿ·Ù€1>Þ>3=ãÿ×Úùÿ×Øôÿœ æÿ‚†àÿšžâÿØÙñÿÿÿÿÿÿÿÿÿwsËÿŒÿ Ÿÿ ¨ÿ®ÿ¯ÿ ¯ÿ ­ÿ ¬ÿ ¬ÿ ­ÿ §ÿ†ÿÿ}ÿ €ÿ‹ÿ‰ÿÿ ®ÿ ®ç¿ Šð2­²öÿ¿ÂðÿmrÚÿÎÿ3<Íÿ3<Ïÿ*3Äþ–þ’ÿÿŒÿ‡ÿ„ÿ€ÿŠÿ›ÿ ÿ™Fÿÿÿòòü²DJÈÿÿ‚ÿˆÿ’ÿ ˜ÿ ÿ¡ÿ£ÿ¥ÿ ¡ÿžÿ‰’Ôÿ§¬ðÿLVÛÿQZÛÿQZÛÿU^ßÿ6>Åý•ÿ–ÿ’ÿŽÿŒÿÿŠÿƒÿ“ÿ¤ÿšXÿÿÿ.nqÁüÿ…ÿ Žÿ —ÿ ÿ¡ÿ¦ÿ©ÿ©ÿ¨ÿ¥ÿŸÿ‚ŒÓÿÆÉøÿyèÿw€èÿˆíÿ29½ý—ÿ˜ÿ•ÿ—ÿ˜ÿ“ÿÿ„ÿ‡ÿ¦ÿ›k­­Õœ˜ÿˆÿ ‘ÿ ›ÿ¡ÿ¦ÿ©ÿªÿ«ÿ¬ÿ«ÿ¨ÿ¢ÿŽ—ØÿòòÿÿÂÆõÿÀÄôþ#*®ýšÿžÿ£ÿ¢ÿ›ÿ”ÿŽÿ‡ÿ€ÿŸÿÿÿÿU[µõ‹ÿ”ÿÿ¥ÿ©ÿªÿ¬ÿ­ÿ¯ÿ¯ÿ®ÿ ªÿ¦ÿ­´äÿÿÿÿÿ×Øïý šþ™ÿ¡ÿ¤ÿ ÿšÿ“ÿÿ‡ÿ~ÿ’ÿ’ÄÆä†,®ÿ“ÿŸÿ§ÿ©ÿ¬ÿ­ÿ¯ÿ¯ÿ°ÿ±ÿ°ÿ«ÿ ¯ÿæèøÿÄÄçþ™ÿŸÿ¡ÿ ÿžÿ™ÿ”ÿÿ†ÿ~ÿˆÿ—¥ÿÿÿ™ž×é  ÿŸÿ¦ÿªÿ­ÿ¯ÿ°ÿ±ÿ²ÿ³ÿ³ÿ±ÿªÿCPÆÿîîúÿ¸ÿ °ÿ¯ÿ­ÿ «ÿ ©ÿ §ÿ¤ÿ¢ÿ¤ÿ–ÿ„·ÿÿÿa|Šßÿœÿ£ÿªÿ­ÿ¯ÿ°ÿ²ÿ³ÿ´ÿ´ÿ´ÿ²ÿ­ÿª±çÿfnÓÿ ´ÿ ·ÿ µÿ ´ÿ²ÿ°ÿ¯ÿ²ÿ–ürÿtÈ÷÷ûxUcÍÿ¡ÿ¦ÿ¬ÿ¯ÿ±ÿ³ÿ´ÿµÿ¶ÿ¶ÿµÿ³ÿ2BÈÿ›¡åÿ¼ÿ¾ÿ½ÿ»ÿ¹ÿ ¹ÿ ¸þ–üpýqÿn×àãólIVÈÿ¦ÿ©ÿ®ÿ²ÿ³ÿ´ÿ¶ÿ·ÿ¸ÿ¹ÿºÿ ¼ÿˆ‘ãÿ8EÑÿ&Çÿ$Åÿ!Âÿ"Äÿ Àý ™û |þ |þzÿpåÜáò_O[Êÿ«ÿªÿ°ÿ³ÿµÿ¶ÿ¸ÿ»ÿ¼ÿ½ÿ½ÿWeÚÿ‘—ëÿ@LÚÿ9FÖÿ8EØÿ$1Çý œü‰þ†þ €þ €ÿwëóöùSkuÕú ±ÿªÿ±ÿ´ÿ·ÿºÿ½ÿ¾ÿ¾ÿÂÿ&9Òÿàáúÿ·¼ôÿ©¯öÿY_Ôû šü ”þ •þ þˆþ ˆÿ €ßÿÿÿIž¤çö%Àÿªÿ²ÿ·ÿ»ÿ½ÿ¾ÿÀÿÇÿ(Òÿõöþÿýýýþ˜šÒû ”ý “þ —þ –þ ‘þ ‡þ…ÿv·ÿÿÿ>Üâûågnßÿ Ãÿ¹ÿ¼ÿ¿ÿÂÿÇÿ Ìÿ0DÜÿÿÿÿÿ}ƒÐý™þ ¥ÿ¤ÿœÿ’ÿˆÿ~ÿ ÿ kVÿÿÿÿÿÿg¨®ê¿OXÔý.ÚÿÎÿÉÿÌÿÔÿ¢ªðÿ·¸íÿKPÓÿÀÿ ³ÿ«ÿ ÿ–ÿ‘ÿ ’ÿ|¥ÿÿÿ,ÁÅõƒ”™éØ‚Žñÿ“œûÿËÑÿÿÉÊÿÿ{îÿFKâÿ#ÙÿÑÿ Ãÿ´ÿ¥ÿ•æ‹}ÿÿÿÿÿÿNÿÿÿq÷ôü`›ì^djÞ^+4Ñ^É_Ç` Å`¸a¦HŸ(  Ÿ —šß ¡é  Þ ™ÑšÄ œµ ¡¥ ¤”©ƒ ­s"¹b,ÁR 4Ç@ Ÿ • ˜ÿ žÿ¬ÿ £ÿ ›ÿ ’ÿŽÿžÿ ¯ÿ·ÿÂÿ#Òÿ)Úÿ"®ÿ'7Þ. žá  ÿ»ÿÄÿ ¨ÿ œÿ –ÿ “ÿ ‘ÿ £ÿ ºÿÄÿÈÿœÿ’ÿ+á<£é ¯ÿ!;Ûÿ9Ýÿ¹ÿ œÿ ›ÿ ™ÿ ‘ÿ ‡ÿ ”ÿ ¬ÿ•ÿƒÿÿ!ÔM·ÞHWÎÿnŠíÿVvëÿ/DÏÿžÿ ÿ ˜ÿ “ÿ “ÿ ˜ÿŽÿŠÿ‰ÿ ÿÅ`0EÙÔÉÏôÿªµîÿµÁðÿ»Åóÿ§ÿÿ¤ÿ§ÿ«ÿ©ÿŠÿˆÿ‹ÿžÿ µr¨²ïËfrÜÿ'¹ÿ•ÿns·ÿyÑÿ¹ÿµÿµÿµÿªÿŒÿ‡ÿ‰ÿ˜ÿ¡…¸¿îÆ!¸ÿÿ …ÿŒÿ$2¨ÿUbÌÿ$5Êÿ$Ãÿ&Åÿ ªÿ ÿ‹ÿ‡ÿ•ÿš—ÄÉêz ÿ †ÿ“ÿžÿ¡ÿ ¨ÿXjÐÿWsãÿ?]Ýÿªÿ ”ÿ”ÿÿ ÿ›ªÿÿÿ1=ŸáŽÿžÿ¤ÿ§ÿ§ÿ «ÿœáÿ³Àðÿ¡ÿ Ÿÿ žÿ “ÿˆÿ•¼¸½âh šÿ£ÿ§ÿ©ÿ«ÿ¬ÿ'¶ÿ§«àÿ ¨ÿ ¦ÿ ¡ÿ šÿ‘ÿËÿÿÿxƒÏÀ¡ÿ©ÿ¬ÿ®ÿ°ÿ°ÿ?MÊÿ.=Çÿ¶ÿµÿ´ÿÿ Úÿÿÿaoʺ¦ÿ­ÿ°ÿ³ÿ¹ÿ Ãÿ@T×ÿ+Íÿ'Éÿ «ÿ ˆÿ }éÿÿÿ w‚Ó¯ ­ÿ ±ÿºÿÂÿÇÿzŠéÿ­îÿ)³ÿ šÿ “ÿ †åÿÿÿ°µè˜-:Äð ¿ÿ Çÿ Ïÿ—¡îÿciÉÿ¢ÿ™ÿ ‹ÿ|œ÷÷ÿ®µìnu€äÄŽé䃋âã'Éâ¼á¢Ù Œ’ˆprism-1.5.1/doc/images/000077500000000000000000000000001506127434000146645ustar00rootroot00000000000000prism-1.5.1/doc/images/c.svg000066400000000000000000000064551506127434000156410ustar00rootroot00000000000000 image/svg+xml prism-1.5.1/doc/images/java.png000066400000000000000000000510401506127434000163130ustar00rootroot00000000000000‰PNG  IHDRhhzåaÕsRGB®ÎéPeXIfMM*‡i&  h hI€KYiTXtXML:com.adobe.xmp 1 ^á@IDATxí|ŽÇÿ³§bYî¶l: ,É& \èð !†HB $$$1’))¥Û´GBò^€ $@h–-°)¡Û*€Á€ ¶%÷.énçýæÎÂ’|ºÛÝÛ«û›ÏgoÛÌf¾³÷¿¹ÙÿüG„H€H€H€H€H€H€H€H€H€H€H€H ëôĉÅ몪Æf½ , ÀÞZ«ª]}Ì1{ßáð—€å¯8J# °ÚBá𵈠BmYÇì ‚Î{朧´–¡›Ïh«®þVžVÅÎTÐyÒP,fîP!£ ´ü|õ„ ££Çü 4 ‚NTŠ,lC‡6¡†íØÊBa{va×–µË&*èlÒgÞyI@=ýt_-¼’‹ÖVUMÍËŠ°Ð9O€ :盈ÌQït•K‰úq×1÷$à'*h?iRV€¨·»Uö¸ÖñãOêvÎCð…´/)$h”Øö £u·õ AcÀú¦Ÿtú3‡$`kky¯jÝ:aÂá½®ñ”R"@>&*¥7÷ª»Rý™^×xJ) ‚N –@ÄÚÚ»îZ¨ {3áyj¨ SãÇÔ% Cö–8UÛ:n„8×y‰< ‚ö„‰O Ú«e¢ìigC¾ ‚ö %‰@ûÎf&á^A)™²×E^ ¨ =‚c²`(-++Gî&¶Ž7 Þ=^#·¨ Ýc|;î׈" …Žéã/“€+TЮp12 ÄÙE})hx¹Óãɉü @íEÊ;éSAc˜£2p@Xá´ ‚N V -tZë}úª#œ'Ü×=^'7¨ ÝÐb\ØM@kë ¾``ÂJŸ÷úJÃë$t<*¼FI(e'è%«>{×IÄò6 ô @ÝOHÀ`+Ét&…±H 1*èÄ|x—â€Nä¹®øÝÑ£û|‰W /’@TÐq ð $"ðÖ˜1f’JU¢8åååE‰îó 8!@í„ã@7û÷7‘âÎ$ìŠV!ÒÑuÌ= x%@í•Ó–€¥õ±I+ßÒÒ™4#@TÐIñ6 ô&€„Ç÷¾Öë|+ƨ1_…R#@?¦=mZÊ÷Ì$Õ^ä>o“€#TÐŽ01 Ä´½ñƉ8ž„ÇÚ$÷y› ‚v„‰‘H F@iu^2ÛX•,ï“€TÐN(1 €¯Âva2JôkÉâð> 8!@[M'”‡@ ­ªêdìMP‰r‚Ÿ*h>1¾`ÚŒZ}ÙI=-K·8‰Ç8$Œ^H3 $#°aâÄÁáŽÎ¯¸ZÖU47Ž¤™]BJ¼é{ÐA1Z° „;;¿‰•3"`ÑØ稜ƒý¬øY{*h?iRVAˆúÞÐRë¤r6´“xŒCNPA;¡Ä8&0¨_ùåp€J©z'ñ‡œà´JŒXzâÄⶎÎ7`t2ÞX1¢±ñq$#ÅûN °í”ã’@[{øk¨øh'•‡ôÃTÎNH1ŽSTÐNI1^à¬;v¸VºÎiÅUD=ä4.ã‘€TÐN(1N ”•ü=âa+¿jÄÑGÌw—ÑHÀ*hG˜)hÖVVV‹’+œÖ+yÿ^=ð@Äi|Æ#'¨ Pbœ@ЧVkŒÿE¥ºBÀð³Ü(H¬lFPAg33É'më×_)'ÉWMù°RzΨ¦¦w><å øD€ Ú'SÌÐVLù›Úh­g»‰Ï¸$à”Þ0 LœØ¿¨£ó?8L¸bwZJll<¦Ç5ž€O؃ö $Åä?¢ŽŽ_¡Ε3"£‡sSþל5ÈUTйÚ2,WF ´VU}êör—™¾=bØ°]¦atpL€CŽQ1b¡h7a‚X¶qr”Ô[]w˜Úý™ŠÆÆ¿v¿Æcð“´Ÿ4)+ï´Ž·¶B/â‹p«ÂcìÊy"ÒÙ®Ò12 ¸ À!°µ°¬<þø2e…r­œ–3¨œ ëyÈÅÚPAçb«°Li'€™%VéÖí÷aÿq™=»gºõŽIÜ ‚vÇ‹± „@[eõ-0Á¸ÈCuÚ1öü阄\p:•Õµ`& \%ÐZYý(ço{+ŸþIEcÓRoi™ŠÜ`Ú/ÆÎsmUUÓ¡œ¿ç±¯WØöLi™Œ\ ‚vŒ ò•l¿iÜ7{,?†«õ×TKK‡ÇôLF® PA»FÆùH=g¸Uw ì0¾p ØoÙÔ4ß}J¦ 蘒½³cÊ蓼Œ‹1“rúx’Rê|°¹‰ 6 ‡B5û.ZÔ–ñ1Cß °í;R ô“€QBåÝôyåF È.êÜy§œÍø»²¬ ´VŸÀ zËR68”Ñs>«½prJ¶EQAg»˜Ÿ`ß|^’ü hBŸ‘Ü߀:Ó_…"û‹û¤ÙI¾xãI–RŸ‡‘O ŒF6Çðcó£wà}†Ä°Ì'‡8 ¦) «"mãÆOÒ–þ+j5ÒÏš)Q5MKnñSf:dAñZmãÇŸwzÓ …?ƒ<*zåc›áŒÎââkö[¸p]¯{<-TÐÒ…R (&…ÕO®Å“_ã͆B»Ã·å2«Ž:æàPQøKø!¹å<0~YÕóbÉ7G.Y²(þ}^-TÐ…Ò’P¶#¨‹KïÆß÷‹|®Ž^è#›ÿÏg¹¾ˆëÂPbaY.ý íkèq=Øü?2Îð…|î ¡‚Îý6 D ñwþÛ¶ÿ‰žãÑ>WØXk|Ö÷ú,7eqQ;åˆþ2”ò!lT¦÷W‘eÝ0tñâM âñV ‚.°ÍÇê´UWŸ—_÷¡ìƒý,?†K: œ?;ª±ñï~ÊME–[ÆbçÚZ¾ƒ/ß$ÈJö|1¾‚˜©äË´ùI ÙÑŸµb©ó‚€ùk߶té1üp= ì÷³¸=ÓOÁ3Ýc¹ã­1cJõï ^ú]çð_BDî„YÆw÷ilÜž u`2OÀï/EækÀó’Àª±c‡—ÿzùŒ4T`#”Û¹Ðë\}Ì1¡pøK¨'¯•ýœÕŽ›tä+Íͯ8‹ÏX…J€ ºP[6‡ëÕ:n±절‡¤¡˜Ë-Ñghjz# ²‹\[Yy&”| ÿ¾‚Dý&Ü©•ÌY\üSµpa§Ã4ŒVÀ¨  ¸qs±j0¡ûœõ[”Í©ÒrSFËRçŒX²ä}7‰üŒ»vܸñPÌ7¢Ç|ä:wF¦¤A"‘+F¶´,ó³<”•ß¨ ó»ýò¦ôú´ÓŠÚÖoü Æ…¯KG¡ñ ×[;Ë.¾ìÅ-éŸL¦Yr«ãËxÙù9Äu®˜E6c8æFšÎ%#ÌûTÐÁl÷ŒÖ÷GÁÆ÷A(¢“Ò“±þ}ÅðáWª§Ÿ§G~ßRar$”2~x¢¶Ûî¾OJU¡Ð•‹}Ðw¼dî¨ “bÝ=XSUUe‰úö$ q"ø ’ÁŒ®.q4ÿïFWï×Â]ét|‰J\æ° ?V×£×üK¤…å Ä'@Ÿ ¯ú@`·ÿfãOÃWûæÝEÛŠé—íÓÔô°Eu,"êMN…jðÃP‹D'ÜñU¼Äü\¶_bî)r™t.·N—- þ›»ÑPËB¶uÁð–E¯u»˜öC3¡L~…/ÍA2ûQ¹£"™¡ZZ:<¤g’ ‚`£§³ÊÑ—ë6ÜetUzòQsJľdHSÓÆôÈß[jtœÙS§3÷¾ëèÊJ¥­ÏW4/~ÚQlF"ݨ ù(øF`ó¸qÃÚC¡1ª:É7¡Ýó¼‘%EßÌ”0Æ™û‡::~Œ™W£ÅÝŠâüPÉߊ-ëkô¡ácî!@½‡R °z„ѡ°ýz™¾/Tj|j(­¾>²yÉïS(¢«¤­ãÇŸ$¶6ÞïŽp•ðÃÈz ¾\3*ššŒÍ7 x"@í u'°®²ò([YOáÚݯûr¬eLô¦ejxÀôš‹:Âÿ ãŠ(¿{æ=ÕU²“N¦qÒÉ$<òFÀÛè-/¦*@m••µÅšªù¯œE#EÖ±™RέUU§wvâÅct2Ç»½¼ü*ç|سP%ö ³½P²Ü½,•1s˜†:=h+ùb&<¹Eæ/]ú¥åû¨‡×U\Ú1¼s4ÝžPTÐmøT«½¶ºú"(´?ANiª²z§ÇK¹™#š–\‡3í“86ŒwPX…þåzRïr¸8_iûBzŸsAŒQðø7ΑlF*PPΟ‡r6PüVΘ5­¯Ã¢®ð™œ~åŒ!sÂVhqjÊY¿¬ŠB£r.Ї=ËÕ¢‚Îrä[öPÎWA9߃r÷µnž§*E-5D_:ª©i¦'.E'ÒĦ u™´[tõ@¸¤ä4úÒ膄‡¾à‡¯8 [zœ—Ãæÿ¢–~ÿ°cÅ= «Ÿ<žn‚fe“ÁeýïB>_H)/%¿„/ ³lUÚ‡aR*'ç5*è¼n¾Ì=Î/@;ät(çs œç§»6kª«GZZ?Š™cSÈ+?WÃAÓ¯SÁ¤$àˆ´#LÁŽ´¶ªêB¼¸{¼Z8ôPoA÷ó, k¼ÐGß.pÔ1EŒ­¶Ç‰'Ñ¢ìÄùgQÞ‡|+‘@TÐ àð–Ⱥñã?fÛzX”ûÌà kd¤ç¼®ªj¬-Ê(çS¨Ã(ç  œëSÁ¤$àŠ´+\ÁŠ¼[±=‹Z÷¹æ[¡ìÎÌDÏKlM„3¶]‘B¶âÇä¼L äPF&-@TÐب~T)êøÈ ½ Y‡ú!¯K†±ÖÀî9˜€2·ëZºöfª­ŸüT~`¶imŸ9ª¹ùùt•“rI /~¿ðé+^Ï#ff]»ú#Šì«r†<ãù«™PÎë++´lýòô¬œ£?&–ú•s=¼VT*èkP?ªÓºtéMs¶²ºËÀ°Æõ°~øC÷ké8^}Ì18oÂßÃRQÆ.{É’'SÁ¤$q¤„¯ðÃœîSèç>àwÍ0¹å×Íir⿧´+?¾¬tÛö¸2qÏU/GújŒ9ÿÊKJ¦!¿°íÉ‹ý¡œ“†ª¼0BG¾“¹{‰,ݶãN\LQ9«{¨œ÷BË Y @蹘%Æ[­ˆ­Íðƒç1Û>êµ¾*>•‰uøÖVŽÿ†¹¿ØG9œ]Vò\…¾ÒYdÆ"ô ‚N/ß¼‘¾®rütŒwMö¹Àx)8-¾*Œ½¶Rú¶Ë¿)Üú\&~LR,'“„t@:Q5ÍrUZé%ŠãåÌé¾ÿÈf<8­Á¬‚‚É4©{×ÓêÊý^_´"­…¥ppA€ Ú¬BŠµ‰ºõ÷·~êù‘Gy‹¿2ãK+nï¬ÃCâßuzU=€5ïw›ñH hÅ‘ Ê9œÇîÅQýîåîP–:¦bÉ’7Ó]õ5UUU–¨…ÈÇÛªÛ±î‡CG³÷œîÖ¢|·؃vK¬ÐâÛú'~W öÃßÏ„r6/6±Ú·qšŠr†s;ù•³ßOåùA€ ÚŠy*î7CÑOõ¹øM#ÆŽ5C&imÕÕ—)%K%#(ù ª½=#åM¥œLLTÐÁl÷h­á;Ô÷‰#Z«ZõÀ‘tc5½gØl_Ÿr>Jî¨XºtkÊr(€Ò@€ : PóA䆉cÀi>—õ±QÍKŒ[Ï´‡¶ÊñŸB&cSÌÈƺ]fˆ„r’žO† ˆtv_ý|¬»ŽXêZå%¥ôu‰#8¹«ë‡76­r“qH ؃ÎõÈSÛr¯ÅPòï}—,iñUfÂÖVVžŽ[éã¶ãËZ)®Œâ˜#fƒt6¨çBžJNö³JëÙ~ÊK(KY—'¼ïð&~³R  ä,ÚAçlÓ¤¯`»×ç[îc¯Œlj<ÖGy}Šj7n€X¡VD(ë3’³Qæa΢2 d‡{ÐÙážÕ\‹Cv•Ÿ€åÆÿù)/‘,­ŠÎÀýT•³ÉâíDùð ä*è\h… —&j)N‹îQàÎHi‘Yñ;#“`üYH@É{)03!PA§/o“*Ùß¿²ë§ö[¸pò’HRê´$1ÝF¯§£ˆŒDY$@EøYÌz€_y« ZB`æãHø{ãGÙ1GÜöCe@: PA§“nÎʶýÃÖN[Ö3™ª¦²Õ¿òÂ$¿&ð«h”C ‚þEp0ÝéSm׌\¼ø-Ÿd%“£#“FraçQ“²C€ :;ܳëv_  å9_ä8‚ü|¹y”ž6 îHH w PAçnÛ¤­d7^ï“ð¥>Éq*cо…²µK—å›4 "4 ‚NÔ\©mõž/eTz™/r ‰¯ãÆè>Ou˜5£‘@VPAg{¶3¼ãS 2:Ùcç%>•;*¦vçø)²HÀoTÐ~Íy°¼X‚bFR-*ìÔ6¦*ÃMzô }~^õ¤¶£&îë¦ ŒK™$àóŸÉ¢3/¯öil4/ S^/’vx-ƒ§tZµ{J×w¢"»¨ã²¾oó d—tvùg-w¥åéT3·"¥™UÐJoNµÌ½Ó+QWë‰S[Ó°·Pž“€O¨ }™oblKæ¦Zæµ+£Š Ö'R-sœô´¶‡?ç:/‘@Ö PAg½ ²S€¢esó®Trï…¥’ÞmZ­õr·iœÄWJÿð­1cJÄeÈ$*èLÒΡ¼†/{q fæ=™J‘0=0•ô®Ó*•.«‘C†”•Ãuy˜€ÒL€ :Í€sY<ÌÌþ’Jù”¶L%½Û´–ÖÍnÓ8¯Eÿ`Õر¾ÚY;Í›ñH /TÐ}‘ ÀõŠÒ¢ šÞMµüñ,çõð¦&cy²Õi|—ñ†—~ÏeF'´ ‚N+ÞÜ®.ì%¿ñ\J-GxNë!!†dlLVyÙCRGI`g}u[uuÊ‹Ñ:ÊŒ‘HÀ*h 9J¸¸ø.ÔÏ«óú‰™f£TêÖ' Ê\7¤wÓì.!ÞÊ(*èŒâν̢«¡(ù³Ç’Û¼eÑkÛý½§Ò*u–§tÅÆ¡õý“;MVj+ë>=nœ¯Î™œfÎx$ÐE€ º‹DÀ÷p†ÿ} pm!1Û ¡Ü¡73B–õ· ä6±Í²~˜|˜ ôI€ ºO4ÁºJ­ðK1Ûm­¡™ZW]}ŒÛt©Ä±dÉKHo†:ÒÔµ¨Ûä4gBñ$Ð'*è>ÑïÆ®ýg¡Ö+ÝÖ½èËܦI5>Lâ¼›:ÏÜ‚]ß½™~ê¼xŒY訠 ½…]ÔïÀ^Ø Åwƒ‹$±¨Z.Í´/‹ˆRÆòį¥»Uù€v«(?‰ÊÀ{%@Іï«ÚMM˜ò¿úº÷º’ƒû•_÷^š.ŸÖ’ùešÄ÷«§µVU}±×Ež’@Ú PA§qþe`…‹¿%½ÁUÉ•]ë*¾‘C%E·CÌ&D9¡~Õ6~|FgN:(£8*èo`/Õ«x}ájØeLw—VÛ:~üIîÒ¤{ØÂ…›Ñ‹¾55)ŽS—c¢ùôi§9NÁˆ$"*èjòQ€’~ÔUýlûzWñ}ˆìõŦ—¬ñ¯âãmë7Þè%-Ó€TÐ^¨$ê,¾Umu^]u.ÆjOq?õ˜æŦhÉ ½²þîÚªªãS/9%@rTÐÉ6†êP¶ú48žÓ³ÐÓÌèÄ•ŠæÆ»QÆ2ÔP†Uîâ,à Ñx6TÐ’U¿¢eIfþ$Y¼®ûð6÷±ÖêêOvgb_[lë*äÎD~È£ªM…j2”³ 0ŒötÌ9¯«Ž±ÕVUõ8:Æg8¬È›%Å•QÓømmuõl¬Vž)Ź¹ÔŽ:¸¥Åµ‹¥ŒÀ`:0Mí½¢¦‡j+ef ~àPÊ­_q×·h;¶l1þDÒ¶,V¯‚†'¿½®ñ”|%À´¯8 [ØÚqNT–=µL¾¶–uáÒ⣢þ¦3ˆ¥­²ò£ZYÏ#Ëâ d»UìÈ~#[Z¶e /f@ìA°Ñ½VyTËâçD«/ =F=’Ì.,êètí|)‰Ô¤·+š›_Añ~”4¢?Š ]â(J!½ PAïÍ„WÙ¼äoPÏ?K¥û­/¬­¬<½û…Lcº:ʧæd"/±äòŒäÃLI€ :ÍžZ¥aÖö(é¿:‘¢TèΕÇ_æ$®_q̘y¤Èúä¥wåS`-ÇÑÛ_-G9½ PA÷&Âó¤ uûÀò/aÿbÒȢǔnÝn^Þe4ì»hQ›¶-cÃÝ™æŒCíªhjšó ø€ ‚hçZíè ¾¢±w^žT–’­ã&LHÏçÑ1sÑWú,v/qÚÒÛë"/€¨ }€T‹}€Á3Ƽ6 ƒbmEþôîèÑý’ÄóýöȦ&3Ëð6ßw¨´Û픇$à*hßPSLÌ–i;r&jŸÐí'¦G]>pp]6(UŒ=Ò¸BÅD›tuXº$Sn° PA»ý}©ý¨––%ðÙa†;v%¨gdÚ™’)zàˆêh¿D‹~-qù¼ÞÕƒ½¦d:HD€ :ÞsLÀøì°E's¬„çMÝÓvä‘ ö)bÅÒ¥[C"AÜvŸDv£t;á! øF€ Ú7”´OSÓÃÊøH$šÈrˆ”–ÎÌ­MMo`ÍÅkÒw’iÈ‘"A€ :Íœ¹JV4-¹ êù;‰rÄ*à_k«^¢8麇I,¿ÅïÇSþÊW›ý•Gi$#@Í'Áw#› ·£ —ÌÒJÿ³ Gùž¹¡Ð7­ÝITGq”^é(#‘€KTÐ.1º3·)­ŒõD_¡ÂRÖ]}ÝLçõ‘‹¿·¤¿÷+eË~É¢èN€ º; ûJ ¢yÉÍpöÿþ„b ú‚ÖÊê/÷u?×C:ò È÷g–¡Ò‹ÓYVÊ.*èà¶}FjŽÅgë0&Ý·s%%·a¨#ãvÄÃZZÞÃÂ\øÁÖÚ¸`e ß PAûŽ”{À˜ô÷ðbîúÞ×wŸPʺOO›+¸ÌØn›Y†)µlTsóÛ) arˆK€ :.^ô›¦\ß”@I¿îõ7Z~ø]#oÓ®ís°ÛšŠl-ö_RIÏ´$ˆt":¼ç+£¤abw™(Xuütõøñã|Í0‰°Ã—-ƒ%‡úO’h‰nk˲þ˜(ï‘@*¨ S¡Ç´® Œjnœ­µú:öžÌR²õôĉ™XªêÃr£Þ×0ÔòhÅ’%o~(Œ$à3*hŸR\r£š—ü3úŒP»Wì´µw&2Íë=õS˜ÛyWЖÌJ½”@} ‚î› ï¤‘fôýV_BáÙ(¹q]eåQ=®¥ó$$^{Àll\΢Q6 PAóÈ(¸{1ãÐxÁÛÙ­¥¶²~ƒ¡,Ø’þ€/@‡‡\:µ¶û²Jñ ŽIH >*èø\x5C0ãð wœìºû³8e]UÕg3R„09\L¾ùLë]&ctpM€ Ú52&ð›†;žAOz2ä¶vÉÖ¢nÞ8a®ó´í‹ nÝ%‹GF"}O¼q#‹qI *è$€x;3Г~õGn]“>FuF"?Jwî˜x‹<ÐßÖ_Q--^†E\dè$#@Í'!gŒjjz'¤ä4èõX¡ÔU­ãÇ“Öj5Æ©|øº¾½ý…Nã3 ¤J€ :U‚Lï+á«JDŸ¡/` ‰mßâk{ ;rïKñ®è»áë:Ýe‰—1¯˜t€?W«>¤©i£­«…Çúê´µUUSÓUV¥ô¤¤²•<·yçN3¹†2JÀÝ ’Œ™À[cÆ”îßÿÏÚ–0ñã~óX?#V¤%‰Üw"E¡ãö]´¨-I¼º§ÓŸ>L,] cÇDë}EéýðcYÖ«’›D©Õ˜n´÷ß°õªÜ6iS¯8‚<~%³¦rÖ¥ÀTРå]’š†¢"ûá¯ê k zJÑË‚¿°8G°Õ(ª÷e‡zF-ïêç¡Àk+ÇŸñç'ã%…MöŠ°e¶ïâÅËãÝÏûk×ÖO’ˆºmžIï¯"¿_ȬÉâ÷¿ NPA;¡”ëqêé/; \¢ å{0¾;Äø¡ˆ±óí=vhj´ÛÓ¢U=l%æÊÌÉKÍÅ „µUÕsñðOÞ»¾j‰eɹ#–,yï{ù~½æó®ÃsñSÔ¤›€^íf\7ÿ(6ao~¤ñÌà‡\éCq>çGôLƒ3oá9ä|Ìœò’·äÁJEOímÆ ·Ÿ€å¡Šª¡Œ«0ÎW‰/‘QʇbK¶" þn*36X/–5WÞm[$\ɧêûUÖµãÇŸ©l½×p ¾ sC%Å [¸°û´s¿²Í¾œÚúÿÁ3p ² ~œå±"ÏȬ3ÞJZ¸éO «è(rã;åBl“¦é;&ŠÊ-R¾þ»Rw1'ýôÍ ˜r—ÀµÏ{×Çñ¥2vÁ'`33íÜ|1>@èQ¤yDÂýçÊ­'˜1Á@}ÚiEm6¼ å4¡'ýûŠ’’¯©… ;{^/³óN…Mù±Ô£2kJ×lMo•3ÿض÷ÿ^Ž'úÄÉ Ã‘O;úˆ“8—¨ s©•ëŠdkø8±B§£‡|:Šv,¶"wEŒ®0ýdüKfž†YoïëÎomuõ ™ÙíZ;º)×áäíÝ®ñÐ ó¼n\‰a²:Dá$Iœ8ëðŒž'³'¿ç^à/QAgû¸a~…tvž%ñ_è‘LAqÜôMéÍ0Å3ø’ü]Š"ÊM§¿g.2ìM– GbÉ­Wq§ÿî»+1!f,5¨öÆåüJí“#Ñø |Ây¢1·ãùÿ$zö˜˜ÄÐtw™:ž^(^”|ãy K3t‘lü¸wÉ°‰zãÉ“Ný€Ü>umï<ïI uܸÊ ýæQËìÿe…¾¬ (=™ø~VSÿm<Ó7C®ÛçÙe¾“øò°g«PA÷䑾³XOùŒ8|½]3ÀKXDwKȾ›=eçø ŒU[UÕ_±»©v¢·v¼çý?ͽœct³vÞ¹À S:éç,A·X 3Ãú¹uê;Ý®ú :Íõc¥RZbþö] åpöŲ3KB=¥ò;)_P/uuè=3¸!°¶²º¶Í³ 8žV–u%zuCÏCÜš¹gãyý'R–zHý² °NºIæ¹| ‚NÇ#0½a z¹_è/aó:CkzÛÆóÍrËÔ7ÓQÌ Èĸó§1úz¸ ½‡½æ µzÍÜË ¤ÿà-7õßxiøcoi +´_íµÀˆ\3¦¯áódˆõÊv;Ò΂ã™Ûéx&µÆÁlAŒóëO×?xØšš4¦vM v^FWow›´ClØù³câÖ„Ë-çÄ¿ªa€”E¾,ÛìéxAbfñy &åƒH?Cnž²Â«¦‹€‹ÒC1‡} ,}ŽL²E ³£zÚÓ‡¸,A‰„¬ÿF ;xí囚©ýŒ†}ð+5zh_ÇÙÐÔ€`ª­¨Keö”y©ÉajÈ15õŸBÇ奲%„Y²7Mnñ¶`’PA»mÊkŸ‚Ó¡ÐÐÓ½I½¼éã{Rd*¿˜´¼÷ ž“@BÓçî‡WGíF%ö! ¯=ž{ Lµó£Æ%» åü›ü–»D…› Úi{Ʀ]Ï@O×Lo-wš,i@~ûÑÂœ~ËiÄ$b”kæ#v;þ¦©Ã|®^; óŸöY&Åå#Ó.ŠzŽ;Ňò*â£àWn4ÆpcßSØ î ðBhÙ?Ë‹÷P¿àûs'ÊÞ5ƒsO5”[Ì ÷¸na'-Œ»Ý[¼0jäw-bch÷A¬{Ã{ge™Â±gg ò:–±‰/+>TìСxo˜rz¿±}Ì¡³çKéÿ`¢Ó÷ò­?:fæ¬ÛðSÔõûnJ|ö µä5óÆãËô'D)I-Å{—šy_–›'ÿ#E9LžmÑ…4/°ê¡|Í?¯ý1LŒu¼Yú4CÁ}þ*Îv5=å¯Ô³¨·{­Äë¬[OÅ̵DTЉZÄ’é¸Nålr‚¿KíÜçñžî’Ùg[h†\"`ÞADvaš jÍ‚XÇ‚ÅÌB b—E‹ìïÿÒVäuf‘þ!gǘµ“zÙÓ/Ó^naeV0‘¨ 5¥ÖÃMŸ'Cá|Ùá8©h»ÔÖ?Þ’q¬ÿ¬ôok¤Só4µ€YaãI°€)EjXCŒÄä¾hó}¡|G!×ý°ÁS›éý¶›¥Âb:¦ë™ˆî½u‡ÔSúÕ廊øùÅÉÄÏí(a{%Ìæ¼”q˜\ñJqP_RA'zd¢ÃðU›Ù ¬®,r.ÞÚ‹lÞÞuFzoK±_ŠS¿#«à0isf‹–«¹Á”ëúg‡HxDZ‹AáC¬Ãˆ½-æGçzJ;Ö ç8Þ&ÃbÞQv+^À†´éܘøäŸðém‡¾.·LúOò¸ù£?lý=­¡¤ÿãkéƒ<ý¤ SíÜ:Ô÷Æ­ó”ë}lk „VE÷¶~==³ì¦Øb°öxÜ*¡0®õÛš½±«$%e%bG°·Ê$Œ°!{D¬(×AP®eP¬ý¢ÇÇ‚k ›VfBÐàÝLj‡ccjæÞ‡6’ä\Ø߇Qç¿Ky讂sdÌ· o÷D]EŽêª+TÐNž˜õ牶`&¤t=âlC»lK2­M¨ÅôÈÑmGˆ.êt5]Š]&T¥H;Öщ<{®ï‰Í"àøá”çzxÍ—òu/ôPV]C?¸CðÔ…–pñ~rÛ)ìAsˆÃ‰–˜5õQ©}²ã×#úw°ùmí¤~ÆÐMØЮöÝ®ÅÆZãÞè+þIÖ‡â+‹WÃÚ Eü¾$ý’¬ÚøZ íÝl÷äÆß4ZGdkÛ.«Y³í¿y±´õä3ñe›†¤ÆlÈŒm2@]8hÁËÆ%Ø7âEï+R¾}‘Ôo†£‚jæœ$ÊZàÀv¸Å2pNÿÍyÈ!‡“°í¶qbóG²Ç£o—m:ÏTœ›OÁÂÆPøÌÑ»ø¡~ Êøuì—@‡4Ê»ß TÏØi;[¡#ÀÉiìîñŒý·§„Ý…äë1t*-óPfÃàGÃ)Æ’=¶ýQ5R§x“dc‚KpÇ ³ÕöÆÔ¬¨ø`L€“5Å88º™Ùi6ö¼Ãs0Ãm»7³ây+¶uP¾ka£³Dû]Ñö Y¹ùG€LºCMýÑè={ñëÁªõûyÕzö Óýpö%ÿŽsŒ™UÓîmïXÓŸ/“âí£a\Åb&VŒ@/³Þ0ÃÌp4-Ìd s=¶î¡±.Ä€Ytj¬ °aj‰(˜j3³Î(Þuøq3Šx <»µar¶öV¹õ¬ ¸Æ3¬Ïí6 rY"õ‚Ü>Å´s`t®6ý­'›Ñ×woÉKi¦ÃšW*RŽÉƒÑ ï‡^bÆK1ÉÃ.‰î¯¥pÝøÿP%¸s;« ¿»¿¼äT ”½6vÍÆî¹+t ~—ïcN¶5zC+JÓØUÇ‚mmÂÐAìeÖ°½V(×øñÙ†^í6”yÎ7‹… 5R¼U¶ãÚ“ŒRfÈgÓî¡Ý/õT¥ï÷”®€QAJcÆ^XÒ˜¿Pš° ëqðˆKð£}‡ºáÇ»ôé *‰UPµaeH€rˆ|¤ˆ®õX ;eæI±cB2*èBhEÖr‘@ÍÜ‹P¬c<m&µüÊCº‚KB]pMÊ ‘@0/¹EÍòX’ŸÉ¬Ik<¦-¨dƒ.¨ædeH G„v~%í¡4Ëd€u³‡t™„vÐÙ¬¬ d‘ÀŒ† ° 2¾¬»[û8+Vgaù·À.Û‡8zá9 €wÆ­¨Ø€÷ÊYÉíTÎ=Ñsˆ£'ž‘ ¤B`›} ’Wyñ¢”¯¿ÖCº‚NÂt¡5ï5ObQcÞÄ@&PSÿäøu¹n”"ëÓ½`(& {ÐÁåT²és÷GK~3OÃŒ¼x{›±—S…da š@Ôß³ºËCwbfë…ò‹IË=¤-ø$ìiåk×5Évû(þ•xÀ'¡×¼çãåæ)+òµJ,wž˜1÷0<ƒæ¥à—5èÄ”ÿ eÖdã’!ö ã@ÉéKÑWK.ÇúnÓQNãϬâa}/X¨œc<ø™)Æ®¶ŸBvn•³†–+¨œ7tb>¹s÷†úáÒi}=å+Q¨òS˜N;kÊ‹=®ñ„ÒMà;ó÷»s²9ÔeVèqYfO¹ÏeºÀE§‚Îõ&¯{¤¿l+ÿ6üâ^å<8Nqß–å~ç:/‘@úÔ>9Rtçd`ŸpŒ×ÂOÑœÎ2*hgœ²«fî)²UîÅ;¿Ñ}@«¿Ñé|Ÿtx#®o-aû QéJ|tÁu.”óBWé™ :ßøv¸ùGøÀ"#É"´J/ËÅ*°LJ`úœª¨rÙÏe ŠO“›Ï|×eº@G§‚εæ¿ú±Ré·ù~ŒÑý—³¢éCœÅc,H‘€ùG§äaHâJ’Vÿ#»jäŽsÚ]¥cdàfÈfõ‰ƒ‡ÿ :Çq¡ÌßFË>Rn:}³ã4Œ˜^¦1véÕø¡=B"¿Îûe¸jç~ÐŒ Ðî«ï$ãÎú ™=õ¯É"ò~|TÐñ¹dçjMý·az›ë̵¼3;ŒíMZç:-¤F`FÃ>XÜLm®Æ!³b»9‡ >)> ÍXÙý¹uê;^É—ƒèpÛ–[ñä.‹<ëi~YnÄ!8—àºG§‚îN#›Ç×/*áŽ(Â@ÅXåð —Ý#±õ =Ša²¸jŸÄÚ!¬N E¬”Q•èÇÞ©ýï(¹Ïɬ©OÄ•Ÿ‹o˜_!a¬ ˆªÎþÉÁâhö”ßrF«sh}Ť‚î‹L¦¯Ï˜wþ?èC¶›¡þ†õÃbEžãЇ ¢F ÛÅcðZÖ OŒ2Æ>jF6Röw!©¯¨X(Wêä½õ?ÏyË›kë'‰­Œ²ózky/¯’[Î\Ù^wG€ Ú¯ôÅ®™w«_‰ÊdCÉ´`Õì…Ø/ƒüeb[ËÄRïKù3­RWg'J\p÷êê,Ù4y”„°@°(`l¢-¯QÂn-¼"z«¯Qfñ–WiKg\l‹ü½_ØÝcmxgá (óëä–Éæý ƒ¨ }„™’¨¨³kAJ2Ü%Ž z¶V|?€Âjm­Á96+µZB þ=Â¥û&©;‡;ñŽ]Ó0?Bû@ñ€ú`\Xb{eÇöbÎe¶¢ —¬¯ìvâÆM)›™3CRµO"*ôgüh×W¡{\7/¨E~(åÖï¤nR¸Ç=žøB€ ÚŒ~‹ÐÚyÏAÒñ~HKƒŒv(ÀMø‹¾=qì­MØoÄ9Ž•¹¶%š§’-èMAùÛíè¡Æ”ºF<lœ+S+Û‚¬ž³"•Qœªçø»­†ÆâEgPšøØô tìÌ~pôž–¡±ëŽ{{¦$9”± þ¾ ˜ÿ×ìý£Á³WÓðU´ál”¥gÄ'eÚõioÿLçbí?¯¦H€ :E€¾&¯™7_’g ³§¯ _3¡°%ð:~ ~"ÔýíNoÀ˜»ý¿`rª.æàÒ‰•OnŸjzÏ i&@fÀ®ÅϨ?=ÒÇ‘ŽJÚ5¼‚H`†™î…ûߤÕG²ßzÊWÐ!¸ù HBÃ`òk [·Ém“6%‰ËÛ>È•ñ8«”ç¢fM] 30cKËQ“£ò¼6,¾;p«š‘d½„“*Mw’»Ç¾¦á8¸«ý”óÄî—ã/Egá̼—³ãÐÉÀ%ö 3ÙSÓŸ/“¢?†¢þ&Ò»_€ÓS¦L”PÈê)´óSb÷›ŸÖ†ÓŸ&¡¢‘Ÿy¦ú²ÐèÀ½‡1”ñ[Ø2ÏE\&Ìr7*è\®›s„Õx¹öy•ÿxr½½—Ï(»l  H(òŒÌ<4if8cû)—Â¶Û gô5±fîa,:|·Ì>Ó i0ä*èhGE0ÎÑ‹:’¾ ÛAŽÒ0R¶ SÆÅè>‡Øga¼Òñéø3æÅ|ÊQÆôÿ _.’™Sžfo9¡,_¢‚Îr¸Î>:‘À>é¦a;›;Ïb®3d‡Lïø-(â—Ŷ_ÆØíË2hÇâ¬Ù_ÛðQ”Ã(æɽÊoLäþí>°þI®¤Ý‹NŽRAçXƒ¸*NÝý%²mÄé°+>½Ÿ©H{„«ôŒì•€é›Y€M°Å~U"PÆÅ‘WrbZýôúC1Áè§(Û%غ¾ßÆòâ ô¤ÿ&COÀŒ/#ò@WæCYYÆdÌxµšŠñÍSð·úcˆ>Û8·„÷õjôŠeE#¶Ø¾Üz-'•ÜŒ¹ÓÐöÆúǸ5å}e\ÊÕsµ­FÆ þà—׎¹)åº9ƒ1îùq|iEá3:y8öŹYକÊô0MØlo‚×›²0\~+'zÅN°|»~””`¢‹q=kYËÌI«œ$cœÜ&@ÛíãéÌ°Èæ¡Gâoð8Œ“m‡"“ð™ýþØ ñ™0“?àaM¿‡ê­Ä_ýåèY¾‡ú›óq‡Â0€…øetRoƉG ®¡Ÿl‰w›£à7ã(¯}ÄÒPÚØkæYj’™m8¶l½œìÀOˆñ²e0›éýÂ?i8wR’31½Ž“ÖȦamòÛv" ä*è¼k²)ptªð©Ã°šÈ )±Ê0ó­”æ(wLªÑpn¯KáP©ÒF$ik÷µv(Ô˜3¥®H–6“$¶Ç®G-mÁ¥8ß,Å¡±;6ÂFw{WtîI€H€H€H€H€H€H€H€H€H€H€H€H€H€H€H€H€H€H€H€H€H€H€H€H€H€àLB &ʵsŽ‚ó¤1ô\0-ÊŠ8*èo`1ŽÛ#z|T\ˆª¾(‘²+Óºî]¡ódýH ƒ¨ 3;cY]ýüc”~„®@žÇìÎ÷Ï2`ÁeRWgg¬̈H %TÐ)á˱Ä7̯ÎðõpVdó€n¥û‹AGC݈ðò€W‰ÎƒFJZÄkŸ(vûuÒÙùmÄí®˜»’>LåÜ…‚{ÈTÐùÓVñKZ[¼èv³Ì‘q¸ßGP=Ý~ö‹—I€r‹@—oÞÜ*KãŒ@M=zÌj>ü0'PÎF^^3§k,Ú™lÆ"È:ŽAg½ < vÞ· xow‘z3–yú–”Ïÿ#_º Ö=jí“#EBXÛQUJÄž+·žÞÔý6IÀoTÐ~Í„¼kŽË~Yyi¿¥0¹»C”ýO™y^2ìEÀ,ýµUÃr_UXÍ¥ ÷«Á ÇX lOãÞ]h‚:®i¸ ü%àå îo (Í=Ú¹Ï"щîöH¡qö Tü|ôÄ_y /ßí£ÐO̪çauªy„Xj,ð‘86 Ù¬|Âæ$àŸ‰üBÂe·Ó¾Ü .ÆqC€ Ú ­\ˆ;}îþP«ÒT³Þß2(ll òÑ[h ])ƒ­µR7)œ¦¼Ó#ÖØ„÷ïw tbåò>J8¦•…ܽGœjþïA@ °îË;F©ÖœéÓF€ :mhÓ$xÆÜ@±,L“ôdb1ÉE¯…ò^2|€1í÷q¾=È ø»¿Ã&Äì#ë¤=²^î8gK2žï_¿`¨´·•"5+W`b?È:e9eÁ¦Äñ¸6Ès^*y|~*›ÝÇÕĽdšî¨ »Óȇãèd”N(I¨ŸÜa”r=Š‰•ºe3ö6ö[ Ø#Pì[qnzãÛ \;±Ç%U†Ï~Ñã?ÔÐØ¡ YC‘Þœï¾öa¤…û1|©ƒ÷°YnE펿û»e‡u³Ü9i›GéI6ý‰a*ž/sãQ×ñøQ1u5Îì¦'ôK5|ßD]–¢N¯ãx)Úñ Ù2äu¾ÔK;{fàt2hÆA¾ÏqJÅ]uÃ-7øQ–w±-rx½´U˜<¶/îàO9´3V½Nnžb”uî‡o×’"}¸( Lù´2v×ûƒÏ~Ø›«Ìú`Ž3³ñÖa3¾ªß_8з°°P²B"‘årË™+cQùIùAÀ­¢ÉZ¥RÊè_ýÈñ˜\p¾ØÆ¥'zŽ®ƒ™1ö ¶—ÑÃn”ª%çzÇ®«ä"Aí“fÚùHQECaá0ÿ8†aègX Áõ2lýÀÃ>ºL´UŠ}ÿ¸Ò•ñ!­áCZmD|3&Œ°Âš•_¬uX¦ ÃEEë¤$´^Jç­çb¸q)fîâµÏÝq2&~‚máv*hÃñŠWŠeÐfó¢ì³ØÎÄæÖ!<Æ–aj%ö#²¸+2“ÀŒúóð]ø Ü.3§6‚µ°‚†ÉYíÜã€òRôÊ.Á~¸K¬ð¥ ÀÐÇÃR¾þi¾PrIÑ —@í¼9ønLÂ÷ê2{Ò/°7ÃO OAÏhØÿš¯«Ë°'Cn‚yÛo¦ðþSxÝ`cÜ@˜Q zÑÕYÝ %}9•´·' È[²6ë n xQdnóHüÚy`9û»ð·j”ÇÌ: ÔO—YS ·jæ,áö‡ðtBœ¤?Œs—Èom&˜ Ür+z¾ßè9æå æ=£üŸÌšBåÜ“ ÏHÀ®¥Öô/¡œc°žAËpaðHÏ‹ˆö†KŒó#¢ëAF±2 ù\3Έüëð,ÿBïÎÊ0Æ5óÆÃ}Ãã2 tPP½I柂ŽÙ@ÏÃC3Þï§1Mò6á!oÆ_Ëfô@^Ç?€7%Œ•¥WmXA»ë4ÏW±f1 ;r †ÐÀ0ÂAPÂAùšExÅÁØöÁæuõx$u6 ot‚¬ûe †ò²åf·fÞ™øÎ<€¿ ÿ8§9*yFÊ?mÁ(é¢â_áåq¾Ÿ¯ÁŒ©½m¶Ø0<‚U¾Í Ô:²Jl~?¨ãn`Q8Á¼ÛxR…‡`ydĵYÑÇÕ5¦kfEô¨ ›QÄn^ÒùÈïV=U%Èæ!s³îÉqF=\7¨ÛPÁ"üX|Qnžz¯•Í+Qù© »G¨”ñ›7Ð…4¾¸kð ®Äg¶•xXßÃùjl­ó^/‘Žõ2[Ýù; ­ò9[Ÿ«$%¥CÑC0„µ{o™UË÷EU Ó`L@MO øÃót÷zÝâ‚[]Y€òA)Ûÿ–™§çÆ{è?ûw(×y»+´IìØ?ÈÏw~+è®ÇÒ¬à Ô—ðåø/\*ﺠ½ñµkÜ9vm;ı¦wo¢¶ã˸EìÐ6(þèÅm•~%[¥s玂Ÿ=iœj Û9@ô®Ò©úaè`  À5m?¬>=“1úãG¾ Ï® AÏv(ø Á5컎£+½ãZÚ‡…ï!‚z-ÄóЀº=-ÛCÏÊ“ðäH0ÿ2¶Ÿr)~änA‰º/Þ<æ'ØP º«ù¢YÊͯï9øbMÂcx  lF¼øïÀ—ySôX¿½Š*fâ¤ÌÞœ› lÄ3ibAë-Pp‘Ø ÒiÙÕu«Ï½²ñü¡'ÚgP%hÇØ®‚2]ªê‡Ã #f¥ ¡l•„pÏxUCüèõ ì͵ 3 öU°xÌž–]ó13vKN¨™{6~4~†6œÐ«|¯ÊŠõ ú{šÂRнZX¦×Š¡€Sñwt"ó˜‹øB3@A0C_/àÿØÖdPÛ«9ÿþ"º$ú1ZÁÌXìÌ¿¼9‹?[½Éôyô¯Ô ‡aZj%ê Ó$c¢$GâaÀ–öéã–•Ë…zzž]ØàÛ‹°½*3Ïø S¹§”ùþm;ù\ȸÛñ}È¿0uÌúîã~ .KA'jÚèr=°/…¶±©¨±?”¸Qäûk(=ï‘€¿Ì1^Þ©×ð¾  ÃG‹¤¨dQ^Î^5ËÑ©ÈçQ³°Æ¡ 0aú¸¾ =ç»Ä Ô-*è¤Í W‹5ó`“j‚÷CØ465Ûîãè•T #@|Ðx¾^Z ˆ_Ç+ÈÌL}]nžŒ NyîK¹fÞDL4¹Ã/—¡êÉ:9PÞ0©›ò—ø˜‚y•Š%Õv7³»Êú–ˆŒÞ­¼Á÷ Çщ°qúÎ ÚK*T›¡6{wlê-ì߆õÈ2éì\Vp®9k*añüýLìûÐB߇ðòç?Ýw”`Þ¡‚ÎD»›á“ÎÎC¡¸÷Coö²Ø+ØÍÚ {ÙEƒÍX0ä'(ö;n~Å-õÚ÷‰¨·å¶IÆ*¦pÃô†1° 7Îü¡”żßq4LÿBÖçéÇ&>2*èø\2Õ¬±Â+›e&6fœ©Ø*0¼‚‰ ³Ðd6³ïn+šù²#ÇvTs-¶÷Ñlîµ9‡âµ0ȶVK(¼ZÞÝ´6p¦`ÓîÉèÇá]Í¡£q>Ø…Ím0f˜u2`Á,©«ÃØ3C<TÐñ¨äú53ñbȆ Lº.E°#ŽXC¡Ü‡` 6Å]+Ì$ çfo®G·Ø›žz®ÍlC‘ÒÌ3¸lF·b[`µÿZ0ÇƤ…¿Ö»'òXØ‹¬ƒÒY/;­õ95‘#-h\ ­}r¤è¢)HuøK 3cÒ[Pò/$¼FfMyÛ›€à¤¢‚N[ï©©7/ˆÉáÁb‡Ë$êUî!» J«,¦è±ïš"J]¥BÉLüÀ-3ÄÄ1AÅ_=ìó#úcÑýyCÊL„é ¶1¯ê9™B™‰0b¢eÌÓëBšÝa”½«ÑÓÅ,ImwÀÕæ& G0[3$;"[©d»ØzØG—¼ ¶SÑÖS!¡[÷ös/T㨥keÖÔ'Ü'fŠÔ€“kM…G ffzþuaâˆ: ü8¶_*j|I‹üXÊüÃîˆRA»ãÅØ$PÌ,[Kˆ 'Âêâ$ôÍ8²ßC_ÏCþ-R>ÿŸTÌÞ*hoܘŠò‡ÀµOí'YQà‰®€ÛùŽÍËæt3 õFÄn‘Y“§#ƒ ɤ‚Rk³®…MÀXW8ì0˜­UaL~<†*ŒRþ(¶t)ã.žpuÌtŸ„C+x³Â®Zg`OÈÌ‚|'P3÷` QŒÃ˜1&†(c{l63La¼øe*`ºþ,_þ(·N5và > ‚ö(Å‘€oŒûÜ-å‡Ã‹Áª1ð[c5ò¡˜³2±É˜-þ–<cæìCrËÔ7}«+Å%@‹Ïcc€_ÅØßG ù-Ì0{ÎcÞ„ÉÑ›yã‰Ìg$·›Àusc¶áÁŽ8 Šïpô†1«4º¬ñ´¸pjűí9XKó ¹}êÚ(S`Š@ɦ¾v<åé¯!Ë/b3“GLØŠ .$ͺ„:¶×ÖòعZåæ×á˜! ˜1áC*öÅ0ÀÁhw8Ü2 H`¯•9*á\bvå¹S?ØžËsø±xF"zzÉxÑ—çN›r‡­ë’PA»FæC‚®•_´|ÏþÙ˜èKjÜN®Ä¶›ñû»›™~¼_rìí5RÞŽf¹.!¸d&Ô5ôÔ™}¤Ã6>UFÂ8 =],+ð±bãºÒû@©+æå\qf å9—.gÿÏâŸÝ4¿‰&qžYúž Úw¤.šY}¥ýÌL­óñ?{3Æè%ì@"ÓÛƆEeÍtfÑfêò:(㚶1íÙÚ(Vx zu›¥=²K!ŸÁ W5 ’Ð@)Þ5@Th(ÆU‡ƒÙ0˜ˆÅö1Ÿ'Ãp ç {øF‰'üAÍe–Æ«Þ+²x?ì/K‡¼Ì!‹\n.½ãÇÇÅÑIØ<Ýå'ÝÐe ‚û#þ¥ó¾6¾OîõzDZ1|õaOˆ`yZ” .#ÕH –÷%¡¯î•õl,îv|…hzà6| ®gñZ]Úu¿2¸“áƧ®DÃ×zV¿ÛÇu| T<ûƒyÌ=ëð ¸|“ˆã˜ž7Á±¾\ŽÞB7ŽÏæKnòÄm…_ïWéq6ÖÆÏ#vrÌåñÍÜŠƒÚØÉÿ~Ù-gÓ¯:âdø1Š?C÷0×{}Þ~üÛtúýõˆw8þbú>¹µvàqð¶sÃ_Z´©_^ÁÁ ¢(ÍÚ+ ‚ r{¸{wŽî®ÕÞ·l~êŽqátÈÝãÜÞo‡/òæ¹c÷–s´‹~¼…:àÖ‹ÊÍ/ã+ü9ÆÂ-1p‹>“7²“Ûý·imÿG¼ÑOÅŸ¡{›ë½¾×Üþ@ÓëÆÞë6qk—qàu Q¢ÿÒZ¿‚%@€r4 ÄM'ï )ÐÚ>Ç‘ˆ»ïtÁCü󹉋AÜŽJnjF¹±Áq"…×Ú€ýf$DšÑÞ—Ï“I¥Þò$uAAÜ“– ÔøÑÃŒé_|ƒ)N¢—KV*Ö—¤åeÞßyä ‚ ‚ ¸Ã¹†‘}7^*@Å š‘rh¹ nV âpÍOd‚ ‚ ‚àz9¾½ìJrÝ]ú°~ý-À8zj™fجŒ`AA¼`ßlÿ]€Ö÷|üuDø?‚ ‚ n+Öþ-‹Ä7Ç2á£ÛOAA¼ðŒÍïµY.7˜ P³®þ?x³#ž ‚ ‚ ‚àv³1ÜSïësl´Ë£Þ.‚ஆ?ƒ ‚àî〿a×= ή½Íí9‚àN⨡òAAp×±Þ³ÿ:Œu»Æ¶a÷Á­€«ÿNyø#n°¹·[ÃM²¶ž[M?°½ð ¼ËofŽØçÑçÿÖrØÇ ‚ f}2ØuG·š[¸˜[ÅfmÃͶ;º¹•`£úâ°×xWþs]‡9œ(r†Ç¬={Ä)]fqGr¦|ø7ö.7ïÜð[ßG¬öÅå€11AÏx4έb­ã†6¾ýpÐEYÛ³ùtm͛߫Á]ÍÑ}Ì­÷Ÿùýc/Ýb³Ÿ\p$tX ñgá:?GØg×µ“Þ0G|g%G?rôkofåwÑßÝXçqκ{ØKî–sw /Œÿs—·uÏGøÃG|Oç+4®ïèqí›x÷…áø¹Mlls'ü3×pMé°)¸×µÛãÚco|Ó¥?l{nl³¼¿r…¯áTp+®ÀßM/ºo·yrïpîüAÁ½Êa±Ð#°àîâšþÒ¹ú×tˇŸk~Â惛 æ´Øo½ò‚k­TÀQ ëü¯Ý¾£üËxAApLn8[Fp\3ewp’GýëÿØÙ¡o{Do ‚ ‚ ¸Ý,%?<,ì~T"K ÐM{¬/zŒ?‚ ‚ îyV’½°¼QŸ8ŠÕ€°ßƒ ‚ ‚àÎç¨ÂäÃë€ P|CÒÿp‚ ‚ ‚à…ã†ìïò¢cO‚ ‚ ‚àŽdÕ8,;@¬ÔÜÄ;Eø?‚ ‚ ^4zsœ\½¿N|#À-Gƒ ‚ ‚ xqѲ Ð*½g "$@AAAp¯³2÷º€üAAÁÏX²SnH"AA÷‡÷ÿ쟿~ P„ÿƒ ‚ ‚àNäÐþ<ãah®k‡AAA܉¨fµÛu]€‚ ‚ ‚ ¸á¦H«Ï‡AA÷‡Fþ×J ‚ ‚{:@8AAApŸP\€p‚ ‚ ‚à>"€ ‚ ‚ ¸¨ÕÀáAAÁ}D8AAApÏÃèAA÷Ê0àp‚ ‚ ‚à~"€ ‚ ‚ ¸ˆ"à ‚ ‚ ¸÷8t$0Š@AAÜG„AA÷:ì‰p‚ ‚ ‚àžä` € ‚ ‚ ¸'9¸ € ‚ ‚ ¸ ‚ ‚ î=iÄp‚ ‚ ‚àãˆN   ‚ ‚ î'‚ ‚ ‚ûˆp‚ ‚ ‚àžfU@AAÜG„AA÷<´8€ ‚ ‚ ¸9xp8AAApOÂCî†AA÷áAAÁ½Ê…áAAÁ}D8AAAp@AAÜG„AA÷áAAÁ}D8AAApïpØàp‚ ‚ ‚à>"€ ‚ ‚ ¸wе6 ‚ ‚ îxä]„AA÷áAAÁ½Æ¥ÀáAAÁ}D8AAAp@AAÜG„AA÷áAAÁ}D8AAAp¯3ê tmàˆBAAAܹ ¦üh>°…AA÷8+¾]AA÷Œ @AAÜ?è5‘!‚ ‚ ‚{F  ‚ ‚ ¸W9(–@AAÜ£lªý# ‚ ‚ ‚àîf¥ hAA÷6\Þ ‚ ‚ î#b@AAÜ7(æAAÁýDH€‚ ‚ ‚à¾!j‚ ‚ ‚à¾"j‚ ‚ ‚à>"2AAAp/³Vó@AAÜˬ)~‚ ‚ ‚{™ @´ ‚ ‚ ‚û†(‚ ‚ ‚ûˆkg"CAA÷ ‘‚ ‚ ‚ûˆ(‚ ‚ ‚{™èAA÷/áAAÁ}D8AAApqm Š„ƒ ‚ ‚àžáÚ@´ ‚ ‚ ‚{†AAÁ}D8AAAp@AAÜG„AA÷áAAÁ}D8AAAp@AAÜG„AA÷áAAÁ}D8A÷-1ê=‚à~$€ ‚û½Ø ‚ ^p@AAÜÓpõε€AÜ»pô3‚ ¸/h^ìA/$4²øÖÁýEH€‚ îQ6Íz®Þе6 ‚ îV=Ç‘Awƒ¤ç°Ð¾2ý×rAÁ=×~W‚ ¸—ÐÈúúäÊ¿KAw=k¡p‚ î ÖdýÅÜ?Ãå“m»²‡( ‚ ¸‡8$§@Á½ÁÂ[ÿËŸÕXëú³´ö‡$@¤‚ î5BAp¯Â*ñ'1Ò}ª>û`ÐèFvÿ¡© ‚à^"€ ‚»‘ø‡Cx¨*‚Vô=+€>KPïÿ!òA÷$M|½AÜÍ*Ü' ˆ`ù‰U³_X3ò ùG ‚ànæ;?2A÷½ÄgÍú_3ä5VûK½7À @!²A÷ñ ‚»™¡ÞW½Ý^âýãŸÆûfw ƒ ‹¿Aw‡vºVL'b>Aw6Z¶þT©êÝœpøK…Ý¿ Aw=! ‚ ¸Û90¾¿fýkåúþ?׶ê׶ˆ<@ÁÝá5ñeApw£e7OV?Ç=>«6hsûåÝ#ج‚ î´ö»rí @8Aw0¬?zË\Ë @}¦·÷— @‰ ¯Û®7 ‚à.æÚ@|ÍAÜÁôƒ{Ö Ó€‡¢_/.Au´l z #AÜED @Á]ÊÐàg©õ÷û\•øhY), J$®è‚Žñî‘!‚ ¸;  ‚à.eò*{¹1íkÙ"T æ`§DZç '³²‘Õ„€®mÛ<},‚ ¸ó¹vÐ ‚àƒk¿‡–?ãoô¾{ÿ²‹¿‚¤\ÙšIÆó¯xöý‚RÊ‚ç ‰$±¸ëÄXCAp·qí.@‘â ‚ ¸ÃØhëÐ7ý/fû öª{YK…EÀ³m®‹o|s÷û|õ±Wvsß_d3K©)Sƒ—‰„Ûiæ‡ Ap›9´ hAp—qÐ7zÉp)ÍéÇÕË º æÖ]>õGÿþWæ‹?û÷ÿîK{¶1µË½üU艣¥@7¬>äp‚ ‚›çÐIÀAÁ]Ƹ¹ÿ®˜äÕ«‚j Pðlû—ýÙ¿ýŸK¯l.uϼdöü¿ÿ£ŸÌûezöL#{í¯aߘ #ïA·ˆÈAÜÍpŶ?ða#yúŸ%XîrF·‹½W¿ç±ÿÌGÿìéçòdÇÒþg?ñ†¿õ3oíöŸ÷®£)±(†Ä> pˆ…~Ñ{nü ‚ ^8‚ ¸+Ð5ÂíëY’¨–ûÐälâ¢S7Øâ$Uf„ºšc-îØÇAÜJ6j"ÔAp·0˜Ö†ÿ‰¡0·˜ì=»l±7;÷ÅßøÜä%Ó]ÍáÉ™ðy·€çÉ$åv‘K¶xõÃþGïÓíÕg“¹Ô‘" yßTÄ1-üvâÏRÁ-&$@Aw-u ×¦u¯Ð§Jl'!åìu‹Ùâí?òÎ÷~úýÛ‹]³Yç 'î)mhÐt‹l槦ÉíÓ_üÌ[?ùC¯¤®vêÑ@Ò=c pxgе^ï±A·žèAp·°aæR_1É%™Yë›ò¤›¼lþ‹ð¥³ûÏ¥&{‡œ}’šìrcî:_,¦ÉäJ‰];ßžÚbÿ›ÿÿüÂË<פÜy&œRJ¦2P€½r?æ‚ ¸Cˆ @ÁÝÂjËÍC¬mIöûI0gwXKîž¾ðKøÓùù¢A׉0Z“ˆ–•g‰&%ã„œXê³Å#ÛgþÅ~ÝóÊ;³â`xyh}u‡jþ ‚;‘p‚ îlÒý¯vàJ‹žÚO_4´€ö§—~ôg>øø»_1Ï{ IËݒܺ2äFÀ.È,›-žû›?òê_þÉ7h~ ÜÍÈd._¾ý±Ú÷ß|WÐ ‚à@Á]ÂÈݪõ¾VzuÂÀ®Söœ§W_ö¶OüòO\¤çätWÎp¦fJ@*å.·mÎÊž:4PJòótªf~þ‰úw?÷Î7€¶×"w]WÞLÒ20O| 9Э8ì ‚àV@ÁÌáBúaâoýKH¸»oíÉ _üíÏïÏrž™ÃEH43 îR†™M§“Ô4LæÞ9; ä¢õœR÷¿õÿü_cêOO­“Ü Öf Z®Š½°¹NŽ{ÃD!AÁ-&€ ‚;rû€­H«U0JÉeÝ$_Ù¾øéßüÔCïyÙ¢YäNÈj÷Û”Rj&³”@å.ƒ<ÊÆlDç ¬±s¯|èÒ?þûŸóýg½í\ž’‘«=€4ò]屪†ƒ ‚†p‚ îHŽm-«$èFksç_µ‹ïþø›¾ÿÓï[hoj¤KÙMÌ)R29=KÙtHe:ÀMóEc©kŸÿùϾõ?ø°µ{ê Ü±6íÝöpЂW<™ˆåAÜ\ÛˆpMÁ Ê‘_»c½}íÈ – ~Ûe’m^œx­}á÷>}—œP§ÆRbJi’š d!Â(&ÉäêP|˜š“žæY®ì»ßùŸþøW;}yšrö H\U÷”ÁÃãÄÀË–·ãKÁ‹Id‚ î Žï_¹#¨Æ˜ÕÁ´0^™=÷›ÿø—íÄb6KÈY£U·èR¢@w f"œL&¹s" ’™É¤”&‰“äjüÊVúÞÿü~®é¾;1(çq9lX¿Vd>ã…†ö'‚àN"€ ‚;e(síQ:þ”ØQ¹tyçùO|ù/}çËö\MÓLl’¬Émš‘LtBPç®Ô´]¶d"TÍ~‘”:By±@‹$L“fºúÑw=ô‹Ÿ{³ç "-(Q _ÚúÚX1ÇO Q1AÜ:‘^åÄ×sÁíåZž+öóÕR2ê²2¡ù£ošýøÏôòÞ…ÉÖ4/:² „%“º.w$ ØX“½x.4ÀJ&gK¢IS›£mEtóù7ÿé}áß—\†‹rúéVÒ±;ê‚ n?‡|-G ‚àEåÈ&ú›frß‚_‚` "ö¦óK_ùÒ÷+W'Î)s›™šv¿S˜`Ì­v¥A’,‰¤‹`_J €rÀ$dwe€šÑؤݫþÛÿý?ýÆ {ÎØ N^DHH¶h,“«Â¡4AÜNn A¼\‡ÜwÿIÈݳ+7ÝåæÌßøÒÇyÝÚAîÊÌvž‘=$ äÙ¡.:á’†œBméS>î)¥”¬Ý›OR¢í=úÀÙþÏ>5ß}ž’{gRcœõ½¡ÏUï†Â°U_Ey€ ‚ÛÉ¡€ˆ¿AÜ Yþ“Ácê:ï]ÒÕ·ì-þüû÷ýr–‰¦Î}á’šfBA‚™Aéex0\ ^,ÿ¥9.°ê %å–ÊD;Ì:ÇÖ¾øÞOê?þƒX;Ï\ô!¨/õ'EÄAÏÇ¡ ‚;"þ‘™ ‚„ãÁR/ü)7ŒÈÞÁÐ6Híé·¿ØñÒÖ”IF4)MäÔåÖ¡dIR¯Ó'`dò¤ tPµI?‡q‰ èÄ,8Lò~»´wþ¯þÿþé‡'ÏìL“fF+Ö½@ø‡cCñÃ~‚@XÿA/QAðb°bý#ÞÂþ’˜h"ayqëÌÏýÁçÒ£ÞBÊ hJp¦fâ‚ËE¨˜è‘¢D܌ţ(kXÖˆ€Á &¸D¥Iš@h¼=eßû_þãÏ_½ø­”l±˜[2ÐëD²~±MXv êïF )‚à…`ͪ?ʈ/æ ‚ÛÅq¿aµ4”%JÈ*=sÎqurþ}?öö·üЛíÞd2uÀ,9ÜUúÿ$ ê‡ÐGú ˜ ÒúŽE##Œì2<5»[Ýô5Íg¿ö™Ëœç]çMj(#-5Ésv•h>i,¯«e.ÉÀ° ŒÔ×™F!çNÊÉŒ°d×tÊÅÕ'þÁ×>þÞWgk÷<—åR‡ƒ•Âž— ‚à¶@Á Âú,ŽÚákc‹á5E‘/’“ÅVGºI¾:9ó¥ßù)žÌÍNCdçÊÈsÈ«=O_¾%A’4&9$Xu1Jø_ƒÃA˜„γÑI% xv$›Ð÷ÿòûO¿2ËÏNàž;H}P¡6*];ü¾ÕPŸë?‚àE!€ ‚–ë•þ $ÀÌIÐ:—Oò..|ì |ÃG_³›/f,I°Ô bÛåV a$QÚû¨úÈR‚ÕÎ?µÈ¸·Í¹dLÈÕ’— p%ËHT3ÑÕW¾ð¿þÃØ{Îå™C¿Oô¡•auvÁ‹I´ ‚ xAèÕõk]ƒ~¼nQáÑæ®Kù*ç'_›~ê7?}q÷Ìl–¼ËÈ$¸ÃÊêh@5ð% ´÷ìp– À ò— !P,‰‚šL H$Šî³tbÞžûò—ÞõÃïÝNÚ/͉’ÈɵJà"Š'Ò¿IAðÂsTÐ ‚àV°Úýr‰®åÃT-ȹˆÔû^þÊ¿þÅKv¡c‚šdfHzëÆ i2a Ù×çÒúB]±?iÔRò`5 À²"D*º9O¦Óý«þÿíÏ>4}vb]çÙKµá*þG z,R_l¼òš÷|ò}WÚ rb H&°Æ&‚²2™HŠ2«u¿(J"BBé*,ƒôìMsöK#esîÊÝ¡k ¦ä.4"¯üÀ›wþί¼[ósåYò3Cò³šhàúÓAÁí$€ ‚Û ‡à;€Qì°ûéÿ@n —2˜gs<º÷3_ûÜÕöòdgŠ.,“xK—W`4Q²¶¯M?KŸÿ!˜ÏÚ#hˆ÷s´&ý¹(š¬–×á@r‹dwÏ|ý·äÞ9I¾›sNB“Ø ˜6…Eýž×ÎRAð‚`ˆ/Ý ‚Û°‰yÅ>¬è{([Ló¥í‹?õÛ_œ¼j–'ó,‡™Z§ƒ´Išš¥ÌœG-9-Qò²Ûªö'‹îk_ Öá2 `ØõÁTF»÷CJYqNI¤ISr2M9_þ«ÿôÏ¿pšON'êݳ8šb†òöC7Ð#Ž>‚ ¸½D ‚àÖÂõ{Ôþ®oÉí‹>î Í=»u{¶ûî¾å{Ë<_n’™ .z ¹wÊfV:ýHåúx?éYž$[Vì²n‰§'Ï€³ìÈaÈp!§†yn4¦ý—=réßü³ÏîžûÖl’5fcy8ê‚´Q0:9áAÜ^Žrâ;8‚àúYµkµ¦t9xòW_[‡~Ié¢a’Ý[úÕÆÓãÓÏüÎç/v:¢Z‘4X⤱¦(ﻜaTÙ`ƾhq9V ¬-9ËÛ–QÀÃrØó" ð"Ê Õ EzÓX›Ñ¤Yög?õ¯þÅŸ~«Ús]ÛJn†È?З tö>@Áíæ( ²‚ ®®ÝV¯®âaúÁëoBžS2§;¼kü²=ó+ÿÝ—Úí½fËËYM3ÉÙa"ÉÌ N&ÒŠÔµ-OÕü”òß~„¤#¾èµl ¸t£i@¹º2TX’ÁòÜw&[ûûßþgÿèó¯{Ù¥-SnRß`HuOÃ)9Ö ‚ n=! ‚ ¸=ÔXöZëÏá¿Ì\’½L_ ÌDïä†+[ç?òËyé»››ä¤lš&Ì€å.ÁÁ,σœ¿ú—¾œƒ¥/öÅ@)3ÐÒ'A¿ÈQïþz—DÊ9£oì)Gb#x}#u“dmn'WûWÿ¯ÿå7¶òÛ ÛvÚk¨+)Ç7:KõM±á<…'Ap[ PÁ­¢4×é-WÕ¶;Û`óûµ¶èQé×)fÊ‹œÉEsõá7ŸúÄÏìj{qº510ÏžÕI Œ4F:TcÿeìÂÌäb/ò©u¹ tpñ×em,l4 ŒBÉ@ÕB!ѽ¥º”} {/}àì¿ûçŸÉW¾;m’{—ŒèçÔæ?ëJŸÍ?8:0IAÜ  ‚àzáAw—Ý5{EÿØÄgPÊz‰Ùo¤:›9sqîÄþ/ý“¯-¶;&³&sQBÃ&ièøIŠ :ehV:ô“½1¯Ñ[`Mß³ÞŒsÔT½áßC¿¡1åœå0Ëû†> e£ÕŒA¢+%îìçÿú;Ÿ~ÿG_õà6rÛ¹WEö¾:Cj€Ø8×AÁÍ@Áõ¢»\ji»ôìp»Œü†xöÜy~¾»ôC?õ©‡ÞðˆsžHåÙÖ4 ‚”ë`U{ßBtÀp£,‡ƒ i™X1û8žê@òR\Ÿ¬ ÊÐa¹ƒ»FÎŒLyéÜû^~ò—üíÖž£ËX}bT °ú†«²ªÍ-‚ ‚cpÈwgd‚ ®ÉaÖçñƒÔ›ýPGh¡ÕòÂR÷¼ü]?û›ó×¼í º™Ús¸' ‚X»ð«]3‘ËÔ¦üuÏåùåH२ºÅôW_|ŒñïáÐ4º=àHhÔy}¢4#UÝŸà"rƒÅ6›v¡“Ùî3OüƒŸýä[·®Ì˜]µã»g_5!l:UZzAÁõÀµß•p‚ n ®£²•£¢ÕýK¼4 ¢ »N’_•foüÀK?öù'÷595mlŸì`t9¥d„ÕÂ]’œ¹…«V÷Ó¼JkÎ円?# K£9ÀÌÿÙòEæä ¥*ïïÏ„`ÈÉ„äw”ôäÿþ÷azõ™)áž-+±1€¥"I£uŽ~G ‚àƉ.@A·„ƒLÒý›¯"X±’ÝH Ú.éâôÁþÝòļi›YÇ›VSC3£A^´?}óNfx†Ó¬Ôƒfheð–DZošݽ áãƒ7=òhIƒs®™ˆ•À}MkH¦lÍd*¸©ÛxõÂ[¶í7~ô}Ó½+žÝÙ{%U 4®7P­®{ä²+i¤‚ nšp‚ n ®ßäúÌՊ'„ÜfÁžwú¯=»õàÞdÒ:Z—&è¼sï`„5$”2\‘K äªa÷Rûë^ ñ¡ã¦´"ý/±ÿ¾ ®».-tí9ðq°¾ïTîR¥Q©Ô¦†L†¬Íö•g¾ûw>ó¡÷=–N”†ò®½t©x*û²„jö—Íú2ˆ ‚àf  ‚à0Žl¾¶]º²…¨bo+1w-µXLü¥üèCøøóÎf{¢ý«;[[­%·†à`Ë89ZÏ$iÀ1µOIQŽÕÁÀÃAMX#ë}Ö’ Ë5oZû’ò\’Öƈ9HÀsîÌH33´ÕLçÏ|ãúý_x`ÿlLSTeߢr·.XƒCAÜáA·ë‹±­•Vûè¬2Òã«7f¼Íj[Y{ñôCßÿ›¿ûW{à©m»ß4p¡CaÅB/M3@T†dV }û܃ú&¡}ù/ ÀÝ—£‰W–X‹xûúàƒJV¼ÔòaÕ©À–2þ‘±^Ò ‚h/¾¡Fʹéýgÿõo~fzõÙd&¹q销Zª}86øKº`uMAÁÑD  ‚å@‹sUñ3ê‰yЖ½–Å@$ Kî“YóLn>òõúÔ¯œoºù‰Æg4t%ådVÂßFK.@²TfùZ ½Po%sׯ>Ãx}¤p'–ÆKVg ŒSSv¹o¤A¦T#úÖFD“÷fºµ¸zñc¯yàKxu³wJð!¸?ôE¯@‚VÇ |€ ‚ ºA¿»Z„ÊeçÌuéÿºiªZÅ:Þ—‡rk OÑÞûË_ó×¾åJ;ŸN¶é`–²5)!+±©½zªùkõ݈®vÑbæ,€T¦ŸÆQ¿~öjŸš(ŸÑ„à#ÏF}LE=d”@™»÷ÒœA?Ôg,FjLfYœpšÏ}ûýâ¾íÔþ$·î"`ÃLý‘¦hèq4’%ÝBàÚÕAw%‡|±…A0°fYjõöð³æÚãR3èZœN’]†ÚKÙv>ø/ýìO?ßí§ÉÞ&¸ Ûéä4p98„Ök÷ý,G‘ÿWÓ¸¶ª-õ‡ejH,Dß©g3Ü8ƒ°g¹ ‚ æžû V+ˆëzì[ J¤8ñ鉮ñ'þú?þæØ?Ó$t^Ç ÅÊuÅãE¯/÷ } ‚ ¸ PÁñÌA®ú&ÿ5,Æ‘µ\Åöp8Ie¹¼›l_}ô•þÊ×¾{eo²½%urO„`›0—w­þ$i5Žï(íø]€ª­âŒßŸ}@~Té»< 0î»sð¡­2צC”I¥ xý ¡2€¬T—‰¿LFCN³r‡×låßþìyå¼ RNdH½0ÎH[5AÜáA lj~Æ\o„xú»ÁHÑÜÍš3ÍÎýá?|ŠŸND÷ÊáJ 5总¼tÉô¾ý ':Ïf¥÷?U4 /í~Ôû% ’I+SêÑÒ«žÁÚQj EÂ<çåæUÊO”ÖEìï“„¹J1°®.ö·¶O,®~çW~ø{õ‰i^ä,‡[p¬a›©­,ì–¸áKAp@7LÿÃýZyøÐh¹F*¡ˆYÐOèu—û¹Ü½ù‹??ôs0£é\„L344æDߣ&>Dv±ôÿéû.KHÉ]"‡9[`yzEMC,EAÂJÑá¹*"8ª®»V©<®Æzïh4Ô·$$Ê ‘šN¬kµÓœÜ?ûÝ?þõO=nÏÎèžÒÐT««X©dؼ"7Â%A÷2G9!‡ ‚àžæ@ûï+ðøŲ£] Ëd×-fÖ¼åÍÿø§.´i2M&÷l†dÖ2Êå ÒûbZðÞ à^¬ÿ‘-Kãÿâhˆ´²æbFW Шæ¸Ak•ÊäÆÁ“áR›/ ^[Ž’õ‰âé”},Ç}Õ—ôœ`fÀôÔþùþ«sg÷ÌDÅyé3åçj±Â†Zÿfä@Ë–F7ôò ‚»•ÈApß²Yò;â€èþ1ÍÄqì¿qK¸”3Ú.cbÏïœüðoþݧçM³ÓЕH\žs8dh’ ï z0V%½Ó™l´H ¢±þٛᒗ$@)­UNç ê;ëp¼vhT«Š~–uêg¢òH´ƒ¾¢W­OD°Ô82 a9M}§Ùk?ðêǾôÑ7OÚËî™B•6õb©~:ØÒ¿ÉÈ}XÿAÜw„ÁýÉf8ÿÀ_.íÐaƒkœ}¬½¿IÐ'0ëܦz²IoûÊ?8÷Ø÷uMÌr× 23ÂŒL0¸£w)Ћ=ÝÝéµïfÕÖþÀ@wï"k@qG–™áé¢ØYV:«æ+´ˆûTÃòy±Þi˜rÎX¤þboî*yUü/C ,5]v’û–5ùüó_ÿôGÞù@ž2çœ{Íz_b´ŒecPE/ÐÍ8á Ap¿@÷!¼v@ùÚbŸMSy¸+ó¸‘ÍÛŽæç¯ÿ±Ï?öÞ¼¼Øßj_,R“ wFùÔt>1³Á í¹(ö‹ì¾(æ­—Å«/üíù½©¿q×DþËðýÚQpÈ**ë«!~ Ý>«bÇù Ü±Z \,úÎÛ” ˳æâÓÿÃïüÂÎÕçNLåœ@‡¹f+‹Õh]+‚‚ 8áA„6ÊÛ¡ÊÇ—ƒtûYx™àÛei±ϯ{Ç;ñ+Ï^½2›6žK/ÿä ¬q/¯2¹Knt"K½}Ù³Kf FQ¤%$óD¤Ü±Tû`|[ÕV$˜ª’gE¥?> Z{¤?D>ƒ¤èÞ—%×܇ŒdŸ«(5 Rî'~õÃÍ H˜4ÝÕWàò?üÒ'yõy±$2Š®©o&ÄANU\à AG@÷\ÿɃž9¢4”ã[ƒC0XÖK+»Žå’hÈRîÍä¼Mâ·ÿÞw÷46Èãdb]^•jÅ®*™ä3™ø’JwQ>èï”&‰f­Ž £Ù0€ãƒâJД`8ôˆG'hi铼Ÿ ,ï#òõ§ƒÕgÒz+^JòÂ,Éól²£½‹Ÿÿ×}äûNL¥ì"”ÀD åÕ (žÅ¥qàbƒ ‚žµo÷p‚ ¸к¸Yóz˜’œZÉkj¡:Ž€—h4P¹³†Ocòî¯üîÕ‡_¾'Ÿ6¤œ’·š¤Ô=·FwW†É44øa©³Íî’ bá—øz- ècø½((uÀ㯒úJtý•E 9ÁRO¼ÌGˆ½C饇O­7(‘zý¥¥©Tæ%/f½'¦…k2™vgÿú_ýúgkÏÎ,y–{ª0Êi=È!Ù¼TAÁQ„ÁýÃ8Â?zàèͱiç;‹sú<€–¶*ïäò‹¹{ð?ü’~ôüb1™Nº6—0½Ør÷‰!È“1Y5½Ët/õú~«ÁpÒJ·Í2/ŒèCåK9?ûÚ]õ­yÆEÍ}Î%ý€6î‹ÿàÓÔ«€ÆýRÄ\î ŽLëÝ):J€ŸÞ$CÇíœÚ;ÿÏåÓËÏN›$G¢-‡÷ï^ü‡Ã®ÛêÕ ‚ Ö1Ä×d÷·ä;o¬ÿz}Š–&2ap‡¼Ë†ýÇ^ñ¡_þÚÙÌ4<ÃLHc“=[íè“’{iþ“³DÊÌû$@–g“m @dÊÌb¼5XÚdþ¥gmZW¿Z ÐGþ7õô:ÐYPý˜+u¾îõlECÍ”vF2šÜ—# 4S‡$›Ú–._ýÑï{øèÕœŸ“¡Ë‹ÞG¢ÆÀ:CU×?8½IÁ2šz šýF/ÁH-Uê•Ç•äÜ!¹¤­I³xú[ÿã×¾ôÐþsÈ%VV:8 5Á1Úí¨£OXÏqcl~nnÓ')‚à¶s”A î 6t,·Åfjd´Ü9¨+ʼã}oþägÏÏçi2uÉŒ$ÜD ù÷†8ª"¿ÔË‘VŠ‰QÃÞµø< fyè‰C” øUá|oÐ/7[Ëêíõ¿ãè8û÷fÝË(O R ¡~"Ù°ê¡‹Qy-!ÀJDî˜v<ã5iþ;Ÿþ`º|Éœp/š"pÿßLyŒ|ƒ[Î2ϳ<†¥Ö(‚àn"2AÜóŒâÚƒwëÍ6ô2 7‹Þ¹ò¥‡ûè×~÷¹œÙ,XJÌ(ï_¦Ræë5ÂbCCJI6TÕrØDK3z,û©OV){ ´,-)–yb¥Âvy,ceÐøöðtŸ XÚÁ¨=ùKRAÈÖ<­h®Ù﬑ ‹ì³t"ŸæW>öξötã‹ìÙ—ƒÍjÙÁJ4žýå]æn“i¾VûAp÷q”yÍ î~J|Zã{7- Ùt Pp.åœÍ³Î}ùk—N<Ö±DýÕ¤$d—;ÜRßÔ¾†æYƒè*‚ï¤ÜÙ%„_ʆë ý•„ÀÊêØg°"Á©n@y/ý—ûXK˜h©ê-ì•} û ’»³lÊ¡Day°£WŽ. ‹pÉS“&„uÝÉæäÞ™oÿ›¯~úå83KPççèýF¾L_óKô£Ç†¥ÝB}-ö?þÅÌ î&"Á½Í†}| Xu ˆ¾—%I˜+AçˆWþO=ôý?t~ÑNgHµ÷¥H&£¡oØ©*p/{t3J0³’€¬rü?}{C³Ì‘9ÏZÏ»|tivW Þ]Ñ«>†§zG`¼éxÔ}Zñ@\hfªIˆe£:3CÒ &&ŠdžÁì³Æ:š¡yx~îýÜ'§ûç­±ìÞŸ}iÈ¡€Ã’Vý“oïV|ŒúßÂ2ƒ ‚ˆhÁ½ ×~ß †{o†× ºàÊ9Ï©üø«¿ÿç¿ü½«û“[]›ÒJÁ-A/FoŸrl³–ò€óEíõ_fyÉ{ùL¥Ue0½ÎgdþQQ•ÿ£’ ng¡–.­öWòZ¾ìHX« ª‚I¨€‘çÑ뛼;SRߣˆ}T ’ Ê !OÓ4_9÷ñ·¾ìg>ø†i{™@íT×ÔÏ4Í7 ^ºŒÏ…6nAÜÕ4‚à®…£ŸnÇ7Ý ˜©f®¹©íÜòù'?òk_?ßœbcÞ¶43Õ÷çm(Æ-‚•ª*—”"ÜHbF%€ªó…ûH6Í!£¡º€J Qõ­6¹´¹WD7uµå·†¸¸ê›o„þGçï³·|¸¯F`ÕòÓå ˃²]ñUJö£Ȇ|©ìÃi Œ„Éub6ŸùÞïþï|Àgjårx_tPÞ±Wü,©žTõ'äÈëx3 b£Ï[ÁLH€‚ ¸×¹¶YiÀ¯!X.]îHµæŸú¹ÉkÞ¼—÷'©aéåw9$mMo_Eÿrlµ€v¯íX†¥´§Ò¥NÉ­ïÔoÑ bÔ—kÙœ‡#»½$–º"Ž^;Ãz×X‰WÇFuaî4“«×(Áz­T™˜V§“ EÌ” K–Õ‰h“˜ÍÒÌÎ?ñ?þþÏ>Ðî™YVgŒt9ãª_õõ‡¯üFÙÜW†ÁN8AÜ{p”½µô!ë¸ïÕÿ¤!˱¸ÍÞ÷±×|æ óSZ´ K–Ì䵉Oõz»¾Wð³Þ`¦™³q$&B^ ô^é²T½ Âþ⇌ê}ëñW¡Ïhÿ£|@É$ô[¡é?ú4 °O, Ò¦ri–ÐuPŸ °eQñ¹è½c"A¸2[Çt2™åÝW¶çÿÁçxkï’gx/~ªÓŠ¿qP£Ñ5[{ø†Ù܇6~AÜÑD @÷#ëÿÖÁih4ÃÞpyë9§Ù•Säo}íl›'“³$÷.·fª2õ~Àîг쓪uÂH`ru½>¿—µ,×P,ø^HıĦÿ0 ¬7ÊÇúž^ž?Þßœ¨¥¹ÏÚK´î®×ûg°VjŠ[Rçqû•nDuÑ‚l"kص‹YšiïâO½ÿ5?þ†‡¶Q’ 2”¬Aoy’ªàr0ðMšçcÁ6_s;ãOkw.‘‚àcÕ˜½eÙQY(Ón{“ռˠÎZó#¿õóíbÕŸ§”röÒÖ²4ݯûA˜®ª7Š¤¹¹›6­×¾ÿê|‡â\(mpFµØÚöþÂrlX}õê@àR\Ü{7p¦¸\R™Ò¥ºžâÞdät‚ [t¥ä€€Ar¹›™»—Ò…±“P”X (ŽF)gÎ8kÏ~ë_ýæç^ÅK[ ]וLoŒz«ÜŒ]¾Yò»û'–©€ î\‚àÞàÃî–ÅaÛ©V`èÚÎä¯þ±¿¹õ¶÷]͹išœ3èŽÜLR› V43y/\©Ý3œ¦©u;©5ºÔ¡öÆ¡úк‹—˺×» u:VtF«E®×1ÎXoã47eIc ¾CòÎvO¼rÖnïæI–•ê«ob4/i .­÷~tHpÒHX3zg3Ûâ…§þíoýäÎü©‰1çÌ¥èhÔýgõg_öÀá*Ü Ö¢þãŸã ‚ îD‚àÞàš}jn%P_úöf¹¤™;˜4 “(W .€äýă’—H$d8¦©Ë-·<姾õo~ís¯ÀÅ)<»÷ý€j}E]–6¯þ8p®á¡þÏ!ï‚UG$ÔAAÜ)„Á=€6ÍÙ[ºs- JApžÕyÞkfü¾·¾ï§~æÙËWšI#uh„.n©¤è’{/²21 ÈÌg¼øøéóï|ÙÕ­Å_lo]êr{îââÙ3W@œ„Ãû_’r‰fwø°ÖA3 ¨#~¹6šîô±ñQKþUKw÷×^B+'¹47í3¥®j;Ÿgsúb1mÐÙÞÞìüÃï<5?qÙ' s(­Êx†~¦Ë÷.³Éª–ÉN›Ô@MsÒØ<¢Ý?üÅO¥Ý )÷T4 Ó6? ·.=4.X{ä°ÍÆDŠ ‚™p‚ ¸{9$š»rïæ­þ]J­*%t]²æâ‰ÿÆ?ùçOìî§iÓ—éšÁ3Ȫ>'£QCH ÉÑ,¼É6ó‰vñ¥?õþ×]œí}c6Ý´·»—:ûηžœÏ3Ñd'” –x·`2Ë€[±|µÿk”´,v{-–=èdÕªæÑ €5›võ«z ,Ó¸ô”“ˆn¡va"åìÚ‰µ–æóí ¿óôÞÉË‹I ¦„‰Á$Yñ—@ZYm_À~·ŽdM×ueÿmžOš™vÏþÄÛ^úÙ÷¼ªi¯æ,ï}º®þˆÆawmÆÍ¥ühé ÍxäK‚ ^h‚à^b³ÑËÍÈ-z£¶*àÑ÷ýdΩyÎõ‰ßúý3Üò&Ì9“¼òUECUÐ^Ô,Å4@ĤÉ;¼ð}_zß«º­+ß<1i‹N©Yt9¹u{Ýw¿ý s‚¬—Ê€K.e¯¬³~Ë1—`¾ú z:å ïÚ¹Œ”/+µzÚêƒËwª¶õ²ãM0L#Œ€w­Ï» 2ï0e$“ϷΟ~çÉùƒ»m3WäV¦£Ì@èG%H}N¡f ²rJʤ s—w&Û‹‹OýÃ_úø›O\Þ¢ä2© <{9Ë’€êÿÜÄÇá†Ó¤G†Û&‚ ^L‚àÞåf®:=·ï>˜¹­›çK ^ùñÏÞúîËÙh ='K„’Á ÊQD,1Úä]‚Ã=Ã:Z3ôÔ{öÃ_˜^ýv3Í‹H$óE‚Ïlræ™óÏ?{~jS/+0sIpÖõ XÑ÷»K},ßÌä^ç÷M@Ù›îý0²aJت©ª•8ø¨~‡ûPFШ”çs¸ÃeY*æd™“Äʼns§ÞÝ\}Ù•«³yFƒ<…¨†YYeòqßœt°Ý½oõ#˜Œr™‰†˜^~ê¿ú“§öÏLaY.õí‘úS2Zñæ®>w#h÷MxA¼Ø(€ îV6uØ£gxÔóÇ`‹K*qv/òôìÞºw‰»<ú¿ð•gö»43÷ܤT$+®\ÞÖzATÇ€C™mGcc)?÷ö—í½÷‘ Û—ÿb6éö2LÙuš/rc ~"|ò‰gç{‹°—[²¾g5“‡>ÿ*½5UÕÿînf5¨¾œ¼<>/M—Aý‘xžk'®=Åå#ÃkË}÷n6[n@–i‚D§D9&yÿÄ…Óoßj¼’S Â$fhƾha¸Ž}g¡âM)Kb²”ˆœpÚ¶oz0ýíO¿«Y\HG"ý‰v”ÉÿBZäaýApÀp‚ ¸‹©öçÁ·7}€c»%p.4@&ƒË={âÝÛ󇮴“}O2é¨m@Z_\JzMÂÝ™3µ.¡IÓ|ö;ÿî·¿øÀÞ3''¦,©åÉÔÏR;Ý„]~*ÿ›t9‚ nŠp‚ ¸ëàªýtdàfÞ¥/že0už5ßhòö÷½þ³?u±Ý£èÙ fL]çD*C®›¹Øò¦œˆœ»l°Ýtæù±·\zÝô¿ ³…72#òDÞ$ &X;ï Ö(ÉE×Nsâÿíoè©ËÎd¤u’C0–²ã!Ê_Bðã½M†Ö¬ÐͽÕû¹| ôMÊ,a#™=/æE}ã@)^:K~BžL»É”¶¿uþô{·w½²;k3ÕÈpP*]}ª¢©VP÷Š#’‹ 253ëN\}æ_ýíŸL—Ÿ¤2$PCt5É£|€[Uª{üß͸A7E8AÜ]õ_{þÆÑ迾5>ÙI¹Íi:»ŒÉ§~çï}çÊ~³5#Y¤7Žœd4!ƒµ‘M±À‹IFЦMžù?ôF{,s–Ï Ñ^f6¯…¸T@ë2r甄lHrC›òÜž|ò™’¨Õ®†Úd¨èe\}ÐRn@¹JÃÌVZ|ö'k%m0–±ŒNðPÈÐ?¦¾@K ÔÍç „ €|/5EÆßWÐ%'ØÝ:ÿà;¶»¯ä¦ƒ®#`fž¤÷&üðÛ᥾DbBÛMí¤µù‡ßôè§ß÷²Y»@'È Æ¡ €µ^bÙGévq]ÕÀ7PCAp  ‚»…CƒÕ+Ül\µ×Ÿ èODˆœ=Mø¬ë#¿÷ß_Ø:Ñ5ɇR“+©‚¾˜6Õð7‹üÇÄf.'‰õͽíêcö—Ä%OjE3ƒ’<Ã䄃™¶—=ƒîÅDÑm§íï}çéÅ~gJeˆ® ÈtaL÷¯ ôíÛÿh™Ìü¡A×~|2GjêñJ*嶹m½ëªÇiOæetÂ()a¢¹Ø ±hš½ÅöÙ‡ÞuÊÞ§–iê™ ¹»%Bnµ)P Ñ¨eI@ž¤É"c’¦ºøÄ?ú¥O¾nru[îKNBýuéç£õ‡uè‡äÄ97œrº©Bõ ‚&€ î®eÚ󆌷å·ÿÔºeg]ëûEu¯úÄŸz÷.vJM“Ý%¹²Ã-%ª„½]Eð‘E5‰3v§ñÔÇߺýpûÄÌ/!qßéÊ„èÅÙ0À`³Å¼…‚rP’˜hû¯ÿâÛ5tš{V¼¶ÀG?ÿwh„¹4üG“€—¦¿Võd®ü; #G ˜å®nAYéKT+ ¾ê,²á~9µ6¹I]bÂ|òüλ¶óKæ{Íf){GƒÜôM‡ $4Ðû%ó!f’ÞjÒùôÊ3üµÏZ<·Õ.ë=I¬•¡È‡|‚ îe‚àÎä† ù·Ü×ËöšÍÐ9rk[¦W>þ¡¿õ;Oíiº=aîŒf´3šœd$8é@¦:Rîî–2ØΚoÿè;º‡òŸZqê>KL €D-y1›eIæm‡ì„ d†ÖY©mvÏï{î¢!å ÑHS±Ž[)ãí¬4õÔ †_í©o®Ÿ§ÑÞ@¦EËœG…¶ex£›g/£Šû’Šz†ÁdybÝÖ¤Ì,-fgN¼+Ù«»+é2'æ.”àr÷ZlÕÇê êÈ_u>%KÜ¿úöýë?õÛ?Ë÷L³Á½é=¡â&]Ó›¼^VÄcÇ&Ä?A¼„ÁÏá±}Žþ;2CÀÑæXßpl·iˆ£ÓàÙ».Û„g•>õÿäɹ¦'§í¢«:›^ ª4¥`¬ÍJìÚ§©;Õ<ù#oM'vÿ¯).¢ÁÕì4O ¡L¹"dVúi¶¿» ’»$:Ü™•AZ‚í`ç¯þì›È‰N–æ;,‡ÎÒçÒ¶­âŸ2ÍX>§ªégÈõœ\S”>n$DJ`ö<_$‘ê÷®~³R@=ªCèUHeqé¯ä€ÜSìOÏÍ^­×i7]JƒÖ:à>¹0ÊH({–³iJÞÚ$MqõÙŸûØ[~ìíLýªCt7ÂÈ’‡è;”¢÷—û°Ü˜+y«*‰ƒ nG|‘…Á]ËØÐұ̶¥™¿¾£þ?Öñ¸lè‚Ü›žíü½¿ñ^ù†}Ël;£ªMó>š !5©Ô·:&3°ilÿäì;~Ëî‰ÅŸ§4ïˆVL —:È$ÁÝk³K™öÓD:œFÈDË :vʘøô[ñ­i3•¬“hI*²÷\ðªýy€ZÄ\†c¥3—‰Žåÿ-¨âžÒáG,Ú~èööRFR©±­ {Ddž2e&°,D*—Š’Ó2Ìݲ(f5É[f¯Ó‰·L/¥«hš²$ßBbŸ\@™ ,$K‚CÙݦֶ&©;óô¥O¾vzeÏ*++ªóuMýWñÚŸ¯µÇ$<‡»ˆ¸LÁ]ÃÖc9ña‚àä_9››\Ë‚Òê&eäoµè%åì‚.º^ñÁyù?vvo>±™K.§•ªZ €Fs)2eÏ |fû/Ý~ö#oL'v¿=å¼3ÎCN" U ÌhµpF¤ý½¶Äô €{©~u 3òÖ™§/í]ž«ÍŒH,oX[Ü°ÌÌZ*‚FEÀ#¡N‡Ïamð3ú9œ¤jß³ôÓóÖÚlÎRþ뎪/rÐà’¡L- pÙ›Ö5q0‚[#0O—ñòýÓoÛºlç9K.T§±õóŠK}6Hï3‚0wqæ´ÛçþÙ—|våù)Lî&,{ƒö³ý,Ý,cgôøž@ü¥½ëˆKÜÅD ‚;Á~:FXôz"­Úø9Šz«/ní»[fÀ»Ú}øåý;¿óÜbQüR²F*AuS‰L›ÙÔQÈ.&k|±ƒó/9ùć߼;ÛûóÔx'fO4¹Lƪ¦tU I  "Ò|Q"×EÀSÔF"è$ÌrömÛþ³ÿú†[ÊM—]PVi€_âäty-ò\Zô¥=N-¢ÅHCuÀ¹äDe9Ñ ’Ów÷“CìÇNº¼È£J#NÕƒ- Gu²Š—…>®:MÍÄ'S¤<ÝË/½ôÀ{O· š6D§¬”ÊpfƒÉRQ\‰"äÄÂ-af»ç?øÒ­¿õÃoš´WÊ™©GP Ö†¦úNÊõšz×*Xî>†¯#­Þ‚»’p‚ ¸9†õý¢‰ÕJ‚MµF‘Ì8wdwOÓ³YŸÿ»øLžbb„»çIcîNBʢ䵷¼;$·Dø”—_ñÀó?øú®¹ø­fß­k•Éœ@¹œ¾]/Uì»jÚÞîIW¦ÛºÎÛ¢èá©›§§¾û¬ÁR¢L°T*’«×PMÅÅ(Ýz–ò®ùèÖØ,5òé f¨·%_,˜áR¿gŒê$Jò¬œIY]Puµ†1eeµ.©VR8€n¶¿ÿйGÞs⊳†DRÇdV·§¼80+Á|O´4®;5¿üüïýô‡Þvzo;¥ÜõÇSÅQÃïþ#±þAüD® csÃÖaxw&G$âªwáAp§q­?¥7j’­¶hˆ¾rµÜ‹Éì2Óä·}å«íkÞrÙØLÜAvÙk+ýþ­ˆÔ;$Ç–³¡ÔèÙ×¾ü¹÷¼þ<÷ÿ¦ÞÁ]0w§Ñ`Ð2öÞ+@˜D9º6—'Ê6Y¬ºÍLPöÜpë;ùd{ÅS;õŽ‰“Úr}h½ªíÑËo–§Ì%RˈüŠht‡.žµúaâ–ÚÜíÍ«ÅÅ  ƒ(ö¥ÑJE4 VÝ«RÜ/¬–)Tu>h;Ñ‘=©M[W»ÓÏ>ôþÎó\nHkÜÁR\ /êˆ# ¹Ð2­Ã<û4mû™oý§¯ÿÜÉËOÏšÔuY^µVu}Õ#XOul|Ô°zrŽÏqJ6íÈÈÜá/9w6ÕˆOqw‡ Go{È3‡• ôôñ<ÝðEÀ ¹·¹ÛG÷À»Þõ†ÿìó‹.M§]×¢hÕfä^úý‹È„·rÒfðYûÜ{^±ÿ®—\ÞÚ}j‹îB§"œ)’~öâú>Þû%¥P—4ÏÊÓú©µ*Vt¯_w‘F³ÜúÎôÔ7þÏ¿˜b+)QJè%= cíï^ß@}õrÝdµ;~ŠVD/ㄉÒaŽ¼7gª¤æ€ §*º$øÒ)ï7Ú~œdkФ®aNœù|û™‡ðáË[ç|Ú©?¢¾@.%&w_J¸“É(§m÷]ü£/|ºÿäÄLòZu>þ¿¶n®?0º}ý•s}­mÆ„¶äg-€¸dÁ]Gd‚ ¸{8v¬bÞ_ý½áÔTkL‘2Ù¶6µ §øè×~ÿ™.qbô"k7®ÚýƘ äVÞ)Yj²ï'}ëƒo¾üæG¿7Éßë„Œ‰kB˜¡Ê[Ї½ÉZ˜ª¾±½äÎÛVbΠ”À–ø8Y:÷°¶²!½å|·{ê»OÏlK™Yn–P ^{õOovÝôé^sµ3Pj¸y–5„Éiú|_m6äµ º¼thª’PÙ¥jqyúðT'AD9:‘NÓ´éf©›¦mîï<ýÐû¸²s®¶°¤ $+E½“SêŒë_4‡ËéOšY¾|éo¾ù_xçËšýË]r¨8.aä lÆúG3®“ÁL¼^ë0‚rw8<èƒwáAp‡pdV×x~m/cƦݨö·¯¿Q\bÛvF<ûð—ïòöK½wOM‚•þ?¦\ì&HÉ1%iØ›òɼ^o=Ý´ÏA.ã¢ËF%¦¢aíóOņƒž4ˆ„Í÷ž5˜¶Cl¼(”Tû!5„4ÕÖ·¾õ½.KÙS2ÉÍXììâ<—o1î Ê>š>Øö½v¨æ–ÊøÁ7 åB—óþ¢œ³".ê}mœb”C«¬¡ØÞý˜à•({o,«Vé"ƒ.e¹c;_Ýzö¡8Ý=p¹ãU6)·¹1“;A——r‡âX¹;„d©qCÛÌÒV>óÄýÚO¼íÁ½™Ï»œÍ‘V·!{pðÇHkŸ£à°Oe„ïR4ú/Ü€à®$€ %×i2åº#Ó´ÿ}”œ ©œ»´xn’þäÏïüà^Ò`ëYFÅ3 ¥ãd&æHfäÔ¸‚ßøÑwuMÿva¦• L «x§Ú÷½Ž§ÇQzw Âý½Ý½&5>Ì­í5ú,U³5þßÛÒ’aúgö×Û“m-™—×rè’E!ƒ¾ êz üHö³4„—>Àè"Pj˜ºý}d§J§Q¢Ì2+o§ñöýe=/¯ÃðcÇl¸2å}ˆ2àLYÍV7ož=õîSí#‹½´ËYZ´95 ”Rõ”È$™h;!YÚI°gžøw¿ö“/Î'*×*éÒƒ©‘¶ù¹Z—ÝLÄwœ 8@yÜÍÄ îJ‚àá klú/p`Må›QU÷^Úm‚¹SﶶÛW¼úþ—žßÝKiâÙË÷¤”ÝsQÖºY˜S^Ýæw~ì;ìÿÕ‰´¯¬ J³‹@_M[¬x—ÀšõC€-ííÎK£¡Ä4l À«´§ºD&`Ÿ<ó½s—/îQ$-1­ä ,YÎnV¿ê5ÈõûYa„Jã£Áú^9KÒ`±’„C‹Nmf•ö¨dFUÂýÉEÉ/NM—Qn.!7-âe%BqRĆfR‹fÊyzþä»wü%»{vÙ¶R›Ûd{ÕSf)»ƒÌrLÌ‹¹k¢®{ýÉüõÏ|`rõ|“¤ò‚^”$m~®^Ìè|dîF¨„ ‚;–òW!>¬A¼ˆCÖs=‘Vo¯–pŽtÿU{–RÞÒì|³ý…üÏÎÌÖ˜h&QF‚VíUoÙ›‰ÙÄÏ<’þôo|3Ýÿ«élÞ¹×1S$”K_!Õêb,î%ð<ÄÞ‹´d)íí-h¦ªáLT£Z#Í2™yöN>ô¿ÿþK²²º,‡Œæî.5MãƒF²Ü·:X‹%'Ò{)–Ù·þ¯ýˆ \ìîÒ«¹_öS²> X½˜$­ïw$¡ŒêÂr"qÿÔê•2ÐihRž°MÍŒóé™Sï8—vWír³5k[!%¡¨€».¥TôOåàšÆ2˜š­|ùÉ/}ì-?ò†Ç˜çY¹ÌV¨ïVF• k΃…g·ï/æI‘àŽgM.vßVAð"Q€ø°AðbÁcýÕ<žE´Yš·þºÞºímt”¸v×vDz®Ë?ð+_9âÑ6D—;îÃ@-Šr÷ä>™[~öå'ŸûÑ·o7þj:i;ϺÒÑÓêÖÅâ. }†ñS,N‡„¾$ý]ÖvJ¿ÿa~° Ý£—ãôV:Íæ»ÝÖôo|㯛Ô2#ÍdùPe;\F«e F”òÛ¡#Pªz-~UÉåó²×ꀲ¶êž€ƒü§ Üq‰„ç\¤K¥lƒ@HX¹Ëš:@_— ÀKñƒ¹èȲF{vöÔ[g[¯ò+íÙÉlÖÎ=¥äžZ“ÜQ^E+c”4oubº3?ûíñëã•éì̘=Q‹1èå$õOµ;Ô­Ôê_óC|D!BpDzVUÁÝAH€‚ x±X˘¢ÿ¹´q{=&­Þò,Œ¹Ë‚®LšÓßÿ¡—~ô'žie[©³ÆzYK±®à ·VÓÆš”Ÿ{ÍCßüð[öµÿÍf:oÝ%™Y‰î{oØWÍ}Ñõæm5ÆYwÛ"@BvßÛÝAš ¥r –Ó2ú~7õ¡”Èvòü3v/¶Öd]çF£ê\-Wƒpyq@\^ôûÅì^mþSòâöwÃÄÅþ¾UצºQ%E@TÝþ楨YŽRáÐg!4”(piî«×þvÀzò •æ£î–ódÚµvföÆfçu“óùÜäÄö|‘ÓdZ ,HÀ‘¬qÏA3÷ ›Ö‘’?°÷ä¿ùògv.?·EË9KÞ[g>ê9†¬™U7óøÓM7B×Ú ¸+ˆëÜ}„Á‹Åµ‚«céÿõïtÈ,,÷C¬X{¥Üyv÷ ®<üðG¾ò[ÏÎ9ÝÞÊm†LòŒÎ‘{­~–\Ôv“¶ºçßüÒËxÒÕoOR̳“d ¦£—úƒµÖ´²US_û~rd9 ÈÚ6÷wGû—6§z­ŽÊh0ÀŠÕ;éÿóÿüóédÆ\Ò¥?&!™¥òâÚŠG0³ÒœVXéOÚŽ78òÞܼJeú„H¯¡_Ö,wÐoÐ/Ù‡§F›j¼Ýò¤ÕúæÑf„Q4š¹Y‡fb ;ß¼ÁO¼ÕÎëéÉÉé¢kÍjG’ÉÔµ0£¦Íþ•¼lë×?þ»r‰L@ŸP•E?ŽÄ2r«â²!Bþ÷a÷wáAð"r@ˆuåÉÚãXQ¤õ§F1^tÙ,_h¦ûõßÛ{ð¥­eL’%&šÉ ‚|ž=æË‹'Þþø³ï{õEí=¸[î¼I‰Uc½Im(w•ìd9þË}ä@)Õ¾«¦ òÒú_ `ƒ\öP&)»1%%ë&yŽï}û{ ¹I&Rp;eš ñu‡;ÅDÈ«­_÷]#òõ\Õè>Ø©ÛŸRíCSïÀŒäI+–Š£ðïm†M—âÖæþÃÑ#̧l›¦iÓ+“Çõð[v.äsÍÖ¬ËDjÊ|€š (æ½ËRÊN÷´e3?÷ôo|â½~Õ4ù<;¼ISËR7Ëc8]ã| &c/áAðbqëãC¬|EÏ=iô§Úg’]›E¿ÀÉk~ü'O½ã½ÚÝÉt"e©±œÕw˜¡2 i§A3ÿîû߀7=x>í>•-²KÙX§a¹TzböF.ûÞA03$€^_ÂÞînf{{û¹S© àÒ\ÆHBÓW¬ö~„jQqËNýõ_~·[Ž¬\ÞÙåftwTR ¶»”ÙûCÝ/«öƒ<‰BÞŸ7°Q-ñ2°,eþ—W„õðåÃÃ}ÉïWˆƒ‹2¤jÆy€Ú*•¹ÔÐ|r¯Ø{ø]'.åçÒ»®³dYžRãU®iLÖ害Éd‹¾÷Ç_ýɇÚç·’»îV]µþj NÍQÒ›1ý7ïŽsWnApã¬}a…Á‹Å-³oÆvÿ{ïÊe—{’žÝè{f‹·¼çí_þͧöç–Ï-\fì„R»›}OÍ,‰óoþðÛ¯ÝùkÓÙŽÞúÐ׳ö–'­vÇ/ÒT›u4–C;¡jø×?IÊó|¾L€¥{€ÑÙ+hŒŽªé¯„Œ˜"[ÛµùÔöƒÿåOþëVÚ2¤–R!Fù²¸U2Žmî*é§Kî¥:xÑi‘ V3+§~hî‰/¨KEA$ïç ÷™‘/±&öâÞNcÿŠ¢Jr$Xgy7¹ê^|èãs¾ƒEö4™dÏ)Yv'`©q÷†H„ „4aûàü¹?þµÏή>OÏêKB@”oË£¹–Nmuå7€FŸß[¸Û ‚£ ‚žkW¯‹´>F>z³þ Iæ,¹rJ—O>øé¯ÿwß»´H©‘˜s:gœ‚è®LäSŸåoÿÈ{vÃS?cÉ[‡äV­ù^çRìúþwé/Ã^º/ ò•Y¸ƒêÆ,íï-\Ì"”´Ö딌Õ®ƒÅú##“DwY¢ÈùnÊíôÙgΙšd EwwÁUFÔwd™l,qˆÿ—§ªZŸ,…Ý}nl\Ža|fG.Á”}wQå¾îAË«ÑŸ­C> kžSßG0–F¨BÊœšìûgý.ØÙt"µ¹KFÉR)ÊH)åV¥&-ö[k¶½Ýûè«Oüìû_‘v¯Ê!yb­†®~[v9²[Κ÷ÊkºA7L8A¼ðUYyó».æºÌ‚ª±t ¹OÏ$~ø׿zyëtKôœÙ$³D/!a´NÛ“ùv÷ç?þ.<äß4í&ƒ²ÕÏÒUßH³Ø»+«)}iJv€}QÀ üq  ¨»º7‡5`ª†vñ.H_¶Úw’>Ò¨ n@ ‘¦~ú/ÿì;“®Án×i‘“ZG–Sy#˜h.€&!Ò`n´\}Q†E§.»Z(£ÇHýs€Áªê ³zýÑ8Ô¿ö1ØøTÔràA=Õ¿¤LX&)SgLðYÛž¾ø²÷?zg¸Õ8šL82ÍeÏÖ$}2™,œ §ºøÔßûÂÇÞõ0&mç®<”6÷µ,ÍV¥Õ©˜®›ÃAã]E6 ‚â/Á É-ŽýcÅš¬?‹5[Å9ªÒñr£Øâ9£s^¢¿ê£?|ê½8׶l¬íº”XŒEÐy'óÉNjNO~â;'çßžøešÚ,‡™ª…¯¾ñO®4ª!­w1Ê}󟾒·¸ fûûsõKÅ2â^û…C[ÿºeiíãÁ„Üv[<ù_ÿvòäI-%¤>¶=€h.˜±´Ú¯û‚C2ZÕöä.ïÏkw>(= ®V?“yÉRïߨrfÿš¡'èr/FÎÄøzÖk9(†úÙ]ªS—I ׬mwžyôÚµç1‘Ë,5®L#eB©tH`ÊØÊ3]|îß|í3§Ûg&$2H,–ÐúaçÃxaûÍWmº‘ ‚àV€ ^0®eýo>s ³GÝXÎ¥býŸPÚóÈô¼Øâ¥Ç_ý¶_üê“mj¶Ê‹âELR#1»Ñ¦;éê˧ù£o½z"ÿe¶]Q.±©#º¼ïç94¬£T÷ƒ®–Zù¥v§Ü«²v‚ÁövçBi´,HÔóË!YüŠZX@š1IptLw~ùÒþ…³—¦šäÖŒ‰DÖ¾³­^Qi"ª¡AG²"4Aûsº¤ ¯-‹Ø»-}ìŸU<øUÕh¨VŸü¥ÚʈZÿô~FmÈ¿òl=|VïÙgóʼn'üðÃ&Ïæ-ïÜRšÂÁRÐábj2(ÉÕ$s|ß´ý»Ÿû]}Ž&•AÎ8ŒEæF££¹™ €6¼¹² îg‚àãZæü /?JU¾„?;|Ón*FêºIâù4ùÑ¿ý»m'M îî™ Äì.7'½±¼ãW_»óÔÇß:ݹúÆw3wÀ3V¬^Z¯€çàp\mЇý‰¥!¹å&Y@H.™KÑKi|ÙËÐëÜÜå;ô¶xÿÖB‚QÍ•¶íÁÿïþóíÉi.ä‰&Ϩíÿ­ÆáËûh9\¬Ú¿]öyK¤¡FvœX­Å'ÑÆ €!ËÌÑ¥^ý,hE´ÅõçF»ÊêJTf[Rjr2‡mù|ö½G>øÀîé yÖ–ÄÆD°4J©)%îš°ÁÕó?û‘·æݯ˜vWè4ɆLAM ²­ãØâ·*TϨ‚àö@·›cÈ~VlÃãîwl©·7ŠkÞF6˜º®1¿àÝ›>û¥ô†÷ìæEã€g3BÊB."ä-;ÿº—<óþ×_áÞ·L ²@73ö þ‡ŠØ¥”¥ ‚zu~œ_¶û_jÌQ)auÖ,AÛvåÍû 43î‡cw÷:]W %‰Fä¹NOúßÿßrrçÁL8H.y]K½_ÿpíî^!ѸÑ9üJ7бJå0%ú.@}åÀÈ]Xu˜Ö?-cW‚}6`tÅë ‘,O¬›™7¶e{ÛgyßÉüЕ9÷8™dä"U¥ì– ’h³&ÍÏ~÷ño¾~ëêÔçõ®ft†Ë„ks«öaýAp  ‚ŒkÙF›B~^ëE½¦¾¾¢ÏKCÑØe—c¯1ÍëßðéŸ~joo:Û"KXHÙ&趺sïzÉÞû^qi:ÒÔ9ÔºÓ`}#W™×UW0Œ÷ [Tcõµ?híï7RÖÍ®ó®-½ùË$`ë{ˆöuÃC/;ÿhï!Ôw7’‚EÆßíb~5_óƒoh_ÿÐ÷fx²³nJ´†rAU*SÅ?C@ƒÔ‡ƒ.è€Éê 1òj©¹¹» ²í:‚îåUærëÇ*ûÒ`‹Ã»&dJ&@É·þôOÿìÄä4[™• ‘rd -@}(J– Z\½JN¼o¸ =@K`yþ S/uQ½dh”_1ûhôAYK Ô¥£F@ãÝ”óoäLÙ9ñÅÎó³w6öê|Ù.jfJ„ФF™ÍÔ$k³ORJó‹ïù©/¼ÿuÍüªò8°”FQÇøß“}œÙ ‚ ¸õD ‚ÛÍñ” ×îÔêÏ‘m6’˜ô •Q³ç²>üõ?<·õÓMÞy×$ë„…!5>Óþ8û¯Ê¯Ù9³íç¼ÃR–^´æªÁ÷R;[ŒT«žÞ€ê—:õ±ã¥°¤v©w÷d‰ K„íîîw–@¹Œ6äÊ”±G>2 Ð`„Õ÷w°C㘑ìŒóÙ_ã»ÛÓÁ­ˆ ï•ý,ÃƨZN¢ÛßKÙKçTš†ÿÐÀtsRÖòúe?èåE’\pmn6."ip<Ð{5k%¼ýñjí7©` »÷‹çú«ÚaUM­tá©æ¿Ö>]ZÞ¥eÌy²‹éÅWëÁ7œ¸¸¸„éÔ UIѤ;¦JéÂÿöë_ÜÞ:±Ë]GP\Vté ÊkttظAp³„(‚Ûǵ¬iäþÕÃþ‡ »8˜j„w„°o9¿á-oúé_zæÊ¥éVj»ý””¡.M ¶ýG'ç>üZ¾,=9É)eZ²™–/»`¢dÍT£»ŒnK¨¢ ¥»€ÕX·™Yé:#î^Ýs¨dÆÇ/ÉFQ÷*Í×RŒ?´Õj·S¢4¾ ¶ÕÉÙ#ò'º½u07© ½ã4+g°ÝÝM¤+ .•G£ó¿·_¹t_»:´xèvº²åÁ­ü·Y~»î,3¨Y ”.ª„Ìb£vzŽ/¿òèÛO\ÊÏÛ–yÙ:&,g –1á—6û‘¯>ÜÎÑêíª,©*ªÁ9…®™ú…“ïÿÊß}ÛÍ6à‹¦™v Rc6Ó¥WM¿õ±×ï>Ò|«™^ÜÏó\Œ^«Aýºÿ¾.´_7mY.Óè6†¡Kƒ®ÿåÙK'{’óù‚»:†5¶,ãÆ–Ç;¤–kð*º!+M‹2Aƒµ_Ö™o>÷w ëL–ÀÜÑ$Š œ„y»ðŨõÇëýoFu ýýk÷Ç©muHÏ>>'ã³°~QW6ØøŒvR¢¥J¿¶[ª£Õà€àŽÆÛðø¥‡Þ÷àY?‹í&»ŒÂ(Í@ÈSjtåÂ?ð¶½öÁéâ 3èyéü¬žîkÙáv ‚àú(@h|‚ ¸UpãÆÆ“Ç1W ƒ°ÖP5¬!¢¨ì ó¥V'?ø©—ýØç/ç½Yr0/<·2€æW^qòù½1oñI5{ Aj”Ñ4”;h}·ŽlñÞÏèóC·Ô^:äî4Ì%XöÿIJXewFÛߟ'³â,mh14Œr{y"(õQ‰Ê£®Ëé&1Ó€Ô.l’Nÿò_ONO[;!À¹œ+ƒïï^V—6¤3Š¾féÚ,UHËKs ‘;R/õWD>À'ìÃë\¿ºëpóFïκA/ʪ!§1ÑÍò,u[fßšw§žÙ‡^qA4£'ua^\¼ l:ïN_¾ðGû'gÝ9iáðñÙ¨PÕç?Žâ†3Ý7WoãF÷ÁýNAðÂrÄÊá™MKjMQíGV›œ°Î•=ÏÕ\zôåùÊo=uåòlbÑ:m2›Î0ÑÅW?¸ûÞW¶'ý Únë9ž Ê`²¢!q¸ú.™åMúV<Äe¦—õ’q3+uȃÉÞKsêÖå¡ÒO4<+w¹ôܯ/,2|ȬX~µ*·š¹Å›XúV^HR4ï‡ Ø4‚Hyrᙽ³ß½¸c;æL ôÎà½m}¾˜X”lÇ`Ý–`·ãs-:} ‘»±g-¤>4"~À£×Lqd/³4C&ˆK e€9“îÛûóíï¾ä#^™>­ì©L(p&kRBÎ §yï⇾ïÑÏ}àu“¼‡ìB¶~IZzò ·šÁ¸þ;ðßÆázª ‚# Pw ‡ä Ör ›?—2¾ÜÖxNÐóÓOüÁ?>ë.Ë–ºy§Ž[d“Ú³o~ôì{^uyGO(]q¢“ÑYcÿ%¢ì ÓHd"r¯Í}Ê]y‘›—~7.ïÃØêÛ†ö¯"èú§Xl;w‚Ùs—…2a½Ÿ}ò¡ê‚Êñ²?Ú2a ¥¨wxÜ) •™.Èåè`.ù©­ÿõOþ$í7ÉOÌóÄÊÝ÷òâêĨ2TWF(µ²#ýzgÎÍdÀpgš‡«”ÔÈë¯]‹eÚ>ÐsXÖã.·U=Å%V¯ª’òâG%§u¤`'æùÄä%—¶Îøv«ïÌl† d´Þm§I>óÄïÿÌO¼z{Öxή:«¡ãpN0JEÌ „êÇçùš"ŸHApÝ„Á­åÖÐ ìKÓ^[‚›Âó‡<ËÈ‹ÝüûîKíK¿š÷m2Ùïôè”÷åbý‰¤÷s¸†è~/è—q9L½ògÙ¾¿®š¬»—¾•Xì·Ý<³t K×|ɽ—›T©?0·;Õ€wß«´vªWmäDY‡MDn›<ü§ÿÇk°­Îg‰êZzçí¢ŽÓ•D‹'S¬Ý¥÷²ð–Ž’ÂÔ¢¥È¡Ô:zË-ôà궃¾ú`µÍKQs¦9Lñ*Õ ¬i-µæ3ŸOŸzôC,N_ÈÍ^Ó˜·ÙKÉRƒSgsùì¿úÚÏN.?±ÓrSu,'˩ćqDÆ­æ¶ä#‚ ¸÷ ‚[Èm1>FFÖÒ€,V¶8vf&ÏûX<òžw½ìcŸ|>ƒÌsîÒÉ$›,ž}ócgßù²Ë?ÝÌö³Ôϵ 9z9½Zÿ½Æ§†ü‹Ñ¯ÚjFËgiU$Ò[êKÙ{Ù¿†ZXPVFÔ¶ÙD°VžI˜ÑHûàUë /5®Ö¿×`Š!QrG-ã¥DC’l’NöòÓß~úTsZ ºr·ß66¡•ý”IÁýy¦øxYW¡—÷‹pe˜‰nÒ”|†ú ë»=[­ç4ú]&Ò&ªˆ‰uÓ¤‰5]Û<õàû[lí-&-¦ì$5™åÍ”Z\~ëÉéï~áGÒîse¸†bæqKØc-Y7g_—#9 ®AÌ‚à²þ_ëܨA²jÎhdsi°ËÁ3—;»6gúÅG}ǯþöšh–-u³-Ûšð„]|÷ã‹·>tîD~:Ù¢Ëî}H·4Ñ)ýþÑç0\Moý¢ü²š!,ÜSì>ïÍÜb”E(Ö†?ez÷÷æ.de3B>È™–Òùꨌ­å2½ C”]€—Ñ`TÍ,(*÷â>YZä¼½ýÀ_ýÅ·Úù‚¢ºl]Fßï’}+—:KP}¤º?öµ+iá½2jÐU­ Ûx³õepsK®‡è륨Š ¼Í8ëæ鉇>ø@~è⢹Œ ‹þ‹lòÂO¦dWžúÒ¾ã£o~°Á^çN/Ó•5|0ŽwÔû7üçôDA‡€ n6þ-µC´qcÔ™§ÄcE˜<{³8»Å7}á«—_úÖ9rãÙ SÍ·Û'ßõŠó¯=ýäÔžòf/ÙeÅH®:šbüTg92ÞêˆÜ>*¿ºýªh»ße±¢Ëã½ žrO$ª b{û €¬z½|¨ ­syGg¡z!åjíµl·4M©T)ˆtÀɹ4žøoÿåÏÓì‘Å|"˜`Þ÷(5½¥¥9Ǻb–.”ûÚ‡åUT¿Üñ<ß56êÁ³Ú ³?¢ê>9ÜR9Ų¶›=qêÒƒí¼ÙMæIÙæÝé&é¹ïý“_úìKò¹YRWÊ+ªc£~ÞÄê2]ÿáÉ’ksÍÓ¾¶A„ÿƒ 8ŠêD¸ ‚›æZ_$‡ªHŽó:alƒ£ÆÙ—j¸jsR·—øØû?ò²}äl{uÖhk²81m˜ž׫ÚWŸ¾8ÅU—·Î¬Ò«}ÓõZ£j>÷=ez[ªÊxÝ}lµÒwÅP^™ ÐK×EP_ `$i±hÉÙ-@ßCs©B–³æt>nØß¿W­Ó¬6)²6`³˜§óçß:¿·×l¹¥áh{eËpnÙ÷Zүɨ9Îȵå¯Öð’ã#)kcÃþ}‡Ï†.}2n ,-˜²å-íNž:õý[“Wîïá\šÂÝih`9sÊôÀþ…ó՟ù§·*ç$YmjÄâs­¥¾V×sÈßbÖ¼Ö›É6Apï€ n©›¶ÐµÃ”ë*ïå] :™ ®¤}÷½ýW½áý¿þõg痋ɶ76—.¼á•Ý«<Ÿyqa]¶FYt•’áÁF"Ê.gÑÒôM7:Ñv¸¡á÷àp<,l´ÜÞ_®¾öþ‡äÆ2µÊö÷çh\Úøà 1ˆccW£ÿ–ç’}ãQ€,Å µíNyKšJ¶LF8Í'ÿùO¿uÉ›yó×ѹu€n5Þ½Vó¢¨â©n€ÉEp%£°©:8Ù°þ¶ËØÁ†n/`*É–-鄈œ ۶رn:x7yjç³­WóJs'0ïænÌ2ºM>ðøé¯üøÒþE‡#¥¡Æk‡³y.–7F©¡ÛÎAY¬ ‚žp‚ ¸y6ìýÁàÛy7‘<Ìv©ö/«¤.䮥/ÎO§?ðË¿û=œlÚòítñÁÉsïxU~|û¹m=ß•wôŽ@¢Q,=Êìk_I«ï=4z/Qÿþ粡Oߨ,ªü‹‚ú¾=(mp#pئV {{sZÊ9o¼0~Ñšõ\-Qô-’j?£Þj'ÍDtH¤» ÜÚ./öÓŸ[`¿™ìÜ€¡}P=xÔ:k}9Ö¯Wíùå,±ìË´ÆÊÕð•KÍUï)ÔÜFÌPÎܲ©æéùÙÛ›SoÁezrÂ:e£a‘·mk~áÙßú©¼åÁ½©r—[÷l‚v7zgmœ®M‡øè3¹öì¡ù… ‚#€ nž# 8­Þ½5TMŠj‡vÞíyðŸý•üšwŸÙ×ΩÉNsùdzú¯š¿jçŒéL§¹¥ œÌ´TüEnFÚìôQó^vS-M'é}×ÿ¡Ÿý²¡ÏhÊÕØ,]+® ¯6) ÁvÞ¡L^:¬¢WÊ—è>C¿® }e-GVo5Ü]n–ܽ” [J„yfîÁÕ\IÓg÷óf¶P“™Ê[÷®V/î1T^+QïÞA#J7$¹—ó¼±Ëƒ$+×ö7|΃6èýê¤•É õaIIf*“Ó6OŸk^?yì^ÁÛ¦yššVH Î~çü­_x`÷ÙM99¼º]ÃöVÖ–xMoxóÙÐóAp+  ‚›‡ë÷¸ýÄ Ø0G蘋 éEÛá­#·{>ß~÷÷?üc?s¦óOÚ ]}drþm/ÓcÛ—Ð:Gã³T‚⥸êæþ j¼vó,ö2Þç–›s)b¯£àõ•}B¡Ø¢+ó~‹EfØÛ«’TMç>…°œ?Ö ~ê$`º{¿¶ê}“ÐòÓ¬t2¥Üú|ß•'‰3ZZ4éJÓ|ëÂÕýɉŽSWébäèƒäË©^×-9êÄÁÝÇ{µÂøÑ• }u_+¥%ÕO¿.¯F¹$ÅkrjòÄóæ"^¾û𜾂§Ó–:ÏŽ<Òî•W5ùkŸý _|>™IjÌJñÅò@F ¡ÅóÈ»Gpc®ó ¿]÷>áAp“l¨ 6uû› ˆãîù@ªˆD ÈnùjÂnûèËßù+ðìÖ铧/>Æï=4}þõí¿tv•yI@#wxißIÉêx«~P—VÅ.šàôº´ÒZ¾êyV¶¯’¤¥ëÓ÷þ//ï+úÖšêgx´ÍÞæÚáÈ°Ž£õs ª$„¤TÍu3Ö]³ŸŒû7/ÇÀ¬!l¾»@N¦&›š˜ƒû“­ï^Üß·Y‡âsÀé0ÔƒZ±h7/ðúõn …ÕuBYŸ9)i” -Б—ý§«8c×såY!²”Leh0Õp1I]C-4»„.=úý_Þ~n±•Õ™µÝéÉdÿì÷~ácïüø[²öÈœÝÌT»»¿H‡ž¥±CrMn,ü¿&ŠBK‚àf`µ3´aÒlÚ·Àé'£ï²Ÿíþ{§Ûoùù¯^~ìñÉöÞc[ϽôäS¯}t÷ÑÙå v=/Jy+—Ö:dH¬ãc1åj)é¨3ªúÐý`ä Aø^)Tv0”Œƒåz•rxž`5¥¸Œ©m[÷ÞéXNúª»-oc#ñLñ(ê®R†Êá4{Q •¡Å0öj÷$·«Wöá)©! `"“e—gN/ië{W¼›žÌHR6Zß‹hXÒš¶ƒC‚ÎÕÖ/·½Dä73DÃE^ûc£åíóºÖF×#âÐ2‰Æ4yžÈ„®ÛÚ×CgùàéËv†[Sùd¾×Ú:qõ©¿þ£_ÿâËÓå‰Í³2\Æ¡9Ò xªŸ˜ÑÒ6{ØS·ŠþßæònA%€ nË°àq7<ä-–;"kˆÛÉÛ)[=ô‰/Í~è3{³ËOž|lòÍW?zöáólv[µl&îb-ñ`ª»JÕ¢­¦{ íSƒÈÞ”/ÛUÕþÒ¾_vÑ©ûÆH/´ZÀ^1®AÆCbo©:ê»J¤Ñýb¿ÖÚâ¡$ Ï%ô‡£Þ¾­Iš5†´¿;Ï ÈÊèG–·”:än–.zzæªòt&BÊ‚©^AŒ_ÿ¥ÃÐlUýá WaíŃ£u=ïx„E]Ï|­KϤúÉ(G¶Ôg„š¹vv󉳯üÐ+÷'gÛI‚¹}`Ëðü·þå¯ÿììÊs£ ÃHÿ¥ñ›qyeÖÛå×<Âä‘‚‚à¾&€ n×ù܈å¨Í{Qº(äìÌݾœ¯{û>ûK—|ñèôòËgß}ÍC{L û®…²çDë#ë6LåÄ9½®¦ˆ`éÔn˜}Y°÷v¾÷ }äò>â¬å>†Dûród@ª›ÏÛâ™puëe¿¡•Ô@]WHÕ!)ÑíZ`)35»W¹3ó™»õš4DW#X¶ÜMšgöó™¶Y¤YW¼oš3Îwv9ÇÉõ W-]e_Õè¤`0ÇqlÌAûÑæCËÕ•aÇì‡@ª£å ,Á’'ÝV|èO´'Ïi‡­˜ˆí¾ýTþÛŸ|Ÿ.žK4y†ËDÉYçSÔõsÕ§»Qˆ‚à@7WnÞbå =’ “p‰¹3ÏIþÁÇÞñÕßÛ}p²Õ<ÿˆ=ûÚSí£³L;Là-`.³¢±aG¬Ú/Rœe»Þܯ[Öر¶mÈ ô€AùS#Àƒ®d0ò­ÏpÕžFíÚþ¼ÌÔeÌX¨öw5)ÙÏÑ—­–m‰$¼Nß…dH '»Wç¹#½¯ê#nD¢Ã䮎[;ß¹4?ïSˆá­´üÐëvÈ£åàÍ ^½™õ­ëÁÞ¬:fc¿c9Q*†I(ÉË)³ÁœPcyjí$e4³fÏ?ô¾^šï s;ÅÙôʳ¿úÃoûÈã[\\ͪÞÑ„LÒªuM‡i|œÇq‚àÖ@7ÌXÄq«ö©ƒeµE'%%£KR&uÆó;¿ø³“7½±³§^ºóÔãí½d§k|u‚ÌF•ö2z™Ž…j¢V{µèGoºÔmÔP»†xI>ô‹¬Z-°¢8¯iY\Ð×HïBòDÛߟ‹¶Æ öo>n«ï9£>WÞ'E÷Ѧ î46{» µfj(‚¢JékGR„@§)Y–´Pîfþõ%]æ©N@ryñ7–uãksÀ5\º8)º¯}\–)Ž^Þ´ù©8 ö/ì±Zg|Ø>XJ‘)}‡~©ªã؆QÅåw’ ?±Ðé§zÿ ÜÃlâ]Úi¶Úóßû‡_þ±Gtvj®ìKÐ=UÀÃÊŽ´Üy¤=ÎñÜXBäVþû ‚àÞ € n õ½éWM”Ã7¿aªî߀ÉÒ­qîÚ¤y߇ÿ䧮àÙWž~ò-yÕ#ûÙ®¶)ƒnBŒðÒG4™!adÆ ¤ŒÂ`S—·ëêÊ‚«)7«½]?®Œ#ͨ¶55$ú"áš )¤~Š—Ï÷ç¥è–ÃÞGº¤¢õw98”ᲊYj†@"œtJæÙÔAb“š­«WÛ®%•ÊjP r3—•v¨.(¥N©En·O}ãÂbúÈB(aB$`œ,Y^¢#LÌ^å’×ÚëþÉÞ)ÛkírxÓõ»ƒòæÛЩú^P]û9me³‹Y’™<íáÄŸ=õØ{™œvÌŒÉf†—O÷¿öùœ,Î%Ë›1“Ùè3v÷Ž:C‡í/>þ?'ÝŽ ]w;áApŒU.kVÚÛ ‡ ÙÇÏûP-œÊÙ­Ý}hûc_þÕ…]yéì™×?påU§]û„¬$C‰]—‰O„(QΪ‹é[þ÷Qù^{Rì~÷þØÔG¯G*ÿ‘^h–“„×’ÒåD^¡µ©N˜9HPÞ -æ]vUÍѲ«jiZªbâ›õ:õáÄ!ù>Uˆ0zu2öwÛ¼ iêþÿgïO»mÛ²«0°÷1çZûœsï{¡ˆP $@`D%™Ò*À¡ „¢Je" +mŒp3ØÍlÒ`›t:3›¿ø[þƒl™²eËæL* IHQ¿ê¾âÖ§ØÅZsŽžæœk¯½Ï9÷Þ ï­/ÎÝÅÚkÏ5çÜ{÷1FcPœLÔÀ«ç¥&è¢viï~ÙO?¼ú—r)÷\å3‹zÓºl µëQ ³äÌ6ì}¬g&¸í¬G–מ;(ÃyÛ°¦ù¦Pò²€"aDh Èf1äNb:UZ½Þcä6ŠÛ—NºtþÖwÿŽ_õ»~õ‡8<’gÈ x±söÁ™·džû!™â//øqZØÿ‚ nÆ KìpÁ‚{T)Šöläà©Ÿï©ÁI$¨àfi¾½8ѯÿØ _çÎÙg~åýÒ;ƒoסëňdhd VxšÚ§vÛ"EÛ»óKµ ×ÔZ«%î£Lnò "Ë'¥P l,½|×VãÁËá¥ÂNÅÛn”…^n¥,P#úlÊ!5×{%ήÒÈ æé¤Ã)Õi »u2vî”5|5kè¢`UZoµ>ƒrﶻœÎ¾ìã.s¼›“›P¢Å©€æs–{ò)À΢’ùÄÅ Ödk=ëDxã’Ó¶E8ú¯.x±©@–…ˆTZ–eGv û/ë¡¥3ìlÀ«_1/yõÑ—?´yí•ÿôÏ|÷×­Olƒœ$Y  N6¢ðÌÁ_¿–ù€o;ffì<çl·ÝX°`Áû/d,Þƒ ì1ù¨÷¼kzêóûF@íí$p!ŽcÊ>Ýøá_ÿõßøû~s×½þU¼úð1"[À6m`2”VO)Ù賆$÷BÙ[ š7E¿ï‹AÊU;ZC\h(Ò6s+!StòMTFÍl”Ml@3°õùR›LÁ3Æ1Iµ2ÍzúeÛÏþÜßÿÿÌjóväèžJbE“>ÍæáÅ0Ù¼Ï8`úû"§³ä,X°X$@ ,x×x†GósôÜ@wØh¥˜êÓ&9xÕ­}íG¾ýGþÔпõ•w×ìÆ.†]ÒÎe4sÎZŸ’ójGÇfÔzÌWƒo’v#RðÞÐUqJM­õý1#ÜU%‚ª&j%#UBS9QY•’S2WQÕ«cmé5éÔ%aw79e“[)ÏÃÙ4̦æ¨yÛàTRƒ£UNÝåU ì[£1Ò–RPGL‚VÅUí¤…Ÿ;)e†!ÛêS—C>ù`Flz)›ÄS³4…ÙŠî­–zsŸ9½ï™»O½nÇk:ö0°Äùý2鉦²ž7%ìceÄ>I¹œ– ™¹Œì“K°$ÏŽ`Q(Ö¡@DŠ [ž^úéýþNO¿®íáGîÚWj÷W¾ûw…ÍyreÍ iÝÀJççëú7Æ.nÃs?rGqº#Y°`Áû‹hÁ‚/ŽÂo |óçß nÕ•„Õâ—Ëhž )†Ë;îoýp|ééGî\}¨N"%G”™ƒ‘ª5kLÎä>ŒØËKO+ƒ,'Ž™»#6»”Ew£"(#ckÊkAk6Ë`(3„ÆÓE‘ y X:ìVö§}ÁÐz‰í&K„‚9$¹³¶ Øû²1å!Ïg¶Ej£BæANS ›Ø\WrÖ&¾jË6iš;%¬VG-o?é€Pèõ–ñQ8ùôÕ0ôw“„G†M™‡6á´GÚ@çÜ,ñƒã-´·lö/ÔÔláH¿r¸ËÄÁ¹Ôð‹D”AÓ@sÑ…ìžÝ³KnNK"B?‚Îà 1WI®m³ 9õy×ÝÇ/ïüŠ€~£«×ÿýoùÕÿÎ×}(úNʤ×.ʘÅÔ:Ƚ üüð7ÆE–¸þ‚ïw,  ¼8f_ŸÇŸñ#FGNÚŠO_¾÷G¿çËY¸³ÚÜáåYðô$Õ·kD -y†•¹Óšž­·or&Ä«AWƒ_îÆ«]Þ&bƒ‹A¨ôž ²" ^³ %,îõê /ê¡’¨Ì ¶ŽShÖÁž+P) ´† ÂL%/x&‡Ÿ^›`ïħZIM‡FC\_l Aµ÷qÕC•tTMžö) ¡*yB57&ÿ|ëœ,ÅÀ”ãÓqõÖUVìgu¾µxP=™÷r›Ù$÷7(ÐÖÛ¡õ%Q2‰Ñ¸mæí·´¯ IÂ<“ê.Ï·'Êí2¡‰rOÚó½“Ø Ÿz¹U)vm‹0us£‚¸zéSO6—ñtg¬Ù˜Ëx’­€fKÏ%¡ú€_×qî0x}sBÌŠI–©$/µüÇìI>º.Ñ2P[ÀÑÊX½Ù%ËÃ…¦ªï( ¤uƒ`¥Xª%õ™4È(+Ê4ƒœcò§øèð‹~Ó—_^üÄßýÑßó‹OFä¬Òæ¹uŽPU6Í›¹= |î‡x®dhþ®·[à ,x`1,Xð\ð™woyòfˆ€¦eæj]Á¥|½Ú}Ç|ÇWýê».™EgtÒ¥¬h±—ÿ/D^lÖ.ÈCa¹µ°ŒR¥Å ]õ9jjZjlñ«(|Š¢Ü䀭K£¶£¬»óÉO½ýÙWÜ{ýÉÕ¹ë=·Ó£´’-þßXêˆî§ƒû4ßBÌ%®·#-8jjoUìkØl^&~Îf-°«Ëó-¼S FX-º9kLÖ¬‰z2ÍFUûHÞo[ïµýª8$rô8¬>ôÉGÛMX9˜Ý]Yî•ðOaŠW¸VB¢çŒ*Œi¦Îц©åV‹8ÇTòª‹Z‡»ÌþñUºÚáÌ·,(9,©ÌAt1ajÿK•ÉiƒU5Áæ[´^D#¢‹Ùá9K2x¬T|ªëËÑV9ë"~Ñ7|psÿÿ÷?ÿW»;¾ÙEÏJ®l¡˜‡“M5³‹&»÷óƒáô ï_°`Áb,X°à9hõ1ç$åúŸ‰üqþU ·½šN‚ŒÌ9%Kë8~øë_þ–ïúæm~Ú˜+ÅÀ@Ð=R €ÁD\mw´ Më¿çÒ­Ög)t¹ÞT²D'T&E«a…³ÆºÐysô1|⟕[Ä™áìÍ{O†K6pµ&¨IZÒêz¶)›RlËø\!†õzS¢S‹á¦ÏÑ~¾8µD® î4Ä‹ó+²§Çª§W«ðI÷æü¼èAÛÜÆù9é®0+VCM§•©{:¹ó™G—ë°Ê1fÈBÐ^Hë˜É˜ªf§Ô$mÁƒùlïXÿ-¹½"©âl]…óí˜y6¤“§cfŸÝ²™f fYªÁœš ¬h*¬£Á|wÌG{ÅT†„ Á$H4ˆm 9 Ðݳ™Öøð>òË>ôѳ·ÿã¿ø;»íS–gºf+©}yÙYRÆõOÂMSóyÁhãá;-Š  ÞGX € ܆u{Arp³¸à]ˆ ØʺÓ,e¹qgaû¡íŸý»ò=ô@ŒáÅK"XMØÕÕ.eóÜ ¡™!µ‹à¢{e¡ ¸èD­ÛY;‚y¡Êf&oD°4ÍÍŠì·›áí{¢N4–“:C÷Ú]Š,åf sxböÒ]ê@þSF&.yÖ8äúÄ$Œoíjk‚:;5 A0 ÄПŸo³G÷àœŒ„z’ö®,÷êÜžœþõ¯µ–g-ZÀ}DD-lÀJ )sÑ7Ù7§§Ÿ]o®ØevîtŸÆ9ÅR0“»4iWÔ$`["Sü§(qj@ƳWMƒlu¹ó:çjôèX=½3O“3«Ô÷4³NÂXV®XaPioPx75ç¿Ú› (ïÜæÜŠ^(&a’2…ÒXº›†È "£ó¬óþËïtwïwýŠïøí|=Œƒè¡jaÔ²LG»ÿ¦›Ï|ìfÜflëÚƒšs“`Á‚ïqL)_ ,Xp„‰xb0g¹œÿùß1“®¥°V3senñÂÞùáÿs'/oW(SrcW°È^Âf·uܼòß&Ç/…X À§Q¶§€V²²¦á%‡äîF‹«¢&¹)<~tþðÁyЊC×2½Ün`t™—“Èž[˜§œzïðÒ\s4“Ví@ÕëK•">'î%÷NÔµª©‚U¹šu7O»Ý}rþÓ÷oýÞ¯ÿÈù©YNÏDiP f_µkžæfn$òp8ó=ô|Ìçüú§ïÈë?ÿ˜/t`Á‚÷ –À‚ ž‰kÌ覻ÚßØ¿ðE¸JõPOìCµÒ á]«Ç¿õýº¯ý_1*»d`g])Ãd0òz×£ ½#¨ÆŠ[·õç*ÖEMÏuÒ bFô÷*–!­ T ì N]èß~çáãó«È;J±”Ý'#ÏΟ÷\„Ø æµ¦ŽÍ =fþ_’0†Ý˜Ü÷D¬Ð…¶ºP²’Ù$,å }Xm.wy¤å ¥1YKž¤D˜ºü¶·åDÒçIÅehjƆJE#ùTuSZ6 Š\]ÆÝǹíjbŸÔ¦wÖüv&uŸ’˜kžugÍœáí½÷Ûˆ2zÍ×&#Âêj«A]‚"³4&‹ñîzíÛ¤’׆Ðõä3Úuì)ÓíiÈu+ŠƒµJ‰IR11M€•"L(¡ #5vwquö!büÙÿé}ìo®¢%‹ÝÓB)3AÐü#ÓþRûžGèoùta/pðuÐX°à½ÅX°`ÁuÌx€nz¦`råü$àøüˆ,º˜APÎiDúáô—â{~ø;¯6û³‘!X ]r.7   )£Œ'(·"2Qõa‰?TäüåKÏk] }zCõ»JŸ++‡Ë!!'½òʽݠ•ÝÉ£#dBò©š£\n8}ôp{q14—CM}~0lÿ ‘Ãn—§šÞfÆó8 Oà€DS¼8¿ôl¦^"¶ñLUçÛÌN†æÎfìߊ­Ågë^ª‹N‰ÃµÆ¿¤b’€0Ä=ôðæzã*µ#Ë ¸ïyÅéýª3~JÀÆÌF¨£c]»6»%fØvàλ`€—6ŽLcÃÙn˫ͨZøU¦žeD™?Ø”1™;ÓاûL ¸\‹´ÞeÉ*¶D —Ê6Ë®ŒÚ<Âïœä¯úðÛÿoý®“ݽ@ÎŽÉ#öQ›éÍÛÊ7)ÒÜþÜóGŸÇgÛŸë‡wÁ‚_‚X € \‡&-dz¼Gt¢ú˜g'y™8Ô¢2fdÙ#°îòÅKOÿâþ—‡ÓgÊ)™]ÈWÝ©ÜÍ`Àz·Û #Ð !0w°6²õ–ÍYÜÀÅí,Yi¡%c†dÕŽñB)×È€œ<†~·_ým²GêrR¹“,Äfî”±»÷Ö£õF@¤u){„™Böš \wKÄ£¤"ˆÜ £…X†XD%¥ý–¦ÔÛ:M¥óU0ö»­)È;ghÅÞ0TÎ 9þµ·ÍŽ—l*0Úf©ù¤[›^µ.Ç¥›‚J´ ”¬Ü!Sú·G=ÈJ!ȲP†b^Ëâ] ™ò&EÿS'¯6F«£©WZ]ï¥h§IÆäñrà¨N²bq¶b®Ì9yÄÎ]fB<¿Ø&7°O¤új—-k—;íচ×Ij›YS29AÜ;—Ž’—P 1£NÙ-˜K&AèûÀÍwþ®¯ùÿóÛºÁ‹Í >Ë@ž}€¦ÛuKûEÝÿsÌ/s¢g|4œ ¼Gpô _ € \CíZú€³[Å]yÐêyÖC£¹(™Ü)“ûÐùÚ|÷ŸÿÎ|Õ {ïÌB0ÂÌ‚‘€gÏÑ:“mÇqÞ׌QW©ØLŒšK5ÐVVfÒ³·@¡d4ÂJÁÐÀ ÑWñôу§ï¼õ°'>,œßÀ¬5Ï" Q`§oÜ{˜r¤[gZ?^˜¼õø%@\p„õåƽèIªû¼õj—áMTãdÃà›M6­$ƒ»±º¦Q2’¦]™Ouá“ À¢qj‘‡Ã圔1µOÙô%­•Ò1ÊH%Ä]¼ûÚ&=Æj ºÍ;jµÑ«V=jJ"xž*/M‹…V™§ ÃkÃ``p»ÜùˆÎXR“­Ör¸…Ò¶Œ³ÓìôêÊ·;ÐN<—,^GaÞÊ,꟣}81q²å±)uC%d™ „:yÈN§9ée+ 4CÝŽaÝÂný‰ÿâï~××~ô2b+w¶ ©ôŸã¸þ!9üû"ŸÉÁÃk›ã0³(‚,x`1,Xp ×åÏ:²Ýª…ûtŠƒ FÏÃçà¼_üý ¼/° ,˜A7ö£ƒêß¹R¸Y`pü˜ö¾ÿBdŠ7ŸU"³s»ÄûÏþýîî ¸GÐkÁŸÀ@Â`)]m·B¤¬¦¥rÏ׎ “ÉÑ»§ÊUT7Õ}KK)wñôéÅæÕ7Þ2‹J«£–;óâõ­†æþŠD NÄË«ñ‡§#DJ½Ü–BÁQr(ĸێé$Œµ`=kÌæ¸zz¾#{¹I !Ë?žâýäsþà\°uí Õ)¸ç” \-K@È¢ fpôŒÁN?ût³]½¼STG'ÀEsZ]&y´`‰¦P´53MNé:æeg8ûºË²Œ@± jô%Ó…8ŒrºÜ xFR’庋͸Ù!«£[HîlÂýY™¢)z5ùâ1%¶—u¥jç ÑE§ID\.ƒ"ÀX´Kf)v!çÜ ¥Ïü©ïû5¿ë›Ï, cRÊckúìÍž ‚–çpÅjC»g~J§'ux‡ßÞ^ì Þ›X € ÌðB?÷GÊàÇ<¢%Ó{J>éËy:]òá¿íû¿õ›~Ç/7úî40˜cðR˜ß`Ø6»ØËCu¸N^yx½3åŸîÝà`¼ Ô u `°.GN^{ýÞ£ÇOWvŠÁjžÚa«”¥Ñ¡8zopg,ÊRÝ£Û'Ovf½! Œ–Šô,åüÓ˜šþ¥VƬAÐÌ•ç›ÈS¦"¡¡»f± éFF§}Bé|ÀäÎðÑÒÏL%©`Š©Ôk••L†’‚²mú;¿¼ØÜI.Ç Oº{m(ìn4:=yQóO«3Ì@£eÅÑãåNÅ*¨Ö§ÿÕu¬½ÊZ¨ºÕ YŠál»ååz'D‡©ôi‹õȹGmØ­%[¥Õ3JÃç’ yÌe ‚Y& XÉO7—gZÀwB¿9ÿÙô÷þȇú{'}”YM.—FØ]ÇËØ–ŒSdâÙ€£E½¾ÆÏøœ_WÝfE,X°àK‹°`Á‚Ç\íÓ<ß“ßrr˜^G“•ìïJõë§T”Ì•¯º‹_ôë_þ#ú÷ y`¤’ÍÄ@£`Œ0Kž/¶1¬é±jú‘&«>xcÌKaÖÂ:Ó‘BðÄ.žxŸ~åÞ˜¼÷L¬yåKV[ìcO[!yQà“rQUÈm«û.7;‡¢² „ɺŒFÒ6ãhV<Ü€J6tmb²ÀîâÉÖÔ›4©Çk•û½<ÿpêõiÿÈlýæ÷ à@ Ó„BªŽRSµŠ‚÷ÂL­,Á6kÝÅW×c·RÁ1’ÁEÒj0dQíX•þ $WHµI˜BæÉÓ­FD€”—Ü(´kóRïÕT#š]$ÉÚ’™HY:iuqáÃÐ '^â=¥íC]Ãýž™‡L*}fKŸY+JP¢ÁˆÝR¦»•^cIVL:Ò(‹žÔG?á§þ/ÿÃ÷oÏ?cØ Û&»òÙüz¿Ù[ |R~³y÷npLX°`Á{‹°`Á‚žóŸXãDå›úezù­çÅŒ—¢‘u–K }ã›áÇÿÔ uwÚ̬RÆ,'EZJ¾Ýí )JŽ¢/’pB¥¡×äÂJœ¡¬µŠîÈÆ­÷ñôé“Ë×_{«ã RGšÚ£õÉmu0Q«aNÞ÷Æ;åÊf†ÊûJ›3ôo¼ñ`Mˆ¬˜\Òà$˜¥”‹¢¦zÀå¥Â&@“ W—»ÀžŠr„Ò¨xu·®oº{è®±9Ù=|m{¢ÉNJî/ë«X.²TU°ÈLJÎ{ɇp×!A™w¯çÌ9Р鶒¶=-“èÎlv9hT”Ì `¥o˜OÃhC,‚«)¬TüèûÀ‚²JO³¸ÞŒ»]–w”ôŒ©B©ÕÊ£Ó…Ï:)ìwÒ>Ì¥Éö"“Lbv¡d• p8H8”\”uvñ~MþÑ¿ö[Óöõ`¦<†šÿ¬¹ 3ÿÌ …<æ÷˧hž2pË>˜Çàæ_G»fÁ‚_Â8ú$/À‚ ñ|z0ãñ/Ä'¨ÊÊ"‰={Ô9ýÑ¿ùçξæîÖv»A‘ÁH».žÈµ¾ZgÏÁ:‡Q/l‡:ŸÉ_Úxë«h™­./%hrRߟ¼òÚ½GO/C8É#-”/Iso-h›>ӻ̨ZÉ[-½a%‘N#^ô.ò¬ðÖƒ§òèÙä*^ð’9Œ]J•ý«5VÉ&œfÝåÅè)JÎÀàyênVmªF[oVðs·ÖªœpÖ:`TKuÀäþoáî]æŒÌR¦r©GDÏvòö6ÜÛjìîf¡ðzvEñ΀” tM'TÅ0¡»¸Éb‰×8¼6 ¨ŠyRÆZâuVN_`9É´7KmXȉ¬Ì`Ûa¼\BÌ%yÔTUÖHõTQk\Ü,U#¤Xˆ0À˜\IJY@°‹ h€C@¡‹i¸÷—ÿäoþíÿV´vIòÚ›nŠ…Ü°ñ*ÈjFãMK}$þ™n¿+Gþçð’ |‘âè“\üU ,X€‰’ߊ}YÏëžÅöÀMç½þ>ÅaO ÉSêôÐ~ã·ÿªßþ{ÓèëþäDfEí…‰C7» Ì{wAn­fòiNýË4Ë &IË9“$dÁ:O¢G(|泯Ë<*‘¡ä·Z¡¥Õ\¨ïS™—ö°ç…%žÀVƒ“¢¡*ÆN®®ò›ï<1žÂC0£dVÊÝp“r «}Js™Ywu9*E¢““¤»›¥ˆ<¥ZçD@œÁGÊŸ(Ü,ë´vååÜ¡<Q‡½h©Veõ×£4 sNÅ‘h “4Ä“{;3Û°z))Ã2¦â¬® åv-û\6É6cÈŠjxA²ÂyçúüÒÀx–æP³¼YM½i}êÚ™I bÎñr=Œ @œ Ñö•vtÔ¶CÛÐ-„5‹,wº,—v_¡Z-@I]—ÆÑÖÿúüG{©¿‘Ü3|¦d«†ÖÁòM†öœsÙÍÚ#ê?÷å¿øoþX°à½ƒ"·Y÷‹Õ¿`Áû…êb’\ƒ—zÞWÅ ª¥ zH9+hç_±ù¡¿ýý¯îeÄœ `#%ʺî$»ÖëMÎNÆÒ@d–WªD¨Õø÷5¼8ÓÝCˆÜe4Oé¤;½¼Ü|öµ·;;Õ¥À:é¢ÉJC`L× M~oM´µ¨7TZ÷Bä( )ó¤Óx¶]§×î=Œa%¯óQ®ãj³B`€“ÊjªÂz“ÒHª“[¡©”y-¥)ÕðÇ|„ØÓÂã÷Ïíã!Ërd1TÑÉ”öP_ßXoñÙ·9oƒ˜%I&ùØõ¯ïüm·]ÇŒìÊ“~Fȹ/Õb+ΞnÆ„Ž -ƒ0Y]Y ²ÖGx–˜~ÕæÖŽö”¾f5âìÂÉå:íFe…\›4gZK .-%0¥ c6_œº”lšMzwËY)g*Ô¬gBt1‡>æLªëpuŸþ‡ç;l|Sð\Ô`ûy­—öK6[ĉËW»Tó À3 Ã£^ðç}ú€/6À‚ï5XkÜ4¯íLâSÝÀ­\}ü¸D3 .¬º³7ÞxëÑãó“xêC) SzÅ’ÕxÏ$æ0Æ0¯¼_&®Jó‹DE¥,a!0Ùt²ÙâÍOÁŽ 6Û쎒–*ˆ r’Ýn›‡m6ö¥ƒ½8ÀzquSl‚Íf|¦Qºéßkk4ÑÇö§ý{ yš–NB‹±´‚BÄÔx¸q{N8•é»Ø½¶Þ> ý`ÑK²·2@e­!B™k‡ ŠO7ÙÃ)Jß-0{k²°B‹uš`3^µ÷˜W‹­™Mho–ÜC<]oÒÕv''K¯5×>I|ꑦƒ €pªi$Ód¶72)Ba̹µAŽ`>öñÄùô÷|Û‡¿ç÷ÿb—rZp§¶:¾ õ]ç÷ŸÞt÷ÞŸ{Õ‚ ¾`Ïp,€ Þ8”ìå'z»{ôŠ#èú³û37$#Œ tOòÇ|ã[þüoûš_÷K7™€è xÚŸÁqyµñœI­ÖϬ'm*ðùZȢé\Í<ç`1ÞÅåð‰O¿:$Ñû<’à ­z§lvU‚Ò$+¨E«"¼6+Qâ§7ÁäôQ ŒOÎwOž½V'9ô 1cØ^.¡d ÁºõUÚne\)‹VDíåI/þw Áin!óÚÑ×õœÎó™¼í 03Ö®ïìõ6˜ä>*¥=Ë.3œž”ÆÕÉ«WºŒ«‘EorÒ»ñŸýÍ?øÕy² iÌIJf,†ñ‘ms}i÷ÿÙ@Ï2Çuíï‹c¡þ ¼×`Ïø\/Ÿø Þ똻±u+àü˜¹äöPÀua‰´çFÕ WNdZí>ø+_úúÃWWçýé©f¡*H†4^m¶T¤:MÙ¢%Ûr¸Ã59K«dÃIÂÕRwkw­º´Kg«»çÎ_õÞ*œa„Õhãþ®_¨f-¦"3mâA¬ UK- )õ@Z=|xµÙÐó©W)3J ‰B¤yžwôš8žšá2é,J©I²ôéªîériOkNgs×Êþ(Åœ»·î_nv™dÚefЭ7cIô€‘€—óMA•¨BlµQ|¾PM¤´—è\[Ó›Wëè9ý;»;¹¹_Ï2<Íf¤Î ¨ÀßÊ.»ÓWÖiO³™°£'F?I™ÛÁ…­¾e õ”y¯¡—zYí§¦ rtm¨uTs3¥,]ÙޖÃÕÕ˜Š3}oÿÉÑ’‚›•x̳ë‡df2æNråY¹´‘3:šJîxB´€ôö|ìï·¼Ät•3‚fvÛE/cµVË\݃;<ôh>æ‘»Çb ,Xð^Àb,Xð~Æ¡Ã÷ºd®ÿ©ŸM2¦†ÄJI %™rÎ=æ‹oþîoýæßûë/Ó£Ñ@ŽV}w çåÅeJÙG4õ k]O©r¾¢Ò†ªÎdRa0ĤdÒ8výÝçëÏÜ»O»£!R¡Ôàgv ¬]»šv¢qþR<¾QgiôÔ”J+ÛÌAµâ0Í 9LÅQ6JNtWöÆ£õÕà) b¿Ýi7ê)Û/ÄÄ8[¯ìëÞWcÃKש°i °ª%s´’7šÊ‰=߸ ó£˜eý²ú¼[êjk$ĉL]NvÀEòÙO»>ш˜¢çîb‡-VÙbÉØyWÜæ‘%£‚l‰ß¾9°7Ff£w¤{Kñ ‹9[Ê6dË#p±v£¹wRPÉ@˜L ÎŒ Ü0m-oXÕò1s™ÃÆ4æìd Œ°`âÊÅÕIØ=ùä?øñïú²Õ[} wO¥ÑÀ ûægv:1ÿóÒ"U/Ê»ŸÃK,XðE‡ÅX°àýŒY“SnôÞꕼ~bTZŠ¥.#å£[(~àêÏþ•ï½Ø>ZõdÑwã°Þ¬ ]§U–C0…"ƒ©õeŠ¡)ºg˜[iÏ$)„®t¥Z…;¯½zïéÓË•j³Ëmœ€êXßSʼn;ÕCKlM†ÂÚDÖ… §†ª 5ƒ¤ô‰²øT&eÙ¿½^|){%6 è…XH4«”¤ DœDðR«oÄú feò§éŸ H&Ÿt‹P<<½`~å¸ñ˜ùêNš®FÖ«0ªe#”¶bSpN3È1(> Ýg\tw²™¥MN»mÆÈÎÍJóäÚ’¬žgzGSàeŸþ[Ç~› ÐrvˆPäCm·‹­Úi¹[]®ÓÕv;‡Éiäþ­Ùâ=ÓúLç©oU Å"A3‘iÑ…1gÊä 42ey°€{õúÇüòþ'OVAò`­íM¸þD”öé|¦¾çèI޾ʷa‰,Xð^Àb,Xð>Ä]âÑ¿Ÿ#nŠ/µD€4Ò·1\àÍûoþÒ…?ØÙ ­ëú“qÄÅùU¼ty‚9²‹+œ¥V#•© Y‰Ìnrƒ #•¬—wŸþÌ›9…˜:e•@Š£^SI™ê/&²ÙR–÷$© q$ˆÑ3Zr”J=ÙKxbM.^«–ì1Š+x‡m4;rþÒÉKÜbw± ˆpŠnÕæMES'w&CŸ|ý…Ó«gZƒk‹1å7ðÚÓ{¢­ýI÷‡ìî_2½&‡=š…E´õ’Æ`Þ'\ ö8ô¯$º>ç]weQ0cQçƒûpTIÂp’j ·¼Ú>5Þ‚¦ÙzÖ6Þ_T;ªzÛ­ˆ‹¨ä²Ðcxzécîsè’j ^¤’@¼7[(b2&E€™pŠ†…Ò˜’A"Œ2g´Ñ Ö~Ó¯ëþêý†aý¦Ë%1LööÑZIö6Q Xµ`§e愼XLoÿæSÔeÁ‚_ ¸åý ¼ß0Wõ\—Ìäu6ùÌ_}N¯jbƒBÛ a2¹röd÷Ú¿÷çþÀW~ý­7ÆUrŒŽ$í†a³@+¹2½ …ÛìÔ¨ I—QëV²5Cì†]‹óõ«¯Þë ©ù/ÍX÷UÛ÷^~¶®3ÑkŸë×è.!”*Ÿ0¹²C°Òç–“F2ÈL¡³àã‘:ë© ("Ø,Ÿ¦Ñ..¶@·Šø{߆59Òçw&QkCÆëd®å -õáâ÷jОâhì]̳ÙthAÌÆ×”é¦ Ÿ„“Ï\ø…^º Æ"¢(šyµ|d4¨Úc­þŽ«äæ–LìUùåí8‘ßPåh}¦”©Ì¾0\ƒdçWÛaB¬?—4“ûžh»©F`4Ù/uLÕ q—YŸÝÓ˜Šñ@A!˜¹ïÏ®¶¯üè_ÿö_÷+FË;9äÉJÓ»©õ³Iú´†5¶1ü<ŸCàsˆ,X°à‹ ‹°`Áû×¼þ<|ø÷©®ô L̺R„"ž ™g$ð2>þòoúÈïùÞo»wèO }ßÝY…ÓqççO/rr28MES_ýÀ¦R;ˆA“™ª §Tg€@1Œ#ûÕËŸ}åÞÃÇ}<1M÷æÞ. q_Ns>øÃùš&¤`r8­,‘%!3+Q3swGv¹,'úÐØv³Ýf­s8?ò½öêî3¯^ÐN=G4™€¦vº‰c¸Þxob{GlüøT(~mLít‹]p=H0½ëÁ>˜mIÿ3s®OϘ»ƒÌ†L!»òNzÒÝù™Ã6|ÈÓi̹Õ<í·¢×D J¹:ۥІ]&©Ñ\ƒ™I7Û¼Sô„%­d²µ¦Ð)‡‹BXoÆË«l•½Øæä×ÎÛJ‚6“Â$À º³µ6UNî.C £ Ñl‡Nl¼úéü÷¾ïåðVdw(·JÝ*qÚå˜dçùÚ?:Ÿ†ÏÞÕׂ ¾ ¸åcº ¼0QˆÙÇ ?xënEu?×o£ŠlÝ® Ž}Ú=ù«ëϯNjþå»9A BØ¥t¹ÞXè#{ˆ¥—T²]™åUR°ìwÍ` à@ ðøéO½ ·è p¦RŒÜsä™Lž óiiRcµ @+²{‰£†© –ÃETvM¨®³;Û·ƒ=~²¾Úæí.\]šøÒOÿë{?ýS¯WÔÀzÍ€dUü3Ÿñ[½¸{î‹)»aIZ9Ìùk~ÈÁ¥ßfy€×hßÌÏßþN,uÊΖ›™£ ‚™2q¡øö?þÆ£Ëц\4"¨ÐZ©5×6­Eä”ÞÒÂË[v(˜_Ù>Â1]E3îXI-¡\ÕŠF‚1æ..7&¡F$XóѧóÑ8¥¿×,‰Úµ Îèd–g÷ZhÖf€uÂÝ/ùð“¿óýnîÞ ‚¶ÀG5 [·‡Ã¥žßѱ•vËzþ|±D,øÁ-Öø ;Š |Á±g¶7Ñû‰;ÌŸÆáx6š~F“;d‚!]Äú?ø“§_Ño0äBèá¶ÝŽ—ç—0c×åä¥ØäÁ@³,Q<äµf ¡ Â`ž½‹§/®Þ¾ÿdÕÝÑàN…hî•=›‘@–ÛavlÍ7-w[åœ2Aª­½Ê¥”#¸×{ Ø•ÍPT„+e/KšgJÚ I’É öñLîy ]<ûÉþñ!å—Vž ˆ+öE­sTŠê´¿ô¾­gâ-c›¼)p+a¼¦ ºéÇB7ÜVaÝ7[S–§ZI2ìÜ£S ²Èp9¤”>{ÿÉW|ô¥Æ„h1p; QJ€g¥Òü+šÍN WëŒ{;m?²™s-þálÃTú©F4‡Øl ‘äùÅö¥;§Á Ü›aÒÈ}[‹ö¶Å¬À4Z*©ÐSÎ43&‰¦N¥qÜîáþ=¿êÿó¿¾ò¿üßåð2”Í‚g{Ò!ɯ+={ˆ[•¨[Y»f7^ä“~tªwå&X°`ÁGï%°`Áû“;¿áÈ÷?ùú©Þ\tp‹(eÿÔ•¤ `Ìžva|êO¿ù÷|ã7ÿžo´‹%äì)çín».†U–Ô{'%©yçk^¬03Ï„¬³“×_ëþç§Ý]ߊ#sr+åxJ2.JqžéÔ…4¢Ùõ¡½žœm(¥j;¤ÖƒV„B)%ŠÈƒTTy ë«|u™×Wy»qôbCNô1šþ³þ3ÙÍüt·agÝåÓ­!´®U^œÔ5Ç´ÖüA­vß„&œ-ÏÑ’Þ°2 ~|gOO¨›8à´9í£Cg•’*ím™Ü™‰D90ŽyÈÃHßeß:Þy|‘ØWƒ_­õä|xr¾vôV«h+U’0¦¨µjsýOæÎdAò`cr~Á³;“ùÀ©àj¥þ*¯”Õųó‹ívH´.ûÔ§—ªUý§÷›,‡ræö¹+ù ªÉÄbJ^šÊÕɳ›­Â°ùÄßùñ?ðõ_u±²!ËMLF+Ý'¿Þìw~)ÓjM¡€Ã-ð ÜHâo{Õõ=²°ÿ ¾(q‹Q¿ ¼pí·™‡·5‘¹£¯Š9Å»ù[¤ðž}†jƒ„K9{ô5ÇÕ/ëÿè|Ï“á©Â‰±!Jvy~9 #bX;³–LUùPˆ\é VÇ2`pe˱;M‰Ÿ|å]Fà* ½•Þ[!TÞÕ¸jã¿Ú½•ÕW£ÀS½O–7E5YáH$‡Ü¸Ûáüjxz5^^i—bÖIR/ëSVʃ P—Søgÿô_™ú>OWk[o(?ñÜ Q4E]ȨïÆÃah¶«ošJ¾Ôâeð¬±IÙ³"¶y´®ß:¿Ø'RBJ–[ŒÉ÷¿÷È—ì.’ã0¦ä†À`êÜ-ž&ŸüoÿË?Öç× O¥’²JΖèå½ç+þ"^ýýTÔÏ0øņ̃,Xð%€ÅX°àý€#®xû!÷ˆËÑAÓ-M0Éi„êûwwÔæìñþWqÀy×ÏHÂ0æÍvcŒ«œ•Ý­Ö÷P“`k5ETƒ Z¥òfˆiTߟ=y|ñêëožbìèæ”+Ó,Ê%W“‡˜fŒïà:§KœHRîÕ2j¼¶ !xvÒˆ¸¾./w»#šNJâ$/É’YiȽn×ù_ü³½âK¾ £™'ë™ûÝUF Ÿµú-Ì}ÞLI³x–^³‹ÚGmnvÿè7ªp3Iœ\Ý/BøöoV,@¢ÖÊ„`è”K÷æ°‘s ê5ÂȳâêôÕ{÷/6£­N7ÃÌ=ŒŽ¸±ÛñéÅpq™/×ÇèÞJ¢m5[k‚6N,øp#Ït+°Ó‚,uسù%P*Y(Š²ôOÏ·®Þ]„Að«9˜¥²|mÝLµ[yË.ZÈ®ì^‚!Bi´Ð§°ýU_“þÿøÍéò­ “§ÐjŽj¾¨7áºQöœÂH7¯ã‹|zñó/X°à·|a,À‚ïyÜþ }Û3ÇßšýwÃ!¬:Œ¹º‚ ²ž®îÿ‘¿ôï}e7†NìV«“1ëêj3ìšA„ÓJËÕ‰ÈÖœÜÚRÊŒ€”ÍÜO컳×ÞxûÁãËhgb@ `¨²º{Uqhªë©`üür&'m¼\ÞšyÍ|ÄuX( òºq°Ë‹œ†ŽÃ‰©ÏN É"WdÁàãpÚß½wïÑOÿÔ§NûŒë`ÌDÈŒY’G¥n}5”»HÛu¬¢š™k¶Õ'Õ¤¸Ù7Ý:^Ûë6Ï N…cn‘ÍôÌÝ}ds°öž3ò܈ҳa»Ë€QJ‚µ,¤Ϻ<¾õÖ[÷»~8èNOð’Ø +Ïýz‹s]]0+â$»JM&U™WÕVõÂÏRª[wævIS!L¢Nûd'’ –i0!díäârØíDtYh6@./䔩‹"øŸæÁ¦îªv!ív[wFȺ¸Í õixãÏ|ì7|Ç·Üe¾… ÷šÁâÇ+zûú…~®Ý{ÁÓÌ™þröw~wÁ‚_X € ÞÛ¸Ñé}ë3‡/š«Kn;ºQ'¢ùSeàîytßØÓ_ýÛ¿î·þoò1ºûz³Yo·"ÌbI´Êw‹ZgFY‡U©Ù豓„½òêëÃàÍh€ žÁVç“VU{"¿gfÇŠ‘¾³O (‚¼5,€€¸ÝæÝÆ™úàaG ‹9Ë,ä1‡`!0ïòY÷òg>õúk¯½½²»ykÖ]Fo¥-©†-RX¹Â)âSî'eo˜ì}îÇ‚ í¿{Nw«ÜC{Ïsäà Bž™ªhgïÛ¯„éF D!Ó•¶¡Tà"ê“*- d@ØnózáÈr'³SŒ1åći8;}é'þÕÏ=|tuš0Ð9·Sb6ÀR¿½ÈôPJ UŠÝ~K.W5«Rsl-={o]¿ýzǺUr¦ŒŒÚ[Ž\0öÙÃåÅà9@ÑeRí=Œ:ÓSþÆÞ>9€æ¬øˆ\s?)-ÐZý"K€…pòäÉev»ŒÍhåe9¹üí0 š×]:@ ’ç,)OD¶ì+Û|Ã×nÿãùmãæ ‘îɪÐéh©xt 7š6û¾g-f÷g¹Åkæï¿7ršËEüS2DH”zGeÕÌŠ`ÆJÜÒÙ, £+ÅUçÕ{o\lס[¥1‡^’.²;cHÉûîÎúÊ×Û$YK ɧÉÐ4XkW3›HìÅJGs3Mz-4TÜöÅO_6Š`µÙŽ—ë Ji bÚMª²VÀ¨ÿò fS/Ð º»Ä 3·ì]Ø^üìÿøžœÝ_1å”B–+c¿`/D»Û½„7òœs>ûKäÆ3/X°à „[>ˆöÌg,Xð¥ˆñ¾«³Ý@ˆêð#¤HK»ÑMåí‡ÒŸùÛ?¸Ž—êºaÔz³w™0Z„BzUH•“ˆ´BÎhVY¤1'²?}óÑÅëï<íâŒ!Z0 0À!yQŒˆr¤¦ú™ô0{çÌjwKz°UXóŒ ‘"€ÁÛñãˆÝÖsŠPp§è ¤¹ùÀQÛmZu/¿qïÑ'>õf×½4l`½ÉŒîÙŒù^…B±ÔŽ4‘nRP–íß %ëî {­ýRzÀN´Ö*—+ÅQ‹˜g僞|û“‡šŸ£ƒÅ­nåý»Tsªü5†í0f'ªÍ#ƒ• šÕ| 1ÃY–²¥í8œœ¼üäéö·2žnÇL ¤)+2@ðälHCè,e¿¼ÚÉ#Ðem þ°½Õ¤–„;¿Ši{Ìv:¹·X ¯=ÚŒd *¹[ˆ)óòrçnYÌÅ„-«Óê¢Î‚8µ“Y1vU«fÑ,¤”=+33ëûá%ý¿ùñ?È훢H´ãðÎ-ñkk9ݼÖGžB kX°àK·|Ü—À‚ï%<×u÷n1—ÿÎ5 “*$ᥤ‹옯âÃ?ý׿ïå¯ì Ân7¦¢Ìœ…è³j`*oE¹ŒFÅ`Ñ`> ëNîÝ»~¾^Ù céë ƒyvk%ù‹ÏÞj?ÕCº]”Pkûx¹I™¼ô#ÐRÊëœtÒm»M›u‚zC§+ÃC„ˆÁºÀ€Ñ^:ýÀÏýô§¾sÞÛiÚªëƒ)“{KÎÖá« µeŠ!Põð)®/ÇÎz¦½ÐßfuŒe<¸ÈCŸ•º<œ‰ëÛBGÿâ…÷ÎÁF«¼ð àP‚1¥ŽÌ]ÃÈPß‹íŸÂ©›œÉT¼àD™–’ü Egøìëoˆ]ÎÈ’¹)ý=„ dP¼¼Æ‘`_ŠçHeÅ[pGMsÃ/£ÀÃÙh%V9¹óQ”<”Kr–VЄKd'uçç›”%˜ Æ V·³Å~šùW£Ö²SL„ faÌ)Ë˦VÎfýŸþ»ßúßÿ‡~yÞ=‰!@¹‡ö:·«ó?E=æë÷ÂøܾX]Ђ_P<;°`Á‚÷æ|ÀŒ¨ésû!ž^yí} á7Ña°"Õ·wv¿î÷}ÃoüÝ¿q3Ž4ìÖ»qL,ÄÀ> +½ø²›1!0˜DÏ‘ A†úÕ4`¥Kž¤”áR°àî¹v›RóéV‚7éãÛCûr,•z–Z-¥îŠpš,€d&“)åqXçqƒîÊ#(‚1䜄Q6„ ¥ýÄ·ÝOüÓŸv@ê|Dè ÷ØuIŽjÞ('Ê[r¥k¤2ļÓn]–I%ÉÁ‹•Gƒ›ÉPjS²¦_7&Øò†ñB¡ )óa¶²{ç: ‹M2UÁ¯MÜŠƒßÌÂÕzc´R¡Ÿ¤W••rxáƆ’Ëᣂ †@8 óaLýéÝϾþÆùz'ôC"Bt æ€ä^”5.ÝöJÃÚ¨³ì¤àn‰V»éžf—qíýíï¸JŠz‰·”ú°¨æHˆ'ëõ¸¾€]eÝ÷Ùéµؤ$ƒ\*Íã†4Œ)Q ä`]wyõsÿéç×ÿâ,mFa ‰u$/äþ¿é²ÞÕ7‚n¹ýŒÃ®ë‹Þí›.X°àß`Á‚÷nwì=[µ{û¹n~eaŽ¼Çœ¥¡Ûê#þ=ù{ŸŽ9b½^§<ŠÆ‹6Å=k…MIðâuCTòÎN/.·Ÿ}íÞ*žZ6@'a{O¬ÁPJ"îºÓx‹ÒA³WíCé½TœÌªÕ÷ùµa”A€ÂùÅ&çÐÁið¡”j1 DÈÉOÂGžþìÏ~ʬσ pј]¨9›[…Ì©5ÁÞ]>yõ ÷Àþêj–ÈÄÌ™O€²)Š¡éҦ䂩Àôgâ¬×–XólÒžÅs6ÍddYdÉ€‚vcríµï’¬Qp«yÛØ×8š,´É<±"ž1 a»Ûœ½ôðüâÞƒûݘ!VÅO5ª+q€ÝÛäѽPðjçÕAeN®¯ùè§ír03“1\ÖiþëYX¾è­K™—WÛ¬RB”-O½®ôÒ1˜j"ŒC0ÚÔÂD€‚1(ùIäúêgþÇÿãÇVxcÕ™çd,3‰wS÷iïx74üú±Ïxõ³Ã ïþ›hÁ‚Ÿwh1,xïàÚ/.Ÿóü³qƒ>dš’×”ªä.)›—w?ð£?¤/;ÝrHiLC¦“0 F˜K1˜àª »#% pÄ»Ÿ~ûñΣÝÕÐ$Åi쓈cߨ•39â¬k{p¢wíøâuv§< s„¹B$OŸ\dÇiÎ]6 "{†ç@“Ë•C0Ï lïþÌÇ?óêëo[;!–¤…q– 0˜ÓMI’{+0ÚØf¡qt&wy¶«Ëµ|‰’…ê€S™.“Ó½Õ·Ÿ]&uÈÃë az«ã] Ì´é‡çzþ†¹fSLGírEa»Ýíó2 ·mšé!Ÿú® .À[•¦¢ËIY6ŽÉB—a¯¼ùÖÆåÖ§ š¥Œ(@¹Üé ئ¼Þ$x/Bp¦Ú%“Å0E@öCœÍošÜ+·Ú§ÂåÊÜãùù:¹¹›`4k­øié Œb™rÕ²HÆÐvÝ-1Ð;S·ù%yøŸþØ·W÷ Á=I†š÷rƒÈë™àáŸÛŽh“uxØsIüÑ·Oã‚ ~áÁÅX°à=ŒÏÕÑ6ãC:þ•®9‘EÀCHF攓 W««ßõ]ßöµ¿î—mÒ&y·%ƒ…ÂȦSU_¯T»{1C̃S]ùÙWßÜnµÂGCɣ̘LZ«¯½ïS3ž¦Jß_ f/iŽt+ÍY 2<2€yæÓ‹ lµš¢ ôœÌØÅ> 껓q«ù/~jؤ諜ÀXø¾•™«o7  9¨'úy¸T¬ÞëÉq»M9nÓ5hbkµ”Q«g4»ðvuÍ}~èå¾î(nd—óÔ§ŽÔAÇ8(%?ùÌ[üò†±%0³Ú5ä^nhÂq°iw˜Àdæà˜*9l½öíÚOa«,Ô4ìÙdÍ—¦]G[ÁCOøõlÛÖt¬˜n42KDÊŠýíVç—;÷eÅfóÚ Z5Tæ-_¥½ ‰àžSNÖõãŽL±g\?øøßûñ?òåwĨäÙs6+ésæèàÆõXÆó^öâ8 \‹E´`Á‹°`Á{sÿæ» …ŽùâDÍ@ÀÍÝ]yŒysçâ‡~ìŸl8®r vñ$K«q!ó’ “ŠŒža¡{çþã{oÞ?‰g6s'œOuDû ßâÿ&÷f&ÓðV¨e=Ñê«Ô"Œ@SÅ””j› 2‰~³IWëÑleŠåtåÕ.9ÄŒNV/}æS¯¿ùÚýŽwòÎBˆ%b+|Y}ð…ùÏ)ãœAꀄ¡™'ªÎrÃUÎ1u¾Ýw˜:Zç–T0ãuû‡æ«wËrã&^{ ›¼,²].PÄ-»Ý€Vé²oš®¢,âÞã^ß³1šÍTçÓÌrv Áå4# £;r¦ÅÓ7<8߬e–š©Wº8d8ƒFÄa›·Wî+]fÒùº?§šŸ…ÏS¤Ù,LÕVÇû‰hÇJ„]΀¬ ÀÌRJVžÂùå&gJ¡$v»×–Y‘ÃJ1Öz´Yn!f¹Ë™Áz ÊêÐ#â³ÿÃ?þþÝùgº ÈPkØ>ç?´¦Ë>zâÖ—qFåß•_áèä‹ûÁ‚/<`Á‚÷xãÍçþÎröß3Ÿ¹þKùNåO-ƒÀã“õ÷ý‡âä«ïžo7fÅf°:šfµØáÙ0ëH^¨’Ðì?ùÚ;¯Ò*~@ÛŠÊChÁ ”|"5“Ÿ³yÐç.iÉ*E«‚PJÄEøQ$"BI- zâôêÊ·;˜:ds‰PÙS©÷]ÙeòøSÿêçž>YNò(ëL.³P4H•þrhMþ¬©ÇU¯Ó†KÌ“[ç¬ò”A ŠW)PA^ˆ,JÒB69%xSL眬 ÍÅ?·­,fÌ{ÚûË Ð-'‹«¾d*VÓv7Ai>­TËWžú>cÏ+ÙJã«é¥ŠÁ¹ÇRJÝ‹†YîÁ‡4Z;aUîU÷£¦|Ôú¶„\«îdHcÊ#¨Â0xd<øÍ¿¡ÿÁ?ùiû ewåB©ju¸¶·£ÚØí‚gPÿk¯ü1÷I,fÀ‚_H,À‚ï \û5}¶G¯aN¿®ÿ°_{i)¦^Ëø+ËÁÁ.¿éÛí¯ý­ßðäü¡ )ew1—¼ä&Šõu^KÅ‚É”=bu~±yåµ7V1Ÿ*[ˆ¥Z‹€¢évÖZ§N.Ó©Šâ! +„R“×Y•ƒ0w(‡Êe¥.y¼ºÆ ²'"@CT®j#cˆ>¢Ãén§ŸúÉOäÑ;wX09Bˆµié˽›ŸÕ}jòÇ‹Gžù–“:kYUlšú< ¢sòé ¥C1æIÀ7OaNò•ƒQÇ¡ƒý*s¶t°5Žvu3œSOJØnwd¨%žŠœ¦É¸ªV~¿™› $ö¹ “æî1¸¬õ÷"D˜¥¬.œíí­··ƒÃºœE3G£sˆìä<¿\ɉγ–s®¦Ù¾˜þä'Û”¬XY§cÛµ5ž«4ª#Œ0w•ì…”ãÉfë;¡—¯= €Ú ¯¹ØDS£±4HYJ]´q›únu±yõoüï¾õ×~ýȼõ,å‘Õ,Ñlù—îhÕ—ñƯþåáãïóu^Ì€ ¾x!`ù€.XðÅ ß;ÔøÞpûð•7òþƒ×%yQcÂ`Á˜M®]7è—ðÿð÷=wŠ™Ð¼ïN"{*„ú #ÒL ™0 vòÆ[î?¼èqf»hY¥”{é4f`“ëÌÚ8zT]úM¨ÂbhHÆLÊ‘%ã¢BR¦Ñ]în0Èá&ïÏ/RÎѼW)+ ºJÊ/„<¦Óþν{~î_few´‹‚1‚É<«”þ©f‰ŠhjA5“ÒTÏw³ ¦«ÚSoU¥{Iž–"ûË'ke#£;š—]jÆjŸcqÐ;ù†½rã#œÝ: Ø7¼¬”<ªåí–SNcš8<[ëÚéËZÎ󀢡©|¶íÐÌUÊ"ÁP+@’„Îâwœ¿ýð‰B?&ÉŒ®Ò*AIa]8]¯óåù`ìr&h¤“åžKäA-FáÙúbZ©ƒÜë:SE¸SstÕŽoͺ0—Ì:¨òd;¦Î½Ë„LŽ\êKA4˜‹` B}Æè`¦äbˆëì‚|ó©ò>v·§Çà^§Šj4ƒq¾xõ½ß“ûv p:Áç‹°}ý,cÁ‚/–À‚_Ò˜~>upoîbÃs~aç¿üí@íO#P­U.R’KHɽÛ= >ö×~à*Ž©³’S]*aÌ; *I±Æ⚤ dðdVÛm~ýõwv;Fœ(ÁL¢ €¼ÑYÂ!§71øT¯R$}º»n÷t¥ßÆ@²”!YÅ%˜÷iÄùÅ6ØJ28¢EåÂá!Wì:eë:;ùéŸú¹û÷Ÿ¬ÂKi+‹¥'Wmf\xiÔÕ<ÿ¥Lê^(2¹P…I¾TWl¢jh,“jqÀi7W;Ò꜎‹Td/ähV@ɯ­o188æhu*gwF×®yŽ«µS¸² `;쌱œ£š:3ãbŠRÔJ©·;£§b®S»´ÒF@€Ñ¼˜PeCÐ\Ì ´n;êÕ7ßÞ¹„˜²J¹H+5k†HõO¯³›¡s‡+Ú^Ú ÊL„j'惪sÎvuuRÔ’ J)§f±Í ] 93Ä“ó‹ívÈ`—Uš@×NYBÑŸÕ cSf i"<‹ÉB 6l?úeWóÿ;•ß\î¡ôÉ(M¸ßcû©oç˜>'|Í€ÏãÙ,Xð¢X € ¾t1cìSÕòáÆ»Ôß î [qCÀ©—1)u»óÕÕoù®oýE¿åë6¼rSN2„u!ÖNa@)Y_ÒX% ýé›÷ŸÞ{û\¹·1‡eä¤ +$²øø]rSµâÊÿê¥rbÉ™•Ê…ëÃat¸à 2 Á³{Mùuö—›t¹vã©'# ´1g•]î]ìÒÎWý§O®þåOüë”ÒiiP¬‰ª ©jõ©­Á$éiì€üÎÛжBý50÷Êr@n»m·9 ¶ßªIV–>Óú·œ3£böv7-ùÜ?3jÈ瘙;çÿ–)íºr.ü—œºÞjîí­úI¹t<49««M:åXð}ä¤Xr¦l9ÃsF §o¾óèþãK¯ ÛX‚ÈÈ2ŒÊÖÅËõîj—\Ñe3˜Š JDx'ÅÜÚÔÚE5µ¯6õP!ß3ë©Ï¥¬t‘ËJ9u]¿^§Ëuº Kt7–ÀöñÀ³94“G8c|÷ðǯùýßúåйTj¹f˜g®/»æÛ˜Ù×þ½G_1Ÿ|~϶`Á‚çc1,øÒÅì—øèGù·Ú5Oÿõ¸?®Þ¨>ÚÂeÍ%Çè}î¿"|ï_øÞ‡OƎʹ”¯4wS&FFc1¦d€Ý{óþúj9"T–¤ÒÈ©xÆ[eËæ‹ÇÄûkR­$圦Œ×=QªTÚ ã/‰”FÀÝhÑ¢'§c÷øáeÎyâIUtîf2d‹1XÞùÝ“¼òÉ×_ýô›«ðRÞFÔ|Ö:QÅiñi’zû¯³ïvE5;á0‘ynº©N‚7[zäAëÞVªžÍݯ}paªßtTÞþp¹+>Ò‰Ì Éúïl3{áàVá¾ÌYÃn,²œ¦üÙ³ÊÉ6j­À®IQ¦õ,W^óΛ~ŠE­§€5° ÆaL1žm¶éõ·ÞÙŽ.„ì’!U‘¹uÌYfq³×›$RÉX X%h(‰ÖEÝ¥\âþ¤éÓÒ –Vµ¶ESL¨ÌN-TŠ©‹wÆ]xüt“=}ö6×òz}Õ/³àî“ø$Æ4ž·ÿïßÿš¯Ø¬ºQž ' ¯Š¬ƒ¨îì·›å¸ð¹Œüóå³_¨ÿ‚_`‰¾-Xð¥‹CÊ^pK|_Ïú´ÏhksîŸ R€QJ9NÖ?òßþ'o­ßñ<å€RÓÓ;³àɃusv‹£ç×Þx{ܺ¥@Ö¨G4+"ìêBeñýR€PÈ™ÍJQ¡$ÉåîîÞ h:é@<»hÁ<N»åì¥Ó—Æž<Þ†îLc‡Ì2”ážÉLð‘¥îŸþóŸ~r¾ ¸›¶Á:b”3¯ïž[7‘R5˜wvÔ\€©3ïõ%Û³õ½ßµŸA`` m·ƒÓ…ZLsïyƤ˜ÑáÊß^ßSS±×ƒ pÍ%Ï©ˆç36(XØn·%E:¿7¡edWþ¼¯˜tÃk¼`2ùš‰Óh5ï½™dFP4”`8º;ÌÂé;ÎßytžÙg™ŒˆìJ9ʈv’S¸¸‡­gUïC1*F7ƒ1”»{vÏî©ZÕ$¨Ë0köÖF[÷CUj fV2g\õ|ùê)¯ÎA;uX¦—,•uS-I«Z0Œ&t´Ž¼JÛOüãø§;½Aæ2¥ V{nÔÅ|>Ͼû{w‡ÿ|©üÂC,øE°˜à |ÉcÎøÕþ1Ávà-¿´,¡®}ÅFCÜM÷Ç7à¯þ¥Ý*¥<tw£‘0 ¹BtÉ`,zmŧW‘+ÂÏp dNÙ‘‚j]—"ïA–³rÜ<1VoŽJ k™ÐV#HrµHL  2Æ`ÁG—aÕÝyãÞƒ¤ÐÙ©'#M®’àép‹ rîíôþƒÇ¯¼öv×ßñ-vFe‘Æâ>éö ·žóìÛ)-XíºÚ‘­üËžïç_pÒWuÒ¸Êqs5¬NO€BŒAÂ|JB(ÔS{ÆW ïÜ&°inì¾ý y¥f¯º^O´®Õ¾91(—+c.•”Pr7ª½)ªÊ˜6B<û÷GͿΖT}ôlMs­‹_fµæ"³êé“Èn;èÍwîäÃ<écö±Ø›"àpy@ìj= É^ºÓÎ a´ÀLjŸ¾Hó%€ÙÝ=OwÛ_Z1€&±Z ˆ,§±ûêïgà‰ùâ|¸ûRO2wdŠf!{¶òÙ’¹œ0Íâ¸]Ÿöý&_üÊ_ö?üCßô÷þ» ¦ h!¤œvKÕ¦gà(Bpã³Çkôù`ð/d¨,X°àó‚ø…À‚ >7ÜþsËçr‹0ý“-­³Ë110Œ)»ùùÉÕoþŽßö ßöo½sõN¿2À f°P+žEfÉCˆã˜?}< xEF…zDX\!)§RT­j §4ÊB¿ŠSuæÑ4£»öÚ…âøDt$0$%Ǽ §còO}ö^¿zn®P|ßfaÌ D &w’ÁN擯\^îNÂKiMëj;©B1-T=ÈÄ­ç³WêÕwÝó„Ôb­•Š•¤Š½ 0?G­‘éY|Å^, ÊrëÍxv‡ªôUŽ¤Ñ‚á5ž*ó`ráOÔŽÚ½¬ÇÁ~«#z¸[¦­Qøv;o½W®Ò.Ök(ˆFV«•4’ý®›"Ïã{-xPƪ}Èefæ j] :ÜÙU²¼Xj ý›÷½|÷ìÃ/ÝÍ>†ÒSN³”3³hYxðèüCüÀʘ™-$soc53¹wˆjZ€+éår%wA¥ÏW]Í\90Ôuiò[19J_ #ú§/_þÀ)‘@t—1 –* .BÙ‚ÁºÓmÞÆ“¸½úÔÿàoýü??þ¯>ž¶9FK%n&Î ÏgLõÌq°÷èÚGÏNg~fpñsÁ~§.VÁ‚Ÿ}D Ђ_Šx¶‹nvÈ-<ë3_U$Õ«,t3xrRÜžüÒÕü3ßõhó¸?ëÜ÷EhÜ‹§*—‘<²ßnÆG/<…N§T4 7š»™Aº™;sè,C •H–:>å­EdÖ‚^’ƒ圧bŒM¡,1Ä,ew˜!œ”G‘0£yR°.†ŽÎžý°öŸü‰ŸÙ®s¯Ó<È¢ØúL‚N} 0ý­ôÚ`mþªÌe_+f_Ïœ˜ïüe² Úš|Çt£€¨nódË\jÌ“(aA2+ìßæR®&šŸŸ“ÉÄiêéGUi¦`Zúí$k¡‘Ž6Æ1{" Z­¤ 3k J[ts:òµÈ¶oò0O±›ÚÐb å ˜È1åO/×Ãëo¿Ü–Ý-˜#•·³NNî>:?¼¾Dˆ.d8©¬Dº+DNòZYJn”Í$ êVÖ÷áä$ö+[„®³þ$„€®B3ÍaÌat¹%˜NOï^\n¶»‘ 5»ƒ*6V©3Z¬ÈŒ„ GÎCÒ.GàòéÇÿñýý+¾zvBfFŽ"ÐÅ]y<Ù˜Ÿdþå3ôŸ?M×᎔i ,ø_vþþϲêEPÅéÚ÷öK/Š1'ÀÀ“7ßyüäüJ¡RÌK¤¢3‡±ïÎ<‡‡Öi·îîÆl1’twYÙºÀ@´ŽÅ„+X$eÐ ÌR¦9á±C¾: }oýʺŽ«“Øõè:ö'ˆ1õ+1Œ£Æþä,)\l†$ÖäzË.ó!" Åà&Üb’¨ñ¥îÍÿÓÿð›Í§B§Ýnb©Ë…k3~°®oÌÙ½Ýz8ç¸v÷¼7€7ý]œ’ üÇb,Xð¥ˆi>€Ã_á½Àãøõ7ýÀVŠ¦I¨A"Àœð¹¹ê¯G0»±`Á‚SX € ¾äpä“; ÝëæÇ^àç”ûÿZM{Á˜rF‡n÷åßôõ¿ùc¿ÿáp©`Jn}4 “$,0$ºõ6½óð©çN9*3YtÉÜŒH†}’›A”¶aÀÞo §H“Vò ŠÊEÁÌÝÙ*Ê'e¹ˆ«Ï+îºGo_mžúiø@“À109Æþr“þùOüÌÕÚ£Î|d´Ö´õšzæ¡,”^3ŽÎyM Âs9«°9w 9M÷OÔ W•â×÷kF® rØ\ị́ɈP™(i‹44[¤ròãàÝk«²ýFj™Ä׶ÖìÂÙ”<¨ÁÅín´jçì Ï©xþ<uãV<ÜÐóyœMÍ­¸á”*ê#y? At*S£²ØÉW¯¼þÎz›UÊ`iT]üæÉÇnu2Œzðè*yŸ3ó>°#³0Åêü˃J?ಊ¨Kp˜/¢6É¢œ­Ü­]@$Ý3©û1c3¤Ls§•üÔóQ0W6£D³@Ò: ë7þÒŸú¶oþ5'Le Ì쓸ߎGk^¿LæsËÙWÌÑk^œ¯ß‹˜þjf ,X°àß `Á‚/-ÜþC{äA›ýb?Γ xÒˆkªÒ“bÚœn~ðÇþüÃó‡}G£|çA,ÔÃŒ1 (ñÉãóõŦÇ)Æ–쥷—¹J¿]”¾§a«…ì+——bÿÍ ®Vÿ…€‚5žI†–4\úþ"¨¿z:>y°‰é´Ë'J™fæÊŠ]°l´âÙ[o=üøÇ?ÓÛ‰FBVrL>›£ù-ő愶²Æ¸ú7L=g‹ÔêÜ×Ó¶Òø{AÙÖ”²ò”ù»õX«^ªÒî[´uœærâxûÁµì„ãªòÕۘʋ’ð 0ìR¡²åQM© û÷d3› ŠÞ²?õŒ{·à¦=®}•Žpƒ5srHZ¾üΣó·Ÿ×“ð†|Q`1,øÂ_:¤•×sïöìÙ näžr‚?ôûÿ›?ó‡^þúnóUˆð”ƒÌ³yÊf쉸]—çähÞÁ žƒZ7ÒF½¸H+Ùmáʹ÷ˆ£:ýU›,U^jUP7W5 T„D&DߦÇo=ê|ÕéŽ'¸ÉYØ|v$åÂݳ<¼þ?ù¯S2Ë'yðØ‘>‰Sˆ™ö–C;ͯÚïïNõ35ó}Ï mÞHˆ–);#‹ÍôAe‹sV6™u&S¶Íf‡©tgeuG:$ÌïNÕŠf¢2ó ³íãû!ïËy½œÃn$B“ÜÜÊo™‚g  ëÆ|„öòCkâèÙɯ] x1v¤L+9åfÆ!%‡ÁúûO.ÞyôDÖeGVÉ*ÉÙ:ÛC°U w=ÙÞtû—r¢[ñ×—8ÃAî†f6_Ù SfËlÿ`êg”²#,!«$ Àà‚…n=eW) HÛW’%d TWñd7Þÿ½ßöô| ýîP²).LIÙó¸Ï|Ižùý1ò0ptx ,øbÆb,Xð¥…}=Ôx±º­’¥iI!çó³íG¿õëþøη.ž®N %ë,t”9 ]áé“««Ë¼cFÁ.H ¥lî©zq|zíñZÞ¹ŽkÊ&P+m’^\ÿL4‡%3–%GQk³³ÇîüíõæQ>Õ¢g0(I)¹àI#"³R } g?õ¯>ùÚ«Îìe¬i p¯ªžÊü›®ƒ˜»ñ«ð¢ y"÷ûùãTys_ÈF×Ü/Q-:‹L˜eÊr& ¬¤D{`¿^§açd`‘xT¾[ßÕ†9H¨ådOc ˜X6Û˜<ÿ¥¶=0ù4ÜöÒ³c­˜jvP?ô9xÖ&=6Hn6,®YÀí k߀Ã|  0sw€YÙå9*'O q›ôé×ß\ï<ØiʤE‰)¥±K[!÷qyçÍ7»N¨.yRà,´\‡J¾pÉØZüÁ9ÙxÍžL2=•¬˜sFsx1•ÝæYÙBLÙw)»—æuAÓVm‹U2ê7žûÕêüÉÏþíÿè;¿ú+®ú^£ç’-ªäŠì÷³¦tn#Þðäá#7.¼fÿ=ã˜éïIX°à‹°`Á—Þõ¯ã‘ãùÇ „ B\\ »—Ö?ü·ÿÊkï¼qv·“'#Cì,öD°<ëу'yPô®t`4åRÝ¥¢õ¯Å…LV k¢VÍoµÞ›{²$1F˜á´b’”ÝŒ4·O¶O·®:_u~½Ëð*ŒEÁ,„•'®øÒÅ£ÝOþÓŸK[éNÞ cQÖ·Ž´š8&ú%:Ò21Yj“ç4ouq טÀZšú¯pø–ûQ#ô¨“A`0”r·Y‚¡¥ì‰÷Þ²*æï>1åÃkkƒ©ÌrŠ‰¥Êd*”&Ê¸Ý ±¦L}ϹçyÄ7ì½çlåÈés ‹Ù<9Ûq9ÓrÓàôÒ§ÚÜeh!9ÆŒÕÉË÷<~õíûŽ^ê¡Ðw”C ¢Ü4Ž~çìÃo?¼x´ÙXwšr1r™=c_s¨åWÓe–`sà[Â0Ê €ÁZA¥Ò±ŽÙ³YïÉÆ1»ÓE”´`J-%ÀÝ ÞEå´ Ñ‡ôéÿî~¿o?»ê 8åTùTÌ?Îú©$¸\„‘æÑGÛ\¦Àg=›šÍ°?Ï$IÑ4ÞZu_lhzù5þÞD(3Bî²7Û-`RmÓ íƒÍ$úy«AtíÆlP<<ŒGÆŽ&û SŽ5!)SfŒrÖõ$”Eë„°Ùyì^Ú¥îÕ7?¸Ø¥°G72ä ”¢®RêÏ>´â[÷7)÷âɘ3Í £!ƒô<S&Q2o ÀLd ¥‹ž år•ðA•âµ2¼unef.ëˆ~”xÕ” u ¡~°Œžuùµ_™ÿÆ_ý–4¼cFG.éuoÿZ¹¶lÏðßßþ¢ýþ;ÂdbÞh†,X°à‹°`Á9Ž~zgtõ:^Ôá?;lJý-¾[9‰œÓ¨Ýe·ýÚßñ_ño}Í&_ÅÞd²®‹]Œ]„ãáÃ'뫱穧9 p A¡—š%¥,ä^b®}ÿ½W¹¥0ZÉœdiëJkEä€ÑbH.˜1˜8±“|5>½Þie¹ÏIRpyV: Ä´Sߟ¹ì?ûÉõÅö´»ëÁ`òÚÂɽæhʶmÌ}ïí¬C&aMt<µâ©7-Í‘_óÀB=ótØ$ ™2XŠöTÆdµü ó0\í”gu&k홽6¼©’x4Òf‡£>~óÙj6 HHÉs.ªŸf:3xÃÉÞ=N·Mü±Æ1ê(97ºÊ¸Új±‰ìe4Q’—:´!˜»,ÄìN3ØTˆ¯.ß|ø°;½ÛÇ•ÉC”`® a;ÞéÂËŸ ŸîOáÝèY&Á-ÄÉœkÖàÔnm?1S^.Ž.«%’Tƒ@=±ôÄ ã0¦œ$ExQIµOµËÇྻ÷§ÿÄoúößñAå«äbÊÑJ&ñ³HýlÛkö oçôï·Dæ«zó ,ø¼a1,ø’ï {ÑøŒóO¬ªD—Ñ!£)ù€íxǯ¾<þÁ¿þvï 7 ]ÇUû«Ë«‡2YHR0 Ó+YðæoD‡Ü“BA´Bîg:yV#`Òl°Ii@Ê)JÙ "#¨; wžÜ¿Ú\æN'Ø™=9­·aØZŒ¶ê¾ê«¿æáÓËÿ×ÿ÷Ÿ]nvA€rì(z‚»yF–1„Xz‰Í Õˆªbö=“(Ñ‹'ž{ÅLÍ3¿smšnòøèVü¨zæ'®Ë–=ZiíT9IÍä ÛÕņŒÆ 'ë·ú¾žjc•-Ú!L‰¹ÁØžjô´‘ív$ëúÌ°åíà¹uqp¡7OŸ1S7MÙ~Úf[~Æ_Û*˜3û„rLÑ¿—­åp‡g ´ì 9æ1º'£‡àŽÁ}åÝn÷ÉO}j»ËwOï¬:ë; Á‡>xλ,ñL:{çþf›B w’$Â1f8Í€Òµ+ÐeÓ…S°2ëÇ\·]¦égÍ,/!1ÈéN±RÚí’«4=õUM eÑÌúNÛ'Ÿü/ÿ“ïþÐêA0d“Tóˆ©JÒ-+@Ì—µÝ}Æ+n4WñÚ]>r=>°`Á‚Ï?ø‹¾æWÕ‡ëÏ-‘¹ ¾ðàµÅkÊ[ €Û_PQ8·Tªëx©û‰œòJo뵿ñ¿üý§'»îÌBˆ!ã,ž xòðñ8ŒAS4 ÙsŒ{K­5ì ÈÌ|ȵâ礢ŸF¢ÙD¥ÒŒI"Ê~N|‡'Ï#O| º’èu ÚBÃ/ùʯ¾sç¥î·Îÿ×ö/¬?»¸ÿxw~åc6ÅW¡‹Ì. Ì™­¹kõÈ–Yñ–ÑÛxZ¡g>é¼÷þ[j:èÚtߤ¦Ø;~ëëŽ<ÁœÊúLE“ŠÕQ:£¡ôð ,xÜ}è#g¥¸eµT\Õe\Æ©‰ÒOA€L0*ý¦>ý­_ö¸óIÕ¿< 'T«lOå ¤œq¹ÞQ±†jÉÔYݤóᆙ¸qO¶CLTýø4œ´M¢ætyÖ9 ]™-³„{ù‹—‘ÒìBžQ>™V}wºêW]Œõ1¬Ì”†—zžž@Òz›qÌÊÞ™õʲU´!_­Véå—N¥HÁ˜ÝŒ0 ­Øm •x½Æ‚Ú”\¥DÚ\QE@T °Áå©[Y°Pš¸<ÐÜSˆ]&èwÿùÏôôÏþßN?ø59åh;kzyÛÊ7nÐÚízÚ5uÏ%å×6ô~ÿèpÍÌ…î/XðoÕa8¹ñ 7ž ¼n¡P/ð[yK}ú¨ì¹I)çDŽ÷ìêýÍ¿œ>Hs[Åè£ö/í6›‡E2¨‡ €Ç`î©H*õ¯<¸UÝWº™ ‘«ðÓ=ýÅRñӧà isÏ'w»—ž>ºØ^lzÞñ„£\Ù!ÐìbuçìC_õÕüÐG¹’x¹ÿßÿògN>ðeÁN?z÷ÃÁÒpyyqñøÉåÅSHÆ®·³{–¼°îJÔP‡¹í½ ªôlšý}ÍËÂÙڵϗçÐØi®è‰øòÕ®Ô·ˆ³‹_½0=@†JùÛ€J(@¥B¸:_¿üÁ;úÿ³÷§Á²lÙyö}kï̪:çÜ{ß}óÐИg N€  HBˆ’ H‚ $Âd´:È)ˆrH¤eRŠ°Ã [aÿp„"¬pØaý²õÃaÓ²¤Ä0 t÷ï|ïª*sïõùÇÞ;+ëœsï{¯»5Ùµúõ¹§Nefeî»ò[k}ë[¤”QäSg%¼Wo#¶ÇÁ®ìáÊ=RÏP³@u{o³YADíȦ@µi¤vm¦»NÜýåS»mê1ç¾ÈìZö,´vsm©– ƒàµe‘“(iÌž»ÀEŽ‹å¢ëB2%³$¹e£‡ηâëbJ·únGÚzÌ›í™ñˆè‡1‡þd‡û¶7O}Œž/,@žA‰„—¼•‹*M›ËŸ4Ý/ÓãY³iÀ¤-[·Òìê £u›Í¦_  ,˜ç"ç%‹qµX.Æíßñ_ûÇ~ü«ÿ÷ÿç÷²™9CPV“-½f÷œÔ™“õÁú´ÕÕéÞ¹j³_.y×îx°ƒì i‡ ÀÁö/]‚ŽžºJŸ¾r÷Ááôaôœ/º'¯üÀ·üŸÿ‰‹ôh±Z:Æ¥­?<ßœm¶`ÊÈ™ƒ4¹,6ÑI¢®Qã³'øî,[+ݽ¬ÑÙâ2€4+Û‚¥a8êŽ,óÁÝGôžêrFè˜GQ]¸ðq€^ÿØ—-oÞGÆEðqŒñèÿùÿùolu#¹9ŠDCä2Äà¶>=r~þèþ©Ÿw Æ-ÖªEÑz6í õ^f/0ƒDœJ÷'ëz3ñøwß¾u©È%¬uh1ZŸœî:tÇÅÛ«¸ £Ä¥DW˜4=k”"5~Û‹¿ó…‡]¯=¦æžP9+Ÿø@8Ži»IYÍè¨äšZl…©{Ѧþßò·ëÂÅœ½.³äÄTPÞiWY¼P¸ ¬®‰§¨¸Ê&IDAT<©‹¶èÂѲ_ö]4˜ žÌ(Ofœ\£¥Æ_EÝì ž»l6*$çÅÆ=uâÒ3bèyZ¯ŽxãØ\kšÃÝBp‘0ÁÍÔäÎ/}î+Õçsê»»­eäfÈi¤¡ï:«.ƒÃ¨ä §|ÜñÂs¸ùÍ?ðÃÿó_ùÌ+]X†@"dŸëíî×½*Ð_óßÞ×.ìÒçó¹—o¸òÖÁv°/€]›88;Ø¿6¾0¬í¿¹÷”Ýñ F攑ÓÐç³×ü/þ¯ñ¡?^-³ÉÌøäþãq³Ypű#Êœ¼ô-¥•ĉ*"íÈ…f¬Vþh’ZHy — 3ËÙ §¶X ¦„£n¹~t¾>ß:¥ÍœóØÇ~p?óáöëo¼üÚÇ·çYÊ7–q»»““ÿÇýß0"å.E¸»‘Èh®LÉÈ`ÖõÖÅ1_<:{|vv~zº]o: cg¥ÑÀTz[¾ŠË´7å4Ú;Œ½ûßռ̈́`«ÈK{ÑâºEÔ½¨À«|ä®g@  ƒwuÑßzù–EÏÊ­ØZµ¸µÚ¢4ÂPš¬uHßþ£ï|áaÌ[„)MçT>ºø!åÂÎÏÖ® YéxÛª¬EÜKŸZ^À¿œØ íôÍýIT“µÍÖÞ¾;ïiï6WY›RR’F3_tádµXt1X)…Íë2£»áò`æîÊ‹`ÈóöÅ£åʈœip3Ñ„n;òl«Ì˜¥l¾~áötÎY[GTÒ”×¢iÖ>ÌbûµQŸöÖðtáíþ)¥Ì.o*R^V ,„Xºô™g-ÇÞ†!¾ûðß÷#ÿ©u_¶M)X§’dR»¿ˆùhÖYÄäLãû h~u~¯™ñë|ƒ§ýñ`;Øçkà`ûÝ®Ë{òäüÉÙÙ“SÆ΂±´¨¸åÔNØ^䶔Op7â-fº#x_Žï}§áÑ)Xe­ì¿åÿqÃ'@FôÌnk+;¹±JLD†¡¢KT÷Ë!ȬκvóËO¾ãöý˜·”Ì€©q³ ð¯/Zu„ c^¯Q½¿ªn9¾óî.÷ïÒÕÇÊeïUÅ ¸œA`¹y¸»—ê=Ô %Kùȳ+“ê"W‹þhÑ÷Ñ¢Á}0élŠm£Ýv*Š@R¹i<{° fŽÛ[ËþÖj¡<™!08»ÄîlH[ÒzW”°ˆØnOŸ¿½è£›@ŠY$CqY9¯¬åyEvÜî¦jcÔ xŠçY:ÉÇ.Æ.+40Ñ=¹ÉhžÇåòµÿüÿzÿ/ÿÂßpG]rAvõûdw‡NŽéVøàè|‘˜~yâ?ø;ØÞ®u5;س]z^ O÷ÑŸùü¬‘ú¢9ãy\ßOþàKßøÆÃõ#yöäôììtÕ/B6ÏÆhîÞD&a2RŽL˜ä¥^u/ Ð8çHT;­,÷R°šr Wiªz¥`éï‚ᘂÝ%«Ð¼§ZKÐòr\oÒ*³ ÞÒ,Ác‘œ7ZÆåÕ.€^&Špù¾0œ¬qT\N7›ŒÕ[+x¹ú ÙŠ eEîª"üÐ@Ó³Væu+÷)Ïi„”FØx×7¿ñÅŸûûýí‹ûaáï?Üžoa†F6©/j)g­åÝ}Á%YñŠlÊåbá3Èa@ºa3<|ðdÑ[Ž9eZÇÏÆ­u«¼þ«“ã­nµmq/"§{û΃Oß’’§ÈN%6]1%Qkµµ`^èÔhLöñ!šÃ`£sXo×ÛÓÓ³ÍÅ9¶ƒA]ì‚…z lQëµm”…^a’ãÇ¢x—£2µ0tG ™&²&v»SH&J®à¾n¼xìù¢¢PðPâù^@(­k¡Ãøí/=ùÎçî(7-ÏQO¦œ„Ã…0lóv›‰X}¶Y@¿…©5i@Õbç¬L7ÊüÆœ“ Ú]Ù¡Ýn;ß²¼i5A€,ß’*.ûnÙǾ‹] ðÈ¥Ën°Éé(ÐÙ­}I¹ƒµü»°ÑšR»EafpW`€†ÎÆÛ«Å’Áœ"d4gÅÓAçÛ,®ÒC·Èi¸½u³ïb¦oÌà‘@”¼ üp7‚ó»áš…»7|•5/Ðemq`R !Ä`fÁs†’ºNãÖûç¾í~ìï}úÝ›î«Î:/>HÙù½mú@Í\·i*žÇçï^ëSLÇžÿ~í•;Øçe×fÀÁöEkWŸ Ü{óåŠÕÀ¡‘³çÑCºóÒæoüççí#‹þäÎ]Ò"tA]`€ÓhÈ…(à^¨%p»Co; ÇÙç`½k\UÙá¥10ÌËûN)[°¢ÍH§Ož ëaÙidvÄ>l³_¤á#ÿÊãÛ/oR@ôÎa sŒpÏÎððüâÿ÷Ï?Õõ7rN0Í8#•2©EäîJƒU)—‘6šQ´œr,e „À``´ 0mÒv»¹8;ß^\Œ›P°``SU—FxÅÙV»eUš¶7H{¥< 8Mˆ—S`Fˆ)Aâ½&cgPPçñÄŽnhPià ¤@ÒkɆ@X‡áÛ^|üÏ?ˆykMWh'áZ1Êe„”q~±!¢ÊüËfXmr1»'&`ZÜD]ªyhÞa|ï¶lMfŽ « Û¹‹9нV}Xt!Æhœl† ‡§dbZoi¬Ý0–Ç`-e©âUµ1…µh=8Œ0nŽ:žÄ®ƒÁ˜é’­¤cƒøä"msÜ(Ðz¸ä£%OV 8—9e^ªì{µ>y³2€úlž¹@—v+vFi &¢a»Ó8t}È® )K9„èò3ñö/Ý{õþ¡ÿeÒÇ,ô‘!× ‚’Sª}Å8ý{üåƒ8O ä_ÅOËì`û\ìZ ¶·v°ƒ}‘Û…üWŸ™»çxûQb*MãôçÿÝ¿öð쉰=}xŠmZ„>*Øa¤\Á‡H¯ðh5®ƒN¸±[…†+¬+øÄA9h“Ú#!˜E¥,ää<ÍâjH!P¶\<ÞnŽo=ÿŸøä°Õ ±w …§e¿ÈiT¶üoÿɯß¼µ]¯­Šµ¸ ÜÍLr¦ÊçŠ'4²º»àÙÄ„d`Ê02£î¾Ícv [®n,V'7åcÊiX_\¤që)É33º¼jätg“íÙ±UXºï8l¥¯uªÊ×4‰³[`BÖ ž©ò˜·O†G+P¬¤Ð59m­à¢ƒ($%\ÜËKìN÷0£Ü@T˜;ÝPí®”$ZÞb÷ì©Ì› iw—Õ›pyó\*ÜtAY£<ÇŽ–Ë°è–]`G™%×@:±…—È: ¤™ä»²lWÉ D“ÆÝPÏÎXõ­ù5•™(·ÜÕÖcbßQ"iérX0hÛÁn//’k;ä,³Eu±Æ0¦ço.¨¨ªµÖ4G=¹HeÀ&E×½tÐlicÚ¬ÄñjËî±_äœíÝîõË ÿÊ4\óǃì`_H+ÀÁ½>ØÁ¾8íCçáxåa‹Ýþ”4/QÉ)ö›ïý‰X~ìÅ»Oîk{¡Íp´8²Îtrt Ò–ø •*ÆIó§t¨ñÜJ£P…©Ð©¸ €\ (ͤ °+ˆÜ¥—Žë±³Þ3}\û˜˜?ò5ß°\ž.ƒQ)›@‡6`¦2`Æ‚ÀK\¿DòéîNˆXê܉€²YOdÖe²«.v²—-9ª·#@ h #³oÏÇÍQ¿è$Q2ÐALNnNŒ'Ç‹ÇçÃùv´¸Ü8ý‡›ÛÏG Ižgg°ó›w ¾^Íô¢,ã–*Ú¿9¦ŠŠrÞÁ‚ÜaÙÓ(Äl°°è·ÊƘÖïþÉ?ò­ÿåÿåŸý£¶½7 †¦èu¢ÏFäÒÒÇŸ'Ò8•ƒì i ÐÁöEkóÞ•åø~+³Fåj¬±÷c,â P‚wëô±ø?úûíS§.ò:¦íÂŒì À d!’°'L r4ÀçµCÕ?¸AÎxï¥ÈÕ Bn€hR¡ÙÝ{‚Eägß$á"o¼ñe7o¿t>8#F7(±ËfGÏ£Ù/ÿÚ»JáìѹE½ÒX&PW褻”{¡zqK¥,!Ésv÷R JF›Å¹mƒdh… DµòªyÚ>-ÆØÅØŘ‘×ëó³'w6çO4**¸Ë, €5%ÇÖFMFЩ\´VÕ ¦âÏÉ/õŽh:8n0‘!SîÖG/+lPä}²ÃÀ¹C¤ÔùöÛ^9ýŽçDßXño\Óq›+¨p~‘r†`°kaØTÁºË7T¨æ"éðrª@'k+¸””@ ‹åÑryt´XX„‘+gù†¾¥†@/œ*—‡Â³bØ% ÔR<4#ÝU»€"E7ˆ…$S¶Þ«AÐ4Æ“‰,Õᮌ”:êær¥<Ý}ÛÇxÔEL¼¸@+šœ EKI ‹uæéEÚªKú×ÛÓnŸ,; [£“¹Þ>œŠ¨¯8ïÓù`¦z´÷Q+Æ ÁI(ƒ,©ä=ä9G ì¢Ã!F1>:ûøïýÁÿd\|r»Q×uæä¥÷ü#¦Þ;ý“ºr[\‹×/å æÇ~ö7Út°ƒ}îv-èàì`_Ì6Rî˜×®ÌKÇÙû­6Õà.)"\ë8Ü?:ÿÓ¿ø—Ž>¶zrúÈÌBV0j1nUV`!‰R «‚0Hˆ , 3:8Aȵã˜Ô¯ÑèN ÁhEÐ’–†í“‡z[Œ£Âb•£ùö‹¯½ñê—k£[0OÎR/ NèÙ-Ä;ïþÓúæÇÙ5ŽiÈT„kv½ jÀ^³(«ÐdE^¦âUNW0)ÜãÒp—d‚5:’^Ë œ@ö2&]X/oÝXö}¼ØlÖÛÍùééÙãÓíz=œm"ÌÈÎbd e43d(™‘¢Ú¯Ö©‰¢Ã­¢CoýlÉ•zMV¢Ñ!ç~|áÅC`^¢àŽy²¨Çø­/žÇí»½o!ŵ«áè’6iãàÛ- óÒ¡`æÔMnVI­Š¸lPÃÕn…óC“ª§¨ÑsFŽ1¬ËÕrµ\ô!ödÌrzƒ›²)C >8<-#зêáN’jÍwm†‰…Të)æÏ»êáMñþºaój«’& +)užO–]g"¤ì]Ç!­—]·Œ ºB0A.a!ûc³,,³Ç³­Ÿ¾l¹8^¯ÏÃÍѵ Ì Pz³Ô+™i궧7§‚û«ß ­WÂNrÊKúÅŒP–àn±ë,ZÎÙ,E»ý_ýƒô§þ±Z}yÊ9Ä^ |ÊèÌý‹ýòík¼«ß@¯?h ÿÁöùÚµÀAô`û¢5Î~b÷œÇS—O Sbð”Ò³“éœç¿óþž£WnŸÝ=ZÄa3 [†0¬”êîBü¼(÷°‚˜¯Ô³–`8+` ’«:ë ijó³õú< æû£ÅÙ6w«£¯þø'Vëì „œ,(»»3ƒ1Ž©‹ñáã'¿úË¿zo¬o]–‰b¥ÜJùÜVZZ}Š¥ñ˜©àøÖ·ê,ít§a`°Àª›®†Õªn}iá%!‚“I§Ÿœž>¶Ž«£ÕêhùâÉÑËo¼–òhÎÍùÅúü|}~±}r1 [¹cDb‘€.W+-[˜»Dz›Ž‘{õ`¨–«‚ ØæÍEŽ«(K’Oœ'êQ™Og®U³³ ~u~\$iÙ1 .…š(Þ2,j¹@ ùÄ /ΔÊy‚gå¤ìôÅr±Z=¿¼Ñõ]¨ê¬YÜ[3Êàôž Qžè™Öʦ"l­¦›Ø•ñ»>VÜ1Wö¨3jWκ'šþP©xiÒ« , …ZàfJÙq¹¶pž,–Ù©h]Σ™E3OcbN›ú‹®Ý…a}q¶ˆ«Ív\çÏ?¿"=ųW-IFî ~µ_¹Þ]ÂBíæ¬Wh¡8¢E!ÈÌ\N«‰ƒìI[:½‹7w~×÷ãÿc_ÿŸýï>ã+ðl ¹%–ZRdÿ;åšèÃü;J³ížaóT@óÛ®ÿ^»öà;ØÁ>_;dv°/Z{:Ìÿ0ûkz”ÀÕ!*£i™ÂW¿ô§ÿÖϽ÷øíå)ˆ¡y›‡¡œI+ƒ¦Pdù­™KÄ­Ò”S½ñh¤RšЃ>¦tzz–¶É´ìâj¤ÖJo|ä+ON^Èɼ#àðáõLô„çúøö›ï\ŒZö7ÿÉ?ú•e¸µ…SÆ'WN…aÄ"ÿR†cgfE˜”¾ƒ$%´Ï˘C¨‹å•`°¤D5GÁ•Ypåу°:YvË®ëCV¦+ÒJéjNyÆ‹‹óõÙf|r‘×[¤L2Äh̬e2j(vÜ7´ Að%y§RØÜ~é&˜”ê}ã%º+Ðé_xøÝ·ïõ‹z E²þ)¹±¿ØŒy€< H΂Â'=Ÿ*¤_{@¨PÏÛ)HÐè£Öõý²;^®–Ý¢ëÌÛüºÉR\,ˆ#ä­F ¢²g–òîúȪ¾­9`O‰BO\ €]³šÌ,‰0QêÅ"„EŽ¢÷±v³š—a ¹oCàÑòÈ É̳ëZʉ^êb„å6‡›­³Þ5ܸÑ-mœî2²Û-4«¯Ðta—žÎ»¤ËN´Þ1D!:•Zžêx@ð4¤ewã›ÿðOþ½òK 7a¡”é·ÜÈ.±·tžŠÆçCú¾xý¢ŒCà`û¼ìÚ @q€ëÖÖUý`;د›ÍŸpóÔ~‹õMï28³™YÌps#•ò佧ƒ+D~úíwŽÙ0†|‘ÞùÔ=ö‹Üê@çîϤç8KT¨ÅTPºÌôOŠR §ë4°˜‚ÛóágÛqR;D•:^NC–;Ý‘´XõG'+ æÊ‚¬\pdå.ÄÞ CÇqs¾¹8=_¯/¶ë …À@2X…Úï;šxMÅ‹‚¬7ÂÉ­ÕˆQ–!Œ_ʶƒÐ#}Ë ~Ëí»ÑG6ÎYû¸”ëÌJ¹êcJåP*óN4É“g‡Ó¬ëû£Åj¹Z…Ø+Di48ÊFÂÖ¢]¸ÉIÁßPô$÷@kzSÞšö¶ìÃ%_s$ó™owþ^yV3ÍØÞß[FeH ¤Œ¹½¹ê‚g1HJUuV¤ );Zt$sö¢kíF*Eï1ôîÌÙú³ Î×rp÷+>w³7ߘiõz©xIÂÕÅ<‰Ç>õ©»Ö8È€ì`_$¶ ±Ø[’ó¸æu;`ÿi9û·‚¥V")åà©?ü?ñ»o|üÅ'Ã…uʃHswC€Šü'¯V³få€,ßÊƒß WEL@éÈU 2•ï?| ä ;–…͈—_ûÄ­Û¯ ƒ¥h€)ÓÝ»™3Ð’gÀƒR6¦·ß~wÌ2 F¸H{þ•[o¾}×m6tÅ}±B^™Ãˆ³·ÆõŸ©©Ô”.hâP¸ô%Ú ŠËö|lÈd$df,ª§*žGa‘†´¶ëÇýqwtcº4²žÝ¼Ê HàÉŽÂñêäÆ 7fYÃv»¹Øœ>yBÙ<ÉÜCíŽ[Z¦© £M訅ÆÅG›t1/¯)5_óiÞ[2—÷l£AA Ê}¦\ úUç´9ç†ìm±ÙŒ¶¤D‡#0ÖÕ*g p%–e½éÖq#η9©ôpXéèhQks-ç-÷S®§Âû§Ÿx½1¹4µ®£ÔaW>˜$3l×˾Û^¼ûcÿê×þƒðÏÿ‹ÿÛ#†Û¤LÞ²gÚû€:hJç¥7&û€¸âj¤q>•¼ò—ƒì`_;dv°ÿÞíÒòº²ì.¹³¿]÷·CÌ•’/%WÎÃI¾ñá§þæÏêþ½›7ceÆ@‚žÜ‚í|æGÖ%ta…sŒî $@c ;";º.攌 Ö§gg!,ÀþbÀÛ/¼öÊ'³úl!ÄàãH™h¥úÕ䀲'ÀÌsGuù­wï®{TVºH!ZÿÖ[w6I0ÌTÛYáôÞ@]R®oîB…éld‡‰|@B•òÐIg´Š«6‘p»Šû!k\”Öû‹­ãªÓ,kt¤ÐÅãGá$ ŒŽ±ôP¶Ld° 9Wx!:BÊr÷4ŽÃz;¬7ÛõvS$•”B:¾¹X/RñÕb†Üˆù[^xï·ß~Ç2%†ê3Š.œ^ŒÊÁeF#-# =Ä°X.VËe¢…à…[ÞÒ#Í“"÷ÚëŠ K/ÌEÛÇ0úX¤~ÊV$¦ÜY}³©®b·(¦µq]àÚ5²w Ï—ÔîÙ7¯úhù¯â\˜tÜ¥eà™V7hz£“„Ó̉ä¥o)BØ•ö“‰ò€‘JJƒ!rkZJ”y«3礼æ)4ÅÁ¯”jï­žij.AÿKÛ{”÷ÚȬú!¢§ç–!Ð y‡µÍZr‰E2(0xF Èy»\ô} €+â­¥lÆ+ îYVäg ìr^^Œñáƒ+_¬üÆ1L[š—ÎÙ®HªXžœ¬½Ë»ú}€iÅ–%К39'c¤ n)eÀ#Èå‹ÿݧþõ?ó¿uûD-Hæ~©ÅÕ±½æcŸöú)v­_v }|€ƒìs´k€ƒ èÁöÅ`—”Ÿó!f9ôöà'@§\ˆãýpö#?÷Ó; ç¾A(Af¹H9ªæOíÛj;PÁ‚*efL¨†Õ "aò£toLÁºˆ0Q,¦¤ÂÎ!¨sÊi"JeµÓÍ,{.àÂô0zØæþxñð|uÔ,—}—9x¨‘lˆÙf%KAÎ@K³*€I´ÅÍãŽO’îë÷Þyûxu< ƒs%ƒ\ˆFºDË@°@ vñÉã³›·Ÿ³ÐÅÅÂØ™™{"‘•*½Ë‚«J¬\@(Ñå2rD‘ p*8•LYiK9!¢X­Q©Æ®÷[éԆɉÚAÏK¨pÿ‰vyEÌPdu/G¨+2®ò¦3ŸcÊÿȤ.ÂÌ[CcM¥äVn`Y¢!e…Э‡AìúÚ]R›sÙôÉf(sÀ,¤üغn±¸ØúéÆ7Û0ŽºytÜw£8PÙP[ô†*´ë/revžo¹ïK7Œ¥@Þ³‡`€eOL¾éËNþä¿ö­ÿñöË´—ÝsÉtÀQ„šàûñþgú‡ø*ÓìçÕ—˜ô`;ØÄìý79ØÁö3~€—¼ôëü—÷ËÅMa?¡=ùIxöŒtaçßðÛ¿õoøÄvØv!ºrN©0ƒ!™|É!4™K´`%*Æ«¢/»ì€ÉHƒŒ ¨<Dë©Ó8žoNÏ6›Áηö _ö•_ñíËå‹Î!ÊMnr„P;9ápQèÈŽ0IŽwÞ»7$eX‘_qÏõ Hµf ù¹—neŒ!š—9E˜©öø*1é Yý騒7—#¨»†`œ‰­Â|r Çf\"h¥”.Ö  øEåµ›Y= —\È|Ùãh<Ã;§-:ôdðÒÑ+&šHÉàÖÚ1Ôÿ27fÂ#Ge°ÿÈG?~±ÞÄЕ”IéñàB¡lQ9pçm¶Ãs/Ü^-VKÊÜ™(£‚ÑBͬԒq˜ƒ ©yN¥%¨N9*uÍ77L›7d+Å×*ØgÂ…15sœ.¯‘Öyþ÷ÝjÙ§ÃírÚmvy¿R)^Ï£ªrŒ¤§UìÊÝoí#Êf--f5é%B 1gÄÐo6ã˜2€¬$dÛùŠ'!:Œ Ë h¤m:;½±Ÿ?½·ñô Ï.,«wÀm7E­iÃübXGþ:<]_œ´®ª<–dÁD)'Ò\/Þü‹?óÛ¾ýëò¹K„BI]È%Íů®ã{%.ÏÔûÚÕiÝ»Šs¨ƒì`{vù+£P€®]É×&áv°ƒ}~öÁ–Ô<%ðÌýuý¶…"â$•sR6¯ãßøÿê‹Ó~àÈi´h;Q$sJìÿ²lNüµ·R¥IÔ:` î™&§CäÉÓèÉ=I£Ýç_~åc}8q¥*¢CiJ˜%#€Iž{ja™Rf|ó½÷¶£» Îl:;µ¯a§³ƒƒ¿ù©wcXÕ3”1#ÓXÈnE#È©\Mðq‡äIiÒ]©8Ñš´ãöLl¨‰¾·ÇŽ9TÆœ ©f=Ò¦I%r©W–ŒF"ÃÝGëìøÆòèh ËŽERµµ³vJ¬œªÊÎî $¥Ð…Çî?yôøh±=Ü™†ïyýÎwž|† `Œò­Ùɭ爀Úyã&Š†+OŽb Í•BÉJ4g'zv ‘òJ«Ù)MûÎB»vÙ…ÚÎnèqéVÊjjëâÒÑ´÷k4ŸÅÈÑ’$éù¸Ó2J¡‰áL#=ûlª*•–Y–\Á,çõ²ï–Ýòæ0RŽÀàEU 9Ã8µ~^mÕnpº6WG¾Z!pm!M¹ø e N£·çÅÖÆÞe »$–ê•ÒJíwV– \Ø°%â9>ùƒ?þŸœéãã‚ Q*E4œ¨€Óå_ž­yÉÅ5ÃþÁùó¯º99äv°g5ËÙEÅv_ß;ØÁ~cm?Jwí"¼>dy)J¦ù/E®(‘q¸{ö„¨»éîOÿÿìýó‡ÖBÚn¶ÑºJ2wWmK@Ð˱f±Æ†Tq8)ÐD™‘Á ¥¬1ëáÞýS[Ü|í#_÷‘׿.„[ÎÔ![á®°4xª4™àî>væ}H¦ à3ï¼»ÉÈ0ÁŒ€Y¥gO2ý5ðé2x×ÙÑÍUF]r²á–’&`Fc1ìb½åÚæ_ŽÖRÝÌjB?Úª‚þÍöÕ‡T äLP‰b wWÙ!k°Ú*˜`pA`¶Ž ¦xþp{÷݇g×Ì!¨‡‚À¢°©ÚÜ€DD©  1Ø8æ““çV«Wibe&<(U‡¦¨$QnÝ®ÓÔZ Ô /ͤ!@Ñ”©Žœ”!EÑK××ÁSBQ@mÒ’¬Ìžù 7|½çLqýÙ,=s‘ì^·ãì?õö·Ÿð$t[kFJ:ÃÉÜ£¼R¥f膨«×PÙò¢KLžCXlÇ´6U2«ôP3:2wZ´T¦Ñ "7iÛÙúö±¿r3QÛóñÉ£mÊˬEÊ.@rªIÞÖYpî®Ió¿?,»o´ìŠ¸çhÑ ¦1Ƙm{cuçoÿ­Ù®ß4s”º—©yÛlh9?ø¥Q×53qå÷gÛ¥<èÿ`ûÚt°ƒýFÚ<¦5û9 ï޹δ÷sÆÇÁ„%X©ÌJ—Yø]Þÿ?ÿG·Ï÷©óEŒJi±ì2òèchôž¿Zƒ¬‡Z\ÜZü@)‘ UMÙA³HƼ Û ÇáìtýðÌ_þø7½þñoY¬^ÌèBrG€×žHr0“#à¤; 40`\Ø°â‘Gå_}ûíQð\>¹r¼*ÃTAɦ/ „Æ—_~!!ÑjÔ¬R¢L8mƒg+N…åÝзø| JO`³F}w.T|«¾ MT}“6¢œZUÕãÞê“*zó/*wžå7™yØœŽwß9}poãC´4Æ@Ò`áÃïˆÀ Ï¥›-ðüK/¥œ«OÇè^äà % Cßæ±[¬<ƒfÀè(cq Š$‘*íÙ¤ ¡×6ú:ä Kç–×Á·‘5—Rù'*l’ê"iºÑÊضD /äüç3"Vó†ÝôÍ&òÒÖ³ê>K "¼©îŽS]¼Ý9É`Þ.Hî4äìÆnHi›rv@lå¨8ž2è’Ê:Ï$9ΖÝãWnè…UäÃ'Û³M”-¬¯ ô—•œp9/]èìjKkµ©éYðPÊïå> u‹Åvóöïü-Ïÿ¡úJù“!¥ä9F+]˜§=k&Gmæþ~øHã%wÏœüCó`ûpvpv°ß0ãS`SfûÙèæ²ëÀ†-gÏÙ†¬ÌèɳsÓoù|ãW|Û×l†‹>Æa;ÄÈ¢Òo—¢ûµ =ÂÙH ÖÄ 4˜Ñ¬p_Dˆ‘ÁyØXÆúbýöݶ¼ý_ý]«£×3‚J 4%±¶V•Œ^yìˆF÷ãfe\Ptm†ñ­÷îf„œË©²)MM´&8YÎ hì"_xî–ç±øFî^ûÕp)J§ƒ’HU¥±M&L¾7ìet0ý¬'P?jÇ»sååÃj÷ SO«)Þ>¦°nH™É¢‚Á£–¾æýw?¸{êE-:v„9äͺ£ÈîÃe0dd—ÃÉpûöó)@Q©•Kj" Y4ëŽo”Hv]v2ƒYíÝ[BøŽšÀQÇ‘z¥Î·×LÛ¨ 6„ïòR-ЦÌÀú¿6BELT,:¥O¹ù?ÊÛ-³ÖÆŸ˜/—Í&V,D2÷£¾§»0‰~îŽ6»EZÃâÒ¯`ÂáEK ¡_o¶CE8“âTi°-@ÎRQ'͇2-1œ-Ç[«p£_¦s?’ÓÝ#¢QÞn‡HÕ%€yÎD{·åî†$kåÏ ¬[¤¶ÛÍÑêøÁƒ_þ«éû¾üµ³HW†¼$Ž¨Y‚És»êoì-’ý¶Ù`wg9ÛåÙà!3p°ƒ}8;8;Øo˜=ÝOaèg>ÈtÝÏŸ†j.„`HPÎc7úëÝ÷ÿÔ>Ün}à˜ ¦Œ1åìr/ÌošaQ’­'‰ì¥õ©r®TwÌ…>úB ã°ˆáíûú╯ü-7_ý¶µßö°$#A4€îÑ`pW&Š è ²ò°ÔxÒå¨Cæ[w_$ÁÝ×”Ôx÷³¸鈘0>÷ü-Zñ[CíDÖŠM!´Öf(<Œ+ø}7 šÿ· Ïgs×ni¾«æî+ÇÝáÒ&O³‡’²º(ZÖÝÌåÊŠ¡÷-îÝyrç½GgOFjÑÛ*X—å >Š¢{&ÙÅhˆ9ç'·ŽVÇ£; QÙ(šÁSRJ7Ÿ»=f .·2‚^ª™[!))l¤­.z¿èÆ‹ÖÁ·Ñ=¥hÔAŸÔ|/ж¼ö "V_®ÞþÒÞ"Ðå‰À¥ݷɉÞÛx‚‘—¦÷Êš#Vp¹bP°Bx› >&7¤Pj¹ƒ§*õÚ²«V–»ÑBÎ躣ívÜlÇ"\å(y/<:•L$,Èd1\ÃIŸ‹~»‹6v§-ÇJK'–‹~®«ð¶v©€ÝÅOºW»<@IA˜K’A.‚!ÆuÎ0ä'¿ü÷ÿgtîv‘9ç’¿álàØnÛy„7:{ã:ÛãCصótÀú;Øçb—VÎÁ8ØÁ~ÃìjF{ö;¯lÕ^qÿùŠýTBc§×jÁkîÊYŒé±=úñã+õKsW0³` ”r]Kó®gú—3syÔGÁҔ࿚…-h‘SNþæÛ÷_|é+>ö‰o˃õ<§ˆ$‘ ôà-±O•zKQÛȰަϾwwð,@•Ÿ:óe Ð`‚y¤Yo¿x;û¦ÞYe‡ HÝ[O%9vééÓ†]Ÿ(–pµöÞ§®"î€m„ÛË¥WO—Ø"ØšÚT|j4Sd‘KñìÑæλ=8û†Î3RJ#h•'¥â§Ð“ž¿õbߥq¤¶}4¥lfÃ8,W+„ tZ)iä RM(Qÿ©óy£aqƒ<˜R€¬q|,0Pœe8ñ|´Ã‘;hZ‰f³!Ã,!0‡˜×Z½„½]öJ ÊD>Ý™'Eh#=s:‘ö¶v•®*7çìà./ž¦»h–Rq1¦´60”"ƒ&5T+ÈáD¦Ëd³çA‡Ç£Eº¹ìVqqþd;®Å¼pQr‚’K 44‘®ýQªÙ}'—@‘Ž¥1dOUI¶ø-o^¹ýðþ­ßÆ|4ä¦z˜y.뺱Üs¾`ö¾ó°ƒì©vi倃ì7Þø”ß/o4÷®: šo[™@(Â5Øæ¾~çø·¾údëÁÌr@ž,xö Œ¥TÔèP Í 5Ô p'‘= BÊ@ ‘ž‘‡Hx~ñ`Í~Åo]ÝødÆ Â–!(BΔ³àWBl„åÊéqjƈíqÜväÙ&½uïñˆèêj]šÚJåq#‹ì FÛª€;3i¼õÜ ‹“û´P}¡oF—sÖñi>ü;MÈÙ0«Ã4uŘü±]¢`ÊË\ž¸êcíšgM½œ+*Ýß ­ÏÖä.x‡;\! Fï‡ Ý{ïÁ;oÞÖyŽáDŽ”³YT–¼”^@uvrë¶õ‹QÙ,tc«“£/Œ4ã@ÍJv8Ò¶=61]„ñ<¤uHCDð`™á¥uV™K.oÑ`¶ëÂ%/n–ÉŠÔ¤H'&AÑv—ë æÒÝ0ÍȾÖ&’Ó¯;Ï°ÜV¥Ä ±Zåæ¤Í'ThÜ¢šAš¤žPR6„â³ ÈÊ>æD CNÃV(ý¶¡ŒšPñˆÈÐXú?;‘.][/âÅÍÅðÜ0Ž›õz„–R—‰¢'ÛŠ Úéíü؆¥øäõöµâŽ@F“{ Q40 ‹éñ}ÿ—ßwÜ׉òÔ2¡Và´£?kjö²8Ÿ|ß ÐÁv°jà`û 0^ÿØ{JÔ¿˜fÿa?wÞ@K}–; ÈæîY£z?~ýøwÿèïºX?^ô±4Z ¡ƒd”"#×’»œ¤Ë…"ÎS©@!H!’Æ°}DTrË1%¼÷àüø¹|â¿)Û­Tg•JSYÕJ×âjˆ §FóÔ+ï˜ÜyºÉŸ½ûpðNÞK4šç=íqMWZãä30YFH ÌsÁWãG^c¶•Pê®)˜•Ì@«!¾äcUvÐÄùÙ%Fw?¼ß¨-íO³BÖy¢¢Ùü.àŽ©Q1hkරê†ßLì ’fV\tF,éý£§ï½w}¾¶XÆ#–^m°"?_X}¿\ÝJ¶XsµN1YÇné2ånd° J(Q è `yããó <@9˜‰Êj2úµ¨ÁPHC˜Š£/á¶ú¿ZoQÞ›;Zeôðíòñ.¬ú€;0_ÿU àS |Õõò\s>­^CsO¬MCýQƒì‚XPµRM™3g¥SX?Ž¾Þn,„¬ º¡ÖX—Ósf´Rûâ+ç %à†á¢³‹[G«ÝúÉȼdîÝ©ªéYO‡E&« .57ú27§}Ã(É@U­ÏqÈ9Ãp~ö+ÿþßúÑWnÝ_t9çÚÇb¢­MKçêÔþ<|nÀÿÚ€ƒì `µ®ó©9[Õ‡w°ƒ}NöÐ37áuk@ f·7Mʈ\yLú|gyþ—ÿ£¿²±!G€•‡³›K(Ø µ©R7¢ DQd% QGrw"ðê9ŇOÖŒ'/¿üÉ„¥Â‚=0]©¨¦ÐD·Úf€t T&Ö–SO_XîÀðhß¼ûйpï+Ü—L+¼k½ŒŠÀ&ܾ»r)n ‚ÁSäâíϾ7nrát´Hs‘b1‡€Pë8¡8N~Æ•¹`®Ir±QA–¿ï±W*o‡Ó4Ö —‘,÷n‚Qn rBgm«rªµ^Ös«s0É ÈJÒcÞ0ðøøèÆÍ ²—éÉrYôqxüðW¾ùæÝßrûáÞ–'·RÊîÅë:+rMðœ·&òPtgJÍI`· ¹ºšòfq./•l”+qÉf²új¬N4úRnJk¤›™ëþÐͺÓî\2íˆûíOŽœàS4¼-!ÕR“ÚQ"uXvÁ”JÞj7³^»;¢áìV²›<+§Ww ri °“Õ1Ý}Æb#ä yç¼@.+© Ô9›¸½ÛlSèÐQÀ\ lÊ'ºD+ýÇT¸þÓ˜ÔkâäëzÕm”&e¹¢úö|îWî¾úÇæ3è ¡3Zö©ZYæ{vÉØ-•=Lñ9ò/í{ ª\ ˜ì`_êVs‚õÛ©ZÉàýÁöëdºüË^mÜÿ…—AvÐà ¢ç”pw¸ÿ#?ý‡ÒŠÎѳD£èfUŠ¼æ ”¥R—©º ¡ 3+h+ÔN·F˜»H . czr¶}þ…/õ•¯wœ(,…Þs "P 8«G4(Â1ðÏÈ90÷1KN{p¶þ̽‡¥oUdD®ÁdÌðqåßbgãÄݸ@‚»Ñ²§—^~aôÖ@RBfNLd(B¢šbÁ»iÓ.j_µ9猊þYþnV^qR÷· [Ûjþ ÌBÿívÞ1‰å—­ë…(Xò`­k[öB2Ð<«K">9;ÿÌgß¼÷ðÑ°Íd4Xϸ ­!¼òÜK†£À£U¿ô1wfôÑ£± X‚¶‘›¨ æÓ›€H0'áÊådˆÖI]-0ìÜʹž˜T5Ü?ÝÉc*#Y^O"ýWÖªÓ¥é½&v5ñ0ù¶v¤:…(£/B ç¶¼&å'îܱÝe•Vp5ý4HÙ²õG«"½rИ=Á‹Í¹šv«Ó ]OJ³°’š(ä4g0Ljt¼ì#l{6(9k;íêÒ)eª õr¦^zbB¥•3f¨C"WÉ-1Z¶GÇÇÙ6_ùeùÏþéou?-ny,úA¥¡ñlp/MRr͆ðʬ<ÓxÝK]÷òú?ØÁö>V€ƒ£|°ƒý:Ù>nçä‰Ïì™ëïŠQÃÝ‘+´e°“Kþ„gßü{¾íkË·œn6a¥ "rUa/ÀR@Œ} ¡‹¡ !šõ!Êa1$™e ÈÌ0³`…Í0&‰ë!Ž¼ýÂkß–ÙÚQŽK –>§^0U ˆ*À ™ƒ ÈÌs¯1ø°2œ|÷týé‡gn‹œƒH1;ÆöÓcæz)Á¨¬ô~F”¦H.3Xo·ž»•sªÏ Šl`~7Cjp¨¼’xì52x-«x匘4aÐ9¨ê±÷†ªßR/¤ªPR•K3¡ÖV¦]fw˜‰°`¨!y1Ð`)¿/öýÑãOÞ|ów çÉ2V¡ã¨Á±=Ïa7o¾˜u}ÌX½2”²ÆuÄÒ™ÒÆ<1{Èf »¥Â5.x£í׳/ì+ÏÎ!_õÒ[m˜wÃSlGj!éɺ´C¡ª¤¯Ä¼ÚZL®Êº‡Jy›^ëáQ½;w´€ ÕiÝéÎIJi°pì´‹ÛÅBPÎC¢jj0FsÕþ'YÛiï]·¤T¹·mªº¡€Ô÷ýzÌý2¦Í§æ~Ë· :¤!yöܲ'­ÞucSGˆíîØŸ¹Ç%»Ö ¸÷§ÑÇå›é`û·§¬†Bâ<âµ{o?¯v°ƒìÃÛ3—ÑÞ‚ e£ ]4¼ (6d¯rÕ¥<Ð錂-+³(˜šI`ê>ý©Ï ±©n­)z_õ \îØ@—¾Ë°—Ñ›â¼M9éêkŽ/d¶Õ\§¢¯†M1yó£qBž’Yíç0Qf¹I„ä~´\/ViÜ^<>Ïž ëóM¶êŽÖï|ËêÑ÷~Ã+Ï0ç'G1vq{´ˆ]×±“çó1Ÿ•¤Xy,"ͤTæ|Qen8EØ÷ðúÞiWXvi­‰]ÙR…¨¼E¼¹i{ƒÙ#Ô†Ví>`=“汶 Ê*ˆMê0/c¤sÊ-hïN»f­êÒ VÐ;sÊ…U–MY°R0¦4.ú~Ùõ¥cµ)ÔCÐ$ˆn Ókª`WQârGY‚¥Z:B–|Œ]täÒ*:çâšjÇr•¾W½£’ñz˜ëKADÎ ”££e¥ÓÍ'~ßþ§Ã⫶۱‹]Ê…å„kë³÷îW5|’K½ni\±KÛÌAÿîãÊïà`ÛY}È4¹b(p@ÿ;د—ÍBùWßÙ'N¿³F¶&`÷äÑ.ÖG›Ÿøsò"ºõžÇl¡÷ŒëBCìBìb!Ù…=¹ree1Ããèôh “uCÐ6»°<m·^xé,¾1¤BGg,è„•K0õ–Ó¼ÑÉÒÎ7»o1u#t¡ÀûçÃ;.LGLKCgb¶(† “j ˜%Ú ¡€©´¸ÆŽç"?çPÓ"’ƒ$‚¿ðâ )çùH–±«Ñõ¯Ä—g‘ä÷ʼnð²‹j£;ãÒ.{—%¦T Ú©±¾:¤µ2¸iÍHSvB¤—w¥`€2QHMPv8Ž»£>‡»oÞy럿õèíGëSy9jÁóík~ö ?û3ÿôŸ}êí>ÇW_ؽGþÖ»çŸyóÞ{Ÿ¹ŸÏµrÏ4³0’#LÙs%Ý·ÓJÕi§ß¢ßÂüîÖìBwÄî† YÝ f<ªÌeecí6œ°¬ºoè*ÔÞs?Øv+ y«—Uw±¦Šã]@(-£÷O{¶öï’k6h…í¨Ê§mH\-;b\CÞlSñCÕæ®Ì‹…:‡æ¾˜hN«mʬôÔ£ÃË°d=¾•¹ш(×hV>aDéÒVH×›ÚZöŠ„«ùµfFvÁ ð›á¿ûïÿÈé鯆.Ã6Fƒ’Ün\®øÌíçn!]òŒžaÏLˆþÉ|úö;Ø—ª=ãjv°_W{Jàÿï¹ÿ|«ðºG šðzÎYÃÚ.¾ç‡¾ÿ…O¼¼ÞžZp »{¿ìYhó’çœs•j,%¡­Hf4„Œ!+Ð…°Úf®‡þÖÍOÞ<ùdÒ‰¬«üy±‘(J ˜ 2a¸¥dRo¹ Y¾%â½Gï<8݉DÀMFzIÓ m´ì^WÄ©Ie2ÀBo¢8é.ÉüäæQ×w³Ž_â„ŧGÓ±gNÅÌ»˜<‡Ý˧̛&WeOb¨Æ蛧Q>y îO¾L+n®ò ýQá£4}²Ï–À˜å(ýƒ ž½³pku4>Y¿õKŸ^ß{“èTVNãR¶þô¯ü;?û¯®úͺ¿÷xñøÁØçØåÀl–Wãvñî»Û{ï JGÝ(ªÏ–ÄÞQ¥6Ùl\ÄVC±»øéÆn¸˜“ßP¯´ö¦mˆyV ;óÔPù[ul›21±š3°›“Q5‹‚±yÔ%*7ú"Dk,¯ÙJ}Š›þTÓäT/p×ýÀѦDv¡Ç4Œc‹ñO·ÏîÖÓÜ™¨{{eö—\”ˆlŽÈ€D¤Á-3€…@Zé©Q´€’e@áhÅA”@ecè(*¹<[èˆÓïþM«?ú_5ŽïY0åQ<‡Ý_;L­Ö ¦®ñ¯µie_ý:¼´®lp6;€§.…ƒ èÁöëmóùz*]‚˜ « Q–+Ì)ñ:cPàcôÛ_÷Ñoû‘ï8<±ÂÛɾˆ¡DóˆÒÃÇvŸß$ÀáB†1 ˜ÌCtab`X­Ž}òÆÍoÍþ‘QÇ™Ap) îhÿ˜ó&d9d@@2m ÛÀaaÉ Ïý'›w^Äx’³e:£Då!çècÀh–¨€Ö¥«‚£™p!÷ü¡´@FºXªŒb^~ù–ª(£U”©&em 0û^¤l!ãÝ4]'f‹xE\HÍQÑ„vÛÞœj ˆÝ†›ïÀS½€ÛVcl¥™ yòV“ ìËó:ýÚ/ýê½·Þ‰É,ž¡4ú¶Ã¸xpï§è›>yË´=;:º½½Ðöq²a©‹ÜIc6Ž-Ãòí·.?Ènäñ8‰`ia‹"¥*§¹ËýÌo^Õö ¬e l#ÖÓ”íÖ[…À„þµ›Ö+é’ÝBh¬¡zœ]‰¸f¯wQcQú]ÕÝ(ƒ¢y­£[Í$<ú?ðÖ©ŸbÝå«Wd-`^XþJžã& O®"ÀÕ’_Õ«.Í 0Q®|w½&ÐJß6„–A˜›¥€‘ȵø Ü- %Ëa ÖE.Q{MÅ AɻлgÌb`—aóú­¿üÓ¿íë>ºEÚx)ù¶Výt›7]zý>võ˜zú[WÉëþx°ƒ}‰Ù33;ØÁ~]möúa¯⟣BšÐ•™¹gWö¨³xñSþ_tzo± YÆÔuÁ= r— p´ÂÕ@vÖG‹°.tæÖÙÂsw6ë^yþöWwáÅQÁ#¥@Eå ØTÔ¥Il;E•ÚÃÂÇÀ<*"/L½ J²Å{Îß{t»ã”¨³è)™È@iÕŠú'к‘‚‘Š¢Ñþžu³êÔÁ“ Ì''‹Å"£¨ÄCÑ6ßÿÓˆï ü¾òÏ„2›f9 7 J©ry&Q£,-ñþ– ØÅU¨ €T {Î`= y§Á]#³”|Á.Žvç3ïÞëÝ~ä"G&4& ]Ôb‹çóŸýÑß¾ò³[éhñÂÙùòSw6ñÆ+›aˆ²,mÕóÖÅ©½ûÎÅùãˆt"_dÍe]¦¡â¥q›½ÝèQºì TÏfv¨‘ë4yGm°fŸÈÝ‘¯³êÙ©-¡Ýëæ® Ôþ–P½7å£.R¹&7Þw©j6“3°ÙÑç–ÜÝ>D“ôX\e3º»ÅÅv;nÇ­‘®\*êEU6!øÜÿQ)¿.ìê IÙFw$2Íà!@2æh…ò&QIJ¦ wÍk3—|@1´Âc ¹¹ƒÁ#9|úïÿ¤³wRΉÞVÄnž±ûžÚÍöÞ(íýûþ= ÷ßëêG<ƒlgà`ûõ°§?iæï\Æu{vå*HÙ´Bí¡!Ýçý?ü—~rXŽˆôœS-F9Èh9'Ì‹À¨7b°.Â#¢å€<ã0†ÌçŽo|Õ"~|Oh 3£rId›dtr¸Óxšz¢RÙ·!(h»ä¸ðDŒ«7ïž¿ûd ñØ­`yÏV¥G\(ÌXfðR3)f»‚%——ýh Tátdg*j†˜dBf[¯~ìåmÞ#Ä$E"©†™'x]!9äP‰{­ýu¯`¬R[4çOîÚÔëËÝÁROêjH·ÆêèMïv-n‚ÉXr7û Ce¹ 0è[fu–á){®OñÞ›ï¼÷ÙwÂ&ôZj„QÌIIð è–ÎÞü·î‡g÷ƒb2ŽÙ 3{îÑÅ7ßÝÝÔvËœHb ݓÇã{ïlÖ§!øIöèñWêR–®ÖÌ€X8*ÚÕL…¾ÓËJèšòíßáèÙÒÙc|av¼«‹g¢íüiÔœQ¸ï»œa„:ó® Q5Ï+í†A÷Ñ?öOvÊï´÷4sQ xêj¦d0ó„`ËqôóÍ–¼Þ ¨Zµ`•Vˆw‚I¡¸Ž%k+îr™9Ió±ÄØkˆÌÜ@™Á(£¢È‚…hŒŒ¶êzäi€g%ÐJ3bKŠÒÊòÅkG~áÏýŽ÷²rBn±Šc<7Îþ¯þõÂúk£û϶KžÃ¥}þÀÁ¾¤íàì`_p›#—«üYÀpÿÙÇý?óòåE XR’çäƒë¾å{¾þ£ßøeéA£ç‚s:¤ì9˜­è‹1v!„.v€ Á Ö ì]ËmêW'9>ù¨tììÈÎݲԪR§°êÌ'$GàNfO‹f£™“ŠìÞz÷Þ£M2[å …‡Qåto -|ïȬQuMãb•|"y‰£KDn­¾Q@2 ‹…ŽŸ;v$P¥Oqm»4Ç%õÕÁŸ!IÁ& !¢¨þOˆ¿ûÛߨ’¦¨ád²Ò8¦ák1ì6±j³_ÄÙðÔ\K§žŽ±4ßffÇ¡·Øy|r÷þ»Ÿý ·¹÷ÒÀ-3$ÑSÑbýÄ|ã׿±ˆ‰”óºël“¨øü½GÝz{Ì°ÈÈIi„#Äì®,d"-ÞKï½{¦qAïÝ%2»£ÁK" òsêlLÉ“ 1·«*¡š'5[=¸î÷ëí)QúV0£þïfV»“¨ŠK¤|Õuô\'º:œsßÒ;{aíx²ÜQ"+¸½`xf­sábsÂáŽ,wÁžê%N ;zRͺA²šhhp%˜(ó.o ÉÌ‹>/wµX‰.s@I}ˆ)oƒ±³(%š^ð|²<óƒ?òc_û½ßu>”ÔbhÞ8÷S:—F—ßyß<ËÕ/§GM®ß÷Ù_È;Ø—¨€ƒì n—žOódCš{qͽ 5ÃHØ^±E4 Œ´ òíÑÆ?~ïŸúÑÃy '`$’GÅFšCb°@£ÁiŽÞ­sZNFetOR7v¯¯n}ýV¯¬q¢Ð; w‡À*;#Ô‚D@VO7H t£m;­o-4˜„gãâ§ï?~°Md#ˆÜ-Œ6*‰vÒYp¼Æœ§AÜ»ÖßÀ&T+#¡L¹)d/¼ô\V2#ÝvîF«±ÄþÈ—×­:wÇ"×¥à.jQ2w;ÍÞlç¬Ùð4ðRÆ¡RhvŽ`ìEHP–Á¨œmÔM¿÷ðÞgßÜžž/¹ÈÉÝ$x0óä4 á°°½²xòã¿ë›°½ÈTJ[_?9âØ!¡äpÂsŸ¾·H)À<“°1»ˆ1'ÓؽûÖÙÃ~’rtÒeÙåS›ªIµh‚þó5±»¡•Ÿ-”ÿôÈìEm“wÑ<¸özvÖ\“ G `0…àFA0¢Ñ«æqìé~™NõÃBɉ$VŽ,C©(QýŒ]Yâè¾N£ËˆÈÒC ¸‡^¤KѨD¬””ã‹"BaÐÁa4(ƒL ‚²å­iˆ†^Ìa#l´âÂ!š)û²ë= ŒF!X=’Q<½[./NÿÙßþw~äöɽò“{* =o.)hÕÁ¼ôÕÇùÄ_;¤W×ÊSB*Ïù´ÙÁö%dà`û‚Û%ý?ìÅ#ë¯3pr¹«NAlaà¢vHî@ëîÏþÕŸ=Û^,c‘[éºPÐc¡ „‚…X³µÁQ´ "‰àê6cT¼}ãÖWÄÅ«CŽ° ·œXP/çDt ðÊq‘[i@r`HAc§±Wê,™R4=¾õÞãÇN®”aÞ¶.¢óˆøœ%^¯¿Fú§hø\P¤EC hí¨ÄÖ1kr-(e± xùÕç·ùœôzQ-p¹_&:yµ‚µUOt#íåŽ 4ŸjàÔ¸ÆÂÕäk.]h)À¤ç2O'­o•!šÁ…ä=z¬‡·õW‡³‹^±óà)u! y™R4€.ºE_Ñüì—þOü®£ÍÝEpúb¢{4‚¹Pï<î]gž¨rñK8ÙJƒXÉòÃÑúqxç³çÛu4?ÎÞE½3‹Þ@ró¨sg*˜h€š>ÎØú×Û3ÇWüi^ÚtZu»A%PŠ@(™ö¿ï29Д“©'6÷êê샧÷eÛKp%§„Z/ Âè”Y7 i;nˆÁCp0WýRy+`Àt·ôKiÁÆ*+jpfY’e§ÁÐË㸖R0t ¥,ºä…ê)=ç¾ïLŒ!”dW ÉG2ŽìÓ"~ö?úÔÒgº@ÉÔ‰›Ì|¢.#÷k`ù³aú”EzÚ>ÃøÌ—;Ø—œ€ƒì×Ãæ©çýØò¥ è,?ÝÐÞ…€šê¿PlŒ Ùó¶»õïÿc?Þ½tÛCBvO90À)·h] ±‘f¨¬(uJ!m‰Dv›Ü ¸ÝúoüÖà<ÐQ¶7kÅšX=f`ôÎÐ#ÉäÀn:½¥Ø C¢p·þí;§O.d8òRš¸ðç¼*ï×h"']–VOYC¼“¬gCÐUE½U×,˜I~ãöзÚâ&:¹‡+ækÕOi!| mŸ|>S«œüA³Ùol ] a09UÚ´èük~ïˆpq"ËÙ;ë,éÎ[o?¾{z&±’9{ŒÑr2ȑܺnyöÞŸø¾oùú—½o0¦ˆ„”Ʊ‹îž\4m‡íÍ›o|ê3´•LÊ$SmÌ«šf³»»?yðŽßn#ŸäÌÊþv ÐèKié”Ü®¥eIfNPKµ[¾%>&u¤«xízˆ¿¿Ê0÷nÃzô²–d(EóÎjsª¦Eº+I˜œöÑ{NüµjQïojw{“%%Q;ÐÜmá™Û!«Uˆ—º„êäZ«ßyæå6­~ŠCÌzcRb˜A™BÀRãrÜô>väÂ7JªšA4ȃIÉ@÷ì9…ª&3€eLéüÛ¾jùgþÈ7h|HYöTÓWemíÇöŸ1ûöŒ=ö¿,/Oö‡²i¯ƒ'p°/Q;8;د‡M’{èaoëÉ]hoÖ=0ýÖ4V$ÉSâxÁÓ}ãÇ~óïú­gÛõòh%åI»± !Ò‚™(ŠŸÑ $—Õ¯s߯^[½‘x22:ŒD(!sR…þbx©M”•¼ ÐÇcô1ø¸ Þ…D°\d Ýã[ï<8Û‚XÊi•tϦ„X‚Ï· rAŒU“}ÛÙ+ÖÝó²·ÏËfF“³Käo¼öúvÜ¢q˜¦‘ž&sP×ü¬–µ ÂF$íå22-¯a¸ þî>­ýA•mTehÑZg…ôäæZ0<ºsïþ{ïEgôà)‡¹[)¾ ¦$£•îVÉ2—¦ÓõÇWO~è·M7>é*!'R£8ºd&`³Ûls·xýÓo#,n»F!/ÝreµùËö Z¦µ½ûÖ£³Ç™Xy2Á@Ê}rÙŒ»aœ*öªi«—Ù&n/Â}Éf¾Y›“ë@go´CEó*0YD^…ÎÜË©jW»ÙDÍ\Í=ºÉ½üP6KRLEý,õ…œ$²\4wßn7eéµÒZ¢Š†U½xCí}±«¾­½ªYjЋ”hù)™ RïCô­Q=Jëà2ð(‰å9èò@šôzÐÌq£`1]¼õ~î{¿ùkÍ°ÍÙ-{4Öê|í¢—Æè)CvÉ¿j;±m¿ÿíú!l?Fs°ƒ}éÙÁ8ØÁ~=ìú'¯lñ”÷ÄæYжP•”4¦nðí§þòŸ|p~/®ÃàÁbg}ÇÅ*u 6§ e n–SÄÚHÜ°?ÅÉØ¿f·¾|è^ÚòX\ ž€ä•fMÒøE™0 €&GÀè‘ëÈ'/ÂÐw9h$G™»”3 þí÷¯3õ]Þâî¡S!á/ì•X–fO¤&Ü%MdúR“p]ôµ5¡$Ñ,»ÃܲÆÕq<¾±J¨‚–»OÜÿü+VMÃñšNÀÄo4ŸZcËxíø;MÑ)´r|ô©¿û7~ôØÞ‰=’²WÕË“°wÕ×Æ|"Ÿ:`O;懴Cà`_êvpv°/ ñº—×< ūϺ)¸5…4Q#ÊÓÓ¾ IÒ½¿ð?ý7ï?¹wt£HhÍÀàÊYŽ$ÂL’N&1y·õ¥Â Ë“ÇÅ« +·(X‘Ä ´¬\›zžl´ÀÅÉ4ZÚ.•W¦€™h脹C¾øì[÷‡!"/ä ƒ5FO þ7@5¸OÄ´ÈkkïÊF#gëÛ;0¹Ãcs!w¹aœ,¸üåWžFVøÞý¥ùÔ¥k[ªIÖ]Eèsvæº*!¿óYðoÌüÂc¨yE0r‘f¢©ƒç·ß9{ð°g°TqÖŠäbœÒ4óÀ‘Þaõ§ê÷ûW¾ÜÅq½ªxU-KÙ5$¹$w2:Ãàn¼û ·ðbÎ9€ÈU¹Ò%‚î^’…´ânH½Æã;o?¾Ÿ8®”™•^ÑÚÓ…¬ÃQ* ê­ÆF›smZ±Äì÷ùÀrÿ?<Ë¥žÏb¡ÐP¤Ü”V]¤'–^ >ïx^:È•Oy }„Z‹ÝwY¥¢/ ÐIƒËi]v\l.”¶6uAžš´À}Kg3D¨0µg¶Ö™^dD-;%˜±ó1¦<Ñ—QY·%AGè9[€PKŠ}Ø–´~õÅ'ãßþ=ë'oÆŽòŒÓ =­.íÿþ¿à}áø%óC~Û%t>äŽ;Ø¿$vpv°/ ]û,™ð脸.%T mÛŒ¬!=Ñ@cÈÙé‰þПüáî…#õt ¹`2 Áh0‰¢Ñ}tnd Ãq›ƒ½Ž>Wo8nA«àe²‘3ÊÉx µsÇmåÞ¹ÈV >±óÛ¶ªÞ4(£d©´ 4Iµå§wè•…_¢äC{-“œhÜ D%¯ÃH9§—^zQ’O½@ŸbŸ³Y(0U׿Ng«66¶üÃ~¤ÉŸÙ£ŠÌXC;ärÒ<—v ”2’wãÅú½7ßĘ{F¥„ÒÙIoõÓHÉI£“pÀ`éÆáyÿÌŸûƒß·×ËàѲM]£(Ò†!‹–rö§'Æœ8ú˜}q6¼t÷ѶJ’;‚÷l4øéÐôìBLcXú¸xpo{çs¥#¶ÎÁ…Ø6 Î.³Õ¼¸iö'=íJ­böÇÝ?O…æm°Û %}Òyz#r&§[~ªÀ©·›³kà襠öçK&Z±z= ›T]¤z·—pþùú,ÉL.³ ¨4ÿ‚'×hð«yMå u t3´”eòâÃï¯ÔœsR›-Qi¹½pä]py.ˇæH®-îÙ»Ðåm:‰G§ùÿæ|åùûɳC^Ńö†ëòÕãržWÂ#ï;ªÔãzʾÄÍ8ØÁþ%´ƒp°ƒ}>ötÜ!î=\te?`_ÔÜ/@#ÀL|3sG‚§Åf|!ýk?÷SÆ‹˜³Gë""2$y’eõK‰TŸ¹Rw»?ùHè^uÞȈYBðL¡6誧B€>)ÿ ËÁLƒER‘©;êŽ|ãÉÒ ã¢gòkìBfHÛ<ŽŸ¤ðKo?Ìá( 9‘ WÁ ­tr"øL‘*RoTú±×`kæØžoï Âí*YZ7«mÝ3 ÑÝ‚Iã+/¿8Žã ˆ°Äåç° ˆrî ÚŒµÏÕ´oKÚ´sׄæ*HÇä:Ôv=V)H U‰’Rî´M÷Þ~çìÁ£…uH€df„ØIÖTŸ*¡tC#52¤¥…Åù¯ý™üž¿tË|‹”Œ‚œ*É‚%]C— –«ûeI‚ ÊŸðàdne ÙAë³ Êê¸dàHž-rÌ[§ aØôo~æâñCÒO\}**EÕœæ½Áß©v¢ÕWL€6^WâÇÓ‘0r{,ΖTÛ¾IEÀà`F•DEÙ™òtÄë€aÃý—ßû0 ²ƒQÖNqw15SR…­\pÉ-`3¬sNFbŽ”€Ì»N°ZÅEp ¶ co)˜›…‘Å,Ê)Xù6:hp†å,…°ò! k*E *XÑ" ¹!8 iTî‚]äÄ(Û|êïüâíp7rQó>;gøYt ÿPÐüsð¾æñ¹í~°ƒý‹d—ÖÒÁ8ØÁ>{¿tÃ"|ê³lþÚþÍ#¨ý¶RJ²ñTÿÈÏüdêÕuåž='e€Þ¢ßÉÝ3ûÌE²;zÝŽ^Ïv’“ 1 ƒ¬61Í*!ˆ¢<·!D¦ 1äAÿÝ?üdžpÔ­˜ÔÑ2(ÂÄh‹³óô™·ïvÝJ#\È0xÑ&¤D9K/i Õ–L—C}s*wœÂ„»¿Œ]šzÌŒ8¢R³ÐÆ·£%ɹBÄñÉr±\x-oUuKvÿ ¦UüYØJ¾«Ü­g`¥ô¶1¶0Mç®Æ`˜í´ ÷ª•CÔx,éiìÀÞíñ{÷OïÝ_"ô H(f!W†RÕŽ¬þJm&¥Òe™óâÑw}tñ½ßü•½¶KSé XúAPb²×NREwÈ®¤Œ“+éÅ·ï-^H2'dÞÏ®Ô<¤è’Å(¢gv¸ñè^~ûÍGã&Kw£LrHuzÅæޡɕу²š]¹¼vÚLMËh†õ÷勇YïGÏG]WrIÖ´ÿKž‚Ó\Ís6óxÿåŒÎì–|êË˧>ßfÖü®üY¶K‘ÌÊ‘e¶›5P¸CŠ°v ]q˜È¢–1t}6ÒÆr,-\¹Ý¥ÍS­9:kêƒ.–æ«í†ãÖ”{b‘A¯AX¥¶L0ä<ŠÐˆ0<úÖOâÏÿôoÆx$”ÃÎý.îé°~7¤ï÷½ú…·ßà;ØÁþû·ƒp°ƒ}Îv kðiÏ­ '.™æ ¢<Ýçá>¬ÔÜzvçpóoý¾ïúÄw|í`[w¸8ŒÂ"„Þ³4$sÝÇ7Ýò¢{n›Á5œîþÙߥÊ`û«æ–RN>z'=o?ú³?yïìA\Â1f©ïz—ç”ä™!$aÄrä v/.Žßˆ‹W–b0E¥·&¾>i¯Ø„„ sBg]ê—~|z÷ì½ÏÞY?Úø…ìµ7"È(ÉMŒŒðEjž¬7ñ·¯úçÓ,žC£àÈj°ßé@)g(´„’ÛÐå?5åøKü€z Ó>h°|w˜Y@†ˆV±kíÏ -Nn—Zä63-d9;Ve•ú×ɩɇ½Ï¬Þ&˵N7Š’.7 ¥Ò7€Á¹==»ÿÎ[Únê8ŠÈ °)ö]v©’í• ìè†%Oüá?ü7ä·}üùÇ‹€°ËJiÚ0 E É]Eõ¢º |«÷…a8r†¬ 5ÝIy íV½Ñ¬Ð½*Œ7¸;’u8Ïoþêã³S<Ê…FºOeàBiÚЦm>*vÉöVÏüÝY?:­ iœ>Qª–ùÚUý^>Òþ‡ì¹WÒûÎÁµVÚ»Y‹Ï£ªz…ÒÌZœ<œF’9ú.®ÏŸ@)\¹dÛw 4’â—°á©CGÓEîr°LórÃ>}eMN+A8SR’•¢šØÙjX+%ºx @Ðܦ҅@cÊÙÐisúÏþîßþÃÏ-ï,;e%+‚±sž58×؇‚æŸ[ ÿþ?Ø—¢í9‡Ep°ƒ}Nöô¤v1]ÄG-µ‘ÀLó²<. @ÌïãñŸùwþÎpæ]”CY\YÙá"m·Ý‘/^ ËO,úšžsï̘}¼”Åzéà5aÝZHIÉ3ˆòä_àxûÄÞúÔÃ'w´ð›y=¾p+¾t{%Û žÉ¡àNÏC€VøÛo_¬ºó&„hʉAî¹Æv+GÅ‹Œi‹†DSiñ¶‹øN^ÁÌ)à®ftÄj°YS¸¿0TKé„l’YlºúM‡Gp—e^zñy4X'£¥ˆYËÚ¦+T/I{µævE¹³6c­añäÄ”™¹g¸w†óõƒ;w6O±£Áe¡è3ÑUv‘Й95õ®b`é •Ü“åž]^ê÷}ëíßöÕ¯úz F­}×S0 8B·r×÷5ÀÒçÕÈ­çÐÙ¨õ m7>û g@ær ì¨)¥<´NIû½Î'Ý”˜2ǤlðÀî~~X{¿ïðƒì_:Ûs9°ƒì fóbϽxvC¡åEƒ§†4Ä(ýçä~ìOýøêöј·„)+CHNWH9$­Ð¿Wéú×a·FïrÑúv˜+½£ò-ê3¸á¼„½3 aa«÷Þºw÷ûÜÚ2÷Û³³Wž¿ñú‹/iIäò3 PKÚêÁƒôö;gÐñf{$‹±s¯apS“ªMH¡JU(ų…QßucróîOýþïê†óÞ#È d®‡•ã˜1@!¥VùÛ`·Yá‚1ÀRN!R¦ÁÈ[N êX"þ ÈÕèué¢UÇ`òÌPô†Ä€œÝò Ûï|æüñÝÑpâɼÐpj‡ˆR¡ÁFÖš/¦ÊŠá<¯T–««júð²ÍôKõþàù¨ï)¯.™0C¤Mi´´Ã›-çK¿^ýÙγWûŒÆê©ØSÕ ¦›¨$!hE£U¢+È{Ø‚ÖÓ:2Š4 y7çÛõzmÝb3»@Êà’‚r7ö7,áÂÌ;u]Š¸€m²Y6–j€:eàeÔÑÝC°êg2œè#Ž†­£¥ldtÙ ``P7}¿Z¿÷;žûÉþ²¼yd¢<[ë.ØŠì/ êõ#8òÍ?'l÷);Ø—(@;Øç`Ï| Í¡?vÓSOhqÜ A•Gc¥B/‘Éìë¸ùèw~Å7ÿîßúh½±ÀœG˜É5Œ9Ë’–¹¿£×mù†p\¡ˆ|ñ·ÔÂÄ)à%ÆIw‡+ÐͽGŸà×þùÝáœWÈ6ðü¹W—/¼vc£syfç±ÏèžvT†‰÷ß^7RZC„‰taý°{òñÏ®ûJs’gs¬, 8c—úˆ…ÄLOÁs-ÖW!™•lÕtÛÒr’Ë:j5Ža»Å¸Eß-s-vŒ1xŽB_<¾ÿ·þÚï[Ÿ}ÖbÈ9™ÁÚ¬Ö|^‘Ýäí 6¯üòaí}qÍÕ€ÍçÃ#:ØÁþ…±è`ûÂÙ \fazÝüì½_ù7XNÆs;ÿ?ôýûú/ü"Ä (edt™Ë°|~yüšu·=ˆ7+ÇsÀ‚è€ 5.Õ°  ¤+$.´xðÞ“{o? ~óBiè{¦<ܼuô‘7^Ûç´L‡g' 1vË;wßyïqg'9å™2:I ˆÈ¡ò&ú6úÐi\(uô…¥SAóf^A Ájø‚[0¢vÞEtM³²?䨌â & °]0¸JÛ“€ÑlêÈÛ`;&™Qȯ½úŠ{2ªA®ŠYÚ‡ÑÞüŠ¦2:M=À,Rƒ•È`TòÖ9ß½÷äÞ½à蔼P¯ëþJ¯”¿Nçk…ú„ÖA«ô‹-#¦8òùüæÏüà÷¼²âÂsåM½ž(ÐP8ßå-¬Çœ³›M¸§ºX%»b¥J×Ýhbp"ùâþ“¸s.îYsN€¦v!»„—(W6ˆ@Áå¥3Ü9.ì¹'ü­O?7=}á¨` ªš˜å TëC&FNIµ”ÿ®‡y•§Ó§LZTbûŽë?O-ÔàË (8¶w<±•¹ïN‘¥$&—H¿‚£“–!,,ô ‚IV[Y—9š<×Ꙣ!¸‹ˆàP¦ä¶ «'w„néƒ[’ˆ,¸D÷~—N#B@*‚S@äî½Goß;59ˆ,–ærÛYÈDÕ¢(BCXä>¦ŽSßôCR ÕתÖÂ"PÊ¡QÉð° ±(–@K„ZTÔª|i†:µt¥eÑñ$£ú;À²cÖ/¬ÓT\!²äêsWsŒDËŸ(Y ˜)F“ˆ€fIÐËS"*xI2¨‚Ç iýèüþíÛÜæ!zs 6·Ðâ*½”ÒÊ\ýÐxO³ÛXŠ2 €80Z$týÅãýžï¼9èz4Ÿ”¬9…F›GSÇ\½äœÑ Šp iâ7âS•©¡„Hˆ†(åÊ[÷é8fÐ$PfH„S"8`@ s“¶ÜK3ŠÒ©Ù”!žcR1ÃÕ;o¬ïßžb<v95ˆ5r ¸»\蟽•'¬:‰m¦ G…½é¼bw‘èå+Oì‹‚w³KQË{Û…Ž¶€Š½Ê 2¨$0•þ^ŒRx\ÁF‘—ËNJð,,)ÖÖÂL§Íx4>¼u;õC³˜P\(âèÅ$5Žn£œ‡åP„`@ê·ÐÓ±ß2€«Aa*õAz]ñƒ®‚ +­cG‚¢fÝDÉaãÈi„I/Ú1'„ ÝðøÞ—þƒ¿ÿ§?|íQ'¹Þäæ©ÛMÎ" ò ¾ ©ƒùö½Gÿ{û–°½°·½ýÎÛ" ¸(ö]¼QŸñ4ÕfÏnñ ?þ›ÿàoß;{¤&„n!ƒö׎?ô:¸"]b’ ʨŠ54*¢R^éÀÄH'ªá)›mûۯݻ÷æƒ!Žuì‘CdÒäcl®Ü8|å/®/NµC\ ¨)©éàðÞÃÓ»wOLIpZC;2³4H2D`„Pºø$>©geîÂ;FbÃ@+áÑ™áQ9ðÊ /h²rÉ›Œ‘ P`dnôKit|0J¡dSé)ñóÒï@fáA¡_©¢@”À;Åo<…¢u¦vþBi”VUÛ„²t.ˆ–¼GQ‹Y}êÄ°ÉnßÙžž®Ð› Á,"R*‚‰`†I*€«„¸¬ÿÑ‚W£2C a‘iÓtï§~Ïsü‡?¶/z¸‰+()•Ò˜E©Áɤ~fë0¨jQéKuEÌË•å´‚:EZOGÏ»Ì!ÌÐá Ý•$Lum¥xÚ€¨(Xú0D .I£¯ôêtÑÝzíÁÙ£I10[P!ÖŠ}—tY KªO+@Yj‰¶ @'bs¹ø¸¿ŒøŽ¤\HP=Ëf§d—ï+ŽIés]:a(™€NЉ¬Ôz‘h]@Æ,lÄÅ~¥ñê-¢&ŠBER³”Ä€’Ã¥—‹ÍÅÕ£ãGwï¤~È£‹*%„ˆì aî¶ϧQÏ=²c×{7Œ²ŽžNZÆ°R/”îàÁ0M$Q„Ÿ(%;8€iœ|»å¸Õ·´5çÒHQ•¥µ€Î-ðÚ2…f†è;ºJ{ð-/NÌnÅ<¥œ×ªöë;_öh§‹ºK®Ã„vŠÁl0íUSɧ4L_2[Q“hsÚjñ}ÕÓ)r«¶¶ÖJ•¨¹“ºÞ\Þóvßƨ†Eiñ Í0÷4˜º›ÎN¨Â¨.ûfÐ[µkµŒØVRÌLMÇÑ{;´X}þs¯?xûì(cM:S汸™Îo>wåC/¿|qqb‰álÓT6¬ß~ûñ·©dWQ¡‡lr¢;¾ÀáQµë+RA&zcÇ1Å6Å”è ì˜ èà ¡€¶n^%Ì)•/„ÙmÒ¦SØó%^=ŸE&¢ s"Ð&AZrÁJ× 2è¦B 7o\3+î˜ï_ÉlÌ,ô‘mÒþªªBTGÏ´y|úö›o&מFÑE¡â ÑZh •á?WÐÊbµÈ|“&I% ¦ T‰ÉÅÙþÖÏþ¾»"÷âZ¦à~5ˆBZÿeŽÔ:O¾ÝNÅÑÒ¢ò—Š¾§K­@õåBq"xíÍûv „¨ Ý(Zô*‹ÊìP ©"RÔ>QÁ,a„ÕYp˜ˆIž¨qÐãúÝ·ÎîÜ>•©Gtî"b5E$­Ž†ÍÝBì’ó%¶«Ã&€ÎÔ„²ëÏÐœu©Ê¼OFßk›å®Ñî°ÛI»Ú@TuO a¢ItÐÔ‰ZyÜ–ºVŒ(ÅuÒ~@©ÉF[ø4X[ƒ:e@(&É#ÐÛz³½q幇oÞJý£—„’PÅaLçG7‡Œ m¢Lª’rwàGýÅjz”m’©ÜXÚ He«ž‰²€!µRe'ž+¦)‚bv±‰4mܤ?;{ëïý­?ü½a'®Ea"Ší2I:OÀïˆ=âïAÿÞ¾mŸØÛÞÞÅdñs~Ágl‚KO–¹ÔR´·fúkSgÕ° 'ÉQ77?qãÏýò/Þ>9Ám³õÝó7¿m%× +PéPŸÅEÙ¥ÅÍUfhD§‹FRQR#tWß¼uö[Ÿ¿«¸Öå«\#u‰cÞè!Nóƒ>x㹟;]ŸZæPRàÉ$¶®õö½ÛÏDÝ]ÁÓ² î”T>[E¯¡RR3{Z`†^§.¶o:äòO€ +“I« gEÙ•Ì^¢ø ’R”T¨te”^R¢Z¢ûªÍÿ(þƒG!4U²I x’¤¢w„˜fN/è¥Ñ·ØAñYQ¥†µ¢±2¿QôRˆè%ÅvºëÎx²>”AFQì\,”óÊÖ‚Ö]ø³˜P[YGŒžéSÇFÇÖNÇG?ýÉçÿà÷¼œ¦L£U÷G„Z}Q¨4O@„R™6¥é6ç‹õf3æ¤HRTVI‹ð²dUë4¥‡]ä+NÕÙe"dj>Š*Í0gWÔ5/„KÖ£Ì Jj ÖžNU>ŽÑÛlV·ß8}xw#±Š¬¤ˆZeï—ëK(mç´HÕÀa4•4 $†¤ c×Y¡Æõwnzm F<ìŸéGZÖ@½~çŒC+7‘½è ºR[‰öP%5 ¬ó^”[Që¹µö¬†séB[ìUvv‘רNÀË:Ñ’z„ÎÔõgggׯ\¿ÿú©|"Ä b쑵3‰˜Âxtý`’mXÎ:e£ÒÌuÈ?ÞÆv4ˆ@Šø(TBé¤ ±êÅÕÜšA•J Q¸ç~è#;Ü×#Eu}úÙÿüýK+»­6å˜T-ò¢³®îâ^ú ¶w‚øÍõzöϽííýl_ÁØ{Ä{ÛÛSöÔ³ái7aŽ>û¹Só5¬\…yœž#ëxjç¿ô?ú·în.|åøh=žj¨î.‚ÎÃÑ•7oß»ÿð 2x)ËtZ¡/×ÀéŒNDžA¬ÞqµEP7 C$ñ^}ð­æD6æïÄ;D LÕ‰(üèÒhJDg¦Q€D´TÌŠ 6©šg¦f¸KJ¨j’4´ÂZUÃûÁŽJùÔBU–4±ˆ(0xæÿ«s$5 <º{ïôÞés‡X4Ý“Ys¾85lT‘JT!—Õâ‚åÿÀR‰ 'ï$¤CVrõ¼¿ö¯ÿÔï=’‹“"ƒ¬T*]„“›ü+Ä +;4™r@% cÎëíf;‹`Az°jƒ¶\Gñ1BµÀÕ»u3]{–öe¢ ”a…+BñÊœ"Y”ª„ª(zŸÎ\¸ì*¦M„4ÂPI1 rêx<¥[¯=º8͆ÁKV¦¡|èFÛ×2„E‘z!-Y?¨ÕêÌksƒ]¬¡æÕJQŠ(‰¢I›=§ÁÎÎÏo\»ùøÖíÔw>9DË%Ñçƒ]¶µ§-$C"‰¦ž8N}ØZïI²Â€* 8#A„˜¢ªÍk) ÎDÀ”´ —ÈŒ¬ˆõQÿÖÿô?øSyzM“E„êÜç‹šçß øýN{|:ï°Ïìí[ÅöÀö¶·§í« Í Ù=›« à3öT*uÚÚ1©€ éãD·è/ü‚|ôÛ©†_yñ ¿IIžl„x +©-²Þ(1Fƒ#2èPQQdÕr~ñ ÷ÞøÒ#¯uÓá4š¥¾föQ:ßlÏ>úѧÁ2³ª1#©³€c¶aõ…×ßzûѹ¡§ÓâÔZl¿`Bìà [±-g£B#5¢f„d‚èƒOƒoû¼|˜‡È="Ýšf}_ña Bè¥ú¸PMvÌ¡j¬e¬‘û`ÀYTˆÒ dÀÐüÒË7³OgÖúY r0T•DxTüˆ³£žÞôðÎÛ:q^2Ì*$f_¥å B¨Ðù|fuÌå…#%µ}2UÄ¢S‘~!q˜®Åãßü+?õ]ºJߺ «¨E¾Æþ±üE-u‡`Qþ$´v¥íDmr^¬·Ù#×êN™Ý—6Û$ éÊ3=ìú­ûæ~ ‘<~ôÖí>õ19,˜¼©19ÄcÈÃä¶ )-«¹fóðð|‡ÐÇÒÇ€2nÜêë3ˆ1!ªƒR/Ò²¦ƒ qNUÍ,A”ÉÆñáOýÞþÒÏ}7·@ wÖvÔs±w÷3ož_£-÷øôûK^Ð>°·oÛ×ìmoOÛŒå¿zkÏÂúú™û˜;IE^9»Ç´æxõÛ>üògœäÕÁÍ+Wžëôjybç„¢"jG ŠßSKÇ«‚¨†ÔR ]òîî­¿ý™/ù¶p¤“Øu" %r¿ÒiºøŽ~[oæ1½TÐ ;88~ýµ[''gÉúfÔ ÚZÖ{2Uø¿ˆlÈüH­Ña ¨WI4dO *¢±ómŠÑè&щ§ª&DE©B-*¹¨‚ £åÚ(ÿ€R9ЪaËIÌ$ £CjÂÍ®9·j©Ä¨GEUÔ`ëéþ­ÛÜŒ’z…€Åo¨|Ê’Ùg@Mk ú)mép÷‡v8åMñ0 5PÅd•/nÿ¡ï;ú¹ý„­Ïz‘Ò‡µ®¿æ˜,^+`¨êA*h öWj|ˆ@•bcŽívÊAV^MÁ¾e~¥vÈ‘ÝY¾rÿl5ÅqH'pmBI…àÝI"ÜTUîT‹P!U¯,‚îÌ™^rK§F)ljdhvqå­×>¸sa<öÁ*†T=ˆBÔ ´NeÆ*™I€!µÙ^‹¼Ï‹w—,š‰6h£&K ®A#Ôi„=dPíE‹¤O͈ԡ*©ÆÂ¥+Ii·ŠùUûo† »ßÛg9;Œ2=‡D©/G!b" ëºÍf{õðÚÉí;©3ŽYEHRKž #†|p½cÚFÚºn!žLÕµÏÝ;Y‡?ÚØ{¡ŠÐl™—“VÖÁêã³2/$E b9;‘@›N^ý÷ÿ‡?û£ú–¥‡´ iµ¨c»…î€È¥_¾zãS¿Î_ ïºåÞöö»ÛžyÙì)@{ÛÛ»ÛWzÞ<뙲«÷•gmÖ˜AŠ *¹)vŠ2©(ª@&ªb¢:f7í‡o½ñè3¿þ¥³[ãu¹iÛΠfTAmS—8mϾ㠆ÓŠ8Œ’”Iá#5 _|í­G§EO‡š™rüVIšÂoh5X‹a`Õ#€Ð ÄYáÍU(´x!aÊN£|ÓŸâ8pd4z¡)¬ Hyn×~I…g2as7Ö¥€²¨fŠ¨Öи”ð°c ”©(ò,Pa¿qóº¨!ªEGHTÜ¢…´ÓkcÜ»s÷ìá£C;°I%Z×.QVXÆEífû”Ù‹šÕÅ’™Ë=‰ ¡¡ÈÒ™8²"L®‹~¯ýµ?ö/é˜Í³2¬ ÉÌû—¹\Á±Ú 4´ÁÍ¢'š  ,y€Ò7 ÙN¾ÍÙ£ô’B òBCXŠa×îœØz<ÖÜ—ŒŽÀ‚ QR aJƒÌ. `¡"Á¢ï_] -¸–nn Bê"!ª¤3º«ù"}ù ÷ÎF'Wˆ!X:CTý"‘2³ë+cH©õCS¶ºáë?q×%\“6lÅŞƜ$8$Y%L’Bè,ÿÀ(+°´ ¦Œ[%ýì’)Åïš1oU¡ ¦² ¸ý‹ûHÉ@Dñ{ª¿ÝÖËÂêÇ“­6›+WOÞ¼gz€ “$%5TB’œ"88>sX¸z¶ –©{`†ÇÙŽ}î-†m8Mˆ% ˆ¨gFÂ=L¤tžEPjjǺq2Ä*…žÝúÌòþb/o«‰#¥ žsr¥¹OϘžß ½´Ý.Â}`oïÛgö¶·¥ÉS?¿¾Î|•eUaKý›H0¿b7V\!#u¥µOQ¢ĹýîO|"O[K@8OYL©^hp »q¸ž\Gh€%$40ɘpÐoºÍ½s½Ð£¸"£C ¥Wª›D Dhi×GI©£xÈdÚwiÙ%õÑå¯=úŸü½Ÿ/n+C©¹J ^=4^ZÅËUýõÄ'Ÿ™ xzƒ}toïgÛgö¶·¥})f.^ÍvmÙýO% ½ZD2yšòwþìüöŸø±ÑRêU5ÇÄ Qˆ„$È šÈ$ͦtxø÷N(™¯¾úú¯þêoÜyãñ‘<7lìE-,&hqÀ§èT¶~&?ñ±]l.RgôÂ|M}ÊÒ_øò›§£ …»™À)*Qå[*·ª!müBJ*.Bƒ8d„öY9°@çb¡F¨VEœ*ÙˆÖAq"Sbig&©imÓŽyA¶o,j5;Y£êüTÍI‘ƽ¨¤ JD’3ÓážSg©ð¾E#Š‚LîœÊ ›Ò1*»ÒOLÕ?œ›óŠ€TՈЧjßI Ia/i"­Òœd)ä@bEG´×C Þ½õxu,×o\rTc¦'ÊÁ` W–²VEüv/Îê|Îejki@ &’RC!‚¢Ú¿Њ۹ˆîsÉï—]è©;Å%L¿øû\<ûÏ+pÞEyRrSµV%C¤ðLK›p³í8^9¸rzûΕ¼èÛQ:!CÅD „¦ÃçWë·§Þ÷ljÅOS…ȱ ]iÿøGvÔ­nfdµ !ÔÊU-¥ÜZ ÅÍ™Q(^¦ ·ÛƒáðÁƒÏý¯þgþÏüÅÿìáôA‰k3ÙoªîT]š—áë N>åƒ=ÉÿÙ?÷ö¾²gbyåÛ¿k—…|Ö5±÷ˆ÷ö-`ß eþŽ×Ìî]’bQdÐs6}”ÿòü|äƒ6h /ÑIS •(\ I€åP~z¼=}ðøþý‡gçkÏ1¤£+×-z1Š†¨Vîx ’èV¾Ùž|à¹çn\½šó¨½0! ´dᢩ{ýö‡gaÕow̸Dæ \éP¸Ö Œ”ŠD”^…È>cßB®¡60Ü8/(ݦ Þ)»%£`hÊ!!ŠóÄ·àªP ªÅix˜Ù›¿Â˜ã¯$„Bë) g²ÜF¸C´ оüúm߈yzxçrî`l% á&ô˜‘wq'ÊX9wñm ¡lQ-e»µ­ ¸¨á{Q&BÖKð l†|0u7ÖŸþG?ÿÃßóëÃxÚi6Q¨Â¦-äÏæ …ÔR.§ÄaÝÿìÿúÙú[§’ÀT«NeIß4Ê9ôª£J:ȾïLL$•ºî€(„<øî—ò!ßì`tIYTP 8víJÍÙ…ÉëQ‹B"‡–ü Bš²¿° '•dSU%MܦÃãÕÕ›+èZ4z÷Ã^VÅc ÁrîðâŸEÔÚƒòõ !ÃT¥hÊV9Õ¦±SÎ,•àÒè>Õ÷ÔÂzòï~[<\«S|ùÑûL€M÷öRl¢Ñ{ª$n½‚.íEÚÖï Šªo§aÕ­ÇÍ•^ˆÈH „©JÀ)$5åÃñÁ$9͇è (Kc`.Æíýñ¢¿z,½‡ÝÐ%à‘)“k¦æ:£¸;‚šî(õDˆMØväíÇWÿÒ_ý¿Á>˜uE5ÖÈkÑ“´Ú‰gØ×Ö—÷ëwÚ‰|#¾ho{ûlÜÅ'wËxŸØÛÞðì§ö»Û3Ï@ÿlÂâ3º-¸áLiº»~ôóço}ä#ÓàÉ:@ £erDöMè õâ|ûàôìÁãÍÙÃuœoû°¤]/GýÁ0¤Ö€<-Ü%™$@²¯Vi;ž¾òâó×rl¥CöL†)G®¼öæ­§ªCŸŠ–à)¸ ü×»I…”%¤_6ÞÅCgÈUÐö˜_  ÙGÝëÜ'•mŸQéª*ƒÎP#ÕÕLÄ)[F´(j´™€ZÓQ âI¢¹†j8ªc*½Ž#çWn¾ø¹ßüÒÅÅØ!©v”dþ)Ô€šµìBEóˆ ký\ç°ü 9ömĤ’ Ê¢KTƒ·¤PT]òÛê÷¿ò¾IçžÈ%ÙÓv¾CÿRˆø5üOƒ°òÅ‹@¾¨·.U—bÿtWšz‘^%íUãè"ì’$¨ÝYQ’Y®ùþƒï|ñ¦ûc‘mgæRØP¥ùq|ÏeÙÅZ€V „ftÙ9œ²ó¡@-ÇXæ MÕ~}2n7ž{éàp°¡“Α !Òü3VOËÊ5Ûxæ"HjV¥u‹Pg -aá,µÊQ¬Ùž'¡ds˜Ÿºcìêeò/ÑÿüAVúR-7P£hÑj[êh«8GMz”ˆ{XgÓ6iØM쎎^{óîý“µjîj…ESd5!(\Ý(!Z0}ÆïøÀefÚ3Ñ@\ÍT,ÈFÉ™G¶xKî>ÐüAiì[·@ˆ;ú¾§fÔ_EiA%.WĆK@H‰ÄÂÝäÉûÕàS0k—»Oýw¿i1êÒq×c ¥5¸ÄÍ àµÐoÅŸ "> Æå_kȹ À´i¨ðªðc‡þÄýÑ<^t-T<áB5ÊÄ|2'C Ô3ÐÛQ„7m×:ÄXdyvèufaÕă9È‹õªï‡¡SBÅýév}ÿ,¿p¸Z¥F0¥‰òÒX sVOb’ƒ0Y|qT†Mu_ØnZŠ)`¢Ù¨÷¿t›W_”K!Ï*¸·9ÿ#¿øKqóË¿}ëâ<Ÿ>Z »¡¿v¬×R'pLNªHÿ]ê9$𕫦)ÆdJBC  ºI:…DÍÁñÛ?ü§I:!© ]éÇ+DÀlxûþûo?LÝáän&ô0Ývñm¶ÚÐöÙóÖÂçRø»n[ãþ‹'fÌXy§¬;a ±ÎêIÂæ̼‹¥kñdÌ"â„@@ŒÌ 5­‘KqCp}+[Bs„tJ"&=è>õ+¿é[=Òë~Á®3÷QL³3)(ZÚ»Vÿh–’iQì†ù¹ˆ*cwJ êŽ³X^R7$²Ö Ú­òô=76?÷CâJ ¦¬­«PÛ•Ë‹u7gå•ÎãÔ”ãt,+Jw…xT+lxT¥Dêóªš#6žMt%K„ -"Š¶ì" ƒ¥ÍÉzèW©šgôU-0§ÃÞo?z¼ž¦è»ÃirWBžMÕ³]M7™×c@ï?¸ØÄÖ:Èj¼zõPVoÿØ÷~ÏÿCþüÎÈÎŒF¥‰{¨*[ÓƒK3°CàO\DßÛ]’õ>sÉØÛÞÞ¶¯ØÛ·¦½·¨ÿ|óÇS›/ÕKôÆWi$“«ê”³Fl;=úöïyñ»~â¿úÿ~ñ ×$é8½¤ìÂ…ÔLW (é’‘ÕЙnÖ¯]»rýø¥R£L¨¨X …»–^¢ ÀŒ‚ÍÐËË/¾Ó„$Î0MîY*)Œ€vݽ‡§·ï?²´ÊÙ­æPÓˆB‡XÔï¶àè2¾<ë¹´óåÜ lVa#”ÄÜkµ†õëè6¨Ï èÒ×ÅÿvX§å%Ô¡¯®@j ¯±\j·ä ë PMIÄE¢Q¥"àxÐ:Í +Ÿø+ÿôÓ‡éØ"E–®Œ×PXkÚªK4ÝFEŸÆ ‹W™õ.¹s±,°F+-D©a}Ý üö/ÿÜï½ÓغÒͺË—Ž‚¨å©c³5oSݲh³ôsåòë ½Dj±iˆ”À|£*F¡ª9ƒâë³³„ôù ^;Ôïºvc…IP g‰€V~i?Ïþøàí_ûGï~õ×ÿ··ÏŽ'—¤50+À^M.~.Gâw*Œù´?¶wöö»Þ¾B#°½íí}gïZ{âïÅÞùi2Çùv*~sHÀ\hZk‰Bý÷“áàGþô_ýÒ‹ë7^\u7:»PO‰`¨¨®‚NÔ§-9¾òò+Ï?G÷)<<‡VÒ}”–;FщöIÓñªÿÀóÏÅ´‘PQϹ³¤¢$ª©{ðøâ­»÷ }vˆ =’ÙÌÄÞaó]®4ÒÃÅ?j”˜•,ð¬#ËhC'u<šA¶]°Å•Ÿ|ˆ?^­ÇQ¾bw\h^Qj¥kù ®&Cžàny2Ͻ§÷ *”Þ’O>àèäíóßøÕÏw×°N€hÏUJ(‚l‘\4ßðÖˆ´¹¿žÛ—ü‚E¾ ;•¢p1¡IÇauþÚ/ýÑïþÄu¦Í™Å¨p…WaŸÚŒ¹ kTÝÖEYrõÚvÓÕ¤¹[U=¦AÊ¢ËTæ¢P½±ØQTu€EÕ¢b Ý]DÂ#¦¼>=W0Àè¯ÿÊo?Úàň¡c¤È‰T÷TweÝ‚¡ÌFWw£‹çD$"ìD$åŸF*ÃeíN­U Հ8K79 Š’“ÛhWÓs¿ý«_êýŠåÕäf3¨ªðzɲ*á´…Ö†v§°¹[ƒOÍvà:ñ—ÐûHU{]~—áþÓè-5QHdœ5ŠfÔ»óÞXU\k&ª9ƒµÞžÐ⨢D$`dFo+? ¼Uíb 3%C©F• š¸Mc·9|îŠËVz/MÆ¢0¥Áib1FJ’qÛ¼ðÂñµ«+3GŒ`h"jUU,I(S¥t£¿r-݈Çñê¯ýÿþÃÿþŸòƒ^É0«õÞ5û´¶~ð›O½ØÛÞÞ'¶wöö-b‹Gô»?=xyówxØ”‡nýI°ñ{Ëß+¦8Rƒµ‘•¾e÷{~òçÇîZ:ê7y‚N&aâÔŒ`âäîÎ6ëí£ëׯ¾ðÜ ÉÒ–[$Mfª* M&„Ý }R‡œð…ç¯yž Ì6Iðè œ&"Œ¢O.Þ¼ý¶Ø.b"„B#¼Rº"/çs§×ß•!VP»#éÖL}øÇÜ -H.ê ²ÈÖÜHÛ[s£HF•Y/{*ß9ÿàb£Š*î¡Àg(†2b9SeöžÕÝ|Jž;ÆÝDÌ$Më|µ»ù¥Ï¾ñåÏݾ6´~5pN…X.hB“ÐÎ#`a ãÙö…£—?÷+_:;Ê•È•Ïß¼Q€qéâ_¾äÏ°Ãò¡+HY@ IHÂHP!µ *ë(¦¤Y¹=>8|áù›Ûq$RTíéE ^’M™Héä|óæ­;–VÙ) š¨P´°°UN¬r7sUhå]\š;é›Å´rp.ØU ZX>•ÓÚE`±rÖ¯aÒEµo9¼]X{ö´DPZ #Ú P@:M-r ÐG¶)Ë”±|L>¦ãtã×þ›OoóH¯çµ¤^‹$d( ÔÂa,ÐØîHv|Ž¿øˆxb)ÍXqçYUê¹U/_LÆ?ø³àۆͩN“ÑU\€û´EL Àwߧ¢ì?¢Ÿ(œ”F Ä\Ö]t9ËÔPd:J½°ÔŸ(b<séÊóyÜl×Ä ±.„ÙÓÛãÑoÞòQ¯d± =Gó42¤µ†&Á œðvñÌZöõJªk†»uXG0X–­„(R‰ƒ Ô$ew ( ‰.u›Ç›?øèõõ럽uhWÃ5Uç¦mRœ%RAüöòÝ­Q»–ó»;B6Ìy!vŽm»ä°¾­p¢Ê×ê’“·ÛyÙ¬ªäÔy­×Z+Ó¿ì-ÔþzЖçcH8}°~{ráëQ“N‘¡ ¢´ @JN£Ûfu}ˆ4¢ Z½5ˆ¨ˆ²¨†(ÕD’8°îûéæµÕ«+úEø”`ˆÈ9›„—NÙÁ,™tÝÁ0žýܾò?p¬r$ÝkÀùäæËéoäϼà¾*{:ê/‹ŸO|×{x¦ìmoß”¶wöö­`òÔ‹÷ö‰§6ß=ÔÛ\zJ´ õ#„PaÂ'Õõóßö=?ÿ—CÔR“»& S§€äÊ8IŸŸù¹WoxdSQŠ’$ ºˆH (ÛÀ\mJ:õÉéúµkÛììÕ%®ïÙCÆÑÃV«{Ͼt붤!gWcÕü Î …–Ø»^œ—ÀIÃ5sز•ÁV¬þÜiÛ7l×{Íì ؼ3i1Ð݈—èï"C1—–CgB´´ ®¢“! ÒÌ‚ð`ÐP»8uÉWÖõŸü׿5à†nV⪉ŽÅBB¶ž ÿ§Aé'×ÉÊÕ$È3VØnRÂßExQë(„èö+¿óÿè÷Þ8œò¸‘&Múæi»Žq zãÈXãëË ‚ ^±l‘Ì©˜“í0*Òn!ñ]N :}wÌ"8‚IÓöb·J%©&ŽåÒ`˜Ýø•Ï=8áÍ)zJ¨AT¥¸+“­ÕóH!L´jÍõ µ·…ìÖ!Q"Ü'ñ,`HPé $)úž ä°·÷•í€½}+Ø»$p¶D÷ËmÛ“f¹‹™Á=Gƒ¥Rì¢UÔ¢šç9‹<ÄáÿÂ_¹{î’’X礙©˜§ y|áù›/Ý|á°"6ÂàâTFÑ©! *fPÑ'@§ÃÃÕõ×=oE)„R"BE-u¸#¥þí{oݹÓwƒghÕšTa!Ÿ4`>3mÚ@È"ÂÙ’³SP€y9‹5R>õùOË+Å@ÑÕ©Å%íP錰va@·™eƒJ €ÌÌVäD2§Š ¡bI»|WW×ï¾~ÿÕϾuÜÝÈgbÚ…‡J¦¹D¡9uµ³Rû*TW¦9à~ 6fç9H{¿ŽYË¢¢ C¼Oƒ­þüïýÐÜ´>¯EãªïJ«MÙ9Žðy—Eµ°â¢ µ‘oXVf® ¡ÂÒ§¬î–JÏ^`ñOˆXýÖ9C±i¼·k8jG°äs¨+Ö9xø¡ÿ÷§îŽ«³‹¨:8 µ 6Xý–Ù•¬EŸ²CÁœQ›­ŒcÑo% Í`¤‹DÉ ÀEE4™‡[gp÷ y¾å­ß¸wöÆæJz>o¨’¹ÒèŠê4¶ôl7;¹;Jܳ·xâó³ß»\+ó¸c RêÅ°sÚ%Éy¸[@‘4}ÿ d¾\Ëîs£e”& €éä1ØÁôhâ¹›Z*¤ '‹„2ë4Ù¶?NÚÓÓsD¥T]ƒ,[&&$‚Ò…ãâð/>åpµ'ãE϶'¢HË7g^O{ÔÌàv~*-Î%óÞðk¦N²þèŸú qtU;£Ê†9,…k^³ç`®‘Ç~°—^|ñàð†É· –f=¥ ’áFÒ´wWÅ`ìM0ô܈ùõ›Ï)ÏÎ¥ ³€`†³¨u÷ܾû é#,‰PZƒòµ/€½‘&¯3‡2kpdDùmd‚sÙÀiÓRlÞDi,µó";Êò\r0ƒ~ìFœ‹!–y,ß¹„:E BÑøðtOfyrèáãte8øâg¾xÿîI/ÇÓ9ÒÐE¦I—'/meK·4H+ñ¨€lËuVê¡Ì|‘æìʆçÄæC¯U)L©(ýDØJ3øÿ¹¸y4ÈD 7@ ­xTc@Á˜&Nž©1%†!t§?Õàþbý6NVÅÒªuJU/^fm5•xO¨ ˜ÛÍzÚŽôŠª@¨¥jB¤v°Åvk'Ós¿òùvW§\;Éáeý)¢z›2¯©ù›V‚;£íösvºZÅÕ QÒ¤y­E¥•ÒD£&ŸÖëëÃõé.¾øO_?Ö0ji<fd&iÆØszêÒíþ=™ä©‹xù6çOÍØõR™ümÍ”=ë³ÓlsÄV<ðÄ1ÈŽAWÛ,°Mi$@¡×RÌ­"¬ä`ûpä9AWRÁLAg‘­+ÄÂUgGôŽD$MbP«®¬¨¦ š t1‰Ä±ÇöæÕþ¥¯¹o<Â:¥8š<”=BÙ§ió/õ?÷㣟GõÒÚù²«¤xjhÞkë+/žøš§möö»Ò.ÝY¾þ‹fo{û&3yêÅ{°g^ »d}ƒÜQ(ÚÔp1¬»‡ÓoÇüÐï½ù‰X‡«ŠÉLÌy¥Œñ¬ÓxáæóÏ_{A•[zÂPÔü2¨Š¨”•l`€«N×ç'‡ÃðÁ—^\oά!à”Q1ˆzfêW÷œÜºu¯³ÏPd¦*·Ùpm-·•¨!àú¿ S*<¿ô6wš‘˜kvAä]]ñnl {§¨^Ú•Ì°«"»yÔ«#0#çýﶰ vi‰…šS ˆh„§d O‘vŸùgŸÉã€izödæ%Ô²aLÐPa!ÄkEÔ,9“CˆwZ^użÃÚ#¥Ô>V|)„Õ F“Õ0Þù‹ä»nàaïcQnª(W"Æ @1I1f·È[‹Iz΃]ò¢ Á¦Ä×KmuIr4­ °´Rì–(=$²¯/ÎnT)¤´RØMŠ YêM`@B™qõS¯áó«[¬²zHh"”Ъ+(0µµW™¹–|!7 -&>ëÿ¤­Ì 8·šh‹µu«¾n]:ÆDlû«öâoý“/êÅÐûqv²Ì·6™ñUýVHËüi—ƒîpÚÜýå¿ðû¿íÚ:i0X UÀ~Î.þí‚<_?"Ú¡Û㣽½ßlŸØÛûÛ¾š»öÓÎB vW·HA·ÌûÁ¦ý/B%â±ö‘úð÷üÌŸ½›sØGž¤‹m1ˆLÓéó7¯>ójß'bR"Ñ$ ,DÅ"Ú‡¦ÈŒWìâäÑ Ïß¼r|u³Ó !Œº-"Ø «;÷Þ¾ÿØÒAöÐᡪN'ª´Dí’–v²>AÔø>vý€!O3È SŽÔ+}R…3‹Ša“FgÞ!'u«`KÈÒUµÜx§ãÒ•ËÎLñ°d>þBÖã-eË*­ W8X×ùƒ?óã/~üºåm–È"a-¢GõcZ 8„„‹ŽÊ)6k™.Ô§R 3& ÆB h^ÝÅ_•–²j ¼É[ æ,M™,’!iÜ®7çF1«~2"Q’¥©°“R#GîŽ_ù}êîÅð|æÉÌ4hx)‚ž3Yk¾îfÜÛZä^·åB ÈÚ¥-Zê©ÍO!‡•”—˜†Ä$í|{vñüá˯}êî£×Öz3ÜB4¢4þÅbQÏ´¾¹‚—¾°Ù\·p ÐïVéüËÎÁ~lm ºUÏ‘…V ˲ªYš+BŸ r´óG -ªKBH( Léå»B’)‘c:\žß=IS¯“–⊓“H¸äÔkÄF»IR ‡i’‘‰Da†¡,‡xÈ„D1qb&½†$óg׎ҋ7®¤_ A5eGÇ4h¿†¾ë6oýÝ_ú#2ÝÓTòNµ(¤ÍýåñŸÑÿ3<¯Úð©_÷øhoï7Ûgööþ¶÷v×~b«eT¿úÝOYDä0“v 1å!H ñìÀ´íûÿ3¿ø ,­Æ1÷)u.B¦©7ûà˯ôƒ‰â%p†ˆ$b¨n"J½ÓNBèùàÐî?¾ûÊ+ìû:‰R(d°hó¡Ú÷·ï>¸{ÿ¡Hç.jJ§% F…°-fY¥QÙNíšK~¥q+°‹ñWªÏ ŽØB˜»!åfž‡w®ýi?—?R!~ ¼ô ^7w¢!ݾâ(˜)shà0|ùs_ºóÆí£î(Ö!  Ã]­PQ @„ ÔØÃ!Ì@V µHÆ;a•E@v«ÉÌáv,mCd‚R0)5 Q]aûCØüÜ÷^Oç÷{U-4¦ÌÝÕOP„U4H(âÂ0Ç ›-òæ]-EUú/c»_?Ëù¦&Z°UŠ‡h¥ äæìܧ±E”" ù¬«RAúâÈ ¡4¬ÇÈ«ýÿìA~pP e˜¦÷uyA킽ËëjwÔPÿN†rÔ쟶ÃXx<,œ4…Ñ)qfëÒæt}}xqs'ÞüôǸÆlIª Twžžì‚ ÿ´]òø–Qëú?Á2˜ýŒÏ;ì?¿ÉúnþCŠ\ ;e§å—Í(¸®´rüåâ aãuÁŠw)@@a¢€Ê4N‡ÃñÙíÇ)VpŠ“@5Ñpï’¹OaÙ5WúQÖèI–é)I·âWLn"JôI°õñazù¹kª[bL&î9ÜUT ‹í÷|èð~ê»t¼—R|¼yTŸÀöËÙø¯æ¡ìmoß¼¶/ÞÛûÒž z7{§§Åq&V°7£Ü'6­qS¡P˜³(yüž?þ¯âå³(á°ŒÄxá¹ׯ_1«ØšÕ5€¨Ê’Ùª E4™†ˆðàjw÷á½|ô#ž$:Dx‚Áµ£õ¡¹K ‰”ÞºûðÍ»DwH*Oy££ÔY¨‚/!Èlà."?»²õüª¸M*¶F) }ˆÝеzAßœ]_ >#•ö[pi…þ²›Í£¥É¦Ô²Q ¡Hò A²jøƒ®ò?óŸ×1Ø•i«Òõ…­¬%ºÝ€™¨áêP˜¡×èdk¶Ñ4Z¦*lrõhþM-P<ûEO¯µÆû/c.`˜¨vGrï/üáï8äcøFódB8…j…Ôb€(JN£÷…•'·L=²Ó´¬_?󋦘=9”èpÅŒÁ(ù(‡ç~qq.RJÛ©¦¥g„U—ê£"Œ9^^ÞR ÔùàÖã£O½*rðbæ6síˆÂÜrˆÐàEtÊ+ê ˆâ‡ïFt¾Þ‚ "‚\½år$ø­"%Š¨î‚c²A§Ífˆî8_ûü?ù²]¬’îTS2P…èÙ&zá*}e»äÊnù^Jhìèr%éRË·++ s"©~¤^&µ Ñ\å²ÇFú/+CÙ]P¢®SXìpiuØŒºŽÄ4O~<ßz 1ˆ‹W˜„C‘¥³$>™…c®­FÙŽpÀ4:³N„¦‘‰0˜%A †¤§$¦/ݸrãêÀ¸Ðäj'DRgyóð_û™ýáY¬•¨K„`w?yÂOªû áïÅ¥`Ûro{û¦³g®Ë½°·÷ŸÍHñ]ŸOÿ…ïü§»”qÆì p'N@àN2ÎÆéÆwýðóßÿ/=š¦Ô¯L0ˆÊ8wýËן?´. !¹rÖg˜QÀœT‰C¨˜Â’BˆèúñÞÝ7?þÑÃ]S€L)¹OfÕ0µµWs]f‹³Ï¥ŸåèXO ggšé¤Íƒ_ø‘l5®°Nt (¢ül)êˆUe—ˆvZ&.¦5Ç3¶RÜ°û/é€Dc™#éÌ«(EÑÒó˜%CJŒ›‹isÑ‹hÈRuz¬UChéD•K½|µ&[†¬^øµWýÖÙ•ÑDTÕK–€åøë€ÐFášçWv‹W„! ÛýiN¼T ½KÄ,éå‚+E qMBb<˯ÿƛ緷ƒ\Í[h22ªÈR]~O8¢ïp‡Yø*»+ŠË%?ovÉIh›Õ$[ÙÁòðÛÿWæüÎnWRØþ-5É9uP?i¥ÃuqEL Z\K¢¤¦) Çg·((STµR±îfÉ#«Ác;õÖ‹Ó À£ù«¢f¥³oDˆÎµ Tz@ýâ¨÷¾tíxEŶ7‰1$pØ Ö¯ÿƒûO_é™NQ$^Ÿqÿ"Õ±w¸÷Íèü½8{{è¿·o^»|©kuïìí}iï!öÿô-ýÝ7–[QBR ‚ªŽâÈ‘7ðí~ÏŸù‹Ã{Sø”$dô—n>ãè8)Ô@*0•Âä-Ä]°í- 0xž Þ»óÝßùÛiÛ­„‘0BLGÏ.†Ñiǯ¾yçÍ{ÕVyÊb,m2³Áå¯@ïóP¤¬»O´x*þ@c²H4öÒNο2×kL³Eï8ƒD©ûÙõ1-éÍaóS*5¨Ü¾.µ>U"A„¨FP˜èöÙÏüöãG§ 1B¬È‚bÅ%v‡Q]m+BQF7 À‘Kt]E´uhÒ'¢Â"ÔÅzi+5XªcDtÇ>òÇ>fäûVƒ?€SàZñ™ ´b¸†v '¥91s )$]–GlÎb}Ÿ -ÃSz$ ÅN¥+»a)q®D€¡á½ê¸^o.Θ]‰ˆ¡I ÈGJÌe­óõ!Š/窀@§1<ú—ÿñ¯ßÏéƒÛÑBÂ# Q) Å¡ÒyaEkCu‰ZŽa±Ë€Ôm ¤¾´¼—j<µŽ5-4N¡Ðe¢Åv»¾~póìÍí—ýÖ‘<—G 5Qe”!jÎ&—û{ǛɓáÿÎ/v)ÈŸOt±”êþŒK_t‰kw)PýÔAI­AÙ·4M–‹#U-Êš¥°è¨ŒãtÔŸ¿}–r'. 0JÐU¤¥1iÔ­‘V:EfHL + JX§@¤$d …–Ð LX´ƒ‚ùâúÕÕKÏõš“¨!©ÇQÇ£íÛÿ¯ü´]Ü’Bª”²(¶ò¬SÞ]Óïôâ½Ûný|õÙÛÞþÅÛ>°·oûZS±|êż›§‹€q ¦VÄž!úØõþ¹¿´I‡jÚÁdô•èŸq°ÎT…-ìÛ9ºÎÝãXD­¨þ¨Jd7•³‹‡Ýýä'¿ÿbÜ ‡És65ÐAOÞ:…‚H«Õ«¯ßzøð¤Ãà“¦”C ˆ¦^Òúâlw¤‰*Òb¨å,Ùª kp¾dŸ^„‘ê)MB5q­½fžZul4tAS”' B)‘uC˜:Ô:®nâí¿üÓ?Ž»]dcè\!œ‹°\Ê9VŸ¬äwnJß.B#|s›Çð¬AQó Ö$L¤ŠJD‘ˆ‹³³Èy—1’Ùw*ÍJ»þKx÷.@)T®]ñÅÿæ·/üàå ¦@¨TòŽ#C›xTíí’+BE¥/˜—oyÑÖ vú²æ¡ñr8M]GÖP±P³iãWǸöÛ¿òù´Yuyå®"¥×¤Ò‡–_¸èR½»8_»¿<‰Ù>ß®¼v„Ï´2OóegäInâ¼Öý×Ùlk§m&ƒ¦V×P‚ªæ#V8Z¿½¶Ü·†eˆEi¦A vÞ_±Qr&<WYU̪¤¥Ç\Í ƒ4pR™ž¿ytãÚ %IEyñcßuíOÿËŸÖTE¡4ÕËi·8fgàÉQ”§Gÿk²÷þXù†|ÝÞöö³§ïÞØÛûϾ¾ÐË™ƒ§ ZêÕÂ]gî?üGÿĵÇHïÌb³yáø殾dÔâå£Î iª`6ˆjíäj šª(| w¿ûàmP>ùÉ|pq‘»ØŽU³¤ÐT“dD¸Ø›·;ßœ^å³/Ø"΢Ð2ö"OŸ7s/ -QyUQ¡ÂÇ_¸•ßº§}Qê/‹#êÒ  ptÐæ·y™ÅI˜’Æ}zrý•²V¬ÒÈñó Ww±½)RM í ‚ñbûüñK_þõ7OÞØÆõ˜:ª¥æ!æê˜ÙKiBõ;ÿË(~[Ösغ}3wÎAíß&—ÏäÒ%¶óvæ!¯Žoãt=cûvy4¦â®6z7>Í?gK•úà¢>%"’uà°¾{¡>„3À4ÜU“„&U .|˜pLY™0an"è)õVZY£hSí ªj*JÏ)¹`s´²—ž¿¹Zu“óðà`óèÕû_û©ï|1žgÏ)¥›AÍ„ÉewëÒh=1ÿW2A„"º»¬fþK£þË<¢\l1¯´r´Á¨Z¢Aa¢ãà•ÿò7œÉËÛH”Ié†:8;üËɨº˜Z쟗'´U…7·uŽ©Ï—xq\Ç[…­T5<€¢Ë”ºõéÅÕ Û·ùê§_崙ƃf5O5¾­ÂC*ó~™WjssŸÐºš'Tæ¨|»TgöVÛ6u4ôµÖØ¡}Ûrôg”|Ù7h#PäqK °Ù­ U,EÍ©ÐúÇ ›·OLR¦Ó$"4)ZKŠrYv #7bbbp÷MÖP`J°dDZDfMDrdKêîDv¬U·Ïß¼úüµc?;{îð`ûöçÿÿàÏ^³{dq$æñår¬+áY8ükˆÍókÊ!ì}€½}SÛÞØÛûÉž€AïjO; _ñsóS Á1ÑZå-š9A“ÓáÚïûWÿÒ­í4i\9>öò‡WXÙöpWBM’]@ÒÔ„ªbj–RJýùz{ïáÃišN?úÐK/~û+ØNÃ*MÛX T 'ñHp"­V·ï=|ýö=‘!"4Q" êNb§ÜÅDëIµ@| Þ0²žå|ò¥Ä6ôÒXÄõÇ䇡†oe‰¼U‚–¸4s¸³% ä‰êâ3Q½‘iôÞ†“û§Ÿûì:Ì“BI/áLî93—úò7?5ãs™t$&)º—eš"‘JôÊÚW¨°t"¨¤t)°Öên)Ì솞ýóýßÿÉoëâaž²R’´:pîü‘y\eÆÍ!b;ֆ± :LÐ%¤$)©©HD8˜á#|õˆ\v—óôøôáÅú|Ž’«JÕ:jÒˆã [Ùÿ¥f¹îAÒ!qqÚ´qn†—ÿñgýË™ÉJ$*= Aa«œ×Äî«ÕÂí»Å2‡p·};¦æ ,f\{*"Ô,"’%÷ˆMi»¹@æ±\{õS·.îæ»–'¨¨{©(j§ÊåU´ƒÒË/j£UŽvfÒ,ï>OD±‰Åïå„Z“ê’‡´sVeþöú51;µs%M[ÒE8(jù¯ˆV߈+J£(Ávõ@xD¯Ýúþi!2Õ¬è$‘ˆÒؙ档&]ÆØ 3 “I§³‰[¨#Y‚B“„dj¸*j¯1[±Ü-‘Ý7Gyéf×éáazå`ýË¿ð“ÉOôÒÁFÂl×ÉòîþŒ‹ûk Ï n¾¦/ÚÛÞþ9ÙÞØÛûÏÞ[ª÷îç˧Ã3Ÿ‚K°¦aƒá‘O!?ú'þžK¢/_ñ…+7uÏ1–¾ZZéóC‹j&¤©¤®SµÔõœœœœ^¬†áüìì•W^üÐ^ʱí:¥3YR''7SM$„¦axëöƒ[wª ¨ ½tR¨5\Ú·µífmņ´A"È*ÔÊdk‘B#NÌB¥µ´J¥ µô–Ãìd }{;ì6æŽ7Rœ£þœýŠ%È’¨ÊBJ1ÀŒU^ýü«·ßºsØr Fö¤¢zkh¹ “&ïóôr‘`b­`Ë4ºWk/[ÑÄ–úà(®Ý,–Zü.ª‚"Tˆ"B1tC¿½õË?ó}/O÷WyZ™^G·¹+"h1惪(ÆˑOáHd’ Š‚½)-y…€À±ÉÊÑdcv®)¯Žp|8ZʪapF©m®‡$sºx\ÒeuÎ3Ý]<xª(ŠÔWlüðÖúøS·b“®¹&AŠJ‘oÚ!ÕÂŽ+TŠ•’è‚ówð'‚ÜïbréðD@ˆ*jæ¦F€–’ˆlÏóµîù“×·w>{ÿH¯Å$š 5¡¡¨µÂå!\>¤yñWŸdç ,Àú“«pžÎyf[ãã ÷9§Ÿ¼4þdH í  sä¨ÕÏÅÑj)š:vT"hb…T\b€Y;¶o¯;N9ƨUÍ5¸âê¹þÂOå Wt=V~îÜ€õ¨äI .ª%Wé¦ÖI'„U²ÄöÚÕ«+±4Ýûó?ýè÷\çö” ¬]¾Ü­—æ|mˆýÙ¶¼I| ûÝ»{ûf´â|#/”½íí_¨½çDí;Ý“ùÎ;xÒ1(ʼnFŒH/òGn~ò‡½ÃÍÕÑõtÔe3‘c.D‚ÚÒù2+~ˆj2Kf©[oÆm6yúG|ô£ü¶}`=^ˆ‚d.ÏÐIœ (¦·ï<|ëî °ŠIÄŠæŠFÁfvH†S€(P«u¡ŠŠÚ*8ˆeKÑ],¾þg¼ƒÆÍа@Q)]ceu-E»økCÏ ÔÇ·4Ÿcá Ô²Î†Þ 2Pµÿ!PæH’¦õø™ßø¬o}ÀÊ·Ô$B1M¥#GÄÜ9 (¸ŒFcjŽKùÊ™á!í8ØÚiI´µh˜ˆh8-I Œ C*Ð Q¼”2&àŽìüä/þøK?ø¹mîq„ׂ-ŒÛbþ²“nmcEBc€/ËII¥ôÆΘ4̨†P­EÏ¢®±òk'wõzŸì4Éú ‡íj𣃱ï·Ð,æh¸¿ø|Íw- Ñ´zyU1©ñ…žèsµÃÆD•Ø_ýƒÇãµiêBr– MBƒt‘¢jÚxÞV;ßJóPÉ'œÌ¯`KŸ¾éU/´®;Ñê[ ŠìÌÄ·ã«´>üü?}#MW$º @5€FEÜsƦ}Ùå°~õæfOrw@2»›OÛ|ieô\£¬ ìnÝ.ò Q)|:_E¢È”µ5^=Ùª ­²´ °ôq#)¢Å=’Œ%ùÐMÝøöi'‡îAEP §@ ƦË8äÁóÃéôƒq’«ébš¶S0Û 0Ô[•¥ÈTZBEÔ!#d‚:}{óÚÁÕƒŽ'_ø÷~ù_ùÈ•sãdÐEE”sLaY¾#Ä¥ùxÇ•ð× /ÿº·½½lŸØÛûÉÞ[ìÿ]>ú„qñsÞ°>»‰ª!¨áá>I°=~áý™_ ð¥ç_<^ NFž&‰Äe0DSaIf)Y×Yg)ÏÎNNO6týÙ£ßýîúÕõx®@…d§ZŠ)‹6¤®©{ððä­·ÞV]y@­À«ÊÔ`i14P 4íRj‚@©Ës]ÄSD*OÄ]ÄyŽg¶B –Kh¿îªd b+ăஉ‘Šlv†6 ¥>€%–,* ¸û`«»·î¼ú…WPUè5Õ‚ ”+E ú\¥h©p˜¥Uš¿B,´#ë²jås^U´¤ªm[mQ[!Åé1xuù”ôئ!Ùd;|ü3?xcؾq`P°(x¶/y-Ì[ñ?¸µ¼OHí@M¤K°¹ X4]Ô:âPžu»±íg>ûé‹ÓG9¶Ò!Ã'pki­6õ½ƒÃVÕUCfšUõ…%«$*»k¤‹ÔÍî2*`]K>$B!Ü:qð¡ÿâ3·ÃK#B:D‡TjÛ¹:{¢ AŒÍÕhùŸVž¾K漋 ÙªŸ5Éew"¶¾ZEyÓTCý×»_ûÔ›Û{Ó¡¹ •V˧«+»8ïyé´õsiT.ùõ"È M±§9æ”Hs*ß8sê­­H[8_k;BÔ|c({;¶ IUe@D…JPŒN×HÉ»|ÿÜëó¦S­%åÔ¹m2k€v‰uÄ8ÏH¤@P(I$‰j£>” øŒpȪÀ’ÏüìÕ»wÅäáíW5gŸ ”ÕÒU˜ª.Mrê¦a‡aÛ¥É4‹„Z@BB.¹'h´üC·sصP‚T’EU’Nˆ×~óvÿÚúÚ¬qw›ÑBõP[H[”å´vN#Ûy^¾€›w°Ð€šëìö²ÐÛ–Wý“¢¸4†ŒI;Ë›|ˆërzðÚ¯¿a}â*(f*ÁÚ£Š”KÈ¿¢ðÅ7cw —†l^fÈ£zËQ v(žD¯õ·ºö ´FÚ ¿zþޒߨ¯—3TÓ/ËRBVüV [ÑÉŸ2N=Eʪ¥^D’s¢Š9"ëV¯Ëêy»ˆ])!âÚ³ß>^sr %U,90ш¨Ò`H¨Š˜’bfy³=>ºâãýÿÞŸýÁ?ð]½[èR¡D`‘¸4<ïvKÆÔý›æ9‘­TzÄËüE‘A"Ä™eÔA²Àexé¿ü‡ãðʘƒ$B•†€IDA“Ö.Cæ¥Ôæ¥:šOCì2¿S}¶ù]R>f¾œu¶€=´ÒÏ*kÏY'½&Ï¿õéû§¯+^óÑ`Fa-$ÑŽŠdë¨=–,Öß³î.¿vº£¨U'”¥§ÛÂI:š{ óÅÙ@wßTÝœ*PµKSÒ¹îZýú¬:T–Uï@T42ôJLÅ5a1+g–ÊÛša ~RʘÁ{—3™£ÂËE ‰J)%ÀRd][N¥|ëB‡€¨ HªÁ••¦þô3ÿÖŸúä Þlᮢ¶‚… æRÆÇœÿÅÁ#…!¡½•À¨7¦?€ÂuBñ‡€’÷ *ÃM³tùõG·Ö*ÐN ž7ÞyµW–fp‚êJ1Vhˆ([wÆá8†+cFQ7 •£¡Ðº=d®8®Âý„€T¹#xr¨oÇþÎÅ•ßx3o혚C3` j`’’Úºì˜Õ_çqO]ų 륅uÉU(«~.D©]*JBBè’…*aµâÖ$cô”sl$ã€GŸÿÕ×òã.áh¢P-‚Ñš'ÂÎ/@óMg™«é›ùÒÛÕ ³–y7—f¦é·!Qå®Ù"\tçj.a]Àm‘á‰à6­Ya3 ÐB„„Ñ"¢Dú3'v‘c›,ëM¬³ÅàY$ko W¸ˆ ˆ4ån­Wíø…£-.¢c-Lp˜ülÍõ¨Ž”RfVSÙ¹1Š R²í´ çÐ%³d¾ùézéOþøËÆ3è.BQ)yÎê„rYünö´¹Xg{ì¾·÷퀽½ì]ïÎÏŒ ._ïÀí3ÂÀOþJhÔðÄyÎ?ù'ÿâÑó …dHSƒhJšL»dJ˜©˜ 2ÙíÁ£“óóuéeɈN-ç©ëô¾÷“ÛóóÔ‘“#4膢ù£¢å1/z~ž_}í¶ÙAžD“2`–JàY^@MþWQÈ´˜ËRCŠ> 4Éÿ¥€Š´°mˆÆÙ¨û_ĹÛHJ ãËn䥱+#=ƒ·Š¼æ­È&rBáüG Ó9è\éð…Ïþöãºn©µ£ªQšrË;Ëxi›ÃÅ‹pî›;/©¥Ã%RÚ6(-¤¹Û°m ÔÀ6Q2E* $5uDŽ‘îÆíéþòO¾ü=Çë>.zPĥ­( ‚ÒÃiŽj‚t18*ÖwPÀ)È~Êò# Ð)j‰ª &¬óùw_³N£¬ §·^çÅ©º ]¨É™•Db Re«1öæ«s—&“ ‘ÕV5^œ@HD-.L,¶p¹ÁÄ,œpý×ßœîæSPB<4Ôª¨Ô\<\ùFmŠ—m‹‹ÏKrWÀ=£åËWµHKwÕó½Æ¶P(Ú¬AÑ™g¢MDu¼˜n¼tû·ïßÿâ£c\ O€Zíq‹Ú³ ­¥•Ú>”ž]NÙ]‘@‹À_:ìÙ£.ßPbým¦f‚(·¤v¢¨KW›[„ÅÿÐæ*+õ¿EþÁJÒ$!ʉ) MšÃWéhûhäytÒOy’NP6 Ac rÒQ¯ÉáËkœI€«Á„”×Óx1úƇ4èžwre¹ë’e31¢7õ³/ÿûÿƒ?õ‘«'½l”¨¤ëÚ[ ç2¦÷fò¬»ÿ¥ñúšR_Oö`o{ûÛ%`ïáîíw›½·5;?ÍŸÞü²ïðN·g¶( •ˆˆqR=øð'~ð§ÿØÙvY¢dþ­‹¤Úw¦j 0TBà]JI»Í6ß{ðpÊž@ƒ«ªf^¤>ñ‰n.66$w&5H(¹ôn C%3.2?÷ÚÈÊ'•T`FÁElQ¾«ôpÐ*„Y€=¡j¼baÍ!ªØiQå‰"kÏlhݬ¨š²qxÈBtnîÙ“`É20 ü“úQjý€ÅÐZ¤ Qñ-Wz¸=÷Ï|úóá)ySÑ‹ ]ÅM& ÔWÇâæ DHÅH©ºˆ¼ bÞ:» EfœŒ"â¯2!SÊ „ˆ¤DbiNëC Ð NÓù¸ž(ùâáïû˜ÿÌ～¦û>ÖŽ`¥s0vú¡€ Ôå‚”€Ã$3[Ÿ´³PÀŒ[©hÓPI jjg'HPß<}kíÛ\Y\E{ÏÞÞøü§{ +M©MƒA¨F]Kuy‰K'꛽‡ÓÁñØ£$W)¼ $²Õ¬ ˆÒ7 Õ%…j@j„Q#„¤‡Ezé¿úµÛºú„©nÕ"Ä /Ë—d)lÝåµØjdg¨×‚ú‹²öËW6Ûeß–åb™ÌÒF»ß-rJÔÒ+[J€ÜE¡†&Ý^¬¯ö×ð¨ûò¯½ÕidH©¨&”Q®ÉÒ•bçoÌU%¬—qù)p!_©ŠU%i²ûµ¬ –´Js†¹„æ~߬î©-—Jð"Kì_Õ\\‚ Z„!t„¨1XœnÌÌG?HW¦“ O¶½®œ-C0B I˜:¦$FÉñËÇç8åÀ€—†}ê$»_ŒãÙÆh)um@†ªœf-…3X ãøè·þóÿè¯ò–r*<¿ê—ó¯w°…jÙWxhÌw¼§·›£$ø:r{œµ·o»äìÓ½ý®²9Hó·TyêÅÓAœËï?¹£`K¬‘€˜Å'Òðö:þÜ/ÿ;ÏW‡+S‹ &B“5MSSµN{º<~ôøôôŒ¸ *æ+‡‡ßýÑO› KµÊ5"kÖª";Cdrüöç^;t,Þºf…(Jr¿ÁŠ‡æ>Qu¬Ê¿Š*`o€¸€†Y¹²!¨º)`}~îÈË»(,Ÿüu’n§R…”ï®ÜöÆÁˆðÞmS+yËUwüÖk·^ÿÒ«tÀID ÉY„ÒØI­-nQ\ÈÍI€‚øv"*D­Ræslà©X:zµSŽ TR©’EE«/Ä` …ˆ#²gëñìñÉùcºÇãÇW7Ÿûk?ûý}¾gõ¤£Ç<˜…[T礶®Bˆ»z:8Ô¹„hIM`7Þ"¿QÏ›Eþ¿¶10\ýŒg·Oß a§0ÉÅ¥33N1ž?æÅ óVM"\ ªÈ×á¨ÈT‚dÁv*“h6ó~àj]?B\…jPe™Õ0A:ª (ªzE4D¤“u¶‹á¿ö]®$Í&aìA!#‚ªâ‘K]‚2Òœº™ã>/û¶*w×wcUíÞ¾øä‰ëµÏ’2V"X WÑÝÔ™Ù¦þX^xýÓ·×w¶+ûD1KbPP¥†töK]¯u”€~s¸—×Ó|@;ŸZ€¨çæ0ÏŸ\ÜÉd&Ùµ1« ³ cIn±ê¬î Ij½D¡•UU„Ž¨šZßg¡Ã’yžz]峌‹I8ð¢¤„Ò JD¶ ŽüÊˇY³“RN €RÌ%6qqrÆLE‚Š‡‹Y„¿œBŠªDZ“Ô%ÿà•ó¿ûË?)ãc8#ÂDUfI§6dËTÐWaËg¿Ú?ko_³ç°·½}ƒmŸØÛïj{×5ûôöb:ïôh¨à‰ ¬Ä#k’·.ÆŸùëû"£ë :éR2µ”RÉw'­ìg3[oóÛo§@i….Èv5èG¿íCÓf­V¸"J2™"âEÑÓÒÅ¿ùÅ7¬?òѵôhb-J”‹s˜Alû-'^3ãE©0*o¼‚] G,ë!e®6œ‡©ºgó&œcüX”0Ê ©ë?*_.ý­€2REK»4¨#é·~ã³ç§½>FJ¶‹õlÓ„JZ4}éuìÐ>kŒ|ö‰´xmÐJ.¯„Jᨀˆ0Ñ‚ƒˆæ QXê!ƒ '˜Šºëú|:?;;{|6žŸm.Ö[†lòÑú¿û‡ÿƽ`'žƒž4˜”{I´£TH•^xW”î@‡c ˜*«£– Ï,&pHCĵ„K `Ç×½>*³SD¬3¤ ÂqëõÏ­’ÕŽÅê´R[Ä9¡ %` P‚œtۧͰʇW¦þh‹”iPsÖ5"RØ€¸4ð/‡äTB<$¯ãà7Þêo]¼¸9O1QrZùq—û¹&p Dw-½mÛ°U_¢Eñw´™TŸ¸Ôé}úÖ°¼/hµJëRj/í*PSŠ˜Ã%Á9æíæjíüv~ãÓwx#F)Y„Ê€„ µi𘅔ŠýÿÙûÓ`Û²ä< û¾Ìµ÷9÷Þ7UÕ«¹º«'4 f A€C@"I"H‘2A˜ÁÙÚ4Ca)$KúA‡ƒaýtÈvX@Ê Ú”M”IBLPˆÐ詺º«^ oª7Ý霳÷^™ék­}Î}¯& С›ýúÖ½gÜ{íµ×ú2óË/¥!õÝôOŸE°P³Â ¼^xVzKÒÈ‹jV©ˆù¦o?‹ÖŽ,¨y¹´¿–ÇÏ]ŒÝ®A Ü](3ÉÆÌ È–;Y®ï­8vÌ µÕžƒ„×åF!÷§~Ñž¹4ê$IÝ-¢á=dstjÃH—®ï ™„@Qš¡wÂ…v””Ãõ?ò}_ÿ]_w±³qÊnžÛ\}½Z±õ¡‰ò¿ýN²ûôî~Õn@œûçö[ÇÎkÎí+Ôæ ò½|€wx3ÙÞæeÛ˜[Ë’OaÆÓÉ>ô-ßúÁoø䘣Ó."DD“@h扲H=]JBÞpxtt„;Š&G˜¥fãÁÞòãýèæôXSÀà@Ða&ÑÂÞ`µÎ_~õ ‘~Q»}Q"ØDcÊæ&sÞû¡S;ãÔ˜q- ˆº?6À\þ»+²2Ë rfa›@”Ú€· ŒÕÏmŸ±ãšÂÌ€VâõOP/”iœzô›ãõKŸûB' FxˆÖ¦¤˜Ãö®ÐHGU•sÉÇüËVC30BÓ°i‡·X³úb¥ôx!•ÈÝ0qUJ5È„Íézu|²9<š6ë&1cä@Öè×w?ûçÿð·~íUKãiOIªU\u¦rÔ¾º^>šÔRë #°¼û…UÎÆD:«&ÍÜL‰I%+sôBH·m°f¾=+)hç殓|>¶ g'pìüÜN¡¹$œÕ,÷Tˆ”ßED, (òäjË}â•_x3­—/²ŠBÔ© ›l$FSi @³K<ß?õuM (¶G…Ó™é:;W •Ä_>Äuj»òÍU3³G´óT{e!¥ÍÅÒE ˆÂVQñ{Ý㧷6št t¸—ûQ$Ë4"²npÁ.<{0Èš]XLN“D¡`ŠûñdœN7yȪ]¨dw ©€Öi/L¾Þ,ñþ«í¯þg—wö@•[b#üí¸xÍÏè:¿#&êѧðv¿‹=4°çvn¿™vîœÛW¨Å#¿¼_ã΢þöï/a¹Ê‹E‹°,)ùå'ðÇÿÒÑ&ïï/$EÌßßâÅí%Îð¹$¹œÞ _„Ôº?2Â`Â,2F^­WÇG'G'ÓfäÆ“;³!ÂéÂ4Þýžo¸ð?úúÆõž. XÅyƒ4Ó.\`D@Ä$rê|ﱩ;‘"3o¥m[!€ÁV>(Ò: £ $#\ô7On2ÝÓôT¸»˜ÆÍÞB®½òéeGÈêYRœ áΘô¢KR *Å©á@1u²¦t—³´7"e$‡F0³º…[€N!bã0êÅŸ{ýtÒnŠLy­‡Óq3ŒyZ»N©»>§Þ“Ë$bx‰fs–ëÝñçBq$uÌwHb8 cûòm™Í<Ñ‹“˹«E‚j¤M§Ãã‹'ßüÌÃëÓ^º’3]è€#Šv*¢U»4Κ̙}¬·›ÄóÌ­W¥þ”êN•RcS«&X="M  ~æÖŸ1ß[g~°þúz·ÁZjR“y”…¢¶ÉÝ•õÍ#D­sV]ˆÀìa]ò¾wQma{Ïì¯Ò*îp÷0íÄs^J/£LÇS>5féûEö’œ î§.bÓ^~ã¯ÿ¯ÿmn^ïRdËRÒv1ûDg/(w‡õì¥>c¹ñžúsûʳsàÜþ`,Î-„­lò”ä­õúGÿÂ_y°‰½ ËÚñ†¥$¦¤"J'zçö½ãÃcq‰ŒB’!%O¹_p3>óÔSÏ=ýô°Yu=-;Hw«I~‚-GPÍõ¥—¯ú0%As=³³áæî>3 æ3ãÙ.¥¹[ݾª4gh_w~ÜÓ;ÁyÝÚØ~)¶4Œíí:@´:„â¼x Žã$PLñ™_úe£—¥¦]#@|n•ûð5Œx›zgû߉øoŸnX«y{s vöÊQz‘R2™pô¼6'ÇÃɉ¯GÉÁ ‰N R¤€²Nq±»öã?ôͺ¹Ÿh‰†È¨$›ªtXDƒ ˆRËYz¸¤÷.椊I} OB" L­Ø—›Îú/„!É‘$œLÆc_ßsdŒ$ÙIDÅÃ(tw‘c}|<¾GL‹pyÕyž€õh«÷XóK›…Â,3‘,²§´Ü[\¸”%¹tAûWɘ­Ka¡¹E¸ˆ+9øô¹íWסÖ¤4ÓPd‰Ãz×îëЬÉ4…2„enl#ÖõÒsòJ4ý¡V!ËæåÎÓ~gbµùܦE›j³ÃÜJŽÈ冤§.mNÆËýÕñN¼ñé×ü"­wUVÞZ©Ð@}ÍÞÌ_½Mà´¨~)s©7t‘#Új¼ˆ’XØA»»‚¶¥‚lsº]»ê™·ŠšmÐŽ_½U ¨<£òb·póðŠGé……¯jë¼×]Þ¼5`J°€Âéî^2˜€„I \¦ØËOï²Abxx—’ç¬ÉOm}¼ö쪽“æâ a†péßûmð?ócßŒé¶ ®Â¢Æí ÞYïZ·Þ>°ûŠwöÜ8·¯0;/>·¯t{»uù!XøÎÑ~Îá¾íþÐôò¤ÅÂ-u¼}¼ùÞ?ò§ôéäd'œ”¤’D#áItÇë7oMc†«»\:Sê±Z>ÿÜS—¯\ÌÓ(Š°¨¨)è% ÝÀ “ /½ú:da9$ÂÉÒh=ÛÀð(ªþ^=&5R¡wCQq÷ Ï·h9ÎÀ÷±š£¨­D•@Ì js6¸=¢¦ØÀkŸÓhû‹ý»·î|é‹_¾°¼ ÑÔôF èªèŸ[²ÎÇɳ׾’MÚ”àC›=wO«ˆ¢”¯p áaFwuÐ<6ãêðÁÉÑýÕÉÑ´^sruA¨A¬2<Â$œÉÀI|¿[Úé+?ñû3WÜòiL“jHÁäíûk‘&!uæyˆ»P–û\\aÇ©÷µä 0ÙGs‘¦ŒY• !L"V= qZ¼OŸB§[ë»'§0 dR°|+ˆ0Ûá ñúµ_ÞOäÄJ+ò7í*µKÁ¹ÚsêAL˜•“0L\§ëi=%.Ÿx:/ö6—䢆ˆ¦.¸´Ä뽧 ±ô©üÒ)/M¶EÑ™¾—¨¥ÄÙÖë“q3Ž§SŒÁ,É•µ6¬½š²NõvrG;sõŒS]ýÒío;NdÓÞÙõŠê…šÊ f›´ã8l˜åbÁÖŸ®¿WòPù„šÔ+µñ¥h'""”jæ%‰•cdyØ,Óþê­Cñ=DÉr·‡Ã ÙSfŠà&ºvðôÁ†&¥ AwKI"2Ã%b]Ý=æà)( ¥íII:1¤ž6ÜøSÿÖ·}ò#)ÙÚˆÒþ¢$FP ƒÛâ´!¼ÃîpÖÞåéÝ•è}¨wˆ>Û¹ýÚyð¹}åÚ;O؇ô¶Ã—wÌOF{æáqÔ}%vq‹7ù…oøä'¾ó»NÆ)é2‚^8°"áÑi§ª÷îÞ¹sW˜Âæ­SèŒlËE·YŸ|øÅ^¼xÁ|¤†ÃCØ:XÍ%Vù•7)O¤Ò=T%°ËnŽ-À %¼’Â#,fÐCèN,¿À€Ê)n6 3@Þ‚¤úUÜÅU P±½’Ø ¶}š›0 ÚAoQÆ…ê0.tñòç_>¼{xqqi:±®ë`€Œ\šf{̇²ƒWPB¡»šél0îífÎ)k-dÅn¹\ ÐbZ«£ÓõÑÑp²ÒQJÈY£°bQÀ¿3J-&ˆ‰nÙ­_ÿ=ßpùw}â‰G{UKK©c0^®’RÀpq£E—d¹ç‹½¬*„Dv߀æŽéÝÃ"á-Ü ªgº³‚1 ŠG ¬òpëôN¦E˜ÃIQUŠˆ¨GÜÜ)A!×÷¬ïÞ×0 «H)Noӡ᧭ŸWÜáRRMD8„§ëÕd±v;ÉÓâÊãËǮҙ$¤ÎY39áA)Õ,5$_'“øÉ„[|æ¿»¶Îû¹@.îx#<’vt2ÄG›ÖÓ¸|tZQîç\ù¾[©¾»p0vV€(ñ6äϨ÷GiëÛ*[ZiK) Ù™€åº(´Èèˆé—ÓS‡×Vw¾xÿ€WbŠ*B"´t‹ˆ¨Œ¹ê°Ì|°êƒìúÞó|g½;/g;˜ïƒYŒó‚€¶bg¤â;¢å&j¼”°„ÃÌKùP’ü÷PшšÉ°0í:ò~ÿøñõ£Äƒ˜h¥¥F€ ì½ôá1IŽý¸øÜ寥‹â£’tbŒ}]®¬†ãdUí ža¡!r„,œÂÕ«ÿÙ¿ÿ#OÄ}z¸K@(%¡Qn—µþÌñk·xŸõëö}çvn¿;ÏœÛW¨½«»úhø¬ÅÎcg§=Ð&óW#ëÙ0]¸úý?þçï&)…;Â;MB†‡&§éÆí['«U’…g…E%0àŽÔézýàƒ|n¹¿Ìa… ¸»›kP=$BœæyÊþòµ†Î'J¢jµ»S4`Àög=Ë¢Ž93ø#ÜÍ¢¨—c—ù[ ¨d³úaxåͺ‚•À2îM´q¶Í 暘´B䶶ë‹;iDÐbJŠåÚ^¸|ý'þÐ×íÅýÈ&‘µ«8û.,4ìñ‹YìËò"tÏ("PsLbãëJú“‘ÚÑb`­@- Æ©Š¡’‰‘aEn¬71N1D¸"$èÙ‹ ª»AÜl‘^ýâ/.ÅàÌ (-JîZ8]ë7¯n2œ4‚E'΂CäðÕ險«œ§¾ß{üjºpi8S¨æ­ÓÒ|×(’ÿJ¡¨­£ÿìôÆé2Š[)¨ßZZ'„•þzQjÇâÙ§aWC&è¥wGÁðµÙ‹ÊàìÄЋҥx“²Gai£ÆBQä·%¸v*ƒ·ˆÀNE{y ø‡ÃÜ¡ðpQ3gë´¿þú›·®ßÚïö#€Šš…JBÀÍËÆõ`X È¢Ÿ/{ÍHœ,Õ3ç»Ö06Š„»!\ ;Ü܆¼>]NëMŒYÁý‡» Pu[Hœ`PC*F3{ï½;½óséßùΧöt¶Ö˜¹¥RìZ 5 wšÃ¨½vè’K€‘ ˆ€m"Op¸t›´øâ[GF ‡îšk©µ…;Ò< xÐ&L'a·W‡.î–—DaxXaD¸I/X.<|ÜœÜyS0•ø´‚r?¸\øqóÌ|ä9œˆ0/î_süÏ®mo³qÄ#¿¼“ýŠB©çžÀ¹ý¦Ù¹pn_YÆG~ßYÁ¹óØ»&c·ùô³Ëoݤˆm¨AóÃaü¶ïÿË/~Õˆ(,ö–Ë°±ÓN4½þú'‡G½vÌãîR"ãæÆ·áô…žé÷áe׌"Þæ‘AŠ!2ÄTN³æµ7­[æÉU*µR@‰xƒÞq†03x1G £2«K\¥¥„‡[£\ɼ¨’T Fø6Ì^ésíÀ<€(¥ » 3ˆÀLªØa&í0›©&›œ!ý-«IDATbüâ翸Ymºˆ)D¤" 0è!!R™Í» Z¢f;jrá kÑT(ŸƒVÒ[ÊXM€àäÃj½>>^Ÿ «&ë˜"äœ5)c# Ýk¹jì—+Ô¬'fäñå?ü{žøö^7#‘YºÂE¡è…9Æ‘¾>=½Ô=vüÆtã ú|¹7 ‹ˆB: +£õœ˜?l&ìµ¾%_½€¶zÍ•¼Åˆ°Úø¯…f €ò§PBk A0<ÂkÓ.$‘o1MµŒ çû.¥^Ø™ymÔ£tj›aOöOnj,¢dÀ'Š»ea ²B7Swê§KÏ_Za%}‚§0À‘D Á/Q,[B—ï­¸ÚtFÅsߧ ìúÅêø ÿþ_üÞ¯~rµPËSFDשn{ƒñá(}Ë­<´ì<òèÓÚû„þqö÷sàÜ~sìÜ8·¯,{×å2vžç»½ö>bT— Zxä“ãà¹ç×þÈáÆúÅž@’nû{Ü{ðæ¯)E<ÁШÌíûݵÃ0®^üÀ ûûûAsd!ݬ ƒR(pæÆz“¯½öBóDIa)ô†Äw#ðÛó.€ó¾Q;|E%<´Wz éÈÍ<ÜÌZåaÜÆÊÑxCåt"‚Ñ-Ÿ)Ûq?ëqµdq <*X‰€¨¨ˆ¶L‹Ã;÷¾ôÒKË´Kð¢,^b”ÁáÞò‹fRcù;®Ïì¯a®3®GÍyǯ®W¸ Ð࣭OV§GGëÓ²::¤N’€M›´Á-QRqbuibûÝ.€!ØÅÉW=}ïÇà›âôÁB’ÀµÉ³ˆªŠ²F}ºô"]ÇÔ €¸J($àëi: dFZl|ùúÿ©Ÿþ¥Ã+ã%`_Ñ`^g}‰Ç‹5K· »uz/‹E5¨Žª!®¢ŒZåÞ˜!@”“ 7÷o¾!n„iIV”Áâ€Ìm(0‡¨d8#: 6ÃæäĦ܉§›õê´Ôê¢wé\¼úü³vc»¾ôÈHªG„S”£/û™7Ö7qu¥ ÌgêP4Æz»æà.€Âm‹&Wª„ÒdZãj3­Gäg‡¤ÐZ.옧Óìî´º[6¸¿­¿o<7Ç™o& †@:c{ƒiŸ¦Mîã .¾þéq¨ï[IZòeú±å¶þ4ó§Ýóígô:Kµ•,ª»Y^]³6íî(MÝÜÀ¸Ô›­¸Ì…WÕr eAÙ¦Íj­L`N›œ Çx˜2µz"Z˜h²Ñ.ôÞ8U_D¦—s ŠŽ¬„™ „1aå{ãÅ®lbÍ®´9óˆR£$îâÒ{7Ž¾šd äÒŸZlz]?øüöŸüÛûùÚ~Ò0‡Yñ’[1Ò< g»Oì\Ó_QPÿ=gþú~ø¹Ûûµsàܾ‚Œï†ë]NßÕSxoÒf¡?ü?ù ÇÑõû Àb¿_Bä¥W®œöè%C‹ÀD„”Œ|ˆ™kâ8®ŸûÀ³ýÁrˆ)(ta0‰Ò€Œ" ´ˆp·iòk¯ß°LNT¥ô_v[+ÏA*!HÞ¶u¯U¢’[¾#Tý‡ºµ xÌÝ€C%ü5ƒ™9×€ÆxžAG!J´üÀnŠ  Zên¡T:y¹Oѳ{õK¯Þ»sÿÂò’H*•O$F!…t^±vãlÄÎïõ8ÑÀ Ãwƒ•åmáB(HÇ°ŽNlNN0Yrí Z;ÕZ„5: •ô2ÃŒÐâa<$h! AÄ.¦.­?û—ÿøwk3ŒS‚À¢HÕ£@õ˜B­ëû”Ò•ÀŠDVø´NÍG$‡ê:ôÿæßú'§›.O{*¢¡˜vë‡ ¶pïFÑÛÃá©L“b.æKMôLX¹rU;Ó œÓ:‚¤…í-–o¾òE Cäð¹ ;§ŒDí=gp§gšQBÔÀXì/mßzk¹\®VC¿\Ÿíi'fI…¢¡ºŽ¸üÔÓû=6s»…G€¡B‡LI‘s^/Ÿþé—ïŽËrV-£X «Vó(¸4%©‚Ð:#ˆDMT Ú0 «Ífµ7# 4³ª&3¡¦Éh¶Eˆ­R¨î¤[×4BK;g Ò…. )uÿz˜ ~9=~ïË'w^>YâŠO€H@ÜЛO>ßqU4¶ä=*B/÷…G)_)yŒÝ¡(T@¥È6vPü–Òš ‡»‡;¼¶*ké 8Ü™­ú(Er§á–QÓˆRh^|\‚¨vv:è¥ÍÍ#ͽX Òa%¡#Ù‹wb²€ŠOÞ¯^8XÉ }õw̲¨”Î' š¹/d+Ï÷†”‘‰0MÈn‚éÙ½£ÿàÏ_œÞT©4-oåM˜·“9±ósf“à#¿¼{ÿÈþý¤ÎíÜ~íÜ8·¯D{‡…õí‚)ｬVœ8ç÷ëÓ”þ`ØüŽßû‡–W?à©ÄJcooïþýû¯¼r-i*œÀj8\jéž»÷ †õ‡^xñÂþÇØ)a!”ma9:è&Ì&¯¾zÝ­‡%¡‡–.£úÆ‚ûV‚}浃ªÿ¾-Ä »|@…襆ÏÝ묤º{‡o Å( §ªÔwöìQ̱ýq&ì3H¨0ÝÍ¥Z– È4Œ=ù…Ï~ƒïqiëT"GÕ™it”™l ! ‚W¦2)g8J»ÓÂkê#ଽÍðŽŽŽ§ÍFM:t= мŒ]Ñ6©úëj§´ªÐ û¸å[*^B¶$™Åûnyxë³ñG¾óÅ y!c¸@„B’ =-S×/D© _ÄœEÀX¯Vác—Ü“ðˆ¼voýþѧÅzµ*¤Â£Ô&T€Úä\Šd AÛ`¸7e‰!ï¨RdÐ ˆÐ”RTG ÎqœÞzýs „J”@aiVahiB,AP©*ÇÍ^/§‡oÙ0jâ0NÝÞòÁááúäd‘î.‰@¿8ÉŽÅòòSÏu.¯'ƒö„Z6•@xéW°ÊÝöøÏÞÆ°ÿXF†—ò—yZ·9ÜfgÁë¨i$E(᥿AM†t‰†¼ÉãzWÆàñ¢#¥ 0åj¢0Èf*Îœ(k0»Ð3 ¤¸ƒÔ …dÐ)Ìkïã"WËW?ýf–i\škHKEr È߆”P©)…¼D8J§‘Ñ€`¨ê=Ío-Á¨! g8=‡;g•^)Oá—1¢jõƬ'„¹€½Þžœ—"Ì"šgÑböˆp÷¬©óM^¦ ›;'ðÎÍ)4FqŠj77  {}±¹ðü… 7¡€*=\U¬æ¾ Œ©‹n<^ùf’,É“D׉èxç÷}×¾ÿw?ÙÙqÎ&zFEµ)v£Jmgþ|(Gð.ö./{ô©sèn¿9vîœÛWœ½ï`ɼ½ûÇ•Lʾ‡ é“;üdò§¾æ[>ùý?8"4$Ì{á×_»ÿàþ~¿ÇÉ!dÙ”ˆÐÝ´ËëáäCy±[&ÀáA!Ã3àÙÍ!pè!S&^~ýFŽ.2D ƒ@Jéju-ŠòF•}‰X½ QŠ£òRæsßÖnóA´(ôpRrÎᥡW2 ðvjhL3ÙzgŸl<ìYb±VPÎ{\aRxõa0ãÁâàúko\{ù• ýENÆ.u‘CDÑŠ*О…M€]ü1î §?v6TVmsJ¼6Nãzs|øàäèÁ´Y'g.E’˜uO#f*½4R|=úʇ˜Ãês£$†KxÕÑ —`¿œŽ|ï·>ùÝßölLw#g¡)<²U°Nh/Ò‰.ºP@Œ`–âà¸Y:²v€AÐÚÙòñŸü/ÿÁñʲ¯!k¨·¤K«÷œ10À†á’§Ãu fcؘ"-|O­W* ŸçDÍyvÖ¤Ötúàéô~d X ÜÖÙ#J€žKkº”°§°Ã;<yÞäétšV#dqA‘w*×Û» „ÿwæLq9 ^ŸãÊ4 (’=$‚ÎÉttŽy˜.¥'^ûÌÕM.í²›˜ Ü8ÔdV˜úên^j[Ëå.¾¶>˜yCÕM± ÕNaíè +ÊÝ[™Kñ¥¹"älø{³Ï<¼¾6žÛ|ŸD¸”¦ã#Räq\èbõÖ‘b/F!J¯Õð4W§"8ZÚØrsá—‡´FÇ0÷Ô©‡‰@IÇñ°Ü…ÄÑ„£QVHƒ¨éž&;¼þýÙß÷üâÞ¢‹Éó< Zd›x˜¿Í¶ñ«Cêoë ¼“‡°›ƒ8·sûWkçÀ¹}¥Ø»®‰»ÚG²µñ®ïŠ'€%Í<”4ö~ôÏþO¬MEôÉÞxíusBŠ 2àN'IQ VÞ/d3¬¾ê#íú>Ä"LEÝœðR…&E$ÈE‘ÌÙ8 Ó0"‡˜¨KÑ ­@¸½¯Q×ÈpÖÒÖª÷ ÃîJ…—l@íÜfbÒÉæt¸Ü?yt}¸þÒÍ¥] ë§ðÔÑ-k Ë{h ê—[¨Oí®. Š¶ ÍRM[G¥«rh9L„4 ÓÙº1¬wplcÞµÀã¡Ut篖GeuŠæ›—(»²,â"ɆØOW7Ž…‘‹ÚS !J¤ÈѱSˆqÊiuðÂå 6\ˆ…‹ÂÜT5ê-œÜ]T=G¯Ë0$­¦‰Öç7ÿwÿéÅÉk÷4¬.Vµj¹Îø3xœýäîã¿hþè—™|e¨YzW5*àÈ.ÙÅc+ Ê*#TT‰X|¡˜‡@ÄE 4 ‹®×q½YÈb1]øÒ/Üî¦^.M™L…­C¨æÉè¥{\ÉFIéªEºÀ‹OVÑlÓ-mUð-È…3eç¶]ËS<³2n¡/«Wùè»Í{4·¼zdz`QÔÊK›B´…jÊ«¼Ÿ.lnj,hR\r…k¸ ä—ªDÖõÁ.®ü”½„1¡s eUtMÒå·sûõ´·[çÀ¹}¥Ø;,Ž<ûûÛ-á;[Úü!±ý9oBg¸9œÇëüÍÿú÷>þá¯=ZôxãÚëÓÓÄNœSd»añ>v?(\ÁR³ŽZÙœRç[ÊÞxgEöf¥w‚…XTÇBµÐÍ…ç/­±fßy@döq"J¯q•.rL§×áÇãžv¶¾ýãà[>ù5‹D³\¼wèa¨ê gúmCñQ‡ålLé=l÷ÅïùúóØÿ¹ý«²·[çÀ¹ý7¾ÃjÜ{çEµ¼a&'ÌÊšÔ@²2Â-ÌCútõ…ßñý?òƽ“1O7^]j’B”* 5G“í€{–½|:~äcÎbèàR¤{`QÄ÷"RJ€]08~ù•×Ð/ó5nsû¬Æ^žuö·8]´a‰ªw.­ؾ¹Fò±êiÏ>´sƒ9[!U×MšðY²°DŠbi•@l´Ji-P$pPúyh›F…JÈ—>ûòp<]ì.ÛÚ)Ðl&;GØP\yH j 0†+ Ž6žž®O6G'¾tŠÎ¥ -  0U”TB’Eš ]g¡hÁü`i(Õ[w©ð’~  !té|RÏFFZ,”WôÚŸþCŸÌë›Ót˜–}¿\tݲ ™¨AQ DB€¤@Ï€FLð$uæRb¨RpÊÁããÿùO6²:d‡LôÐæTmÛ‘ÍX‚  ít•‡i1e5ÙK{Ù%ð`xxÐÜEÔ%‰g U#Š:cP%çÜK¾yís ÄæìÂ+±%Ñ´yVDUôeJo~é¥n²D1R1å¬ýþ[‡÷6y$Q%_Ë`2S•ìß»réÂÓO¥+WNUc!&qÒ]ùG¯>8Þ{bÒÄä8¡³ÔlI­ÐUBY•—"Š‹º–Ì‚–æÏN€U¢K^”  wG®7›ª0)§„ùx²UŽë$É;ÍEQ´èön™÷Þ„–Šúë\ö]}Â*µi!SΛ…÷z²÷ʧnO÷É.d’˜›yD!ºÒR!HEíÉUîÿ’$c¹•ê2°>Kév™ŽUFéÝbß­•Üñ Îææ• õÛÏX§: ÷©|Ž»SÅGë£?½u”tßM¡ f "2`ÂP1Y7ØÞæâ OãØ{Ö»µ,J…žX?Ò}$©L1@×:mL9áô¥¿þïýá+ñÖžjž,Ü!;I¹ŒûìQï>²³b¾ÇˆÅýŒâ™Ç}ðÞrnçöëlçÀ¹}…Û;/’g‚·ÛÈ 1#åúºÆ_·°É$ÉðÃÿ{jS¶÷Ž]OŠÒ›'] s ¤ŽÃfõÛ¾ú˜`–@!r 6ÃÅë½zíõ¤ËUÝHIàÚï]~ìê3Ï¥ƒƒÜñ(×üêÏßM§é1+ +±÷yVSÊe[,饤¤ü«ŠOE?W â",Þ¤:º­nanÊVÍ*ºö܃idL›i\mò%3Y'®ÅÇØ©-!„xãk!P(UDMx¡„"@p)=yÿÕÕ/ïÇU&"¹Üî„K‘ÿŠÂîÃ0m_¸óàV©ÒHD[ïq‡+õ>pg<ü Ï>Ü<yó?úsߧ›;}ß<µÊˆR­q’Ï«D]”w¦‡@ü£áÿ·}÷ûqÎíÜ~Ýì=€sôÜ~Sí' ßõÏf±MÌÒîõ ;H¡¢„;…'9ýîïÿÃéÊÕ“Õñx:“’$R‹.§G“ß!ÃáHa–?ñ5_»šö(”âR§çPq€žÝ3ct¾úú­ˆÞ7¡ăN·Bä` ªVðZþ×€,Û>Š‰/jƒ%þÊ™‰[÷õs¢0xvùÕ¨›~A:ŒwÛu8J^J01œÁR=<ó«‹"a‰µºg‡K/9<›ô—_~éË÷îtW|¤¡ˆp z=Ò¨œþ¹œ¡hó8*!I=“ó0®ONW‡GÓjÃÉ’³ÄøëûȺÀ$HI¢FËtÓ0†•º oß[ÿïd£³íÀ`DÉA „ÐE]$Yb 6† ±r®t¸xeÿò³ýæ}ÿG¿îùH~>-]§=˜ŠÓP)$@‘¢ChM¶W''¢e"ËׇlŒzpõoý¿þ¿k³aØ@sšæ\ùÛg× ÚØá ‡ÓÑ©¯ÖÓÚr–`§ ¡:Üé}`Ž F?+‰Vl•ÚT×-‰¿öê/%ZXxxå£ÕHví \HùÚ:j±X” š¤{ý•—ST%ö)oúNNÖ›ýK®½ñêÁþ2O&ªˆ’g’^“¨ç¬Ô˜€/]}ìÉŸÙ{âÊtåCÿüÍôæôô˜6ErˆhmâºÓ£ö1.—»qËæØn#d1(. ¦ðr›ŠÒ§Gó×èžëÝVn0†kž4»8ILÉè›<®†¼™lL¢èÔ5!1Œˆ\Â%±PÚ>T•­â\9LRØ°YrÑ­ö®}êºï'¿0šk’@œt'à*®,Šxhf1¯q»!|¢”½PZ…öDKÁ½[pú푧wp”¸El¥ˆK 9VÏ\¨±æbÜÛÜqÈ8)iãàÍ™÷u¾ó¶²óÀ»Ì{¾g_ðžI†s;·_«¥wúýEÎíÜþÙC9ØGžÁ;ÎÑy_kAë3¨f+š! ›[øÈþéO|Ë¿ñ·ß99VMe§T¡»)’ö…5JHhøW}ä£cÞ,–iš²P„dí;Û _!S²Å—¾üõÀ'EX¨”øuežÀQ y·Áö ìÎa·ÏnñÜ*Ó¹³ÓìFäv^;dz¶1~‚ ¹%IÛa-ÞgÆ3f P˜(N‰P(ãzÚëÖ§ëÏ}ù3—áSf‚@ÝæN)QÚRO\«"Âî¢Ðé9OSÎy¤—¶¯H e–¾È•qÔγTDŒQx1×TŠa¨£½$àÖÜ%d\J‹º{„E@ ª©_¨¦E—R·XÈÐ-/ùÅE'éb¶gòK?ðÉíㆫ%‚Ô¢-Bü ÊÐdêªw`¬O“¤:W=îªibÿ8þ«¿ùßJ÷L˜ç<À²ÛÔõt3JéÂ\J$^ ”#K¼uzoÂ4Œkñè$É sÚÄ*ò—žKm‚E)ÓŒ(ÎÀœà[ô“Pçæøþáë{W?à!^Ú¬ªœ–¨Y¬pO½š[—:Œ›õ½7ßØþ£¯ýÅaœ‹å°ž‹þÆí·žyâ™ÓõIßõ ¼¶“lY„Ùm.…É“'ѽƒ ¾„^úÚtý¥'>ü1½ÒqnÀ"Â%H›ïdP+`£W€mÖ—ñ f—xg¶G9{©,+÷ °UŽ¶ÂŽÃ4çÔRt{<‡I¶ ˜ ª" RT½äË°•ãš™H s „$q3š^Z\½õò݃'ÓÕ=¶Yi/µx]d{H©»¯¥8óElÄ¿ò—„ƒ¡t–¦¸ÛÕ¤ÍÐw]Pßœy4ª£Ñpr Þ>éá¥ówÀ…F,—Ã[«ÅSËl+UFÜ)¥¿^„y¥0ŽìóÅçöOÞ\‹hfR uÏ%· ”œGJ*,‹s˜,í©½ö¿üãßù/¿ôÿøôm™`.%”3OÔ°wG‡;#8ŸâΓøzö¡ŸïßΓçö¯ÐÎ)@çö[ÙÞ9ò®ñ”ðLeàDC® Ïú‘A)"ã.ÜÛ,.Ïýã÷×ëÚˆ0$I–‚36¸+È |âZºøÈG>:ب)ÙhZä½ðþ½$ f ÀhñÅWßÝóÑ%Énµiî|t³F£X{Ô´Ceü´ f„{¡#”Xš“;€yp¸;0˜6ç8åÓºÍÕŸå©y[¬1³€ ¼v¨ÂôˆiÈú o¾úúõko^Þ»XKn6±¢š¿(ÈßÞS:ˆ ãp²Z®O|3¤ŒT+T6J©ºýÂ&XTNˆTúº• ¤ÐzH4©TU'GbM[ÃV°p컼\ðÒ…åÕ«—ž}öê ¼ú‹=÷üÁO.._éØ÷Ý¥+ù`Lé@Á£öG¾ëÉ=;Ì“'a§@k—¥úV¡W1„À!Ô ØlŽ ðP— BÃa¹cr&×Ëû¿þç÷PBÆâ@8¤ˆÊßp¯‚+¬I “Çys8œNÓhÓ¨dÇ¥¥|áa#{é¿ÄpŸçÄöÎ)W<ˆ2¯w;èõµ—Y&cF•ÐA ’£MÉ–Ø)`T“h*µ5½^ûü/-stè¦ÉRêÆa#7œnVG«£E·p³X„ƒ“;¤H£’ÂðÈnš ">Q/?ûÞšÖO~è~^ç<å1Æ8›SX¤ŠèÂH¨<ô–7Ù  ZÐ(^Rr5—Vê,ª÷ð`nŽOD¨^Äø%æ~ˆP%Õ£åõ86 ÎQuêúÜõ!­d A¸»Š¢4ÓíÌy÷ußè«?ÿÖ^~Š›eFI©Yø(2[eù üg߶¹Â†{ñÛé×Ó›Þy­}Gðú0PÝ~ÒŽ‹Ø¦U¹)H1/T;ZLðMtÖ¯ïœ&îy–@qkYƒeÈr^l.¼pqL›œÂ«RˆhY;=\U‰È¶î•’zJ“.$üîËí/þþÇå~lî~ÐjÞw*Þþ wŸà™ÿ¾íàÄÛý|ÿ°þ<{nÿ íÜ8·ßšÖðù;­•ïº„î¬ÕÛ À ›QQ4(Ž0ÓÔßÙðÿÇææƒ$ÝhY”nNH…AW†.uÁ¼ÜK~ñÅÑGö4Ë Â¬¡"’E§OjaÄ—_}C¤·‘T ¨xæ¾­[nÎ|¬e¿;Á'F+'ˆª»Rzï4Çϸì›Ô |ùŽb"Z¼­ä7`^«K€ˆí°¡âíRæÛp$IyÌ]ôÉÓKŸýBŒ¾”=)"BÉU3"R À]€ì‚šcux¼:<¶Jò‘¢5©aØ|¡ UO,È"'&ó"5ò¤ˆ¨@É*Db@‡°61r¢î-÷®\¾ôÔS?ûÜÕç?ðÄsÏ?öô³—®>³wåñnï"»=“”ÉLqv]¿påâcËå~0wãtã ÿïþ—¾ñEí°é(ª(­ÿpimL^©4Pظ9öð€z‘X¥LD@=LýOþØ/[oFËwà¾èµ ~÷€—ðeÍj˜UnÝà›ÍJ":éERTaX€!2foå­î7ú,Ö©”q2>Å‚ñÖë/ub3Ÿf›tŠŠ%Ë_ašÔ[_a›lxãKŸÙï’ˆÁs§=)9ÇòàÂÍ;·K·ªWŠ‡%óòˆG¸‡ƒ!2Hœ¦ƒ×úgþéÝ´ÿ5߈ÇÝ<†!¦¯‡X±rŒÀHfÂR¹/jÝr§ì¢ÛRÐlÕÅcÖÚ©“)|z¹YyckÒUT T’Ý6“ cÞL1B\áªHE#›K A¹ #Ör%=ùÊ/¾¹¹gK^(¢ ªˆ* TUPwÑ=›¦ Š¯v)‘Íz¤vwût+ìF[š›Û°ý·»ÂóËÏD¾·$F•T®,E,\¤ãÐõÓþx7+÷ÝÄ[ÆŒQ TH§–jxÖ“½.ŒÝ€¾VWªù¾VÈ9n=GžjÙWå= s þÿæé…«Cv 1Ë}߇»&š9„B†‡Jç9RÒ1o.]Ú{î¹g×Ã&-5,J|QDÍŒ69… É–'ǯ]§,|€&Â# ¯ >i³vG¥P”`ùŽ>]MN‡J'£ùjŠ…þh" - [Q3[l«(ùŸ¡?ÔÈŸ€ALÙ:íZ‘A#•ê3f 4€œ6ãÁòÒí·Žôó)ÂTB“˜r©ÒD‘èv82’tdÇqò)è5R>Û0”2ÕRåÈÂNAa“mÃCTWG`QØðÙ cˆ&¦”´[¤*)%‘$$ˆÈ0§—VR‰;G@耇©ˆ¦E¯{ §u¬ïÞü¹ú:ùî¯f<½™`J*4*«HÚ$ÝAMÎêl1 Ýz¼ïfÂd,Ì#‰0‘prXwñïüÔÏÝ9.ÍZSb8DÃ.`@¬pªÍ“tFŽ§ÇãÉ„<¬W{Ë¥RQ¶wGÎæîÊfZv³Ø¹€ª ë÷o~é©g^àÞe—hçm!Éê0„¥na)Ô* ¹ýúËýÄ'V&E'?D˜¸§ý+—_¿ýúóO?†)gI’-„® ×û6Dè@Àâ 0Œº–'>¼úØaúö?¦§×èF ·žÝm²MáÓ§¹ÕÞtNQFˆH­ÎF}š c9/5åÖN­¾Ž˜oµÔ0~Mi±Þ„£³TlÓ‹s­H(¬“™YDh—D¤Sp ¼håðJxx˜viX^Ú»|t}uÿÞés{:Ëiæ¤bîYØyÑÐtÚÒNSÔ¹®†åäfŸçí¢Ý-½-HÆsÚ¾‹»Ðè„Í(ëmû9g/ç!uRक़X˜RuT6÷OõQúm» 5×ExP¢C¸b’“ý÷O®,°ŸF°4Àq«}?""á ï»Í!ÚOw~ð[>üÓ_{á|qZ…Jjžk£R=|‚Ì;î>ÜyÝ»Û#CüŽŸÃ÷üÖs;·_;çö[ÊÞW`¿Ú#ëçÙ5r7ž7Þ™ú_‹ÃÝ ^zþƒÿ¶ß}{5¤åršF)O²‰ª…; B˶LËõxråêŧ¯^¦M×'³Ha›»‹ˆ›‘„•B€À—¾üštrö¢ø)"^ð-‹‡”°X°¡‡zä휈M4*3;¶.ƒTšûÃ#F°`þ™ð3‡ÿ¥ôŪ Ô€0ƒ¥9ج,Rqlý¢z” ÝœýnïË/}I‘–i/o\;5‹08f®EÐ`æqÊ6ٔˑ÷¢`îhëp²Jo’‚&ûMFQsœK{ƒ"©²L½HM•Ôy­Ø È°†ù¢¢x#i…Iä Š:`!Å(-ô>õ‹N÷´§åáôäp}óôÞ+¹|ãOýÀ¦ñ°W–0¯»V7¥ÆE«Âc ùÑŠ5¹WSΪô(^†º9ÄÌ!è3úƒüþÏébÎÞ'ñ(‚”ARR©ÆP,<‰šU'÷œÒ­w6¬Vj¢²4€# uÊSΑ-š‹'ó¬ˆ3žáîÍ¥Öܪâ½Ê›×>ÿÁO|ûBMb-çÖ~Éd™¤l3 †Û~×½ôé_øð7ýökF$‰ÍfZîܼ}ëÙ«Ï: ᡨ›áæ’Ä<´tˆ"ƒª\™pÿéŸyýõ§ööŸ[$Á—æ‰\\\zPC #)ÝÌÌ-‡[xŸ<,Üàî* „æªì  ÔHÌU×ØÜ´r2b;%2³w½Í“”û7š>ŽRÍ])6¸Ñ€ITT•‘Ò£°Õ‚¤¹iJ¶ÉKÝ÷ÑßøÌõg>üDº¼˜òI·ÐÈƺ ”2ei_€ñ@Óÿ‘ÓˉÞβ÷ò&¢Å"£á´8]Ì'»åvcÎtGM¤ß‚ë03M ÏTÐÒðLDE ›r’nu¼¾öæ̓å…<¸I01›,=kG& ÜÍ}Æ)çB:WPðÚLVZ¼°ÑÊ¥¢rNî‹$ aß-(’4QUDYøâXRFQó©!ÞJx¤´ôI!´0 = ¸ ££ðß¿ôÙïÿÆÇ:»Ñ% ìRx¦OõÒ]Âν *Ò:á‘ͦ)²¹™[v³È”°QB‹ãTHQÅ/C­áp†­W§ô|,Ð|®­A„’¡¬7³»OaOšDÈTZŽ»(p8{™¦µ@/÷—o}ñîÞã˧>tuµÉæ ìÂçrVVžîˆÂHôšó)×z{ˆ­¤ñPákuÛ«çóxÉî„Z¸]G0ƒè6>¢æ.7)I²I"u¶O6똖O,Í'Õ€—ÖD˜*KyJË1Ž ¿øâ¥Õ«›.–É”¢$_ÂÝJ“8R³e%Ü8»®K›7ÿÓ?ûoüøÿæ旅糹H˹õŠvÉ—õg´Tò;çße{Û§ÞÓ8ϜۯÕÞv’;çö[ÍÞy)|h |Ú·Ÿ[y´Ç·ñ¹–ƒ&˜sNIïý±?iËËlò"O¸¦Î²©ª»wÒ圗{ýééñ‡_üà^¿ðÈ¢°lÊYXQ¨)R<˜Ô_ã:˜¦‰¢nÒ¸¶S§ â49’ÆÆà6ßN¹a­ˆjq<6ÐÖN­¶¯ñwwvߘQÂ\AKt³¤*qaaÖXŸPÜŽ^ôÖ›£áâòÒ¸‘ÊyUõô’eH…´d1åÑs3$ Ú•¼D= J;…¥P@TE¨JI’’h‚ŠH‚Hº×ð3Jí$ëL° Þj’I! •Á¤T(Ô V(AÂäE¶t%ê»n_äî›×î\Ç»}ŒÉ®ýéùŽ¯t]ƒY–†Ì—jÖd­@ Ü X¯Ž&GÒÎcªPmB¡vS,N±üÏÿóÿÏbÿ‰1gŠh×â’Fº¤À@…Wñ L9áÖᇛÓ$ÔBºÜ}Fw':÷P‘í²¢Ä¹½f*b.Ÿ§S¥‘âž½ïôú+Ÿùª+O¸§Byª³4(l˜REé^šG5àöúk/}ä›>i^f²†›K“åÓÕñÅ‹“I´„ÜM©fÆTªê1ÑÃI“8Ì_ŸûÙ7ï~Çžòñæ2ÑJ‡«væ¥uwIs±¨îl¦F…ÁL!ÁâùqËf9[ÎaÙ=çÒ3®€4­…Û[l=¢ÜµÕ£×¦íhK9Dòä™ÎÉD¡"à¢t7I‚าƒtÙŽýK¿ôÚ‡¾ö9H6j%1jëëùv¯Ì¸‹ú9ÇÎ>€y™ÁÎm}€·]¬gÐÛ¼„U¡¨‘íK%€†CD94ê< í|OÖiº—»ËK·œ” oÜII"cØ(‡û/\Zßb•:*,ÊI«¤Rñ0õ0ºA ®‘¿õÃÿ©þºÿýó%çã„‹hözmÚ]pä×E²]ÕöدÍÞgçnÀ¹ýªím'Ù¹pn_ ÆG~9k±ý¹[Ü6sè^7…–žŒüø·~×SûºÛ§ë¤ËÉ'P“ªÌ¡Ò›mD˜óÔ/ôduø‘}¨ïS.ä]‚Út# ÷’a'Ã,BéÎkoÜ —p0AÊ jD=JH[¼|ö á5ÐF÷)'Y!vÛ¿£I¶°¸³´á;ß0;F;ŠÀŽb‘ù/Ñö¹¡‚`6KÒ­7«Û×o$,z°ÆÔK‘l)ÈÂ#|`Ç0ƒ»€]Haà˜Rö€ªJ’¤ÚušK·åR ¥m-d.§‹Rf*QÜ…æ* ‹Ö;ÜM4¨0u L)-cR¨CºŠ˜£4-„ÁDAhšºƒ~yr|ø…/¿šWG«¾§ß÷»¾æ»¾õ#œx äR^Yʲë¼kP•ÅFåépdHŸ£H£6—ÀM$€.[g‹Çÿï?ùïš =’J!až%"*ê<‚¤•9$,¯r>Wø ¥¾L¼¹ú{³KœZ¤°ª#À.ÕڦͷT ²²Ó"ꔀˆzvÈæî/]zî£.è-¥Û²•B°¢Ý­Ì@‡…¤ôàÖ- Ó2+I0 K‹Õúâû#jm„ˆfËLŠL&ºåqwD\4&ãƒÅSÿòÎéãrü {••,…%½C¸¹ž‘¨ ¶UÝ-JH¾èš·h³ã†šê %R•²0óœ‘Ç°ìa9[qvŠWJ­ÍJ²«´ª›­9†@šžàè©âŽ0·É=º.$„„Úi˜1ðÄþã¯üÂkO¾xõòՃѵ F„PK3oJ-+.µ°sô`»âDÉÄmÑî;ãÌw¨ž'M¼û+j dþ¬r€ä€J›Xkƒ¡i¤ò4võ¡ðÒÕ¡ÄLÜI¥+Ü–¢1-N/,67F;NK,èâ>¹ÐÝËUF„ˆL]={ßõGÇ7ÿäïýæ_øÌ—ÿù+ë ûG©v˜‡h–TÚñx¶Cô«仃ýž´ï>GÿçöëiçÀ¹}%X‹£½ûR9Ãâh1·9n3Ãë@@˜-";û…wË÷þ[·O6]·ÌÙ)*RÔÇ@ W•È¾\,ŽO?üÑwI\LP:°zéZ0–´"K³ušüåW^CZ"‚ôP)*k˜yÿ% >ãǶ-*Ù•I ÉUàP‹xf·®…z[ô-qy›=À<Ž%Ý­°±~„‡Y —¶ä…@Φ’:t·¯ß>=^ïw‘að´Hž‹ŒM0îp·<Õò߀ˆr®M–”ºE×%I¢)‰–®OµÁ½x%Q$!”2‘â·°*Œ¶©çV`=“ªÃfI+¿n P (‰  $záä&b\W§¯}þ¥“w÷„*yt_¸}ô©éþÞo?Ð{}Þ0††éŠr *²,NU !j„‰êéædò骖<¢¦¢¼ð@ "YÓ­Ãéÿò_ü¤W‡É“.ZЀҨŒ°JP !U½¿z0L+Š——“š=#sž¦,ÐFZg=à(ÙnI;î¶^ºDÍí½Ê45TL"À[×_=¸ú,Ò>»p„ÔzÏ:Ç"Hh E³HÖª<ÓãÖ›¯?þ‘mÌTºlž(áC¶½nïød½Xìƒ!P'ÂMµ³°Rh#Ôppd8•Ç¦}÷â§nœ|poo!×iG!tªÔ… $šJá8 ¯øªåfñÙ/®s²M¾üÇ’¡*컀31uÔàr?]î`¥¨À²·Ÿ¥ÈÉÒz¡­ilJ_ð  0Ñ<ª'¢Ô°§ÍDi…$jNš`Ø<Ÿ¼ðüÑk‡'wNžûèÕ¬ƒù¸T13)§.dga0'wÖù¦©ÕÛóêÄCN¦˜×âºnÌ*í¥Û`Å;-Òs=€‡tB„,y,"¥FzDØ‘éåÎÅQ*(Zå„ Ÿ¸Ú{ê` ‡ãB:¥x]x=à"â¥>Ôˆ0Yvi}øÊü—àþ…Ÿ<â6 +m1¶÷JìÿölÞ ¿-^ŸCU»›ÙûAÿ»ï:·sûõ±sàÜ~‹ØûXßvñ|øùºg·çª-Ûx¸ðpËšº·Æî‡ÿäŸ>ÁÔ»dÄpŠt 3O}<ØÜùê-"\­ÄÃkóhYáQŒ”«Ñ^yý†¦½i é@+ï(ëÊj¿/Îu¹ØÙ›eVdœ3îŒ_ÿ‡æ lc‰haËJAa‹`ÍO—o$èprÖ®1ë¤êî m»¾pó^ÒéÉú­[·ÕdŸ .JÆ`ÝݦÉÝÂ="Rê}G UBDºÄNU¢Æä…Ýï0½ê®ÔÖ¤µ÷°Ô¬Ô+UÀ¡¢(jQ°öB…öK¨lå™,¾“04)‰‘ ¸Ã$YÐÅãâþ›_ûìN܉l ¸ÇÄ~8»$oþ¹ýÞ«‹ 6+ê+ÅßU[±q¸æ\‹…N•Óõáh.º,å¼QK굜Ü$u“¤X\þÿÅß;Ý@z'ÄÜ;UÝœîŒèE…QèLFŠ<|ãã½ÓûBó0jŠww<– ™gŽ@@àVPPápMEF¦b» Ñ)u%dѧ˜{êú7^}éÃ_ýMÙƒEê¨ ­°RTAª˜M r›‡wIÞ¼ö¥§^üÃÃ]D[˜6D9Lãr¹¸{ïÆsO>?åN4è¡zd0ˆC!‰JdÐO™‡¾O‘!RVD„“cÝ/!a2ëkmä*§­.)î"%[€"êÕqÄX²z)1<;Бšs¨u¬íÌ´ö«k^s¡gŸd+øµM$¶…§,FµqDñ¥„3ëmÑ}'œ»IÚ¢úUpAa*%1„%qÉk3æþÒ2C xºåˆKWaz^¬—Oïgbó`ì¡Œz–5i¸0Ü9¹(ÓV½Ýù_üØïøÿŸWÁYš9ÚélK ëöó^0ü=‘zìüò>€÷ù²s;·÷kçÀ¹ý±÷Ží¿KÐdg¹Ý& ʶ- @Ÿcìˆ0PÒá:¾ó‡þ€í=îáDÇ1%ED„ ÕÝ•êÔKWŸøøWû4ÉBÍ\ ÀR©2¤@t)J«õxíúMJ? A•cmØÙñ¨j3Ë3#¾œCÅêE°œ3ND=‹-é¥Ò* R8ôÖÂV^Q—*Z„/šsQvé,k™ªPíÂ=r$¦·nÜ8yp¼ì—âBB…á:SDä0Št]ŸTU“&­L%ÑÅGXÀDÑv,¨KD*‰¾d,€RE„ÒÜ¢èœÖ ¨¶v^s¤®8<"æ @¼ á¡gJQÄ$KajÒ!2)Å}ZHZvz÷Í7ï^¿±_fwÔÝsÊÄðú¿û¿õ>´ÏÍ}ÕA$Xz¡•ÁßB„Bs.?2…«á4»kê}§á.Êa`Ö“n5Éßþ[ÿ¬ß{l=©Z°¤[둈Äè”ìá"‡[I×ãJû`„@’³ ãn€0„e4Qœ“ZïXš[{é_”P}QÈ RÜ­ø (-ÃÊ<®…ªÎ£;·¦çŽxp)èDWýM Á¾êJµ©W¦šåì›ÍæäH/\t†Gé/á”+ò8î/nÞ¾ýÌSÏMy‚@(vYv%Ç$Ò én  ƒwíR¿øÀŽîõúàÀ»e¿¸¸à]2Ù@‘Ø1Ï 6.Y#ÔE4iÿ&:ÙnÉráŠO\Êwêu«ˆ°¶/(цFrâŠB!•ì¢KÂé^^á³ìî¡Îpa¢­,˜–ÁRsws a3t) 'ƒ/.¯Üõxý =õñÇÖþ}¨Mb\hŸ'G¨’æ‚RŒÄ­DZL]VŽmîcVýÜI¶±Õ6Ï™–*¬ŸKùÛr¶c»Î%;cíT$+s¶0„’õùtrPŽâgÍÓÔÁˆNᣮú«ûH2ÝŸ’$Ï“Hqð$"t )¥i3v}×~ßw|øgéÕÿê_{yNþ´öx­œhÇv™¦¿{çhÖ»ÙyàÜ~}ìÜ8·ß\{¯…ow­{çEï‘g ß$zQ”„hpws3Óų_õ‰|í'ßÚØrÙå)§>…× ™‹0,§ŽÃ°ùê}|šÆÔ‹[VhÀ"`p/¢”A¸³ˆ• N‡üê·!½„—bB R’Ròëué÷y,–ÂÊnE©ÍªwSj¬@¤&Ê9ÇÙ¡¨¿ ‹(U¼/ª‚D©½‹ÊC*tA6ë šyr«Ó[oÞJàÅtÑF“¤Ù˜=H{)©¦¨už˜ v,è¶J{–úZQR  E èÏ"2W£JÁðŒJÞ­§É–&N… Õ»fñóª;Ã:^ŒÒ-4BeÐÝ虓tʜƃt°ºòÚoÄf³ŸÌ×Cˆº`„í‰j¾÷]ßüÜ÷|òãîÀWʬ %;á ¢ Àˆll8ÍÓ"í[‰qz!/Y!á×î2}dù/~þ ÷N6Xd]t…TU ©P)õ z„ƒä鸾¿ºß/úaZ+;C¬OW^s_$PjÆIè‘ë¡–º UÝ\º¹r´„ŸCDJÌ»ô*(qîÆ݆ùte¿ÿâçþÅ×}Ûï™\3Ý‹Ô €…{@$!g)`¡“9Ùo¿qíƒ_û §sÖœ5 ÄsuØxê÷îß{ìÊcá-)J»aÑ1•›.AKê(8å®»g—þðÍ矹tpr¤÷Æ.dñØ>—®\y77¡º‡É|FÍê±ÒœXÛBÌ·Zƒ™µGDõ „Gy§{¡Uw®rý ,¼µVOp,¬C tCŠ_…âW‘…™¹E8¬ˆ@Ï!J:ͧÑŸ|íV›Å¢÷¼ôs×?ò Mk§*SÑ2BQ-ºGñëÀVµ¶ì<¹w2ª%9YrG-Po’ŽÒ¡bžÛlwÄ;,Þц¢Þ6¬~²•VÐUò¶‹E>#L. D Â䫇ï@xGqƴؤ«½†{Ó^Zb²r‰ªçÆò%Þ'™¦¼ÜëW^þ÷þô÷üË¿ü}}ÜßLÔn„xÙ„g·zdí„ÞsûêwÃë¿ ônçöëcçÀ¹ý&Ú£ýGžÜÍ»âW–8eÑÃf&‘=<»$=Õýø¡{0X¿ì7›MRUó"‚Þ =ÛW}äcÓ8¤…zv +$`N*¢F Ã"ˆÕ8½òúuè¾™K‡"R&jž;aìykD%b£Hu¥¸{‘§Q «º¡ [›Žú<±×±=Swâ(ܔޯ €dÀsP[|1„#´qLëI·nß]=8:X>F£…ëžÑw •ŽTs7LV"•*(Òò‚= ­)z©ÑAPjNcKhe³@T•wT@ àí.×]˜såE›¥â2è^ƒ„5-Â@!š“)‰O¹§îëÞk/¿rzÿ~ª9|Ü$ÊHÀ^×/>éì÷çŽ%NUGbŠ’¯i03*¬~]0,|5 ]·4+PÅG²FûPŠ'<ƽŸúo~Fºåä®iáæ)i¥Õ„‡{ˆK2íhSH%BàŠûÇ÷G›Œ¡Òcž¦ ]¤”"õrêA‘ˆúõæ#—¸ua« Õ”wÊNd;1P6E!!Ófì5ÝyãÕKÏ¿è]rwB£¤´ „v¡cä:®!XwAÜ»yý#_óõp“¤M|Å• C¤”r†¦xp|øø¥Ç,O¢ÅlÍ+šÊRD"ˆ€Nä±öo.žýÔúæsžI÷n$.¦U¯OWºty,cI¯ïš3}+à-öÝœñh"_mNÒ·®‘àÝ[-v9šZQoYÅÚ赪šElTø(âI…@U§¸• vµ¾¤ 7DÀÌKk5·ÈÙ§œ}s†¦.¦îÒâÂ+?óòÓyòÒs ²2núž6åNSxëlÐfˆšý`›Éó/õ´Ë¡F£(U‰‚×Ë X3œ )±å•Ù¶]©Ú*³ïÐj¢X—Ã-y?i£”¢Ë§C(yA]¬òµt“°B¼ò gÝôOìMŒÍq/-‘§(]ÈÃ&T„»¹ˆÆèÚŸœ¼ö×þêÿ‰ÿà'M?¿ÞÿDœ|Ra™iAåáz\o–úý帑ñÐZÝ<ͪåh)14áI–>õÆŠÝ»¸Ô£7U½Õ½•ƒ{«× à¹÷p›¿¨ÔöiíÞž]ˆ¶†H úÖt #Aº•ŸÆ‰Îi=Ù`Wž|bu}ãx}åO§Å°VeÞL*‰% P›Þ–¤Í6–ßÂÛ¬\¦ÙY=»ê6úP¨Èn±D+~Ÿk•¶'¹½×ç)<¤­Ûm‰+BFânÕ³‚HXŒG!ôÂpTá®Rm2AYjC‚æô¼ðîê~’þôÖf¿[`šÊ•–<*JdB¤˜>vaü³?ôÉ¿þ“_Àòéì6—yÌg>‡,êæònö>3ókÞÓ –£ÿsû5™¼÷KÎíÜþ•ØûXòv3ñ+XîZ6Jœ4ÃŒGc|ø×ãúÄà^÷*ÕÕ¬•"l¿ß{ñ…š ©cΆçj[| s •P3äx5¾výºHg9DK$µª€U)Qaî|˜5̆Ú®ïô@Š¦ÚM° “£ X²ö.g†×(GárE€¿`‰x*Áµl†@§É‡1Sã¥îòo{ñã÷¿ôê—>ý™§¯¾@[dg¤Þ¥wôÁЉôÚõiÑk¿”®GR¨@‚P:½ˆzZ¢(¤{“È)‰6Õü™hPò涕a’RPÔÒÂœu‘s™«)¡ÅIÓ#ŽèÈž”)_ŒÅ._ùÅ_¼ù¥——%"ÜÕ©Y }ÂtýG¾ç¿ñ£W8:Xºj¬|4uNÚTR·°*+¹ØÑÉQJ}8Q`+·HnžâåLHÓ½{›»÷G7‰Òò6g†Ó]¡Q«6c¹D§2&äÛ‡÷@ óq3lNW h)ð­}¼ð×gPÛ¤ÑXPÕÙÛ žÅ= ×èv àÕ!ƒÈ”ǃ¾{õsŸº”(ÃØI¸™C=C BauÉÙA2ÜRàÞ­›‰ ¼\Ó#ŧ‚ aaªzÿðþdî^îÃR¾\¸7RÜ_’ÙL„¤Là&u·ÿ“ã½{O|ü;j¸º.§.ß]O÷NÒ É;†VY¢jȲúuX%C£9Ôí¹‡Øà»kUsÚMjÌ34f‡bǨÜ0Bªn)DuÂ…¡ÒUœ0ÄŽ›àýºƒ8¸*Ï ¬®<Ö={éÊÉË·âÖ¸Ð+CP–)—tb°ˆ’±ÕëH†ˆKá#±åéJþΪuD0¼#ÝNógñqëDÙ¹1c›81ç#ã¼<÷Z½Ó2x€¡½8êpÜÁzsñêZ‘L‰¤‘ÜcÒ.ûÏ/N±B¯VùÑoý7ÿÐéTªx=]?©€‰†±ß[<ýܳ٠‰æ.µ¹OEG5NA˜¹gå*ûk·Þ v1…¤•ú²Flm!ÀªGÙ>í¹²=Æ–Û0X¥Ø*apw)IÒj5®NŽ†õÉ0®l0eä,–Õ‘%LiTÍ•IC“‹„ N1å&"yôÛoÝú³O^ýè³/¾pñÙ7¿píÿÃÿßæyå”MÔ EEEDD¥$œU1²y0PP8ý˜±Ï,å†Ãj=Špz!Q”ë5²^r.1 ÚÏㄨª¡mj€BªÃ½ªYB):º¹;7q˜]N‹;¯]{éç~v1åi3"/Ò$ÈêÙ3ö²è|øί½üÿúoÓé.óJ1¥zÀ·bNÁ¨Í+’„)O×’aÐ*³~†Å[(EA_‚Ý+_~] Ã\ꃑ©pý¡9¸ႃ(ä%·£Ó“l>šmÆÍ°B|ˆHÛ6OØ-sOTÍ5{óN7Xì îüªӈ͓›_اåÕH톈 É!ºXx¸´bü²ËP)åöëA³Ò²™d™&p”²jF˜Ùr¹w÷Þ §iªjQµz4$¨PNPH¸ˆ÷IlêF<ñjúàß¿žÇK¹Q7Sˆ¬l|óÞÃrZÂÔ”9Ñ5b.3j9Ií„ÐPð#h>¯Âñ ÁRÊŸ˜*èáê!“O!.'O+³“'¾øO?wôÅû‹Ç2¨ÝƒC‹ôPK¢ôT‹mɉÒ2š”H(C-wC'P\÷&¸ ¶¡›U†Îžã<ªsУͲ ×fo¤ªiL—ΖvqâRº‹µ¥„½KÌiá}r±½1_^í}`q‚S铇€5™Y²¢Â@ö!~ûÚÿê'¾ïù‹G*£µ*™í*>‡¤ªc×xÛeèWm¿¢ ‘¿Æ/;·ÿ!Ú#Sìœtn¿ñö+dìfSß׫ ¼‘€ ‡¹SºÓâ‡~ôOÞß„j*¯H" ˜9í·^Iø<˜Û›€.„„ôÝh£ÁÖãæèdµÖ(õÜQ†º"lÙéÁV àŸÎ³pð˜/#w¯Âö—hQÚ¨H.ÂÑËâÕ/îÉÁž|ök¬WiÑ!,;ûår84!5`õºAÖ°Íé±jGѪ”U˶‰p`š,uÝí;·ž}ê¹)OZ»a±a‹LaP‹ÂTäIRZO@zü3>|`s÷õBŠU ápÍè±°¶>^wOôÝÁbÉX|F§b–¦™áþ ôæ†3RmOÝ]9¯Wœ&9OÔG2,;«æw8r3þ䜌ÙùΗ€$\™ 'A{ëú­'÷Ÿ½ñË·rŽÇ¿ñù“Íý+ÃáÊ7Þ¥¾K©¸¼(‚HsÛöDóWóª\6aŽ@—º„ät‡;\‘J&§œ2Ûb¸34ÛÕ<¢Um—÷¹|¿¼ „ⵇC€—„};YA‚5PĵÀ™;¦DÕjŽðèÆ؃Volº¥ggPTË™’$"›…0ÙE»õÿ¥ßûãÿÉ-‹çG Ñ®.=tUæç™èÿ»§âÝŸ~h¼ÿ}î=¿øÜÎíÝí<pn¿ñö+_°æµö}¼uˆŽÂ+-+ywâoÿƒ?ÆKOåfªK—sÀeѧÍêèɧ{òÉÇsžR§a¡”*‘áNžF‰ÙC(ºÉöÊ›7(½›‹æµ$ ‚ H«’R”å Ší^×è¿mŸ/ñ¿)f¸»y’T4j#îÝ}£X—'¯I|† ăæâ&žel1NMÓµcu=nîÝ¿|pù;¾îÛ?þô {KjŠtïÆÍüSï’w:x>9ÊÇG 0Â+5•î¨'*•›óðè·?K o»¥ÉPy„˜ÁNQ9¥°4ù…”€5Ž¶Í—›5ÌHÏÄ>'è=Ì3è¢ÈÃzOÒóµÏ~öËŸþôAôiTŸ<:†€æ}"ÍÃÕÑeÁ…~)ãþä|ý‡®vÃê˜DLàE½“A©”ƒF(>QÂzÜXPPÕà+hi^l4í’&ºAÅ¥ûÒË7CúûJ´ *‘w›⢙ÄBVãúæ[·Ç< ¤øGõZ ò§·•¨ÎVÔ9V5ŒÒWa‹ñšO¶½^úÏ`lþ¸"$åµaµŒf{îÝ}íÍ7~ñBŸcX'e†k·4TB К‚îy:º/1èÕ±,#Ê:>(:R·©ëîÜ»C‘(! ˆ{)îà„<¥Èê®Ã=MyØ?ÿOïvúm† ½k2At:œ ãtg•¯ûëe— Ñ!áí~,ÿZK­v½ºIÖ6÷·y)F›¢MakûâhÕ¤»?Kd ü;sÓÔœ@ãÖ{Kvaie€2 ÂÊa3 ,¯íq¹tïÓ·ïüì—/\xÌ{O]Ø{b™V'Æqb$¸N9GÑœuÒHK4eFLæÙ-»gx‘VJnRÇEcZYd¥©Š-ªß»C™šçØvjmçZÏ:b˜‹ê«ZAq <æîÞj ;f> ¢Ð O€&2&‘P‡DæbŠƒõ…쯸A§ gL½0.=±”N6·¿í…îüžOÈtT²“­¡ÃöBïÜ;öˆˆmè=í}ïpg¾aöÌÏíÜ~ÅvîœÛoŒñ~ÿ•}ÀN„èáO™±aÍÎ (æ\Møð7}òù¯þÆãõFS?NÈRÈ+Ф8]èƒ/^ºpÑ}¢zÑØð°9ò溄q:ص7o‚j™E_E5±2’ÏüÚÕ­­Ïî¡×c}qÌ(¢Š’’Ý$4\Žû´‡¢ _åÖ¬•¨†,‡œ”…y.<„E$<Ùñ³Ï<ñ;¿íÛ?þü )¯„y¯_ØäÃÉÉßþsŸ)*».csx¿/’h@¨ ‰ZÈQ$;gSIhÌûúìÔÔGMwœ ‚òKcùïòÞaÊœI Pz!$yí´À> Í4çÇÒÁÝWßüü§~ÞŽOd‘7ƒ¦«!FgŒBBSVuééÞwãÞïûÎç¸yk™¦¤Yªvgõ9.œ«àŒõ¸1ÙÍâ ÊÓöhË{  ¡CM»W®Ýp¨¬M‹J3`–¡4ú‰Ë1M“ù`qýö-óps¯ ?•wíZ4L¶l™mU|´rËmÕ&f$öˆ¦IüÅ‘m˜”„»{i˜€0A¸ ž½uýõ_¾¸×—E7¹Q ZºhÑK… éîIäöõ7Ä]Kcf¸e ¥í.U¤¤ñÆiÆÁ¢*nº{9*3K¢Œ@O8„ܾüá¿s#NûèÆè»DõÈfya]·N›+Þ·>'æYŒ¦Øæ2´Sßµgnãøv6Ä-l\¼š– ÚÁýí-mh÷[õ@jL¡ÜfÍ G´ yAûE.e:€‰–¦ã°A$uãzº¤—¿ôàÞϾ’ô˜^ÐþñtðÜåtQNÇCGî´6Lƒ“¡b=sGW‘žLÂN ÊD¨@«´B ‰2Më1,à ˆUFc´0|œmvò°3m´‰V¿S ÿŒr£”O”9ì #¤³ýxpÚ:‹B²d …‰„jt1!Älo}ðƒW\t^à .U•Âi—Ýb<}ëÏþÈw|ÍSëÎGz)w(Þßœ Œ]/ù½Œžï»Ú¯Èà#¿œÛ¹½/;wÎí7Æb»Û½»½Óó[¨R_<¿ ©àOœÈ]àòSßòÝ?tü±§Çqͤ×oÝ0[™PQû);àRÔ¾h"–:ïÔÕSžöN/~è±[¥~—ÿ?{,Y’‡ß9ÇäZ•µvW£ô‚¥º±¯$A$@,&’ A‚#E I‘"mF6\F&™iF6¦Š4£Æ†âpHB€ˆ…u tì}©ê®ª®%«*³2óå[#âÞëç|óÃýFÄË̪^‘€çýê-ñ^Døõë~Îw¾ï;"Z¬¥TJJæ ’éèÙ¿÷wÿÔ%^ŸIDéa(+׵ѩéôzð…ÿ w-„{>fõåÙ8÷÷\úê?:gãwhÜ«Pú*?¼c¬Ëë÷~Øêh­gõ0„X{›öâ/žp&­FvUµd1<¼þu%kT‰(RUŠÄˆ·ÅHÐAÉÀý¹®RZwH*ÕTO*öT-€ C±n%#c¤»z¹Õ$Iª¢žC¨âr|p¼8^6Ò˜›ÒFi—²(ù„P©q•jbQäXC‘è?~àÊ…oùÚw½áþ=‹8s¨#‹nwg÷ÿÃÿ±½ $¢Ä^éàÖ­ÒA7#ý žÌR"TFmöKQ¨Vc|Aéæ[^]±t6 ;µT¢¯[ñ{JîU¿³ñKeö´ôB@a×ð´D–"Qz¯R£²ïfl¦ƒ>ÿ©'¯~ú3»6m²1gQ7­Ö‡Á¬P ”?afYú¦E3<ý×ÿô·_j»‰-RZŠ”–º""bFôµ©úaXö½h+Hcü£ëŽŒ¸® Æ¾($0Í—‡‡ PÌnäGRôî*ì}ñæ·=:_œ¼týúÑâD5¹—~½!#ÑHjR^[ŸŽpèF ZR2!)\¹|–§«ü–U’½Î 8¾üú»! TöD”˜$èÝGÏæ£æyš,iÁ÷K/ᶠƒ€*ØŸËyÁœEJkjaHT4¼PÉA*”}ßïîž¿vízÓ´áᨘ“A'2K^L’Ì!9¥zù·ò¥Ïȃ Û )Ú ´ UÂC³MóÔoõùƼ[ÊM8\$ Ž\(‹¥,´:°BY¥k<ÿn¸w3L«[Éšõrº0†•§ oåÆ»;—;žaeéXPIAL–‡Y˜ t:Tú®¿.½ø‘—†§öíbXJK·eàPÏËôþY{β¥ÙžD@Ä”UȽÚiE«¢VQE„+ÕÂb‰è©Lc¿Úóä.èæôàj“—Q6°±EÆYþJDæ”[< O6Nà Hí1Xu|KÑÛÑù¯¸4÷…&«ÄH„ÊŒ µíú+ÍÉñ—ÿ t×E „©Œ\ÅZãäÎ7ÇÕ¾ð0ësþÆä6¾¤qV8¿;C6ÎA¹÷·ñùmh¿rÇït)–ÝdPcßåßòý“‡ÞÒ+˜…Àà™AR åò =bIÄ"ÂËZšOF„ à£ÕnÆ©™÷ýSÏ¿„4ÉN5‘Ñ;HCe¡ðŽ×[}¬^çˆ @D!Ó— ZÕH†SiË“~ÿÖ÷LœH6+o *©w‰ë5‘&²–X+™;ŽÜNÞðÈCßþÎo|Ã3/#zeÊEš -r¾pîâOüÿ<}“©¤RʈĈ£9éÔEËñåÕß¿(uPõ4KâŽ+ÃÓå`GäÔc×t¡••Èøƒ1£«Â ‰¢2,m­js+ˆÂ‡ÜÛ°kO}æ¹}Xy†²äÃCÄKŒÂ OÍ©i1\ÿãß~å[?¯q“>ÀÒv´Ô<ÆDBƒ€Å|Xt>¤¦)}{Ç—^¶!ûàJbÅ_b’¦Ÿ½zciF-Çw*FÀ’’/^¶ÝË“[‡7÷ökIª2g,*•©h •ë58†V²þ”„èjYnÒ6‚KÖìãB[ÕŠ¼*Á€’e¥pÆòäêÓßn›â\%j€–gˆð¤ánäÍk/Ã#Ü0MEê.¥_[‘q(8 "]·œmoݸu#iéiE¬šèX´:è„¢y ß;÷ȯÞâÁì~Ï&a‚FhB1Q8!AóC¢N–Ò¿¼ˆëÞt„ ’s J½:4Ì„:Æw±®j­“·;¦r,üŒxöX8µ+®`ÞñÛãMs:Á(Ÿèx·HÀFo%Åô* pÉ0éúî¾éåÏüú“ù¹å̧eXG;Bsˆí~òЄçcÙœ MŸÕ‘Š ¿æM²z›¬l)ŒSPB€¤)÷‘;RDª!—Þ *|e¼×k ¿™V¸jˆ R‚:ÀxL¸íûð#I˜ªU¹ @–DØ«º —2†t{û ºdS3â§$¦á“¤º8øþw=ú½_Ð<*¢Öþ%“X1=7àz9ýÎÖ©Á­ž½ ;ËÎÆ6΀³ñ»6îÚžV¡ü=‘Ž×ØÍê¯ÔÚ°¬À˜‘\®䈰vë7<þßs°œ'kƒpGjF‡¤xìÑGMiæ¥p)íÌZ gX¸PdÑu/¼ø’6“!ÄìœÊ•Áå‘#8ŒÀÈ’/¿”DB@5UÕª (9gƒÅÀÛ·öº“E#­†ETôxuÌh…®  ™ÑB.]æ_ñØë¾é«ßuÿ… Cw”‡…èdf5ŠöqyëüÏüø¿œßÚOÃØB kn£ƒŸÜ¼U2’±ûX OK C‘ŠªuEß5+¤ðÎ+Y½U°vÆ CâP89E—1·U!¢6hS09wu2¿qãéÄŽvl¢C ²)«ZAU!Qú:‰†A`B´TÄÃÛ7þÒŸü։ܞÈ"éPZ´Ú¸@JSi@K©‚ÊÅ°p§è„ÔJ[Â(•X FËÐ’ãYjS™€m ¼}ê3×2TÕt½‹œ 8ÿCèñý½½ƒ£C2|Ìw°P#€U8†•›#o|…«ŽS_þÃZ=ØÈ6®ÔêN”ûòÊVåz®ì.ËÚA¨ûÐ>ÿì“ç΋bÒ_xu£”¼(ì…<:¸ðQ 5I>Šj+X“À<¸¥tcïFjS5uwUCˆá¥}¬p:¨T9æäÆîë~ýº÷Û,%uLHÇ €FŒ‰Oš^>ѽ¼ÝÍÒ0qj6É‚¢3©]{£ê¬Wyë¸=ÉfhÆÕtŽÿyíHmM\}cýqýÍ;dP+Y2«£ŽÖ¸FSU! ³n‘ïk¯<ñkŸÂ M}C$Ó¢EÊÙöq¡Ÿ<”pɇ鱧…6‰º>”+uó˜µ*Ÿ²iDФ•°èÀ DÉ™‹riÌr6_ûx)Æ){µ#a ü”"¡£Â*ë„»8hxÐXÌÜÕWK´&/‰Bk0ñÎ¥Þö¶Þp®O=“ŠZ0¤ôCHæ£QóÛÏþ?þÿÑ£í­™y8…a2öþÞàmÔ/ïºÞ_Ìø<U6VÓ«£gãl¼ê8KÎÆïÂx•ónóx¼ót»we€§þ³Šh¸ÄT³{Ñ#Ì~àÿŸîÏm;É9¦Á•döðÃPÅ-{Åá(‚,@u@BˆÒÝC±ì‡^¼¦6‰šDQ=KF®AWM}(§_°T.Ð(™ áªJ  54·oïìï'L” ¢º ¼Õž£A’©^ÿp I*šLº8–vxÓc}ëãßxùÜ9 o$¥SÑ ÷;[;¿úoþíËŸ½ºm3‰H¬•ƒÁÖš—>û„ֈÅØHG¼ÔeýN9’5¶¼ûHÀ«9ظ”¼ë¢Gª¬~ydŒ«Bª¶ÑPzxÂt8Z>ýѾøâ®4©·ˆT:v9¬tãªÞ;dˆ„¡–o:i3=oOý×í^²?ž‹/Á®úþÅœF”Em\ËÁ´£Pk³jSÞì(®]5RRFjÒª„h 5íGþÃ'··Z2Š›'V3!SN›î;¿ó]‡GG*šs@`b+jøœ–Œhã.ºó&Z RuV•”j@ŒiJ}«Åù¦æ¥÷V½¶B‘aHÆK]Ñ„0 ‰Èýq0¢r j /ù^Rìß¼…ÈôD)ü!ChJ7÷oZ#Cîad0œ¥Ïîj¹’  ûrùã~ባ&0E (¥(1Úûˆ)Ë<áÄ4¿0Ø^ÛøN¦ †œÐK‹Ð%<4j7Ápr}ão|/Í)nÏjܹCr™¬òÝÍÝr•¯®îFÒ,¤—Å ‘º£a¤€­'ª¨/ùÐìáÿüÇ°·ÝôºQD,13A5z×#ݙϮ¨^D×,²3ÌÒ´ UÛÞ]ÀúIˆº 5(æ.‡Ò,Nj5ú‰ðÿôƬÈ_°Þ–°¶´¥á6àûL16 FI!2±<‘.M±e]JSíÓþÖc;}»tФª(M3eã©ÿ÷ócÓùsGõY–¶ßëXÿô¾tw²ö*Ý—<ÎPÿ³ñųàlüÿcÜq<Þ½‰ñ^_Êi˜£Hk”YTŽ%Ž‘\5íwéýÉÿø Z5£+%H‡Dˆ7)=òð#€@ŠºMelbÉ1p(àry h³\Ï=µifž!¦VD ‰` U¡£c}GGlU*åº8Ìcd5€z„J²°“Ó½75k+S:t4Ú©Ó&%:—¢“MË`Rѱú‰J~ûW¼åÞö5—·Ï Ý\˜Sa¸DáEmDÕ£‰ô©ßþè§?ú©sÍnô®*”Âs!!ŠB<æ{{šx¯RߎT§†Hº"öÙ{–w8òRî«Vg阌™Ø:QXËVD4MR!{o¡Ú /|úãמúävX3HôYS] ÐÇ*B«UB+•J õ*Ótqyôá¿ùç¿å­ô²Ü3éDp v -î•£0±èO²»H • 8¥cPß]qž) 6#´}îÅ›óE"¶Wkv>ô᧛¦1³(†S(,f †Jˆçw¼íáÝ™÷ý"‡—,,ª³J½ƉZé¡ë=sW°YÂÁuOâR`5¿\±6bƪ¼,—eƒæ ,±>GÎV±…*W‹ a {ш¦DF¡`1¼tÈVDÄ'Çd&\@€.£d¹…TD ( Ò-醼Xvª–û¬ª¢¬}ËB®y¨„+{»_ñÞÃÝ«úÀ‚­ B"Æ»$U’{.êßì.9µý”û¹ñx뤙u-\Ã.Ù™MUŠÂµf°w¡õ\Ý w|¼×âß|PÍ67YåcmàP¯¬~¬ÓΰÅáRac  -Ò¨öÇùáÙë>õóÿÃî$Â¥°µ$÷é(¶†é}m:/>í]jÃ"ìeÔþÍ"c_wó`qÄ`êêCfïVH—M$ÆÍ@ÆéU¶úÓ;FeʃáaœÉ‰ù!5¦N„ÂéDˆ–ÄBƒPB“v<Ùzô‚î¤,ÚRüTQ±¤ì“ÆÀG§Gë/}³.njÛbz‡ °¾2ëD{}­o¥ÕÛx•ÈýŽoÎrÑÙ8_èXßJg ÀÙø¯Žýß½ÑÝóa›fól#oÄ[‹çJ'x04oú¶ïÛyìkJÛ:={˜ZDwnš^÷Ћ†xîªÁÁ§‹¢Ô+ãbz´X¼ðòõ¦ÙZ28”2ö~-ai±a…T;ÁU»¢É¬˜$áÞX{r|²··7,óDgpCˆ™­q2¢æ‚ ˜6å êÚ"%ËYö¦ÛýW¿éÍßüŽ¯½¸5a^ª°”Ý#Jy]CP7¤W^¼öž_ùµsÓïz),wŒ¡m˜dRUàCwt,ªƒ°bi@±©JàÍ–8Ñæ(ß•MJ;×—s|ä ½síF_ԊЮcPÐCS–]¢L¯<óÌÕ'>Öžœìú„Ë$TDˆ@£ö?+©TgD¡ip]HjÒn·xæ¾åÒ·½}wX€s-v†Y$D)`uå‰n(çy™¦‰5T…H6‚µ@UÂZüMçîÿ{ÿÿÊéB—ÍÙìŸt×nwLh¬¤nBœš UPö¿ï¿ády‹VÒÕbS%+rä TÁn¬Òâ€ró6ñ×Úû k¥õèE»F7QØuÅǪØM®î@JBéEøU ‚4†’ª}äHPÇ« •Ÿ]ÿêí7*o¯4ب–Ê*ç»2çŠJÐIÏðv2¹¹¸|¢É‡¡”—‚QÔ¡„0‹ÂN$RD¾rþÑÛgW†(f¡ ɾ ”.¶(>ÀŽ~Ў^\âZÌN&–Õ©—ao,iŒõ¢5Z1f¶+†Ûéµ>>ì”5Ъ!À:qXAæwßGõ7ª¼ˆ”Èð.*UH(¬VNRZ À¡X/ï›]~â—~«KyH)C s´œxºsÇíƒLêr¶XZ7HH²Ñ©Þ¬UQò:ÅÅŒ4ÑÄı fÓ0J„zÀǼQW†?wÎÊúýmÎfá–µc ¡’â Jyô‡CâT¢5¤‚ $B:h†º( J÷ÔbàQº²eç&²6âN±„Y³ôhÔüðêò=ÿ7mMò¹TŒë«§yúUŽðÇFÎwŠ(ö*ãÕ’Ã{wŒ{bigãlÜ1Ö‹ä,8¿Óã^[Ò Ý‘ïÈ«|À*ôâVÐèòÂÁ#ØS¦=úøwýÀþ¼of³®ËyˆI;és·½5yä+YetÜ)ÖÑÁº_¯Hì4„RôdÞ½|ýºZãCñc¡ªbµ•×]:Ý«î¬ ×«×^ úÄÚ¿BD!JUêÍë7ºygLÆÄ j1ØðâK1¶áB(„»«ØD’E8O¦[öÕoyû;ßôŽíiÓå“'àôzK ÒX¨DF•N»Ã“ŸûÉw_š惪a¶z«BÄ¡* 6Ò¼üÌgÕkï!Yg"PµÀ¾Ó«`êÿZŒªn\ìUl´±8Ö@j ‚*¾’*$%“ ù\šÎ_¹ùìÇ>æ·αµ^@CWÁ“Hm¡eQ V^•jˆRozøðÇþ£wN†[[Mn›PõÚIXZfHË p™»´A[ù¡#Ît¦J »L´F M;Ý?ž~æÖÞí¡”öåë·Ozõ,$ñF*L úü+ßvþòåƇŤirïb2š¥ŽËp\]#/«¬O]½õ¬Ö Qÿ…r6~?³ ÀÙøŸkÇ“ À&²uÌlõ—ÆÞEãƒ*J9ÂÖTee¨ íg÷}÷Ÿý«7Þn·Ã¢ ˆMíxq´{n÷¡‡í³W¯èb_‘§Ê}–ÂV.-6…'‹îêõ›Ð62Ô Î3²w@§¯¨¥ü „Ĉ^—J¥Æ BœÊbXé ܾµßJ“¼±PE™ 5ðÊ·ðÚç^<(ŠI2²ôðÜåæ_ù–¯zó[g“¶Ïj #¬Ø®ûD “Ì¥·îÿâýÓû·/õÇËÆl¥,&Œ!^hî„ÑŽn¼ÔöYcÕ›5)%‘úøË+%Æú'ï!ù‹ÑÕŸ§ƒµäT´`þÂÐ úB.^SÏÙ'2Á"æãÛ»ú⦩·ÈDƒl(MÑÀ‘2^/!¾N1D¨C’îrÒÝÅ'þú~ã¥-—8–èL(^có&ÑÂü nXv¹4ƒ®Ã¶Ê¢)ñÜFð2"¯H©”éóÏ]¿}s™½OÙgŸ½ &¡ˆXét UFC5ßûßv´8¶¶].ú”ZdMDOU6b=Ó+:P÷KßâÀ˜®‰ˆêÊ2¦JR£¸r•¿ ¢MÕôOꨆ¢−p&ÑêkE@!¥-Z©m!²J˜ÊëŒFuqtÈe×½øÙgžùÔǧ‘¡ª™9˜MMhá b‚Ä€¹hHîxnûÂõýërXôÑ•L– H 4(. Ëir=ÝÿQ¼îãËé0sµ™¨yµQõ6‰{ ŸÚþdù\Ö›Íd1‹°Þ‚†r{–àw# ~µ˜Œ÷ü¯µ{®oªú[§Òæò ®ó+¦“ƒ…R•ÂUóÁZç)s©Ý€ÁY·ÅëÃËïyj’îË!0a©! ¼‘h-£ÔFO0=Nûé#m\êí"!VJ‚BIP0¦‹µç³’ ­ ­ÏË$ÑBÄÍ™rH.‹p½}ŒÙçÆiq‡‰(1R!RÚôAëwR4r‚|»o9ÑH,³H€†‡ ‘H¤aBVKêÚéùY{a²d'P 3£$ >Y<ó÷ÿï?:Ü|:™xŠåѸáÔ«¼ë²±±ùküÞÝ?Ú^¥d¹ á˽~ôjOÿÉÓ§Ãà D—Á±Ë7þñ?ÓÛ¶M4 k1råþK—=çb*Xb 2À‘‘ÏpŠÎ˯]k3Òí«Ê:KÉŸ U¬ÍƒPà¨*š\ÃA‚ˆ@m×Ꞩì|ÿÖí¼Z™r!¥5+HšG¶.¡N ´USæ!Ÿû´Å0.ön¿r­U’žÔ’6ž³†Äºð´^tyh'³ë7®“µ‚43g‹‘C)HîÚ‹Þܺò¾ƒÝƒÉë“RKq©uÊœ†–æ Aq˜«#õi7ïÆMÎ_:±C¶ÙX²yÑ‘R¯ÿZtïÍîÎ;`,ŽÝ·Ý„¯·ÓÕ}T—™h)JX7ïE$"WYyy)å*Dh¤‰ ½ïÆÅųýч¯7¶5`&‡ ˜¤!ˆP Õ€Û²·#=Ó+­í2§9uP U gmÙ+«ƒ(3aPiæIáÂ1„…–åKFl¨ü×{ûæÖ¿NqZ¬·öˆæŒåHÒ˜¬3ßÏ\Â$ÔRÙ 1’$¤—‹íôòÖ`š(KÕ t¶ÖXøŽøŸýè7çùK¥}^ÒSäÅõe–;þ{çvêÁŸcÈ«üÆ=ƒûõN·ñ+giÀÙ¸÷8KÎÆ—w¬6 Óǘàt8t¯ßÛL î2d,T@SFP«@Õ"is´ÀC_ým—¿úëçážÃÃM­[Ì}àÁ‹;»@€yãe°Âþ€HA­„ „éþ|þìµë’&T­QÁ`Ô˜ u—8 «Ð²¼‡xLˆ+ÂÐyV3cs´w4ߟ§˜˜7âšÌdä—Ã@ ªDÒæƒ(5™ÁÊòѯ|ãW=þúûHá½jiVø8£"‚ BFM(EÜ8ï‡ó/ýø?úqöô“¬r]Ô¢PQ¢g£“Ï|ì“~Ø50 Cc³¡¨¨µ|r›¬“++iêêÌf¡‹Yì*;±·;Â. ‘Lzj0"[`‡ÍÍg>ûÂG?ª'bšL XÔFÅ”šž@ª}$6¯‘H”¨„AT™&> ½îè?ù³_ÏØ£gQ/!3ÆØž"„Fˆe?Ïž%%bãocŒùeÌ@‰Bš§Š“bI$eX‡öý¿ù©”f·÷:bêl>þ‰çR3-ý†T‰lȬßýCï:Zjk q€×.˸ñ–)QT½+Èw|i5«ï¨ À©p1—ÑëÔÍ+BÑ€…j¨ÒF~S¥ƒ)tU$ÑzCJ±Þ¬ÏEA­…¤*’FkO±Q©\=–,òÞËW±<Ö~ñògŸJ5èžIªZöRUTdˆ>²H‘²#÷!ÍlvsQ:#¨{I¡é .â&YIˆeúòöëßs´s0¹2ˆ™ê(ÅÉwÍs“r ‹„$Ñì}ÖLõ!:L¢É7úÅÕyZ6ê:0»UZa­ÉÔpv·æêéïœÚyúË»‡¬²²&ä€hî=÷ ¡bá1f •GgjC8Jµˆp*µ#/°f%lÐ_W'⨠àjnÀ;Šåc×_P¬QE5%Uw[Æ.'ݽg>òáao‡m;}P}÷#´^•™‹*›FhJ™ÑêVŠ'þÎ_ù׶¶R—,¿§Hºêq,btýÂ"SÀ AÆÆK?6£,ÌUÛ¤@£‰.€JÚ~þêþõ['ý ×oˆl-{>ÿìõIÛ2BIC(`Zà‘+öo¸¤ž“i aFUÒªüR1S¬?[¿žQö UG;ʲ˒†ALDäÒTx ¾6‹e­s¼ýFºüJ›;&"(Ìïñå…°æíª’Ç¿Ìq®J c~xè݇žo½2ßß3„ª/ë9÷ È AI=EØÁá¾YrV[½8J5m¥x¨‡‘ýté#“G?Ú]\èVÏ>*"P ©¯6O¦(•€G˜™(Ý2S¸z hòÖlØ=¾z¼¼yÒ椞H)ƽ뷷žÊÕjYEˆŸ0tµém|~Gð!D¥´ÕV¡Ü^ˆ«@£hŠN§!nªåyUtÐÆú®¿2{ø‰_ú„Ýž±kÂl¬$•”Y‹õe}âbŸ@=ëI—öq¾o¯hs¿äæ$ÒTÆjë,îL²NEYö›h$7±”~UÚ‹ÒÕ¤¾ÍZââú¯>¬o<) SkDZ2åó¦¶óMjÞò¡z;#DD%Ñpªj’„ðÔè KîøôþíH”’ Ô†B¦¤‚ý'þûÿëÜ/¯LÂK/öêò€Q^±ºåîºn{#Nñ·^k|ÑAüYô6>Ç8KÎÆïîÓÙ浊_-ú¯Ñãšk%¼&á!”NþðŸû«G¹Qk<†årñèÃÛÚ%ƒp#r úcUK­AG¦ªû'ók7nZš°ðþk&‚RÜßj¬[s©ˆ;ס.j†!qDÐ'2‰eܾv‹ ŸJ‹ªTÍ¢’š ¨Qx³ÍTÓ”€ÀÂÚîͯ{èßöU_8/±L¥O–±ù1(aš2V§d!v”ô&û/í^øÅŸüÙÛ/Ý´^%¤mDP¬¡%N%cm¾D°€¿B"!l9\øÿégpëhǦý°ÔD-h®Y¬ë!G3ÆðfÌŒÊüÔHXÁ£€Ãé,v¥ @²{(³jßçI´iá/|ô“ϾpžMêÍ¡aNta”vR°  ¬á+zn‰R¥àÑÖ+Ô]»Ø~ô¯ÿ™¯zãåλcÈRªë?FÏ+“™çÝbpW™ÚZjY ½W'þªcj=è…"¤ ³˜8SèÖ{Þ÷q¶[!ͽ¹G3_æÛ‹¦iË * ­ÜMêäøû¿ÿ[s·H¸gah ¬äÖ؈ËWŸŒ÷ÊêîYghUÙK 4"Ô,‚±ÔxvU-sV :õM‘R8ÞërN¹Ž2ÆfÕ´¾ ’‘•4b4lB¨“Æ­äh%hªI‹‚‘‡IcôÙéùåçžnL†˜ B*§í„>4M›ÝEÅÃ!."–ÉfžãÆþÍÔ¦L ”*Á¢¾±…14©g`¯}ôýû³›x8d‡ÑûÔ¢þî¤ã ÚoEj(¨Œ¨Õ»RjÓš½­q›PEúHÇØ™OV\ÎÃdÈJ¨!`A—dŒl¥²®ˆ$êýK—Ø)ècøðèClÏfÁ,aqà—­ŒÐÿx¬ˆg¨µG'ó—®]›43ºˆ©PT¥Vó±N?Æ ¥QpÕò ÊÍ " ¦û·ö‡G[6•¬AJ+Õí1*O=TBe!bÔV$x¼³£o{Û¿î-_}q{æyn¶Šë¢˜” ÂPð=]ÔŠˆäØŽtÝÝ:÷¡÷üæ O>=ÄKÉ=Ô´`•¬&þP‹[6F;K:Ô%*qÂóœ}ü×~ý©ÿ›jc]02Åé±Ç'++|¤i•qƒÍ1àC95ÇðUÄê!ª’Ã!ªI"BÜg”[Ÿ}æ…O}¢íóV¤èÝ,àYk‚R²7*Ù ôo;mÂQàê±myg¹ápíû¾óÜûÖ´ßkšÉ*S¡ˆ ’£ŸwGAµa2 2ÆìæÔ²¬Á^©ëhxOqÚdvî7ß÷Ñf¶Ó‡\»µ?8oß>캊‘ƒ¥¹Dh°û/éÛÞ|Ùó"‚fQJ4 ¢p”e}»+¸ùôW£þêI+D)˜PBˆÙ5c%­É‚ GÍpk*²q×WBpP[S—«»Ê¬iŠXÄ4„¨Döz-â£׆ƒ}u™A³†„ꆪžëÍ u'ŒCdµI?ÄáÑ!J5cLËKÂ#0B—¦8ìÓÞ…7ÿÆþì¶\ÈIõMEDÔ4ŒVZ”ùQ—¬ G鑽Éí¶ï¤C9zá  Ó˜H6RKÿl¦&c … ìúŽØNÖó¼¹+w^SYmƒ5ó+vI‹^óqöá05÷])kc£$Vò ¢x&ex“&Ëýxpöº'þÍ¥?׈T4#Ÿ_0º•ù‰’Ué„QDs¯ÇÜíÛ+š. ·ËÁ:*U…Œõ{— H’Í;ÎÕË® –P—Ï*¢¾{…¯üpë#¸Z¬$T0hƒ­þÖ0ó0„€AQK9£ÐÔ{Ob`Ów‡4 %E’¶ìs“Z÷ão~ÛîŸú®×[> w2JC¾‘zúr¼ÖßÝP‰}~)ßç~ØkŒÓ‹îlœ g ÀÙøÝ«ýç5v3Þë‘õG2âB(Z/9Äi÷­¿þëÿÀA?ˆH2 ËÅ~d·ˆ„°šs£rfjŒ(A@mšû·_~åÆd²³[*hk ¤KŒ¿WÊxÜŽæðc¸DBj @íxÿøàö¡º¶œEMêÊURDl4C !'jÆ,2¿|>}Ã[ßþöÇÞ°=MÙ*jÚxA$+{¢eŒrn€»dzˆä³Ù䳟zæ·ó·¶u’û®i¦gñ`M\jT£‰Q(dy!ÕI\sò¹˜ðêÁ¿ÿ?ÛÜšog“€ˆF}YÕ³³§X‹£9^\n°ÌKžTr—šÖH±¦ÉÌ9ç)Ô÷ö®~äC~óÖ.'Ú @ItñB‡¯qeˆ†jv»–Î_ ˜_T¬¦Q|/UÐwS÷ØÎs凿8TëÁÁŠÌÑÁ(®9FÈyÑ-(!¦P¡FÕÚÊz®ä¶÷d÷Õz"®“k¯^»¶ç.©Ýzîêuˆ½ôÒ+d#Hjš"É0Ä­ïùã_Ýu‡Ú¶ “›!¤÷CçÑ'õÔ-µiÖë[Tª"HÒäΤíN³­VHE ÔJZ"_©Zòq­—[¯fmu-ÖÒEuE°*A`T¯HE&jMuŒ¬ëƒѤ´\.’ ÁìžÄŸêÉ)LÈ̈`›š¼X.[¨8TR3BLI x}cÓý£Û}ßŧ&|‡&-ÍzCÈ éäí³é‘Xçæ ˆ"ALE¤’jPÌnYït•0õ¤a >p™µ°`ä)SÜž=Cmò^&_£ãÔø¾Ö‡°1§6Á¯6ftãûu‚Ç¥& Š*³š½—öÕ@˜‘ é±f¥‡@16¢ÛEÐ)ž-».EeyÛ/ò“?ÿ[S{ º‰´30À„XãâƒÖ[LB%DÝZªI7´·qñ¤}$šrÞšwz–T–¤Aj¢ ¥PÂe(~n†¤.±t(®Ø|—¥ ‰o\Ü\e§øx¬ÞüdÑ C]´ÜZ¾²hd+†BíS¸Aè!Ní©¡".pÇ€Iž<°Õ¥.’ eÒL;6µÝþSÿå_ýî×oÝžiøàD‡[r¼ÕNÝÿ¸×Xݲ¯‘ÿNÄëg9ÀÙ>ÏàKI<ÏÆÙX;~œþ\6v¯_Í Ëæ^ÝýrxøÎ…oÿ¡?wkFU–Ëã7½áÑVEÄ%òHxöbû=òþ‹hN‹ išë7÷nÞÞoÛ™!* ¦j_8v@ª½Ï*Ú«ÊÝñ»U-ñc’¦Ÿwû{·™½A«aÄ ‰hˆ$g¨H#j’Á“î?ÿµ_ùö7?ü˜Ê0`©FˆR$bthYÁLb)ËfT› ¨AÍeÖLö_ºñ+?÷óçÚí¡‹¦I9ITI +n#M¾ø·€(vÞT¨¸*Œjæ°._ÒÙGùß>õé`ä~”s®A&bœcD¹;ÌãÈB^4ªâË~‹ÍtÉ—>õÄÍgžÙ‘Æ_æ矿fÚÒ³ Ås’bKé?à_ùÆËŒœÄÊ»PÑ1¥TéÇÆL®ÙG›7Î:')k^D‰@¹›ì½¸×æ¬ ñ 1®óU†F@4ªRWª‰çHs¯f½#Ê3+”Œi®³UW…Hš¶‹NX¹`ΣŠVÔqrã,ŽQ”îÏ>Iiqx¨ U­¯¢J¨½&} Û[_¹uÛ ‘ YŒœÊ,¸ %BÄ—Æ—§>ŠŸîï'÷‡“ôÒˬVô€ò^ÊëÖ„OdÐÕÂ".qËiË·—¯Ì®îã$šH¤1и¬·´ñË{æ+°„wýhóke)ö’О¼2_ÜîMšÈTÆ錴ț…µ‡7E*|ÂÐ<™Åv»óWù“=ØwŠ¦EJõÆiü„½øÂRLè:ïí0o/Ò}2½Òúd™ÓÃH!B…(kéªÆ÷ÊFÑxÞ² ,¢Þõ³ÖõToÀjÌ0®ÀQÜ%¢`e+…dmŒKLõâò•!a‹®œRl«ŒŒ Lj(L&–5|ÚÍÙê“k£î¹…É3Ñaï³ÿýý£³åsÓT¨@!uå“å:oÌú«QŸO ~Ï#óKgÝÙ¨ã¬p6¾,ã /,Þ± Ééwý±JYIwU$ÙUô Úïü¡?—Û]W6ËåÑ›{C+…ÅܵPtÖ§/+#W 4úòõWöO’Mcµ‚c#jT±!í¡ j„T!X£ƒÜC%ѱûör¾l1QOB#Lƒ’GYp¹ Í‚\@–\¹ïëßñ5]yÐ̽h6cÂ…ëQŒDQÍQ`=@I ¥ðè)æ7å̓_ø韻0ÙíN†Ô(HS‘’~ˆ¹¥Ý Ï™Ò .Â$ÔD±bݘ²$ÆryÉ&ÏðcO¾ï·¶Ã"g ¥Z­x)•T*7¬’„18^ó+, ž€¦›Ï<{õ㟘œøNlç^ØÂS¦åzýZdÏÅñG¢tc(~ãÕ  þACi Ø'Urÿ;¿éÒW½u¦<`ßk%s ¢™‚\æå|¹ ¨h+ÒZ4'Á¼Â‹DQ là´§Bñ²zQr²ó‹¿ò~$sbèÝr1<õMm˜xé˜ —£ïÿoÌ­MCΪ¢²Äß"2ÖÚ²ÚÏOÝ\5)9™Å]·¦þÔO¼÷7ß÷™åq,E­V·Æ¶zeP/ÁM%uqÔ­sÌë­î?,ª«¥™í¤-ùËH«)b„«J¡÷Iz"_~öÓ;Ó)ƒA¦”(’Ñ7³¦÷\…<å• )H@ê–y:Ý~ùúË–R„à …Ã-ƒ-`̵¹:}ð7»óWqqÑW½¬Š’Q¶ A¡]±PØIFÉ“B P‹] ŠŠ‘¹L°InO^žŸ¼´°“Fs!T…jåÅm¤ÊàxCp3ž–SŸðŽ+[¾#AŠY¸š4Wo_=žÚNî¢I-‰(BY®%:GQÅ %” ²€¥ý™‹Š‹¿ÜíýöÓìæ0¦îµ9T h„@™Ì­ñÔFc Ó"ÏNÚ+–îKyƒå0¢–UBF•Pujê¨6B‹!¼sq@-$\=$\¼bí‚1M…Ò•}_êhaòQÈp±ÄyL±½¼1O¹Iш( †ˆX”&ž$T™èe(rãÛnõ: %” bðáõÓåÿå/}»,®©GñPŽ’e–tªm}>!÷FÁî'é—úsããOz6~ÿŽ³àl|éCîu4½ÊËàx^¬pã ÞŽ?]=F0n従Ñ\oÈ.ƃ®ÿš?øƒíÃo=ì‡élêýòM¯¬Ñäè^ ÁJV2jJP;ÃzÕ®¿róèdž´ L€Ñ\j[ûñ€®NãI]-D„5ÚÑÁÁáþÒ”V9¦*Qì&´ØÎ! DŠH°Ÿ5ò–G^÷Mo{×Ãç¯Ð™ËjÚA•j`R‚…B4 Y»¾p“û!"K -B„’ˆwÿóµÛît‹!M+0&$J+4-íZWÍtH€…ËQÎÏÚ’ Ôˆbh)¤ÔxŸwtæ×÷?ü ¿ÔÎÛpϽÉ?ÅdÔTU4-¨¦‚Zæ¯ l¹·÷ÌÇ><ìíí YŸY”¡X]D­Ñ‡Ö)X/1T‘Vx+þúfMÈ4?ó¿û¡wͦǭ¹`(—I¤¸þÀÞ»åòD¤˜¢zQ‰7\“únÆ£»"’‚Mt> ”®zóöòSŸyÅKØX.»n9<õZÓ6¥œÌ± äÍo¹LöÁh›R¨áÈ$ªŸZ)l¾ûõ¶¾¥ª2,”tR¦vù?|à™_ï[ÓûæG'óƒýÅÞ¾9èE ªZi0`1ÿѱVÅŽÑ…¨LûØ„x|557T¥Âšx•p EÜ\f0.*AyûÚ Òw&lyÈŒáäàs¯"QEº@]ºZ’J²<Ätkçêµ—µi<\ N‡ …™YLð’eàH¶®ž{ýûö§‹G² 1¸{©–¸g‚&)èõí­\”dhaù˪´H**3ÙJ'vòÒQ}¡j¨™E aK/µ1gÆòéÚ©i½'J…c¥0KÑ!arøòáþK'Ù–lšÉ08DT5à•ÀX c€ j¶\ïø@AÁQt2 u6ìÜúøËÃÓG‰³¡Iá±®TêÙjÿ/È7µÀ‘Ä .B1ªXô$fËö²Lïkd+g;q[hr®èþugEˆqƒäÁ½s¡ª(µlˆQªDmw2–kJýªVâJòY8Šˆ]RBÇ©lw·—âU…EÔš*Ê¢–Rö‘ILØÁD# B0è Žoþ‰ïzû÷|Ã}ÇžZ—Æšßxêà{­±Ú!_íG_ÊWùx6~_³àl|)c ú\Êæ&6ÆJë¸SR¸úÈ$A$@¨aP @å°÷Ë_ùÎG¿ñÞê—;Û³ÅÉá›ßðº©5Š°•4:>-Ñ"CÉ^¼~}ÿd®ÚFPEµÖ奈Œ±Â°ÔÞIˆŠTÓ:Õ¢Hb''óÛ·÷èÒ CT "HU£“á"PÀÔ6³xËÞøø›¾ê¾ áKW4 ²DUt°b ×p²ý¨-ˆ‹ÝÀÉA ¡šU{笙þäÿ÷§Îµ»ÝÑI;1ä@Z„‰è‹½Æ#W[ª%Æs±ÎÝXí&³&¡çIöó]þÄ¿}Ï­O>»Í&rÀ& –¶J(½²X^6…Bw…€ˆ (\8Ä ®²ÈÏü‰›Ï¾°m34È$Ј…Š‹Ò„V9*c4T×I‰dô)¤¦® ¼†½sºÉt˜ðïþ¾õþÙ‘÷]p@„Bé –J»a¾XœˆÂL¡„4ÆàžÂê´¨uRtŒÒVÛiAvY%TÌ¡ÒN?ðÛËP%UT-åÌ“yãæ‘B Šìâaâ½ì}Ï~Ír8’¶5 Ü¡$%¢¢­R8EÚ\ÒªM3PŒ¢O)bõÂTÚ î»;}ì£×~îÝ¿±3¹4ŸÏMa”ÅñÉþ+·Ø‡8@Щª*"FÍ/ÇŠS‚kǵ{\EjôS#bÀ±=ÚH “¦m)PÕññRK*…*ò©P|¸yíj«Â5"ºN}(þ?ËÅœµ¾æ *†ÞÛéöõ/·ÖF¦˜(­«]9zµ9ÕÕ#ùõÅ?x{¶´  ,’´)Á¥Â ‚>Vþ¸¢H•K72EA`ÎÁ)“ñøùãþzn†6(ƒµjp1ò‡ omL£Ô¢îGcGtä.‚LÒwÑêöµ§nݺºœÙn·ð&5Þ»@ÁðpU-wMÍO H%4,ü9€ªZäÄA€>ø%»øô¯z¸ÖXœs´Ð¡ðQ¦¼Úü+5¨$ûã¶^þ:Q:E·¡ ‡Ð#ŸÊ}¹yXãRœL—]“ÝVL‡„ˆ ³ ƒÙT4ÄJGæRsŠ'cJZêÃÕ“­<÷X (µ¦š÷C3e&b&2]îuš'Ì&hJ‡`¨024ˆ --Eȃ/1Ò}ìD¤HH)b»ÕþÆsÿÕ_þ¾‡'{m (‹¼.ÌJlÛ,é¼ÆÓŸoþûgÉÀïÓq–œ/eܳ°¸1ä^ŸŸþæ*¼¾ç&´Q" @TQ’9bçÊ7ü±¾5ÏÓÙdqrð¦Çm¡*ϲj÷„(qáK€¥‘ÒÙ´íÕ—^ZvËd­; äIû¿q+/±TTP7V¨vuHVSôùöÞ^^­4â¨Ø€ç!ˆG(ÑB-\ìÌš¯}Ë[ßùæ·íN'™óÐ~4Ç,øYŒ¬ƒ š)@A¾ÇÎg%¹ aHÁ¬Tip^šûWÿèŸ5.ÝqŸšä9KW£¯£œ9ŠyKÉ/Xcõ"·kÂ/¡k5Æ e\dsëO~êWmk¾œäˆÈã³”ž£5@á)<~pÈMp6pÿ¹ç¯=ñ©iö©§ ‘ ¸l$O€±õ[AØF0¼F£ËPíÄ\´¿,^I4wíSÚÙ;üÔýÈãßüÖ)—É`*f&°Uô0 ]ßu&V‚%(‰ur/~¥ÿ_Kþ8À¡#î QË®Íìü¯üòfÛ燜 ,fïàxÿèDE"gÕ¢M¸ÿ¿úm!{‚’ÕE„*Z ßŽñ02êõªÅªÕ¦HŠFi»Ó‡>ðïŸú—ÿâ×ÎoEô‰5ÿºDŸ÷†“»\ˆ¨„1ÞŒ2ÞäZ>^~¤¥(污Ȭ+h#×›¦«A²®•Þ±Õu„0¼^}橆fAô]gÈ'‡{ˆó®*l%!Å­ae­¨ºGûG‡ªÉ‡\,,B/VQÐp’!LnèîGõÊ vÇä2^ಲª+Ð:¹c»•Ëª¤XË#ÄL!Rh[ÜÒ9|ö·ò$·êʨ ù¢vËZÔB RÚªÒ¤ðÔÕTÉœØ4¶ŸÿÈÕá¶ÌdgXFÓ´y ¨V¡Þ(užË^É×09@* EÞ "šº¹ßßÞ÷É_ü`šïÄ`ÅLªŠ0^>®gF¤Z‚Õ¥Çdhæ-e] í»yzÙÒùÈíINK6:ò+¡” Œ¦láæ}DïªÔšdIÙµªÀX¬]/»š‰²êR (áp5‹^¦rnysйãó/qðËú×ÎÆÿ&ÇYp6¾Äñš»Ú=w˜Óß\ÿw>vU(ᇌá8át9vùŽüÑ<½ÐLÛ¼˜¿ù Mµud"À`dYñWBPT¢!AB˜³K²g_¸: nHt˜I±ª–ÕË)´•–µ¶ C*¡b&zûÖÞüxÞjcnˆ"¤“"jš ƒóèü¹ö«ÞøÖ¯zìMÛ¦‘ɨ¡ÕFEQá¨.kã«ã’¡Ú  ª$£®ì\üéòSq2Ä<§V„a¦¥1ðh©QFçzd1c¶QŽÔM1[E€Ëá>Ö èÌyÛ±uÔ}èßüÂÁŸÙÍÉû@#1F0«p&†N2Cf1]\Ý{ù£Ÿ’{<5ËlâL9,ÄV|…pd®sŽ¯«f%äjšHDH„AÕ0 A J zù;Þißÿmo@,ÁN“3Zj]^Η‹Õ´ØLÕD‰w@´ô]Æ8E뼂±CudœUknvO>õR„8tè3Éédú‰O>=0 áQpR‹Áæ⇿{1?¶¶XÅ4¥,©O! ‹é,F=ò::•ÒÓ b†­É•ßü_žø©ùžó[価˜Õn(¥Ÿ~¹\Íó¢ÏóΗ*µ²­jÀX3é ßV3Ÿ€W¡òJ0?fq¥³DÄÄš¬â5Ùø¬\ ÓÌ ‡îøðäö­T©{.áóý½Tãò¤^ì_(l¢ÂÒ‡H“4;8º}²f2cô|Ç–Vï˜@A«bZ¹àî‘5°ÍoúáӇܗ6OCdP/­¢t^& Í¥E¨†I(¨¤R@BzmbðAc+Ž›§>ðRÛ]˜øVîФ†NU«)zm²†ñ’ŒÉÊXOÙxãPl‚ ©F%$kÒþdxýìþ'Þý¾fq>–mXw«Õ¶1¦œõ–¬ Bé¢\ÿ¾¬bqQ×&RÚ2«ÎugÑ<\’aꃒ4E %Ð/9Eh)Ú4$Ì)½*S))BPE³1ª€ëÛëž !I”òH¨Zt>µí~o®ƒjˇò7R¸¦Ö·Ò[£[1„Md!oE{iÍ€VúÌ&%Ë7Xÿ³?ùMÝŽsý+Ë£öÒ‘41a.lE’.&€›ª°ðsȈ(=©˜6>Yì>üÂǯ]h.J§ 6šòu߈(÷8`Œêm æMk±¼°(£ ¯Œª‡¨=IÕÔÝΗyß ÿîㆠýàE©[ý‘±âÿœÂ¹ÇU9¦ãƲÊÚkK@ËC{ÌsËt é"b{èÓÒm(ÝÃb¤ž U£ÑœÔ›ÈÈ#DiZoˆq‘­wíU}c<`‚*Qn¨`„š²÷Ö¶»Ûä.µò¡ÅA¨”J"ÔÔ{OÑzûÈ®ÌRj'Ñ÷Û–âäú_þá¯ûšÇ˜”Ðêk*/Ö’uõèµÆÝÇãê]}>¿þùŒÕß¼ÇÙ{6~ŸŒ³àl|qƒ_À®Á;¿”»¾WÆF>!#rѱ$<îâ¡6l]yüÿÐ~Çɤyý•û¶4Ê:"oŒ"„Šá@(³Gj›'Ÿ~Ê ‰„ÔkôC!Z¬Î‰ ,-nªÌ¼õÊ+ÝñbªÓèKÜ'ÁJÒˆp4"ª½Èü±‡îû†·½óÑK©Ð£7eBX… eE÷‡@I¨¤.eurbE"ˆ"TÅ|~ñÜ…_ýŸyïÅk6”Œ"É}Î9GЇîîCxŽœI#"½ü#œµ¯O¬Ð°¢½¾.AÀÄ‚æ¡‘»ù$ØÜ>üä¿û•£g¯n÷’:7´ ä!/§Ð­W?úÉ[O?µ1ÍMŽÈ fZBjíW³‘1N\c`5Ü_©F"~yÅ),I-ƒKf2;žêoü…oyôRæ1 &D™Á€~èæó“H“ ªïÔ”gt”vZUýºªÔB͘¥cÇhÀ³§Ùö/üüû¶f;>¸Š©ZEìÉO=+n­5ƒ{ÓZÖýøSß¼\h;ÝS’(r‚ÒMZiQVKIV¦(u.j£$ˆ1™^yϯ?ý ¿øÄÎô‘åq¤¦qDˆˆÂH"ô0Qƒôýr~r”ÑçÅíãXêeÝïÍBNÓX–š Aj³æEõs—ê\*p¡¶MÔ&c{á‘®mbp÷A‰Þ|é…äÙr—n'|~Ä“£©ÈäÉŒ’Zr"–ÜÂ`ˆébèwvνróÚrXªØÐeµä¥¾*™ªЧ¸Ö^ü­¸ïI?·Ô‰5ic(±`IèP‹=«:À¸¡Õàn,ÐÉȳ©ÄÄчÙ;c3ëg‹«óÃçNšnjÞ:…&+„ð,]$B&ýA-¨m·:e#G¥ª 6­5b7í~òþôÇ>ž…;ÂE¥×f©œ“ð]Ž!Â#rDöÜsøsžsî³÷^ÿ îCDvr²á™ƒçÌ ¸j˜)7—UwchÞtLÕY¨‹B³„l‰-C—%^‰yÕ·2 êéA¬*™Pµ‡—¤b’v—{½úDÝA ¨j0›4 †Š",9<ÒB¯L:‹H) Ûáèçòßü‘oJÝÍ&)ÃSY`ëÚj™â ÃÜï€ÿïŽ×Ïðû³ñEŽ³àlün ÙødÃón=xÇ¡P<Þ*C 0`á$CóØ;¾ùá·¿3+/ílO›Æ #HDákÀ© C#„T‰Èn)}æ©gLôeö‚ÍTt[Ã%¢š‘‚ô šd „*©[ö7¯ßB'S™úQSËa£ Šd,ÒD¾âõ=þöÇï?9{ ©i‰J”…’?jW˜1G ©Uˆ¼‰1–ždå³jPÂajÍËϾøž_þµ-™xöÚj€¡ $¢ ÐÒ€©B |Æj^ì.”<ò]¢ÄT"ŒÈ"!pa’}’¬2x 1dBJQQñn¹–_¾ñÛ¿ôK‹g¯ïgÓùäà…›Ï|è¾×oa‹]„’›($£0œâ¡U X§eƒ‚4.–ÕjáÆú!@Ô–d2„=4Ïœ{þ?ý³_;“=zV Jdc`>^̦¥4´¤&µ&ÐÂdÑ*¿,6áge‹iåƒD(2FÁx0Ô |ðcO2 Ð<‡˜ªª;#4²JÛè$kÚû¡ïÿ¶ùÉA3µ"fP$pºDá$€”D1tw©u‚ ‡¢D„'»ð±^ý¹Ÿ~ÿýÛ¯ëN3µ$¤+EiR²”ˆI•”¿¢Þçádi!@öîèx8š·4B‹Ò•BKk_FdS-:…Êxà — ¡Ò†‰M&!³zË‘fÊÈJ N‹n¥Éµçžæâ€Ý‰©6j\Æñž°¢£x£8¢,+Q Ib˜¤éû¼³sþåW^v€°âfÊÒÝ¢š÷Ô¤ã8¶÷vÞøëWcؽ²Ì]Ÿ;Ô £ oÍw¤V.Š=ÏÆ}jßc]%P–bºI(Ê`ÏaØIÛ8Žýgo÷7û&¶ÜÅUiêæ¡îš‘èš<Í7ó³yáÒä"–Aº©¸»G®TžœÝÏCd÷œk¹/œÕ(ŠšEE”¢¢,1Q!’˜ ""™qy”rœŠ‰ <¦óÉÍO¼Ô={,y2h¢ÏqƒÇ˜®nÊSÈ÷.ãìˆ (fÑ$oÚ0c[¤Ýaz_£çÄÛÈæLNse@ƒF½Ñh É»Ì\ÌNUÅH–´M E;„Q'S*ÎP¤z{•Ø$ºôí?ø#ãʃ÷ïìÌÝÒ^:õG@eì…J[ÏÔÒg?û\ÓL˜QHÏ °bí$CËZ òŸ1U¸7bêzrp¼¾½wó嫈š‘Ñ„ßzñ³[ U"ûRM$"¹R¨q%àŽðÒÕ *>Èlzîê‹/ªµ™¥;õª›˜Œú~ôj·|zãÜ›?|«ég÷q2«.SZô9@Ցƪ"4P£ÛP ‰ã¿B£ŠW'URÜÙÃFä¡ÉÍ·‡ýþö³7Ò±Nó$W"‘¢y!^¸ýÌágöw›‹ýÂ¥©TL¨žÃÝÇÎeB¥Ø×>‚±øPêFåóéªzñPEù="d ÂÃf=/ð¾gßûŒÝPï%'òªJ‹éÊ)Èz{YírwŸcŠ‹Rщ"ÁK?4sìätIÒE÷Ù"7'ž:5Ò½ljfhGbcéÇ¥=U…d÷‰²ÛŒi*€Pöý´Ùîö;´š&¨„»¥^E Õ@eÁV†É• ³sÜe»MÝÏü7ÿùŸztk" 2P[IÖ7¹ta,×}aãŽ"À—úßñ7e57gã÷ɨ÷÷—eßëc³˜ûêƒÙxàúw­¶ÓØ?Æc´>º¶×qoLCþÄ_û›ËÉtwwÛ†ÞU8D.…÷â ·*2”î¡¡‚hÒÓÏ_…µ1(E S_DJ!ƒHP!Aq•A…꜡]îŸíxç ÝÔ,Hwgx0‘þ¾ËçÞõŽ¯yÇß¼Ý4áÀ­Ybåä(õ¸]cBƒ‰u°r_Qe1ú"¢âá* 5€‘¤QáOþ³ŸØ¶‰/z-‘ÜØɦø™ \ ñ0€k‘궡¨jÎÑþ#—d}œ¯¾T„BÚ`R$¢Ò¤”ˆì}N=á~ßÎÖy±é‹€»h@BŠƒ …×+P¸H¨T÷¬^ózm¬q´eTæHDŠùaЀ‹³µùðÙùÞ×?þç‡> p#00œ9Ç¢›Ï— BÃò$röù°<ìûËåqöž¢¢IaJ•Ò‚¬ÒÓä–&&Šžº··è²¹N]›e¤ßþÈsšf„º T§DMB@ê„M“wÏßòï8é¡(åŽ~:c‰(´"A¥Jé[FÉX5 ÆØ !‚h'~úÓGÿâÇß·;}d8‰d&"Ãàf ÕБÂ0u½×Y †”÷)Ò÷ÝÐ÷‚Â"Luq|²<8iÓœ˜¹ºL!‘ #Å1Yc¨X|cD¤8¶ˆªi:¬OgI±dÌýX&A}?éêKÓÉV€ªÈâÆ-9<±ÁÝCSʃQà$n ¥ÚfVŒi÷ííÝ^zQÌ|ì©Ah.%eh—“½—žˆË/ ó,—õ SŒ-Õª~¹nÞ_«‚ÕÊ@«|[™%‡T^¥$Q÷Á dGŸ£3Êg‡/]=n³mç Ï&<ÿ‡¯w{6ÃùÅI‰CH0sè†È®XÝ·ëÚËÝ­kD«›œ,ÝÁÖ±{MÏê‹m‰çUqx€Ã|¸"÷ê><]l3&Ñ6¡ˆ¸"¤x™IUïŒXžþwê(©bŠŸ‡8%Ê&J‚Y°Ìé0v–v™z¿vçú“ÉIL‡^$F²¤!2} T¾’aåÎØ8`T5ÂE b@bôÃ$m-oè“ä®*Æ°2c…E QP#$zp‰ÝÙd{«±ØÙ Üþì÷·tgx¥-º3©-ÅP£7·®/4ÚþˆÎ靖ƒ¿FMÎ’¾³ñ¹Æ¬a–{„j¯ñ7F¬›@5ôÐÉûÕÛK~ïŸû zî>m'[Ó©ªÁ ¤H~ɨ–¡*IÅ"ÃRó̳ϫ%¸ =œR¢â@ÅŠH+9ª "Zãzpëfî;¡(%èN£6$¹{ø¾æ­ïxãÃ%cç ¥@°Œ•7ŠŽ6ÿÀÒ_õã}j¸*”Ù¬ˆøèëgj ÒF»•ÒOÿÓŸ˜¡¥òKA'Áꢃ;ÿ<Ç'Ù`¤Ž&‘¼rÅÖ1øª¬ÏÑT¤¾%´Àø^¢0m›Ù¹­ t—*/ó xÅÔWC­¨:WùÐi¨p5{+°pµ¢0F‚ÒÊYA"Ó4lþ–7úŸÿÁÇ7­Š¹õ¬hË®[vƒ¦)ÑŠ^Ü-ø#a„õÙO–Ãɲ_ ýKì`XRB‚PE³3Ç®O.jšôÿÙ_Òvk¾`ÆîoäêÍ〦ÚJQ°|QqÏ“Foþù?óG†î¨6¤o˜•P.¸ °œ Š@)…nTyó¢‚Rj’4¬ Ïw‚”>Þ‡U¯"5ºxµí^ÖÿVOÅéņK:ŒF•Òi‘'‹tž“ËæÓEž.r³dÊÐ@YùhÄ-zAÍbaZ´ûÜÜ:6ijQ´¢Dhyšvú}—.YnÂEDá5F”ÞŒÒW‘BB2Ç…íA(“8yóùî¯ýð7s¾¯#í Åœ©®…± ».”}¾cÕÙ#õõZýrÿå³ñ¿ÒqF:Ÿçø‹ƒ?|Þ¿· E9õE‘iÁžòæoùÎ7|Ý·Îs´Í 98dFDU}))…í):tzf±Oö¹¦™1 A"õð£hÜ-Äg@¼ô~MHGÇG¯ìÝ iˆÒ ô*µiöbÃCÜÿ ¿óáû®$Aˆ$iô„ ÕºSW;£õ¾]ìþQ?7$ƒXUO¤Šê¤4WZý@Js,ax/¡³vöîŸøŸ†Ã>æ‘ÌFü¯bû%ʬüb]Q¨¾¦*CÖ´atÕÜ8î÷7þüwìN:å ò¢a â]æËÒPÚâ˜(©9 „HD mÂ,› ÈÞ óytKôó<÷ÈÁÈCtó¡}ñvóž<‡öüÞþüàhR¢ƒ6çúgß»}þBïYµ©a )¢NZI'ïzוÇ<_9Í4JÝRs¹2c NQ‡F5?¥ˆCÜ$JQ† #¶_|¾ûñôoϵõKÑ”Dµ†ÒÐ0D í§ViÕèkTlõM­ëJ@@Däðlªý|±<žGÎQ.ʱ'5¿­Ýkc¬G•œTK!«™N UÅÃUTQ¤$£ !Œ–ó¤ê1E€‘óW¶uà|®á¤©³n ŦhVB$Pƒ¢‚0 Üß»™,õCX²p¯÷ XÔËYý†L_:÷†÷¿ ½=UÕÐÈœ[‘âV•²uõss¯°(Ų©'ˆºJN©C¨0I((*’yÎÎå›xq¡ÒL 'Wÿâ÷~í·¿qÒré‘+Ò3²ÀÆ ìŽtñóü<>ÿ"†¼Êdzñ{vœ%gãó_ü^ ¯òyw%õ¼*­Gx Tìâå?ö£õÚþòüå ‘Jü³²j®]ÊR¾Ÿ<ä¹ç_˜4ÓB¢Rükñ›€ D¨iILÓhÐ僛7ó2›MÂKÿª‰Jxtm«o|ôuï|û×>|ßô^$”Ð Ì^;ÊŽJâê2:òñ9f¨X®n„þXaïý-hz‰3¢¼³1\μ¸»û+?÷ ·^¼Þ„Éx®W°”2KðV,ÝÕ A}­óóî‹pÏódã‘¥5„PR 3]Å…!)C&iúàùû¥Ï(rÂU=eËÿjТ0 ‰µ¥NM N $Çù-‚LwQ”ÎYKDj§Ë£OÿÕ?ù®·Þ§ÓfѦA‘ÝCLWËe#süãôŽxjuá‹Aè>ÇsÉ—ûožÿÕ³àl|¹Ç°×kŽÕ6ƒ¸Ú`›—¾®™GÍìGþÆqmž·/ëNº SXõn¥Ýiù¿À™t‰ÔLŽNÏ^}©mgÑ<¬ÌŸ(ÜòM%TéÑ ÑAnïÜ>„4°†OÇœýx{[ßþÆ7<þ•o»rá‚pP Ž=|fÅGe\se^Â,‘õq\£ýSqy=¤è&+\®„¹j\qß…Kïýù_|þÉ'¶%ÅÐ5I«ôµ7°ŽÕ©á…ä*¬¼ª”Ì€«ƒ¨jU¨¸!d¯W½Pc¥B+Á¸Ï„&K‰S•‡Ï_n†0R<Céˆ1`*g~}jTüoÄ ‹i÷éIáæË#”)ÕB§a˜A²Ð'““ÅÞw}Ëå?ú-XÜrïÔ<"T °Å²;>:†,Aµú¤×ˆÅHS &¢ö˜’ :è“ {õÐi>´'¾ûÞ_ÿÔ‡>ôÙå"Âq4Ï/]{å>>ÉíÎ¥Ÿ|÷¯´ÓKæ$Ô¨VhB™Ù±øÿÂÌ—7›x :^ 0Æw]Ök § "Å&è`ˆä*—WQËyv°úÿíÔîëç°ÔÔ¸GUÕJç`Q]…¤¬e“Ó¼Š[1¶”R±œs? •šO†çRBçÃñ"¹q‘\ŒãG3ÝF–öh¤ÄJTQqÅöÅó®‚Tx:"Â%ã]M„&/TMk½$Onl…äýý˜ï¿rm~t}ÒdC6 FP5 ®åe8Ä f›ÌŽO·nµ“Ƈ°ªï¶ÒQrB¯ù$áúìÒG–»·š Ã!ZÁ»mfl§öÁõ”éʨ}}#1,\ÂUá̼$ä>0¸åv§ÍæÔbäe5ŒBüR)m%V*Ž J!W4»²‚Ê–¸ _S¶Æ-k¼ÕËïSTJ·ìÖÁB—âW7ãÙ.F´l*EP6ïà;×ÆÝ+Â\Õ10â‚ê|E 4$ 9dá“œ[6÷»Ý7 ³£arâÖÓ<Ä¡`™@WŠlc£`"c߆P¢€E`€åÈ]›fýÑÀN-RÑ€5CJ]L´ðTûƒO¶v8›Nwš]^ÿ?ÿÅ?bÞÈ"ìÂÚ7 c5â5à–;gåîIäé_b`ó¹îùñlüžg ÀÙxíñ…ßö›[Ðêâ?=ý¨òŠ@–àO!î¡ ð{ÿÜùî}ÑÚ°¤šÐ½ìÛŽ #LŠ†ªÀlòÊíý—oÞjÛiî£xÌ1-´]À(¡¨ªR”L"Ëùüð`߇0™d/6%f„Ä°»5ýª·¼õmoxÓùí- §ø( †”#sÄ‹+²_Éeϯê_lžÎ›!÷z&+F1$@Ñ‚ïFј˜EÚi·?ôž÷=ù¡lI}nšî,Š1 *1žý”ÑS6c둧!R»”ŠŒßÄêG›gÕ®¤ãœ+)¡¦ÖX3k'“&ô¡Ýûµw¦°(» 7GŽ¯ £çÏçy‚/3D´³¢€¾š=emM®þØŸþ¦©Þž¤At a–‚2_,siц*# X?%áZ‹K½®ž(Ù£'U2()8íúædØzú¥îüƒwÓ§×_z…l»IÓnÍ&>ðàÈÿ—ÿ±éÖNf–Ù'bpwSÙÞ’û¯Lš6rab5-+,…ªÉÞNÖØ%¢RÌ 1$ƒÅb2Ìgÿìÿ’Æ¥n¡)¥ªT,k*¨ª":r‘¥ÒÓˆûÿîQ+7$ÃMÍï–]IMË c„p ‹e7_²w‰2cÎðr£Aðª^ˆ*âÐE\0H\¸r)Í&yTò£z£¢=88lš¶¤Ä–Œ!{×_Ù§¹K‹£îæõ›Ï|úúÓŸØÂ`C/ÌE *N‘‚`—¤š ‹èS³Õ/óÁþþ¤™ôÓÖNtPëÚ^=÷ðm¹}e uæ@FuaÚ þ_{»dÝ Æi­Yú؈¨F[”*“Sg„HVgç.n;³•ZÀ„*ƒÙ,•ÂÎ1×y,–5„æ*á½³6/ôz¿.Kw¼#¡* Ô•Ñ0œ[yûð‰ƒãÞJ±å®¢Š"”Yë}×Ùì&ö1î²Yz:õàñóØ–Í Š¨:y ª¡}N‹˜ö“ ’ÎEl-r{̶CÔ(„äÞéJF‘Ò¸¡ÕZ(*M„—Ê-%ÄÚ´Ýe?¡yÐÒƦŒªŠEñ`UD Ž‰5ç¶ÐPí໾ñò}ÇC6ÜTÏRx}wT`>¯“V^óq¯ýÓ/eÈç½1Ÿÿ-³àl¼ö༭l>v,÷oþ±U!sú^E¤QQzb =úø7¿å;¾ëæѱ¸ Ù›¶íàƒQTèž`™`@rxÓL®ß¸uëöaÛlå!D¥*åh” –<‹ÝˆBòçóÈÊH"6iØgÌ/\˜¾ãM_ùÖÇÞ¸ÓN (æUÚ;¾üR…VÁ ×ÐN9ÐkgÐ ‰ŽÓQçkS¢‹ñ w)9ŠŠè aâ`ˆãù'ŸùÀ{c‰÷‘R*0"€Dé•SŸ£<ñÈ¡£÷Z(FCÅ÷@h„D}9kônÀè4Ð4†àîîM3išij'í¤‰e~èü6ˆ@‹'§ ZIëcp·Z¥·A•Œëa»3+Ø,GP4Ðj?)"KÍ5C÷äßù+ßúàÎ2| z–ÊdÑ÷G¤¨µb:Rcl˜T¢ñ™Eëe¬ò&ÀCEƒ }3;¶þÞ?øŸÓ­Ióü3϶a&&“Ýí_øw¿‘';Ë. TÕ "µ4“qáò¶` Z¢x¶’«%AÖÞS¥®£¼›JQF` Ü÷);ÿÃßÿ.‹Ö¬E…Ú ¿ò«X+ «SýÎ$ýŽ[Y …T:K˜(‚Ý¢+Ξ Â#ƒ^¼â»Åg~ïyþ2 Ùøx6~Œ³àlüŒ½BV_ŽÑLjֱžÕº³ªxÐÝ5µÝäÒ÷ÿÅ¿ùÌË{Û;;УiRｘzD0LRäP îÑ6Óç_xñèxѦÙ0d±± ‹„…¶Pb£jÆb~rxpûŠZJŠº0?xéò×½åkÞüÐc»ÍÌ*Ñ\ŠA=Frka¦VMm%.¯×GžÍO î£B *ç R¼ë¼ØªPD,~á§f¦Óp±Ô‡ÅOŒ3¿ IÖÓ•ø® õ.4+-¨6ßå¨ –r.¥sƒ ´0Q‚dÒÉÖì¼h«’Ô$ýƒçïÇàŠÊâØ(ª$Eåi8¡%HÚ|…åp_j=ORåM”˜‰)DéÈ*“¾{á¿ç¡o~ÇVƒ9˜ cÝ#æËÅñüX[S)AlHé4'£':VêuRjä$¾"jUº•Övl_ºÞýãòo_¹­Ë¬ñÒK7©[óaºsádéƒìþËý¾vzâ*BwÒÍ `DIAýÒ}»Dι×Ɔ\ã»–Õû­É¢–F\E`B‡Iƒóÿèþ âÂÐ%KI¨ ©ð¯j±ØßP×|f¥£X…°+ŽWy¶1#ªÜ$"ª~±¬X>Vq^„礖ûÜ/;_öCUÕ—eSŸ¿Ü–D…NeöÓdB)M êz᪞€¤ÂæÝ&€¦&Ñ&¹~íùÆÝ\‡¥åÌÅRûÅÕ§ŸŒÅ"EfîH*ðkPE‹¤ŠÄÀÔHï]c;ÇÇÃÁþñ´ÝîrFŠL/–ò uá鵭‡cqîª=¸´‰§ +4ÅkhLmê-(k癜µª¢1Fåã&¹J¹Ë¼ M¬è &"¡Á件JýAÄDÅ´MhÉ d”…;’Z„Ðr·Ö¤¢šüJÙ*ÒplÇj{ª[Óz?//º2ñ«úœp˜x礞øåËí©–Eð] -)ÿ*ý8ôoÜé›Xó:*æÚáy]h•qm–Ü€¥XDª6÷ÙRÏyºv¾Ïí1S/¦ZD¼rþ ï;lö›"¨¦•§µ™­­‚Üq&O}Z2¥ÿ{ÿlÛ–‡aßc®µö>é¦÷Þ}©ú¡»" H1“¢DŠ” °D 0“R *‘©¢%•LËt¹T”Êå*–eÙ.Y¶U*£hR)€ÐètÎñåtßÍ'ŸÖšc|þ1çÚ{Ÿ{ïë~ À&š¸³n»Ï>;¬5ã7¾ñ1¸1ѹÞCFë¼FâÖ/Éìj :Ú˜ì$—¥˜«$…6ªª†F —t¼åí„ŒÕ~u½ì6fõȵ ¼qq­–Üzù]Ƭ–…ŠhÖLãr¶xzëê—~ò#ÝÙ® ­kƒj½ŒYa¥šë²þŠû›lôÒ¸w­a›‘•ì]“dIÞ¥^²¼*Ù@,Bt@»”¡}”ri“³Œ™¦š`*r0C²h(¼ˆ£ŠVÍÁ\Ðœ’Å‚t mc«?tYšÐŠœ­ÐE?IwµdŒE¹ÅÉÅ­édùνùúgo7?*~»1yEל—ßɺÎ?»ù@6žáù—=ÄýÛ[m €‡í«´_Ãn²±½­w´ÏO›WqÜF³‹¤ƒyüÑ?ûbç‘ÞŤÉC6µp@(©,R²¼8ÄŸáUH‚ªOàEbK!ÅÅ JI°Î’fóùáÉál6ÌV»iÓ}7‘w>õôw¾û·Í Ï+mvT¯ú†)sn{^ÓýåN1r‚åf ñ?’pë~©IÓ)`„IR5„˜ëìŸüþ§ÖuX ÖXM†SÏÃJõÝw´® ÆýmãK϶Œ•eG¨RN-™,¦mÓµ6U± šÆ|±¸záJ 7•ëʘ/#+ºA9nöRÅ#ã…¯>c££WQ¸PUЃh4ëK?ô—ÿåKíѤsÓ¬iË>ŸœPTDlŒj]Ý£C|ENŽ×Ș´Ä¦k·/Îú~ê¹h/½ÿ_xýÚÙ²÷i·½ìyx<ë<Ìó0Ù{ôGÿчv/^] Kˆ!tE(`°bˆ`kÚ ÀPŽÔf©»´A’²º† Fך E &Öh‹f«}ìøþ“Ål;÷­šŠ¤šËfêñ\×0l ù€ "ÀˆþëÏõ´Q!È€BçóÙjÞŽã Â3ÂÅ9,ú¼è‘à ¥z+Æpüª £”d£$C`ÓV›4¢PaÔºÔõÂUÏf3@T”&¥dÈýp|pØ $g 7º/>?ÕþäÎõ—%òí[7™½cMbS !³|~8µ±¹/ºÉäöþ€"bŒ©4RœšSs‹ÝËÓ·ä¸]î\@‡—ôIí¢(´Ö¼®ÜÛ©nÜ|Í8@5ÔšBS×@(ž¦²½ÓPzHÁÔÉd’dJR¤þµÊ!kTñè¨q÷Ù€%шÿ7gCe%F³+ž¢^IÉH ¡…¶º<ÉÉ#/ÿÔ'›Åî°$lU¶:Ê”¨™ªÐîÍŽyP/­ž”Õ¾º¾˜š@JPjCÄi%Ú6“­!]ˆæ"£]Dê)YU$NÏ0ÆJ¥/¡C%£(ÈGã‡kë“á d‘Sj> N_K1‹ÈKˆ çéö–û?óo¼ç{磖¥C°*!ÂƲ)fқ͑{æË_÷ý?l_G{KÀ›nZÛ¿øí­ þæ«ÎCü V ä˜ù‘ës†}Ê€*ƒŒAðÌïøÝÏüößw¸ì›¶óœS׸"TU Šu×¼¼é¦ó~xñåW»fÊ^ªk!!’Ý3shñštËÅòôèdyÒ£×$m›ŒºÐnñÞgÞùßü-î^°P«j—”ú”bZ”<ééÍx ¹µÒËæsõ(«pˆ£þ‡+ß †*ŒÏy§ÝúÑ¿û}>pémcRÀ+£H§Æ\ñ¦úWÃñf£ÊŠE(Tº¥ªÖ‰ª6i·ºvˬ-'oP’¥~6{lïò­Ô\¥BŠß«ü\°™ŒÑÆå[¹‚N›`÷MN·QYEj}T@3¼k;ï_ÿ÷þô·Ë;#é!ûE£PÁb>;<8dhJ[ª‰%/d•øjM‰XÀ28J§EÂjÒá¢B(!Ö^|öõ»üÔs Nç}ú¥|¶IÓÎtqvrzrÂðgŸv> yâ#Ÿzáå[§™BÕ ÁXõLhÁtôííZ¡T…""*ƒ¶^)ât ­¸RC/É®üðÿð3'‡m,§ªÉ´¦~IÞûÕHðV/Ê(©Þœ 3yã·jéÊÊŠÁúE`IÀê‘¡ˆp©æ#M@÷~¾XžÍˆˆR7€%WMxU¢Š“ÛöBEÔÈšæk4Ž"išž¥Ôd/µØÄĺnr¼¿¯î  ¹ï†~¹w9?nµ×o¼Ñ÷‹FŒáˆŒZ/°TtVLu1,·¶·_}íÅ.5Ã]$ ¹|¿‚ˆl8H{_ñG_Xî,$åPâ…K™7ùÓJî‘M;¡mÄxïj}£‚Hm·’ë Ê’B5T¬é l À#ªRB\BÆÝ· }06§¬-¸1Þe“ÖX­»õ¥­÷y4ÄÅ”3ìÎw^þ©ÏMðøЖP)‹®¬Ûµ<é«.÷÷V¶ €z++eϧº=ʸ(µ ki@fZr»·+¢éSÄÝDÐ [ï’“F+ÑÐQŪa “P°˜jƒ­|ÌL™ ©Rúe«½*Êp4êν½Ý³Ã/þÿÖ¿ý® § rÎÁ(5%Îwæjã“ûúfóˆ9O˜<°ñM?lÛº=ô/óÝÃC¨]»q#u“Koû¿ü?þÁÎÅÇý"ÎjV*(sa‚¶k}U™ب Q‡« ÉH’q©XžËÎäÊÿèöoºÆ¶ª˜X8VƒHlšá›a—UqÇó¶ÂòÛ¦é8ÎòÑþ,æ 0"ÂDK®¡ð(äi P²ÏOÏØçDƒ“î¥~pÆDÉeš4ÙÛrPDQ‘ç*Ò=°\ôjAUµÆ<ç$zp÷® Rí¦08,¥_ôÇGýòlçÂîÁþÁüôlªI ú áœ Òè¢_ìí]xåõW»éÄ=Sê@)z`¤-¡ûÛOþò~{ؽ}ŽiMeµ¨«ö¦šV2þ|à‚[#¾õÏ1Pº5•ÎÊT+C.C»Õt“Dd*YªhÃT“VÑ@%~ºêyÐ}.Þ¦Xþe²É}—ˆ²!”‹}#䆢§”sÝ^L¯ÿÒZìö0 (z H Wöœ ðf@ö^3àþÎ<çÎX?;v.‰ †õ}sæÛ‹t)šK”iï:'r2µ,Ò ÂUÊ‚(5ÂHQ! ÂA41ö]f†hœ ‚V¶(%èÌ0A,²˜å>_¸°srô…ÿîïü¹íxub† €¦5ˆà¾ u´7îžã]§ÿßìè½çàýul¿¾Ÿö°ýól €‡íí×´È7ý»÷_ å¬ÑÊx©@„7Ms04ü/ÿõ»L²ÕÃ’$Hr´’0QÀ=/RÓˆµÏ½øêr`#ïCPBÏD$1¥Ñ@¥ú£ÙâðÌ–šú4M-ãloW¿ý›ßýmϼ{gÚõý<%“Pz”„ôRt5EMÖ’«+"¦ÞŒÈý\Í}7>Jl+}U7öÊ—stÔëŠM<(ÔT—¶w~ñÇjÿÚ îÉ’ˆX¥5¤O×É­W—6úîéü7ic˜%‚/º|!¤¦t[)uªƒˆVê6†‹ÓévÓF ¢–rN•G»C•4ŠõÑÇÍxCž;õ a)¬q µ (Iå¢A¨E÷ì_ûKß1Ñ»î® ô‹ÅÑþ»[jÔRQ9¨†HÑE„(i&! ki@àО2P‚ªË)mÝ9X~ð㟿stXBsãæþç?ýâV; ï‡Å"g¤¦ënݼ}iïâg?ÿâ«o×@ŠA<…j*!‹éÎ4€`”¹ YcôæCP¤ÈýµWÂ88ºéåú?èÚ+gïHˆ­òÕ…ûÆüœ%°¢WÔ.Î-\9ú×dq“!@D€L&ó~/öbIJUŒ)áh`yÖ/Ngâ%1¿—ˆ×샫Báˆv{[š´r™”…XTsjv:?±Bn#‰µÖ÷ËDpÈÑ» £úÙÍë~¶\t»;óÓÅá­ý–Ò‰f_Œþ=̓År¾LfwoÞž4¨H š¶"Yx¬“7vžúøÓ+9µ€ª(²²€7zíMÌíºMŽRýÕ¨ŒËqL #,/Ûf RR‡n«iºÉ"ùÒD“i“¬e · Cb¤4Vߌ1ˆ¡^A1Ú±y=ëÉQYTC¼Ä3@ÕRçÁC(3]\;=øÜ­&¶MP(*šÂ¨!D÷Ùù_§>À°¢2Îýí–&$ %.š àfs6GÜ>’Kóæ‘Œ½EogÑ ´L dÏšùJA…†]ƒæôÖv†#—¹—k45D& Öª]šwj÷àýWþ-ï6f£í»aò÷y~ö¬¦É×< 7íÊ_¯v/5ó°}£·‡ÀÃöfíkm1oN=ðAT}nåU!*QÉ)ñœ-q¾ø½üOm=õLJ4fID‘ I!bÉœ r§Û^œÎ_{åÕ6µ$2U„¨,;ŠA4ŽåÙ|q:Ë}/ŽV$¥læïy×3ßüŽwµ­åX¨ÆˆkÆ*$AG œ“9%ŽÀÿ«u½7>ê^7Þ3Ò„¨Z QRÊ‹)u/mìÞÿâç¾8eB¦‰Œ€l$/ìèƽßk”Œ¤üêñGSjº¿R§¨(V4uÓm³F-©r ªR[Öî¶r¯Ð PKC‹Ž@XÔB¢äŸçˆN×d^­¼?#øŠþ/`–•©T°@Á—vëdùâ_üóßúž'†%êÖûa˜/æ!)ºªÔÜáu ‰0©‘"ZKÜŽR U8D+Í…/>ÿêW^z-3ù` Ùž^ú؇ŸÍ>Pzö~€‡ˆ¸£_äÉt÷§~öƒÓÝËy´ô† H­c¦+*mlµ bt‰ˆ”œ¤+ØX@Q«M,5-†´Õ]yßÏ~úÅç•;AUMîˆQÖ/c[}îÈF?>œG€«Î ËH`UMB¨ À4–æ³³òö %~IgÝsNbF™žö‹e#It—@äÎÄ,Gì^¼˜š´zÉFSÛ¤™Í¡R‚%D(úe¯ª}¿$JDG™Td9_jÂb˜5“‚;·îø0t–³ H/J0¥Hˆš 0_Ìöº¶ÁM-3œj$;ÚÇ>+}f¶»hö†èÁpº¨x ˆ^£¶i`VÕ OÉƦ°Y-I]­Ðu^,h0\†n'YC˜CK}C €¢€©µ@K  •)‡MiRÉW%ÚD©E°2@WH²îÞu©bÅ}"0RAe±ß‚;¼pë“×ñšcN&œ`­n[½¥… Q$h XïÍÙ0=Æî²½Ll/½›‡-hp¬s)—4AÅéZÜËQlOx4ºÕOÔbâ^bʪ1z‚ Uô.ÚùæŸùÞ÷ü‰?øDœ ¸©e‘¯ùšÕ|àxKoÒþ9’ñýÿ"´‡ÀÃvO{Ë ûÍ^¸‚l÷yŒd9>!Ô•xv,>ò­¿õ;þØ¿y°X¨&Q ¨ºêR˜É~k&¢“W_½qtëd›;˜ DÃáÐõʆ"|Ègg³~¤ÒH«¾Å+O_}Ï·~KÛM2ÃL%4œ ‰pÕz¸ÕÿËÁT“W‚%#9Ö7òÕ{kõâñAq‚¯O,é¿*ì‚PÖsF™·¬ûò'>ûÉ_ùèNÚ¢CU¥ä!ÒšõŽ«4ý\Ÿêk ÉŠrGÉÞxÏÙ¸º¾ªa]DJÎFMí´í¦Õ` 5!T!áèå Þ÷¦Rƪ̣!S©`*EÂÈ&$´Å#Z-\è9{ê¼q5*ÃC²€ÉæË¿çw¥ýw]öþˆÑ+ÜûáøðdÜRSê‰J¬˜ŒH¡å˜/Æ!2„ÓÚÃY|âs/œl½Gj,¥†ì>þ±çT¶b‚áQ5í@ö¸q÷ð+/Þ;Š6#< QBu§jÒMéŽÁï¹ÆñPƒÑÝ”bð&{Ÿüå>û©×éZ¸ÿ¢åX¥/ÝE­mÄ•›D3ÆXÜÍv?m½ñŒ¬ÈTŸQíÉ.g=BLÒJƒS! D}"Æù°8<•!:$ñÝA—CÌÌ%ö®\è”õ<&hMsz63I‚‘4© iÚùrî9wÖDŸÅi° ÜsgºÜ¿ÓÍJ䥈´mwtttv|Ü™ú0P¢hùŠ×}e«íNOŽŽZ³ÜRÃìµæv8QÞØù¦Í÷^綈‘`è*aÖ¨ö[-õ7‹Ä¯àšë×®7«³m—ªTMÀ@¿µ31\ê’(´p ªj)©¶„°:Ajºß²ÁɘE \CÜkîm>®5ÂWÏÔi°Ê̓âYPñy~Ü®~åg¿hû;è»lÆF×– 6Lû{ø”¯bÜÓw¨wñ¦{±c^fUP•­D£Þ´Ñ4èàÍ{K{X6ý C¦{d¡â 5LBÅU™ªz_î­N9“á 'NáF%DÄ‘Ð ‚j2mlvð•ÿâoüï~l)±0ÂÕtÌgJÙðã«ÞÕ×ÁÝ9ûû÷‡‡í²=4¶{Úi¿¯Úî߈ иB BÑʱ“ â!áH'Úý©¿ö×o6“VCÚ¶±d"ªª¥VÒáíۯݲ!µÑ²/j})™”’¨>k ¾˜ÏúyŸ¨¥†N»¥—¹üÌ;Ÿ¹°»žÛÆ%IF!½¨XÄQsס*c6)»Ú;+Sfóèþ*ÝÊr0oô‡¬aAÁÍQÙga"åtíÅ?ô‹¿°ÓìĨÁš%ãÅ*Ó_¹¬â¸yŽW^¿_6¤ ླœ¢fCxÓt“vKÅ@Ôtj†Q€y"vi{wX,’YÓ†QRÔ+¤F ÁZÖÁXå¸!Xò`Œp®ï5"¥ˆúà@ðÂî¿ö'¿{»¿Û6YeÈyqvv$ ¢Z*æ d‘¨þ–•š‹Ph”tB„@E%»z˜GzþÕë_yéUÒ" AK*‘ÝË/Þ8o VËÖ£A$m—§þøô©gÿÙìh’Ñké‹ž«¼‹T¬2ùÜ3õ6·Éû;ì^kaõºÍ3gãÂÕR-E\Jí#Ó0Ø2§…lq²—Ò– å>Ðsݘ8–®‹ÕÖP‚aní0î š;‹Ö¡¡ªD)×]df!ƒM;m°xþ¿û;AÏ^ë”Á(•6ø˜>Øð Ü·”ù uú°=l_G{h³íõn„š¦Û?}ëŽZ…fãü®¹a J‡®±à¸ÊøA” 1© ŽåöÎÔ¢tz‰‚†&pˆšv SE'hi3ãX-0BÆ|«á•Õ–5^jÁÒ"Z/H¤Zz•0€«bq<{Ô®|ñ§?1Ëž›¡Ñ™%ÔxuO_Ü3ëVî‚q[{¤n¡k†£ž-rÎ6­Ãbjƒ€:$Pâp¡‘dè%Ž9Ûl[–ºD•¬‘Å£F,…XûG„ 0Cˆœ¦¼ŸeÖ´1%•,ñû%ËEˆÔ ßIR²“§.þWóûG¯°¤ý+8³––{æǃ:i# móuoº¢ï?°uöÃ[÷<¤Ë¤$döª6‘ —~ëµk³ƒÓ&’fÖÙcq_QwG¸÷ðXÌçgƒ/ÓÄv/í=õôÓ^}2ÑÓF ÓãCˆ1XÊIIÑðnØoº2·ªáb„.†Òœ-âóϽøü+o0¦ô.€ BEÍi»k×_zù #‚á2…ûtÚŸÎ_¿¶¯Ö–¹‰mÆZÊ ¬m#T ºNÃ^£ÃUd|+Ä´A¶¤»w®/þñ~pwòøư̈Ԇce¯J]‚+°þîÍÿ[ë~¸Ž[½g2¯_r/ùˆzÛxãh »G¸s#f´,ÕòeÅÜ-s9<‹<†ùr˜ÍSÀBàuu>dÄÎ…½0¡@)+§bóÙBXJ‡J²ÆsŽÈžáŒˆì%Onä>õó8=K$"«(=L,÷ý¤,‹Ó“ÃVT"À ÜÃEwv“ÉÍ7#»’¡‚A&WÜj.|O)_™Ûn†æ‚ûªÑy>"5ÎÝ ‹j£ml&ÕEºá¬*経ã\:‚E¼dÒË|ûb§êªA†p®s,ƒ$E+Ò­„<¬=ÔΔµò¤èzjž¨r…5€ŒE 7 œÍ !žRÓçGôê ?õù­¸â™Ö 1`5mÖ&9À=ÝÛA¤”dó⾯ŸÒšÈ¡d -N+ŠPµÐôÎH¡‹º4”¨Srí‘q·ˆÔH Ö N ™)ºaßql)Oˆä¨–N­Â&¡*臦ms¾óoÿá·ÿ™ï}{œ)•‘K:&Èü=®Ó{î™~,oò’Í'WÝóÀ•þÖÛ¯ÎlxØ~´{ùÀ‡ÀÃö€öÖVøƒhÅ5n×Õõ°„jÀ!Ó'Ÿú}ß÷ýó¬M²Cš¦­®ÙšÏâú«·Ž®¶¹KCË\³(:£8® ¢A™>ôËÅ¢ŸQ°wáòÕ'Þ~õêÛw._d£Y Md‚´N[’KbÿtvcÿàlÞS$ТŒ ë£àhYÍ›ÇTUßoÞì½üh}¥Bi¥Œê*[‹@Á ˆxd†&Á?üá¿7eÂ"’˜V˜:jå`ְͪ¼õ¬Èßz@Õ2U×4þTD!–&ÝVÛv"&.¥my™ $@ UÌ“ÔìMwàQëY–ØBm¦ñ¿Â/*´(¿… ˆ ŒQTöx‚#™·É.¯n@C44Í`H€Jo!ˆ§ß¶ÿïýÀ»vdXö‘ýxÿ4/"I×X#!ZemkÕN/ )ªh…zjØÞç^¸ùéç¯Íf©Ã®÷Ð’4ª‘ScP›ì\þ¥|L  f DÎ|áÂÞ /½2ÝÝë‡a´†c’xVx.%A¦‚“IRéÄ¢)Ú® ¥HRIÐ<4Çûú£ÿàƒ»“'–g¹íÄ*«"7¢ÒïO&²Ž\ïÖ—–ï;·ty~6¯†ã<Þí¾ð¡¢Ù3*”‘ k^EÝ„¹5yN•Ë“3öÙŠ§ÀÝ<¢áâ¥K’ŒZcñÕl>_Ô£jáDÄ’nJPöºÃbv|;|p`¨61 ƒ­%Ë8>ØG¿L@ä^´âo!ÜÞš\¿ùàðAJ`GYµ’gi¸~ññ_h˜:¢c&_­]RêŠÑoâ›zГ÷86§í¹N @Rj£‘ !D“hd˜`è°Ô8 ôžû޽ׄ¶iš&bˆ>$“8ÊÏR°±©CÏ­vqD?¤å i.,?P!ªHÊΦm'Ïý—óßú–'–—ΈºGꤚ}kÅ•¬~> CtêÜ×M÷®â‡€ßôí¡ð°Ýß¾þ~ÿNòཥPÑk^0çFN¤ÿ¾¿ôœHGKJÝk»Gv.,Oæ7^¹~tó`Â.åV³’ƒ9IpÐÈ@–óÅYÓØã^}Û“o»|ñŠYrž³P8p8óå|˜Ï—CÕÔ4Óét§ëvÎæýÝÓ b‚=°:ðªx#ÀšMþ~Œ×»;ÊÚÊ€Ö§K0@¡KE¨ô°ÞKJÖ®±ú#ÿ sÅ2ÌJ9²ñ›kéQ}v¥‡­ß7ÂŒzåB€*`-\P_( % Ñ®Ûn›-ÑR?(¬âàb£±?%ågC¹0ÙQgQÓˆh!(ÇR›‰Ý«^ÃRµd$هɈŠ}³êÖ•ƒ4žÓ‘´¡šk´MK¾ø×ÿòw=Ñ]›Ø"1Ÿžx„&b%ž› )‰ÿ«.`LÔ'êQJ¥¡î™Þ¹;ÿøg¾rzêL%‘Q$ rô©±¦i!éèdñ¥/¼,Ú…‡@ÃQ¡^v.]¸vóšÆQƒHVgcêÛKIN§mÏU¾©q–•|ø¬¦€½‰~ëïÿðOOìÊrΦiçÞê;î2”ÍçV?êðŒó}óu÷à‰{>bý9õÆ¿Ëú­dÐsÆÊî(/Т\g0Ê(¶AU¡G‚‹Å°X2GxÐ]ÅæCO‘ —.1‰Xu¹EöåriÅ,ÍÔD#<ƒ{Î%ã$YÜj oMüì0åN (¯‚@ä<(´³f~2_œœLÔ0 d.1-ŒÈ9š¦»víµÔè2/` ø@.E—Iî`²ÿèwüÂë>›>¶8½”š&×n¬Œž•ÆqFpœïGb3äHµL•}w.n¾: eD 1ëb{o*pUD‰¨ü~]e!ÈÂP„ªi’‰ƒÌñªê¥RÖ:õl¯Ì-)Š)Ôl_çæN0Dªˆ«‘ÇS^×»»Ñäéà!ƈz‘\*6ôŠ²²$Þ„Fºï™úÊ•á´êÞ˜+Y-½B DIIs’ÞbŸ}Rvj"ä˜g,CëÐL®}æ@x9Yé ®2Õ¹.îœ%o 1•S!AÔ”†>ï$[¿ðßÿŸ~°ë_m U¨ºî…ó÷Ú–¹¯½ô¿ùÊM«þaûMÛˆ‡ÀöѸÛ~ýŸqσß+g%PaÌáÆ“dßù‡¾÷⻿ý,r#m§Ó”qëÅ7NožM–ÍŽO¸$….yÌÙ C DÎý°\æÁšöÉÇÞñÈ#O6ÝÔ%³QØSô³~˜NFø0xŸ³/sîsDj;XsëðäàtfÚ¸CÕV©Ç×5VT“Œ¸IF…ÇŠµ£Ü°µT ´A î Q‡†ÐÛÝô§~äÇúƒcYöj*%‹"UÂj©Ÿ’²fò•Hçó×h†4¯ç{ a2i·'í¶I‘ˆÔj´…8gIa§Žu±e#ù‘íæ¡mUÇB#DƳkœG”âs(ZÛ uʦ~w#aMŒVì_hNRD ¤e–¹ÁÛvÆ×àûÿîwöÞŸ.‹Óãã~¶Ð”Z)¢&„Z—TR! Ž†]N­P°t§LÏâ_záÅ×o5¶‹!i•Ê1@¨¦“vú‘f±„;Í „”¸OR 9d÷âåƒã³>3„cbøU4ÌhŒ¹o…œLÛb•~0-Ÿ ))”Ètë{I¸ü÷~øg¦éÊ0gju¯˜­Ì%à\ðM0ÁæD{y5N Ͻ÷ dÅ /Y}Û Q܇NTtÈC±OXB1(Åe1†¾Ô*Ñáн‘ä‹>–Ëá}¿h»öx9ë…¹Â6e!ÄDt¹\ ¬ BE Rdè"çL¢Ù‡ ánC^ݵ@άJFÝÜ»d1ôÇûIJñR¡!è”Ð6Ù×_ŸvÓ˜çÄ”ÑÌe:˜ I®ûÖ Ï|æ8ån'$ âe5p¾ÆÜÔwbôQ8Ÿƒi ZKÇ“MGßø¢xWݸœm›ï\˜‚YE T&J™ÑF&!ű¤©k(Õ=†j†ÙßF:„BK½‹1åÔ½¼!ªÙ]D$1°ˆvòÎþgö¿p<å…LóÆ2©b…È‘ ã¹9¶±p6ÚW;§V–éùÃH€'ÃPqqML²Ìg”ÁŒa’Àwô¦’ "N(½µ’Ú&¥¤%±©dažpÐ/2±æäÖ‘3ÉE‘‰Gñz \”M¨ŸÚžýç?ô‡û³ëfž¥Î‡²¥¬úuíújwüµzæ|·¾éǽµOxh<|¶ûÆü¡𰕶 O¿žw¬?ˆ%Üh;X•4„Ã¥muç±?úïü»ó³¼Ýì%èÙñüƵ;>—äÉ«hRâ–õÈ/b_R›îðøL5Ep ‹Œë¢æÊ)2k("¶¦m©Ž$@5–‚-•¿Jõ«<ÈÞÖÕþïùâr®f ³ŸJaX›ƒç&ÏÍÙs'÷ÊtÎk…õË6Æâ’ZÛë/\+ÓÖûÉd–‡~e¨TMÃø»”˜û*^ªK†ϹCf?›K ‰-ç˶i‹ÅrÙï]¸ØLÛÌ°¦==9ƒTy¶BP¡ºÇ0ä‚ #\Å ¸ÀçÇ·½œž%B %žÈ#„’,ÞÝÏF¸Â0³ðH2ãöëoL›vX. TwqÕSI׶žþ•xäY^ž§í^…àâ*\‡IÕͯ°<ÉõÂÇ’ë.«´eÔë5J¤®õ²?•8WQ¸ aËí‹°O”Ìžu1˜ˆF@Cɉ€b¢­jPB)Vô85j,²Í wV±ÝÖ {sï(³Ù´)K„5ýrý#×øŠÛÐ]SEÒw¿ízn&~Mrjœêãê=w­÷c-É;Z, AŸ&&P‡J‰¾‡”©A§†Ëàš‘$!`Ñ£2hš$f4 }ÚÕK<ÒÙõS`bív_òŠ& 8<ÓÙP¹¸ùçþïþãàq.ï”pa­‹ø\ø8/~½€÷=®€¯«=„þß­ZÁçÛCàaÛl_s“ý:ß½ùŽ‘>WˆžÚî0Ë_ý›ÿûÙ"¸ŒÅQûÚÁññÜÙ4 ²º¶Óz8è’©6D¹pñ‘Ýnjb®&æa–}2Ça9ä¾–9÷tGD„û0øà$ -ÙCÜEÍÚöÖþþ|™ÕÚˆS‚ª‘ˆš'ˆX¶Z±2+Ì¿y³åä_™å´q-D<ŒTº‘‚!†a¯›|äçñ•/?·%] H%ÏDˆsý›EK1®V³ ­ÉÅBÿC åÛ˜ZÛêºmÕR‚wK°e S9O̪dH¦Ñ |lçŠ9™ ©:*ø7¾ªj yk²s¸8?;í, #òTûeߥIøpóÖm×ÆÐ7î%+Èp*¼{é]ï;ÒÛz%g•œK†×‘îçFq½|VÁkmÃØ°•W²ur¡Õ²ƒÅ"af)d]ì\ž:—…ñŠýŒ ´È‚ÂMRÑ¥ŒIÙT­³Ô•H€•L ¡¥'E!¥ðsM;°¡ï“J”u ÎÐ’ V1H/MäYÿTzâ+?ý»ÕX߆6ÞX˜¹û(ýçæÞqîî¿F»ÏáF­?–ba å™`H€!iH¦æñm DJSâ½YÝÅ 6fÒn©Nµ™*Z°A”Îàbú®áî{Goø‚m³í@Ž%ŒHå(ä´ãé­/üÿíŸ}ÏÕ9úDͤ̕'¦D*gË[Bì_ÓXZõÔ×Ïú=໶oœÆ{=46¼åe|ž38îëO¹çùõï%M)j#CÎMÛÝ=ã¿õçÿÃ…^8óáGÃòlvv*”ڪР¨b«³„¥†°€ &Ç'ýg¾ø•ë·îšlÓS™–%oâüPÃT :™N‡€uÓ_þЧ(]Ÿ]DIF„¨ÄˆÉ¨¤B¥ €¤©amIuÕá)#éÓiCz„›©Ôú¿Ô"û&¹Û=òþÁûnß$:U• ¢¦ÄßÂÝ å¼až_åA)øT§÷›îofÓóþ­F㬥¸2¢Ø™ªºz#YjEC¤„;HÁ’ÅæUE0#ÄD‡ÅÂ}+½Ó#ç!<Úi—&Sæ}_ÒØ—.K¦ú;=¼Æ£€ÁP1Ò-òÁí7ŒN2TËZ0U¼°ìî‘R3ëç[[{Cûe!g÷¦³~X´Í¤_ôwî$EŽàà‘‰œä6&×v¿íƒ'—κÇ(pÍq.£G;ùœ©t°[…*œñaõ ­VÈ8·G3T+òEQ…EÆ|çâ’K ¹#@´”XE`\´¬Vh§Ò h $wP-.K”øãµMÆ›-?”PÑ&—%©Y5õÇþd÷¶/þÄgÒìB^bèÕX­÷º°VÝ&šwç^±~@Œ=7þum A˜gÎ>‹La€8ÁP²(Í­²͉Á!š[´í¢kf9J¸«ùæpúêññˇ‹;KA“C”>ð !‚â¼°uevk>œ ¦­¦V%•*mXf éºäGÏþ¿þ›Ê;îîêÔçUõy\ ø[‚ëoÓÿZ ÿW‡í7`{ tKÿ.äaûnrî!Ï?^íSÜ|aI-%D=‡%=\ôßöû¿÷©oý—^¹u0IéàÎI°QI)ÙÕ,(‘)¢!PÉ}Æìò…+ßý]ß±Xäú÷~}6mTÔ¬ÝÞžnïnO¶šnÒY‹­vhr A„¼äå,U­ô­ ä Tœ°íº“ù|9ô\º„ÈcL«èx¼Õüw6îWƠƨª?µJ%,<¨bTD A÷Üg¿ü‘}øB»C×vÙ£$ÞaxÍ]bvQØXHT`[={R*Ú®¸àŠ U#жSS[êIQÃK‰ï•¢K? g˜Àdh"Ù¹ÀœS’pÖ$Ÿ¡ÄP~‘MÛOj?¬¤Êâ*?ç’ܘ/õó ˆ C ¡ ôxcs¿ñ{çäþÁG0Ü8›Ïól¡¡Š* ¦dŒ^ДY¥ŠAT†ì–&óE~áµ—Ïf†)3ZMÔ7 ™(JaUXy µ 0kÚ»‹çž½ÜÖ’Fˆ5kO P†t¾XJR=Š› ÞKÎÅUçUH'“®CžÃ,ÑtQ#5#¶§Wéç>ûüW¶Óñ2ÇT›<x¹þ¹ÿ×õB]ur—‹†;D¬±¢›‹ùkìÜüd¬¥r¼÷å!žs“šRx­9ªÚôBÒoÌ a°Ä®C1Ï‘Ù[²¨¡ÑdmÛ2ÇÉâl:é:E)Ŭµdµ0«¿!T ¢¬k#/gÃé‰î]\RLM" ÜÔ†ahLMÛ<„¥f1 f $ìíî©Iν©-–³I3™ŸžˆÈÖ¥‹sö¦m½Iã®î>×<ý™ùÉïIÝ$æPUÐËŠ\‘ý+_MÞMmMåÓARÌÊ2^ÙÑ#@–qñ×NÕ)Tã+”p ¥ÏË­ “ÓÃ¥XŠ ÖâÌPJŒ'…P&M$ ˆÁ³™QŠ$¬£1BEƒkFCjQd­¶T¤jiy¼|òÒ“_ø'û¶øK; Í$ žµ¨äï¡ê|¼‡ÿ–êzXÏØñ«u!£ñPç¡‚†Ác¢¢@ VÑ ‰¸älNH 4,eÓ!‰LtÐaÁ<úÙ³ù0 É‘‹\Ã\gwï?ýow‰!úå¼a›¨˜¥$"êsßÝÞ]-çÞm70Š†ÐÕšLѦí8{jröŸü…?ðøï?éÝeIPI,é똂+Uäf{0—¯þç_&çw™‡–À7d{hù‰/~èU0Ï{ÏÙD.ç·o©­I­Nv¶.lMw¦Û»[[ÓijðÏ>äFB½j˜*&¦¦ƒ»JŽ›·ö¹²WÐDñ•ÇŠ…+˜i­óYý·FB„ë)V‰¨ˆJ¦‰Þ½öÆû~úç.O·ó|°6 áPa¸'«#=ÎñóïéòU<àèÖ5m'mç @¹6 Æ”„+ÄU>M”Qª\j ³…_Ù¹(¢P%°â4Wÿ™ç X’ˆ€ϱ#Eµ”p2 rn%[+*@úÎvGÎQ£!KÖUqLäâ'>üʇùÅËÛOù2’(‹g-²–l1÷/ÆõÄã=f@¹ BVºÇÈ!×1ª×ynÜ6Ð×f¨»¬ˆü*U”9ní˜u~}¥#½šæ$-YA h"9;ƒÚZ2Ëž†Y².-çËÁ³AÅY(T5_%%sÎM2YAK2óÃ;{{B’¦~˜› YòŠ‹t‘)ŠnÒ$ÃáÁáîÞN;éú~H)å軶›œA­ÝÛŽœ)æPH›^ãå.ÞöX£Ïĵ)e£ U[…Ì®¶‹•Ók½7;XÆÌ6ÅCcÉ’ó’¯õ.EFÒ qÀbëÒd~´TFI-PÜ€¾1˜RíÒ±”G­c@S5‹È5Ü`#ü·ÌüѦ­S½ –Ý2Ôh€F(‰!I·<Ê_¾úÜ?ýô»ÿ­ß¾ÔÛ© É,†t5iÆ}aÝW¥§Ö[Þ&¾'t Î¢uu¡Ð#àÄ¡ )kX…D8"ªÒDšX*f:œFœç§§\’®I¡ÊƤ Õƒj@Ø5Æ“áæs7.|Ó#“ǯ¶M3ŸÍcq6NmbmŠEßMöúaî ³HI@6a^.»ÔÎæ‡éû×G?ñòO~æ,5€ÂRwïºÐJç°Îœ®í­#‡‡í7h{hü&ooÆöm>y¡?þ\o@Õã˱>´ R"YEÈ2DÓa?ùËÿÁß|uÿ¬‡÷‡3‘¤j¦PUÑF\úº¼úè…·]}ôo{b{:¹ywöÓ?÷þçž}}§¹póèU,ÜÚΙÔ¤q†ªFH3D ‡§§wOe¸¤¥¦í&[[“íÝí ÛíVkMR-ô ”¤%.9D(cyv Ñ‹nA„ᓶ[ÌIU !rÉX«¥À¶ÇV»5;™å”.nSššHšn…H ‘‹"5/m=õ‹ÇË ——õ/thE4iò¤ÈÙ°Âñ+eÎjÌ67ØòÒ:,&úøšµáPס©+ƒ4ÌD¡5ÂeÞڙΖˆ–n±`Ô²Ó2f'E'µz k"4Q3•  6m†Ñ¨åÊhd5MÇá-Ž²•î­ø0ˆ¹·½óÆ/|åÉå½Ëá®Ê€êdåúà eRfûj:¼éÄäê«ßê¾U.Á•9T5J…æjhÅÍçXœ ‹Ó¼}ugÚ´ª}öç_»ñÑO¾píÆÁÖÖ…Ùk7®]Û붥š­6ÃC²$ r„š*EI“$L\r¾œÍ–·_»+ 1Ó6¥Ô´]cIè Ó­nk:m&Mj›ìË~ #‹ùÕG¯DÀÌ"\ ªiuPqdÐG˜‹ÕqºÙU¹@–0ÐrNÇ°øÇÿãÿx©½ØŸÎÛ.…÷PÌkÁ9ó*À-†ˆ è*Vásˆ©zP-5©1I5€V4îC€åjFK X–ƒÃÄ-û¥Ëê.Z?‡Ed1â¹z*ןÅÿ¿RàþÙ"ctˆŠS“xeC×É.Æ—QBDpÖ—“vÉ7þô}ô·=cË“ëÃb®%ž/YÉÄQQ†PT!É 9<™õsùõNgƒhçŠ,Š,ÍLÒ†-[,V¨À#rŽdIU}¾yëöoܶ$ƒ ©µ…5‚ÖÉ¢?½|åí§‹YDÍm¾â(+¼aÛÈJFJÞµ¢ÅØ-øÙ€¼ló?ùÑ]½øMóã¾íRd (´8F*ÿZ¯ùÞÜ)£±·ÊTzu\˜*n:9<¹[ð’iªî»¯ÖVwW¦T5ëd5Ö©ëQÀ˜målbµµÆû<‘°•„I,Ëù,µ]A¼Ýtkyr2x$@DÔTTÊă áPÊL¦ÇrÞŸéî6 f)ò¢Õð@©cªZ †@²³KÓåbN?lOpö¦Ñ5édÿîÎE¤évا¨.<ŽeúÒô›~åàè_|T†“Fèdõ”;áì½&7ºDumJ­R«Üc"£º²ÚÅ°­‡ +#‚š‚ì·v»ÙÙ„ˆaE£Ë:Ið8™dsþŒš¢ b0ð²VÑè5|h:'e™ˆda5Š¼(Ã4â)ÍÚŵÙégnì|ûÞ0ɉ/X?Êt*Ëå\^€±Óꧯ“å¯öa8TW1Q Ö4ýnÕÐJä³¼<æǧÃYfNÈÉØ&Ÿth|`JâÌC„$‹œaª‘!V A§V-€þøh~p !û¸ráÒÝçno_½zéßtÚbòŽ­îê wO–'ýì¤9•É´Ã™ÛÎ.|ð!¬3Àdúi«KÜú¯þÖüõÿòG\ßIº‰I %ß,º¼^B_ÕðVl‚øuÛm†oøöÐøMÞ¸€ßlUo.øó‹ÿαrÿÅ‹Œ*æî€/—xò=ßõ®ßñû_ºqdídÒMáržs–eqåâÖ{žxÛ“_ê4+)êAœ²{þÆág>ûÂáYÃfy÷ÖW>õ‘KišO–Ùœ¡ÛÚÝÞ¹KÙs)å%š@Rt^BÔ!e¨$¥Š‹Ù M²I+f³ƒ“ÃŒeš¦½½éööÎd²EW_½öÔOÒ©&"R¦Æ"—ôÚ%}D?cøší(ˆ®Eœâ§"ÿðïþÈ…®NO»®Í>H†}jDV±@Š¬¹ž5R’„h0JÎ{1epÒnAF ´žÍãQ#FÕ B·¿F`›"e¿¼½‹œÕÀ ªÔ,"uØ«§¾(tbím‚æÐ*â+ì"…%ïJu ¬üÕ¢Pxˆ©UPÙØÀþ½ßtöýÿÚ{‡ÙkCî™E‰ÖšpWQUE”€ŠÑA0ôÕëwnÝ>é‚S!)ù5„¥ÖqÒ&ÂEE ^ºÉ$„óþtggGH6íôý¿ðÏ:ÛFI,D¨*EŸ¡†Å°xû»ß$Ú(² ªÏWìÿ¦ŒI4©QAÀDÈðdfÆÙ)3wø‡êÑ o_-Ú¶©2 B«,jmoW–xåÚ)ž”4‹È¹¨æ€¤¦¹téʾô¥ÉÖ6¹¦™Ï‹7Ù6Vü8Ü£A8~ÀÊPd }hDÄlµy¬áþ* Ìzo)è®ÌÒ"X’ê=éûE+让é&óå|g:¥SLÌtrÕv‡Fö¡Ñ¦D!©"Gw¶¶¯B5èmÛܸùúc>žE‡ ŠE¸Y!U±KöÜ¥®÷þäèxk{Ú4g7ak6;>žª¡k©É³tèé@/| O|Órxo›Ì“5‡“.ª²J|‰:íGaÞÛ!ë‘+‹+êÒÇ{ÕKoE]\Cc5ªEÃ}ÐV©è$-NzIUT}Ñš]0|ÍPU#ª;ŽÊ"èQUÐf=N³bvŒŒ=¨!•…WVG#µúLsÎz»¯ü…gö¾µyf'ÒR8# #™Äq_»ª.ªM£u=mŠâ$) ›Ï‘úi>ñ~á³Ã³a>äy–¬­r«‰.(rXŽ`šÉÌœRëASÕ ­YcI³ÇÙâôx9[6°-M²¸3;øܵ«ï~bÿ…#ÞÈ·_½ûèïþ­‹¼XN“>¶×^Üî<ãh1¿sG„¼}4½pÉR‡ù)ŒffM›•´áüÖ§¿ÿ_ý¶¿û3¯¦ö1¨—ÄaUfˆ• xþð}ð¢ýºüÜxðM0ð°}C¶‡ÀÃö5Ïï1«Sê¾=b¤¨7JQ±‹“`±¼ué}ÿÞ™÷íöölÖßÙÙ²§»zõɧ®<²«†åâ,xšmÁÒ,7ŸþÊ+_|ñzÒs†mä/~ì—º‰ôƒ5*T’~v|÷ô8uÝÎî…®Û‚”zST¨IŠZeµ$nq*/‰,­ÆRü"M7M[Ý–µÛÃìöüðc¨˜Y׶7_»ý[¾ãÝ»{Û‹š”´¯9ÞajdxÉX_EÑ›JMRT©!6?úÿþ{«/<5êyФÒD%"iS’ÌÅ+­”W• µfRW5iš¶+ú¥`¬/MW4^A ãgŒ#( Ha†èûË{—‘³™ÃêBªnc°ì&°_¹Ö„æúÿ ;Ú%€€•=/!n¨¾”*q¡ 5H,'É8Ùÿö»·ýµa˜ùÒ…4I¡ÅÌ !`)ÌÑ['³×¯½18U¦Ã¢! º»–ÐF€AŠjñØ$³ÂÏŒph²å‹9ŸýÊu‘ÝC*DK!S^zôÒì´TN(™þ¥ѱ¢Åu£ ºIN˜¤d t~9öÅUÑ$N[j="½hr¤EÙê4{o–Â]aŒ¡³¶±&ú|zgß³Xz£¶£»  Z¦“[§§[§¹ØÏ{mäõŸÿÈÓ¿çÛóžöFNÙš {Ó WÐϹ˜ß½q« ÝÛÛ }€»I•©¿ùŸÿ‡âãŸú¯_¼=ËÍ–*¨ê5Þhðc´µ¾vûzÍ9ÿó­´¯ë+¶ß@Mž|Ç{Ë£ûðWázؾÚ¯b…¯Úšè»÷óÎ==~¸”²µÂì汯Íø³ÿÁ£ïýî—oÌëßñô#ïzæéG.î=O—§!Á¦IM’ƒ¦_ùÔ—_zýnxšß¿mkçc?û“;áÖ» Z²k@ ° 3ƒuÓ­f²Û¶F D3To¾À%TŒ¨±8 TKž IMÓ4 5!ÓýÃÛï|ÏÛ¿ó·}DzŸu]K'!Z%,î(!£²¶nÙ²¢eUä৻?úwÿ§ÅÝãÆê¨3J†JAyÊÑÓ´+Š’J_-Y£j% V¡±Ö…oH-J^”Š·V%ëŸ(è@ÌÕùÈÎɹI9dTš¸úð¶báS¡+ x5ô÷xÊ0otÙ¥¥‘¥†lÌ"ÔŠ~Á2úÆ Í­?ýgÞûÇþ¥>ú¼àjªµc…dÍl"T=^xõölž[¶ÙKThÉER&€FÔ4:d‘UIQ:;ÃÄD šîÝÝÝÙž´msš~ð—žûéŸùLöÎ$9ÝP)F2¬µAó3¿õ=‹aÞ5]ö|rt*%«*kçaåÝК­2@ \ºŒ?ù§¾SpÔ¦P“å)w§ýßþÛŸØn_ì—r¿AGmj® -ߕωAD”l¤DL&ÝÞîÞãO<ùþrêÚå‚bvrz²x jc÷æ¶ð5÷‡U¢§½RF<6z á©iRJ+{ƒJà¿l5‘Fz{eNI7M–,uÒ¥Ö¢r|t:;›—וØ Dc©ëñ I·¦»ú®ÇŸ†4 óá/D,/>þî'Ôv%ñR¡„u‚•Ä6&’ó²±´µ»ã&œõÝÎîäâ.i¦M#šÔ¦C~2-¾éî—¾ïª?6¼ÜÆ̪@¨ƒÞ16«PPB!ÉÂjüªŒ®ˆu¡ª"<ï5óU¶ÔyJSs:(„ÔùñR¥cˆ²¾5öš+¢&Ø5áê«’ŨɞÉ5"%*I˜IPÃ54´qc¹6‰º+gñº‹Ó×–¯}çŸø¾5Ó6€,ª`R8 x2Z@£®Žã­s ç1*|)Í°5\Ëû/¥Å4ùT!Nw¡¡FF€%>¹úÔ„àɄ"ŠÂ’6ÔN¬ŸŸÎŽÑ»†iˆhÈ1D)t®¢)ÝNÞþ]¿¥Ÿ’;;[w'}×3x|;l‰FÅ—Þ$EMƒÃƒùí;Ãr˜6SmÂvƒç…î¾v¸÷ýñï̦o[–ì–H–`e¬‡xœ;«áÙ\!ëô«¬á7i_/<à¿øaûÓ6\GëazXàa[5žüÀÅ,oº)ü¶¹I¥¿#<`Ç}þÿú÷>ó;~ ~ßï}÷ü‰ßý»¾ë{ß:XìguÒTLÌÀÂí—?ö¥×^;L}“oŸ=±5ùüû~aÛ³öaå\öQ M Fš”¥?=9ÞcÿöK‹³;ƒIƒÌ*€F‘Å*µ@¿’µYÑcj`"Jñå0?-Žg§û'³ƒ³ÓÛÇ;iûõg¯ýÄßÿG˜‡† >XBD¦—À^$3@á E¡#Iˆ ;;?óly÷¸ c= ™Ã)! H©Â+}D€ðR×DR›¦]šªŠi¬®%}sÅŽð`å_uw¹"®9.MvÕ‘LÝC+aYe\™1#h«éQe F¾î<§<:@Pt £´£\é¨Wϳ €¢…DôjN?üýß5ùc¿}Çç/Ñ=\DKöR ªpˆy¤7®ßýò³¯,*Ñå„*V"2‚QUÅÊ­$ F²¦è†sI›¶i‰ì÷ô¡|Æ01Qz¡™ “M›fýì™oyf¾˜µm¦é8âãý¯s÷%B ©ºûdšÀ¾M*ªÃ’{Ÿøû÷g'öÈâ87­ YÆU¸SEÒãàŽö/„,%‡©¨ ’%÷!™~ãà‹³­ÅåÖwû%bá1Äh(”Ð…P‰@&Œ&52è}ÞjºI¯~tv÷µ7NnÚ2%ï ‘†¬Ú$„"j€ù0<6Ý{íÓŸÙKm^æåÁÙcíÞÝ>ëÏ]WOÞ»Çд ™‚ ö¸°=}晽oþ–æ⥞zrpÒžÀM¢ÇEÿ/ÿæ÷c~M£‡°P>+{otϬ§Žœïœ_3qûu9 ¾Þ·;9:ˆQ[ÓámcM£ìó ÍÙÜ?ü+Ÿ;:ÎÉ»³;§Wšé+Ÿø”tÚH`LÉ/¡"á^r¾ ˆÀEW„ôË£Ùñ‘µítûB;Ù€•ì1"‰^ÐñXkªh)´0Êa Å AäårÒL›üäýÜwþÎïyÏ{ßµXœ5]ò¥Ômñ0˜6¹&ñ‰ˆ„„²g\Ú¾ðþÿÙ»oÜèØ–ªï¡J'H BJvjpȘLF„,•Ñ D“¦²ÒC ŽQVÕõVžNÈ’qr…Í7F *¥Ôqa²ÓŠª^RÍT¸YƲ1ãX߻نr$reÍÛnNBÁ˜Òb¥w®iúÄ ¨4KÈ2%<îl™DrÉÐ(ÀX[´,«QäO-±¡•>'!P±bY])jôœ—O>öø…m àöþþíýD+nŸMh=N:Éàk¸NÚØ €ÕŒÜŒCyš¶©°~ä·y¯ °éŽ8gŸŒÝAo[€ˆÙlÞv- ÖXÌjÊŸ¿Ž ˆåìªj&$“éÙé>ç§:¹wqzßÏNìÂ$Kª¦„õ[BEE¤D¨ªÆÔÏæô¾›nínu'w÷÷é¼U–Á`‘ýtñ‹óæ‰ãá{&‡Xž4)9®qÔx!(ÁÕ²©"2œSwI5ÏÙ熬(ã9zˆjg±ªþH‚Q¶¶Ú³³¬b ±¨!L¢õ’dsárLü5zuÆá IÐ,$#È¥9‹+Ð ÅHÚÝJj8(œÙÌü¸¿²½ûÜÏ~üÝß÷=ƒŸjcôlhŠ‘Àµ_kÍ4Œ¾µ’7ŒJÏC{ù@^ýôõíþ‘6Oæyˆ´d‡Þ©Z¶c†»‰ áŒ6© B‚®Ë ¤F[·éäÖ Ÿ--ÒmxùֈȂ€ŠRoâ*ÚÏOì\|ùŸ|ú·ÿÖ³˜ž^ÙÚ;~ióÓ½o}Ú'êÔ&ª † !Œh+¦W.cÙûÉÑÑÉéîEó|÷ßüW¾ý#ŸzþïÿÜ ËAÒDTSDp}ïç–êÍrþÀ}+èëj_ÅpÏŸz¾ñÚCÀoªöÀõþöõ/ã «æZNM'à©MÝÕ+ÿþÿîogyäÑ ì}¶èlÒÑ2…îMJÉR?̶ŽïïûgŸZÎDi~ûÌæýÙµk‡¯¼¾­q˜h-&U!)±¹Å¢D«9TšFT}9;¸ypóåÓƒ›±˜%zBá%œ@µŽ–T¦•X‘ÞÁpÒ™¬õC¯WöÿògŸÿàû>8mÚÜbPɬZŠïRJI®¨'– "™[¶õÙ}äÅ/|±Ó6"¨¤!²  %Ò«2‚…&7¡*ÔhˆhJÖ´Í´ÔôXñè+2}<¶9ÒÃõSŒÔt!¥Ð°HXðâd§-1° Ñ’¨rþ”*^%>OÇïY…ë•ß6ØÊúÄš¯¬UqQÈæóÔ’SE„’-5Ëü•ÿâ?û—qòy§ R’‡ª tWÓI?÷gŸ}õúáļ‹<ÚPÊßŗºI"Ž"€ªj ä>"G« "æ˜|ô#_´´="„Š˜Y‰$¾øè…éî–XQtk¹—d©g*ZºªÚd¨Q‘¢ ÛŽ¦ˆž­]øèŸ{ýÅ“»Œ0irÞÔrÉŠ–U²£É1/;œ ’B-<÷v¿í™o¹0ÝM%_›/åE õQ߈šdeE¯cÝQò56Š:ÎÙø9¾ªÀØÑ/D DøÊ’”|ý=¨fó+Ö¸G6FS( NŽ›¶ÉÙÍ ½Ði¦x±¨9BùâÒá*r(ºŽÌfEýo>Ç•N|TÉ– –DÆæÒE·€âIËutÖ˜òûy’y„ß9?("¢QsšªŠ™&A”RY«—+õƒKaˆ¨K¨$œéö|ïµ÷¹ÑÝÞC ïRý U5ºD‹¾­îJ!á0[.r×ïΞëo~òh'?¹õC•!H¡©ij3˜4! ”FLCÂáê¾-Í69æ·î¾r]Ï0‰mõN)Ûz”z%*DE”"1z´J‚Ý~–§yrðòu£[’Ùìt7M›»qðÉ—í´Ñœ†¼„gÀ& …ŒØjí‘«ÞþÍÑl6?»ö7ÿÚ¿ùO²…Ó‰(r@áùÉ-›ëíÁsäׂþïù¹ù§{àÄCôÿ׿ÙÚý4ÿý Þ›ýzÏÛüÂrº‰@$÷65ýÎô/þ­ÿê8uÍ– _zøàCβ ’AZŸœÌu²û…çÞøÀ¿4m.žÞíg''>?»Ô¥ç?û™‹íT2“ˆD ÀÔZ°fCJ HˆÄEÊŽp¶b]g'§w^ß¿ùÊáÁµåüáZ@‚`ÅÄøF8¤3B M⩇Å|Ç4Ïúÿ±Ÿ\žÈ)»XR2` Àjüsͼa’¶^ùüËû…_¹Ü]ðeˆd¨À µP¸¡@*øômmÒZgšdÌïs/Z«ù4ëA¹†È{ÍjÕ ˜ {ÓV’U5i‘kõ›Æa]ËEÊÇmü 6IÉ5\áù?°rã,Xã5N ÐÃashjZϯþ‡?øÌã;×–Ë#f±hS¶ U#$Ü$eNž{åÎ_zcÑ'õ P ÒKI$JŒAÌ+P{nÚsõ—Ôî¼v÷Ö¥']"¨m[ôøÊ_˜ª¢ÉÂÃ=¬³œüêÛŸöˆ¤¶2¶¨©ˆ¨H)e5B¦°® 2 `dñb„Úî¿x÷—åŽîÊ0ºÆàT˜Ôe–šÆe\Æîšfj4ƒ(%T%û°µ5}÷;ÞuõÒ•À¢iÑ»Dj>úéO§nšs¨Ä0V³®³ã>ðþ&AëUŽš„°ÀN®Þ±ðõ,\áZ>;ûPƒ_ïÝcˆèFÞûAçÚÊ”)ÔÈqtt<™L"¢¦Ì×R¼@òà¤kÓá몘©%Ï‹³“»­!<—¥aRs€ÆX `¤ D‚0i$Ëìøtv|´Õèüð®ÉÐç…‹õnKâXp}çê¯ÜŽ¡»à¹¸A´R× PZD)û±®{M>`=‡Ï÷ÅXª°ü^üuu“¾bú¢ƒ€M+íÔˆ€’eáFÉÝÖT;uÚ±ŽÌ=ãQayqTêhóCU’%ˆAµõ–Ï“C´Ë6Å,ÑbÖÎ&rMï~øõ)v—ÁHÕÁ¢:Œj6EÉŠä. i{\êÖü‰ë:;zV¶‡Gû™Íà)‡äFUŠ‹º4è”Z¢½²å¬CVo5íÄÖtÞ._;;{å ߘ§ãf»â)ç ] E„2–™Cª@¤è7MCAÝ’éì•ÓY|†m÷§]t—æ;wù9Ù÷š‘†è—È®Aæ %,(Ðí=\¸,ÝTóþÿùoÿÕîÝ£ÎCÝ0ÊÞdIœÿõMWñ[o+ˆ¿ú·ùä¯ýó¶>í¡ð›°m.æûŸß|ü–öšÆcõùSÜCÄÜ¿÷/þÇéòÛ¬‘ ]ƒ!ËEŠš¢m¬IŠÈ>øöΕøÙž»µ»uñæõýaXݽóÔ¥ÝýâÏ^ØšDD%B+÷I`DX7¢Qà”œ¤B#¢d$lLƒýÙéÑ̓;¯Þ}£ŸH¸Â'ðˆ,J”è˚υšƒ}ÛŠù,ïµW~ñç>ðòs/Mmk(9æ™I‡Aah™Dn^{îùýÜÏ=qñòât‘ %[\Â"ž)ôyB1ÄRšZꨔ2³Q1èŠÞó]—3Õû¿Þ©‰¯u¨( TBÂ÷&;$¡£$0­ïåK åj°+æ©J\îøëæ<’{ BWb`” |É ·”†åþïxïâýK;g¯ë&bHI6wîá+/Û>$A /ǤD±odE2IWS¶Îq–8CRNÎúçŸ{É=$…‡@&_üü îM‘;C$è€4mZæÅ»¿í[ý¼i“Gåã!d² ¤RÝ‹‘aj%Ô’;‘é×O~â'>úØÅwÎOû¶m}ÈãprLöXXc<9£NcL kP!Üûi×=óöo~üÊÕTËkŸÃÚæË_y¾@dU•RºAƲmuÙ>xU¿y[áÁ‚ŽªÔƒ£üì0àÌŠ‚AÅsŽà¦ohüÆsn‡5É¿1ŸVɪõ‡¨Ž!ç¾Ƙã0Û2ó9<稪Hxø¢_že6:Œá³ãÛì .t°¤ (j+xš¬jìR›)JÍnQUÍy¹˜py´Ø¿9ö‹> =äTómÛû¢>ýùùÅ™î /\rÁô•v3áŽnÄúãýrU^ú¾­{\²ãÖ·6h¹òQ±C î B¦¬]4[¶Ú6eäó‹ýYÀ}¬cí¢¸W†TöäÑç`Uͤ‘±n6("V•¬fÅEPsBÉÜ^î|þn~q.2í%$áîc>4ºÖjž£É—š[“WþµÉÁ…n¹µœg$!4@(ÝÝ`¥´ µºÃD;6]¯ÃþìøµÛ§o¦¥uyÒúD)¹ø©Të:ÞoÃõ£ö8ÆHˆ4˹_˜^~å³/íÚÞüô¬MڟͱŒ+²uûã_Æ­EʩϵÝ%Έ B¡m³5iwÚÆ®^‰ÿô¯þk­ï+C !U·sÆؽ~€ÿ_aryÐÏÛçÛoüö– €‡Ãû/PãxÊnò ¿¦.gŠJ$BÌ™)Ž„¿íþÂÓè¡Ï>_ÞN·a-è­¹ÙÂcImÎÎäg~ú㧧m’W_º‹avãÎoyúÉO¿ÿ®lu²¬ˆõÇ[RõVŠPF‰*PQpq!G¡È  %Ø2:fNçG¯Þzáèö«ÃÉ O! LGý*ɜЈŠ{VeæàpK:?=¹´sñù/?ûK¿øK&b`¨aˆL‘€:qesûÖí÷ýì?{tkwy|f­fTü¥,yúª«›£LD55i+ÙÔt¢ÚVà@ÂÊÚÆŒJꃄ•—6Ö·€*!aF¿4ÝnA“ßQ‹ú¬háXquÑ—ãÉ]Qî¦Dwü)« ZAnJ@Bq‚ %`zpÔ¼…s¹Ý½ö7þÊo;;|Ö; ™™4ɜٕ'Kÿü‹o<ã0¸ƒ!E 2¢ª(#bÌ?ŒÆOÍÆ?†VVó&BÂ)Önÿƒÿù§üÉ–±û>ó©šv:½ÆPQÌúÓ·¿ûƒzê’çE DZ×t¢"RôâÅT[Y¤pfoå¦í¼ŸüÄ?þàãžšÎ&]Ã!P>…'.yZ×cZmA‰Ý$à *|¹5íÞõ¶ozÇÕ·™”ëeݾ(ŽÅámíOR¸‰¸²®¨ \ª” Å£¨ƒ¢ö&×8<›]¿1 í—ÃLe‘üXãÚôÊGÝíÉÕž¢Ðbí¯ÍÖr{"«ø˜uã*¯6;m³÷Êßkˆí¢µÉ;nѬàÕ1 Ò„mg2úí΋Lˆš™w5$ J¼¤ú(F ¤ñ Š¨&ÑF­ZWì¨c %%$‚îCÿXºðâû¿h7|íiI?ZâºA#" tÃrÙuxêÎ'Ž^ûØÁ®\éáÌÚCØÃØZN M–²ì­t SèŽksØ÷×÷ç¯ßåÁ¢ó¶‰ÄˆŒœep »µn†cßV/ܪoÆófôyª è¦æó¸ —^ÿè‹WÚ«ÃÁi3ÅbyŒåâÑ­KûŸziñü­6ZfA£%õT8„†*î nm7ýàŸø—÷·>ÒÈ"˜ÁR·d%Ì|Ð:Ù0¼ï{ê×Øø Ÿ=ߨí¡à7[ÛÄý«_ï?ÎïgÝÞœKfBFzv(™Ò£ï|Ç¿ñƒîÖÑ~A ï³YHL¶'©iòâ'?eË^µ>¢…`YÅVÁüøÕRÿ¦õ«v‰j© I1š†*­ na4¢-ÙäexóäÖˇ7_9=¼éË3œJzN£c F„KM±!Aöž­I‹³ùD¶b!?÷“?wûÚí®™pðD‚ƒÀ ËȧóŸÿG?ue²³<=±FÁZBª8¾ªŠ•oUkµÆ´uŒŠœÒÍ#ì®ó ®¯r­Ä÷k®Ä9[¦d.NvZE0 —0‹—Rˆ€{íÿÙ%+¼¿ûßþÿdÏïl›Ó}Œˆ¨ ¥öð5×˯R¿çsRÄߨí-í»oü&÷ýúÀEËû¬ÞûàYÀ+¥Œ ÁÄ) ÝÍÔþù¿ý·¯ˆ†á‹h&[€xß7)žCO½ùÅ~é…×N}ô]×_ºvtûŽD>;>¸riïäîÍ;×^ïdRÂCµèÖ‹0z¬†¢u÷ݧWÚ”àŠëFäTql©ÄCšSBŒdÚ šè9;œÝ~ýðço¼¼Ø¿)‹EK¶jIR+é»-•Í^ÉûÜφfû ŸúÊÇ?üÔŠþÁ¥'—ý‘¹Øm/O›d$PŠBˆ™´ 5¤F'¶ISR…Œ5¤„+p/ååÄ­·DHÕ`Ç(щ’Ód'@(¨î—¶öRy±&Ë«À¶&áHéG ŸYAíBàaã˜5&O\KÖS*JÊU hô¥¬¨¡‹výɵ?þvŸyò u‹ðFkÑöúÍ;ŸûÒË·zkö˜3âKX_)QŠú®xÿòýØgMè+¥MÛ¿üÁOuíŽHÓ´]†¼œß¸vs1r¸ªH‚·¸ôÔc cç°¶Õ0Po5R"$\Í!Ã^»}xgùê‹æ­–j²Ä·œ3º‹EÁ’ ,ÜR‰ˆ6ÙÓO>ù¶'Ÿn,®"B-¯±!çÔM>ÿ¥¯¨uTSPÌŒ±‚“¬¦Û ð}{ýj[8Ï&TØy/E]§ÄZ_Þœ‡am(®¿ŒòÕÅßE¡¨®¿•·–E£ä¬Uw'CÈÆl¹<1 F@ÒÅËÍ–ýdÊ£;/uÉ0Ô0i%Ld̦Fm‹*ý*|¶ÐÄUņÁ[›êÐÞxYGð³…KénÊ¥/Ä£_ÊÍLsö>2IáCÀÇu-Š­; 㽫+^KQ¬;iÃTXý.#(5V­h¾øÊD`P" Íš-u!)™'•°R…¼NÖu&‚¼@ãêlXe©©¶w n.NŠê©Iˆ¨¦b…ËfŒ ’Õ)óô¸<ñ¥úÙæø‚äÖÔL  ‡f†LßÿüÙ˺¾çbfƒS :UDTM²÷°¬–;Åv¶´Ÿýúéüå»ÃÍS›¡É1ðÈT²”•r.&MÉÙ%2C\[]ë]d´§V&«¨ 0É»íö[×oßÚÝÙ>óù¼Oyè—[´Ýc9üè—lŽÍR$‡ 4Ã!S²Æú&ïÿßÿÎg7 Pµ’>eMÉz m´¬å_/¤þñÿ ÒJ€~“´Mdϯ嶓¯ú×ñƒŠ.¹n@€ªŒìÂtk9ûw~èuÜn‹bb6 ‹Ô(U4IÓ©ŠQ›k×ï¾ïƒŸÞÛ~²õÉõ—žŸÞôåÙüôøòööå­É—?ññÝnš‡¢”Ž=w¨ ·{#÷=òÔäsÕR—‹·%“ÊÈßÀœp€ Š$ÕFLò0ÌŽo_»sí¥»7_9;¾“—3õÜ(™—Ô›¶Bª@PR<›õŸùÄs‹™Ÿ,<° ï=ß=<œN·òKxÙ‡w˻ϧM“PFĆ?ÞÌŠ@]Ôo@©–Ë÷¼ë™÷ÿ̇/MÞIîYTV$zé»õÖâ¹,iˆLÉž¼zõíO?=i[†×Ús¥(ª9{ÓN¾üì³0ó ª"°Aù¤QF¿ÙGo­mν‡V{r>7Ö¡ÈJP!Ùy"<¯?m ]7M÷ú?WÏ°.äs׳º6Þ#¢ƒûr "ÊXÎÏLÄR‹n¢]·<›åÙQž™äd5-o0!­¡ú"cXC¥±I2’rÑ÷ iBÝx9¨Ç|ég–^O|äøÑÃíw-£SD怔0Æî Œ!Rû^ùKÖŠïÚîߢe³ãj_ŒfïÊæ]ïíBˆšU^]AóÔ² $Á'" Xñ³†VŠqo˜c5 ä ÷”:å@ÔT-Y‚@Í H²WB™Da~Ëã/þìçÓÙöš-¨}˜ŧÍüÒëï{yñºìø…á44%PéPF€ÑP&´¦‡œõ³7îÎoîûÁLgÒÅVò$@—κ#Y÷¤¢L º¬¶_Ñnm›ºŽ[`íb!jU™Ï—W'Ýü«<Zí²Ñ/E³y–/b{ÿÏbÖ1õy;/ @EFÓjZ~Ï·?þþäï‰å AO¢‚u¦q?·Zðkñí}}íÿ_ßó°ýº¶U’é¯ÖŽí7x“=~àYÿõ€ˆH`vzv*OLÿm¿û]¿óîÏcÒv±µ½5i:óÐXîluË°úùç_¾ó-oÿîÓëgûo\¿sã ñˆå°×m?¶·÷+ÿìg/ïìæÅP«tÕK^)aÎ]i¡M åOáˆùUhêI‹lt¼èÊ Ž|VŠJoK&s‰P!a" ¡ýryxçðÆ«·ßxñà×úÃC[.[:b q•tï{‚ž~òÇáú‡—öýñÿùÇói?œ,Äà@ˆEˆÂˆ¬&Éš&uMTS9tVi:+g t"\—’±(<æúÔÑ‘ [gƒ”%$Š«"ŠØnºiÓ‚1Nƒ5…XOµR­ ë0?–ƒmYmš+5°ÎêY,²Õ±4jΨJ\IËœäh iP—ÐåðòôW¿{ÚÞ š¦GGóϿüâ«/»Fw<+EEÔbðš“qí¾8‡šP7  lPÅ ÉFúܧŸ+UMN6[§§ýµ7öûEn¬ (Yâò— hRŠ¨ÉRÇZ¡`„©U®v”qK1X…D†Qa·^Ýy§C2Óž¹d´Û¥|q±¥$KŒ™>þØcïxÛÛ·¦SF¨H¹UqŒRí˜Ö¼~óæÑl.ªŽÅun *²·döo49ÿsáq(#|ŠYXò­Í3BÄÝÃãþoæúñ0ïÙµ*)~Ï×Ò¯5¨P’_QÍîCv˜ªÊüôtªm7ÝcÍìO5tJ•ÅˆÓ’¥$ 8´ºd5 r ´ÂKЙ#d[§§wnÝ~]òñ²ŸŸpò2Þöრó½G²-5Ñ1AØʽi0EI0¹¦kÖ°};ñÀñ:¿×¯ÆEVµÙǘ¢‰4Ñ4‘žš‰¬`5~êrµIm¸Üî7Ô(>+©ÚÂÑxP-lz•Ò'kŠ0¨–*ŠJÉÇ/J?íùä¥÷nÂmK“Ìí&Ÿ}%¿úK¯o-/¥ÁrŸÅ˜™a*É1‰ÔÎÃoÏ߸³¸~·¿}Ú,’ÍLõ¾ì5Ý0Ïjª@)3bÀã1^‡T_íæ“«ºÒÚƒ¡zÒuL‰SY¶ñ' ªÿ/{mÛ’fas~kï}š{î}÷õM¾Ì¬Ê*U• ¤*YXBR!!Uƒj,ˆ2C0ödd0 {ÐÈ2C l0Ætö@B*«Ô¥¢P5™•]eæËæõý»ý=ÝÞkE|Ó?"b­µÏ9÷õYÊLÝÈ—çž³›µbE|1¿ùuÆL“©Ô-uXÇE ÃÉ[7^{åúË/߸Ö2÷iÙÑs:¾{¼¿¼üK?÷ù¿þ“?}xû®§à @p79ÌbØ1®‚-ÖÜdÕsaûç´vÝÔ‹_7(øø·æw—Ûϧdpfí/vV]Æpê)ëHEըݾ¢75°Û^f©Úì* ˆ¶£‚çx=EÐ2"˜}Ý™mNžÿçþgßû]W,âî /¿þå¯=wr’ñ9Ž¾fr3oÙžflhMcZ§|2j£¦?%fp`ïS¿øeÏŽKW/Ç®;<\_}ä‰õ‘/Ëõº'ƒuæ–zâ‘jT} 4ñ™:FšY0kÖ¥qpºÑ“¸ìvŽoÉ-3©&0Ê!¹¬Ö(‚êîn„‘Fãc>úñ<½·³SªhPîN’frƦOÏ¿ú*Ëü¡z3»ÙŤχvnk>5䉺[4¹*?š5 §TŠNRÄzcÞ¦ƒ“G´FpûãM㨊?Ý”0x–{ëON4$)÷ƒ‡°€'ßœ†aOoG ¡e6c«_WŸˆrIöÛ<çT"Ñ _X`%Ûµ•Žî¿þ²oî­Ó+8øYâgû'o-¯lØD± tá00Iu{€&í«žyW3%xü9Ïôë\Ó£@ÉUÆâ‰àaÅ°*v€R‹°m”Gª[×npçn[Ç¢(Épw³©L±·. ´h‘9Òƒ"³ãf±¼¾¸þ7_醫Þ,üò­/^»óÌáU>ê'&G€-W¾XzÔÝ!Ý::|õÍÓ·nëxˆyÕ¹K—[[US=Ÿ´ep[yæÑÒ „^L#ÐÔN …÷P Œ§§ùr¼òêg¾¶X^és–)¥>ù&†;Ç-®œ|íÚéWÞì°ãà=hMK(c‡¼ ¶>|åÏþÉ?º³~k·3!XsÓ¤xëïì¦ü^5üwÙÎ,Ò¯¿Æq¿}xí~%àoùvæD8G¡½¯Ëµ>ÔË yJ`ÞÙûÝÿìÏ{—Wó©“1d’\¬VŽð?~ú«¯¼uýê×îܾ~íèÍk9B|èàà+Ÿû”õjvÅI½Mq´c° Žäbù&PÝžv„3SÂû™Ï®–ûý,°‰¦LíÛXynêùàm”E6­H£(͉Ipåž“…°}‘9˜¨É%ϸ{M—n0mC-eTÕʇkQh£dRêâ"š 9å~`X˜,Æî0÷Liy³¹ùPòŒØ±·€@ Ù60IV4 -£O¶Ì†,‘ÌØeLýúÖËÏï_YÇý‡Ÿ]>nýª§¿s÷ø³+ž" ¡C†Î`íA& ¿ŠD«/¡ú„ãš«b6›Ài즫ŸÑ$“ÆšÊ^ BÙõ,j¹Œ½§¼É-êjÎ?Í&…í{±þ¡UɵAÖ¸tV†œ©4$@£Ü‹gb2Évyéî3wóÜûèS×>ûìæµõáêÑñ:.Ão†þä$èSMÜãJ9;K¢œÌP¢š§p'6hæÑ_Ÿ­ ÏLqŸH´Gu+kí8•8)ˆ‹¤9Q2½ÁÒ†«åò/|åÑïý؉Ÿ ¸3E1(ö7O.\îßìoŸ¼xå{?Ê8¬óÉ",ší:RÜa †‡÷ð¯þ¯~ÿý“ÿ%/=ºYo–«UÎîîjæB];çÛצßGÿßdí¾ào‡6mRéSÛ 1Qadà0 ™~â¯þÍ?ü‘_óý ¾¸‘ØYì?󳟺}«ôÁ'Z G›;¯¿~xã:ØÁe—¯<øæ ÏÝxåŨÁ`rTß‘vˆ‘–³'›yý7{î<*pú39îì˜(½²ùWV›^OÎ ÒŒ6ö†ÈžHByC¢ûæøöÍ7_xã•gûÓÃáø® ƒYˆ¡#¢TʆÆHî’à ’«'0F†³Gû6*7SÞ–ù§ÿ¤1qd¹¸›Üà;q±Ó-¨LUoÑA¥ðb…«÷æã+ „ Vªqôn/Î4­£@K+ÞbÕ‹*uw]æ1z}ÃÁÞ›ÿÔïý¾ÍÑk/¼öÖç¿úâ½ ;Ê,üw1Lx{VG'ÃÌ…½áM62ŒPñš‚Ê%+lÈb·ø¥ŸÿÃnŸ5xÞ¿|px”d_yöÍ·7.¦,„°Z-W;;%‡Áßä©â‚2ƒ& ÆXÞ%xñ¾1 H¦lòä“»ÓP®Œ^òÀÒ¨RB pøêÕ>õôå½}(’ŽR© =»ÕYcJ¾ÜÝýü—¾´Xîƒ[`q¬ P Œs5E4Ö]A8¯?X›0è\+-?GY¤ P_œãÈI£Ÿ>Ž­cšÿÙ§šVÏÙ/¶–‚eÅäy3 ]é‰Ãò°Þœì‡~èO£§ÓÛ¯ïtLi¬¦d5Ý@%dÊ€˜Já>~¹*€P z&A1ÈvcwzóõÛo}íöqz%<öÿ{7Âk³ʲbh0’°’˜ ãâ*Á$k§ö†{TßËB°%˜çÉ%ÌÊXEÐh!†iq™½õKoýÜ›zÍö†«é‹ÜmnœÜyõúñëwüî°èãŽVw¦XJÖÇ$äã2d©ƒcî€ÚÿÑ1t¶ªƒUÂa˦ÜH bÌŒ*4" PŽNåÃpc}úÆíÈ耻˜³/üöñ"ñŠ/ÞøÅ_¶;ê[ Cª! €<¡3#nÿîûõ¿ýï~Ãmî©Ô!¯Y¦ÅÒ  gWÌ× ýsû§Î½x¿}#¶û Àßíü‚‡÷¶chá‰j‚ À²™ ZuO~ü‡þðßÞl!ì «ÁcÆjµóƵÛó“Ÿ«K<Öé­W^»uãåróö/]{ý¥¯|éòbWÃm4ÏœÌÅU=‰Ë±3¦_h»ðT”uìõ¸‰ƒ¡ú ±¹î–”>¤Œn¦@T˜y gÒÝ‘”0¸)+»ÑM´¨ØåÃÃ7n½v|çF‚bgËUÜ Œ¥þ¼£'rÉ.W]!Æ )x¼ˆ-ÌùŽÎ> êr®ëÿÜfÈÖëŠî«7ðoÿ;ÿi·{9°’O|ü‰Ãþ¸‹Ý(eît·ätg­æ ‚ÁÆåÁVÁÍA"…€NŒ¹Œ\)"`‡÷ ÊÉüà•ËŸøèǯ\: ݪÅgªÿP¨Ó\¢à³Ã–Ë/=ûlïHƒ’ã¨i,™êVaÛÌ~°vþ¸m3s‘µŠ€9çQZª.‡ rÝû-#X]@[˜³If£æ1Ó MdòÜÃr±Øl5 L'7¯¿:d9ytxgiæ§wÓáU\¸ŽÁB€ȘcP”gx4ÊZ.8$c®ÙB‹,Ú5‘}¹ ʇ·ÞøÒãͧî|òÎc·ÓÕd¢ ¢ˆYÏL˜3¶yÍákx+Èq£Ð|Äf㦑ì®ð}{â„èËUÇ(Á–We»¦Qk©ÞÆ'¦ÝgœµÂ̬% N×¼¹¤"r¼+¡ùn)Y¯è€íç½ÍóG¼þîæäÎñíWßÂíÍÞ°XjÝLryF©n7g¨ð»Z¦×d¦œˆŒó4F÷¶CfÜVªysÒOÚãt0’£Vvš§;(KY!ýúr¼ôÖ^Z‡e^ɹIkÆìd}ê6wo=öÀÕkŸùZÿâíeXåŒr9¸–æ ôˆKN^þ·ÿåbq¼SBPí‘ýFµýóàCo:÷óüŸ÷Û7\»¯ümÕæªù{ÕΛÎP̨eÇ –³‹è-ÆðÏý«ÿÊíã÷Â’‹hÝr÷Ë_}åÓŸûòÎêJö=Á²n¿öÖk·"Ì€€nvídó§?w÷|€ÑÜÁê =ÚŠë#Íýt:ðõŽ»Ì6ƒØ¢f‡Ó¸Åcµ k¢«éF¦Ï(ùÞ`0+Ü™7¹w1sýñé fÙ0c f­WETËM­¶ÿÜîøü©­éJV@óˆxwºÅÎbIÏ-¢æÂ'­814ÏhtªT½Ô€†µ}v»ÑûH¥ä­f}=;ðláKe1*#†¥²Ãzèô;žÖw>©/}ù ½‡ØE©„¶:ÊOãüAÛ9ÍúǼS £TÖ”M™Ña¥.ȃòêgúóƒï¤L€fÝñÑéjqðÿÛŸÝ]>|tûFÄpåÁ-VË~øú@4X1óW‘ˆ!Žî'k–C5Á‡«‹1”p^£©GzðãO~ìK—å Ȇ’Šµ4$/µ˜ÿÂ[7nݺsTÜOÈà¥æSQt竽â²jF˜[Ñ>h§cv-6-<|F¼€) %jdú0A®­KŸ½UÛÕš+̘kh¤Dǽ¢|š’÷C¿1÷Ó»×lXfšgeG(ÅÈÍ=TO €p–ˆ}ˆtxI Ò•US4)ƒ+"^b>¼ñâ«üŸY߸ò}·ó.ÀDy­ú×ÔÈÐúŸ“¼#ÔkñÕ#H-arÇ™^_ã¤ç;šV«bæ¤}µ³°NÎVøÕD÷ul)¯Èí9¯dÿü+ÙXÊsÌöHnMQ+„ ¢É,oprsÓßÒ>nüÔwã2ÊÆÊ%O1i9× Üã§eƒ-åPfÎ;Ä´¤·û;;k¶×ǨüT%Jó·PÕ˲Á¢hgB7œ¦‡W¿üÉgØg‚yB©ûˆIë×n>|éªÞ<¾ù¹çºw!¤œ3@È ¶Ä‚7þÜŸúçy÷µ ç\÷ÝQýàØ•3;ä¸Z¾:¾n—½ß¾^í¾ð-Öxî—yû +¿Æꃒ¼Y&RvÃüþ‰?¦Ý]Ƹ]¼†-OrøÔçŸÿ³¯^ºü°<š"¿öê«o¾þº¹gH!ÐòåžÿÜ/ì‰è½l–D)ÔU½iGð;óæ¨ÛÛ6‰}ÏÖ`D ·â»D™—B<‚Oñ6ž³~J8DÁDÍ-¤=Z¶ÈNÉÍ0 'ôÜ1˜LŽhŒ¡œ?Ns2—a¥ìxÝÙÈßC¹Ñ%P0}ñ¯ŒAɤHî­vm~*X`;ïY]J€±ôluh¨±êþ@ïƒ,Ô Ú2æs»)tÔp6ÀÂÖ„ê’¡º¢™Á%˜ìÌä;^½rõ£O>}°»Gf˜êãW‡å¶ˆêô1惒§!ë…—_µâQgÅ‚2Ö$›óï38¬†YfËäÝ-©wjóûBÚçv##û~c-ñQ³íhö©‘ Ë${UT äèV7Û÷£î±d‚Ê®¾ïWËàëÃþøR¢çÎ:õi½9é¢åÍÉæÎ[ËÈÁ‡!¤Á’Ó ìûoÜú9Ó&ãÖô.Š“²çæš„ùO<3eŒŸiQ.VU%+oŽxn”åúu£{RÊi—ç2ÞLÙ ñääÄ=wôÍÝkéèÆs˜€D){ !/©ÀÜ´h¢z­TLX]ÖÊzÈÊ´à²n¹"sÏô5íþgŸ¹?ö{X-’¬wn²çìB‰ü¬…Ì9™´€i›bµ; ªõK‚æçÕ5Ð’Uþ ¯eÝšçKõZQ-øb¢h>Z×ÜÝhîÙÌÔÒ+iÿR{kÿ·)¹F-½ºêQ™IæqCb‡<€æ–ÖZA ;œ€•í¨²AVCñk1¸æýV+»ät‡W/ QdZìï(iÍï>P.iß)ۦЀ¦h±%®ß"Ëì j 4Æãtç¹Wwvwûœ³#¥Lš™å>Sæ§ýpóèêòr¼µ¾öÌ×, 1†4¸dA©ïºåéú­ÿå?óýÚoÛ Þ+×4MŸAÕ~·Í~_Ï6Ò ó?ϼx¿}õ-à>ÜÿVio³äÆ•©ÙŸïØZö ¦q(µRMX3í}ÛS?öãÿó7ïöû—/u¡ÛÛ¿úÊ+×ú§~ét®ìôÇ}@ôÓþúk¯Ý|ëº\.º–»añÆs_:¾öÚRÁ`,5¢T©Ü÷5wÊñ±õ(#r™r³ÇÜgÇbd¸ËŽ?žžåÏ1Uhq!%¨z"ÊA¢æyR`& ¢gä„̈“þÈ)™{ ë„»‘\°3QÌB)þ¢ªXÀ¦v÷íg™0L9ý7\`%•ŒçHìîX=T \%Z±Ø·gÎãù7ÃÙM»h¿ÔAn6ѯF@Á¬Å¹Bõ·úsZSŒƒ–—»ðx¶†ÅÎ:l¾ã§Ç'†“þº=©ø¾“¶ÚšMÖ€¼wµ¨Qêùç4Š”‘¦`²@D€äÃÏÿü/#ìžöÉa!„a3¸ÂK/¼Vˆ2lú´åR,³’/1Ó€’ì½úC—ò^¥¯M? *O¡R§š&…¢¸Á­0yè Ãæø‘+W¾ý#=ØYRd¸†ÉAX¡aæÈB© lÕ^syXî|á¹çâ0 ldÏK2"´ÑQ›® _Ïsçž[-š÷Ò¶•Žó;{}þaGÎI[Ÿ›4» ³ -¸¯¹-?Á<Õ¤§šÙ±:¨8Œ–Ý×› Íj¶Ë’m—Öo6C¿ò2øá›ÏÙÉÍÏL½©_pص„þ.6Ga–­€‚MÆËN[.|f![X;¬“0ô«KÿÝs§íú•ðñ_ç]^=ùØòѧvz|ùÀƒXî²ÞÕK©„[ …2§õšc&ȦÏ<}ÚFVÑ÷ôž·¡iÜA¦*4h µÚY˜•B^Ç‘%ó¬µ0¡ù÷g̦·0å®b=ðÒ+Qf0³åbiÑ¥X<K´õ§›"Õ±«Ô)v >{}òÌ—OÑmÇNBgj›]IØ…«3,ɘ§ófrO›VÓY ¯rVVƒ*«593;=+­BwûÅ7†k'»Ý®ážsâ* êánYÃÍ;ÝÀ‡yéΗ_OoœDÛQFÞƒ”†ÕjsøŸûÓÿ›Ý|m'䜒j–«iN[op6?+?`»NœYÞ÷Û7\»ïô·[ÛÚßý×X¿KT7hoW^¯øGþ¥åhÝjO\ÅÕê™g^ü¥Oýòr¹m¹Ùøj±k Çwnß½c9Ëe·ê² 7n½ù•g÷îçFCÂÌf~?ÀPë>3g€Ï°8÷'/|í¬Ú†J‹4<£ZiÜî×µì%­Ï}ö¡žÐ|B ´dd4Z«,Zˆ^qæš„ÊÌO'Qã÷0¾LN~ÿt.íìÒe,y0ªmجzùäŠQΆݠc»_;75Ý´8)Xqn'Ž ÁœA ®èˆƒs %tˆû!^êºËä%å°[.ºnùæïþíëßúÊÁþ^NŒF3ªy‰Øháˆäæðo<Ü':sE†tyãüH³È° :c—†Å/þ¥ÛwKh @IP|ík‡§§9Ãb()KOš§C Gh:­¸þÛ¹Ór»h¯±-jŽÏåîyÊq4IÝ´¡;NëqrûÒtA}ªq©%Uad‚'§Ç‚²g…­8u9Ö§Ç4ÏCZ»óæËý­7âæÈNî wÞ<~ëÅþÖëwÞ|v1G÷¾[†Ú­øð[¹©×Ü3sM,Ìaˆa“|¸úÔ¿÷“?÷’ï÷ËKÃîÊ—Kî¬ÂÞþþC]yüñ+=yéÁ‡WWÂjǃõî©8HÂÔˆz¥q½4o(ŒJà4![r€ #’núuá è40øjoàõ¢ø²ð MY¨×ÁÔY)¾º‡(/.ZBXÄc,Ù?ë7(³`Ã&)ªä +zÇX¸­‡úÞŒ&À·§úÆü‹ógŸ6¹tjKHÛе•Õž±2Ívª"º­;3ß¡v¤eðÄK¸ôúç^Xl"e­ô;û¾7³¬œSî<úÍÜ=½ºÚ=}õ­Ík×,¬‚²úu×û»wþÌŸügxôân4J¡=`¶Òˆ¶‡^Ø.î¤ÍÝ9…ðõØbî·Úî+ß’í׳Þë‚aDáDLÑS†áüï?õàǾ'K›µýÌ_ûÜËÏÞ<Øyˆ™m¹ØI›tûæÍ×®û²wà9‡áäkŸùÅ+‹•o` PEÒ6Ò¶sWý–÷§±˜ãûw÷ ¿x Uj *`‹ £äª†Ï¾6âqµè02#0÷Ç –5F•Q„Î,¤@FÂäFÀ(SM Ø(m?f=ã' I9ò*y,ƒ.íî…êãôWî¿Á¨‘ýB%½*®eˆ&Y­FQõ5€Ó=$¡D7ÒeàÒµHè=½­†¸“ºK¶zЖq÷Jî–Ns}!`µ³Hý«¿ó‡Œéùn—›^ÅÀ€Jb5欂˜)ÔaÂ&•í-Î1¨Õ—œæ4g…b¦Ê94MAŒÙ;³å°æº_ýõŸú…n±›R"¬æšÅ×_}k³IÊNÄb°¼wÐeÑŠÉ‹æîT”XýѬ$”‚9bçiÕƒ-ózÖbÁÍúäcO|äñ÷”B`(t&dÍ_LjðÚ{P^3J¡ ‡’óxÝ¿òÆëIµºeÂf#x"ƤÂNå‡ÓÎúÛ Ê- ³:¢4#ÀìBœ¶ ‡Oßž³˜ÍA¦Á³®Û•Ã­y‡&§ ¾Š7K2W`èOÖÌ!lr чÃkùðM¿©ã·b>F"Ò›¯.L‚‘AÙ­²J-íš‘ „ÓA˜Psù»XD™ŸW>òïþ§ÿÍÞÁS¾f4*+#œ&ï]ɈÕnÜ?X]}xÿ‘'®>ù±ŽW´ØMìúŒì¬)ÅT"ŠÉnòü)”Bef&€-TR͘YIŸ|Y4ì ÝÝf£Bá6s#ÉPg $Æ6ÍL캮‹Ãø5 nÌF7*H Þ Çn(±ìØrkÈ&×®-Z Ms#•0ûÚ« %'j먌˔ÂhŒ¹jyD÷¯ÉHÓÞ]>Rü¸@‚†„0tÚ{éÓ_Þíö{0Q€‚…õúÔŒ†Á`~zêÇ·öCçúñK¯€Ñ¥“Ó²ëø~íÇÿñßõwÇo™{IÈÑ:4ÆLí *?{¬¼ÿ¶¥%Ýã—ûí®ÝW¾%›Î-fÞãç;.ÎÑ¢la€hLÉžŒ—Ÿüèÿ¾üð$ǸíëŸúù_öd-ÒZ¶àÂOoßÊ9;Ôí.e4Ù^´g>ù‹±óÓ ­Âe£$kDÓìq41}Ïí/ïw÷j—ܾәQcó3i?êv_¿5×*ÿ$ 8Û8mð4d§¬2r˜/£¹ +T^%”ª€ãð{; ¶ŽörÇ’#¼€Ì‚þ ^»=B@B”¼¤Ô¯@ˆÅA½zT½"WôˆªhIM,·3!Á²,+&ë6CXx·£n',.Y·Ïn×¹LX )S@Í aÇût÷÷ïùhòõ[}r Œ].y lýÁ~ý»u¾~¤>Y0K3Ö¦¤¸?’ž—¿øé¯üå¿ú³Âîùå›·SIþ#1‹€Avíú­..eVr¹ì^ÞI–Å8XpXSCXõÃI#aÍà„"*QJ+Ä2‘³w]HëÍ'žzz7tÔÐÑ”r¤#‚© ·Þ jüq=ØI€)]÷̳Ï.;ņV×ÉäES^ ˜d}Й -¤÷±´Î¬Îiþ¶þœ¯½B­é% àô-9®=Îþæè°á0LžDm÷¨†®æŠ{Ž¡ RÇfÓ£ a€ßœn ºõ4PƒúcxL@–2|z3ä ܃¹œ0*Ô§™Öiw å¾ÆDObðhwÓγøÈøW¾¢ƒ'Oú cHC ˆs„È ÅÕjqpyÿᇮ>úøƒ=¾åÁ°Ü•ÅTÒB"Ë"Ê.ÃÓŒŽ,ݲ¥5µŒ[ó$•°~“ÌÓr'†„SŒÆbŒÐtµö ïú˜! %cXŒ1†PC´¥‘”˜–bRƒ3÷ÙnÍè+Î;8—‹¹DÔæ(—M{œÓá³ ~ÔÎ*¦ãþƒ¶-ñmÑ×[ÚB‹ PÓf7Që¼\4ËYJ\ñ­/¿°¿ZõP”´q8í! ÷Möìëœî]Z-ÂéúøÅWƒwÁ~ê©ÏÖyýâŸøÿw=½Zhí)›Ë ´±ŸgÈùYunßw;U~° Þo¿í¾ð·I»pÕŸ×Î7bdwÈR„Vä™ÝâßøSêx³9=I/>÷Ö?ó¬ÖÄe3ÂuzxtûæÍ4ô*,d‘"žù›ÿÞ SÖh2䔳ø€–¸¹Â­h2(½9òÕóÓç=´³Ïw” löG|ÜŽó9ˆ@¦i3ÎòO”Hw§H­•(çµÕÔ=*i:›A¤Þ(9ìí+°›™/yjD^Scj6¼ '+sØÒ+¯eGIjn–zç€Ð£ëméÝ>–WÔ]åê-ö]vº½L^IOiÒXÉ–}ptÒΫ¿ý·=Øož¢Á–9¥§…R¹öp"ñ€òW« vE Ð f¦’­0gˉY„h™¡w¸]úÌ—_ýó?ù ¿ôéç/_yâ/ýÅ¿±³ØÏ)I”—ÚºŠ1ŸœmŒQÌ÷®ì î24VµºE{Å#² a5cƒ³¡àõ nIR‚oN?ñÔGvÑÕàaÉÕBË#ÚЈÊZ¦”’AªùO˜¶»úô¾W«48ËU £ÍѱÖutçE^o»z>¤süüŠý‹F'[Ê9gŸ1¾cWg¶©*éb½Aíjl) ÒL¡oøo½U©t5¸ªšÀg¬òG²È“õ¡²w&Ë®Íú>kÁ$¦ã;/=ÑAFwÏt‘PóW)ÊvMJÁ”=Iî–´HޥýÇÿó/\ÿé—Ž‡°'†E\Y.ÙíÝ$“è `”Ytsq`º%.]^>ôØ¥G?råɧw®>ö.).{a-f HWaÚ ‹PÌ1Ò©«×šV] ^0—%ui¹C”\ýîÆQê œD±Áº»Fo>hBóãô€îÌB¦ÐŸ®k}Ž± *ùÙ¶\"·xÑu9ò3|a›Pþ½¶©qïtÄT½%Y°oRFµlß^¬x’e÷! 'oÞè߸½ÂNŽÑ BÞdd¯ÎOCÖÆÓ­ãUˆ«Þž} ë°—ÒÆ4 «Ð7_üÿÝÿu\¿¾·€BÔOEЦKŒ^*ÓrBP¼…Fx:ïÑ~0Ê¿ ÛíuMU»òR$„s‹Ñ©6 Ð Ûܹ±Hë7dd â7(5ð§voz (¤’¯² sÀÆÝþø¿ñ_ý·¾íÖä-è  dUíU4Ez'„LôæÉ,ìîí^¹zððc>öÔåYìï+ÄDË0§ &1”@öÙŒL¡6ÕÕ¯If%[Ê9À¬8(¤n7ØB@2ªjùM››¢ž!ÉQ}éB]ÓÚ¹Ó†êG%5C+ zÜ åÝÙÎ[÷û¦Ö>"?Æ%ok#st±PÞCþç:À亅oÏ óˆþÇn—©—h ÍAHN1"çteuðÚŸ_­ƒe$”*È Î0 ц7]ºud{ŒwŸ»¦›ØáA>Ì–RÀñc—6úÿôÏž\{~¯#•£ÛâiC²ÿГ‹ƒ‡±:ð°“|Ñ«ËŒ2CÍ\„ù˜Ð“€M)MëÞT=cRÌ‹UdÇì©ìâT ‚d`ËÀ`-Äj2ͶÇUOû–bsŒ¦-|„-äe:‘±+‰Œ¡}£ˆ8[<‡Š™TÍù¾f-:À¶Ä±ž“œ¼k Ö$Ë-EÁ¶DOôÊ„þQ}œÈf0¹ÜTs—–Àn8L-xñÓ_Ø×*b‘ƒ!zI#<¬“åÐåNk…Þl?=Q:<سã7onÞ8éÒr}² aÐæÕú_õGþÀ¥“7|èUê'bìi‹ü§¶Ûÿ.Ûy}è~û&hñouî·¯GÓlõžçñ§/mý¢F®”O"58]xå©ýƒàŸþ©¿ñ™ÛëMê= æœbìrÒ¢‹pôýÉÝ[wÓzèBÜ:By‰príÚ[Ï?·ÏEKWi•š@¢2.ŠCá™î5h$‘ÞW;»»½G²bk Œ”“Á²"«äc(Õ-QŒï)»1^P¹ZMMªeúêuÙÈ sX89z¨ oR&xpé’r !ƒC9[¶°G‹ÃiØÛ»òú«7ÖDcň‰œ²åêºeJcÌô½ƒ}göâ–S±&/Ÿ‘pl¼®F¥`‘f!# ÜBö>ú‡>"ËåVÓ‡x¨Á0.j˜ ¨+¤;D»{xòƵkìVñÑ_Õdõ¨x¿}³µ9½q~½Y™ïH„Õ­A@sŠ1\ÏÝù7þƒçn ''GJ¦¬ C¢-– „< 7ߺ¾Y¯£g1DXê˜}þÒÏýâ¾: •¤PÆkxÕ+}2V–B‹¦›÷¬1uz?ÌÛ‰ö|tæŸ;·AÎù•rJzÝeiBIÒ×r8 µˆËnÏJ‰PZ+—[R^NÝWõˆh_­|§KT†›Œ0ãs^„¸¿ÜÍàn•qªÎ³F%H¦–YN”:eb,Ò"Tµ¨jíT.¦ùj?àx¢¦ë13š!”¹IP à”{fPöY]ÎöÂý¶ý_ów1¼¾Þœˆ(ܼ¸ÄÃTÈNI DËÓNÑ’Ë€¹¥$w_ì¬.¿òÆí¿ñ3Ÿ}ö¥ë§GŠ)Êl!„ýK—úÓ4xçÖÍ..å¡øüXMÒ3¤œƒ…òÞé#ßýÄâ`·wwsÖ2C"LÕÃǶTe€B2.­×›ÓÓc &Eè±ýËí]ê²{CÉ?‹ù><á‰&&ˆ&0I}Æ/å+!®†ì Þ@à¹ÐÖE•Ëù5 Ê=:9¹yë&P§–¼Ç"ú g÷û€[E&ÌB;– ìéR‘iå$¡äð©ã¨¾ïÏÐÀÛ}ÒyôöÏêOn‚â¢ÛÙ¿$*»g÷Í"ƒ‘îÊîR^ì<°zðWmÂ&‚rI `( _…ÎTÃþrÁäUÅ48{]‚íÞøÌ¿ó‡~ëÓ~kÇÁFD³¦ì$€æD1—Iv†hk£“œhÆÚ‹æ %Òh ‚%¸ç< ›ÍЯS¿ñ4H9VÄ}¬ü…bgó:vÙÉ RH§H§‚!X(³£Qw˜‹gòH̤ª NE8ûà ShŸ×Xý¦Œ³ìI¨JÛŒËêõ'¿õ÷·‘Å·;@JV‡JÃL3]mªŠ b¹.©Jå1“Q*©žE¤éˆëKŸxôòÓn6›HÂ{yÄE—]Ì1ylÑ;»;ÜÙÒš½]6ííôÜ9²G~ä÷þËwãǪ³Qæ•/Õ–wÓ>¸pú£´ªn­»û.@ß:íüfÄö¶©Œâ9@«ñ—ôT݃ÝrÊ4ÝÜ ¿ãþ³Ï½yx’6†EêÉE É—‹å†Ôݺ׽‘Žd “Éœ{X}í“ŸÝÕ=æ3f¹Üh–²ƒ ¨èìæÁ³Åìy>Ħ푇f[A˜ãY#ˆ0¡:Ž¶ÍЗ4¬ŸA› d½Å˜þÈ0ÑM0ÙÂ-*3÷Hy7vû‹%¡@Vw*˜‹.sD!ft™]¯Ø#솰Ìq—;—±ºŒåVZ즰L¡K†ÌàŒÎèb,éÆK)«Rå t)˜ 1v1tÆhÅÖQËí¦âK`t“"ižÌ6ÆÓ<}úk~õ"Ÿ¾˜ . XÃõX bÐRYár39Ðœ¤¸88:ÿÿä/ý?ÿó¿ö‹›ÍÉ^N;Y1£Û$¸u±Û¹{xxëÆÅbÇ3Iº²YcÈXÔÑà@v1 hïàÒ‡‚¶JÂ’f³ãë&UM™€ÔL %oKÁliñ¡ý+Ì r #1®³ / Ó•›´‘Sö—Ï|õ«¡[ ¹Ä-côù= ­ùQY%Æû´¼[ïmá¼Zè}­L&zÎ%Zu2´ÔéŸ#ûÉcjvÃÑÇdºä™\Hœû“E@RŸRNŹˆ Ü¡öQ¹è¾9ºnýÝ  )Ô"]u¼ç΋D‰ª ï1ÆûKæÆ#…õ#ßõøÿdÿðÇ={J\.îY&Wrpã] ¶¥,@1&`)ËÈ@Fc,šä0‹nwïÊC<üøCUõìĨv€©³%â¡Ø7J µ Ùqv¯åeÝÞ£"C! )£’úœˆ×Òѱî!s¥…ßxçÐî¾ù€îükì-†[;ÁàjH{Eÿã`ŒQMoÛÞëjŸŽ’ûí«Ýwú–ig`ý\ÿ>óç=ôòéH³Ã4 ¨ä®ûÅGíß»÷ô÷¾týžÙcß}{‡m¨9ZWfö¼Ñ|§›½Äú¿ö^°•{-vùÍ°^Åâ?S@y«);^›*Y”Ú5êàdó “\tË"óå-¸JÒ<: êœÆ-D’€ ¥œ,ç1 ,IèYc%¸£2€™”c š•*J&‡Ã’¹ÁÍ ò¥ 0IÙ²A¡ßY Ãâ…ùá'òæÙånL§}>¨Å™‘«Ë,‚`Ê.ƒVB )IFF BvK° X´Ü}üoüô/ÿÌÏ}Á°—õàÉɚʑ%´ÚºårØ ¯¼üªÒ°Z•ŒCQ.3ºçª`É)ÀG`”´{iW¡DóʬbìÂÕÕå#PŒŠdD‰Ih±3‘²R²×Ÿxø‘àC éty´jåo@g:2ÐU…˜U”˜áËÕÎg¿ô B—’3FÊÛ 5ˆ™tN’ªQ›¬A=MÅšÚ¯Kãv?ÞÃw@ §±›!Zš{B—[×ð6›Ä={7‹0ÈÒúôtoo@ˆa³Ù,h…á‡ç$å´¹qãùžúîì2 r„̘/n•ÈÙÜ6€êzCDˆfÂÑfµØ}êÏþþúÿ5¯wç䌂òÀRˆÄiÙkéEɨ…Ã[Ïércðê,§ŽGš2ŒÁ‹›è ²ÅRعô°ç”†aèשïÓ°†§HnÌR *ÖMÓÎ2ºÈ%!qÓ¾Z¼ªp±=í¤«¡ÿê€È€„|šÌÌSÍ{[F­N*ÀæSÛèmÍÔúìmfÙN¾{ûMäè̤ДgÎõͪеÂ|¤jÞzS]ä1,_RÍí³|Ò(Ñàrƒ¥Û½úÒ/}þãÿÓïßs ÓŒ„{€ùâ"©G´ÙŒ¹?ÅñöWK†ÍÍõb'›W~ë÷}×ü¿þ?úËŸa¸”3‚€£8ò¶¤[xçEyNx‡Ï_ø;î‰:î·¿¥í¾à[¬±qgN]Î~bûÝùYaĘÒA%‚-Ë=ÿM?úû^~ëú¢[„(Y^t‹>'ëB‚Ëoßí“yð¤`ÑLXæxë…—Oߺ¾€QNä‚OÑBîfYf¿TÜ~yêììx/í?>8S.M£³Å͎ǬÆ´õBý]Pè ëþ¤{ÉÓ’xíQ+>@gc!Üë™â‘4 †ÎÂb¹¸âŽl!®ÄeƲäÝÏa¥°Ën?,/…Õ¥nuq_¶r.œ#8BIë]ÿŸ¸0p*›ÊÛQZu‹BBhîÿpo¡ƒ¨hµüÈÅ—H¥¶göÔuX÷/ÿÿãû|k‡½†>+•,"Ô8òâ5P,)¥4(ŠKÃŒm/Qx(šd{ŸúÔ³Ÿýìk±{ä䛓M€àWÅ`݆»GwH¡S¦Yç^*iTbÑ‘‹¤‰rêàêåAÃHo g‹ÓÕ¨ãµÐ„"Ò¨iÓbü`gµ—Á½|¡”‚¢Ašý²-Ô5Ÿ!]NvÏ¿øRŸ=9Jé ò-…ýŒxÏ|•,/ÎR•X¶Þf]½ãû]£ÿ tÕÅ ‚9g÷Öí“:û·Ödkfö¶{àt…·ïH‡m8]§¾/÷ëBLžRÎ^¨nQ´hq}÷Öwé½<±”4„f$}ëѼ⋿^3kˆRÔÃaxô¯½œþû¯ž¦°Ÿ´ ):(HÁÊñ]²Nqdu·6 «jb˜ØxI±¤[% 0" ˆb\nÑ«KW÷xìÊýòàG–— «K9¬2W K·%¹ cˆ!D ÑJAߺVÙø¦é..U•©ª 65Þ»Jb‚j]A]þu‡ª‘µ£Ð×±ÜRbÏp)õ—3F²³‚<‚ —ÃÖ…ÑòÖªê.ËÞÛ¶Ðv)aÜ1}µ%7*à Ì°9Í—Âå׿øÕ¥ÅL‰n¢¹ùƒ…œr,aèÙå”6~Ú3Ç•íùa^¥þèå/üñÿß÷±Ë­Kî,³ši  Œü?Û_ÜÞ7^?ƒ40ûùõäî·÷ØÎ(÷çæ›·hþ,W±ÝÞfŽddÝ^R±gO!ðFæü3ôÕÛ‡1ô½†Ô…Åé¦Ýbvçú­ÃÛ‡&Ë9Óƒ3$K·ï¾ö•¯îZçÉE¹É ål;äDæéÖ\›AÝù/P>ìvÏ]oñŸ˜°TÛWYúYbB!÷ÃƬ›_¡„ ”Òñ’‘É,e Áv†´D8l·ûînÂnZ^ΫËÜ{{Wµ{Å——r·—Ã2[p´\KãsTºTæ×­LJ’%1™©$[éŒËV!.ÌL9PT.D_Åå0"¤ (§Y)[Rî2ÊvçÛ¿cý=ßÍAw\ˆµ  †Z8‰ h‘¡|–hia)yv:àîîp·Ýg_>ú™ŸûjÆÎñÓŠ -Z⪆££ÃÕbYC(À’íG^Âðbqìq¹YÈ.‘¥BóÁ9;ƒÕœ0š6«}5fš¦ÀRw‰Ár©Älâ®ã‰ƒ«!§È’ ©Æó–âÌg æZ$éB)+á´ëwï¼y÷0#‹©V´´}ÛÃzDSYu¬/0å¢oží×¹ßeãÙeó¶=œß… ŒLi˜¼ù´Ì¶‚jé·qÍm_ììò|7¸ [2ÐÝ]wttG˜Z×=»”sîÌäž²–×_yfW9&*»ÑyÉ ¤`25aBj‘iÙÜÃ)Òñƒû÷æ+/Ÿn–ÃÆ#»è±ï×2²ú¹ ÁɨPË!¨&«f͎Ķ½³ p øq”ôeIžJ¸‚ 9w>D¦å*î_Y]y|ÿ‘í=òñÕƒOÛ¥‡òê’w«ÓcD·«%—±F&×{6élc£šÏ¤Zßž´9í ñ_ô†*eéÁPlŒ¥TA°u Õ´ÆÙi2ŸìŠ}ÛãY©Ÿ…,Û²4§y8½P5ê¦xOi)Ú‹õ¨£¡Fä´=£0UâÝAGd)ðh¸ùÜ‹KF†è,Õ邧 ½/,ºYƒä& Oéè‡kœú;ñDËasüòÿ½ÿÝ?}o¯:ÉÝÀKLuu7;£3½ŽÒ{-·ûPó¢QÞŸ¶w¿ý­msè?g¹ÎüY~ã¸ûm¯ÿÉï¿ P "’[ˆwNõ[þáß·g–Á»”³Ñ´¼´o¶p÷×o¬ûÈÙ"`$6ÜMöì§>W¹ÏA•ï¢ R­p4˜âòÇÙ~]J¿î’úNœ`ùmso4aVõ§™­YhÞþp¹Öý±°T?q[MÔÙ°šÙÛ0gÐ:GpëVWµÜÇj‹¸{wÐí(®C¢¹ÌasÁ4‹¨ÖÈ–¡ÂšâàoºÒX¸u¡ëBŒVò³{錼õNå¼.Ð…Ž†Ç< ³•›*YÜÄÝ×~äw|<¾°³hž÷"³äõˆl¬a9Kå…«SeÖ'·ºÅrs®ßÌõ¯ÖÓîÝ;‡„}¶.² 1(ûÉñÉ2îäD0Z’ÓÌ[6‡ˆš~Õý $âÒB4µðãŠW æ;›l§ÁŽ’œ²‚©^;àñý++0žQ<ÈÝk•«Våwëj³øo2gdñ…W_ƒ-F¥è¬çû»ÛöJ$]ˆüïy™÷­œÝ‡Þíå«€@ž§0`Vl+4ö”¨ò395´ÊyÀëüíê˽îÝ+A¤röȸ>>®k>;”‡Ñ‚9á™ys’îÞì|Xj”ÌY¹(ü¥Ø­ÐªÏÊt+MqþËfŠv˜â­+ßþ¯ÿù_ùÞÞV”aðÕâR.UŸ=HFY)ý;+«UÌ=M»3WŽ&#±”30«5P2ƒšî ‘è,ÇàÒÂórÈ]ï!¡³noçÒ×|òÒƒO^zôñÕÕ‡âåìïjgá]dìÔ°¹§™ˆ¬ ” èÅ)†D©enÃ&Bu­aµ­”/—Ô:ÖvËÑ–5¶éhNGÕÓfDùe £n02Jm’«–?z£6ƒÁl…Œ@¿ÉLÛZ… `t÷ÜÖ"X\6;@ÓŽFMÂ"D2Иs^qïðÕÛýõ#J 4c@Û©”°ÞùwÒ\ÚôèÚÀEè6G×X¿ò'ÿØJ7ßX…à)h4/æZµí±#÷9¶–¯¶«¢¦òÕëÈîæîn,éáJÁ†õúú÷ÿÚݧÙÀï½#¹dÁZ)/9ÜŒ¨ÉÁ³jªAåòh4€ %Ñ°Þd…Ýÿæ¿þ©nuåät0“{¶…9r9».Þ¸vcµZ C 1Êáš?½F“ÛDMß‘‘÷8r*3ÙèK¯…K—»lj¹qvÆ=ãòA[¶3Mž£øŽRZÓ÷5Ú*ü¦I ÑD‡b°á´`yùå_þÊnXn9=<±–‡l`q+_ÚâÕ¯|m8*|aˆY9Àê b€QѬ %‹g0Ö¬‚åpЙ‡oL¢UÿÖÊ:Z1"8!‹)/•`Èt×úàÑÃ_ÿ½6ÄœËl2a@ ̤âydµ¤(ª‚È@R¡T#]Ü…˜xéç?ùÂÑi¼uý8ça½Ù„%Q&!tá­7ßÚÝÙÉ}.îþ¬©/¼rŠæbrË¥âAÃe®Ü™wöw•Ì$Íé¿.rt¤ PS‰µ“L4 R»9° YæFRÕêBÃ<œe¤‹A÷Z;B"ÍŽONSš¹¾ -ÃÈLÌx^‰¾@Š êÊRv/ønWÂ;®½¶,¹u‡-p@AYʹq­jà®ÎàÖH¶ðÑÆ|o«ëí¢s*A÷„­­©:G:ú¡·`bÉÀ_VšŒJžÝÁn¼þü"„¡OÃF’;:,¢ºÂ—’õ·ö&ä.)èúÞóæÊÇÿÝ¿ôÉ̓߳‰Wr[š¸(ŒŠW—’²ÜÛ¨ŒcÙ¤st©ß²-s¯ÁÍ21æSø†Þ楥eÈ+j%,ñ'ÁKr§;<Ó9›Ó`†ˆ]·ÿàÃì:'iÌÉ»E7 -uQ¹Z…f®a3T?;ª‡UQ)b¢y (¯á­MžU«vLØuôÿ™Ïwû°fX¸<ÕЂ PšÙ:6SÔÌñsÛæ;gÌÊ}ÕÇTH¢UŸCÎlyv‡î/|õ ®\Ì‹þ(WRM£Q˜53X4³Ä|{ˆ'ØÁʇ´’½üùÿø_ÿ£Ë£×w–æý€R`Ū’<­Wb\TÓ†tv!|ÀS÷,ê¸è÷Û¯h»¯| ´ó€þ^mŽþÏBIgaB€å”A÷ùûþžß¶ûÈG¡¡ qq‘{?=Yß¾~‡É w’nÉ 7îÞxþå%—.ÀèRÍyR·no'çß-†°Þúô#%Þåˆù9~sä—¤’WsDÙãw«ÖPŒÌ1ªÇ'ú4¨’ÅåÙXÌ»<Ãع‚Ûòàòc‹åeYg!A%aŽ*Âg Ú£ªñ¡œí)–ü‚%€ÕÛÁÍbñF¯g`r³´àÁrâVs÷ˆ±Ê-ŠBW¼r³J˜#«ÑÀRîÍÒà/ýجӫ‹˜)we#³Æ#wLpÔ&Ã¥d& GÌJaheCvÒãÕkÃç¿tíäDðqÏÝj! BXt‹o]_-VypZ cJÍÁj„ªSX²w²×(™ÝrÂè§1—†&Cÿ|åÊßIɯØrájnÕ¡DÛ2X1KÀìn1¬Oiqæó3"7µSáˆwX “(ç&Óó¼ÿ6~ÿ^ ú»»Î¬´ÙB*UbKÜB™°ñKœ–cS…ƵÉQnÏvgμsÛ-NåëûM2 #¼éïÊ9–Éï^¥  ÁÜ¡œ=Ì=WÐ[ŸœMA™"MfEð£noÂßñoþÄÏûÃO®It]ö<Ùâ¬t hï[Þ@“ÀµacËîk æÁrd èM½©7ï‰!-¨Žè @u@ôÈ. ðPh„’´ T¡ åE9bX – =¼ÜÛsc躔=Æ(wÒ¬ôM%ˆ RŸÙÜ|Îl°LŒLAÞ•õoSÎQª•¡¡ÜqûPyû½m„¨ÊÐ>Q‡¿¥ÑÜ´Å•l‹0·V7!µx²6p’á²ÓÉ@„ØÇtýôèåk]ˆnÑŠr²?@æ\àÈDÐON<$ëRŠ§w‡/ÿ[ÿÛ ‡/ï-‚r* ·ÁLöÎ?P~!>y— å~û:¶û À7{;è/þÄö¯|¸Òd *¹€Ç'¾ã;~ão¾»éÝéž) ËÕÆóàîî7®ßì,ÖÄr,L9÷—`/}î‹\¤>Y ÉB:1–ºggÎ÷]ÕZ*¼í§ßc»hû{‡=I³jž¢F'üÑ87 EsŒ±n§¾Ìl½Y³htrfuH4Ø2©[¬®îí?"["FïwÁhÙ€,üŽ«Þ1?$7Sý]1X0rÉ‹ÁAÈŽÁ18ÝDfu›Çˆ0Û- —;T=¦Ä>)Ó]´h^ÿ{Ë•«¾…¸ÉÉéÑdP63Èrõ>—3Wo"d@4s¹­5H I³“!eÛÿóñç€K'ǹ/–Ëœ!´ïÞ¾Bð”Q¬XeJ+àP ‡ «Ò¨»Ÿ"í]ÚsJÖf­ jõ"FP0Š‹A03wx¨aKÙ®-X]¼y·XïIõýî¦ÔœÅúsxxtxrB‹ÍùxœÓºŠ*çßT©¦^o öèh2Wœ³Úïk]]ñïµÕ ßÕ%Ç¿>¦¤”R´M{ÑEWŸ4 <{ãóxí‚»oõ¤ÞH%PDR?”šåf,P¶ÔÃe¼{tݼÏCŸR/óL·ˆ!š‘ ¢`­*lC­³iðF1EN|ÿÓ×ÓÿÙ;ßõuîCUìƒe£j±d–èˆ-z—]Ûk®²àL½ù:ú:¨L):ÐZ°< EõÁSç‰Þx€ÉwÅ̦͡$­¢ewX1ØÞ•Gvö¯. 1»j$@Õ]«ôzÖЧ¢{+¹‡æi§ÙS4[PMj9FW©"þ-åáü?  ) _Õs³ì{‚ª®Díc¾»£Å—>àœÆr¡4dK}Shjû–~š ²Äâ<°ƒ7žyÕîä€ån1C*Åã]ÙŒÎ,&1ÓHÊqá‘wÁ‡iÊÙSöŒxÄË¿å÷üSoÜ>é+cLî’“Ñ“ßzóæB‘ &Ï¡ƒ3ËuegïËŸüÅ=t>xA9[!¨È‘ò¸g?.h“pæ±?ÀnÁó›Ü½©s/pêL=¦ÈFŠW©ðp<¢„Ñô^Xv“”<;JT®Ø '±ÈXì^zhµ{ì,vrš²ÔA-0ž†ãoš©H,QÖY …î—gyòì>Âù’ †°ÞÚÎ]w¸Ë³ÏZ¥`½}È©ì……™y²éî#Ýùþ¿s›kV2Uè`r—PB‚ÆPé:X’J\„Ó<Ñä¹ÄÕ&*Äýÿî/üôÎòÛ·á9Æs!H°7ëͦï,õP4Ÿ‡–N´ÍPÀ†^ †sùþÁAòܦ²¸œWb’Qa B7J2i1øå¸bÊÁ,ËË…¦ÞŒ¤}5±4m²¡’›Mrr-º«É\Kƒ…&S÷ôúŸ¡œÒùŠ¥(ûU9žDy¼Ï6.¡ Ä;¡ŠùÄpþjù6!‡— êÆmmgVtŃÛiø·ºs^u¸÷”TŽVÉÓ0TWpwo9 äS†Ê€|ã­Wvº ¤b·«#=çjH›¶æ‘˜j±•ÀªhÊðÍþÓæ¯ñUâ$¯ÜK\O,µ’‘Kڱ凕§ µ ²”ôpc6õð´†À!XŽôH¤5™@¯FXT7˜úøôV^¸ùÁ·¨mH’:b‘2wöÚ½ôààŒÝ"ײÅŸ§$ÿ i“ó,£i$³ynŠgÓèµ’î¤:Õûkë;³©wË­·F·9µZg jšSÛY‰­ìFã²)ÛÀüúgo4 ec™ UÊ€–Âð“°a“Z]}þÓŸ_x,ÞZ’â"æ”QâÀk—Tr‹còArkrödÇ/é_üñßù½O,—Øä”é06µu&ƒ[ÂÏÙOÌ>ö>Ûx¹3×½çˆÝo¿í~Ðoö6žoûÒÖÒâüŸj,'T*R Y Æk›ð÷ýÞ¿“:t ICØYF™\ë†9- ™Í̳(,v^úÜç»Í)†>Ð3UýdÏK×»”· P>Ðn1Ý÷ü>Ä3ôvßž.3!‰‘t,ºP͵S]HÇ„ö€ÙIê–šü.“[é¯Ò at‰Q­†ZoL€:ÌÃ"¬ æœ:sR9ðäÔ¾ðÌ›/¼|xçöiÎ$åÐÑ-"hÈGwaáÙK03›®VH`§»%·,dU¯‰‘‰3fùÞÁn1Ž¸¼xMÇý Í$„¤è9¸SÁ¹÷i;Î ¸; ¥˜ñ³—‡‚ZªÏ†`H@Ùýö;4f9j×IÓ˜‰à…+ˆÛr=º?¿iäìg>}áïï§Kè^:À;}{Tì›–STÜDPHyh*P!qË—§å«ÑªcôšÃê‚_âöïoÓŠ,¹dÑúÔ)•»€ã`æîVcÖs4žÞÐúHëû€”:bszÍ øo¹dÐ.3úw•©ÎdFÈ!YL'™·ùÄ¿öÿ}zèÑSôŠžåMž¬úÌ•üž¨êC[æÈ¢ è¡Bo±7K5 qKeU^œíj.áèŒÎ¨Rø»ùMþÅv9öeÌdr¸CÁøòÒÕý>ɽŠ­ZM®ÜgCX“á4ßÿiÚÇÛ;Yø¨>5m¾ÓO"q^ĸµ›mO;GºŸµ/x;qž­G¡`÷öÎäV8~–ãæ!@š…R£w8sf"ÑŸ¦ËÝÞË¿üÌŠK‰2¸{&åê*2Cp$aˆa)JÃÝž§Xv tüµÏÿé?ö¿Ø[ßÜ]ZÎiæ3Õžv¦ ׳á¬ðA¶‡ñê*Ýç_¼ß~%Úý4 ß¼íž·ÎÕxÌ@èRNY²Û'Ãÿä‡~G÷àS½›Ùb½^‡‚uC†1^{íúÒVÌe (š:Z×w‡/¾qòÆ;®Ì`rÐ8Ûoy®ï³}€ÝbBø÷RJÞ~×/Q~Ž§vMWßT+¦ÖÈ!”s®ú€)%wåì]ŒööºòÀc’ˆ¡“{ˆ4"†’]RVÊMÉå©z^¹2šZg`æòœrrΞåY%GIáûKJõRI N¹äô,eä\,h¡Àí¤lÀr?'h°à "Ýä)té4½ñü}O>°s›ñTJðL’0WÖÈÒ–b:Û),Á°8<\I)e0K~x„ÁøoÿÒ§V{žlN|H„ÌŒ %oÐ[w–ÝŽ\$³‹6ƒ@<©Üc¸çFh!1`¹»TE6ÅVÏã™3À  ^ÙS)R]Îq…!ÙXÁÌlâJ9=>* ¨ ˆ@+|ÿí;·CîÕÖ0¢œ&¡œædë­ „Y3Q‹ g,º-÷èþÀšÄµF[ùÒrÑR¼º?Ï2"+i‚‡h>ö5ÐöLxôYUÿÞ=9ÓX2håÞ1ýZÕ@C€î‚±†âÒröU\¼þÂ3û+*P}N)Æh°æ÷ÕTÔm¤Uå¢î—&Á<ätˆ½¯èêô3_[_zâ´D ¤!2zÎPs£s£ܨ€lÌÆ!h-­ÅÌÆdÌf5{XÅð*pÅÕ©y6$=ªPU &÷N²8©eEeƒ‡À.e-vxà±~ȱ[ä앵rŸ•)„¢8U#˜‹`ñr©®q³;”Q]ææÊ1•ì8?‹Ò³Ü0ú¤FjþI ^­nãgæ@ JéÖ·'Ùlõ¶ÏÎõ¤§Œ¯°lFÍó¢ŒnN#ÖÝÕíçÞXX—) EI²’ÇÉÝe‚dÕŽäÈ]ˆy-ö ™­¯ô7þõán¾¶¿Z g“læA§íóyJºTÍÓzù0`â}¨ù Ñî[¾YÏý©w¹§éœ*_y›–[O—çƒÿ®ïøµ?pÔ÷± ëÓÓåÎNÎÙßxãÍÅŽ÷Å™;#@1yr;ݼúÌ—w¸ôÀ3¹jíUéʇ8ïõ»[hbŽ¡Ô^Gãô¦q;wω§&„’åºFÚÉœ&ƒ—Ä;A@†¼“"!¹¼6fa³Ñbqpå§c<ÈŽÀZÁ1;<ç4(gÏɽwïÍÔÅЙ-BX rBòÐ# Èœ¡T%«;÷Ì Îv‚¢P!8T«óV™h€°Õ_PÎâ­N† ¡•B?ðÖSŸ8ýÕß½î¨Õ'Í\È@€JêB¸MùœI¥`v3ìîÿÜg¾¸Î>PɆ»wOãê‘ÿàÏþù‡üè›GQ2˜÷´ˆ‹Û·oÇUEÑlgà¿aÀŠÿ½”Ob'{ui%:-`å#6¨ÏÞx½ñì@7Ÿ`Œ}:ˆK˹ –s6R>»hö›i2¦Kƒ’‡oß¹ãîrÁf4áüKdÌç›Fz·Ê¤3»OØr†8?„ö6+ûnp~w+ÿ´ ˆñ ­z †ê‘!2”ª“•¬*mœ*d¶ýÔöŸãϹ²5@•põ‚HJ}o ¸ruk¡"´Ýåëtr3( 阖„ÂÑ{師 8¹‘O/©ènpÁË6;þ7Ÿ}õóoímt)©g‡œ=È,1x°Lf0Ó29€‰¾ÎÜJ(¬ ÐX\‡TR34ÚjUr•`æö<µÒ€U‰­â7®ßæ}8†¶4Š£d+p‡luåòÕœf° .åî9!ÄèPr‹ÊÕ„ÑBè>é&Zº¡êVMµwõKÒlzgXmHuO/²­DŒ28—‘kѦ‰vÙYºOÖÛ”^Šsñ*4ývÔ(Ts•üLœ*¹’ö}ïÎó7NÞ8ŠagLÌ0Eš§dÅHNÆ,Éàæ *%Õ5øæääÒÒ†›_û-ÇS¿ÿ7ÿ]Ãé-—7ÿFŒIŸÏ<ÿ™aئ!¾~í¾nð+×îÇ|³´ùñÿ¸ÿÌÛÓç4þ3 V Ê);Œënõ›~ì÷Ý\g[.Nû "‡œ;Æpý­uJ"èžà–aJÉwŸýܧ÷bÈÉidMqQÐQáAÏ$)|šÏý|ûŸùozõ¼+g׬¡ƒ• º¸³jç¶Í®\Ï×D[vûêá) 4:ä@ìýàÉ<ôч‰C‡Á¤’’³dòA0‹dg±³®³Î²çœSÊ)ÂŒ°ÀŠù[êg3§9³ßÇ _Gbo<£Æ'*O<þGÀ%w¹£¥Ü×9¿ðüè¯ê_\t&/yª%%ž»¦#Êu¨9Õè`¸nõ¿ô¹¯1ìq³ÖÃO|ì¿ü/~âÊåGn\»c@î“L2ËY1Ä»wo¬Pà|ÈkùcÔû4’ƒ^Ré³)øÎînö¬êd¼¥#rmäh$\E²¬ý°XÉ rWˆÑ=‡ª"6gßQĶÃW‹hܽ{7å\hÀ‚JŠS´î%…÷n£7C* 0MšÅöu?Àé{櫺èÏ{<Á…Ÿ-לP6«Ý!ŒÕ/¼9€[‰°(%¨*^¼W¤Ä=»qñç'¥‰ WN¹f³dM ƒÙ._vñµ—_à°QZÓ2¨8 ` âÉæµ…’W(”<‰Ž‡Îü‘ïþ·þâ'owOœ$äL8Ó&)”7®k#õÒFA‘9À ²Zó–T­R­ÀÖ$Ó‚n¢Þ4 ÙݳòÄÈ•`e¸FïÄr¡ºí]æbdFÉãÎîÁ N‹ Ò|¨©çj7ŒÅ¹Ÿ-½Átˆ”{Œò[íEÑ´ò ß1ÉÍìùšðŒz÷\h¯Ï$µèr…:=‘êEç k~¶ŒÝ›I­Ðè¨T/“Ú +qQïR”½…rcü ;xýË/ñ8Ë…`^b¦,æì¥`Î Œjw‰]Lypwîž\í–G/íýáûö±ͳ£f_.)Sßa•ÜW¼«ö6GöÛo÷Û×±ÝW¾)ÚZ!ç?ÍÆŠŽ¤ä\ ÖÝ9Õ÷ÿàô;Wr|…Ø…Î3bì^íõ2Á½Ò§DæŒK;«g>ùs ÏÚˆfnm÷ՙ۾͟ﵽÍ×'¸¯©äãŸí{“’4÷¸ŠqŒ ÕøÉêæ=¦©‡}­+ÈÝ]f°€~ð«W>ú胟P^1,ÌèC"=Ésúì)gW®NüHP¢\p2C ­rs%ÏeSî·ÔôUÃݬסme"ŒfúQïÓ<2ÃÜä¥jsÕ Éw÷÷ªNÐJ{6d6; ‰ªÕˆfÀ2罂;EÜݬXÀlÂ#‚±ÂÛ5Db¶ÙlÖ›Mù³J_ž¹Ž”çÔ¡s²©ê ßË’ç*¤m”&)ÿÐÛ…xáÝ-z¾í‹®˜sj‰+–Êž²RÇ­º“O k'o®whóÁx› ¤ê!9硯øV½Ø5.@åÍrýÕçƒçáôtÌóÜ}iÒÇfÏN6M5“‚e31˳ӓwöžú¿þÄ'—¿}“;‘1tHRŸ‘e"³à`«@gÓ"7ÉJîa¹œ¥^e*è5z¦,~&2n’Q®<#*Œ-fÃQÛ,£] ¿N–÷Ì®!šï.\yäÉul9ô`ˆd( €»·eb>RläÆ1²1Sòbñ™÷xœàYÞ­ò·¶V„F/§2Y[‹PíÝÑV:N)[nP Í%iâYhVÕ¿©ŸÍ½°è.æÙà^vùÙ×ýå°÷§ŸÙÁ%õq‘),#I)–”r¢Ü»eG’ƒÅuôõféGvã+æOü‘£ë;1䔋)fr(¼p+ø€gõlØîñâ‡vƒûí=µû À7K›ïko·ZØÖ“.øt£µË>ÙLãFËî‚Ž†üðw~ߣßýýÇI”±8†2,W»¯¼ôÊN·ÃL T¼À7°kÝËŸûbÜ$¥–<±ø•@3H=_ù# ý mÚÅÏÒÙ‡ã_@flǼ@™#¦F_W,hà…—Šþè¦ñN$<»YI Kw ýpt|ܼFï-gÿ­Nœë×ìéÙ|xQ‹Wâv†F`µÕ>lU@Û¿¼ëËŸ×ræ\9e4÷E4ð•sI\•³²¼Ä™´ ~à‡ÛÚ1xKÀ¦sU W]îȾ99êOr,Åê¦2Uõÿgãê(ÑjJ[‡K„[¾VóNüo¿t³_=œT<»P=ú‹þJX+=2äBå Ê€Už•ÖwyÙ ¼Þn¦O«mÿQÛ†ª aêz½OÌ1.WÌfp8—ñá§>rçî1-‚†T,;5Ÿ2šdc îL (Œ;j³õT]y¸úO}ÌÖŸÙª-ÎMU‰Çè“3Ó%¶OŒf»ø0…¬… wG5h´c—³Iolýb i(µD|TYkÍu§›ßÍËë_|a÷}€£)Ë‹…§œú™.«å) ]„SkåÓ~‘6ñî›±ÃéŸüíáèúj±,5ôàÞKn|^žùÔ‡Þïë Úý àoµ6³[aý¥µ½¸Á—⦓ÝÝ•3}÷Êßõ£¿ç¤u€r¿^ÅÝaàË/¿¾·ÜϧÙÀÀšø:1 ²¬ã×®¾v£ë#ÜÐ’&C£c ÇíðÜÆ:ïòùç¸×ëãEFMçÂË^4&óÖ>Îs›ùü]áì…Çc °jûK­Õ%SžÊrÁˆ‡”ÝÎS~Û彇SŸ¥!¥ ]Tf•-˜¹'£Y-ß3þ·å¢ÓHÿ–¾¯ê]Ä‹õœ¾Ç5ò½ŽƒŒNÀ 4› â›ÿiYì‰T*™ºN,?påÍ¿ï=M×ÂRé9`Œ`­g§¦'Q¥ÛÊjX7n¿ñæÝõ‰^yñè™/ÝúËùó—/=}rwc„Ñ”rì°ɱ‹7®ßê;9Õ4ÞÛO×pßÙ‰õOªx@W+¿1Øbgá5]§ªS ûʉrž¤‡NQÚ÷iÁ§ÍZRoÙ¼ XS”Ž®Aïܽ[ÉÈÂÿVA›Íü8O“n¿µ5¯@ ñ(yWsNc—›Ï3gâ|‘€|ðvFÉ~w—×¹_Î_£°¿r·øb5¶»e¶©ä¿ó‚qzW}8ß*æeÏžóL$@Q^üÍ%ww_,â7_]”7TÖqIÉ/Ö¼º‚ÀšÈÇYã9£+ÊcV—Q]#gtù¡?÷©Ï?·æzMCE*v/€UÅÔæã2(ÑÁ-VÜB·c[+-z{Cª“«Hۈؘƒêxßþ¨¹Ã2ÌÀìÀ\”6©úŸ…!«[-sÎNGhžý(í(©-1Ý£LýÖ¶_Þh ¾@~´=g6]š Ž€äM»˜é†íú[³_]§ëc²pŒQi$Ìdg•Ïr"Œ‘ãA8i5¬Wve1Ùä„TŠ:”Í"PA.S·yãpýÊÎ:‡•¥s^!É2z™)›DÅÅB¤Rà©ï$ß¼þÜïþußñÿúoÇæ.ÒhÔhŽ½hKÙ^ÓB|[¥áÌ·¶¦ãÜ»X;¿ßÞ{»oøÆo|OkcZšP-ï4(Û8_¡fþIîàâ¨Çþè?ÒÛ®B€‡a·[ݾ~çæ›×/-/å“bHÅ¿VÌzõ 9\n ©< ðæðÊ@Éû©bŸŸ­åF*³©‰¤q4}_ÍÑ­‡å7ñü˜5Z BM;‰É7¦û‚êy\è&sw﫼ÁK?ö£ß¦ÍK‹UêÓJfTq‚h”—%‚,1……žªc(åbm’‘«Ÿÿ›¿Üu»7ߺûìW¯ÿßþ“ÿîêÃ?¾³6£;RÊ,ŠËå­ë·q¥Z¨alã9"Lù-¶DCÏ%L?ÝjYØû¦í¨ÊÇ(íÛ BàCãRX0e#TS¨ ÕØ1‚v€Ë õH+aoß½mÁŠÚ0â*²úŸñ'n“?j2 3!XÞrÏ9Cª3²~v”>¼öŽõó=šiòÅ@Ô“»—\ò'6°Ëªâ¬‘íïá y¾ëܧ0+ ( Mù·ZŠ”÷ò°>94ºQ ÃIð†¥ç¶¶-« X‰n7d§ÃÌòIæÑCßþ§þú/\ý¶;®4°îhð™Ïz£ÕufSÕLn ¾/ŠÀLOoÔø¤t £Yý½ìÕɶé³(ù&R€(WN)÷Ù‡ƒõióøÓO]yøÓþÔ:³RÊl™×ècY{_Ì&[^û¡wY–ÜîêZ3C˜“Z0Ëtv“h«pö•q(‹2 M€¾™Ó/8,ª°ú¨ŸÔKMÄñã“Дٶ°ftyÝåI%íÙÞë_~ÞŽŽì™2(ÙÞ ÑáÆ€’þ©ë–rÇÃúîzŸáèÅ/üÿÈïùÎ+ZÚ ¬Æ6LGßö’Ù§*Hï¹_<+„ç>p¿ýʵû À7x›ïïêÓÓA7î`³ý¥m"• qJNS8ÍøÕÏ>ò±ïìs¦ òÆßxí mÒJ+_§`2(¸¼œo)_ þµÏ|ò vCß3$«À¿øD0ÀÁ‚†G'lL,Ò´ËÜK øP[ƒo¥©½8ykgª©8І¶}ƒs_îù—èÅ’N€ÊLBî‚9RŒöØCO=|å±hÑs ÌÜ¢ aŽ×ëC"£TÆuRV‹Êª‘˜è5Ȩh +lõ}ìqÕÉ&oÔÖˆËBÿÉ (J¬a`MÕ‘1y&i\«L+Þ®ýúxèÁ'†pwã)X€Ä ÑÕ¸óvzP’ç\p¡Ô–‹÷BøâçžKkít»Ï=ûRˆ;'‡']p¸RÎ4zV×-nß¼¼å&é¶6Íã‰|Æ7ašÃ:pÞb¹·ã3·Bü^U€0i±D  ”®}Äfw T %{k[—l–öª90‹w³×ÄHhjL£Õ´M¶Óláœï³Ha%Å hÈ%ù뤞SŽ4ûçC$ãæçþ{¼òü³çöˆ åœ9Íuy¯:¬ä³Í¶õ»½õ;ï>¤#ÓÐ#5êØÔÐ^![XÊ_»ß¾þV ݽٞTì{õbÍ_©‰%f2“‚gKÙ<ec¯è!ÅØŸ ÝWüà?ûôs›ƒG7‚Ë  ÁÊŒ*Õ½5 g“Ü<[4W®ZÇ[u³’hiVPmäé1 dÝC ÑSj/Ð!!“0¸¹[8¬1¬Ù¶É!ÙfçÊÞãßþQÛí6>Ø¢ó1ž»ØQgx½)I[r1÷¤Gµ¼M\mœÄ§¬Ü¿×ÌÖŸÍg-À)2}ÜÜÔ"•'toÍàYU„iÌÛ9Mœ‘Ë þ Õ°`†…dƒEO €˜‰œÓðàÎÁ³ŸþÂÂwÉ‚ ^Ý@ÉMF'D#¥ Í»–¡_àNÚc:yéóæÿøÁæÚN0—G¯±“ç–ʶÀùH½CÓE¿ÏÕòqÓ¹ßÞm»¯|ƒ·÷¶*βD;OF³íh€àt1[Ü}ä‰ïû{øæÝdZ®Oû›7¯Ý½s¼\\RfM\‰,÷`&d‚Øàr·óÕ_øÔŽ,oÜ‚);+Îi~ŽS@ÝëJÑBže­›[hæ½)>ï®ÍÔ£ ñÄèN< }®°Õÿ½TÓñTÝ~JÔ$e;B |èG}èÉ¢×"8”ƒãDeÁ“Ÿlú£¬ ,;× åzÐŽ"”£g’Ú´u¢L Q+“Þ¯¶6âö0ék$Yñ²(pX]”‚¨œ³Ö›áöþwà7>:œ¾º(À™C´ì©žˆÆlHôj Ä\(vJ±0] ½öò­7ß:í{eÇ0äÜ&A)¹ÁœJi47Ž:v¦>íd²XÆÆlO`ˆÈÀñâê_|ñÚÿx+Ý{ë¸ðb\0sˆ!@¤Ùù‹È°™gGÿü3OƱO[µÿnÎøÖnŸcñB©¹ûoNs¿AÎe3r)ƒRL)>þèÃO>6 ÉhÑ\Êî% @¥*J{îO0v•m7n¯Î&¡™³á(š ¾¶UŒ>~ó9v©üœ’ …»¥†Wóõ/fRk§íE*åL¼šnƒf+¬ ä0Dw—#Ø¢¦c ÙŸ—Ãþk_øÚ2ì¬SfÇ`õë^·Â xFf0‡¼l¶ýqR éøÎcÃÿû?ôÛt÷f ¹—TBí|žY>·:<—‰‰sÙzõ]´3Û/z÷~ûº·û À7lûk`öÕi“aŇ%H,KT@v3; »¿á‡ÿÀëGXgÞ¹~ûÖë7-/¢íô̬†qfH"@®¬vŸûôçm=`£­í[Õ'¢œEyPóÈ‘±w-ïÄü-mmŽtTæ„CÑÏ̶3v|êZñs™Sì£ãψ¤5zªBÑÉ u—÷}ä.Ã%‰†zŠOÕþÐþ®“͹‡AÁ÷TË'⋨Œ;ÙÜdHËžJJD «Oýâ—׃;8)7ª³àÉAÈÑÅîøø8åD§$3²³RÁùÓcëùÚaÏ*@-)êÈ»—vš˜°Cá·EÄ$Ï”‘!å‡;1mÌLò6¦¦¨ÝZÅ€†”N×ë2Â¥ i.õ°‚Ehc·'Æsºru³r´x+éÝ=S0 CN-Ô{†¤0SÅÜó+úmÛæ[Æ 5ÐÊìd¥œ8[h ŠÕ–‚æI÷A;>_aóÑKiSŠcÀ,»—Ä-)§‘C3÷ˆ×^îžz ƒlìV©‚{^`Ç;—äb„G´²ëøÒ#ú¯þÔáÞ£Gƒ!dE#$y©[ &”så¶>„Æ1ÇÍ[55 F‘2¨æ@£X4  Œsõ<˜†è7§ÖHÃè›3\4³uf‰}؉O}ì齫½'7”šÁªÁ°­³EuqÔ09àV\¼Ø\ò›e´’wú‘›iM÷£ªf¾OõºRÙ åÄ™,@’›ÕHk#$/}3šWŸGSSJ4ÎêÄÅ5ªÎ~qó‘¹0]žÍB‰åf‰Ç ÑD"ö ‡Ãµg^Ú]l„d%ÃYV€ É [§j(ƒ‚‰b\¯‡…¬ã+¿ë×=õ;¾çñÅ&¥ ¯£ÄZ#zt…‡j\~läÙ%rqÛ>r.hïÞoï©ÝW¾ÁÛû9™ÙðJÛ¿ ÙN+’YHÙ- wÿþßô£}xàÆÝÓÛ7O×G›K‹Ë–£»Ì˜sn§—¢«p²7¾öÌæÖ K¥>íh»Ô~Fê>Sö뵸Õ×9r}'Bá½î œí3v§(+Õ»cê¬SÕÛ¦‚ür°ÖrC6ÓBɇ͈ÑÝvzôêÓ{‹ËpÒL¹eÜni¥«l¥“Œ0˜sÚlŽ…6R›ív3çS5â«÷I)àlÚ›õ3]G[CZS“ÔCqüV£C‰¦”òñú¨÷õí£ç~ï?ú«:<ßu›”zšB€äªçeëN9«zå³ÇI¬3Ø|HñS?ÿjµY:w’–³[ '1žž®OOOY,,éJò9`§ù|Ÿ‡íÍ‚Þ–; —;奀Ôg6H4ÅÐ PpíY×9TŠ?4Ì¡ù]ëHÏ´ÉSNwïÞ1ÂPr½H¨yëTÏ/Í€†ªWŒO£6Ys‹<¤šœÔç {xÁ}Û{¹ãˆûÏ ÿù‹ÕËB+×6°: =TRÅ| Tqþû£Ë™ Úe/w23AîÉF¢*¬÷éámïOˆÁXíE¬ÛKër36²¥¨ªºjŸãs¹ÜTÔÝ!œ>øñÿ/ÿÍüÈ“'&ïä–‡<4‹®\΢ø´©àå1‡lžcm <£pù‰’ê´æö*JTõýrÒ”Dî>ôét£”(˜5§~¢²!c(º³0Éö¯\zò£Oïìï¬ó†10˜{±~µ5Èç]TŽzW’W) ™šÝâŠe[P$‹‡*Ï>îx€Õ¯5íº±>Íýrk)cLpuÕs†¶àË©;ÿfho«™U¼ÝÀ\2ÒÕz9ª¸’Qð´JqóêÝÓ×nw‹MP¶ w3ËJʼnEP¤‚Ê¡hf1‡t÷ô{7¿öÌ¿ùÏÿž'âÑnˆÔÔ›š¥Jg¤þÎç‹ÊÛ·ó×ø•ß•þöm÷€oÁ6cLûYÙú$’žE_;öŸøÎ?ñݯ_¿¾9¹ˆËœ”E'\Ö’¤NKæŽlÆ£7Þxþ…%¢&TTN¸â×JÔ87Ö„@DÓ F¼_¬Í6qᓼÏ6¢÷æ;:Þ ãÐpxí)fJD3˜j¢ìÒ¬†eŠ(Yerd ‡îØß½úèƒOïï>@–¶†–#„3]LåD¯»-JÁË=H ï×C:1æb( ºK Õ²ÆhÚfEii{š¾2ØqD7ëzÞÈY÷s¨ðÐlÔB©N¶¹{tûú›G:½‹›ùŽãïúžîT‡2„ „šä<ÔÝ“6Åz:¢$û³)½]‹,a·÷s?ÿ•Û‡¾\é­»û8÷8\¿!·Irg¿hû™Û‡QžgÊV‡-»ÇÑxÆû΋±Wt! ä> Á]Áº!$Ë&€¢’yîÞ¼ˆ‘…Dh–¨Ù ­Ï4=hÁ³m‘r§1ÓÕA6ÜâgóO|éÅÓÅ^bG²ëLJBbÝϪ&Þ²=Žn˜ g35falu$UBQKZ,ƒØBLHÉ‹æ_}dò7 ¹”¸ª×½f>’»ƒ­"8(¯ç„˜üÇ~âcÉK{â*º)iyåæÛ~âÂJY„PbŠ 0+Õª÷TQ© ÒÉLz[Èí,@Ñ%¼þ¥Ïm3e i€ÆI*æ´’(Œ8³ÑØ¥J4ÌBùy~Á±wP‰)»MÕä^Ó^Ių¿dfÊCºŒÝë_ze¸6„¸3,BZ(dô,’ )+N€FVòˆ+_®×Œ9èµ/ÿŸÿ…?о¾ˆÌÉ!gîÏ·­8Ù‹Þ¾`ÏyûífKðÞö“÷Ûm÷€ovf­°ñ%(V̲ٹM®œÖõ݃çþØs¯ÝXt;Á¢ ÛLϨ•Â!˜U÷qs†:>|á—?¿ß­Òà(%- ’‘#15ÖJ?×7fŸü ;?/¹ý⹑¹`SÚŽCÐøO9€ ¬GˆQx£údUi‘à,tÇÎâÒc}äÒγP|¢æ\mÝܧp¶Âi9kM1@jܯ‘S? §Â&0I™¦WŠ‰óÔüØÀ^;O°Å?ÏŸºðÜÅLlc 9#ee/væ”NoÞ¸uçƦ?ö¸–$½þýþ_¿¾óÚr²*Ã(«¼fe ¥9®ä®âïî…=E0£a½Yüù¿ðsÒŽZÙ¬ìäøtX§U·::::=YcKDäb-å{o\·õ°ãx´·Fu€vövªË=@X3u   ¯k0ƒbÒÕ°\f¯±#„›nØì6kNŠÈïÊX|‹‹g W)˜º…5kÏÇå3¶*ˆM8QIâ$FM3{«»Œ™ûÏøTßÀmÈù~Áퟣ`鹦±Ÿ…Š²êÎÆ‚þç¹Î]Ãé9ÕÙ±RI$¼TЭ¨]ÙÑÍ·˜‡^nG4•hûO•6èÿÏÞŸFÛ–egaà÷͵÷9綯}D6JI¨AHˆ\…°° Â`l £(S…«\5FÕ¨¢ƒ°fXe›Æ6…ØeÆHiDÑH€Y(Ie‘ѾþÝö4{¯ùÕÕì}νïÅ‹&#"á­|yã4ûì½ÚÙ~sN$|.{\Ü;pl4ïûƒöŸüûŸy¹½z¸jw˜É‘Çl×p¤—?²ôgºŽhä(/zHX*Sœ^Tç®÷Ž?KÿÀ ›%Qò¦Š H— 1tê4ÁSÏ>÷ÄSOvˆÑÜÚ6æÂoG0—ÿKA³h ¥6pµ)UŸQ2%#J±A­.JrÑ‚P¢ 2䇅£žá>å“5ú:蟕>§.©F^ º*Jn€¼g³‡@ÉË!ZªŽ\é•!4‹«xÑvný“ÏÏŽdn+C", tK<(ËôÜš@ÂdÞYè‰ÃŸØ[üŸ¿ççoõw#€À1m|@Ó¹/ÇŸÉØ£œ>>`b·÷¶ ÓûXøPµs…ÚGmƒo,n%®BÄ"ƈî ÍQßþì_ñëÙdOKº¡IÐT“5 úh¢»;¹B³ì?û÷þ×+í^œ÷!„õX5`d{Ný¨ö`6>`ðÔÖ„¬·ºk¢ª\ûdøqž./N/&‹/`BJÊ]ò¹Ð,”‘Yì1mw®]zv÷*­5³D‰”25I‡¶ ©ö°z¦s/HHžÀôËżžæ0 q0Î$H°†mÚ¨äý ê(.pÉŸ„{HN 1 f£q3Y™öÇ7oÜ=½5ï½ÃdÙ6ý¤?o|÷¯ù$즦}ß÷-!ï““_u(a/˜S]²¨£ÌÂà eæfÓ¿ýÃ?¹8{4IÙ"Ô{kír±¼ï^ì#‘bd5b.ÉŽ÷HGq¥ìáÉKá[{;i–.Š–Rd ÀÙ8fäY¸uzL>’èSrc%™ „pptèÕR‰7ÂL’„‚º|¹»e·À…,lê±Ê˜Iâs _”ø¶um¬ä É„Ãéâ K®I%R SÉ·ÕÖ_ŸOq”¬+î1æxÐا’_)J¡.š{?]Ý69X,Lzò€Ê €ráCµl4 ÑèF4F`l±ÔêèâÿÑ÷ÿPõ©ãnRŠ!„>F2˜²pœr1UlɆñ<«õhŽÜ•Ã¬§Ê\ ”ôŒFI4>¦’ ˆ±_Î}¹4“›.+Õ¬ÚGVhÖ¬ËIÕYCŽm+ëâ|²;yú…ìì_윴 BÓ§šêÆœ{N—9ÍSÞ²TÆcH^”ÔbŽ<êŒÔG‘Åó`×½l©¯–LX.S Œ´¬8Ð2+DûÌF°JE…(÷æpYìI,{.[‡ ±JýR…Ï’žQW`€‚w‹ÅaïøÙéIh5[I A3 ÑèJ1 QŠBDC´ 6U‡YËÓÛ_úMßñ¿à…™wˆŒžÃ,FŠtUP±{ÊÎQŸËßÑ^{̇˜B}õ· àñ\°mĪ‡·oݲ2:G}šeCå”êelN–üø7ýü8{béæ‘$­ëû–í!'ƒS  Ž¶ê>÷c?~y²ÝÏÃÄ2Ø’ãçgš =ôåòÙÁ?dpU5‘Ú3úÒýÞœÑâVWy­zÙÀò[™µPr¦¢N4‰Æ`hÜlúÄ¥g/ï^o0 ÖäÌ‘uh)­T*3ØäÅ`œ€Èˆ»Ø/c\ ©Gödßvú¡*G+ÊXñ`¯1ÜäG&Í]Üe08RŒÁÕß?¾{ÿäÎñòعÓB¾D6ÿèÇíg}ã®÷w¥”…ß-0*ÿ|±["‰þÅr%HžB “¯‰Á ææ'ø«?ôcàvê´‹±ŒIwPŽ…V¡ ŠF‘_¹çþÚ.thkw;&4sÕŸëçM’ 7ÁˆÖ±Ë‰y$Rœ_Ú–ôÍ*°J—ä:::veسPýD™Ý*Ç9&œïVMöcÛ}곫¥ž†¼”Òï¦å¨’ó0ð3¯>¤mL4ú0Ú$bK0Yô˜=dåÿ,{r¤¢½ÝçzØâ N6)(0tË¥ÑRäª{̵’Íé´³îÝzÃhf rXQªþå@±>P ™9{Ops2¦ì²Ôu‹Ó£{Ë“#(Fé`á7§WÿøßüñÅþõMÑ»š L7!W'íé@)ê‡WˆU1R§[¸ˆQ«®Ÿ/ÙyÖ(Œ½PQT·A³Y¡{D¦©¤DwõÞ4@¯ö._|êÙgÚ­i/gk2ë=¥äÉàªB*CŠòºÖÉfkj_Q­2½ôÊÀ¹Ï <5i­¨Ê. •éK‡_•±rcŒ‚Qêk šUa˜ÊúHë:¬˜á”é‰î•taîQælyÒ]ß}òögnð~œa«ƒz¸Ü‘‚´=ç/¢È>:ƒ¬1"X߬Ž1O_ýÔïÿ÷¾ç Þ›zt‹y¹9ôæ ë>Ÿnhý‹ño´þB£iý‚ñ‡ÛWª­)Åÿ_{˜&0>%ÃE…ÒP†‡›>J+›L®¼ðÜOûÙ÷O–¡™ð½WÃÜ2ÉEŒ†Ø­¦›Ï_ýÉO;Y†Æ6yyÒH»@±ƒ¤ „Á QR”EkHg'ñÊ3O\}æIŸr©mˆAË”y7xö³JFº™çÜ`ž²&˜lùñÓÿª ¤½2æ¥ÕF3ÖÏKb„äM€P4õu&' A_…‡‚•ïP^ßhÝž…@É•Z{”')41_»Ãm:[ÎuÑ.ßûüÝÅ­ÅĶ" Æ`”ËHõ¥€ Ð6÷"4mmZbËV¶Õ͛׿øü–ïžßžªD?åŽçyZ?;L6^©ôøgg_ןñ¸½'mMøÐþîÚØÆ´ñâœvÎù¨¬?ÿt,‰ÎØ Óé!·¾á;¿ûÖq?ÙÚ^.z¹ –¼Ðî‘¢€ ˸¶ç7n¿ù™/nsæ«€`ªxJ FÇl‹¤ÌÌ? Ä1_4 ‹ (Œ§þ-‚Òð=¹PäƒÿaãIc"TEpŒR¿&Ø…Ìs…H FÐ.]|âÉ«ÏN›™ä £j¶|ƒQG×ÆWlÅ#üÆ€•ªÝJ‚¤© !yŒq ï!c_|ØdϪjT‰Y% -±9„Š#\TTw´¼ûðæÑü¨GÇ  gˆÈ5i&nü¦ßð [xmú¤,šYªÀ*&YµxýIy PŽLÎ묑Ýí×Wó‡? ÍDÁà9à)8!›Ö -ì¨ 7vÒ#´ìÎfæ®@hóÆ.lZn )egÊ)‚¡…¦ö0 òêÚ m`uA”—;¡7bìONO³.‘ÇQÃS9^ûaä—ªÞô~ìdc‘=ª–,¥°ò$~Ö’¥uônŸïÿá&ý-pÕÆ«Î4§”à!FÏا5¸Øè‰çOU:Ð\1ör/(š*>&J˜òÕ¨µpÿÖkìºÑ#åPGkåæé] Ã»®?Y.—ËÓùâh¹8é—su+CJ{“%ÌdìõF§ÒÑ•§¾÷¯ü7w¯Üï­#=e~.Ã2_\æÆ¢py=l*0•ÇN¥@²‰ÍÕÏýb™Í),¥K$q…’ʪèJ×Îò@¤8ŽÀ le2ÂÌ,¢ [Íõgž¾úäõŽÞÁÙÒ¥¤ä¤ ft˜7³üR(¹¼ÈäÑNcR<“ÕOÉ:AdF 1ƒ“£¹F;,L6€©ìÁ Åà –j³Â`“ÊîÅâêñsV·ª‘×ÕÛž@Gé·hDœ !L·šfkqÜ]œ\Z¼~zúêÁ6·zg±¡Cl‚»Ã,9"УWèÙ0ØTs†ÎâñÁ·<9ý7ñ×·§÷[#!+àŸ±vfÞÎz8‰¤”õ‹ßBzÜÞekþµOüû×xf¾7ß–b,äNd¡ÞA&}”…öpÞ~Ów|×B»jb7¡±;³F€<€b4@@ ÍöŸ{iup¸­m­Ô4Óåj1 :²Cˆb’3,Sºìñú¢D9qÆðT¥“dÂA͆ÀBv²@9ø`kæ®ÏB¹6'4g63¢æ–¹$ä ˆ­ŒeÏvNÒ»º°sewkߣà0K!D$3óè6¤¦Oñ¡EŽ­J[™™u‚:ƒ²âD&tJ¢'Ä®_™5“f怙5),/Ïzå ¨óå$ä&hæíž<Ü&3_õËE¼Œs”lˆ7)@“6Mç:ü9ß²õ‰b~t4™DÒ è¬òðì"÷ÁqœõˆÎA˜à&i:ÙùÿÇÿŰ㽇 «)èÊúÖ%ª2ö£ã~66FùlØ4Ýž¥xâ¼ñ2h¼Âè’þA3ÁcýR; ÑLy/åµJŒ›UËbl÷þÁaÎó eƒT"ˆó<%g}–—ÒMiF³t@0’ÎP¥«üq÷ÓIëúðUÕÜ 1ëÿ9oº>ˆÆQoÎRÆó[ž ¾·²>[LÍbŒk£dÞ¦õ¿kÚHíÀŒê£çÍš=,±¦ù·¢'÷Þ¸~ý™(öDÕjµ ƒhDïnŒ`@ ­Yô>2ŽénÊT;D8ÐDXëG&W¯ï÷ÿÀúW¿»»ÿê´éÕ÷dËX¡4žØu%PI›MI“Ì›t)3z¤œ‚w}ì;K¶ˆàRí1¿|bÀe SA•HdA9É›–$I®Òd’H9âdwöôÎóG‡wîYZõ±—VsN!†#LUÞ@–æ-g^.Ž®-óUJŸ%û…ªS3%bÍ]f¹V*ãmòZ'ý|8†,[B¨‡=g®t|8…µE]åLJ=z`¬ïûf:å¤YÆe˜5ËÓÅÎl·¿?¿}|óÒ‹×V —ÖµÁÐy˶_Ŧi£9±e¿l¬ jÙÌË£0µÕ­Ïü;ßýsÿѧ?ÿŽ–G]“©²g“HÈa—~®m§sZâÇ‚þÙk Êœóöq{oÚcЇ¤Ëãxæ‚Íã‘Mgï—¯MÆ^¨^Ocsí£ß¸ÿäGV1-v± m=ª0ƒ\Û¤ÇËŸút<šOú™¯Ä F†d J1HYþNžÂüÒF–ïÁŽÂœïÜÈõåšt¥ ²%¹^Sp3=fq Ø(ó%Gÿ€ÑßüO#i2rÍr[î°@£•¯Í´ÆZ€‚]Ø»öÔ•çw&{’‚È”ë¥x‘L™ßå¡ŠU£æ°J£®~“"@CʹD(EÕü?WÝ2Æ.09<™‰²¯Œ–eðrf‰!I›©Þ£¹£?Ý;¹u¸¸×Å¥f#T ØcD4@€C‹&Ì÷/Ýû•¿ì…îèõ­­fÙ÷ézOæÀìêI\V–’<`É–d[wAf0uÍ«/þÄ?~˜‚GOYºËír<_ÝÓu ù@n±qΞŒ,–Ø<ŸnÏJ‘‚xäET1€QÛ {1l£ ªê Ö`Û´ÇÆ%wA8<< !(+‚ÔH¯rKj^¼¢;À¾ïÓ­«ü4ü°ˆ-i\Uåöèi?ÕH²Û7fDõ›·!åÛÙÕ™¿©qíE¦:r¸»×/ÒwÅvv¥åþ1-^³1 Ä¿¤UÍ××™öžÉÕÀï¼ù2º“ظ¯€žAb¢wôÑÌ¡Î}ï¤%录3!E «°E¾V¤xÜoÎöÿë¿õãÝî^g}h'PrÏV “ÃÜ0™yËùb JÉ‘¤…ª1èBûÅR]g ºO/Aì–åø¤¤™7mûâvqUêìU„}’Qɳr ÂŒ”ÅÝ‹ûÏä#{—öVý\ThÍ¥(‡¬!HwÛXyƒ NÁ=ÑMf …eJ5ò0³v¹t «Æ…¤`»gg=nÊA.Ya)#BZ1ÏÛâ"°¡Ì!O£(•Df¬èƒò@¦=!´Íd ¹Ì{ïÚ©ù²k–“íÕÎϾN0áV·Š Ö«Ÿ4mŒQ˜¹'¦jÖ „f¶ýHû>;yé³àßý Wt{;˜÷‘UŸCqçæ ¾I.p¤ôàÓüðù€×Û{ÖgúÀϼxÈ•c5 [:Î=^`ñ~§zLžØEë»×?þsѽå }×{§&Lº>TtyJbíS¶ËƒÃ×>óùYg¶0:̨Œ>Pƒ$ÊÃà!A†¨P“ÚqÄsT–4@–Ë]ehuñ~n¾=û ÆÝË2u¡íY :ÆFj³ßz$Kj<ý^¼ô.¸hTä…ëO_ýèöd4£Á­$Ì,Ùî^Ëë Me…γxŒ‚A Ìl’Õ=®\aÊ”$ûn¹\¤T€ hɤ_b2?§`I_’Ô+yx´êæwNo,ã±C°à4w“ºÁÝšt±‰š¹&+JmèìÍù×~Ò&¯a6Ÿ÷óÆH‡"9ÀTŒ!À¨R¥ÀH›ˆF Tìé.E™ÅhÍìÒŸý¿‹æbtCÓ¸ŒÖx*ä<–ù«É2Mü°Ðç®þæë"z$ý$)røöîv†0%æŸÖŒ XRøô Ý~˜4} #(0Ry¸ŠNÊ‚žb¬Í%xôRó‰I²ª8¦,R$…1¥ý$…&HhB«`°6Š2®A{ÈöÏ‚ÿI¢Oõ¤ ¸>å»|[W™7ßâA6CCt—{¶Pd¯LÉ»úîúÃóºQ¿-‘$©¨ù) {Z “Ý»}ÿÎkTT'ÖФWû–ý¬é'aa¶€–«år!EÅŽTTÌ=Dä) O„G"Z´f¹ìçGÍ¥úì¿Õöí|áP* V¨æXt7N:Ånª7¹u½/¾ê³F0«Õl$ÈP–ï«Ìš‰oNt[4W ÝÈ;;]e^ªùÂR‚)ùi&3º³ß»zéÙ½8¹0=Ž‹>ˆMˆôÎW ’+Q‚SÉC™õ )‹ùcå[Ã9œª)ÉËU™¬Wy®ªõ*Á“Ä_ò¤*ÛRæS³€l `.dLBÍX[®˜f–õ W‰é§õŠ6 a Hw6Þ«³†Š®¥.àÂÑKGóWwÞƒ¦íÒz¶Æ`î1ˆ­‚¼"M-Ú-l{O,—[oü®ßô«wNoÍÄ8ìöJâíè- ƆeáÑÉËù¢Íè&.JõÕÖˆÇ À‡©½%Wª^õ±gªbf1²AÊ(7“¼'É$·;?üßñä O·vbf‘ÁÅÞÑcÀ„Ñ’i-±¶ÀZ¢qçÖdgv$á¾ „!(òå/Üÿ‰h‘°¿H&Ejs.Ö–õÑÈÿøë*YFñ*Ï25ÛÙr/b²®˜örÚˆ&Z¯Ö}: CwÕOSö C±RÒr¶òš£££èÎá|HB tKäépd÷ÚjÕÃìÞÁQ #¡—eo×éQ.›J,%«áhø„ÖgãÃÜΊ:ó·l†5âÇ”¶2íEÕD@Õ=º«ÞbCgüí¦6²®©EwŸ4¼ýú—Nï½:E×O¨HWöc®âÔ½?¼}ëËŸ¹óÊOÍo¿¶…h±s_ KžÔ %/SöjI´†§._ÿý?ôÿ;¼þ⼉pWhÚê&ʶŠ¢1r\îZìKÉ_¥è&¨ëûe‡X”CJÍ_‚Öžíêóâ¬êeåL]%h%‡Ýps(NqxˆnÁc/?Ýž,úUh6ÖÇ7eT6Q¥š<¿ ‰2*‹Q\ðÈKT”öÈáX¥‹Rß²ç®h†´evUà@ÆPØPfF5^¥*a¨Š’†MŸ\‰D„&“TOÅi`L )†~-ßæï~þÖ6/øÊú§¢»1{#Chzuh©6A˜±£î¼þÏïÿúŸ÷ÓÚùQŠX µ.ñ«òåGo¤ým]³AÏ¿jè؇¡™Ð¼q·ªÅV<©@9ÚýÌ „Dß“9>ÒÐ-Ú¯ûÙ¿LÓËb裯ºU@0˜YXÆÎØuÃÔ§7>óÊêæén¿OaM=A] 0Zk-è%QJêsAR™¢¥5]†Ì2çìy–œ¡;ëwÇæÅçMl¢Åª)­°Šô Q ‚Ï&ÛO^y~wv ¤QÁì¡]KŸ­òa¹7upMÞÖž”n&j? °†PÉü/S¤yRÂ$ÅÕjÞ÷«¨ÎÕ't«`öBì]½÷‡§wïŸÜZö' SMDÕH 7-€Xe«Чp:ï Ý‹ë×oÿò_z‘x fZ5SízhdÈÅ¢{)ÑúÐxßcÖ\¾óZ÷ÿƒ?ùc?úRË‹]‡08´jfûþÿö´ÝGìƒÑh¦²ˆ5j}Áßv{#IÉ|`YÝkØLÛ:íŠ2ÑÌÜ£$§ËÝ·B;í1cc0XªJJÈ(“’  ïÉA{p:?íû>Cª²5:ÙmÁ :B±æäÑ“¹P0k§¯¾qc¾\)2"Í3‹” ,¥q ô/Ò=Š£I$ •?eƒ¾->þ¾´5I£|¢õƒ]¥´ñÛlàúØ¿…0ñzäÆÛmÉõBy[$joxµ¥»±Ÿ/⪳l wŽ¢‹‰FÉ_À…º„„Jê2ŽL 2*8,š¢ÉM2'R6 *2‹APdƒ aΞS]|æúõžõºž¡!J2Ð ˆHN(0p¹wò˜(fe\£õª¦ý„ùI±aª>IPN­Ãb+D$©twrÝv¥bC]•GZº>_µé˜Hn‘ü»¤õEo§-š|{"Ðet°±HE“\\a7îÞøÉW'ÝÌ|²¤cBGD@ —oÚfå M»°c}dëaÏÃüK_øÿÛoÿ™Oµæ.—ÜhÉŠ´nnÐú¶y”ö(ä|C•Þy]dzÜr;3éÄcàƒk\Sêõ'8èϰ'åðWrº»ËN;\}ñ“—ŸÿºÅÂ!“Œ‚GR ¡QÔLÛñpù꧿Ðt˜xã]lë#JŠ20g#4 mªÕJbÜ™¢rÇQ–ƒÑ•Ì2ªÇ`c ;sÎÏ Ïe¾ëi|dZšÉ¸ £ZtŸN¶®_zöÊîSTc48ÇÕ”Fe¶²8¶f¢á Ï¿õoìh]Âáã$F®MJᦅ¸\ŒBO¸™]ß­ßø*v§!(®-trçõÕÑÝí¦ñ~Õ« Ä vïõ—ï¾þrK¡w(ÝûhÆT7Pr9£Ó›XÇx¤­;èþÂO|é(ìw+Y$AƒŠ+Ë׿@÷3â?.–ý|­(/éQVhb·lΛŠ¦š®ÓÍ3n©Dj³p)C.éwŠêÚ{h1L›§^xþÚSO:½—š¦ñèÑcZúd!‹‘ÆÀÆ, ŒŠC¯NÂM¦¥žcU ÏeÝå0"§+§;REÜÏþ„ü¤òm ›®sŸAV,ï“(v°¦&DœLDDM;77ŠB£Éò°»<»tû³¯ÛA¿­íU'dmØ»·Ó¶ë:wíloµœ¨o§f«W?ûý~Ý5ÌB”¢å¯¦Úá¤BrtªÖÞÖAÛ ÚçJü:ïÃÇíüvfš„Ç À×Æ2á;ÜÁƒ[ÞJ¤ù À½£úÝËŸøÖ_vûdÙ´ zÑ­a%ÑiÕí`züúÍÃ/¿¾‹– J`S𲙋•&ü½Y“ès ·MÏ_C8dN©3¤ã ÊøÇhœ›²ðв,ÀÑ6>Ë‚ ‡ÊV.¦Ò±É¦$Ê#zšÛvòäåç¯ì>Ó`WnKèmdº©£è…£oÊ9òo­gkÓuÎ4¤ÞÈðQÿÓpS©.‹¡É\ a¦ÌXI|E_ö§§wŽß88y}å‡`ofND‚0HÞ'c”#FaØ#Àb´5 Þû%¿âÚÕkwúY×Ñ„ÀVâî4Èqõ šà2ó½ÅñäüÞ?ò£û³[v±Ÿ‡­é¥?õßþ…Ï}þnc—OO›Ùε?ó~ØIÌ•MpÀ™²„Vr˜½wÔ6tæjj“ÓitÉ£vvv£§‰§@70˜œÞõ3›ùizóàö^zzïâ$ÆÀløÌá‘™qgN±Èa“GÇÇó AI"£µæ¯K0_¹‹]ì¬Þ¼wïÆí» “ÞÍ)GÌB,3JMªñ¦Ùí”dèŽÑ®*²ò¦B½.7Ÿ+»~X×_ë¼Ï±¹Æ@›h./8•µ¯p›¶³Ï}G³–1ñ ØA$Æ7_nhË“ù¬áá­/Þ}}ÖZßõlˆ¨èÞÏh8<~ý³?ç'Ö«·–Å$W/“ÈŽ¶bo˜ï=ù'þÎ?þü|6×ÖÉbqº<].–«ÓE·œ{ߧÌùf̹j³I&!åùY.#,ñ©rÜWÞ籘Ƴ¤õ1—}¨"´­k#ºŸÍã&5.sÑGóœ²éè0ºaÉÖ' ÐaÞîOžüØóûO^Z±lC¯èŒ 𔃉ÊÅÎA+Ðœ?Eå©Ÿ¾’ã^kXÊñPŠxЭ õeò’Vó­PnUõ›¢M•@‰ì9O'<´ ,H ~’M=„€Ø§p¶®_±áüøt¿½xòÊÉÑ—w´ï½¹Y¤;Õ„&.4Á¢©‹d@3i8i»ãýÃ7ÿ_¿ñWo/ï¢ç©wË~ƒÞ4š¶‡ìû·%çŒuü½åú‡ÛÛn€¤½3‰_?V!Œ‰xˆ€€ Þ÷¸TóÍßþ¿9êC˜N–óΣ›,º3_©‰a'Nn~îåîÞÉÔ­¢DO‡¤x€[cS³&›{¹Ö©!—DéÙùƒÛNI(ÿjýg>Ýdcf6)A’®Ö¬W‰’;¢èMÓ\½ø䵋O6iÄò”ìhÌ­*¤"G ”ò yãr¸!ºd>1þWEÄ¢ Ôñ ÷Oá)µ·1ö1öt¡?Ü»{p³ó¹Ð[C™+¸[¤¬ð¤—øŒäȃH%KS­ƒºˆØ›\¿~üK¿ý)ÍßlE,ÂL€à ¡Íi}‚´¾â…öÚÿýÏ}ïøG—GS,gÝJ&´q6›<õŸýgÿÃO~êÎöÎÇÿÞßÿò+_<$BânžêÎÀFS6LÁ»6òhÖ²æ$‡pÓlg«$RuҤدº l‡öÆ+oÜ}óVwÿx¿Ù¾²sÑ©±ìXV'?ÂYb"£ëðè–¤¦5i‡Y_ÌŽµ$Qåd‰´¾ÖL_»qóx±r¶1šè,Κò«q}‡ôȪÀ=Ž…ú‘"ýV3tæÕ‡¤iý5Ïû<µóM‘BJ¥^]–EÒz{ĦŠ¿¡»^¼õvÒ14 ’ð®g¿zó¥/î7áøöë§÷ÞÜkt± TßC©d6ÝÝäÛw^ûÂòþY@ß/ÉŠ%…¦@sÅŽêÜwÝêã¿ç/üÐÝ‹óÖÚihD}·êVËÅ|¾Z®¼µ:¢9(1ºw½bL›Lƒ;ŒÖ3`_DÙŒ„aK l´eó1eÉ39*¥©M »$—'bn… 1°‘y§Õö…§_xnëâN§È& °÷˜*–P ÉiàQSWe¡âKËì#ç-˸Á"óVogukŒlÿy ”8¶º[†m2Ð …ƒ#WpRò‹nƒ§‹‹²v²•—4¦ü«õˆ‚G4Ö* ¤ švy²ÚâíÎçßÜò-÷ÐKa:Ö‡ŒA65L&«Ž³voyÿö/xþ¯þÏ6ËeªÅž<&®ä°-.šñ‚žÙýçqÆwÖθÇí]5>ýÂOCaC›ß=LøzÜÞq{7óªóäÈ‘A¯äo3ôÀÓžø¦ï|â“ß~zÒ£7Y ‘QsìÚ¬;>¹ýå7¶Ùb)$—aÆ·¤¬8%­8(('‹ƒ÷q±êN™ÁÈ3Ä\ª¶àsü0²¬9tµð‹‡²ßA½ù¬^XG®…¢ Ë’$‹B 0Qro¬Ýß¹2ìÑ æ–„Ä\ºÚef’Û8劂¡ŒgÕ°:g—¸Ž Lʺ¤R¿Óˆdïñ˜ƒ$öjŒŠ={Ÿéî«®K™\ C*¸kBšŽäð‡ ¹ß) NêŽ ‚S4űiºÐ|ñwü;?gö¥éÖbÕƒ©ª›ä@77Èchï Ÿ6qïýÿßW^½·Û^ZD›€ð‚Çæð´‹Ö¿ùú+ÿÒ¿ò«þñÿúéÛ·VŠÁ8Rx.Í“±®ÛoѸ~X*¨JhèäPÏþÙ¯ÿ¨]˜’Ý dÓ‡ùýÃãÃ#cT+}ÝGŸß X¶ö°íÓ'y$ùHØááA=íÊbš–Y=›ýÝSr-Êé@/¾vã¶BHåÓéI‰œ›ä“½`ŠË/«Œ’ЭV5ƒKš„½XÔÁxtrzt|œŠ˜©F_~øt€ÚtÀRS!4ë„…îÑÍ bŒžw76É#=ýlÓæ%r·ñ£.š%²)b"ë£3Ô] ‚^D`w5ÍdÞ-ÚýýË×?º’!¤ÌôfÊI“=š“Ddè'Wãê[uówÿªooïÝÞ hÈÕªÁòæ”÷(CÉt€©€½D $</²´j’R »`1áãÏ̈F–ˆ­ª=©e0°‰ªxoxr@)‚É„¡´IÒà€»›…nÙß¿u{q¼œ„Æ =¥ÆZy4³*Ät¹‘žic)0ÄäZY´¬¯œU87vfU;ó—iŒ)< |¥­)OOrü ç BÊ3&‚ }×oíí„v]ÈE‚Ó5ióˆè1À@À’f¤`»Ø„ÆZÄã+½†_aÑ4QèÌ0“ä”ä±ïœXv‡»ŸüYÿÊïù“Ÿé/žÂÍB*úR‚ŽÎbꆭ½~À®¼?J³Ñ nû¸½E;à „Ç•€?ˆön¤¬Ó¿$ÙàR „„Gw°G;¹òñ'?ñmó%-œ©øë{aïþ«·î¾|c›Û¾¤‚)%oW²ÈÊÀ”±£l×!ƒMzR¨Ûªj烘CU›M:ËÂ2GãØ°T›F7¥†×cCÑp¡XIÌe½}‰x¤K@hctS¸¸sí‰KÏÏš]ÊŒ„§YÌq¨‰þ¦r6\ËüSTÕeÖ3T©:ÊÏ5J먪+ÕŽ"ý´%lŒ žÞ#öŒ bТ›ŸÞ¿{xëd~" ™&eBi ã»Ë­ª9œ4ÇïŠbŒ14Zv¯üËÿâ×^Ù¾;™ö}ï„[ ‚¤ÎX¢¾ášfÒϹ®Ü|õäßÿÝßwóÆjfºelg$`Ö8,ç±?8è.^yñ/ý•xûnß÷PÈ…?å)ú7Œ&÷Ý´ÍŸWÍ-©U){ªÃ0ÛžAb¯)ÃÄï/î¼òúé½ã‰7¾pƒ.íoïNgtG„R^]`Ø‚Ê ¤²h/žœžô_ ö™÷§“m£Ùï€FpØé¢{íÍ[ ,U¶ J›6!¾†@Ūç²äà±·* ‚Tùýh.T÷îfìÃÙÎðÓÎÙж™YÈé7nùH­Jëãë~ÈÝ*u”èQ&t 8{w5ŒJuwÓr0ò Áún9 Sœ.o|é3\žLï{#¢îPÔ¼-DýfûGŽí/~æ–ï]íÈNm“ÃÓ=×ç4J–j{¤]íÜ£’"K xX²“¼–Ló³jLÖ˜3ì!©kK4 ^Ö×®DÜŽLæ•îeZÒ« K…´e4ÀÛ6\ê駞} :õÖ4!4î®ûP³˜%I¼†6ˆ=?(×"HÔ5!óU¸D…™Ü]¥û•O׈‘ôŸ5Ö¬ûkÑÈY’f9¶Œîítb¡q) 69ˆK‚×¥`–QZrÍÄØÇ&˜¢âlïÎç^óû‹I3[®zaB`TƒA ­±IXÙ¾vŽ¿ô™ÿôßþuû'olµmEãú†Wíé°Ë5¾€Ö™Ï»iý}ÜÞU{ ú*jeß"¯X¤ 0 •rTŒlíâOÿù¿úðÓØÇUß¡iú¨±‡æõúS~´ØÖL‹>4€" ÈYa‘Õþ€JÅ€láI€%=¿FÇÒ„d… @µàŒÅþüb”;aP pFÅ)ÿ†D ù957U%Ë\`ÀÕ ¿0w¸äM%—wŸ¾~ñ#;íUzCÐäp¯¢ª•ƒ5‚ `ÔajøÑúJÕŒ0à…¤tDÉùL ã Y²ABªF3§:ï“^ÒáÉý»÷ožžÞ_,O(5!SeɘՒ\jrD™ƒ)ÿÇHΓh0sÜÍÐMßXǃŸõsÚ¯û&v¼½"‘‘ &ÞS¢BCèãöÎîóþûÿöþ}v®ù²£Iu¯À.:Ø,Vqµê¬ ]Ûfª-õYeÑeë) ßq;ˆ%Ê£Ìmb“ÙlfíÍâîñÝ/¿9¿u¿éó¶ëÑLšÆû¯yîÙ~qÌÔžA€ÉЄ¤Ä‚…E·Z¬º"Ï ‹æªI¡2Î8€ˆQt4è\££7ÕL»>e 7HrOµØ„èæžÿ"( ÈèÀ“háI![>Y'œ?A_-íŒpN;cbIQŠÊeõÞò÷oÕ1 ØèÕC;µñ"5B”!¦ÿDŠ>ªyžrˆ‰ PŒÎ`î£Ï¤û¯¾ttçÕIpyoÀánÆ>ºœb²Çòøòµ?úã?ñS§~´$1Q¯Ihbß!Ùz™-{z•“ûºÑÍü;È-:£,FFhM.1ìÉàŒ”Q Ù8T”Ýs¦èœ’ÚËBñϨ\ƒT™Oá(¡\þ¦x }»Ý>ýâ Wž|26X!zCôˆ)±³ç˜*¥z“!Ÿ^@ ›d96"SÑ‘\öÔˆ±$--´€¥„ðÀ;Æ©âÊ‹Ȫhr©áœNÀšIUÞe XbT¤ƒìÄÐXàtÁ»ewqzéðգ×îî5»]'…²±–ƒz4“f¢Ð†h×÷þï¿ö—„ã;Ìcª°&[ýUõóë+“³A|Þ úê0U|ØÚ¹3þXøêh#sȈä 0ôôIŠ`Œ²0=X5?ýçý²NÈ N±×lºÕ/âT3¯^ÿ§_ØáÄVÑcÏŠnÉ¿YÁÙ0>·Ù0‘XC&¥X1ª3¹¾ë6|"üø«b׬ģŠlã& ÖÖ¤‰§fqHÐ#¾ä ¤¹ÇK»×žºú´ÝŠu5%—`b)khÎBÁ1þ¡ÄëÌWòÂú*A¿³ªRøŸ˜XÅ`ÌIÝS"j¾šß;ºwÿèÎjµ(* ]²JÓÖ©ipi6†I_§ÀÉá!An¤!Æ8oílßúu¿æ“qþ¥é÷±k›6ä)YC&ZaÆK¾ÚùÿÃÿòþýÏîÏ®-OÔ4´3†¬é#ŽO´)Œ­GʘÌÛ#鉃ÇÞy{káð4oÛ³çÝÑ»7¿üÚüîQën F_u_óÜ ìb‚{drÄçЕAGd®±Œ.ö§‹Ó¼s]9(X%4F‡ii¡}óÖ­£ùܤ@¨G¯þ„€¦F‹ˆÈÑÛ´T1ÉÑûN®TÓ´(«ÕþÐ9ù³Ô½ð(=éßùG‘,ÚÃ]ÞÞ°7(Ï|òvî1ÖѲ´Λå_‹t=#Y°J&\_ì&¦Åý›w_ýü–wMtx×)FÊ(5žÊÌj®pïêÓÿÉ_ý[«§Ÿ?X®Œ¶ZvfÁsÔ¸§Hà¤q:è¥Þ»E§hŒ)Q¯–ŒQ%Q\&#€Œ`+kQ”aiw$4¾F­­.3˨졂æ!¡ÆƘ¨¨ÕtgúÔ³Ï]¸v¹³èk‚ ˜Š€¨d.1^Y*R  ¤¾V2«6ÃJ®ÅþªHïÅ 0 ˜ª9œë÷†“vì'aB ¹d¡ “¶`²8<µ„ä‡Vd“`–B.¤i!U ØkÚÛŸ½¹Í=­,–À<h!ššÀ¦¿÷úw}Óó¿êë¯ïèÔdð”d„£וE]ì±f3ž¹wJqô€×_½÷·™§5àCÌþyo#a8S’oµÐÃ,%bçqg/|ÃÏß¹úâ rônÎÉôôtµö^¹}ðå[{a;."S9ÏI$ʳŠIöŒÔ] F@ fm‚3hýçãœjCÿó ñ§ƒ9§xHóÃΙ±©‡Õü_)Œ”“QË!¢bêv|«Ù¾~åÙívW›ì-Nf¶Kɬ’k3B%¦SÚƒϼ÷^Ãçª#†ôÌ<=s&K²ÓDï-ÀˆØ¯ŽîݽÿÆñÉ]õ=])=7 0 A)ˆ‰Ui-Ó 07YÜ”ìÞ4!§j\F® ÖXo_ú7~ã×x÷…f«é{b¥™M°Š’IîZ0t ­_Äíö™¿óßþ}¿ûûVG¡ÑÖrÞOfL¹¢Ü#eBÓÌÝr‘²S†°bg¶úƒ‘ 覆Fj&£IfMÛ/¿ÞÌ'14h<‚f"¢ú†º´»}i?ö«$6Žòå)PFÐ…£ã# ÎôRu˜§ó,Á:)²™G骉½‡ K $9$JD%gL„ÝîV»Õ¶ˆÑŒîýy<àÖÄ<Ï´xPoôÐo׿J'€DPJc[%•·?Öù\¿ÁÛÙ·Ä“åïDz’ÈŸ áé)ëVa© Ï ™\}+LV«×?ÿ“ÝÁí-4}ß18rÂ_ºCl¬ë1ù&âïý\{ba+›ŠDò-%Šª´nDã½YWÒ*t§ðU`×5‹‚Ü$º<ÅUñ$îån§Àºâ¼)>ç«â/ÆŸrù`öñ”’„Œž(Œ„#nïí>óÂó³ý½•Ù°iŒké§B-ÂbÊúf?Ç@dêY«"oéÌš!)Iðr²4ÞyOÔa2»F¶8ÙšÕ>§²–XèEV8*ÿÎÏÒsÄ„9¹lvuáõÿõËí*Xl–rµH'ÑÅŽ´6Ø~;½ÿ¥Ÿú=ÿúw}²=š¢sÀ‘Yÿh 9ƒœ¿ˆïÚ¶Sî³þ÷ÃE²>¼íÌ<=ö|Õµ3–ƒL$À£äìd핧®ÿôo=Z 0kĹc[¯~ê <êf>ñ¥‡†€äCn²úˆ$š¯^êwép§@€Ðæî °[å¯×ú¹ÖFg·¤–`Ö 42›d~463 †–¤0gl&ûå… (2°IÄt¶¯]|úÂîU8-¹v©¸o†IJÉ{NѲ懃Àðb£2ô1Ç+‹z²1Ëyòœž|9FÉaîèiJ1§G§·ïݼw|{Ù̓ 1•âtŠ„H†<™éá)c]Ö¯²öRÔ–=çUjã0ÀBB¯Û¿ðç_xîÚ©a%yïËÉÔ ¾è¡1ÄàýtwzýOþ7î/ýÀßÙ^YÌAcÌ#îÖ,8¬M;åh)‡„wu†ÎËàòNÛ†>6ÚŸ%Y§!—w°¼o\rK©_clÚÖãêã/>¿Zœ4MÊ%µÐ‹“w…SÀÑÉq{XõÂõÓÕ•S1Ò¦·NÞ¸s¡‘NZ Ëa9´&ÃÙ’œš^}D4S ´î潡¿¼·õìÕ+Ï?qíÂÖTJ¢¿•uˆ‘íœc½¦Û~Õ˜ÓΣOCiIú)@òLQ4–ÃÞ»=J;GA«+c"£ÅAÝK*U·ò(ú¾ßn&Ç·Þ¼ûÚfŒê{©³ ˆè€KM˾G¿÷äÿô…7~äÞé=6]“Œ¹Ñ3H$¥º'*Lä}n "4æÖ¨U✫cסo æVÑ,C 2U ¬Úª”?©'õÜ?Òä•‹(Ô¨¦õ•ç­kE9ÍTØ} £S—®\}úÙç¶v·VÞ+EW,ü$‡:ç{ZÑÇ6¶ÕЩš§¢,5”iKo1&€™’•-”=Éá]½yÙÄ¡iÍZÈrÚ°õ`ºd>+Âÿp>êœf0˵‡]±Y¬®l]¹õù›«û‹­0ë£;EÐMÖƒq‰†»3îž|á3ßûúžÝÕí‰Áåæ²q«3²1O£ö^·õ3ñÕC²>Àvæx€¯º–­* Žz°“©0:æáÂG¿õ—ÞUãÛ­¨å¼ßk¶ûÛoüÔ/ÚÌΈ`%NªØþÏDXÛ5cÁ4Bh Š'w­†%jƒD>|@ƒ9§È* yÀFÿ·RJíŸK:Í£OšÙåýë—w¯Np©æ+8Ò«ª¢”®'VPä)Õ§žgã(&í¡kcP Ä,l$ë0tPf½÷®XDZXÍïÜ»yûîÓù± ÊÔ±U-PD¤9Û¦a 9=è œÛ ®\º3ñˆ ˜ nÕ Óvjû`>_¤:1¦IDAT}âæ¯ü¥O-º»1Ìú>_EÝ#Ð[Ãeç û7oèwÿÞÿ곟¿»5ÙïNbÛ6¤%9Ù]©0$kÚ»‡'`㎚&C—Ö”Ä4-ï¡0nUKDÊñ”2Y0›4+ï•‚u‰„j°@Æå³O\i#K«²MÒ©Èf;9=žKäqP "—Ë {Nqӯܼyp:Zï ƒCî Í=ù“#*Ç°Pj ­ÉÐ;3>ûÄ¥?óäÕí­í@ÅùlH2Eè #›q‘Fê>Å™W_¡Yÿ 7¾uLJ ÌL òõ;ì·xz%8µ¿çý çñr%Ð×Pq~ôÆ—>c«ùPŒ09#À=„®ïÝ/=ûŸü¥¿Ö]}þ`Ùˆ-¬%™ª&ÌQþ%TË“HY§‡«£»óùAïsªŸxŠ4Ê40Ͷ) ©µq žÌ:@V¥Ë:=¼€ÜflAbÙ=’Î]ÆâÈB E_…–W®?ñÔsÏ`ÞcjѼ‡;«y¢(ÒÙVP$ œ?ÿ™ W9F&UÏ–µú¦ü*¿bѪ–6d$áÛi›Ç¿H¶‹²R!fŒ¨ªM-¡“ÏÕÌáÑcÓ„åÉr²òúÑÝ—oOâ„Juƒ“Œ¡‹œ²œž<¿šÿö_ø³v—‹äüdÁ—Ý9„fCWz÷š·Ö7ÊW'ýzÛ¹3þ ÀcÅê+ÐÞá¤fÖ¤%õ GŒ‘ä¡ìùoùNß½Nkãi´e¸8¹øêg^šß¸¿oÛÝéÊ™Ä×ÀÄD†5œÏrD«´3Ò rd•h´&GTâã+‹µä ö-ÙóˆŠ$Ÿr KÆo# ¡½|é‰KûW&ÍDH!Îôè4C͵ŸòhÂ0¢Û£)× 1¬éBR©Þ$s•×Å£ÔŸ¥ü£’%^H)kG´ÀÐXWÇ÷nß»yx|/ªgHU«¢s±Gå$„Ô‡4³sZl+uge9PZGƒhrv²‡JEóï›×~ëoüæîðK;»Ó¾c`CA}¿j&¡±¶;µýíg~äoþäþÿâú­Ø«iš\€’+„ 4—¯ViBÜXYÅH6Ç„¼®Ïœ¯1ëaaáyéc@šyfï¦è& [ø3W¯÷Ëù$Ï™mAC)+KÌ@Íóe¿,› VS"x 2Y©ñ¶}´à‘áAD½Ñ=B/ÄÅâت‘!W4**Æw}[é¤Êôe|˜†c!•¨†ÿ‘¦cQÛ™C0t]ÜÙße0—å vk†ò»òȬq±îšì”eý\‚9œÁÝÞ+LxÜî_¿0¹¸µÄihzPRçÔ‡nÑ/ôÜ7}÷¿ÿÇoí]/û&4*´Ÿ•cŽæþ|b”®÷]·¯Æ3ýahz ÀãI}ïÚ;’sֈÚ„Yå^ 1JÀ2š]~æÙoü¶“Uˆ+Md§wî¾ùÅWölÇæRŒfˆ›Òÿ¨w¥û™¾žÛóbDe¡ ÙF‚±ý^¶õ.둳7âÞîÅ'.=¹Õn''… ­!¸\!KÿÕ4QMƒ‰p« ã—é…ª ?}P—óÿ4²Li$KefSD/º#öêO—'wnß=¾½XͧQtÑUÁ’ëw(¬™d{䌀B(ŸFa«‰}xNÑ‘0¹9‹RWL¾„-ÝO>ñQÿ¹ß´WwSA˜7zÓ˜ºngrõÆëË?øûþ›×¾|º3»¼˜÷í¤AdºY®Y€U”Øuq±Œ •D{©²ëùn6ÄÃo3lëÌ<—YË[6FEHO\¹2 Öõ}L2‚åA à'èûxrrl €LI¹0‰þHnØ;wŽÅ¦2“+Uù5å½cÎûiê[ö—w·>òôS{ú™«{{mpù*Ð(¤ÝnÅW`&hwg'å¹±Az:ûbÐc×¾\S^¿jÚ#îŸóZwÎySô¶•ó³WÛv‘ sVø¤ßņÐrqã¥Ïàô`ê®Õ| N_1ï?óÇÿÁgnLŸ<9U%øÁœ(¹È,eQVc¡Â(Ä&ÛèTtCCÁ›åqw|÷èþ̓ÅÑ’+kÑÌ¡(w¥´ý0k$ЬBH£÷„%¿e.eÁñúpý#n¬×ÈpsÞt®+·9ÂV‰$zt¡±À.®ö/^|þÅwöw;ïh!¤h1„Y $Éì£Ò–JokT°Bª×&Y(Ç6ÿ•žd¡83•B@€}:›2åìPFRî9Äh<iC id&_Ì: ÆHËE(`$q¡½°w|ãèäæá,lu« ä$X·Û÷^ý]¿éWNŽoLB#¹Ô˜Q¿ëÚÁ{Ú>,ç÷«¨=®ü¾µGžÎÁ¸³öwdNþÂ"Ž¸)¢s-¶.}í¯ø—–Ók‹E3‹¼÷…×tÚíØŽŸÂÌJIX:›DÊTŒ"•FN©QàþÈ’š¡H¢<.ÇF/¨¡„BO¿¶3Çüíéã.ax­Òÿì9…‹´½ýÝ­½¤J.äwæØØb1áðˆB{GÏÏ,tñš§‰‡¥{ªçc™‘öËŲ[.ûUIy“|Ôc[R63‹ÉŠ&È ÂBlÂV3ÙBDÕÎg?Mé2’™:K² APïóÆât÷ö¿÷Û?¾>³²@›t7æ“ÆhZ,V{{OþùøÑþë?qyë²:sŶm<ªD¼ådd””LÖÞ¸sß5uG*(7ØÆßÚÂõ}ñ ¶¹‰*¯rë/>qqXfùt2é‹oùúŸÞŸNš&…È',12Ûöœ,Ü éðè(zÌÓ^*|¥¨¡TÀÕÂɲ»sÿ^)íDrÍjWÊÜ WC¢Á··¦vw÷¶vÓüeé¬ _¬•ûˆÐÜ?Z|ñÍ©˜8d-ܘíl”3Øáñ?€Úm`oF½'mý‘ûõ->kÞµÙ]˜xE‘¹œ4ÖNN'»Wž¸ôäs‹(M[PÞÉÙ^¾uÿ/ù™íÝ/m)PŠÁÌ£`pÝhJ8­HDOi`¸œwê™PçûˆÀ\U\ˆ± ÚÙtº½ÝsS*§‡‚QdalfŒ1–¬ë;£¬$ø­vB1È•¬f;L`€{„0UÔ½Û·ŽXB\õ$ÌL>8Ó˜­JÉ?pfy2eWÆã¶PÜqZ[èì5M.‡Fºáàl{ÛB¡l·]OÞÁõW#þÆáѨ6%7 N]žò`0·(¡ ]W¶¸üÜ‘±gl̬GŒµ8ö>^yþ?ýk?öý?qc9Ýu$Üc5ÿÛšŸ眧wçØøép`ÿ™hj>èC67x¨Y!${t²b jqæ˜?è ž¯'l+¥'é’4PQ»»û»Ó½ä¥MñÐŽâo­d29L‡ÊîùþLùÔÏëÓØž³>7à`èQþAåÈÿ)™!@ÂåËÕjÕ-VÝ ŠB*¨žª{°2Q~‘Ù P’,•?ƒ´ºhÖ䀎¬Cø0eiþ È©€§ ÷¢ÃÈ¥¯l¢®å÷kÆ®½‘¼}¿œ´Ó÷¥Ó¦Ópáý¡?õåW——v¯÷§]Ó  ñXù$,Ì ¢0™Ÿ.¥FžO¾±ÄïZú_Ÿù‡µÊˆò ÛȦ~ÒXÓÍç_ÿ‰÷ó“¶i$Ñ”ý7Ì«ä­äV?™ŸFI—Pªí>çYª¼ Zs÷ðèðôÔ“Ž` ’裔€‰û‰^?ðÅ×å‹—Ãéñ´s)ÒÌ=š“æéò&I† ˆ(¯f‹¶ ˾#‚*m‚ Š®$aNl›û“~qz×ÌÚÙd¶=kšKy‡2í%]!¤¢utkÐÔ2ü0$ÌDs§Á’Á…N¡s‹t6r­ó;ßùíû~Õi)oµ° Cèýéªi/|ᥣÿÇïþ£÷n6Ú«ZxÓ6(2oÚ“Õ7•V-Xp9NNVP(ûyˆZ{/DÿñVy;Wf3[.ˆ!m“ššP÷¶v'xO–´ª•`?Ë óùéª[‘–DqÝ#iîŠî¢z¹Ì:çk·ïÜ;=q1WHMx Z9ÑO‚_»¼ûâ“×>ñÜs×/^hÙQ« $M* …Ð@’«§lXÑòÑ›´Mìlt`áŠã3_T·õ+¾¢í+÷½;çÃ_¬›r$Ö>?ïÇåöij”sØò(¿:Û¡ ½@™Î 4$—¡…« ¡[-&ÖpµzõóÿÔ&¤÷˜“V§Óéûé¿÷ÆþÖ2ˆÖ1Ä!Xç+©oi”rEwÒ) Ãü@²`)ÆȤ@ Õs¾_‘]Ï^Á›¦ ýéêðöÝ;7nÝ?î—‘ „‰‰T¹2¨2ï ¿­3È´ÿëÂñ|åv˜Áâ¥D9!xC¸™à4cD¯VWžyò©ç^@V±·¶u2Êe%§C†¡jíøY´²µ5-ù'ÖY‹„>bÈéƒØNÛ”G ß c=˹>^˜hUõSºÒá$ nJÐÒ¨šbn‚ rÙ0¬ŽW›Ë‡/,n.'šö®®!,L9Ùí‚^úìø-ß½?¿Õ„(H.3Ë+—X™÷ú–_Ÿ¬÷¤=ìØ>nj€÷¡mÈ<•ZÎ2f§Ášœ ’ÑÁö¯>÷ ßy2çá+7^~óbر9)Ðkþ’µ¨ÇÔÚ£Ô¥ñŸaP•†ÑB“4±^‘ Ûç`ËF·¨ÿš6ü­â •ŠÕ“’OÚɵ‹×/í]e.YDùdéGJ¤Xia½­J"Îâ¡EµD¬ÁÂr3ü~˜Øny"ÌA}¹šÝ»{pëðä`Õ/`‚%A>*Ëô9kæÌ ›¹@Á…kè»>7‹Ù£)¹‡T]Í)8˜´2dؾܡãkn}×/zó×B«•«™µ.uK¿°÷Ô_úÁ¿ûGþÈŸÛ™=¥®¼wºRð_ÁåÉ#ÈØËlrtr*´.«DfÄÏÚ·ÕÎcðДRšO`~Gˆ€5ðnþÉ|lqt4›Ìº~i9V.­ŽC$-ÅÐwÝjÙ­’é>ßXN• FÒÝhv¼X¼qçö¢Ê.)4d©7¯^ØýØ3Oâù®íïoµT\ v i ¨æÑR2Æ”yÈ2¬,}ŠI‡œ|ok ¯œ=pëœwÐx‹´ñ¾²Ì÷N÷Û¼íÙ;Ÿ=Êâ·»7dö·¥o<à±gï1¾}]âsÕŽîL”ŒÙ,]ŸI6uMèû¥ÛÝ~õs‡¯~iW®®GOÞØ~â¿þûŸš_¼¶tJtľ_äÑ{ˆòyeÊÅÊÑ4M¢9òhJSŒÉñWbg¨^Ýh &-&ñ4žÜ=<¸y÷äþIœ÷Ml‚B2É*œÆ¥¬š¤ƒù&kçÕS»vÞ¬ž3‹Éšj æüm"@£\{svœ†'ŸyŸts­ ‚Üs? '«c<‡µDâ+Kb54e®”Å ,¶™´¡€>s©¸ ø”Ùs6R}Sc(ªäÍ`)}\F9š»àjm²<îv&—ûûñàÕ Öt8iÛÙ{¿ÞŸüÎïúÍÑ€¸y ·pSÜ8ϵþ¶Ú¹«ü¸½íöôþ´G²{rd’Ëg§äÖ²‡1Ë..ªûØhɽg~ú/X¬Ú{Ÿyyvlû¾ÃÞÙ´Q˜Œ3Ö+ˆl¬IÞë}-fMS(r²Š!lBë½òôàšéëtj0T¸~± °çDRŠx¤„Ùdº¿}¡m[÷ BR-c{’ù?Å|4•#šWgzP6JAeÄý@Ū~Àñ嘃’ñ„WœÏ«nÕw+±`c˜"ROJ¨¨³± 7g‘+ßÅ8+ÑúãA2 „• ]NÏ#L™g2?2A¡¨ê Bçxó7ÿÆŸK½ŠY;›Nšùê¤m÷—MûûþПºu£âÒ ó“ÕtjÓœº 2ß'óÍa³HVQ'ó°j›éìU›áí¶G:Pg[ö;Ó’W%X(ÇCXu_óüs«åñdÆÕª aâÑI,ùÛIº¢™yôãÓã¼W™ •Š¸%M‹!Ĉ;÷ç )#O H wvfûÛ;{[[ò|aåX•ü\ëC8÷éçÝ–göê¸/¿8«RðÀ?¢à)P¨‘• +IE7#¼÷ž»“éêððÕ£O]|öÅöÂ…“îÐv÷ÿÆ«w¿íÉã_¶}©éNƒw!¨ë¢YHç·Hu™§]žçÁB„jh £ú` 2ºb°FQLðµ\LHe>ïNN–§T˜N¦[Ûí¤¢—òàe†>; îBæ7Yn\°Ž³±&kÜŽUËè(iòs*ewÑšC=ºfgúÔö‹'÷î‚!•ìˆ–JïÕòÌEÀ…ή\ÃÏ.uMˆ4äPCNøÝN'I×!!¹¡×ª‘›²~&KbüƽXçz™ ÏËsn’‡$ÅØ7M³ZÍCc“Õôèå{³kÛÓËÓeÌš½Ó£›ÿâ7|Íßû§—èåÓyØ ŒŒÉPUIþ9‡$©LýÕ{O²þyh=ïO{KÖ£á»*ïQcÒQ$I@2@Zjëê3ß:³ë7?õÊî|2‹=AzìS%&¦Hÿ" Kë£2-|øñÑðËÒÏ"3g¦À¶i ܧ¨Yf­ºz­ì¬®ŸŒâ²2QošãE"hšL'W.^¹¼µ± ÷„ˆ–+Ë™*v˜l㬲oyVe…`§g¦ÙO¥!mƒ ùTª¨•;›9Gž×IYu˃£»wo.:_¦þ §,þ 3¥Ê/)TsEÆgæ®"?·kÖ,%Ã.*Öv°j)À— žkµ":Éä"ÈH¸à«¶™÷ý«ßýË?úì垶$Ù6ír¾Ü<ñÊK‡ßûûþëãûíöäâê´›NMQF¦RšÙ£œ§¸jVFš!´GÆ©ûÈŒµn{?ÚyORe¥^p4 {³éÅÝ]ÅÞ]0Ùn“–ØTbaN§yOç\$ñ‹2ŠÁšãÅòÕ[·çs€¤Ÿ\ÙÛyîÉk._Þµò% ©$kßT§‹È`%U#&×ö†óHtíζ©X¥žÙ:kG½|?ÿŠ³ÒJKÞ«ÍpVšÞÌÙ!½ÝGoýõßÙ'>¸wÚ˜ñ33Áõcº<âÌø8ÜŸåÀB-!eŠIcŒ}€fÔÝ—>{ÿË_Ø5œõ—®ü±ù‰×w/*YÓN$‰^ §+"Åzf?C-JØtGL ËáY19¼ÈžÅÌN$²îtwˆ Ú-prïèîÍÛLJqÑÓi™a Õ1($ ñ.N€Q´WòS:;áÂúÜA”œ¦‘”Ë`„IL¡½Ñ#ÁŒ=–Ûwž~áùý‹û=¢ l,e7*ä¢ò/æó»¶ÂYدƠúU éͳ-¥Ê4$ChšÌÓrÜ]µ U„ë&H¢dx¨{bð;lh#E¬XW$2©7ºú"bfØ>yýþêÍãß2µcwº»¼ýÊÿí×ýÂMîO“c™BÍ[±&Ähý!x÷íìÁyÜÞF{œè+ݸN£ÇGá<|\³$7}’ò]ªìßþØ×|âÝzåηB¤“€)Û"«u@ÕzP ç3¬3Ÿ ÷ŽéeØœQóåbŸòPgšœEò”èYísd(HCW$L•÷RÓ4û;Û¦5$ç ¹ü,QÆlÔȶÞԓį²ÓtL3Óp Œ5?Š³¥°”:æU ¹R‚ËW«Õª[®ú¥òôg¥5®wsÅÇÛ"3„3Q*½8»"^DJÖlÍ.H!gÎ+:D÷a=!öd4‰@ —›ÈÓhÇÏ?{üÛ~ó×|>Ìè ,ÚÚºüýßÿ7~ôÇ>}uÿz7‡ MŠÊªN…Ð °únr„yºèûÞ[0Êy8„+ž³ñÞa{(qÊ»t|äT!{ïv¯ì7Óv¾øÆŒÝÒSô`ÁûžÆºæuùºØŸœž‡`Ûô,EÁÁ»÷ŽËN×d »ûû;ÛÛ[S¸#AŽÓ¦©É(€ ÔG[nhèSIBÂ(ÑšÏ}ñË'=<,øÚ´¤ÔFìðèøè䤪³ƒÜø^·óvò@êÆ$òßüÑÈë£>qCâ?ûVÔásÉþ¹w:ÛêçgéòüJ´*m­véâU¥Ü-4ó~áÍäÚ3/x»½ ûŽ~Ï/üæí»¯oGEGc)5Öv±3Ȩ˜´f—r¬°Z.EFDHÆ&„¨>Qúlœ/>Ã"¡æ3©ÔFšHy/õÚÉd2›MfS:”•rey¶d$À’Á¦ ãåÅ8%K‘¾ëóW«‘Ì9ËÖU‹äLV±‘{Bâ%K¿{ŠT ¢ŽîX yƒ™Hyu@&Ì}âUÉÈžŒ˜CÆ‘*•[v2)N 1úÖ…= t(Г'‚©¨ £}V\F Ÿ™éÒ w·Qr0A†b[?øÊõË“O;‘©Õ†°ŒKo±ÿÔ÷¹Z/Ø©Ñ´õÛþðÝß¹ÞÑPœ™‚R-õâ`ÜÜêï"xm=¿BTëŸõö8 ÐûÔÆvˆK-›ÊÂ(,4ÉÒÉÎèTT3ÝY./=ûÌ·¾ùÒ½ývÆÎ…”Þ•QòÕàQîS-ënÁ‡œÂ5«Fý°F"›Nú¶ m#@*ÖD6E€*fˆÏEó”å2=Ç% 2ëbß’F¸ú&Lvg·&Ûõ>*w`æ Š¨Ø&µ¸òd xz*Qjˆ õ˜ò\EiÌiè…¯ÀW«ÕrµìúU…-±&yîXéhîÑXÇÉ K›ó!ÃeIÿU‰C WÍüN$eE5j„#³¢E9eA4²×iÀ)ÂëÿÚ¯ÿuŸîÛñi4nw}ÿ}ßûÇîN._xzyÚ›¡a@Ê~-i¬U¨jïÈ(ÉíødåšÎãEÂHx_Ú°o‡å/«‘Ó*y6ÛwO^¾ÒFŽ Ñc Æ('C0'Œàéé©™y®¶›ex—34'§Ýí{÷Ý!³I³»»sqïâölê±3B}òÊ&EVxb5ÿŸDÓh¸þMQöBîÆ `wgçôð¹¨*ª¸œ:T$õæcÞßv®Hû^Ýg>9ûÕxÆýÙ_ñ¼·BÇd ²ÿ ;/ÞxGÂ<×/;ûü$°"S”ì4ÊÊ’÷œóØÍÂÄ=Þüâg¦¯û…+?rñ¿¼të=q±ŸL L™Ò¼IÉàèÙÀc1*ø$D?|íÞv··µ·C_œ~ìú…ó}Ýñw¾Ø·—$„P}B€ê|«ÿ€>|ÜÞçö ÀÁþký=Û0Ác%}H€ôˆÈÉô¸Û}êÙoYÜ·í0SïnÁRþoy¶„T²SY[õ‚}‘NrþÎ92uà]êC˜tÖåÙB|2x:õ¤PídL ’º’ÍëHõ„•2W´êûÀfçÒt²m "Œ&/âS!ß‚§ú·²$‰gš>’§+…Y82?Ùe„ÏÙ9¹¤É`.LBÈE$ÈT•9d³’ZHÇ,l½räÚ­‹[M¸tïöÉoùöoþôßüË7KNáÇ=Ú¹Z£IcùFçR«GhÕ‡wØC€ÞŸöYÔHÏ:²Šy¸|\QÉèa«~{ëâ×ïí}²;Å$½YàBHQü0$ÜäïñÏŠ6ÞŒb^Ï»°j¢P—«“(ž5làA±?¨„ve#œ,ãxàhBˆê)îÍö·fÛ©ä¡qzÂÍ*Þå‰R¸XñѼäA/–+¼Õ¥`ƒ§8Ã],«_ã²_.W‹®[‘$ V(þã"ÐoÊ-•êÕ/F¼¦*jªnèáÛ*§)³]¢±!ɦӽÐL]Ma!å™ÉdÏCÏÐËVŒ¼ë^ý¶o›|Ïw=âk«•¶ðþ‘¿þ×þÑWŸñ…h¹Ømf„¢{äŽD•l½Ëä[t©ópûî\hJ2zuὧ$ou¿aÆ tžSIrí]ÚŸNðõyfBÒ=ÒïM(Ëú7 ƒÌ ªŒ—«åÑÉñª[íï_ÜÙÚkh“¶•;ÐQEɯì‚UÍÚù(Ò³¸˜FfÉzÐ<֢阄Þùé/¾ш&² ’žC‘𘜠<<>9:þ !@çe“õ¬!BÙ&•¬Öà3O’hdcèÄïÝù¿íL¯¹ÇÛwâŸúÓ?tëÖéþÞÅåÉj2i3¸]P®YÖ»°’â·¨r…  6·îö>‰^YÌHoYƒÞ}{diÌ`¤Iizv·›çŸ¹úÜWW 29ï,O7#I~tz$ŒÁ,ÆØ­V]×M§“ÙÎlºÕu+ šå”…é!²l)3g~ Â]9.sP¤ÓŽ2ÏðåÚßaë‘8i à+šI& Ÿ{éåù2F bC9K¤‰@Áˆ>Kh À¹mcØõÇ+ŸÚØZg(û¹Kö¶{ú‡¶©Aæüf…9 ~Õ‡¥`2Ûeü¿üüoû¾ÖÍÛ¸ŠËUgfA–`•™¤²ˆ—‚à”Îç™Îæ‹’ò‘C³$¬MF²ÊHã¥M‘]!Xßõ¡ ão³1&íP‚Dô£{;mÚéd¶³ÚÖÍůœ,•Lhef¬lc¼Žiˆ¬¯G‡P”ªx{r8ÁB{@D xr|rtÿ¾¯b078 f`NùŒ<cH‚uïa*ÑH‚ºc²;m'SyÌ*`¤šòZpƒÇ£ŠônºÜ œ©LxaÁ*HÄÁe;ènƒe*ÙôŒž¥ÜAÑy7»´…æèøâÖ·/ÿöïûn†«²Òá*ÂÈY9ºùø=VÞϦÇY€ÞŸ¶¾ÉÏ|7þ8óêô2\‰T4ˆlÚeܾòä×Ïç>Xô¾mf†ükÊý<ÖQ?*@àášqߊ³‰†nÜl|_9_¡ÄÚ\˜6ÿ.Ázr‚a äÄ JiuL4ƒR‚7žºúÔþÖncÖ4†|‹ hJÙN2Ú½äIb5o”®WÒ•zN€ÅK€HÅÎ=Å)GGtõd –Ýüþá½;÷oÝ;¼3_œ‚²`!©”#åºÈÊSBy*>!/P ­®SεoY–»Nòd©Ît@Àà4‡9(˜íTkZÐ,wÄS%Þ yTŒ<´oüêáÙ-¼¾øå“ïû¾?sïw'WÇ]Û¶±Ëéð¢GÒhƒ²2’W«‡ãOœÎ—½Ó³ŸUú/?}¯à?£¾å:NÚÛÞF’-ªò˜¥›aóa|Rx>±xÛ#.ØÛí„ðzüá¹ÿÞ“ÆÑ߇‰s£#çvóAŸ¿»6 5‹|*c&ëIž…x™5ôË›ÿü¯üðçµ}'†¾Açn!A… uJXvPBJò/H†¶m¥˜}±Ù[¡é—kzPAÖý›ºÄ€>ö¡ 1çpV²e$R&8‚» 6åt¶›~ÒÅ£w_»urçÈOcã¡Qc€EøèYYÙIÐœ$Vs˜œü¬±Ð\óq È Ò!(½‚¤>%0ƒ!¢ßÞݾþÌS®]bCQÉŒåž01L…PÎ4ra?$/ņ!4áìÜ™ï-Wµ/­î!æ¯árú-[%’û²¸dŠº>¯ž‰Ä{+§òš<%P-¹7Â4LwNy2·Ÿœø¯ÿ¶Ï|ÕÉ2d¨·(ÛÑ$¯ïû÷Š }e©Ù?3í±à}n™‘¯)Æ_®é å*¦„"´Ðœv“+×¾…íÓ&XÉ,HÁ,§doݹ ÷@&sæ‹Ì+ZpîÍP1ïô®[öý‚éYàQ±| 0ž}Ê$×tÒîïìM›iŒ± Kò”::3‘-zS0:óf°Z'xJÁb°ämL…q%ÊÛ}Ù-—Ëe×w€h%Qú,ÞÔa6ÂM²òûsÅÜ5Q~]ÌÿEŸÙU^ËŒZJ%L‡ a{ûФÌzã¤èjŤäLÜ´´>†®á+ÿÊ/ÞùÎoß¿ö7?÷ÿâ?¸°{±ºIÓÄèf)×'Ç]e‚gå¾(G^쀫½}ûÐ9É €4`Ü‹Gêìz½VøÈd‰ç«-‹>Ñ)çßöÍ_»=i‚Ñ’_¿$öIl9•Ýµê»““’4kB˜¶“´Ü£P©ÊËn ëZ;2Þ*g>B‰âƒQkc'ÎÞªÞRhžž.¾ôÊë]˜Uᶄ¹Hõ0Á‰Àã“ã“cVqàƒöœÛôûæÜmQw Î|û•cmg)ûç<âÿ€öžurÓš½Þ/Ò=kÆ.ìN§‰“?ú[óö­/>h]O¡so‚%ïc—Sfɻ똟œ4‚'¬:ZÏŽ¦~“‰¼UœcqÛi¢Y6"+Ö@UH¥¼rQaÒN··ÚÉ„­¹¦_É°™LÃjÀo‘N ©†@‚äq.¿H×Ðõò>¹/J©Ähl pzÿèèþ!:5ÁåŠVŠ¿£™)ƒN~k'[³d5sÏY*V¸è3£©­eýÏyBÝà•¸$F¯†¶®ZÔ) –¾¶.L&vq†ÅÖá¥oúúßøÿû°ºpÑR0xžìõ½ÿ@f¹Ù•Çí+Ó{>ˆV„à‘ág0ÙšW>pJ…e7ÝÙþÈtúb£Î,´’¥ô^¬¶ UaþõøßF7ò¿jó,ndIFýчãE ,ÄP  ‚5IÎRŒ¬ØO˜ÿ pÒäêûih¯^¸|uÿòÄZÈ›¦‰9±Lvu˜í>1›6JÒ1 ̞ꔿ,g®–‡Ü½ƒ©µÕ|yrÿàî݃;'óã¨È@† ñ/y„Ò­«–3X¿Š!eXÅ¡©{ÅW[zNß\Öå/Ÿ¬qæ ßöŒû€œT3ÍIZÙºœb/"œÈRê½cÓÇîîÏúäöwþÌë'7ÿ»ÿþïüÀþÃKžVSlCÓw‘Ƙ¤&¿KíÛ6•J¢×6Ç'KW–þ³… ™ÛäªkÛûµzŸGŠtÎ+RÙÜÆú«vö·¶LžãK¼$ìKËï.¹„>v«årkºµ½µ½=M›‰<í±ð¾µ"Lmª¾£ ·†åMÝÌôÄÕK_Û/Ù¸™Á%$‘Å äÅ‚ì|@W†¯†Wc6ÊBÁÇб@Ev)Ö“‚a€À`Ö4ùÃR>+ãt&cµb¿5™^»|åêþ…­¦5 $‰%F³êÔ%ã*3 ¢ÌÔ’rG‡ŽG“âOºà H™)4ìc·\ÍïÝ?¼³Xœ ÁÌ,EH[Ë Xž›¯Ö'NëÆX\§ò¼ed4ëãé/ª×u°ªg`³u²Â|Ž0º"M H:¹ ‘“~ÚÝûØ…›ÿÆ÷|ã݃WÿðûÁŸüÔá•ýë>±iïÝŒRë’ä~LFUž¯"ÿD”ºžÇ§+0$Þ_±Y¨ÖµáVï?]. ®,ÁLòù×âÝr5iy,QÇKËßw+º¶§³ÖB ¡ØÜ AžiçXõÈWé‹(Åz† o .ú¡óÝd­“•('í®–n϶\±ŒX£27’ú7)Ň‘}ž+ÁsØ—ô«¯d+s¼¶×Ç€‹ú¢*|c‘ý, ëô},Òå÷¬Ó¤µ+êO$@ ~FÒ#|NýOŸþ‡û•7çí¤ ¹@ïi+7œòÆ£¤ÉtâÞ0³¨($F%ƒÕ\lÜ×ÈRñL†Up2£+“<šSs&Ü ™²ãRJªÍÐZzÎïܸ}pãÎé½S,ÍúÔ@©¸ÀTˆ/š'Rh÷=¸½S ÄzJ 2)¹äôåOÿè Ï=u= Æ~ÕrR9àryŒNÐŒÑKåµâh1Ðá–Ë¥`¾ÌöÏáKpq•¤sµ1Iç´á ­}¢:T=[éxóîÁkw¼Äp(QÀ¨Lùtyx|||ršQÛgŸðÞµ÷Š¼Å$=ò5ïE{{›yãŒ?¼wï¦ÿe·Ÿ}üˆ– P­ÿˆQÖâÒñáŸý¿ãÒ›o^•#ÂœdÏb_¨RqŒÅéiÊÄo€{"ÐÔæDÕ}–BP¡ 8О³ß3{KYêk$±Æ[;™h8™{è6“v²=i›ÖšäAU‡ç®ÃíÎPøõå/þ·B±=Åg¥4š6ˆ˜ß¿u/ÀšÔ%Ó’AÙéà`“Ù´iÚäj%ÍÝÏ0› åJL¿Æ!”>®¡‹9ì#¡Dm=lë€u\Þ]I(ç…–H¸¹EY? 1ÞÐ Ïü¿üŸüéO¿~¤ýT¬ÇÈðÆ‹¼‘~7mãïþ†ÿŒµÇ ÷©Ë[R+’££PñßEO” fš,—“kO~²×¶[›è¡=Ÿs¨uÔŸ»}㔿ÅXPž‚Ü-‘ÅØž±£)‡ÏY@Ð`o@Á`! RÈ€N½‹+noM¯]¾rùÂÅ6³ –%Ú‹´Ì©<•BP-eMl¦I*’\È1¸H5$Æ..N‡GwnÜ[õsX#Í]½õ;ÿÝ_üå×~ä¿üoÿ§Ð>¢œÉ1ëš”¼”¼©Ì÷LçËÛÄéäé¢ë#<Ò¬æàœ®2¦a¸çhqnoSOóp°†g»{Í{þÙçà=ÜSJ¹úUì–]×u}ß+*À(Ès;”êD‹©ìWºq9©ß9âsqÕÓÿ€AžOÏùœE[K †v¶f,jXšeC•Ï¿ùÃ;ñ·ÍƒôN¯yw]àyoùð\±ñ³÷°wÚb6Ã’QÇê%rÀ¨¾‹óéüsÖŸyáÄ&dCJ¼°¬vf "Œ Ð¶-„êœûfôT®—¹ž`u·®_6v÷&ó8ÆÔdõÇ-©d¿'RiF(׌D b¿Xß¹ïæ­û7ï,N}Õ›B`&:k¬÷+¨'®÷ CŸXzR\ Á’oMŠú .!Î.ì>ýñw._Xľƒ7³D‘‘ÒÿÈúËô 㓆fkT?|õ5aƒ¬lHÿ\û;€±6¾Zg÷ªË•hK2²åœ4zm5O_¿ñÛ~Á·~ãVÜÒ2åF³bEñ¨ožžUœ=Sï é¡o·Ç€÷¥mÌd5l业á²b O”+Itj—ýlïâ'fÛGœN\½ÑjbÞ|,Y^—[Vu¢dâuåœÓèõøêÍ06”ÈÅÄïV'ŠÜI—`Æí­­­ÙvÛ¦BÅŠÙB“ÅÙ\Sù/“tKcÎ;¿ÖŸ‘ ¹G—÷±wïû¾‹Srž,Š3‡+m@`¥Û4OëóSã"9¶ù¬›VF«ºï¦L7Æ?© Lí¼Ž…d¯Ý„ `.›ÎvÍ&‚%€l‰…£þ -´üü¿ö/Ó­/ÿõ¿þ7ÿÚΕõ§§MK‹£{ÌzfR åÈ`Ö¥6áóeúl1Š 7nÝ“íÆŒ]M²G1øicð ý÷àö6ÉÏpÒª“»D*FY /¾ýçü¬ ­m¢wòä*ƿܽÑâ™óSJ\  l“ƒˆPj$Ÿ×¥s><¸¾š{vZó_š€.âÓ/¿ÒEk`“Œê³®m<<:>>=I¥->´AÀïu[›­ÑŒô¹ŸL|rÜ‘3\Yþǵ\7ÞýîÞBû«Óë—ýòý#Û»s«Qt9‰!×gÚ¼ži>Ÿ—3R¼¸›=«Ÿœ;u¡k¦á³RáseµÆBM᪩ÌVòdÒDEw§[ílÒN'“É$WÐ^£ý@ñË:²úSž7&óÙzÂÌu CLðyä¤jî±±)ÜîÜŸ[B yJ$Àж“i+‘–HzŽ.X—ÓFÅs¦²ÐÝÍp†qX–"ŽKë7;K J%²Æ Õ”sP"¼ÅqXaëøàÚµßú_ýÀ«Ó+#Ä„h¨Îõ>Ú»Çíµµ-!è+EŒOx#òxy•°5†Z“„;Rö2x¶ï’;e4k›Ét6N2d£¿€¢°<8 ¾Pþ`Ò!(‡'ç(•²øƒEE¤õ§Ýéý£n¹4O…~9Íš&$Æ•Œíªƒ%Ç;±ê(çìL¢.ÎhÃdrýGÄ€L0(9Uê¯òÄHƒ(l©©ÀI¿¯Ë³¿|wùûÿö?ºa;f!ÍÝÀø6U”µ%TÌÇ À{ß ù ;ñÏC;G×¾‹‰Ià-ÀëˆÄÃÅí'vz™N5–Òj¥c(IÁ$êf$|JÃ’%µAòÍo×ØYé É•Æž¡ãÎgZRˆ¤$RèCç¦À°³½Ý6-ªKXŸì±Tɧ0ê\2K"¡ò“:”¾2‰–•ÈaT.QÑä„çÒ^H`úëe¬ ÝêS¯P&°nÁ\?ÃXEI˜u‰GøÅAº`™þ¢r¢‰ó$D%†êͪ47ó6 ÉÝàmß Sõ˜l¶Ï9,Ì‚ÇØ]y~Ö|îoý½¿{aïR\Î'-Méž³ ,UäêcŠ  :²ÌO*þT`ãjŀ䂔Åú«³íQhúY‘ù­Zånã8šÌí HîMÀ4Ø‹Ï>ß/OBhúèM‚õ o̬ì%ä-xJU•bÍkðue¨¢dp&Jzç<ñÙ×zðW|‹á…Öò “¸å.3 0rwkvrºÈ?D…á.u')é'ýÝ·Nv>;™çNïXÜ·‡|ˆrXãö¶Ž K¸Ù9vDç‘QèÓvöýéÿ÷_÷ñ©¯BÓN¬@Í{r¥[&‚QêAHq,wŽ­÷®*ZnËѨF?PKÌÛ@Ž“r+WÍ -+É;de$C’B¢9ë¨' ST-WËÕ|~$$ð©…@££…äÍF…ÜptVÓGUÂÎ2]' ’–Gò…¡µ —÷óÓÅÑ¢[­ÌEõÕêŸÂŠè=hʼn½±9KHEšÖÍ~>0¡¤Ä¤}Qfxíz–xŠt÷L“ŽXÔúlB1Ò‚MOÃÎáƒïxâ‰üìÕ?÷úÉqd0ZI¾Ù½[àð_œ¹îq{§í •x¬|EÚ‚Ìr„5@¤†]žŒª$¤@ë KýÜÚ7âgvËFŠ©¨bG”Åþêɘ™£(ßkܯ3Gª$:VŽ£cÊù§v à$À`L¨dFb'ä÷£çÁÊ ˜%ßszª#©™^;+ ç{$–ÄסTé—•8ƒæØK\Ì …²­G¸<½²ßÁÓó4²ÊK=ˆsî9hùäVQ9™–Ëý‡àüƒò§AX°&XC™™Iji,°Wº4 ó®_ßþÑ/ýÝÉŶ_.'1ñ:jz™°ª™¥¨t?‹‡iz‹ÿÆ-‹©Ê¦¯múüTçø™³°ñb¼G3ô–íŒ <\{ª `¦nñuŸü:ïW!0ö} °UD~äÒ¦^:MX*£&¹Á<Ÿ Š!'$T”(;GRu´îå5ÙQ›æìão-Š×iRÝx så âÞöìÖEŒp™™»Jæó$–°vOçÜû½lﻘÌõM5n–ëlèÌ.ÝDÎÝÃï°½[âüõ™õý¦rB°WSÄ“ WdÐ…>^YÛ×~Ëòä扯€˜iEÚG…¨e ·È– ž^žV ©g¶þ¨kñ«çR‹’¡'Ÿ—ìÄËŸ R!ö“gfFG¦ÒÝ£‡¦p3%HSèÒÕ£[Šš­Íà:¤eÄèU<Û‚A)qŸ'U€*æ(š™…vÊ®[.Ë5š¢|Ç<‡•+£ªò÷Mœˆ÷VC׆ùÏVfJÀu(+3^½üˆ¬¨¨8'’7T‚Ü"›Øpù¥ÏüÖoùºòæßú¶ ËÚ1?S㇕ÁŽžµqú·÷¬=V¾"mƒ›–½=À~5lò¢x+JcðM1yfûÉïxñ›»7n\hw¹ûà8­(‘Ê­KðψþŽ[•Øó)Ç9#›+*L#9UäÌ,u‰ø»hP/rY©ZnF¥Re>rmÐ"+S”¨vò)¸gxFå/iÖJ=˜µgÆG¥{d,û@ö¼|3Èê•1HÏX³(,PYSÉd²D{±Šèuîê\û(ùc%›u‹”K‡Î(¹¸.ÀŽ)÷”n§“;z‘@T6gC€‚ ÞÖ¼¼{馎Ýbß[kL9îƒ5EªÏ})uê””®UZ\ÀQæ‹ØEB¡ µ9u1¿U}]MHg¨ýzË«£r0vñÀ¼ˆ*]œQÒÑð?òä“û[ÅNQf€{ 7ÏÀ©2¶'WA1€!ƒê×À™ãà@ E ‡µJ,q]²©ŒxMq©‡íÜè€ó‡¾6\åA‚CØš¶Á\hb. L’ŽHKFE«ÌõÌœ½Çí¬ú•oôð³Bÿ¹ksÖß]ÓèÅÃÅœóöž7¢BªF–´Ý=YÈ%iŒåÑv#>ÎÅïüUßñôñ}‹‹&г+Ì”sº”h¡áôBÌ &‡†”É_d\݈('ö2ôp41ù.6:šõU®ÈÂÚä…ìæ 1ªIO@>¥dÀ(„P«=Ê•H¡^K%½: 1öÙ®äkãê­ÊJV“Ú@åE0¢w!˜õ®¤(¤L‘²×.YøK®ýlìË< `ãI˜ß¶\,8qÖÝ’] ÉÎã•I£Û˜N Œ*uÂå¤EsalÜ‚9ogâüË_üßñ¿ë¯þè›Ó«Q @Ÿ‰B¡Ûk;YU›ÀZã¨/Û{ÐÇ|EÚCHäZ« ÊÑ¥Óh=¢¤)±s~Ã/þ—¦÷»í.º,ä¨ÂºëÑc³B0¤Hä5Ù²ÏíìèF˜pf ädgÃÕk™]®E^J‚YÆZªb,Qì ëïØîS†\ÜÉØYAO…ŸmòÒÁåG»¶åY¥Þ‘Ø=¢å?Xëw„Ðu©¬*ƒ–1úáਭ~êüÔR 6Ók9K¦çÂ)2`5s‡õ•«y„$Ñ paÇó½å?¾óSwüØ¡>v›&xï4ó\d‚T œk#,a´q\jnÜ»¸Ã ÙÚœä7z¿¾é‘°Œô@éG•Ï¯-On!¥ åÔôó¾ñëçy¸Q¡1izG¯äQŸ?ð¾Ä¦\Ñí81+"C 6¡Õå^£0š€õI{g­¬WÖB3T‹ŒÔK¯¼ypÒ#4Y°"@—zCãn4»tp:?;û‘åô=oïy7ÒùCvåWž½õÆÎß¼àQ;²y†’ÞÂ4)Uÿƒ¯:õ½5á¬}±;ú·~öOûº­f¶\MÑcŠLÍwÒF˜l¹_ÖŒc¡8~XI2…aL?7OLvC²J‹ëÔ»ÊÙE"GÒê+KÊœLñ Å1œTmL5!™…ì NÒb~ˆ• »V±Fãé.€Êå  ÜÁ‘³•?ä‘iƒßåîäÉÖ°‚•a=`GŒ§9Qñ”1žñUŽùÔÚ]Ö^Ôù©(ÊFŽuH¶)š3†vc··ýWï.þø§_;˜î¦$Mi=«ÎvÎ…ã±èÿ^´µ“*¼¥à±ôÿm,íç6"NÄyÒ?Æü¿Ð«d„pÁBÀñê—|ówNŽúÝfª®³ÐÊUˆQA;¦q<'23pFVŽwB¥1ë-ÄâqT‘CE«#’k¤!™¯ º>é ég5X Ü¶˜K4LýÑ÷ÜœÑÑeÔ¨²03¸4õµTGª½c‚6NBþ,óÔKXO•ïmvu)6»ˆ:EÏRqpäžÖÔÓ¥ÛÃ_%§ ²}ÆŘ3ŒCHü’ÖW2H½‘[¶£cûÆ+_÷“w>ssy׌¢õ1š…(Y0ÉÍ,ö’I,i¬~d;Y/·“Ó¥{ã©™ ·.jž ë­Æ­ ›Þ[µ{Ë 3ã`…,p~®iŒqõµ?í“ÿöþ=غ%¹ Ä~™µö>ç|ûè{oß~«õjIÝ’h µÞ‚Ñk !ÀB66xÆcl Æ1¶Ã1ö„=¶#ö?þˎИ0Ä c"xø#0 ˜A #„Dwß÷÷:½Weú¬ÌÊZkóÝÛ}#õ©îû½×®U••••ù«¬¬*/ CEAÊ…jm9¬!°Oc­%°v,ÒÕt|r“+†B}¦–ÖΠC™p°ÞÇÞ;׶‰£Ž1R ܽ{çÁù[€Ú…ÙäAmnñí‚k%~{ ÿ<Ò¯!‚>_>öB>‡Ÿ>ß´.:ž,§2+l<àç\BwÌÅšˆGp†ÓV¡(,³Ì2Üîù»»ýËÇÇßóÅúò]9½ - ”"Qïo{ ›q†‚#mík_¹­qÛX6»£íÖ¼6?ID»Õhª¶¤LdgqÚâ6`w‘Ÿª Ubö¥ ï4Ÿu´V´Ud¢R»\Z»}ðw ÙàA[l …häQÄ9‚pŸŽƒhr+æíîjˆVÚœæcæm¢QW‹es<ô!h‹ÊRˆ´Öýî„]|ÏÞ÷^yã'Þ¸|2‚ÒÕ&dä@ãý¿Ki¥k¦Å¯·l~‡)x¦[O»YœëµÈÚõã/}ÉGŸý?¼²Vç9‚Ôª/½©«Šàoµö¡ßPID¤ø›‘nšËõЀW“®ê‹°Ý0­òç¼’? õ2ò²ñ&¶ &gp6Gîu³ß”!@’ ß³jÎúnÝp3+êн½`W¾mþ“é鲘 ÔÅtÄ­fðµÅv÷™Ñ,Ê»©œ]à/|ñ½«“Ïž¿öðòâXû ÌU„™¥ —"bS)òJ,f‹|†iî¯2W<:Ÿ§0Úðm²gñf|{G,à†hù3­>\“ªÃ‚ˆ´ŠíLX• Z¦ù…çî>çLç ø¹ª šÌ·×¸…ÁŒ.Ô/öjúþjKï1Ä Dm*R!LÅ#÷K•¦‰W³òxçØuDÚyMHqïìáͧZ7ýÿCBd¿.ÓSö­ÓšóÛ}ú¡£LlgÜxnë²€ûoÌͦS õp|á™;ÏßïnÚažßsuñå‡Gßò/:=¿dóx3òAÌÍÍÏT¥r‹eq°hãžÆª›´[Æ후ÐÁªmMN1Üf)µ‡Hcú´“þC[±Ôo;´ÈFŸ‡5-Ö`[©âÅihšp‡¼mQ:Úcð|SZpM›r5:%]Ë¥Pw›)‡oG‡þî,J[Ïrp&êÍéæ JXtŽ“ €µïÏd¼ÕÝyMR¨6ð‘M6ˆê,… r¼3ñ“×ÿù¿ö5_öÊ_þ™¿Ý…ròð$u¹I["LÃ:Þ¦Ï/­ÔÊí€Ï9%(œpÞ‘“¥»ng6‚AjN€çŽÓ÷~í·×WŸœÔcEUnA”6´ÒÌžGHÁáŒk$'(VP—bM`Ø–Šp EBoí e¡uH¥EKR†ùºEÉÀ¼›¿Ó£Ýäy´ÓÛA´1$Fš(jY:Úº§¨=Ц$tîNêAk/ o×uô²·¾˜ã]ÞÔ® Y¨i7¤2:›ŽåýúüÙ ?ºsõæÅã‡ççG‘©ì@¤¤³3@b…±Bȃ»˜ìlV(ñ[Ï•w†Œl²™Ø4;ÀÐvl5MK¡wúª{hø9æKšœ[°‹ÒT÷;Ð|øš/þêzy¾?)s­Ü††E$jis²s‡¥²DJÚFgíh÷.7—]¡bFìÌ.J¯h±»×>Wô½4Œ}ô«§'ûRxö»H(‘U]ª×Êܯôkˆûß…¹EB샿 ƒÞUþ¥âë¿f­²¨£W°BL:Ȇÿ&©@„Iîß¹óÂ{_ÞA Z//ÏDž{óõøäWÝ¿œO¢PRbf»À.ÏPRˆbÕÍˆè° k žÄ÷Ø7!HF37Qbl$–­š'M|ÇWDÆ´K GJZ—HGdhÔ%Ùä…Ñ1Pž ¹¶åhß Ò!uÚ«c§¨yûÚìÅû΃–’‚!»§«Dr®¹,8PwÑô¶g¦â{´ÕÊl(F ‹X£PÄ]l¼%ÚNãh ”^†3)m ðIWt«OÔJ’ âR9*¦©Ü}ðê}ó×ý;?õ³¯Þ{¡Îsi®–¶ÜÚ«¢4¿hEßÎÞý4Ln¹ûN’.>dk¾ ©3h±¬€ªíE„ìPvêïùÎן›Øæi- ÙI•æML]ëô0l÷7Cëq_èùgî>wzw•z°ówL÷¾ùý_öÁÞÝáâ’ hÕ‰§*4j鈲ì+Ü}¸ŸIÕ<ßNu– 4gnd»ÐvݤÕ…õµ;ÔÝ›nu1BÎ e¤‰A26c7Å¡1hÓæ@ÿ®ü+%]ܦY½¾A­7£haHž«-áQp1S_åI†*B„ˆí̽,}º²¬P›þ>ü,¾0›þ±8 pYH[ýpÖuV)zȨE±hµ*©|*óçóÿÆW~Ñÿ£_}´?#š,`TUN‘ &+ÔÅd…nÓçŸnW>·´@´š¿¤Ÿ°œé)9©PRÒ:]â_ùšo}FONr%»©¨A´ÍŽŸQRyiÒ‥m|Ð548Z­æD¹&†fÕX…éÖªvFÀÚåèttŽ›·xɬõj®çFrSE®ú¢°´š±Dÿ17ðÅÙòšöiܬzÙzdÙý1/òrû³åä£AYüŒ…Oî–Ô9Áß“¦‰’X_­U©Ð$»Ï^¾¼< =¾šï9;{þôîÅ\]^<RìHÛ™øUA¶‡\A¶Ózžåüñ0Ùï%f»Š§¼‰Ô¸Ö¶@íHÒdÇÝDæ4 ¬´C.Bl[ÔWC×JD¬¨*€Ö÷?ÿܳgw˜f»¶Ëç¥1ô|F‹ÎkP¦ºô/»ªùe…'°ˆ€k-TJ”“÷Ž÷âá&|Zr`™z„RXŽ;wž\<€Ýsœ\•Öí!éªùïj¢¿¾óÂ2‰ï.­=±©׈]Œ®¡$¢˜“ÂU芄ÅáÝÔUäòn¡+l".³êñ´L/¾ç¹û§§\ç‰+U™˜T¤PÙ]œí ÷?ù¡—ôуýn7Ïs™˜K™ç¹”"¾í¸·{ƒš´]»Ásî´¾¦Ý><òPÌ~¬C’Vi6K‡ÑW—¢«ºè3“öžâÞõ—ˆäÕa}`݈nÚ©Á)ò7”³$CD Á‡óçÜËñ’=?Ñ0àV#þ]éêD7{¡©=ÆØÌjz³‹ºvVkúQc^è.?Ÿ'¨ù0UUë¼çý|yõÝ~ñï½ò«í‰\H%2OÐj7°+֥ƼEÿï^º¼Ó"¸…–Ù(çRí›ígø*ž¨è]™¾è쥿ÿ#»'ž 1묥h¢ê ’x¼ü¼c¨‘ê{3¨^¢ê_-†|®„r>W±Ëª—¢ƒ·Ä/NÎŽ‡ÿ l»Ì¶L ÿn»ªR­þÁjmÚ¶shè3êÙ:›úQŽÍ*Kã²ìoM/ß½èe~‡ÿ ùêê-t}Cª`Î-CDáDåaX‰TµðŒZ˜ñÞ³—®Î/§“;¹"’ÝD÷ÏÎ^>½÷äpxpùð¼*‹2„l2`>1&Åù“ó*q¸S£déhúhá›5Hí37Q·mÖ±ŸBšÝ¢žðnÒ°­Ç`U@T°'0ê—~äÃŒÚöóq 4¥NdÄ,…Ä‘Eß_¿<&ƒÙ­•Ú e'Äv:´CH¤ŸËZId˲`šªßç«í±é*”Dˆ‰¡W_ò¡÷M; §]ÝzÞŒnv”·c@åiFêëê‹7JçNC_[óÅ)C€lG‹·Ë’=ëW>$‘|{Š7ƒ©ÎÄÀ=vZÑÙ龄¨ª`&;úUDìfSr.\x·U Ò…'w5X|ÀÛ@Çï­Ôz‹†Xã‚7cÝ Ä·çÚæçÓ‚žJˆX¡`0Q•CayîÞï\c‰?óÓ¾¸/¿78Ó¶ ºÊœm–zä-ó;õK#¥cŒÀÐh_ÕY%jÌ¡QØNˆ¶“šT„ÚWzùñÃ?øÕ_üü;¿8ßîXubSP¤ÑÖ˜iÙ¡¢>@Á·àôóM·{Þ~Ê#ia'¡tM‘Ç*¢a (›M…éÑÅ~û÷ÑÅa¢ruYc? (ÛឪÝ~º²•¯È¾…q,âFd“ò5|,A¼á9ÄÜ€m‡ê%¥bÚë‹^0÷f'®läÞbü:[ÜPiƒ±X釱ÊdIeäC¼¤NÖ†¿Ý|-Gßÿ»ì‘þ4VG¢æDn¼”=îèöv iõp1RUU&Å\À…¦ãA´G½Ç÷ž/Ͻ&oINª"$´sa½{vö:UÎWŸœ_‰žŽWÑÕ¼› ié³;×Çš¤›Wû׬MÑÂËîh,ôçæôòEæÌÛ{áQ?í;Ûn[3Š1žÝ¾ÿ=/C®” *…Ú›m×™[8íö¾•žO}!ÊI ðÞIË ¥ï\‹üm±DlaM‰l3%L± ùãÚøQ5¸ ”YÏNOžW”ÒÖï Pe*2Ô]ˆ œöù&Jâ°\Ý÷O‹¯ë¾ùëæ“Ï=e¤ÚF³3@˜ý!ùB‡1Ð>(mºfÄUÞ1O§nHMã¦à€HIRÑ™©N,ï¿wÿ¹;wv èÌ"V!õ£oU LÄ8;㻿äý(ÊU‰¥®Ç™¹(TÄübsÖø 4\FIYúI:–¯Í6œÊ—¢éªŸÚ>$Ñ q9Ôoú¢¯z¹<ËO*éT03RSéˆ+Ný_ í4³‚Y°ÈÓ›ÒuIR». ®çÆ÷ÕÏIïO -ÕoEK-¹âµS2xc¡}¿ u±.ÞÞ³ ¡C”b´—>“¬RÓ±m‰y‰O µ®ÁHÚ´}«ä60š³ÐäCÏv÷àž–Ôü¶®Âv¢ ‘p)$J¤\/çN^¬WòT‰*a±/û*u)ñÙÉÝ÷œÜ«D¢¤/kÕ¢*)ÓÄ&쪾‹‚|ÿ‡MM´áo¶íSKæ·{.µ€ƒö#D%.À•x«eàÓ.Duž«’â/{ÿö-ø)œW×;n›yI&Ìèe”8~cmQ×]§1 $q¥ÞÐö³}Ì;Þ’·†@‰À5!£luÁT""Öû÷ï>¼xÐÆÜ AhýD)ŠÀž¿-q}›)ô”Qž¬úS*x Ëß4r6zwÅœÉO¥tüŸ€žèª ª3¡¼p6.²fÒº6£ä¬õx˶°\ÓŽïœÜ¹wrvÿôDç+BesĪ´KÙ‰HmýNEë>~ÿ /¿—ß|0T¨NÓÎÖiÍWÅÅÏlã‰U˜&sþ¤5™-{WX¹›ÝBéº"ìSž5öÞJ+Æ-«àò–ìØ85o:bvnàð9¡T-ÚöLõ|£ìt‚sû–ôûyüYùO~ÒhbN”’âÈ{6<KA2°] Ūø¾5e*¢¢R«ê´;¡Ç~ïW}ÑÏ=þ{ÿùÕñ€R<±ïeêã0ÑšÚp›ÞYZ)ÔÛ=o3m(‡1¥µt!Ëüw±]wD:+€ß‹;ßö埼úìãgNïˆ( eâZAÊŽ´]hbƒ”FK¾»[šªà> :j§´©o¬MÆÚ¾lÁ‚køÒO=tF.Á* ãåõnƒ-ê>…¤ÒÚ0`Û@ä/i(›xl*˜½ ·HC]×C“ÁÂù'Þ`hÎOñ71;ìAu@p€A]‘Å +DZD $L¤$‡ù¥Ó—ë“caApƒ ‰KaT´«„¡;n[UYÃA çxÈ7KB~¦á*äÎ=sâw³ÕÐnmÎ{ŽƒÛKà8–ˆ DDÊWóñQ+)H aâ*¾á5GL¹ )åV©ãn¥ õšl±•Ÿ°ö®’/P-(öºdñH1ëHåعµà]+Š¤ ÅÝ;w€·üŠàm¨ÓÓ0nÞ´’à …žúÞ»JÊ:é@_Õhê‹T³Ïp{ÏØKœõ†ëæPÒ!4ö„ý&b&2˜ì3Q|°ÌMµ‘¦œàÿ´—ó01YØŠ.&&[ 3W™•Š5^ Šù óû.ÿз}ãñ3¯>sz"óL ÀÖìÓq9`s‰vÞÎzé‚úÀuŒ0>Žœ¿©'|}*)—ü+œ™®€ú ™N]º(‡ºé»Hƒ}ù%Q$»$0a ò‡Ûôv}à‹¾"Æâ5Cè6YzªU Ã0Dºç—#RUTÏ =sYþÐoû½õ3ž»{ÿxyt¡Ä¬P¸ 4`°e‡:hPe¹Rä°‡kÇ 0 µœ£…G\¢‘ýæ¤K†ØCõ—Ò\­óh—Î.»&}[6v•ñz@ÔUµ×OCqͦ…i‘*¡þ›„hxõ©ÊŒÆÏcþSP nˆ”„DÊ|Éç¯]}vž.çéÀhW@ÍWO-^ÁcòM¦øÇ°™=p‘‹W£ÔÑz£»-W$¨á pëØ[º*Û›n#H0 <]Õ ¢R[22‚é ÜVÇT€­Ï VõmGÿ€ÔÝwþ°`‘’«MyH¡º û¸þ ¢ašuúù_øÅZw€¢4拈ßzøÖ“ósf›Eú±íÛ*äsHÔ1ÎmS&Na3O‹V`ÉálÚ={ç“0ƒda;@G™ñ¿>è`ÓÄZc$´jP3M¦\`›^vÔz™T~©*-Í3U(êÝ©Þyðæ¿ñ©o|ñÑë÷w»Ãኈ°"]ª´y‚Õk»uÄì+"§«¹¶{@h~½+Ö Ü߸^c>Õ’å<×æÜ*ùL±²› Á‰‡ÍL¯j¼i$§’;'ú¤'´Á¸?m¨|QrPèÿ5r’{}›7I‰]OzdV¬Ž$êu¹¥Ôfƒ<ñhÞáçfþ_ýô?ypïH¨¶;X8O²R3òßÕ·é†4ô¤â©+o¯ço²šY`b{ª‘ÉÖ„Uuš¸<¸üÁoù]òÆÕý»wŽ—GÓïD¬¤" €‰µÅ8hî=œ«çg9SÐüÔËq@ï ÀÕA hè-©©©MÄÙuV ²• Y#×ÅXí–°ûzÈõ_,y¶ŒíœËI»Ç7• à̶ w•Ù«Ô*tFàí²õ[eлvá>os°(Q‡†D]Z V¨}#@™”Hè´Üy–ž{c~) •Dm£*1Ò­/QøÂÛŽ×Ä_§¡“-‰ËÔOƒžL@>¼:™/PC`Mí+åß[´Ò LûˆòöÛ±ßJª¹Ê£Ë  LešÊŽ ˆ”´êÔŒRï5nÛˆ@}… µ0ÓrM2†¹ú¡~„¡j¥¾gƒ~\»Â-¨‡»ð#Ks:Lk9Êóg‡^¨Ðééþü‰Œr‘J&JI¶ß%cº…Grú—g^2pîJÆh“s­Ç—ž½÷âÝgJ•Rìy¶q²€™ÁyøsûÛ‚à£fÎ}—ab” Y²’ºFÚ“Ii‡ÏÚ2”‰i†pkA¡<ï!gßøáO|Ås—Oîìx>K»âJçYlf0( O.Éz>[½Ø|ý¼Ķ«lô4éð'¤»½u4…úOò¶TºàP&pxˆ)–Ë  »,Ü®=”ŠJ:o›®ä=Yž¡ê““d!~¸†?}×pßO¡®¯S8’Ù]“–®†î ±“l%¹Í) •“ÓÇ~Ë3Ïþ®—Ÿÿ¾~x¸g ebi§oÓª¢DÚ²áï’æúšV=yô6Óu£w9V¼2>ZF;‚£jUÒr.ßýÕßú¾wÊÄ3¡0+REH[`§Š ª>°@?Fãù@×Æça€Gõ`j´=#2nU‹BzÀ_Œ;[)÷m –hW²_74³rNwa :Â3½˜hàu¯µSS˜þ{"ÏÚãZz»6ÌÆ6ýNbj´—Û4ØǛʹæ'íXEë‡H°„Lg¶ÓúA v’¶!MµY‘LWÇûgÏ_ç‡õ-žf˜ B~OÝ Ü¬u5B‹$n³Ó6ØkËX¾V®ÐªðMäÉzÙGßE…¡ í†×ZHð BÄT1«^Í‚i_¡Uæ«cf½³?±å(Ô½L V&58ÑÖh¦ cÁël“swjwÝ‘³Ž{„ljJó{Y×¥ãœRoâNæ ÇkµõõÏ Õûwïž?z T’U¶Q¶Ët=h¹>݈u†lÿrR+cDf¦]c«P&yöôì¥;ÏMrœ d®“Šù qM<ÓÂh`Ú´i1Õóçö.#.ymeuò2@PW½6¦ò RS‹iªš°‘RQ0·HµôäòâS/¿ï+ïß)‚aQ‚UfŽ]¼+ÙŽZ›è*Ôž>{‹üÃõ°~ÈØ2§‡Á©%MÁËlvW…- i-Ð t¿ ¸/â!Î3ó«ë.”3¡ Su¬td8íŽämÌ‘ÖQü馱‰Ðñó*ÿÊ‚ ¦~•uƒ*'_»|´‹œ[w‡¯†ˆ'AÝïî_<~ôû¿îKî/ýÌßãgÏ«îÈe#ES,(õïõ4ݦ§¥Û ÀSSŒ’M%Õ‘sŒÞ¨˜¦¦ID˜XIg•SL_|úò'ÞÿåxpARfµ 2»¤™Í[ƒ~Òˆ";ȶ²ë€qÈ·vÑ“¶SþôKwrbšWL¯i fÂ;6rl Ž,ó…øÉÑó ¢éú±Rêºm¥å–7V&1ª›¿øºÐ:ǗеŠr€²c/%Uœy¼N4¼¦Ü/V4ÇwÃ;  ˆTdWJÏžÞ¿¼zT¥³”ŽU¦6%RVò•\ŸŒdú3_Ô`ˆv;Ø£#¼]”Ø•>võ>XÚ £zÙP§­^_í\–q6adt‹Ÿz"Ÿ·®´æÒ›õ[+$‹q_?ÏågÝÑ©ê©`Eš·(~¡*ÊPA}Là““òðW~ì[?þïþå¿s<{Qj»¹BÚÈr.¦¦¬-ïʈßÎnNèíàæ”…éfKÖ!Ozè#Ó´¾*“h¹»?ݽyüßÿÝóëO2¨p‘*JÊv{9Ї°¢v!+ZF ßia’mÙ:ôž:B ´jP¹zrþý|é¿ú•Ïü㫋݉o×g2iؾ=U•eæ©ÙßÕ÷ë+)ž:øµPÄ¿®RÆ–ï”&­Pˆ* 1Tg"Æùå7ù7¾8=3 ± &šUþµÉ8ü„ôÐoaí—Z#°€ÏÓ“2âõº©c–þ"b§]ͧM6˜;h“3àÖV‘gVAø_Ôö ô‹ÓßÔNME.¿cã`BªH#f$”mî’D"\ÍÅŒÅ×æíû¸Šï™2Ò¢V¦p083!–ù\ï¯$êÌ7’ÜÆ$ï{—ÃpýˆßUëo5K”îÎu“Ch]TT¨Ð\îó Wõêñü–ž Êq*;ˆ0J“<6eLj„Ukº(µš6o«AbÇ—jìôndÇ5qÖ„rÿ¦?ƒµé® Ðm|e!½¬‡ ‘Z01ë,ôÌÉ3óåýú/MáÌQFg[ƒîl~wŒè?è^¡†hMÎm—¶%€€büÃúÀäçQ‚X²¨&CÛi RˆÚ4Bm½Dpÿî½×]4° X´ƒ ¼l€¬ñfà×¢Næ>c¼Ä£¶ÛªÎxþ¥{û©W°ð1•‰XUPçÅyèp¤ÅQ…à,„ „úöÚ6*†¤â¯Oƒ­RÀÙ¦[ô?“ž\=úä Ï|Õ³÷¦‡oMÄUY´º‡UʲˆµP ¤w}Ö¸Èæ8ç…ißԵŠäåݦˆÕ!u÷òÐXwbQúáiný{¿t6ÆD2ÙJ.TR£I‡ŽÑü;µQh| O“ÚEQ^hùœÙ4T²(>cÉ/ù¬þNC‡ö¯¯½Ó"£/0·òó bZp¤Ë؈'bëQ+6\ƒ½,ƒMÀ˜ T'e©zº{æâ3¯ÿØw|êþÌ_ý- VŽšÍíÒùÞÙ~Sú®¼~]¥Û€›SHÚÛ£AM(ÁN~ õmW*Bt¢xoyæ7ôãó›çg»I+T”‰5¼³¨4bú­éÏF›ÆóNnÄF‰æAš~-Š«€þ$ý»eŽ59ez.Ê–/ J¢n3S• ˆHú¾$Ã>&õEp¸åóf_u¦a`f¢Iæ­Ò¨x†#·¤Ôw‚¦‹¥,×ÏÇöººÏÑNöyOj>`ÇßòÒ 7úŠ„=7ÿ%ÔÖ÷Û„Ç´ÿ$xþγ‡Ã£«ª\ÊÕájÇEf‹ó¡ÿ317äJ~ÏqswüÞ 8ÍïãÔgC:ÜJ ˆ¡Ùv®¶ùŒQ&L¦'ç‡B(D¼ßM§e‡*'»Ý,Ua†åÃdõÙyçSt2ò(‘At´ _ZdY™Èx=ÛÂx´‰¿ô (l_33T$.­†@c±Žc¦O!‚hĸ°Ý;=ës|6ûÉ¢›¾?5½;æö×Ìhû¶ügš*R™õîþäÅçž“ÃùÄ,2Û š€‰¹yïp1´s]ÉMêÁ´Âš¾r¹”OƒþÈêsÌC‹/)¤K-\§bBÃBZ¡wôøáùø=û¼ñÆ´#­ZDÛ å@²IO¶« LO¨ãQkb?¿>G}ø#€ý¶%Ó®»€æ¤ ­ÚþøÈáÓrP½cIíÑ¿¹Û%Ù…ÆîÑJ>‘¦ÍŽ£qγPÚs¦oŠþFÏï˽; ·D&M=fÓL›¬Ü¢ùm DScž¥/Ž$†xw…D{!ÝëÖ~´-çESZ ²ÒVY%"åíŸýìþÆÿoúïýòÉs²d2WÜ~ÛiK ¿;™&ÂS÷¼ãQõ']|ßÖ[f¸[hDTgF)zòàø£ßûÃõÕÇÏœžÍ—O\,„ïVi+œ˜ÜÝÕ†Ôõöz•ZGU±™ºö 8ý¥}n¡”^“z4`'¦'o³ÁVtíúg`E[»]¨6Œ9†â|çB!7ݵMÿu†í¥vÌGø6šÆ@àçô÷m‹æö$Mž‚øV%SfzL02€¾1Å^ÄL˜Émè¿GЊ·Î–rT u±Ç"«»û°Vgv¢âd?íK¹êÌÎcøk÷¹hÿäô22lû\JLåd½œŸç²±&À8˜‰%TDd7_öÑÏçö;’:OÜÆMá¶m G«’ÝNM€/È@ûÅPMЈ29ñ¹ ß&•‹Ô!ÐƆ|QÒæ*µ ƒ™ReªgÌ/<¾ø‘¯ÿúÓG§‰«ÎZëŽ&U[j{¢ýÈR²x7 Æ‹ˆƒMòýÑìi"–H&UIÚb‹É‘u˜†)”²ú㼇=+шÇß9í°fzWª×Œ`j¯»>\åJÐQ}kR•íÅ\-ER•:0 u±ëR·Ô4ýè$š[œ]é=¢µqÍ¥*Ȭ–|Ñu(Ñõg* ´€HMÖÝ´(©ÔØ´À¬„ !Òù«ïßù½_ñ¡ÿË/¼úpºÛŽ¤¥Ø/> .o­ëÛ͘yô=Ý®\—6Þ ö+`3ä  ;õ¢J:íÞ8üÁïøÏœãäîÝzÐûwîÚ¡̶Ð/îÐæˆátIG&cõ9Ѷ%Z»Úþº³JUÁª;†¾ïìôñ¬—"3tÚêÌÄâ³TµDL\Û±¤H¡DðóR{•Í›éû휓íÅ(3DØÞ §èÅعm÷à …»c‘IJAU•¶ÓÇ.5dÖ×:ÅD~œ „{wîž\(0n¢¿>½³ñÞša}¿K›ÅÓÛø¼¦HWOVyFhœ¿uúlìD'&=\|â‹¿—§»‚¹2‹=g0ªM´ü,ŠøâÂèaáõ(lÑìDEëñ¶® h$zõ–lTõ#H¡j7u¤õÊ^ õÿTAEAJ4ë|Ftöƃßó5_ú‘0EÁ<²ŠÙÑQâNÙÀÈ͵ï*­ w†Œ1ñux7l]wÕ ß<ÚÇ 5âªPncGf®\/¢7`¾§ÃÁlTié¨ ¡qbéØ[¼Šõ¢±§£-ã?×=X¥d©¨ókYxÒCYë6Á[Ñß)Zëk\ËñôÞ°¶âèÎ(ß-f%È,‚™§]ÙÓÅ¿ïk¾ìï}æÍ¿v1?¤Â<¹è¹Ž£>³rñïû¶ {‡Zì7fZÉÛíàæ4 ­ëóç±øEP–UPÕ™Yù‰|ïWË—ÜyïéA&ÚcGZ¨Øq+*"âbn?°AÂd³:ôQ™ ¥Ñòv#@5›Çf´†³D‰»r ØŒ¸^DX1¥Ù¨Î¾\Q_/N ¡ÂÂälð½Û¨F¾êF«äêòñÆÇL¦'ÙC‡8ÿa“¨üQÎïwºRVÓ‹Þà*µ¶Ù—díGÎ2`–—üH&ÕóÈ—v½9_‘…™R™DôôäôÓçò¸Ô#.‰*ÂÂ,¥€•„¨’a!¯ 4TÖj^Hœº´–s¶Lm%dmyœÛH¡Â!ÙD½VÊ/5b7žäTp5WìJ­(ÝÁ϶r§“¬ ¢(6ö>³j]:|ZžÑÔ1aêã4Ø4?w°6ôµæÕ«¾¾N€Z$¬¡,ŠÑÇíjç,´!kÖ±@ªµÈ|ºÏܹûæã'@ Cƒ¹!ÖoÛnR7ÂXða¡ž0vÛºžÅçÍ毎­Öø}Ì-~RTt*t¼xüþÈ®Ö2 ÙùQÚ–€ìô6XĻӹߋmB$Bj+G`¢R˜‰©³£‰GjÚ2x¢WúŠV_µ5$Ý4׳ù%}í,(f•ôäâêÛ¾äÃ_ûÞ÷œ>y8L;fU-2&_Ê(‰[±8ÖW¡]ÿ£!×Õ®è™ v…F[ý?´ Ž}{–`iÉ ƒ)ôîÚ¨ne.±ðŸgjíþlõ›ü…<ãS62Zþ|T@Ûî§ •FÃsþÆ„Ø?f´¶Î]ß’Ôo ˆi %­©fN˜lŽ.-ñ>éÉ&Ñ5ùЇ)„ÒZÙyN¹÷‰ÚƳжªJTì˜]ÁtT=«÷/¿ö?þ¾OýêŸú ¿P^:)L R‚ 9G–c"ñl•–Âð…›V ¸¬ÓZU9šÍê«á (w¤`gzãä _yÿßù±ß4½yQdrgì°a6×¢á#‚ˆ0Å‚3ÒN‹h:8nSS ¨ßt35ÚOè¬kÖðj…¶5ÛÏ΃p ¿/ :_b¥Ðý‘œè豈5É­‰i˜·N3HÍ?¥á`ÈVÐÆ#c ’šu2àN®RµžÊýT„7ú¾Eÿ¦aéŸT‰9)Sï‘Ö…ãK­×ûÙh;n,D­»ÔÍÏÙ¡þ¤TÊžùP/Ý{ñp|.¢µ°õ4‘£°@¡íöÚŽ??Ø#¡»âí¶ÉABp‹º Ël2جMÑëÁFê<è ReEóПðt‡ùñ«ó÷õ·}Շʣ‡˜&QAí¼´*1iZ ÀW¤‡°Îv꥽ïzÌžçCÓ·á35Ÿ–÷fógµw,$Pk¶_1NW@yi÷š³¬CTûÁí]i‹ÆàOö°)¥Vg`ÖéÚ ëiñ¬ º*¹Y6¼9ý½R/ÞÜ)ä[óÃÝf‰s =ŠóÓ —Ðz3CSñÑVaí÷Þð& N»£7‹mó Ú­’ó¤<3O…_¸zó|Û'ÿýŸüÙùÎ ³ÊØ}ˆ³ZS4¦£kmu£Zù‚J+öÜNÖ)+ÓànQ­z;öåƒÌ³:Ü¿¼üÑïûWéõó{ûýñ( ¢U˜ˆ ÷µT‚ª¹m†™º«Z Û"Zñc+\ä‹Z;r‚©õ\E3¦Òu}üuMÚ)<%‰1¡E_eÜX€í¨·S¢>¦»#^B§½Æˆ¾fQjr×ñdP° Êô$å ÉOZÍ,J‘6ÖYœÓ’tW…2~%xá¡qö:»sÛNŸn <Û°LŠ-¹àÎÿ¢\]œLEe.ÌP¥%°ÃîT+T*T Zˆ˜¨”]a";ù¦÷óÞÔ È2CL§| Yó¶õäÞh—Ô¦YÒÝ ´·lØ(CÀÝiºóæë?ò½¿õôÁ›g;ªzT+ªÂvéDLwÇÔ§¯‰Åí3!¦_íiž'tUìà «ëþo÷nd8³¼Ë†=¹m^Ñ—›zçSϵø§[‹Îàn‡š©eI 9ØB¡ÄSoå&çç‹õü ‹êÞ ¦«üä{£[K],O”5 àð©}eÊÌË­ ÅëC°­Æóθ½rªÜ¹ãx„ êiç\;‚YDÂ…gá“ùðÍ/=÷û>öÒô<¹{¿Š ‡yÏwaéJd­pž®Å¾ ÒŠ ·€›Ó¦0õß:€sOFÚ”d·_莸¼uù£ßù}§—óI™æ«ZJ©¢ÓĪ­ŽUlkd´MÝûXmSæ-›©Íù­«ÇCœÌ²aY¸wCüEÓëÛ˜–ºöç¹Z×òy-ÜÕÂu¬§T–SÖχQ Ûú"Hj°·¢9Sš¶%¨ù‡†ÙÊX}jNØC4,èöa°CÛ=/þFPOosZñÐeM¥®ðΚÏ5þ‡œ§aþŽ6TTÊÄó\ŸÝ=”Ãëó«:UÕZXH'­¦…Ŷàp¿ƒ~÷%Âu„J„ÍË4©Û§¾«²wP˜µö'–’ÛW"ªŠ­€ ¥€DˆK÷º-ÀbÌ°¢½§Ü×vŒ›JБR{Aàµ&Þ÷CBc¨{7©»{[~;F•qy,`»¾×{ÌQ9‚ïÒHî £Vµ/ÖXõ™;w?ûø‚y 6ôÍ Xt‰®IkE”5Æ–¦ˆÔ; ¹¡“r™6Rm@ Û½0“³–;©PóÇ*j­ û »“®ž;=ý²~x¾xrvÂ: ´ YHP+D`¦R ·ƒ®ÜùÙV”‰Ü/Òˆ_¸–{Ã!bƒh|ÁS—,L–gž›ü¶g ©Rtì½ößúº»Wç'9K!;¢‘¨T©ãt×=©6KíR‹ñßA¿E¶±GrHKë ì».lÂâÓR|šZ°A—$O×R˜BEWö´ •SäÞ¢Ô…½ƒQLõ¥—ø;T­æ)[”Ø|‘½—;ò"Vˆ5ÿ¶ÃT7<Ó¸\YÓ:Ã(±Žq| ¹ç 9IT:> y¡TJ´ßEݧD ©•À{Þ?yðÆøÍ_ñ_ÿ™Ÿ||~,§¨B…}_H¿3o`16šx›ZZiøiñëmò”GÂÚ0æ¤ë ¨’@ÀDWßþ%ÿò{àGÇ„Bó\K™l_<{H\㬘º²4íË ¤6[î…Yhd ê,·xl!|ÆŽwµ·.ñ(›î%¿ž]‘ß-dpGƒ7ë:ðCRŠA[¨£äÒÏ5' æ~s_EI^vGv›mÉKo¹²í·l¿Ó¬#„·CôÄúö9£‡h=z2QÔU_6áßOá˜îÃi1Ì~|ì1-"¢võˆçw//æ'òÆLW YqEee"V­>sj¡Ð26Økiÿ†Ç'~($‡f…Vo}ÚP,Iû\Xä·æµvP#Ùa?bžYAQI0.æ'-¤¦=Uí’çó :¥Žù;B¿>°1ÀAи´CÞõMkUºèZÐ!Eu‰uiˆ+ä(±R©ïLj’ Ü¿{÷³;J÷Ð)4ôâªSGu˜!~6¿YÇRRj¢ÙW”˜¸æ3¾&”gN1‡a„Ü+ìÒ. 0MÄe*…xWN§©ffªµÞÙŸ<³ßñ|¹ŸXÂ~W¶¢2,¶‡vû)MÌ‚Ô ©ëäF0Áº‰Ð:¨ï×]¥ô˜Ü­êˆßÕEÎÝ/™ßca]Û›N²=€ Q Ì?õá÷~é½{åÑ#&Qká¢*ª33«t>›$5í'4p;y…²úÊÐyèï”eêÙ ‘ÜÚ„m—k&µŸØg dT›Þ÷^g¦ŒEQz8?¾¢ëÖ¬èñ³¶K%µµ‹1{û©ïÓCbþ2dù¼ÝMQ”œ†©k‚‘y+ëæ-ìlª:C—q•î8ï ÆÿqøÀb­µò~wzxóÕÿé|û?üö—¦ÝQ˜DÁP"•ˆ¤B–Æë7ߦERÜ®\Ÿ²¾¸Y¤Y¹›²X%Õ½ò‹¸óŸüÎ㯼õüÝ{uQÙM“ˆ´ƒD±à^˜Å`ÓÈQ•åDœ7¹¢úï¤mOVz1µÉ´\2Jà¬m жß!bB ñJ7ÐÉײ‚I?8¨ôj"O½áí•feŠ¾%«û]=¸Mµ§ŽÊÊ=j°÷Gç¾²] äXP;~s-º a å6¯>NiÛ›šÚžfe^`¶ÅÑ„®˜s~ ;GñÀ„©C,tãáT€¹î_<ýà|>ãäQ­çÌ3ÑT,vVDcGJª:ÜÓ»…`ÃÕ^­× 9ÌÂØ–³ã'˜ *††-—ÍÇm‹SªÐ™À̧ªgÓtu¬ žÑ*J¢* Q‚Øâ±I˜‚@툣îÅJÈaPŠ¿ä» =Ç4C¼aR+ð-nÑW©j»w!„±M½†±ëó<‚(¤m06*)ß9=-t볨§é·”VÃ×q@oòÈëJN9½E}½¨£•¬õÚ”†Õçhª@%…01æÝTvÌ»iÚ•2•R¸& Íob§¤$¬DÀÉtR‡+i%a …R’ib橱‚¨Å'¨Z'5æÓçXþ…]ßn7 waP•¾7p5Ö‹H1ô-|OY8¬¨qh5æõO[A!žQ•ô Çéñ»¿ú«®>ýÊÙÉ„Š*Â>…a¢~<€|úb†3†Q˜ÔòÒò¤WÞ¾Œ [Û§¬ÖÞ†Ö`‹ËT/%^K.¿dÍå¬ 7i×ÑfõpzBlwÖ€™ìKÍolO[À£em ¨Ådvµ1LK)ý»jÁvwR’Â>DsAù¥@/æ³tW˨CzG€TÌÅ/ ¥J§Äòæ+ÿö÷|û¿÷ÿþëoìŸs¡}y¿é°ë:kƒú·—ó "ÝNžšn¶aYµÁN0ð/'\ï<žÿ¿ã?ûà=÷ï]]H‰™Í[ªnƒcAÍôŽö± xLúî| kJFËЋ‚z ˵ëi`% DËŠ¼ß) áð{Œ~ƒ6Ûã‘’®FÍv¤ÝœðCIZV$ÖQþcD“.Îüx4ð¤¯dëð®á¼þÎB߬¸ëø7›¢u+í?“eeM ìY ¶Faߣ6ˆˆ*%ÖiÒÝówÞ÷Ù'GÞWA%¸ÛIâÙ8»Ö›Øg9ÞõJ.Hk(Ч‹šìóŠv«ÅY÷@Ó„R¸LÄÊ¢¤;ž¬÷D›œï–v0#“¨‚ª*‚Y¤ªÌ¢¢:W©P­ªUU Û€…‡îÚ Zû$VsºELœïSIJÓÝÞ”ê1SÁ@{FPòs>¢íÁXN>%×E|´ÞïwçGe$^ÌD®KK¹ÓåóÅè‰Îß,´+í‚iò bŒ4¾ ^&*ÄSá]™öSÙMӮ𮔉ibævÖ½Ñeå Ä®nn èxqÂTu_&;ð¿ázµ+®ÉaSÔÖ+Æ® Œ¡¡æ èÞYê“BgU¬u¶ÆRp ¸Ç NÄy¿SmÒB4×*EîNõùGOþÀw}ç᳟}æl7-0ŒTE˜ìê¢*>\³DÊRÏûÔÅàâç!ÑÖÛ)+éÅ/ 2CŸRxxvjsÑðƒ¢û' ’}4{Jö8S û°¨È R”›Á@·µM´»,ÄêhÀ±?\d1ÔÝ6‡\³.µàLo|ŽÏ5Òzò2mè€ôY©ó$¦äžÐ¦Ûž‡ˆÖZÊ)Žõž™~øË_úãÿøñÅéj8R¿Ú]Cb¯ëà ð6!øp;¸9mY¶–bøvwŽÙ[¶kÕ¡»óúƒ_ÿÝw/èlÚÎLD(L•v1cœôQ·± V;¢¥ü¬ª L")£ð.´W›8§üáIÞЕøé–oS¥Þ„x3eHn‹Îä5ô’G¨è¼ zˆ_èÛÙô7Ì2.¦Óô~êO\owãÝîšß¡¶„HÓÓD쪲IÄ7´7” CYY üãF´G—"´ëh›3\Où΋g/¾z8R‘JG"iH7K¤¾ÑJCiè©Ap6Œøšnç¤Ûä85_•‰ïžÞ*i-Tf™©V«ÈÄ`*èQÈ|üˆÔ¬*“@i"Unã˜XÚè#Q ª ªUô(UTg‘Yu–Z¡³¨B"•§ ˆmmôr_w¸bx†;SÂNÛ¾ÿ3¿È…-™Í8-ž7 PÛ ÚÅÔ3êý³;—ÇÇqð„žDiügD‘QgkBÖ]“‹l¯š« šçµÂLL»RöSÙ—Ý~šöÓ4•²+¥•R j;º-t‹#@¥ËIè™ey 1‰š&¦2dáòý›BWôSYÄÊgÛ¹™@LÈ‚IâH+ûŒÐ ö;Án…!(¡ç'G-;ý¥ÝóvÒ;ó]]ùƒÖÅÌhè¾èžëɃ×ø¾aÿè­»ûIŽ•DÛLÔVÎD]BC[¹ÿb±º,a\¼Mi°wo)Ìü­éŠ Ó‘¿Ê~)‰Ñ³[€oI€Ûi¿®KìJ:òGDþ¸,=êcˆ³€²µ1•V?%ÛÔ !õsʮͿjm– ‹È\Þ^Ùõ?õŽ;äõm„¹Ñpÿ7õ¤Þ¯QwWJÃûÏÎÐÉð 3‰*Äz¬Ç=¦ÃŸþ±O}Íßÿ¥¿ò3*ç¶DÝÖ¤ºh¶æºvߦkÒíàæ´˜Cçr<@<"ˆÌ¢õŽð×½ô±ßôò—Ñ[e7UVÖB¤ó,LM§Ã-sÞŠØ×Õ4k*_¯ï±Žn„‘­DP¾Ð^‹fÄpM³‰ëó÷ŸˆÆ`ŸmÌ€~p‹Gú!Ö:bЈ‰ÊµõQúÕTnÑÚTÝÜØõ‡.mŠ¥ éDù”¼6[ ]’¶¨,ÄÊ¿7F, îó“qIaÚ!ê\ɼ¨ÊÚ–Y•@,|÷ä™ ¹|X_×"LX²Á.v†«2„ìÌ)iþa­:âÎ&µ‰5 v LJŠiR‚Áj[ °¹€f¥ƒj­R«È±J™eQѶŒ´Sp•‰ÀêÁ~fþ”T²´$ÁÊîf@£Žºé_Ÿ£j®ã)dÇ·‚Êý³{¯¼õS´]5–ÜÝ´îO‰ZÜJ®T!]¨7Ö^$Àö5“‚U‰P@;æ])§»Óý4íÊtº›vÌûib²óvÛ[vdÛ0]Í ŸQ•I0µP1"²øÛ‘œ­v–)ÃŽí"UÑB¬¢mñKÉgÖ1øǸcè¦ûòÕ6o¾ö=ëS=ЉBeôФvÀ1üõöÙº Í%ºeh|åxTtUͬTd÷èñ÷~ùÇ?´ßM—O ""l>'ß<Ä{Š…V%ˆ–ÐkÌsúþ‡àÅ0]Þ&±V§ŽÚmœÕ¤>Ý6¾£ïÞ ç2 ?/ñççf5ä2’ ₈þ0H^Í@RåO10ËW›ïoûµx6wZV¾½—'•Ð;7˜·A‹æ§Ñ§ÉqG®ª¤äú7rÑuÇ\Ù»¤Ò¦ß .Œ*8Ó{—¯|æö;¾íþ?þÒ?¿÷ÒñXyÒöì„™‹©4’ݦkÓíà†t3H @ˆ•_ªT‘»e÷ÌüÐ÷}w}åñ²«¢$íü|Û¾Vm€Åa¶C¼Þà'²…¿/ØQe¸© tõïúëÍi\Ôuð°åyù5 ø@HŠ£1ˆÖ,Š+V´Ôb²µìžÕƒÁÕ¿RÔŸ£rpË¿ñ @[†M–=:&L‘­…-õ1]#´]ãåfn“ÐPzˤªÐ4 Êæ}1(°#>Êó§/Ï/.¥*.…E…Úuƒ·¾Ní¢!æš(Ð .‰/ònljÓ6&zvMPPs£šÇœ˜Ëq®•eÚÙÕhq¸EeC•´PB!}ù¹aÃÐvÎipÚP‚móuA¸ ˜¤@'ŠRQséͶÿXe«Ìµê|P:¨ bðž•™¸Ø5_›~©vÂÌólµ-¶†´MpÙÚok#PXP7+­§'´›plë#´ Úf÷}†ÒºU›…n9ê^‚苨ªj%•BºöÓt²›Nw»“iÚO»Ý4혙¨0“DÚ.^s÷~1#âs€ŸpB/hª#㟪}nÛ¤J$ åÖ\©ÌL(6üLÖ=HN æ–Õ8\EƒO}$Y±k¶3¥‹f[%èúÝ'TDfÑÜ}•¹ÕâÁ`A2—Fo%Q`qùU''_ÿò{Ë“·ö\æ¹r‹™¤¶^Òk¿,P¨·;óÆAóMj‡º°ø·ô[Wçk+€ïךÝ(¹ŸLL~U].‹Jo÷N²VÒ˜?ÌV+0k«x¬±¦´d̲ٔټÉñ•uDÏök®óºûlȼ²O=ð„–Î_û.Z6tR\ž‹]oˆ6]EÊ¢Z "‰¯Œàššã˜]*ZØ\CDÂ*oBŸbµ¢º<Ô‘âdCQm¨HË`ËP×âÎÖ,Á•°AÐòåÁ`›fC[¨Ìƒ¼«R—ZtתÔÐúÑþµ÷TëGQÁÖ—¶Z¬«Ï& tMžë^{b•œm£Q×­ 5x-…tý×ΠTUh1DãÙב{§»ËÔ@©*tž¸È“'ß÷%þÛ¯æÏÿêãs:±‹P}gÔ 1’ɸ,}à‹¾b„é·/tž=mT¸ôŠHá"**:1Mæßÿ ßù‰g?0x_¡ ]™D(M%ÕZ‰ã²Öõrö€\ó‡ƒ,”¥ÿ0¼pó8¡« •Ä‚²›R(–Ño¥à22C9m»nnPnAÁP·?­(Xðõ'Zü½¾¶ºe>oÔÆK›*= u_”÷ßTz Ñ£ºN³FƒŽLáMy@‡€z,WéÑ«O~ûK*µÎ•11µ³݇Û!ƒ&&S ‰^‰^˜ÏëSfKô ”ö„©y%Ip²/§»Uá‰}j¡¬¬êîÎØGiê烥é¨}pÊaÈÞ¼Œv¢§ ÚõÞ9l¶ðó¾TUU`Q9€ÚMML±C…«*”fTÕ*2W9ˆ¶^©ªsaU%V"%"b¶¥ƒºEjqX¢b𪄢‚×=ùô[•¦·ÞxãñÅUÄõå&WÚxC>Ÿk4Cµ 2æÂu_ø¤L§Ót²ÛŸìv'»Eê“ä'°(]ÚM@ÄÄÄι´»”¾§„[iú™Ù 7z OHQt0¹S:AݱŸcI–Ê·§þ$^®OJí³nù±„¥}¾ás‰¶çÆì-؉ ž1Î<øoË7¾ïx~Guf‚ü* 7“·w©ƒzm-¾b©¦ž»ÒRx\º¯aå`›<¿ ¾fªfÓÖ¿×Ñ×÷µfÏÂuE¸Ìõü™5M|’¡×ó\KâSÓµ9o,Âá°S?ç´ÁêθÜÖM[¼& eÛzé:P··ÁÚÇF㬔„hR} óá}ù·ÿäŸýùòžÇ¼ì2f‹ÜËá?7òç 4%%hévðÔt¼ “¤…ŠH­PÎäøÉg?ú»¿î;ø­Ë;»;*Êþ ‚ì‚ppmŠ8Æ–£§ØLã¦hêÃ~ìÊ@Jn Ÿ’®¯ËªƒÀ¬rsÊ æÆŠ³Í÷½ƒŸcr£•§’²0''Ð’À›ëÖï”ùb¯©výµ¿=×úqyÁîð~F°w·Br;ñèËâÍûå:`•iaR(³Ã')¨’¦ùï<”Wët^¤LðÃ2ÛεÛiDv±SR";_E!Éõ“V»œ¨k$}~è»Ç(bç "ÇÓÓÝÙ4ZÈ®.¶èð’£³rÔ•c‘FC:ÇI3÷Ú` ;¦:ÚÍÎh¶­DÚîP %@4îï À¢¨‹˜òfjç)Í*Up¬µ æZ…h9ŠÌ"RÊL àR*Imóƒòðòê>û†Pyý³Ÿ½: °IZ¥0)Ę'æ“Ýt:ívÓt:íO':™0;–§ÝeæÑ;J… &Y¸ñ‘ÀYÏû6ånôÓjC{°éhï©Ž°6 @÷À÷_ro"‰€ÿœìdîé­tp¥$$°3¼·‰¥ZKâªØf2ñ9<‘£Ö“Bg_û¡¯þÄWÞ;½{u±³²ÕöíXœªÝWgH+\mÚïšÖêœØ*ôæü}dŽáC†’¶ ê+^¯q®}ÜD»ºù(üÏþvŠ…Ñ-Á¡ T!Ë”–³ý «¦l¿…Íó>Aº–S[¯ Þó÷iFÎNC†`’Œ"FdƒE¤[¡$J \A/IÞxù}ÿæûs¿rÿ3i©‚Bm—ÀtÙØ4µŸ3´ø ‘\ïƃÛ Òb(­Ô@=$R‰Pwö»ý+ð{¿ãð™/Ü}æêÉaÇSóÁœsMgH ²ˆ##ÐR¦šþÃ0€+®_¢¦D+eU¢FöM¡,+;µø<ü<¸xŸª`U¼A½aKQ/6¹düíã¦:¾ÉÊЂ£¡²Jß, †Û¡Áó2êþ%%†8ÍÎg Ð-š`Äùjn/ ßÂb¨ƒíøÚ‹è8˜ h—'7¥­šDj~ue&TŸ;{þòÉ“sg=&ØÉ"…]—{0@„‚&€ \<.(i"Š.n}áBÙZ‘oôS¿¯€û%8­oìlRÞ—‡—ëéÉÉTf!¨B” ‹,PZA b3œ|GÆË6!ßûã8€;¬ê£Ž€vŒ‡õ Ò›3Bb0vY'GÂ(#‹ØÞàêV¶ï'U*D{UÅD\üä¢zÐz \‰Î¢ª˜e>Ô:‹TÕª¼ÛÓ[ûã[Ô –#û]™˜ Ñþ´œîvû]¹³ßïJ9™J!¶=³Là&‰-Rˆ o:ô Í“Þ†÷o_˜L€žÐ‹¤¬çº<¦4—ºðnŒ “faQ14„C£±¤æüËID…å¥x ŽÆ!X%ò?ƒ½!e$`½ç¢@Éár\ßô@»×ÄóûZ«õ¶©P3D9 Ýv˜O}æËÇÿ7럽¶;#ƒ¥51‘¾m³oB_€ém­\‹|¾ Rf€.~‰ó5*¤œzóá¿õÛä…szf:«—óŽw,… ÕÀŠíÕ#¨‡X;Wu]ò¯]ý ïÑ5w€/:4)ò°)ïdx¤‚tùKw#à&áiEÄÈ¿‰Ï;hœ =ò`a’vÔy?ˆ€’Æج~I6Tƒ{Û)U3®¦¿FÈ“V £çsÈéغ¨€¢sƒÌçh(CÛA,œ,–’ÉÎ*»ù’Ÿ|úѧiz5±¶àV3W©=°¶õPÑX "í¯æ%)%ï¬Á¿IÑ­šûi0qö™Á ;Ò}¿³­¿ U%žª «&©H)ØíXU˜TlU.1Ê'VFäÒ™•*µiçY父ásê?ãM4Qãðb0¢‚Ðø¯J~i”f–Ö´¼NÄU­ P)ZH¹h¿à ¢z¬óQP¹<zx5ÿÓ_þåã,ggg -Í£f"RÔJH%êgÆ)ÚÉ™¶<@ÆU­_(¾%­ Ë;ºqÝ[ê OS÷Þ0¸¹ÞÊn¤NQg¾Æ[‹Âí[+¼X›™»Jëk®[du‘i/zcêþëmÕªÖ¡ Æ‘Ê#Ž(ƒ ó\åj¢‰ê—êÕ¿ö¿yz뉈p¤cÝQQ@µ2“Ø,‹ãäè8°¢½®æzJœRϳb.¿—2ÓÜ"íÄé Š¼½#E‰„ÑàøøJùn„+4Ža™‘rñ) ?JLZ‡þd&mQàÍoߟf„úÌð&K²Rðîéå^σ…¹ÞȱÕÞxçB«\ÃGÓçºÎÏAÿ%¢Ð†˜û†\/Øñ\¨R¤ª…™ zEWÇç^øþÊ?þ‹vO* BÅ×:òø,|!&‡BñàvðÔDã@HÏ\µDYÎfý_ñ5ßúÑŸÔºÓ=C Š ª€TÛwp·N‡;-Y=’öHö$SCK½g¹}ÿm6,ûÏSÍ䄶^i•ÅÀËÙ҉ˤÖô,Zn1û¾ê¦ –‹¡š|Æ ÞåZ»²ÝŒxÜҔê²7}©6¤·Å`\wK7ŠSç D4EžÑ^Ƈp’í,5"³VÝÐÜ´^Œ]Ñó$6+*1kö›¼)±B*2OÇ#^}üéÝy֣ݦ[É€4¸Ôà¾Ï”„Tj½<JÙ‹éúfót1D.)©(ª(®#m«Ç.Í£X™éìôTTT„WÌ$¶g¡0”©Þ½w ™¡"4Ùb†wz[ Agcô¡Q’0 õ‹ ú…¯­Ñ­QÂW!À©'{lvïK d;gs0ú¾jlO±¤€ŠŠÊ<“í$&UQ"æ‰g¥ËZ/!²;ù¥_}åüêh‹”2ש°Eþ(ÚŽcuçcQÒ~åV–µAÔH¿úxéñöÑÇCÈD«-Å ,e{mŸúš Öä ÚúR[*0úËIìŠT{Ga+-‡žŸï¸(?…÷•¸FsSà½éë>j‹€ °BB¬Ï<|ó¿÷­_ûÂáê„¡J¥U*ì¼,b¯‡Í¼úåÔëÕ×.ËPý¹côVÇw‰14äÆÈÈ¥.Ez †Œ¼nj¯ÏíÈ#i#£Íjr¨SÝt- Ý‚@t]ëåk–Ž ‘Hù1Êâ=ò'"ëùSׯ<ý¹y+’ˆ-Ç€¦ö®ËÛ²#Û2d#Ü=‚²+µÆà^²‰wŠÑ³µgdn%Áo©ƒ-YÑ#ª v¢õêððÉ‹_úGþÄOþÝúž#1X¬[’®Îâ›3òé *é µ6¶8±R°_˜i£† [DEÝïÊWÞá}êÛNŸïžÜ9Ö™u®@‰}‘ã©dº(¼ õ ¹Él˜î°æ²»’fAè¹±¶›Æv´rïÕÑ&ËN…ÕÏ¿¯Ìð@¨®\Ló<@>öƒŽš?pÅ­­-±4±äê’´ìžþvzždÚßê8Ù=Ó0],º·¯BG‘C~ME/ 8ß4üH~~ËChFŸñÕbkLg³Z¬  )©`<<¾õ`þÌLW\HE˜ )IUvæî­!aâ'— ¦|0 ‰Vòx¤Fvn"0åâkëÆÙé`+ÂD$ bñêÊažOÏ ³Ô?Åk¡(†AÒäJ2[G*3W‡.HË\hžª. i|-:UaG‚¶Û}.((NnÔà)ÄŠB¬R‰ *" fQ«^J=2®”>óÆ[Ÿ3Op×ÃæÖ í.+E"ÑÔe*3¡ Û•Ž¡üûŠGÔ0¾œßÙã ’= ät0¸´r­‘²Czà±}¤©¬÷zO ÍYxú½³sÑa„Ý[é%ÐÙŸü"€˜ «]º¡Ê)„Ý“G?ô›¾ôkïÑ©VbT¨ªÖà‡ó)ŠSt;£“x–V&ºswå6|Šû:óg@„‹ê¢Wgn.b’¼PkK·µò¼mm`/]q^{6–Ÿüè6‹Ø*X“lÑŸË[?´H}0»>õK<ÖÝ4”äúdÌ™ýWa!Iwñë {þf¯é_ ²Å¦¢¨ ˆpUÚ×ã9׌gÿÈŸú›¿Êïe…´Mt×½¶Í«/¨¤]—t>¼­=ŸƒøÿJa¬,»±“ ±Îõû¾ó[õñ““ݽˋc™PULÍ9JLÒ6÷9†õOV\Òû«pWÃmc3;ÇX ´ö¯î1 ÀAywËÃÐåeû›„6X–©Ê’®ps ¦veïv+?H$ÛTMÖç¡Ï ©>]ö‚i Îç`xû3®NžR8—ÝJ^QZËö·ÌËðH¦C[QÁWoþÈ%gjøýâ†äY ­nU×»‰o!'n Ô6÷v´ÑD®})JP°B‰Á¶É×üôv”ÎD<«ÞÙß»Ð3*:çݴתPÚ1‹p¥*~Œ½6ØÌÄ\ÀU D¶6àÎìKemáB ý,Ÿ_c\³öX[¯‰TeH™…ˆ‰Eª…´33ÀuÖi²s(P¿˜mÁÐK&WqRòA•næâ<á‹¡¤9[2ÕKTE Ûª`¡( À1“ÇÄ”E 1Ï´“Z“K»¨öòøxPb属½¤jgaöu'Jê*”±W–Å?Km¸ò«Ì öVïÛ†¹Ô¤?×uš¿ºR ½ w '¾’O °⃯ߌÐñò}d…@ÓEm?ÉÀ² “K:íÊ/Z)¯š!qÖ©cà ÙÕ•„'‡‹¯yùô/ß¡‹Ç³€u&@IL–©5jmSÀ.£ëPÛ6<9Ü7…ãÎ…Æw¥Ü»Mas„pyqŒl 䦉àútÃÓÀ>DWõøÇî x3Äx›\‘†XÿŠèåáùÿ᳋Á.mî³eÉË”Zšênk™/¯H½ö¡ ´`" ù5Ìê ´u}¥9gjXW4}ha äv‡šÔ>êÁY+öQâ,$¨€ÌÄÁ$PTÅ.$ÍDLwöõKwÿ»ßý ÿë¿ð RöDH.–¡kžÒÞ/àt» ø©ÉµðJ±˜I`"d>¼ù惀ÊÇ2MR…U•´²ˆgNM+°ÙÚ¡|ûÉÜx!¾Mœ-¥0a,–Ù“©RøQxõ<ˢĕ‘6Iu=ë%v‹½&i¨>‚ã¶ô­A‰ šòd˜›0™¯<ûú´Ÿ‰X”Œ:ã,s …À:ˆvm1X rÄWóƒ­Ñü¬TÔkI6©q»§‘PRç±u·”E@c@ú—J\ìÈÑvØ{겘¨³Ûrë/!bø ¼ïÎ V…’¶KbÕ®]—ê—Wh5À©ò½÷|úóݳz¸Q!ª*\¸íS%®T‹øTPqvrúä⊙«€±ë‡MéÞÑàtðm «hÆÉ—êÁWˆõm¥Ë«Ë»gw€*ЉŠÍÀ™Ù\êª âÃ|5•ã›ÚÀ’Á¶äozKÝæu إ͗¼Ã¾5"ÚvôßE¼ÿ·£š²tÅ¿­.3„v,°k‘[L‡eWUŸÕ¢ùņFm赤8–ø0¸´ÑÈZ-ræÆ># _ûÖ5ƒº³<Ðo˜‰z½¯V«‚ÊÂ6bqߌžSè»s›§!\§>Æ-CŸòÅBBÒÚÞW)Ûé´¨b3kZÑ?4‘nbF>å³›Ž¥2•Á{äòû¾ö¦Goî÷\QU¡" P±KŽ½@I-y–¼îÞ¡ý¼ÝÀoª1¸âŠ]‹{—ø]qÃ@¬¢³ ¯~)?®Š½O›†oÂÒäÐô¡ÏT=4Î7ËÑŧå‡Ô_ƒ!H£Q½É‹'.`>ÌÇ÷GÇÇì…ϾºM[ÚSnË"«/}#9:äªÉ 9?kû%# ¼>×è+0pE”ž±ˆ“ë‹MC0ƒËl.¡ªR¨H»È!bóY&®…¨œ¡œ¾þ棣j)R„C½ ìèä:Œò…›øéYn¥?Ýi Bè:šNNþÌöäî„wµœÌáÉLíÖ‡UUU j³ C]žÍ.;²›AÕQ]aïz9ª¢Õ¹¬ @$*ª’ˆù·$(oT¥WÚꥆÅ|ÃDà À KIâ/ÇntUmÈÚ®ÎòƒÞÆ“ì¹ú<¹óa3 ¥fzt ª;쀺‚@ ËÎØþŠcê^ƒ$y>¼]³¹N5-M­kbÉÈ\ì5;¤5VøºQéMÑxn‚düQ°Ý~Z™ ééÅ«?ø[>~vu¾#–¹Z€µ ³6fÜgüÐíOê¿æ07 Ý•¶éÕXÑ¥f3!t…£ÀÞòvy?´] âÝ’;ZûØRwãwË냑LYù¢“q›wÅHmÂ',UÑùœ°è:­á£6ª¯íµ»±&×9ÔŒZ{« /ÂPuû¿vJòOÑCÑ… ÊÉÏ\Ž¹ž¡Qè­¦ESiù9=X®( ‹¡ü6sp ÝiïæÛ̈Š¨X²ŸˆPE …L*©ØÕîEA:QÙ=‘³Ÿ}e÷ÿÿ”éÌ.Oqjc¬ç^Ó­îûBO·÷<59V1Ú&jRQRœbþÊgïý·¾ãûvOßÛŸÌsae’ZˆTQÍvø«e4$–{„th–ÞC½[‘ÐÐÞÆ:ÅSÚÄôÔís§+Ü*"„½H¤Ž,sRÞ.GÍ2ůžÑßc„¢¯-g"É—±ÃuŽf\ؾQ§¤;SÛW³nÉÇŸvǦ ±;«Æ~Ѿ¢½5†t™?µº¬4µÚ-]'ɽbc >hþ@¶;¶Ï}mªdGϳmÇ ”z]í®[’Šã%o\½&\§RUÅXbB5>ke†˜v.ž*‘noWÀ¢6 ‰úiKå‡ ÜyüÖÉé‰ Vbj±y"Zh"‚˜TX§M¬¨ÊPФ¢mõ*È—§zÄDë%"¿fUn‹9±|Ê0¸A1Ä’ÔZ3òæ¡lu9CÎZ$ed—R¦Ëy~|8XÀôÊ›o>z|A¥4˜Ga~-›½¢4Ú§îн9)’¿¶aEJ#/jHÌñ/ØÒ&O­‘$Fç8Œ©ç¡-]_D)¡EFsàËwþj[Qœ¿!ažÀiv’*qEëåØnÝvìR‰¢¢»‹7ÿÕ¾ðmy=9gV%… Ãì’ã­Ð8éÈ€ü¶ò•w%—Þ ^‹­BhW¬½ICfÄD½š•íìÈyCàV{œMæf°šA7ùûÊá†waÒ4–SÇå†ré:}¯1)Ð¥~^R'"^¦´bZ²pAG–c/ÆÛ˜>oæܲvOO‹b½Áˆ¾óšt^“lU_–‹r8b·jS‰Ä&¢¹ÖB¶;M*N.'þ ^ø#ì/üÃÓˆ'ÖY©$ÒÞQ;¾ ’Ù€¬äpôNSLL\‰ ³éôç_{íÏÿí¿ù{¾ñÛ.Þzp2Q­Ç‚©Jµ@DR•ˆÄA[R¢1»6RÇ\]‰é?wôÙz™}dÒî…ojÒ°ˆ±wÊßl£–¥½˜#~ù×ò·sëÃd›ÓÝšLDëB‘•-¯“¬¯4”LFF eCkÌ€sF:â*/Dƒ9pL·´å:üͱšÚ°P­éû€·ÜPkbò>P˜ÃÌqhËae0éF½ÉÊh];Ke`2’Ól1ÂbðH™Úq!AÐìÑ;ñî.Îé± „THìæ R†j\W4Q™U”“ÝþâpœˆÛFÉ<¦‹0¦f’¸.-VLÝïÕÖe2.Ž—ûý) ½0QåÂ"¶_™Q™©ZhÑÌ!'þUvÞ§!&ÐjcÄÑ•‚ˆÄl<åß_¾ŒÁi: ¯cÇaJšx0lïL!÷Ó£]@V­€ MWó »ØÈÖ³Q1HVrºͯì‚c¿*ÒØA*" ¢>P»'Ї-Q–Ȉ÷ˆcn´`ËuñÉvlûG+–]ùÄ õá–r…!ºÈ-+‹ÑJµŸ`ÖœÀ­Uƒë  Ü&ó@ºÔ+¦ ª«e2^r ô¦ý|õ¥gø–}ôðêwO‹V9r‹²¶å´!ˆ±â§V1sœÊE éóÕnJÈ~²W|©³—¥½¡¡ÇC?õŒäMsŽ+,,Ó»ÕõñÂfu¨Ivµ_(Pÿ½Ë^ôŠéC?÷hPxé£öü±Gv…óœ/™UMÅÒæ‚Õñ½$ª.1(½lùš![ -ycO{(àR_´Z5Ïç:²hâŠþ<È­N4Œyúº'Ђ¢EË%,Óe’C{ƒD„š»‘­µ ƒˆE)<]™ŸùÀÿá?þ©~úí˜ç-¬bƒàÛtCº<5¹+ùúZ{J1켧ËË«““û?ù~þ¹{Ï}Ï'¾z~óÁ~šDT*ØNj«µp©¢Lìëþ [.UW¯\Û¿–-v²´Ú:yÎL;õ&Àíèh5;6Ô—w)Áapå–ø@;áƒ;°SF$s<êqs¯"lWDîèhÃa¹[GŸzlò±í?vš=hcó\À"†‡2m#¸Í§üB³s‹5•”1%ÁZf—˜•õþêæBÇÜ£™Î­MóˆÌLw@i7´¾ú +E`—ÂkHÛ‰þŽ9ÏõþésÇ‹ÃU™˜bw=¡2`ˆBÚ$¢Tè´›ÊO*… ˜ŽÇ¹ìw‚I0O÷_úcýüõ×gge® H±µ«ç6ݘn'o?5 m)VòaVJvϳн{ægþú‡_xéKög»ce.:Ñ<Ï…˜¹mV„ËÃtÐÒ‚Æ×0êF!­r¦Q«ù§ÑJæKIøæ»^à w‘ízVÀcXÎrýWW´§|CɆûwŸ)ðˆö[VY¹'A@£Aö2TÇ‘„æ*ͳ*­’-t®KÞPp›ÆU{=Ħ%^öJãà0¿²ÞpO ö Ün-ŸQFá^¢°ÃÈ?f¨Öø°Ò•Ô¼4¶>ø)ì‹ïì Ù®ßçNž{õüH‰Ek±ØT%0 ªxˆÙI®¨ôW›jÈj$ÞÆ‘ʳB7=h6 m@DTŽÇyÚð¬ªG¾{ÿ§ÿÙƒÿè§þòù‘€¸Hs`Ü¢ÿwœn÷¼Í4 t_ÐŽ¤…XDæ*¥Ôç_þÏøÜ=??-¤ÊT&¨’šVciJ™å^—²¦ËºE£ 4qCÿEÌ&µCYÛ¥¨ y3@8ü¥U«Py]þ’´ø)!¨ðÒyÇÀ‰¤„»Z‹É„¯d†ÜÙ³¸¤qé#"°ŸcÂJPåI™‰¸ÄÊYrr,Çÿ@e’~Ï–€fïßÚeøXÓTR·uÉeèOÈ)‘¢*y¹?¾<\΢LvÚóîÓ¯½q~q&ÛVÒöQHbEŸªÝIÜ››ÐùFsrDÛ–¾S'Üðgså¶Öglz‘(ÉÂ}]ZVê}˜>×AÉ-kïÚ_Aˆ$u°M¤PÞj÷-·‰µ¯ÖŒ\é_Ú4W™•äîåão~éîoûØGv&;ˆ‰ªˆØ/¹lëð%¡ ”bÒC/¯¼à¡‘D„À§¡6TV’âVJòÍlJË¢bõgÈØwŽ$ÕÛø›ŒõêOcñ1±`™y›/cÊC!ËK¢‹E‡í×»"¡\ÜRøü>-£-ï5Ø*ýÆ£½0×ÜòNÔÓáuïÙëªõ>ëg!*j:‹Ú%B)¥ÒO?=ÝûŸü±?ÿÎ^¾„9nhnõ'‘¾M«Ô1DFI·€wœ68bzÁ³L»ãáëžùàüW¾»œ?(ª$L-*¡´ÛB•’ñÎ:3UÑ´÷€Ô“pHA[C }H/4íØ­^ëµÆ;¿¹\xM¿P¶¸ÎRwÒnP(cDa´2«>NúÞ©QŽ¿Ó2™¼4c š–dRÿØ«N¦èÆÆŽF¢}é­(÷óGš–ÔGF£¶‰0†¦Æ^â!w7¸©Jµ;€… Õ Òóùá›õMìÁÖ @ÀBDRHEPÁTT€Y¸¸¸`*Ú°1—5‘b Y²©ÝMMà•ˆ«J!²ããÊTR Ÿ–P &U;=I™¡¤E P¥"<&")·è>WÌ¢;tÕèȹ¾)„ÑáY²VÍ$ ëŽË°´­l©‚„ÀŠIIÌ!¬LÓ›ŸhÙU©æϼùÖãÇ*œ4@û7MÞ0fF?:Ü4þ½¼ñsë½®?täGfÏB²˜^«XFy6ñÕðÞP™÷¨w@š§ ™ÎA‹xT€ˆ‰*é´›ìf˜hà ‰íöR¢ª"„ÓzøðüúçÛ¿aÿäñI)µ Z˜E”„6SßcB=~2µC›XG¶‘ôÄ ”FTìŒ#ŒëóŸ…Û&ñlÁ<ÕFlë§Ì©Üõ)w[m› òZöÐÕ/¸j]{Ó=ç·¡Ê‚å¦LÕ‰çy½Íù7Û»|£õ_pd=eÓn>ÌN9yOÁ{KÛЇîZUl¶Ò~È3…Ô›Ú-v8ªTE•™çrr…òäþþÿø/þí ¾ÄN‰ MÕ61…(ߦk’bcpôÎÓBÆ)Uˆ «ÊaÚýÝWåoýÒ?ýä‡>0ÍWåHPH™Dì”tR 2?´ îaõÒ4¶MÂɵ¸WÚ¨1éßBE ņ½L~6á Âd$³Œ1h¯,O‰ðÑÈ;2б’au0,毴s¨…n_Ò/ŠÁòö€u_ÖàÖ€j–˜´MÿºäàK¤Im-ŠZvAª”œ£ïgýˆÞ¹Aœ²õw 7N.”RiÈg¬­(Êš:ýJ ¹ù€ÒO.­mEm d1¥žíî_Èå¥Î )Š¶û–*@…ÊQ+—r¬ÇRˆ•'žªTu#IJb§ô ‚ˆÚRÙ0åÌFÚŸ"‹(3WÌDÅ U€•´J%m&(ˆìªù&µ1×i­Ðb§² ·£Ñ"·ã® øH êÏAÛ’ë£iM^GͲ°òºmciuÑÂŽwÄ¥’w*‚JíFçc­ÕV9š{º9•ÍýÏN‹‰…¢@vPˆå0* S$û¾ÂHË—™[+pMˬ1V{!Ëì¢ø‹-ŠnãZãÛ°ˆ¹ší ¢®4]G¥E+BÁ¤ª‹Ý¦A$ fF»ø‚ºR ]Ñe ¢"H…@ªD´#ž½ñC¿õëöçNÊTå¢RHEˆÙ Û`ewÐ÷€Þ(#=täèFYmz5¦¸¾\_ë𪮩šºsqÍÁ(ѪŒ:–6Ÿvoñ²“½A:¼–¨÷(uï¿:ë IC=½Æ˜¤g:~×eî¶G<¯ãzéN~ÐbY¤[†Ô+®d5µ~r)ÔýtÉšBëëÂ+ŠÇ-5[Ãð>WdS½bOÖaŒúÊhûÉ·"£é¨ÓáÙü§þÎÏóE)¤LàŠnÑÿç’n'ŸGÊ–Œ *q¡:Wà^ùOÿêŸýŠýïaæj‡ÿpaHažkå¶?Q(ü¦žmXÄv;œ¡¯êv¸4‰–’»a`(ÐQ›Ñ@Íw\Gu“WVéE“éc( ˜£éÛ^múÈ€§É=¯]Kt³ã¶Z<ð¡u„]õ?ÕACËè@a"?tÒb1¾U>ìœÈðÜ¡RS|Æ‚ÑWÛñb­c'4„h!øm'aêÏ(æq“1…ÂhuÌâ”'Ä“Û›ÐZøïœXuhÞ{’Šðý¬-Ɔ¡¤¨BÌS•úìé{_¹xE÷¨DJ(‰BEhªP)­Oª"ÝÉÉ|q®ÍÔ d*³ On04ñuœ•:Ç 3¨U³­¶)  f¾¬§ÓÞD‚U ±H¥Âj[¡¤ÄZôXçŠýTÔ~hÌscÙlá€ÅÓÓ äš{!‹@t¹)ìÝ–^‘æ#¬F^Õ8Ð!V.jÛ¯g%F)—Üâ• RÄV²‡ ‹mÞ¦@”¾nµ9ÑQ‚à…Ä.5 îªä<~£Ê/éø¹ï´¥4;o{Tô2fCW|’0ì7UbVhÖ#ÓD<äUèTvá‚íë$ÔG¢?Š G´û5êž°{òÖ÷~ü‹_,à©VƒÚu[&PP;Q~ÆŽ >¥ÌE«Æô_š#¹øÁÁ"‰Ú,¹]'ÒõxC‘2ÆÖ·VäŽØ&ãs£d”’L˜=;$ ] ¡±eÀ.tq4çÊâ’'ê›6¾…ÅÙï[Oû ò†vÈÝÍhr´ö~È¿üzªgöp:Ÿ¿éÂ\œׯÎØo,Ô¨&¨B}@7:}´ÓŠl/N³Î¤nÇÛº«èÄû£ŠœœüÔ?zåÏüÜ/Î^œTA\Ám:˜w4ܦw’n'Ÿgê’GDJPÀ¸RÈý{ÿןøsô~ßù+¯ÝÝMk¨TåXÊ®ŠºAŒó·cÐzZ¨+á:¿EŒˆ]ú—ÍqBäº2_"^x‡ÂtҸߧUÔª×Þ¶~Ž˜9OÂÅ-ƒ/rt…—|®®¨´í÷kF—¢ Ck(?kh:i^Ä‚C9cÿMÒ·0 £wÛ°Eni¨Â^-¦Uä–\XE‰ü„J‚í/f?|a(Mœ¼p1ˆ2š‰lÑ“=ØÌçRþcëëSQešt–çO^xýê59BHµ€A*T…˜0‘Úù?\U‰¨ìwWÇ{ ´Øf¦©á/JÂCÝì8¹Ù&r¸$E…˜•Ô<­E%9’ Ô6iNm*n/‚ XYDª ‘™Á [ݵÊ5`ªo\Bò.O PÙ ñú—n§Ó–Çþ£$ªDl{©+´V²+å4¤)¸7ÆØ+™]T™„+CFÁÔ² «Ælüd²%ÒÙÅòš¡¼$¤WûÆ"]¾‘^hPÞ'Z¹GÖç5,8Nµ+õ ŽRÔ§@ &µÐæðÄë@ss·+*C‰¸Šê^Î?öÜÙ×~ð}úøõÝn:ÎGnqš½ŸÈÁ^tœ=(ûY¹X¤ÄŽPg$ÂÂL,êjèÁͳë¡DJ ðƵ©ÀlØšG¬›4EÀUMêµÙ cÑá£5è½¼I£ÚðD¤W¯95¨§åLh0Y¶ÂnaTê6q¹(ï'  ñ—MHtР/Šl4~zÀ%{sAL}ÀòÐܦi²9\,„¶b›îE;3š¼ÇgVHÅùT^çûÿ§ÿÏO\<ûìäÇþ„N^‘t›ÞVº|)+MíˆX*@Õ#ïÿá£×ÿüÏü­ßñUŸœ?dR°D…¹Ì*L,@Ì_h·ƒí»¨Shú®jmà;¼¦…QiÈ2p>âiRͽž]Ò_í¹½`Y¾'`P롽GÇ8ÁœUo?nO¾ÿ‰Öpjñè´[hr¤“‰¤°ãŠn¨S³W£Þo\–>Wè±iBp4þ¥LPª®cÓ³ÉÖÚŽ2ý]z&ƾÊ'3*ÜM¦ê´:ò-´d G¶f%P"LZžž}ëð&¦©ÒQ9¶$R,"ÙꕪLûÝa>Ú’oD‘1ìæ^EÛ Ü ´‡EÓ|ì4µ‚‰ ­N žPR%>9?Ì÷NOXÉ|£U+®"… v"“()ÊU'.ÌEéÆ.?s¢É€á.ŠM °Hö T£'Ý^·å©§ì„ñãÁkòdSÑ8Bèu5>´¨ Ã…8Ö¹ ‘~“*Ù°ê;ïàˆ®#bÞ½hËð7ƒ‡›àÐumÝz+<Þ‹=o;]½%@×`õ06dB ½à±öÔ*¦ÖòL—Žÿ†.QWä‹ga¤µVÒâþsÇH¾bíSøm ÙêEžI*áŸ?ðÛ¿õ»äÁkÓŽæ:³ &¿[=µZÃ:tAÔ°!‚’8K‚½©ê§·h%µK†+d ÷Ì¢,ÃÍ›Ë*ƒïaj y}fäà–º U–»ùš¤‘Ï9wCƒè†òÓQ$nØÉFfྒ:°}³ÉËÚßεý¸5y¥diùÓs Œ’kZl«› Ë<|[—?ôƒ›‘Ë>Ä<¦šå¶K ¨èL°›#‹¢…‡Žïùпÿû½q÷…'Çc™ö-<¨ £¦p·f&·é)évðn$W[ ÀT+Óé½?û3?ýÑ—>üñgŸåã‰Ë,uC©:Àò_ýó£¡ ²šé×mf§V€Wue@ƒ ÉÚ?ÆpÒ4OLY÷÷Ýy†¬n‡ð!¿ÝÛDتÕí¿·y•¤3¡-_è$õ#²*m‰ dݲÆê7šY_úÙÕØtA kÓyÞMûó‹‹gï<9’¶%‚B ø—Ö' -õHTˆHE” LÊBjs}jûŒLîÆ3ä0†– m-D"ä½%1¹ícŒhˆŽ‰•&Øçòp¼Ò|—YzIc9- û$£YNÞ&´OqJcã‹×ÑÊØ” ØB½Œu mÎèúºÈîö)¡`;Ïáìò9Fn¶s¬10"š³\²u¶…w_v]ù%øëÚAÉ/HQÀ.þÑ*²c:yóÍùÎož¾q÷„k=µ£U…“g'o AoÝ €‹IQ‹ô§ŽÚŒw]Ej3o€ß`Ê/ÏT—2…L¡º×Ÿ¥±hŸ–¢¸Ý-»S¹Pc-‡AïÔ}–¶²‰›Uø@–go"+É|0Õ*m“ïbxÉ6F×6a¸Ž_É—Ë· VÌI™œ­›’>°}°u{â‹E™Þ¦¹C°ÚE…eª:Ï^üñŸú¹Ÿ{¼;çiÚMÒ"ÒHU™É{ðæ>¼MÛévð.'2L dOEŽ2½ç¹ÿÉ?ýïþȺsÄ ˜T÷<ëÌeÒjHÂ#ÙR!®kÓã¤-ò#]©£ gFdÄX õ.„bam¨‡ãˆyUToY[s¯M‰+zDÁ»RnMO %FÉ^õ4ôèד%¬¤a½m]›’c®æÊ·m†ƒ–‘ –g 46õ¹/ïÄco£礵3²È, Î¼lhÂ2Øþà¸÷mTk $H[´€ ·uæYê½Óçæ‹:×ÃÌsaV™ ±‰ïÍh…3Oe:©u&RUÁn'åXÐ;ÝãæZ°V›@Ss/PµQì;Í.˜çÂ˜ë‘ ŽRí¡øãIIXí–_f[ñòÈæQîRÊ#£É‘ÌÚ¦4„:±”^§¶LnPCô,#Óº<"–H”TÇù¨¼Sæ¦mÝ" ÈŠ˜!e€>üÝι “(ý›àÞ0B|[Ì\=>ÒÚ‹}ôôqßøæ- 1ëìZk8ë4¨–a.Þ±9†) j¡hh£Š »ãß®â“_©ÜnÅf›"Wª……ß|íû¿úKÞÃÇ]ΕmEÏc5&åi˜:ñ¡£1HþZ3–+T`×p6Ll3³ÂªX?jðôqa€F±Ù°÷5°qËìÞÞÀŒƒžï,pcL*!1Ai.h$Ç—æ4÷¶¶é¤Â/°ó¨v·íÇ0d<ØJ›)IÆmªW3°ee•;;6-MKs uF„NeºØ¤‰JŒ/Wø«ñMšn¬,ñ’c”fûloj»RbÓߤ($¢Ç«röŸ¿rùŸüì?¹¸÷bQV‘Ecº[ä6½“´›Ûc@ßQº^W¥_Ü1b7Ž¢ŠìÊüQ>ùþÎá7ž‰@¦Rç:µ+9“²íe …§áPHŠð:Ò6©ÝîÒ§ ¥ëãg×El×ytÍ_t'ˆ‡à¸íQwwmâŒY¨³C Ë¢ºžue•Œºrüq¹›Œn"‘ú+Ëü­|]´eMâZõ/ͨšÍü«R·¶L ß—Ó¦Õƨïœg¾iU`†(P1¿qùªœ\3‘»?Y`º‘¢"6ÿSÁÅÅ…‘Ò–Â:™ƒiUínÊÞQ¡ª@Úœ²hÙöðTNNOµÎ1ùzwÍk)Ìv‰“/ÅѪ7Çá»Íý.TŠ¶Ž÷¶ÕëBG¦là­ßcÅ“H³<¼:(s›Þ¨B¬Jå³o>zt~h±`m _‹ÈÍ  œuÔÄRvh¯Sß?PtO?µC£Ý®ø½pßMÄA˜¨ª´©wlŒñ z{í½ºAÌÑÞïÍÓ£ý½^¥—¿ ÄÍKºÖ±Ò¯­´ì}ÏŒö·iÇ¿ÜЊr&º|ø·Ç1VWXY]Ÿ.jLGQ²°¡q QRtÁ‹Á@Eh«3Š–E #š2sÒÏD1"†áž™‘»Üd~ÁÞ~Äx׶ºÊ¢¶%RP. ?÷òÿâ?ù©¶{¶¹»IU½¦¼–°~nÓ:-ÆÛíàÝO™ª R%*¨Uqrç/ÿãŸýò}àcϾçD…0]ŽTÊq®æ¶Êoˆ(- ú8ŽÅWv×ÕÝÕa€Ç<@ƆMR¦nB õ¤‹/ —j¡2ØÚÎýrß·Ï! ‘(ˆ¹jõþTQå©4tncÊ6@cÇŠ ÍR( BwÊž_ÿåýžO>~´'­!bU%f?E­M€ÃpèЀ©˜8‹r@€äQBÐA`'.€µÎÂTZÃú<¹ âb}Á³ ¦Ô¸Ó¯#Q½A®ú©!»mÚ¨ ÕÉëÏ Lù·P›c9CÅ’Ûß©Ê{=h(ª7€ò»ù—fGq^¾µ¦­³£©©É vMËò Ëó¿‹ü”ªh´Q®Øå¿£€v¥\ @4Ó$<]Þ¹ÿÇÿêÏÿýËò„h*Ôno ÑòëÒmÚH ívôÔ´9¼ÞnÒèeìK=}øðþ®?ð‚2‹X„©CÆ͹™ÝC¨ù±^OY˜ÈáQjMÓ3>FolÞ»2ºMøúfÑ0é˜uÑ¶í¦†)ë^Ë›iLÖƒ[ôŒßÒŸÁì j¹WÜt_7/:¼z… t¤×?pmÒ¸õ*¬È’Í$õ‚`-ã:LªY¥çdYíî"g™qJ¯]¾zàˉTUÀ$³r±³É“‹Oy>ÎW…ȯ¸)]?Q’¢h¨jdúAy+Bá… \ŸyæY°]d† S -ªJʪ¤R¸²Õjêc4‡⩽úTð’o7Q,x¹p4š«1ƒÊ¤UPø²âñÅl¥Ñæ`(‰–òÏ_ôäüÀ##GáOR¬‹¿×¥.¨›aÖÑškÆ÷;Htí—Ì޾퇔nkÆO_pˆÇön ¤ž5Íœ©/£4¬LUÕˆHP÷ûSäÕÄþró.ˆb9­2 t÷É«¿ócïûº½T.žL˜ ¬"†ƒTAm¦ËïºõK¾9sÒ#ë× ß ¤¶YL&b0`m–ä‘u+íµ2xËOc|ÿHzÎÑUÜö³ÐÔÙ#sdF¹ mÛÉÚlÉZ¯fˆ¯‰ž·1ðó_“æŒH“½§ ¢DfjÅu0O#Ãðlÿ·As"FݤÂZ¨1Z‘"¤$(ªJ;)å1Ÿüè?øóãÍÝ Ê "%n·K|^ˆì 7ùXÀáí ÀSÓ¨i–¢w½0ºV bÂ,»Ë{wÿÓÿß_üƒßõÓ“ó“RÄUK)"-ŽƒÒº´AŸ¾ÆØŸ®¢WZlPNK2Ó¸vW¡»¼dÃ1Ë1â³ÑÞ€Ø mŽ&¤pí.æ5‡ÉKm»CvEÓÊœ;fé—`¶Ãú7òõ˜ Êóä!ÿM%ÐB»;Í”5*ÁyZ¹ÑEI©_zýK„KËÈGÑj$v¨ÿÞs êß³¥n õbø3!'ÅÃ`Æ'1‰¨*žêa~n÷Ük‡×ët„‚D‰©Š92íþ"TU†–ý„#D•ÛøQb†{VVÀ[uÄî·çàÕ$S,ˆìQ4W©P€XÕ!¢-Ü1`˜Ñ©LµÎ;.“…6E|} ‹ÜÁã(É[ü¾>(Öb=ò(Ìi´Uöø’h5,jÅÂh8Î.vc€ªšó8ºÜOr|‹E^q†¼y~tcê£i)íKU´½ºäÆÓÒaGÎ7¬à£¦u-xSAú+ã|C¶á­ÞDI(ÓôlÕY¨L[HQ¥2‘rÕùé-V»™Îˆˆ„Ê•ÖºøÊgø7à½xòhW vh4±ª¨Ý é±£»ek™fC£§¹£ÕÓt†7¼ E[i¢{˜^”N䇞ÆkôšŽ»ƒwjÕ ,éYm5æ(Õþ† [_«Ñlc6øчƒ&æj n'ï(é0&\ólgýQ (˜!³Ì|ò‹ÿg?ÿsßóñ¯?>yR K­De®ÄÜ<•qsmèfiÕ¶ÇøÒŠÊbƽEž" a·xý0i?Ubl’ 3ÃÜFœ+iêZ¡7Ã2vÀd†Æ¡zo õÌ^†±{4ËŠýÈ‘0®u³…²•P†p+‹`“›¬[“AT· A÷:Y˜ÒÂÚÞØ蟎Íü ³^ï€í[ëÑ燩?‚ `'Y>õBrþ%`£øÑ¿¸@¦Ý^nÜÕÉ ´ègQOEø~yÏÃãk˜ ¨嵶`¨æÇn:9\ˆ˜"¢†Û-¬LLæŒ(»”„“GÑÕžDÄ"ŸDÊñXËŽf‘MCŸª »f•”™¸€!Çã¬P%n¯9„ï†Ð¢YÉÇA“Zãu«­YBãc]žç›±hî»…†åC¤mÏøx¼Ò–Lvõ8« ¤Å.nôÁƒ+¬§# $Š}ZÆ6’×­¯Héò÷¤K:tTFãƒå · ÷×Ûðq5áúl$±¿AýåÌG@ºv-‘jL³T¡$'»½˜Z^´-Í)DíR¿©R=êq_êóO^ù¡ïú¦úà­;§§r<¶‘*ùéɶˆ–79„ÒLœÍšã“kSHÛ’fĪ¹rÆÇq;¡F“ÙԵ帮ݲc>©“p8ûƒNX”þÁÇ^RšnêïdÆP¢­[LŠ&&…8Üô¼dŒ‰Ý æ·Yì:`£]g»1îsÑ¢lyû—PM!Ž©ÅÃT 12Ê¿¦\ÑZôÅ°F/@Á#›3*@J\Á˜Håbw˜ßó‘ÿðOþߺÿÒå呹O»“6´ÐÛPL·É“ŽBt;xjÊóË5¿vö¹Zªà‰æƒêéÙOþ—?ûÁ÷¾ÿ+Ÿž3q;çÜL‡ˆ0ÙD€Žh7ƆçÒ ßXžmSˆnéÈÁƒhû§)Äf„$)Atí~Më<ì¸WÞ›™|gš[›±šÍpÅn`FSÅÃGw98ˆcÞ» H¤ŸÜÝcÝØB1Ð ·ÐTåßáH!èÄ«0@¾Þ«q±bxÝó'xÜu{îwˆºCÊÏB!…ØV¹%ÓÖ=¦:ðeèÅáqˆÊðâ°²0€ÞOÖ$J×@ $pß¾ó ó‰Þ½šÏuR‚JUævÖ'ˆDµPQÈéþäêò.Qƒª0‘’ˆ „lI¸ñ—ÛmqxB¸‚D€ˆso €¯Ç3>,0—¨ €’íÆ RåÂŒIªuO õ8 ßo0Äá›ÐH¿¬u•ïoÀHÜ P›7ø´-H}˜ž™„’ød£uI«ÒHk­¢˜bõC¹9§Éñ€úì×7ˆv €•0 ÝÿÔG[ÊqÄkDrñÄÿ%‡æm1'¯Œvè‘yWqí/ñ* ‰r\Þx²ê6€ó^ЂømÝ̦5²ÝÐ,bb.í²àíß»AÚ€ Ë\Û aeáƒXµXpÎm±¢“±*5VwV–s©Öd]ëÈZȘӑnéÚ D¡JT*úú“Wæý‘  D\k×*ÌDÀñ8?¹¸Ü—ÈQT”±;Ý1•ãq>®ˆˆ0Müœe."¢v¹×‚Qð.Ñ‚d ¯H‘û÷Ÿ©¬Jh—r{Ç2H¥²Ýal¡6 ֠…Yã v!+5/£ôp£…ÅþqCX¤ ïïÖÞgHÔ7>kÛ}ÐЋãWî"è#Rʸ8ÇÚ=Ïꈊªeú•WÞº¸ªvØ×Á®‘„ >zŸÂv¬ÇvEŸ“ed6|ÚñTõZYu£yîµI‚ô¢$Oc¼IŽYÖÏÐØ¡H¢ f.¼ßï»'×¹çóßdLd]s ÊTÏ.Þú¾¾ï›ßÿâÉñ±*A…DÁ¡ÏÜ íÖ+™º—ÚYî\½F»R´‹F­pc~à+[":×Ê`_xÕ`×cêõ­b13MãX¬G.HpóÑÞÞ…©¡ôeùÊÒ*ifèÿlj¹-ýyCZës¤§ƒŠ”©›¾ë¬êSÒX宋ß›ÚKέeüQßá“`Ë€¨ ÕÂE$L?õ†þ/âg/ï¼Hıêölè6½£¤ÝÒwvÞ®¼ý4@žqX\£Ba¶€ëh‡Ø—?ûÓù÷|Û÷èÅÕÂ,ÌS!E¡Blkô¦;Õû,…à9’È€ +5ÚV"´ ת€Ÿ.8¨ §~ƒfÖég »*3¨ýž‘î°Ô¤4^wCÕARk%!É–ß]}Ðok»çúÇVNšƒaˆ^îú7ᢾퟣ¡íUs¿æ€/÷ðÓ]ç5<±:0 .'A”úá X&ïjüj V3 2lm?$zW–&?zc˜È¤mfVð †3ò&;ŽÆ¼ÑÚA™Â7¤ŠÌÏœ½çµ«Wh§V)e'*¢`f£všöŠ+ÛCÉDRˆˆˆQvå„NÇ£J­`PX8Ñqž  âž`dÇ_jgAµ#êËSD ˆJµµçvã®0ƒˆ¢$€H!‚H¸ )fbPiþXÂ,R˜E”}Ï‚õ)Kc¨'"_ÜË£7ƃNhÀŽKà‹ ¢ÊÇãl;Q y)ĿѶo³ïPÒë_ ¶ËFȾ©–ú×õD‚\¸VÅ5YàŒ&ƒÔ6n@_á´HSjÉÆEÎ`eC"i¿J¿X µ]Û[+ðèw¸&Dˆ·¯¢€D+‹¤òÄ%Üÿ f»ŒÐ†!ñ,Âlº¥ë•2Ÿë'îÝùÔ‡ß_¿Á…ªÚd9ûˆ•€Z«ÉGGhêD ¬ÚŽÑ›taø¿ûbD, $¹èñ`‰ûq/H4J#ràÞ^·-f±w€ü–Ž.¿¨ÄNN©FÚÏ&vêÓ_êÿY[ÕÇšŒɨW®ê+í¹ÚF{Zõ%gçÕünð2•Ÿ¸²‰fs¨OnTÓ¥«%MÄö1´ô‚y[iÈ6Ò2jø¶Y"kø=F\¨©^tœÑ:·R¾ÔAµb‹H\¡Gì_;}öÿüSáøÌûë\I¡TÚ¾ßñP‡Ûôy§¦ônWžš²y°¤«Ï× ¦+Ϧg ‹Ì:1Óù“ßöUßô©/þؾ^Ѭ„B ¨m$csö|;Ó;-„!˜>Õ™óDœæØ“î6Óqˆkê÷Ð4C@u,Êö áþÝjGö)¶Ç ö¿Ú7R-àp`Šì>Xs¹±¤™íDù“ê"çЕ:”uaœôä)-ØŸ‹IjÚ=›FC3žÑ‘˜Ûì\Ìð¤[+>'§~h±ŸHäÿK&|!²×‰ï`Ë¢[‘½U=*©qª›Ë.xJ †(„D¨^òù[¯•©I§À.¶È&ØÑ—‡ùòârb¦r2™ÛZ¡ ÁÕùå\…‰ q;ETÀ…T-rgÙ&aíŠ"[€Àît¿?;EëE nö1æEì¾J* ¢¤"!@Ø.6æTÉÂøU‘èêhI‰ ZÎÐ-] iì¨Dï½ÖýkVŽjP%Ož\ÀV´ÃŽÈ窥üêkÎ/äññkß·…lKÉ+)ÞÀÖÖ»ëë:r#{ÆnþßrÞ ;ËRm†°|áeI:-Ú¯>¯ÍæçpÚÃ##" ÝíJÙMv 1©Û •Blׄ³¨ªB ZäLååGþõïúƳË7 ©j%Ñ „ti¼ëõ«'ÈT×Ô-ûj£ˆÁ=( ‘i,žçY%Õ?-‚Vzq`ooDî¡VÈ ÄmÊ–ÐTO8ºr½»éZÚ˜(~*íhw맑€ák_Zt °|oi¬›•ù*¬ýç<´Êïå'S‡MÈA»ÕvŠš_%Û_¦äKSØè•q(úÆéËÿÞŸú+ÿ¥”˺/Là]ÍL*ÇoÓ©iýŒTnWÞFÒô!ìx~²1<#¹Fs䨬RîÝýK?÷_|ðÅ÷¾ÿääN)r¨¶ñ‘ ¦ix&Fê .E]à #ÔG²;’±ŽZé&í?dò‡c~ ŒvGWÛ·Ú¦A›‡­›'Å–§ëeáþPûïÔ5cWû­qº|/œN û±­-„fY{g:ñ9XgK€‘†Û#ZÕB¡ù$Ü_©ï:  ¶.hm§Í¿ ‰ý­‘« Y¯ØnåÒÌL¬1ÖÐì°@ý^+õ8‡­Ý-ÚY½EÁ0ë† Øéëàºs²»wÀ9´2)ˆ‹Åà·c‰N§ÓKº¬¨eÚÙýDî7R=9;ãÃq>γY±ÀArbç·ª<G‰Óq®{"Qp8øâ_TM>Í­]-ìAÀ¶ƒ§BÛ±,~8 ùÑõ±mѸs`ã[,}µÉÍëO]:Âs«Ä”œdp9©ÒÕÕA©ä:ÖšÖHR©*¢Ú°iÏ•dÔ›®£¶ëCÀ{¸éó|'‰OŒ%nõ¤Uµ…˜ÈÏy²W0´I¿Yúã˜Ø P{ô^,³¬F¯ÕJKwé2‹X5¬ZUÝ41;³ûš ÊÄ¢J6}…è =åR^{퇿éëî^<Þ«ÖBÕî-sj`ÒN2×G¶¡³îìÜ[=fЖ…5­’y|>7óÒŒUê—¬…í«6åÝUÂX£æò¿I1z»F*z¹á¦ÈïÓ6ö‘ªŒ&²ÿ›Ö\7ÆJõ¦<\±".Œk…ÛÕR¢1†ûª¿.lãÚäd˪‹·Z÷(¢…p;®mw^#Z5¿†d{Ôûðû²&ò@†>_ð“|ÈtÅQD‰³<ÞŸþÉŸý§ÿ`>½ -\@\j"ŽÛôkn'o?ÑõO®•Î4öè±mÞ:ôÎswþÔOÿ¹?ôÛ~÷üäüÎÉÄT€Â;ÒÄ|ˆqób!I`¯eµ’ jV›²NØœ·Ð[e™ÖXáå· ÝÑ Àï1 !7o GÛ ûSõ-D£=Šü-B¦YvZß(– A'•cµ ˜ ¨&€Ÿº›Ø¹<@Š`Žu”×[Õ.¢mRRTµ”­e¡©jÊÐk-’­Âd»7¼P–¢?Û‹‰-í³ðp÷Èšç8a±•Ðâ“)쥗’È$ÒÂ:ß?{î‹+%ÕbG‚¶+‰ì¯¢û“ÝñP©p›2`~w1M4ÍR!h˜Œ8ys¯‘ÔΑSßJR¥Š2'ìm]KN{€ ‡q¥\$TŠª’CnRMñ ¾(ßf‘V4)@L¢•#cל; ñ‹õ*Ÿ€eÐ0[eK-¢s•žÕcÌSAbF[ ߇?#÷5¢]n—¯ÑˆÆÈÇ]Kñn5ô}[mi­.°m/`—-,R’öh|W‡Cµ£{òÆ{ž‹idV½m'<)±î÷;U‚G¡@LšR(IU%šQK!~òÖoÿº/ÿȦ˙ ER ½ >‰P9 •˜Fvèƒþ‹^ÌF];E6´(ËT-«­\w½ ®cDAµ÷CCÓ.Í”FÙÙôpï?WÒ‹1¦ÆÕ·öÆ…®ÍŸmˆ…7i>°3Å[Ú8žG_ oX×æÖ.‰æ$ÖùéÁÝ^FæG=--Ɔ€d^ôº¢û]…£ÛèQéi÷n;Æð^¥!w"oQ¤9\|¡Š‚2…]9ížÌ—õää¯øÏýÝÿj>yqOªÄn}© 2oÓ»™n'o?e¹H×#Že.S}f¨\ÍuÞñŸúkñÿÞßÿàŸýÒ½Ó³Ãñ¨…¤ÂÝþnü´íhã’×»û=>‰M 0LvÖX¡ Œ$Ä™M„«¿uX.µ°ê¥I)Íœlú?ž/‡ÜWÚ£ƒV„´¦·–­ûk\Ä7¦¸OŽý»®ß˜L…a0w¯•HáuÆŠ›úgø óH5ÏðÿŸ½ÖnßÒ‚°ç¿9ßw­õ]öíœÓ§»iº[ºihZE $*xÁRŒ’„¨1…FomE‹X˪$•˜˜ŠÑhƒs¡Ä.B A”– €DEº9Ýç¶÷þ®ëòÎùOþcüæ|×úöéÓú즾Yç|{­wÍw^~—1ž1Æ3Æ(7ñÙ8Ü÷Låë<ˆ8ƒ_Y'¦Öþý*æÞŒÜ÷ãÆêÚGŽ#ðл\Ùʲèߥ{všƒ÷/,ÆÍ5¤u‰õ¶óö°]DaÓÜÑ!k<° KÜŸøð—r<ïÚoŸk‚qå{{€ÛUîk°¡5<ÇÿÁIûñÚŽ²=wÏ?N\i¼¡W÷> ó™ÛøüØn •Þ#x¾IìÞF¹54ucœ`ñKG—ˆž|½|÷1?ûÓ~ý?ñOJïy¶ßs¾=þì?†ðv_ÇŽ}pö6–óF°FuïœþÔé«¿û¿üþŽ¿î¯òž|Y—Õa0„o*DJfÂcnÓMJm í>ק†vˆß9°ÚÀÖÛž˜€´y†;f°G¾â(ö»ƒžõµ3øª!µ¡èL% í¥ÈÌ&:.Ȥ1*ãú¡å½ÂïgÀÛ8l÷ /Tëú-èº ùø¡ U†Fø›;50Îép4¸;_k7ðùq4Þ½Ò ìž|˜7[á©5ßuèm²Ï¦Gð=_ƒ_¾}ÿdÙXªÀFŽun‹÷­¥Ú½ƒ¸Óâ“÷öäÃëçâK_}5HF8Le~`;èf„]«b^eft×Õ;ÍÚÝÝÝëW¯ÙÝæy^ûÂÈ»µ=Œ’)nl: ].—íÒ>û-ï–%ÔÄÖzf®\r¤;¦fêý‚|dÓän«šqÍ,èÒ|€\Ó4ÝÜÞºãâp8L‡»»;6öµ+J›Æª|Xîú‚«ö %¹F³¨2‡á%­aAærZûøãÛ´®žéDˆ…-¹Ì ”lí´ëe9\/46Óe[%C° ¾}­†ñƒö'Þ_X÷oÚ±uÞ§Â9ê<»"Üñ̪ßЯÜ7첿ָôîzx¿í–sZe–IDš¯@½;É»n4\¢VwãÁO~u99àòÈB9´ãº.6Ÿ„«¹=â駴ëÿÎ_þ½óË/?ÿ¾cž îòæÀIM¤gæ-UjQ)Ò‘6ÄÏ‹À®\)Ò:¨ï”ì,u°áÖîbSmØ­®!wšÁ÷è3þdg(ü›ÍŒ‡¾)Ü™o@Œ®±télŒð݆ì5˜‘ßܤÿ½ Û4ìùï#óÆÕšfÇ6bç9CÛ7UÊh¯ÏžîÞ…ó%ÔŒLŽIkÓtù‡oúÒ«ë®÷•ôÊ‘52i„ñØ{—ÑHïn´Ó²8úa>´ËvýüÆ4I>O“¦Ý$&}N¦Ip”eiôµßupܼ†Æ¢•P2h8{ûºÚ4dmr#›šò[V0©IxüäêææöÅÍóɦ«‹Gf<ÌG¶æ}-]Ã’¤LÐ6ïEDDÔaçó«Ñ–¿º°®Ý&:9Í!¢1ñøÑ Œf´y›ažZ"/Äi¶­£Ìw3_÷ÞVží\j‹ÎäǶèëFiåý°­ÕýÊÚ°Ñ›aè"§1„¡P€¬®<¾@ óeàöË>Z„›´ÿX£MÆQ÷ q˜ˆòU‘ÐÒìÐfºZ‹å‡S?­Z/Ž——Óáb¡Žýîó~û·ýÒ¿ôÊ_>춦©HZÄx—t¹ýÞ:(Úú&|UBL»]8&ãNÔö¥{b#DÍÙèUZ—P<ú˜;G›g›ñû™ ÚFvÙ:o[l¬Ò1Y6Þ‚ÁdT^Ç^ _ˆÕ„™^«í¶ûÇÄÙº ß¯¤Ýø}]Çþ准ðàZ÷n”Êfÿ\okÜûu§?pü}woîÖw=j=䦦•K±¶,‘æ¡1ʲW2É{C{z…¦Ž÷ÿÕû?ÿ­ÿéÇËá]ÑB|½é½~<ëíñuo«ýx{£òã÷NM³Ý¢Y¿ðçÿܯý‹»çOçæ'É(÷ÖšzÖ-ªýÍ^hÇÝ#ÒŠJûæ Ù…¯wRl7RU©„èƒ9x°Œmç¼Ùi?ž_|•‡³(eßסGKhç`rS´™Ñ*ÉÝ64¢CŽFÑ51U:JàJEY©—ÍñÚ3b+௬=§(þD‘¤&a¾g ÜÓ cÀ7–ÅñÃsFÆÝNå}èB‘vöL½HÌ_ÜŸù ý‡_ü¬÷¥‹×U.ª›Ã@ÑP¸rKF)]½@@}ýÔ_¼¼žÐࣿX Ê ‰`à@©›eNA+úûŸÏ®ÚùkÓr¶7 18ÑÑÌ+ŸÎ—³HwÏ¿ø¶Ê2ffÓõÍí«Û›ÆÉl:æÖlj=bTò\H^ÅÉ{DŸMOúØ0øC 1úæÜÜž^¿¼Uæ*€g»Ji¹Ô¦?ùůÜÞz¬Õj8[ÿvΰIJ“Ú€÷„Æ9½éû÷mØûZþÚçk@ƒMÒUêl$bºÂ…¿ûâ^—øÛ‰+ÕÓÕCbxVb%‰Íæy‚YÔé—VwwbžæTT±¥Éhì¾Â´ú‰ÇËËÃåe›'¿»˜íÑó/üòïýüw}ëã9\m¼8.0Ûcç|͇Ñù m­õöJØÿç|&ÓÏ'ù| 6"ÕÞ.ʤ¾5žT*Ἃ[f®ü(dÎâ”c(^›¨ŽÊ - ªÔè@ú¦ñJòb^³èû{™W·=í0õ‡TÍÙ¿§í?á(Ë4õfIÒýõ±×¿ñh|âø“B]÷æEgß{LÞüçOzŸÝ®à›N‹A*¸¿ÓGJ†g¨cØá¢Ø(¤µŸ¦¹ËæµÿËyô+ÿ‘ßüúðÍ&²ÑÜÄ=ºx{ü™9„{=çÀ½1çÃUôöØŽ½PýºVëù'œ2@½ó0Ÿ~Æg.í¯þUÇW_¾0ë«8;.k=qó0òj–uJðÔŒ }ÌݧH˜îœò³•‚;‹ ïï¢=Ù´vEÿQrJRø++°0xÌù× ëªýÓVH4_@¹lG2F qǪ òø™¬ê†©Dc®‚tw«ÞU[å&ž—oØ™–HÂÌê}wéŠØFÍØŽ;w½ÃÜ “kE!ѧif˜|©o’ Ò5’ºK&Ìð­nM ,ᯓUÜ‘ˆ> F»¯NŠ)°Á÷Aš1´U­ˆp'ÖÀ~ÙæosmØ Yü!Ð%kµÀ;Ìd"WSoÓ‡ºýáëVréNïXd½Ó™£  pêÉ]F;-½‘wËéæÕÝ„Inq¶œ{ƒœ°ðâSèìÜÝW×Å»‡ÇŸy*t‚ÙcY°øb A)y#!X×ãéxɹù:ֺà¦Y,ÝõüùKg3šA®æÖËE](£yïÖ ¾! ‡,p6¸fHÍlõž‹Dìãç/–=Þ:ÊÌïz„mvØ}ù«··ÝË‹_Ë ä€,û‚è;ıSx.wŸm"bÈŸuÊ—ù&Ô3žÄ~uæýÊG"ÌÇg‹1>¸VÝ. 4KV+¤M¶Þ"¦yšÚ"‹xúâÞ­5¶f´Ø×’›÷nÖÄ~òŸº¼¼|ôD°ÕüâØÚ‹¾÷ƒÓ_ýs¾ÅtâL…Ùé»GÌÿúxþ—5X›»àpò1™úµmA@IIDAT7~¦Üv"4ÏMvŒÓrÞ§ámÌGØËš´[Éqoå¯B¸]‚–qq:í8¡‘éKN¥&e?yJ¨lIž¶Dm[ ¥·›åAéªÇÆ',‰mÕ³0"oCç^Ï”z½ú™%'œ²›°1/e–«u#®jP‰ÎfkÌò=Ô~ö&÷ÑÊþ„!÷ËIW¼Ü8S»”Çñ^‰;Pâ$䂬±´ƒ2ë·ëáÎ~Êßú÷ÿ+ÿÅ‹NÖ&Xð½BÕîkP½=þŒo4¦{g¼=~¬c¿.þðc|s÷ ƒœê$'7°/‡?üÃÿ[ÿÞüÉO®1±;šMK_­eò*.ˆÌSôÀj$ßv©êro&³Až! ¯J¢¡6­ÇÈ•4š¢®§€ Tã§Ý{ €;ö:µ _ L°ÙQÀ´Ê¡œ Lž5ü1%ÜG´Lª4Dõ#=D뮨„\)¿*ý®Ðü(™—‰ovïEXÏÇÇ.Éîù¨#")Qx(õ šÈºMfëÍjÞ'4u@lÖÖe±F£‰€UT# ‚Ðê68%w¢9£Ø%°º ¤pÏ,Õ´c¼t’¶!RyµöÜ9,ûO¥¿-„Ñz©´xhKSix¸˜–‡Ä­§„ä~È̸-Ô=M“» Ðû{Ó|:<úêéÚÚA“`n'iõÞ»ä袡5óx¿ÒÙŠf4ÆuíÖ ®ãñ®— f°5ÀG´‚l3,EQpNÖn^Ý=yŸ2 ·:ª¦Iá‹Á•¢­,Ù… ¤ñõzgs»l}%x¿’'¦®¥µÙˆ÷ß{úìÅËÛå4ÙáÃ^>¾º¼¼ºäX›™¼»÷fæQ^¶ô{ÄÖ¦¾sb¥¢;,ÏF¨»–¥K-*™˜™ÊMPÏVØ)Ójľƒ ©6ºû¼`™w û9úÇöCá‰\eXh·ÍÇ«íQ ÷·>ûá온±œ…‚Êëq&–Jn¸|d«ïU x–Š¢26ÀÆ|-ép8X³MRI] M0£MrµfŒpu¶É¹tùáòðø飹"*q€®n_½?½øÅß÷³µ¾Dkp7²«3qdÎsÉÏÀþôÝXܶc·ìFKe;Ħ8«ˆP¨=…½ ‘ʹY[»fh·4ÄE)#±ÖZÎ0`ļxu”ˆ9žÚh.zÇÚf³ãäì1#i÷Ä]¢xC©göi„€¡ÔZŸÚ «ôôçK¨JTá̆+>—7ËdÝûŽ°½6ca[(zé=—ÿ¶~ ko“]³«ñ— s«ô#J„oû¥Œ‡mQï6Ôþ߇ïýw{ˆR$eB@* WZ,ÁòÓ¹wƒ²‚›ÖÝ@o“ãˆGßñ¿îÿðÇW˜³‰lŽ(#¾E°ß7Îùt£þc?>Ðï›ÓP$„Œ4¹;.ßý¿åßù¾ïúüw<±ËÙ¢Qªe¦Tâ8÷-Âî%]‰æ³™ÿEÁPz—móc‡ÞórˆŠì.BÝÙ¬%ÖOáÖI=ÀßvïÜ0K®ÓÀ"BÞÒ=ôK [a'Õ—XÕæw‰Âùíƒz?„f(‚øÆ®,̈ZÔKØD¥túíÇ Ú?Ùô"’¤[)k„à6‘Ì2Hý¦ ˜ä=\ÿ.t÷ÖÈ6Zk‰¢­(R1~‚¡…š2ÔM²sŠ‡ lÁuá›ÒIH½5.ˆ ý¤–‰¯ŒI— «ÌÙR2ün —š¦¡¬| 1v ÉõÄÊh&G\öPÒ½æòé²øKôÅ!›íNh½Ÿ–;w'ÑWÙb–ÕCÓçâa>Åi9]^]¡¿î'—rFœ^`i@œMÏa(`G_œ‡ÍVIE*e‡‹Ú3A~P˜jù ^û©µÃ¡¶´§¬Ysu‘.^0.à¾ê^“ž/êÝÖü:ZøÚ](Íã˜s§ÿfõ ‰7TP€ƒæÖº]¬ÇþÕüÏþ?ø•_¼`Ý­Ow³ñþY?Þæ|cŽ{’„9n=º´w¯¿øëí?ruzÝ\«±©{ f— <S{Ïä&±vÄDQÞ<ØX<û±.²„æ.ÞN{ƒ&NHÐeÇá)Ëd7‡Oêâ½râÀ:ûûÕé‰Õ·ì9\ú2åp$OcsbÔùUy<ƒRë¬:)ÕdÌsw/ øª'y5@Ç›šs¡Œ°åÚO7ÞxlÞÜ ònéN˜?M­µ±ÑÊYôÁN^‰T (m^L³ó â²Û©€OØÅgká1#ç}7Ë[¬f|Ó=h ;6÷vÚ^¹KºÍ@ë¡ î¸¥~äÕÇw†%Ì”ŽÆÈžðë»W€›<»oEJ@ŒEVZ]:f;<þÒ» Ñé‡ÈX V.ÞðQ”`2X—_|æòÑÓ ERƒG¬`@´|y…ÃQͪjЦëŠÓ›ZE¨„ÌXèiUZÏê(‘ŸÀ×7·××'r¥µƒzòøò0Ϥ\køIÏÍsæ3þ{ª,¯˜e“ôâåëۻxÁ“‡;½ƒ?ü¥î‡®Î$Ié¾I7Ü_;oúü5ønË—‘É7ñðdŒMËó‚¸Ý¢Ü;€J2N|µ=`DÆK³æie)®bGŠt¹M6MS›Z¯Ú÷ëÚó[Íç é#èì.o³Ý-wï½ÿþtœ æ:i}B¯ü‹¾óÑÏþ¶÷—›—ÇËûH‘/´{¯Ý»hZÉõóÝxþ¥‡#¿ÛßzÃ’Øgd(ïp¾ÛïùùåS^hˆã§žÁeÕÂÕÅG ·Þ­OÇÆy’õʦÉWH$ª¼mrÚ4®(ÛifVË ³Åš•ÖKBØëÀó·~Ó€ŒõE‹~ÏWu‘„Þ¤†·ïŸm l1êýÃnƒ»ßû_Qçì~Þžh̲vp§Ý¶žÕÌMFUTR.`ßê «‚'£°[ }µâ¶†yzåWôËþ¶øW^ã[ÕhfBóŠê¼YÚ¼=þŒg‹Rxk|£Ž³K&)¦Câ#»û¾oyï×üª_é×^Ž§»•J@ËeÍÜÃ;µÉÁ‡Çù5öøÑ÷N| Þ¬TR@†ÌM‘.1³ÕêåÎd®&žË²wNÀ¿3fxl÷6\ûuíMÔmpa'×ÏÕà ΄~ ¯7Ød7ÁZ) Ðl"Å.tSëîýÖo_÷ SsôÖ,Zxº{˜;€“`ãÔŒdäA=˜ôFæ|¹ô«Òh ñZºõî^Fñàù…1‰]J–÷«N:_CgkfüñkÉŒû»XD„èWvX¯úúå»W·ìI²f„¿ÜÄ~Zo6Yšîòêæîî=Û—ö®†ÃË—/°W˜¤Ø¡ÂwÚâÌdøôýBŸùÜ°È ˆ÷:ÈÍÌÕ-÷$‰¨Qƒ¿;aTö~Ê ¿wUü-°ˆÃ!{}³ÜÞTa«µ÷y²'®¦©[åZkî´D7<3ãߊfñ㟟Öâ¬ïæ¢A|ƒ„:ùC_üðnÙZŠçÎùdî:Þƒ» õugWdøüï]û“UQ¼ª¬˜úP~öV»‹<ÑýýM²ãi$C# œšæyšg0)™Ý{,ÇÖ&‘ÍÚD)ïœäp§Þÿàƒø.Â&°ëôt¾ùi‡—Í÷n^M¬~×ZÄ™èèVÞÓ3ضMBzß8&;¢ù>ýT›ßú$mòFCàlã× oóº ð„ ñõX)®Ñ£1 ‡€ðNnÎKÃÅÓº3¨/öéF»‰‡uFœRŽñ/ÓÛ&ž)»4[FLõ¦ásòô$ì¾ñ&$ÏÝú9[Egc­³;cCûûOþþ‰{ãÞ³ÝO¼éùw3‹BˆñF‘ª ³ðrlvi,qíhy!yŒát¼3ÞµŸö7üÿÌŸºý\× ª>ùEÞfŽRàmÐo̱_æ!ÂD·&_qÝÿÉŸøÊ¿ý{ÿó¿ú/üžë×/ó$?¹³hë4³¾v3ë•Éú¦ë£bhI·MËÀ†w¥àNåñÇq¦ Ñ|èXXo¨Q¨ý-ïY÷›||%jdÆ B—ßì!Ð8-.³ëºÁûdE^GÝì> ÿÓ‘f"8–#DìPfª6±Äì©ä€{·f®nÇvt»¹¾›xh²¾:r™5¹[àB‡ºß±‡j³fmš GÖ¿wP–ÕïX¤gŽ'µ l>_ JÄlò|¸ó´¡­R÷[H!‹ßlËýØ ‡1Ü?õl6ˆ=dEÒ}ì|Šœ %¯æãÕz»¸/a•«w“Ä©æGó“×ׯ XDžYÔ©8Œî/õËÇ^¿zml(Œär² ŠæÚ*-i§Ó»Pc&t‹‡ ö íƒ5Þõõ““C´×멵#åFRE!hQÆ7Øq:Ñ?º0ðÕÍkrZk«ðÑóW‡yzüèjšlñN³[{˜ gDÒ…5“Q@kײ:Ù6Ò3´GôƒÆ¶Y#:›µ œOåׂ!Ú3NÎì¾ûƒcÄ‹Ÿv~™í?#„8 ãê|’ÏcðŒ/žÎdÃÞ àö Ä GvˆŒœ÷â•·–û £Ñ&š¬Ö;'Þ-·ž<~ôäaÍŠR¤9–GÓúäú«¿äü¬Ûëž\Õ»‘ê‚Á]Ö6ß¾ösÀó¡õ¾4¦¾Fñþh× î>:›‹mlv–:ÁŽRƒ¯mDwƒ]?TÜFµ„Ë÷_ì |Hápº£·cÓD˜„žÚ±v½võ˜,30†æ4¿ióÞ׶ùó½˜ÓÆõÙ‚©ø¬T†eR½v§  ÐD Þ “ÑéŽv˜o¼ø¶ÿÅ?õ[~äúÉÊ:Ð ý­y{üY:ÞŸ‚c'qÚ¤»;ŸOþùßôo}çOýŸüyï]¸ŸˆÆfîÝÐ_½7kÝ=“™5:âZñí¼I*mÊΑ„²ˆ%…â2ÅF?³Êï˨R•"•õ¬êþNDâžoN{1úàÐJ›RÜýõL³odÐfÆ#§3¯èv´ŠlO.¢‡L£è¥ôšÃ›™M A³ŠFHEK¸›óÂ.Útûú:¤È ÀÂÜ3jll²oQW_dF›ZÕ„CrOëe³„ÎRôòõYÖNi Km0Âw¶T±8±MnýE¥·Á-Å:îwW±²Mj æ$c6@Ûhfæzïòéí«-r3aUEÇåÕåétòî³5mÅ,:[Õ ;hkïm>‡ÓÍÒ¬Aî]Í,cÓõtµ8T8ïnO‡GsL¿±u­–Œ›6RT~Ü‚4b”ïÜ_c½œæ`x#f9ùQà"—qèÑîËÅÕ3_¼|ÉfJ›O‹øìåñ0=yô¤ëº6N’‹.y³&õÜP.ŒŽQŽÓéD²§í^›zg¢%Q¾ƒ†¡°ã íã>Ÿˆç÷Äý†ÜoÌ7*ô3Qð {}á½üÙrŒ7ð!žqþÎÊ8gúa#´Õ;o"l{ LÖrûgƒ7‡ÏÓÁ’ó{;è&™`"(ylêÞ?ó™Ïr¶î§d•FX?=:ª½þè¯ýEßg7_]Ìër< šI=üçÍñÖqêì]ÏF*ÿž³¾ôÐƽM}>È»èÁ~oò|@üüð ›ê &~õbc¦#g+é.«GÊ&bLvÑ4¹“e©Çýœ`Uu*!T & ê«ËêI¢?cš3f§"[!·@Ñsp&Îrý‘á ]p¯†{ïJSmÊ áÇ<Õ|ÞgïÊʆo¶çÖ¹Üͧ=³ÌÆÕ¿çŠuÌÜùnö6ôUfþãgFb‰ÐBd£åwcjÙÝÁHÍZ›M˜]ïþöÿ‡ðwý°_}3$Â>©êÿÛã'æx[ô ˜D‚tuô•ÇÉßÑõ?ókþA{õÑ£¹9HÓÚ3¹2ÝŒgzlÐdÏ2d»$ÈMd¥Ðä½g6¤»K;¸î¾öµC€õµÛáîz½»¹‹Çéëj­…§=Xˆ€É óÕüÎgÞu¬ [‹î.Ëiƒˆ…2bÏHx£i]ŸŽG%Ë Fð PfÜÖUÏž¿ˆP”¾5É!?O=1xÇ‚¶HÑÂb©6Ì.déC¶>~ÖW¬aåŸÎÜÐÆÉ"´ü¡/~õvÙqâùöîÝH,k_ï±EðÞ|üi(—‡ûsÜŒƒ+) {GÄ™ .ÊÞçºßèÚ9ÿsÊ'@´C›¦)þ+û‡ïÙhF“À™+ú4µ§ï¼C#ØS^p_/Í/ï>þùßýÞÏþÖǸFXäûfhÚ%#i<á™»}Ï÷o´;ñ!ÿlìvQAª8Ò¸òÙâ ›9©qbÞCtx ¢ZL¾ —Ñz÷dÅDÕ3‚»‘‘ã$ë}z4¯Sdûô<ªe¬z„ÝB8›¥-„QM~¿@€ˆ’Õ¤ÌÃ’ŠœWŠUHj–©ÄÆsokf‚í‡øœFXyü³‹Ü[ÔãÓTauzܸÔßîùðŒûT¥ 8ˆÜ¼‡ÜIÅ” < ‹€ÌÐ’™Ø\NȺc>Üéê 7ïÿòÿñ?·^}çi•MÍ=ôÙCðöø3h¹ÝgoË€~ãò?aѬIÐÉíC·ßðÿøÁàoù›î®?š¨¾@­¹|¦É»Šš‡±}%¿¥NûUäì’ƒµqY¨tùì²r@aϧPßÛ†ùRÉŠñZ:ƒKtŒGHämn½ÍÕ0äqþ¢$CEÅI'Öˆ@Žr&*âKzz9®É8Ÿ9íD´(—dl^ _‡‰*H]><[H37¨M8YQn3 8ç+wv6]>¾¸~}ëh“LÛM”sz¹¡kl€ÁÕ½¯kem uµi²ð8²%0QrNA¨ØÝ ×˜¶ ½ÝX×ÏûP1õÍ•\ó@ówöÁá“ mK¥¬z:㶾>™/o–ÓK]ßI.M ³æåΧy²éæúõq¾˜šu_Ãd1kMÖ È­X—s_û²,tLÓÔ½[Er”%ÂhêrÃtw{C¼A¦Òªa´f¯Ò1Ø&¬†ÖrXk¯×»6]ÍÆîË] ÒÞ0G¥ˆ*¢j|÷Ýwž½xî„yš¬ Úéä_¹ûèêòâêêòEK£u§QÜFBð¸{_c§Öt¤: # R;i°îª:¢&·ô;ÏÎþ„éMPxIì{H„çÿœÝùü;GÅî?Û/Á +°6BV%Þ-VrÇ&TVÍØÐà}©L>JıÍfÖ½“‘ý…lRBœçvç·ÇËããÇO8$uQ€¡¾®yá·ßþ.~ÎO}Ÿ7µƒu©»¬QÑÙCi£‰gÙZñì;ËýÞ¨êü‡M–ì½ûoùn=Öü†ˆ°Üù[“æ|˜pÜb¬ ÃàQFËs¯è_ºa"OÉ ~ì|à´Ò+t(§ÚÅÔ'9=ü\ùºbÊ· â­·$fRKœŒ(ö¦®b D?˜E0ÈE¾U+J.Pž_Þ“3÷ýȲ²¶¤âq·½™’3”H¹}~,û¸.WO_Ä°m©Züõkå÷7ؽ¿êÁ9Ã+'@â&1,Z:Œ0E¼jz8Zn°`1§Õ¦ÃñÄã2ó¯ýuÿr¿úÖÛ­Yï¡üÇãQx{üéoå· oü1$Gh]‰˜\‹czü»ÿÐýÞŸùÇ~ñÏþ6õ×ÖÜd­f ³J=ªúUû·:'*×;KMæ†Q#îTbnè3'ñYÄpS*g6TäÎ:エ˜f£ÖÊöeu$y“ÅÐ@8FóÛÕ{þb’_R/ÈÖ&»^n^üúêr~tõH} Ô|Z®làöî.¶‰»ÓÌUv\.WvdËÓBÁK´Q?'ÿ¼óôomÇYxfùèÿá2;k(‹B\2%œc‡Ã£ÇúÞ6†E!²óÏœî‡):-ƒ–.jµuºœ×Y2Œ]í¸×´•xßš]¹vUëk“=»˜DÑÑcÅÄôÛ[—@Eˆ·ý?ïÖh¼_)£Í‰­¡ss 3öl½í¦a屆ˆå€Âx©²f5ò/¾‹®´épß.`^y£›aLQåAá痢Ö‹)% ­áÈ—õ•NïÖ‰épÛç»Ã7ýïþ¥ßõŸüˆ/˜Ø@ÚΙ²‡7=ñÛãÏÊ!àm OÍQ˜`!×jSköúÃòþ»?wX®wÜÍJQM2ýß,ÜÍl“O›¶€Á ï gäUì;Šτ̈6–(Ÿ_õM䆨gîK«ftϸÇ}päáAìrg_€¤ï°EIM)P5DD ³ñ$QW2B eE@7!µHË÷uK༡—lX!Ò‚zZ'Ðéèœúq¹Y—»u¶9½Œå$[=¸.B¿Z¸"ˤ€'ž"Ù&k“‰ì æE Ñ‹ˆµ<6,¬¡Ð)d¯P¥P‹b¨   UÈP¨¨`ËN»`ý÷ÆéÓ¼2À @t¢‰î'¬wÄ^~x"Õ˹|Lœ4tMœ®¯_7kÈìðÞÀµ÷uí‹/fSwŸ8kÕ³_ÚÜûÉd@ 72¨îÞŒ+õøÝÇ—/hèÌòÿgÿ5^q(ãh!¬—Ó“ÃÕÁh«(pûŒTSV‚Q2ï¦gÏŸwwô`úeö4Nð“¨'WŽó‘p©G#dh /^¼\Wt¹’ìl—Cr Èdî´þÒ‡7wÙ¦g‡Yðµ½WúŽ³mú¦ïýék]èððåYHÉPœ½a½Ä/5 %_¢›„ŠÄ œÖaªÉé$/..ÐRSŽ`Ú%}Åiž–~÷èéã‹ã‘ €¹ûÜlíëd-‚‡6M¯äWü¢où¦Ãí¡²Jš!ûZ”Í•™¸‹ÏÏú†!Óþ?<ÿ›^/S`Ç*­Ÿï²pRŒŒ¸ÊF¦IBR À`X‚PÒ+ÝÁóWQsLÑVˆxÈh(ÕM|Ô|^×(Vå JÝŒ'Ü-›³ÈHÏ6?|I¥Ò"JMµÓñ\ÖO‰ñ°d: dáÑ”!µÊP„¡µûËp»*v'—jÕ^œžáŒ9B6â6ï;MCyïÎBF™±´Š7<#÷ÏË †[†5(Q0-„äÙ~´b·›9#°Åru}ñ‹éÂùä¹Ï¿ïéïÿ_ÿ§‹Ïª7’aÞY6îøä¡{{üÙ=ôÖøÆûAÎ}%X#ÝO+/fÿ`zõOÿ#?ÀÏM„ºš€VÆ»\´ðúG”Ÿ±ìeúÞÇ€Bia‚{ù×Äã†S Ø•çèE§!ËŽ¡ñ‡ÍÂߪY‚éÝ[«Ø:„t³1p&³‚*rw'=óƒ,ÐÑ£)„ša°HÇ[éðqúø\[B°\ Èéˆè‘€7à¯[8kCÈƸEÅ~vœ—‚Ø'·ðdÉZŸú-o®o'ΆFfúo#»û óÓ…,þ3Tq¾l’žgofó<‹²¨DÄžü•,´KâÀ†@sµ`Œ2ep¸!Pà Ü+¤–ºÕÆ4b›ô3Œ6¦3jøõyŽ>ÒB(´(¿ßÀ®.óU|Ù×/¿z¶ZΗà Ë$ ØÛÌéÅõ3£nFÀ{ww¬Z—Õ­59&´õ¶¿~ùÚ@*CD9á ^ÿ#ÞÿÜ+(+ Ð@ÄÁQÙ}cÇ樘9úÔ§†>ÃOsôöÉFu(ŒµY\ðè3n4_AL={Ö=‚"±‰#À#›µu½›Útu1ø fu0ž}ô œ¢+› uÔ®;‰AË|…ý©/}õv©^#¶ûÇ°o»Ûéc‹FxýY¾€¡âÞuÞu‰Ø¿{ÿÅXÙÉäñ ~†bS=B¸ÕÑ­iPפ"‡I’Ÿmž¨•¼¥rqÂÚקï¾7gÊÃpìãù5‘Ç»áO™Ñw¿Óo^³œB§²sjŒˆr%:‘‡Çn/î—á†õàôí“”€ÛFÍS|…aKå…‡î@úûƒ9ê€"ÔÂ$†?¨œMçóÊL¢7ÁW.n~xt±NRó’ÛŠãÎx©'Ù›äec` Œä䟆÷Ñí\»a‘ÊQ6ÞR„¤Nfp`ôZ<€  K¥Žù¦©Ú CþioNk÷ªgâåJ;ûê~~L€ϱ ð AfÐ~Ä ý Z)lªWÊEÞ«pZŒa@ÄÀ[{Ù/_Íßþ+þ®ú™>¿`bk^+dØBçƒòrþ„zKúÆç8$X7ZÓÒÛÜé7þÖÿ÷ßñ×þeËë'3Þeôs§YíËR²“•¯$ѨØóD!VÐ=è tO%d¸^Qšá°-½ŸÂ©¸÷ôÝ•$ä\ŒímÛ}Ê?”à]æçJ)‘oIC©Î/¥-’tV^‘r¯¼ýmªì£xú ¤¤ìÍX”˜Â*>œ¶Š9^‘%R(’”#³•a9`ܼkŽðøz·ó|qu¼}}šŽ4kèÞ›{w‘FX©'‚/”Ê)'õ ×ÍéDc›Ì&Y3dêXˆZÙ*|`ÁÑ,?q)ÑäÑĨnÎêJ÷ØØ÷ôÂ4ÙièÛ´>%E)Lžt«©éI“Ü:t4Øãvq;]=[oEJ=€®Ë§„•ËŠõêñ£»››u]'› ¡ÁHó©q¥àÀ¢åxuq·Üø¢è~‘I‰\²àu­ËÚ»Ô"þ×Ê åÉÞÉ¡m•Ë½ØDî4v.PƒëzYÏêkt>Ö†„Â* ¢˜©¼ˆr±Ùº,ï¾óôÙËg½;”ö›ÑºÆÓiç¹wu}{wZž<ºBR‹tZ»+Wã ûC°ÄÅ̲¡)ΘÒzˆk"ÇtÝÿCaþ\:;«®œV¹2ð×v6vv¤Wy”{&Ê®ÝðaŠÏÜàb¹ìÁýÙz0×¢¶ê90Ô¬ÍÓ<ª‡¥„Œ°”cšæEwï¿ÿ>&£‰ž@Í»ÏFWTÏô‹Ãé›®^þÅ?ýgú‹¯Ž‡åÔ›mÊä¬Y ³¤ëíŽAÁ6YñÞ{ÐT”¦׫/oŽüšm þø°Ùw  e7j_暇§Ç!wÜŸ<¢hrÀâÄÍ[FJü I莎 ó£Ãb‹¢,rMŸob'®µ9h2Ì0$xÛÌŽùö±‡©«ÝP”ÁdµV”˜^06ï^ H&)³þöJk?/5Y[VÁnšÆ(×’Çî—mâP.™áDKÅ÷`Þ»´]ø¯NûŸb’ÌÑ÷~Qe/jÇ+‹µh‚ÍW¹‘pb;<ýÖ_ó?ûW^ò3+"³% uq?”øýÿ„o €OñwE¨šRpkÀÒÛáßòþÁïýîïùÙßòNd–M–¥›£Žä@pi—Rß«AÝÎ]·ó:„#{“†ãkrq@þ”s¡ J¦BÃk5¬\,õʪKÆগXæŠ'Î-©]PSª[°â¶U½³,gu8ü˜|¡@ŒFË—aJ–RÛÔêÆ|Ò0\èͦ^Œõêr2dÉÆš?máí1øa (ÿÂáDÚE›¯_Þ4L ³:É©w§I\½ èyU£#8ëì­5 }ñ¾È6µÖf› t·æ»ð ƒ#>°Aê÷(6‡| ¢FµŠÍu³áŽ²Ü°%“¦ùP7õÝ'9V&tEú$uCä0˜ƒN˜úûWO¯O¯´BôpŠ³¹»ÑW‰&‡Ÿ¤vœÛ4ÝÜ^OS Ûf«wGŸšÝ­7ï¼÷ÎÇ_úu©dY‚Á:”ÃÂvss{ñèP°¬…æ©…‚²bIê>²VžÝÝW'Ú©ûÉúLëžæ F0a#oKb¯UärÎPïï>}ïãgw:ÑP¶Æºv6žújF—®¯|ôìÑåÕažšµ»»[w‰Vœ¤…Ü™ÌZÔÛ´zUŒ1ßW -uïØMø9×øÏÞØ>Û¾ñÇñû‰ (²¯æyïž;JØz»(æv¶dg0¤ pf)OÁód`z¶¸°eš/:}ðÞnDþ mJ ¯Ç5¨Ç­_ü©_öK¾o}õ•ùÒz¬@¹<\)åEVí£Æ–È<¥ïîJ< ÷GeŒ¸j„X]cbSznà2§Êl@ ­ê±H—GòîÞd¬DdvLÈ\Eàæå°†sø«Íj—ó©‰- ›ùCó ›ÈÖr(sŽ¨”‰!Š««XÉùMRgøœ[„yø5òâ(ª†ÝèXƒ6¼KyúžzrÞãøÍǵ õ¶¾¥ŠŽ•ÉíÁÎPø¶Âk€Ë}2r²6w|-uÝ¿PݘCçŽ½Ï p 5¾kJ…èl#gyo²|vY'¬Ð ‘v'zмk6·£½îOÿõßò~ï¿Yí=LŒôq$·ÊÞ bÞ?±Ç[ ЧîÐù„N+çÉŽ×þúì.ïž_N&wØÔ}µÄèÛ7b‘}øˆ s Bh…‡[S° Øÿ^ßûáÊZØà³m¶7D6) ”K•¼îsn?wß ˆ™ ©#мw%?gw)’´îꨅãùóië÷4š S*Fº‘4´'ŒHÆú€|…¢Ì X矿QbC‘ƒ0_@·Ó«Å|jj€Îƶr‰@O0ÁËqí«°¾b²4dÜC ªÂÌÔÚt&ÓÊ|ƒMú—¨–ÊÖS‹¦ ÙÀþx¹,¤·­ˆñ/j¦†ª-2+¹NS’¥pgo ‘X’$¯ûÝ^?[\.မ|¥Áìm‰ïno&X#´ àâ½{ﾶ¹ùÉ/ìâ‹_úâ4]híÁƒ¯LDg&k¸Ð{¼'u31¹:ÏOÔÐÕXŒ×v9[Åœœ ˜„'ó%¼ÛF+ëŒd±É@F³Ø¼¦w¨£ÙüìÙ³îݼyksfäÝ]skë²çé8_ßÜz_=z””‰M,ÉhòÌ¡ö…¯||}×QC‘ŒÚy˜ßpTd÷>Ýá®OúîFWà@zx‹ÝJÃØb@š2ÛYá™7Ž¯Hr÷mëûŸ$BæÔ³»Hvù|<œ–;fsŒ tvyu1z®å½ Ys¬Oßy§5ƒe{¹fTÔÁ …phíòÕ—ù÷ëç//}mÌ"D£Ý8²>¨Æ#õÍpD“ñô¦?¡¤³öJà ÃÂÖ{Ô‰Þ3cc$Ï'úì bCK/=fIýZ9ãU†æ«÷fŒZ`Q@ÉÙq0^µµ-j@¶^ˆ§öó´Ôñ:Ü­‰DíU!ôþª5†ñ`'vGÙ½Å\©%Å°5Özš5€3K5xÙK‰úGĽÄù3©’€i›»Š?×ÃjÜ õª5,;k=Ïg½Á×>R¾Ž­›}oju‡ªÄf0Á(D¥ÿ]€?ÿ©1É”1OÆšL"9f¾\ç?öòý¿ùþ/~õS–Õ›MÑõ!ôõ›ãŒoŸÐãÇÊx{|CŽ’¡Ü;¨Æ~óÓ?ÿäŸøÕ¿jyö• §ݽz*íp~ú%7!AB ¶±p&”rOïÑ]jT ƒí„„ »ÒŸdOâd^˜dÑ"ìþ€Fʶ=6ã“͇4dxÝ Ü÷DÉ aY'!Ó±ÕSˆn\Œ§½¿æ€cÈ’úq‹Â±ÛØ%7X‡jÝ›––h†áqKb)%IvÇ¢tZŸo^ÞÉ1c +§wYÒp‚“ïêåÉ-¸åeAtïÍšàa˜F‹àXIYkÓº}ýÕ»ç+0òZrÂœ´€‘Û1aêËrº»¦ Øûê}u§OfZàÄG>khÞÝßä6ÁE¶y¾Õíç¾é›º-FDX$]¯›ñªZeµ’SlR·¤™[Çv¸°Ö̦—1h”.ø°ÌhÌÀÔ»7›>þøãÀïñt¹éÒŠkÌZ_O4óU#îg*—]Nž×ÃÇŠýá+í _þøæη50|*´Û·:ÿa·s6Œu_ì>ÂH»¢ÛÞ;¿À1¹·ÎáÿþF–!¥`¦+ï5,[ÓZe½[… ¡{4¦%y¤ÛW4Õþ‹¨`¥:’nŠ÷®nÕ«“VÙo2k$ÔR£0n½½>~çßø«Çýsë2±™`Òy{| Ž·9Ÿ¾£d¿Pað6Q«£]þáùÊoþ¿ç—ý%?w¯g²¯®frÒcJC•@Ü„IAÝê4x‰y7CîÆŠQSI{'DÂÀ $žAÕü‚”h}x›°$|9úË•Œªù){¥!Î\¥À4„zÙ HGÚî½Âõé#èzcÿŽ™†”³%ËxJ×K…°<¨2ÁØF1l«1ÆN‹§ç­^‡;Grpd̓Ø#‚¬¿××K_ztPlÍzïÁø¸ºÙT^Ì>zyôG…rt#Ùá,÷Tãì]nO'˜h6¬MFæ^üãá­Xü^CéÖa¤r*;ËÖ ³ºþnh€I»÷šÑŽî€±e‡¥*?*MÉq@ñŒ¾®ïŸÜ.w/u·x,n§&S Õä]´ æÛ¢ÕZ»¸|tZn&œ8»ºÀ‰“µ‹ËãÍ«S£¥RÏ S{ï>Ù|ss{¼šNTißÝÚÌD‚ÝN ¾¬§·Ìðy½ÜNÇG úXélõI´Î;“™ZÕñgw¿s÷Îfk_ßyçgÏŸGâÈÆ —àtº—umlîò-’£5yó$Õ cÄjfد€\¾íeN*°î¾ñ¶±-…AÓÛ+ò ‘ßWï;è¿CêQb%,0yç{D3L‚‘òðÚÎ>Ü°UtäŽ=«.øÅñL=Ï·f§Ñ;D9¤kæ+Ï|Fëž4KQ¤½óô LÑ”…lŽnʺ– kw^Nöd}ñ æOçõWئà?Ø.lÊ eV,tJÜ,ð°Í‚¿þ`üïý0V'+M|ìÓBŠ<ÿ½Üÿ¹ä]±bi-w=På1³ɾ™:RH¢ÎñÕF7ïÝ h6]µ…‹a¦¯)ZXl àÜŒ©•XÎã ×îtP½L~’ka¯ V£)®wC\?§,çx­åX¸ éƒRATìzÛKåK•éüdtµ „Ý”F‹šºÊ­—C»{تކAeH¥•—oÌέqÞ„tÄûúØìeÚ4÷ÒCbfÖ#’Ì¢¶,Ö¯>÷Oý ÿî3oéÍŒ• ïßÚŸ–ãÇ0îíÀ·ÇOÀÁ3 ¶7ØÔWŸïÿk¿õw~×·ÏÏøÌåª[E%°ˆ.Ì2ßBº¼ë$ÙB T€s¯?ÏeH ²¬ô¤P‰õ"wîhBö5’xÌÁFj?“%=Œ˜:O©·êå>X V¢ÏªöÚ¶Ù9÷ùvå©ø6Òé­úR½'•¹ËuU×ö¦)Ð3ÔZ1øT =|“$¢€c”'»-€¦«vz½ô® ‡u•™¹‹=PÖ5erA :²ä¾+Yí¢5¹+'—Y‹pîrÛïÜ[³ÖZ;Ì œ…,LŒŠ~"ÀoQ¤EŽšpI€±Ë­ÊÔPÌÒ:¤¢ ªÃ­2¢Î«æôÛ2#„Ã̈sC¸‡ª MdAé„"*FƒÃL"4óäLý”*“ûÇôbÃŽÍQÊqÄ%óïo• yíµTmXÕ–Ú$?¶HU¡Í7VeèEá†òÓå-)W›wM’Ú¼ÚôÚžþ–ßó§~óïþ6ÎÌiÃé`WïÛãx¼¥}ª±›Kе6É^}åÿðkþÁ‹åùå<û’8-¢êe°uGT! Ù³C3–5¿møºeA å]?Ή‘Q–‡+¡Ž”][þËMÑ;wË®ÎJR¤XÁ žð:#ž[ÐöLõ˜![(eØcó0jƒ5ãA1ÌŒl¥Š~Ç}™ZûA ›"ã6÷0Q>O!;Iv­±·õºû‰æîËd-ÿDGO5Bc+•Æe3G/Tª CÕXÖéál%æäÉmÖÚÜÚõuºè™<=^?-¡!)2”¼[tÛ$Šµ¬´&$&v…oijª¤…B1b–À¨Ð`D?bØ»ûjöCϾØg®.—·tšäž“#—ÌØÝ Í¨¯½ûÒ•Î[SÔ‰ZñìÃç"zæðŒkÑZk¼ãòÁg>+»³fåìßÁÄðïÖ8"&sz‚!ÒïN÷'‡«‰6&¡'<±XEALaW7Ê­I3ï9}Ï>z>M³–Q52“¤­;OnFƒàî­-j c­ ï´ùò³›»•Ìï­Õ±dï«íAÎÛŸóµŽ1ZN}xñ1®ãäñÛ0 ¶ç_Ž]®Xéì›·;dK,;F™%­êOŸ>½½»ƒÔ»G.ðÔìpœ§Ã”88Ù¬™ GOŸ€U» h›?B&’ùÁ8ß|å—~ï7ý´GýÈ“ƒ™}¯Ý³wvß{yùH«`_UÏGîMpjøŠkÜ8ìÃÆoaйw—zÈŽ2ùË´i”¡µ_3#P·Ct7’Žµ³Ûq•-¶Â€í™ÏZþó”xz°X¶)Œ{•vr´6ã5fä|pÇ×wÅèÆ]¶ú¡kÏ^-'¤`7Ó6î4.OÐœî`ncKoñÞü…¸ÜÆ·¢Óñ#wì¡\î­‡³ ×Ð2¸l Ni$ÓŒÁ¾„<_?_›ŒL/ÕG(®¥æ”&™ÑdÇWú·üMßoè¾­/éš,VÔ[àÓr¼Íø›ð‹¾t8Ö•ÇéôOæüïùUþúykæÞ™YYòWѤA¾?×3*m€Üföpþ98ÀéÉÙKy™á³ÍoPý\Úf_â^S½°"ÀbwS1¸ÞY£º˜Ÿ%®Só(™œ¥ÜÙ·x´ Ç ÀÈ(h1T”\ÚÐÎ圩'/™¯ð•oNß™Mµ×ö'†ñ÷†æPG'}^^ŸÖ[ìÈ@ ä2k®n´d3ôzëíáÂõèJ”µäMSx£”ZQŽÌÆ‹wVV'•5;œ]M} [G·1QRCåNØV9”DtGŽ•P±ƒ95·òOÕ0ÛלŲœxÍäîÂ5ü Ï¿Ügóˆ·ÕeÊçrd¯_½÷ˆvи®ýöú֧ɦuY­M×/_½zñº‰rÁ ÏÒ@Œ¤‹yZZÿìçÞïë"z­ÍxÔèÝ5Ðæ0ñv+r‡;µz_Öã4?¾¸˜!8Ó"f0Ê*fOÕ§ÖYšÜrïjœ¾úáLJéÐ}®ƒ ¹×N¤Ò   ߟ¦_VïuòG¾üñÍ]hb Ï}ÒQÎ{”Ù øÞ~VC‰œqì"o0±¡ˆýßÓ#P½´‰í&›h¨oˆ ›8üé;O¯on Yλípq‘P7.fèò÷ß{•·Fïf0¢‡oŸ$²f0ô¯¾ûòå/ýy?Í_>;Îrimf‘£Çön†Ê_m¸´âM0îÎ.Hgf×iZÖ)¶Sö‹ú¥,yÀ¼Á½0BîvT»Y¿hcÙrD›‡Ñs\tò¶òئ‹y5‡¡‚oUœ¸ÐåÅîgùüwjm<ÒÆÏÙ¾fúì›Õ:»–`Ò ×@ïжÆvõ¸Nž(lw?$?Ö@¨ÃN¹­àüFí}oNÔó—jE·Ísétèq¼äа»ÑÛÿ¦ãÆ>dL…ÒÐYµÿy6ìCÜyŽƒÀª"ÍÈ"0JÈxc ¾óoÿé<{ròÙ&š«Ï¹ñöø†÷Eî•ð@D¿=~‚ŽøÍP6ýhê:þѯ¾üÍÿþø7þâïï·/&»X»\}²&!q¿Vž ¤™êÇ AC`_£ÈzÉ”~‘˜š!e_8A¤˜p[ ²‘ ;¾jöúüœÄ†;'E‹™æ…*zÀÒ×%ÞC\¹|“¹ºz‡S¢°g"KÓÁ•]J¹ÕÓ‘¥"s•'a§-’\_ËÖ]hç‚ÌÜK´ía hÕew&ËÆÊŠÓÃíhÖ\Þ¹LÍ åú4Û,WÍZ4ðîhÖÝ#;|<®@tç$Àµd%o÷J›^{Â)¡Œ(ÃÊëåNmi‡Ö¦6µf¤S«;Ͳ¬Jª=¯yØ©àÅp'ö,IïdË\•ú65_Z‘Õ~ê¹´e£Çsz8Åâ]Kc‹ç‘ƒÆe9ÍS§Å?øgÿåï¿~~XyYrÝ· ÐØ ÜÛãÓp¼Mþ”;…00IN“÷emïü›¿ë÷ÏOÿßõÁe_V#Íì´.6M!였Z^¶ otÈÐhÉÃRgˆ–Ý‚4¼iب©aSF¤Y2L £haZ;ÝaŠ?†”/-XéZõþφKÑ&‰ÛSÕ÷ƒéèÄÜf¸Ç´å:duEËÒ¡R½ÕÈçËv@¤~,Á¾ÁXìÞÇHĨ& ÑEøUäÊŠñìí vº½›l^¤GIzkÖ]´æÙ’Êã2©8Àu)cD¦qN8@³Àåf“ûZ"¼q± ¹ßy?­ z›šM­MÍ+^¿ù|©(Ávœï${ÆX’MЧG¬Ù‘Ï=0 r†Ù½— |˜KìÝiÉI%úÓ‹Ç7ýôZwBUì£@L.™º¼™ÀHk ‡ùR¾®}AƒõÖûúþgßÿò¾ˆfÞE¡Y[½£iº˜—“«ÛÍÍry5¹— ˜VhÎ1‡ÁSV­£S&JîQf…ï¤:x}wšlš2KX…ÄGYïÊ7Ø™…ö$GT>z÷½w?úø£ãñ½vN­½ª~F±QF"o RºYG;!ês©æ#¡ÖpWLÚ¾ÁÝ’ÖÞ›sã`gI {yC8g_ø„ëÜÿPçÚLëûŸäJÊ*.ž¶L˜1Éàž§É+A:®kfÓÔäiF/êwž¾ç,úEÐÌ‚}WkTˆ¿Ö_~é¯ùùßÉÛ¯D×6‚ˆrm^FOê ¢hÿ*C&Šgƒ<Àa½×Î<Êé£\Ã?,EØ'JfÑ¥Þca˜Eÿi¤3ò*):ŒUWMiÂ>ØÚ€hkéÆLÞi´GšH«$ÇÄ[¿›GÍ\Ø9K6î‹‚é[ý+ߤÿ6…5n÷¬ âwµÌF ‚=šO5šG¬ Ø<`jIÖpûXža«b\©ÁvêïLä°v¹úM*6UѹTù3¹ñ•v{„ªµ2L;ì.P‹;æˆL–xR$$‘²ka˜”ã&f¦ÆçÆgj÷ÕØÑäÌV˜Zînsëæ¯îÿñ¿þ×ÿ_„ŸuïÖZ€ÕÀ¡ÿ·fÀ§àxKú´ç³ÎÝ-¸8§»çÿä?ú÷^œ^_5[{ol`0€‡o¶‰ uü^õV’füºùP\÷öé <œ«à*½¢àˆ ññ ¢Z~}kH‚Íæ·NéU¾9 ºA‚»ì(¬i›S± šÇþQÃË´ùèkÝ hBÁ\‹­6ždϨÔKœ]>0íðáÝÛAÌÿ•[¥ޥبòÁšií}Ò–;o0: –Âè™KÃjJYÛ^ùu£²qŠκ瘡²xR#–¢ªR$¦Ã<5³(D‰Ê²8‹Èp7›JêNòĪCœ¦nc\‘+§ÑÆ”U´&]ÏÑZ0ïíD}éåWo­/èѯ7pÑ:–H~]bΦØØÄ.wWO¿»(úMÿò—¾Ú8Q=fÍ&ÎÇCwÜ,³½ÿÁ;«ßÑr9í×gÍç¶8]Ág‰w·'ÌØ„Ckï^=ñÞÛÈ¡ D·_dcƒnnrÂètèÙÇχ£²Uð˜BIYØ'26¸Ûɱ"²Fz§ýè—?º9õ\gÝz| ã—Ýzßí×±¸Ï6ÚÃsw§=8axgÿt@ËòN*E•s©àÇ0YÕfÃSÍB<ôÇOž¬}qÁ»Ÿ–S³inóá8e’.i“=zü˜Uì¿ŒS”<ˆ&«ˆÃÚÿ¢o¶_ø‡ùôíà.ˈd'-Üÿ¤ªM†àt6t ˜œnf‰6ǪhYÐIyUö~¤‚È{T Ñl‹¸n"9°eV©YˆûE‡²\ž÷ y•O]žF•-&56ŠŽê¤ÓáñÕ:»LŠ>°%Hwý^R€¤p±sÃæ\Òž/¢0ävR|ÿVq§‡áfvÄïñ!Çzÿì>Àw9o!^lbbk»Ï˜ Im¿£hŸv—Ó7vÛfÍÅ—+âQ«°•Ô4íA0{œS÷1¢…}1Xšde’9H•M„D•;,‚”qq›h×~øˆßúßûþOË£Ÿz{·'ÁÄhCÿ–öóé8îËç+à¡<{|CŽ‚¼ˆÄBtWo´õÏÿ¶÷ÿ¡¿å¿Ý¯_Ì€$£©W‘‹rÝÑ[ø(m|²Óµ*üuÎÉþ‹Y&aÏQ(éY$õ¬T—‡·„ã±ï­1YíÇŠÅS7Ökp[ŠÄ¡Ï 1×÷!áwº"¬‚Tøáå›Wñ@ÈõÏð£dã Îåãiéx‚Ý£G‚ƒ¿‘̉¡T+º‹ü+1úÑŠn2Dò®£ù¼Þúév™1Ó£HÆåDKc`T—Ù,+_ áÿ•²O nô+í C÷êmCÙ2 Påfló4ϳÌkNI§Ç/ÉxO¥­¡pn©•„B¶[©Ù ýGþ±Õ×,‹ ±;ÀæÂm_¿øú£Só¸ÙEríA›„2A^¾ù K¡^‚Y_×Yíå‹×¯ž_‡…d4¶þÎï¿z}½¬:­ë;¼3êDØ°ßêÈhÓÖ4_x}s=·™P)½sùd6“ûMT‹ü»Ã+¸-ëm½ëâ^<q˜=ë¢æèÞ¡Âdõ7,Å,!tgûÑ/}xs·¦Q]0ê|·ÔÎÝSü‹t2rH‹¯Km¼ÙÛø\ûäZAEërÅŒ/©ÆŒi¨ àhvšWA„„Dæï¼ûîÍõµY;-'Id»º¸0 úZgã“'OiMPâ!¸˜RG§/g~Пÿwáw·›/Û¼Þ-ÍÂøŒåbª Ù¬ÿ„ñQ3ÃwØ%?¥øÙœô@nòhRËlÿ DÙ$$€aIr ‚E’WQ.mÒl?7 5kêAT~Iõw•¡1Ûù¡£;—vuôƒ­Ö³Tf¬v'Ç?)JC|ìáÿÎöy0N,™;Dxêœí!Êø.·7:C?Ê­Ä3l>ô`õ²ðh݇œ P5ªàg­ÇaÞ±ˆ@ùÎѱƒ°ðÍäÒ–†mP ¥ÆÙmPÛSǘ•ÆÁ¶LÒ£ûÆ2 .óÇH¼IÛ@!WsÊ·(a–4B@Œ2>†DS˺ °©Ý®À»?óoýñO¾zçtjv4¡•Lz{|jŽÀ[ ÐO‚£´bÈ"aS˜áóúo¾ð;~ßüK¿ïg Ÿ¬Ó×ꌛžžøš‡„÷rìÆf:@©&5îV =}<ÃçeÓY‘¾smôH•ðôð ݺéÛ.áÂ+KÄ„Íj£ƒÁM¯4\X¤Ö1ëSæÀ’yR·Þ ŽÎ½×8$…¤7ˆpnAs•Âñ’óy4¿·Ø¼-)Çó£Ø¯,viý[ðn0§÷D¨r·ƒå•4£p‡V[pl;.קƉEœ¢Ð Ók>ÌPÌšm1Ï!u¬)¡ÿSÍ„cUÔfr¦×(㪦ùêê}¹Ym²H`C—T™t* ’Q~Z劧ƒV‘‚,ŽÀkÞ»Yó²0£i—˜€Õán·ãül°IÛPZÆC Hî%065$»¯ñ:Ö,a71O‡ËG`èÈ>‡é— Ø­—~>žg>û“Ý/ý‹ýù\Úºtcë늦ح’SŒœß áäÕC!DAÛ«mAô$F>²Kˆ²g÷Ñ=Å{‘½G¢ñ|Ù×)ûHÇm7ø›ïûœP"$(-Xý±®Vöùê¢OZ­K^Ë\ÂhÿoZÐúl²UH\»ï/ŽÝQcæc/ž/cìê²멱{Ž´êêêÃÀÍÍWÈmî)ÓÆãÔVµúS RY{,ÜŸúHÈÓ²pT©Uži" ®¢qÉáTSôšªE13áµ²bò”´ä½^ÒÒÙt…2¬ÁÝóº¨çK:äLj!Ô]r‡Ó;ßòüWç½<,œy€¼W6•¼ÍÙ'Š†·ÇOøñÖøIp _ÅðW ää¾®ÓÅ»ÿ·ßú;¾ã§|û·½sÑ°ÞÐ Œz‚éÈ…‚¯Ç‘¾E¬r„+Há÷ p›BR@àÇx†HÀ”M!»÷2leOLdÅ9\rt3Ê ï¸1¤­òQµ-`qx£›MÅg c€f“Sé¬$†_~i|„’t¸&ÁwfCeØ·ôB)‹€²%XC#XŠé¼Eè¦ )±Ì©ä…œºa6ÔFºÂÖ–FÛm³d{9ÌÃW$Âé0Ùaš1^¯Í&ïQu¯,-*#Ë5’Åg!Õ<“z^S+m± ý’÷”¢C|ä¤ 0KŒ £ywï¾b9_Ìh©wÈp“c@Ld¡i1óªéîÈèË$a‘h^Y•J…žžÈ¤SlêkzyuãK×I’ØVõ‰©%­»³ ºür¼F3sïÍLðwÞ{òì+/"=ršlõež-,§u]T³O@½¯[²©Â€)ó&¦™û,ÈÕ#fàõô úíéî8™¼øZ%±mõ± k¥¹w´6õÞA‡uí§ÓÉÐT /-¯`R‰¢g½×xÊy¨m–¸Â±mÃñy¶§êΟ¨6Ü°UÂÙàÐøç͇vÕ×<óì¤ákHBÖµgÓºÎ{Da€²ÒˆãñbíKÜ¡÷>OSDÑ–¾ÎÇéêê FeAÚtzÐÕÃù/wPÄ•µöâ ÃÏÿÇ»ÛÄ¥wST¶¥ žÄ±&ÙV,@CdÕ‡üÐÉìÈEP©ªÜ3"š‚œr¸÷vR„›YU¢ä–q[#L öZú 2ú‡²bkD*Þ2Vç6û²áY„U °IFËI§ùñÅiBŸ<ëADUáaØÍ ãÍ$ ·u`Ç4ÂÆ&؃dzaí7MˆÓÊRãîÛE¶97%vjUEh‡*Äf]jÏ&"yÖC«4uNŠJåhÓ1Z®1ÊIÒËùÕöHdVrJ¶Ð6K =5Œ†3QvÕ™!XKë)KªRr4óQSy5†¿£ý–.‹eu(ë¹FOA˜:x“?ð‡_ÿ_çµØgÜW›æÐdç)ÊÛ«½=>=Ç[ ÐOšc/ùÑawh:ìbyöëþ¾¿{º{uu˜µpfu íÊ™€~ÖÂ0n´Í¡…aô–ã&Ô6Fñð‹l—ªðnõÞRT•pFªëM\)iƒ³žß*,´¿a“zøifÜ÷ILë¦'‡§ ­* L2 f|ž'0ù0Y—ƒƒY”ܤõÍP:ª1à€;g »%Ô_¸{€ôV&®°o”·‰×ëÄbw×뤦Î)ØVAck•ë@;o“S¾¥pÜWç›t¸ÁRiìÎkœÍGÆIÚ•›8·‰F6Ñ«W&¢Á'£É£PQ‘0âÇ4ëþC{Vê^jËÙ9ñtrMÇþø+ýÐnýdF_WB°êgãžÊ+®&h4hV±Oýøü£—¯_½–útäÓwžíÕëåæúNÖæÃôäéãÕ—ê‹à"ìœÝ*ÒˆfO§%º !BYŽF#ðôÑSj²ÅÛÞD…ÇŠÌpO±6*j@w5´ë×7§Û“µÊ’.À+EePÕüj„j%ò.|é+ß.Ûrç™Os[¨_Ïqÿ‹ZÇÀ;´WdaøA–H‡ÂØòqˆIî&'ÈU XɈ¦'OŸÜ-·×u0±ñ0›ñòx<\Á¨7EðŒ)‰fÌì#š±Ý|õ/ÿŽ«ŸûùG\ovÕý§ÿõüÎÿøÿû—ýÜïñ»k@h¶ôuâD6÷“™IˆÂ‘åºL3}ñÎrU ½¿U¿!m÷¤™þSRjøB„j D»8OÇÓé6¹+0T‡HÂV_³ J¢‡á#Ú<ÂñIRícHÂcÁñUŽ5„Í"y |Ž2JX+U]óˆ‡ÉgŽHh»Þ¤®”ƒ¦Ü±zã|•ûvLš0²Fx °íæ— OUfSäÓ&2N1‘’áxu¼{¹LœÜÈF¨µymM2U¦”@/þ1J"¹žk f|ƒDö¯¯3Ç«¦¨QÁлiläZî|ãnj`¶L©Hæ-WñРö7ã+-ûP¸;>ÇdæÞ?ûø¯\¿òÖV_âbVáóœ#¡'Ñ,˜l;@rÈÜûãwŸ|üÑGW‡ãÜšwŽG^Ÿ°ª¯º¹¹}<_Ea\ÈÙLÒ£ G;Ö2÷Ìi )$etƒ-ëzšûAh¤÷³­/¹GÊRF@lHñ'#ùP ¨Ë«ËõE÷¨ÕÔ0P’Yëò°¾‚Ô•C""GÂ2á ÊjŸœåº} ‹†ØÚ"p,!!ΙEãZÀA¡ßÍzØlˆŒFç‘á‘Ïërf~<†!b4w‘riˆ²ž€CÇiöÞIëîf´f.]]\¶yêê‚ØÁ¢$†b/°Ñ\’ú£#ÚË/ÿ’_üÜ}ø§ž^oïN­™ìÇ2ÿZôj¼ÝEf:‚V¾"p’G+œþ ™^1…ÓâŽH0-$]fKQ-ó`Lýƒ/%^.ƒˆUïë]àl\ÙçÇëìî=ë¶E™æ}ù5nŠ¢vfämÃ¥ª ±=Å®$'4¬ Í–ìb l»¹…bcî\-ÌkG³‰zÚ¿õX•±,9„~5 ε‘of ‡¤ë³âWò]¢…êO©?!)e·2‘\¼“Ñf×VJÄJ¬ÂÖÚÖ'HK•=|lÚUáPÉ\c=´×†T¯Lw •…×]fì]‚qZ–Ö&ÌŸù¿ÿ¶?øŸü±›µ½Ç iOæ¼V„âÇëx{üo €OÕñp£Üÿ¤vS±D©6Á×>_<ý7~Çïøžïüü»v„ÁÕ¦¶®»T Y†¬w ×W ß‰¼p'eA°ò5†¤@ÞMÞ‰’(R¾'!ŠºLÓź®á5c#ãdr Lf3‹T„g)ƒ8²‡Tö%LÇ® ˆª^Â5(B­Ui7%ÿ$­ ðU•Ó¿ÁyWr †ƒ_r²®RT˜äkÎAG꼆3fGbÕè<–/»ù›Ô‡zƒ·Óå£ùîº 0Ç BEÓ\W­`3€ÈÒ?>ªí)Éùs„ï9<¥ô¬G”· 3ÅÓWuÂbÜîÍ:´*ƒ$Äõf]ØÛlÖ&©QV°žùÒ5›ö,…ê 4SÏ25ÜË{Šh«{ÑìÉ<ÜoÛtX–NDòîBq½+Ðá ïBL (&w˜ñp8\/½{d®Z—óúr%¹.~w».§.˜eí˜AÙÈj†N‹~ÉJ­ìÑJE¦`¸¡îmj/¯_¿wñHʶ> _2 š.g‹°!d¨,6XQ¤ÊêxòΓÏ_¸œ=#†ˆäˆå0( æÀ+jâ¨\Íëyß²Ý>©ÿ ;Èñð›(ù±+`ƒÝtßß>Ú¯ˆaCìŸÄ·e‚ÖD‚ZZéT7&ÑU塆uQ±Š¹Mk_Ãf3wúôi›Z$q’•ºzC#Ìѧ`ö_6ë_ù¡_þ‹~–½þòñbº=¨.Yü݆ÇBÀÊŽ2 ‰¬Øo;€ê‰û…òýgPt¡&J¬ÄF÷¸2‹ª®¼n…¡;Ýa~•‡âLªÅvæ_€ÿîžì”.£ù*Qšy§»‹§n¹È9IßÚñ%¹>';KáäѪÅc“°º­Ê Gß[2Û)Wò¥<íƒÝëT4QpY¼±³ƒCâ`Pg*Ž±-MV íÂÛ1ŒH™o–íÒ ¼`)ÉT‹$œ Sã Ùå½Á z‹>*.3ÏF)ؤ0aI+L‰B4/¯t»x8!ÔðÎHtY¤1†™ANq^—•™ßéê÷ÿÐéŸýÁßÏ‹Ï{Ñ‚Ek†¥ùöøôos¾áÇÛ@ÖÙwRz¯Ýóúþaý5ÏßÙ_~|9MÞGÁ`£9,K ÌÝaçyKÕÂ8ó⤠¹­¿Äa96j£o~h‡.‡š[~±‡4©ô3cÞ«·dFSËS^eŒë‘:6OL&h”3BEjãþ4i±) ÐÑ9äh³Z!‡„gžä$ä¥Q¸1ê=£0ôøC)±¼ÄÙ´l1ý±jˆ6 nó"%iGgÃY'ikâXúÑɵnº-‹iÀ=Ú²CˆÊ82 _c†ù‡àO?eFxò‰vz·‡ûàG¸FF®H“o–!AìîtNƉv1uÖÒ«5¸ Îó>`|®u0KÔ9œ«ˆEøÊÍÍ }åîZöªêxšx‚I® ·Áy“¡Ï/ž=[tzòô‘¡‹<Ýéùój’ØåOß},[Y¹Îå37“k§› ðHÀŲ®^Nì,«—…ÀíÖž´ã<5h ¼DUA‚ÎhQ•ã\Ühð¨¥+À¨î Ó³çÏ)Ë%™&‰â¾ù’Á¨,Ëå”þô¥ïV¯»9໵¾ óm:÷þ†ß÷ǹ´Â›þx¶KH ºÃÞ×A#žQ%êØp^«MmY׳<«ÙÆxFu¨4ÇÞ{ÿƒ››×º»Yk“½óλBcBm÷¨Ê;â„ ÆFψœo?þ˾ãŸñÙã¬kS‡û$:$ª±ºf$C/ìl‰}É•Å3Šceì'!<Íá Üen\²Ó,î¾À•¹YÀ÷ÜÉ¢]ã¹|Kb§ëcÃÐ1ÚÄ0ÜRt­ ïŒdö¥­Çw.O\epyð~âŽ>l’7­„wË™Äà°½‰¼3¾º—ÚÝ;¥Î¨ 1oGï¾Þ»Âþ)µ¥ññý±Ö·‹Ä’|øô¬ÆsCÉ=ò®¥R^¸¼[óÕàQ@"k‚C T¤¦,]85ÉoÃlÊEVüÂÙº³Ò›D;AÖæuqk‡&?É^¾õoÿµÿÚ3ûàt»NmMµgßÂÆOéqпÍøÆ?>ô?" ssG?|åÅÝoúíÿÞßòËþ[§ë—ÍÒ9Ô3`îQe²ØçÙ®iˆ418Û–eѲÜ81IkhÛÄ”%hT¥ Cå19©Yž–IkYÞZE¨‰p#]ȲÞË7B×Á¥Ø€$ÅTGqÒ=‹¶.½Ä I£Ö´•i }ŒŒ5„vd¸ÚJÇ$…g`ßmÖ¸y÷‡Í2É8r³`åñ.í›áõ(ž²xÓm ¶™6Î(Q¢æóå´Ê}eQñÉÑaì’)a·º7ÎáèÜ‘*"©$6 ªt …RÈ6p1Æ®ì=šõF´Á€æk¯yI}OÑŒ]fÌîÖ»‹ãU|ÇÎcæ’c †P‚<ª[" 4EO€ÞiÍ0uïùÎᱟ®iX›-颒O4]é–v-áEñL}ñÿà3ü‰/üñ§|îÈynF¨ B3¾~ùêêé¥÷ND¶]ŒcÅ9¾µmêrÀ¨´Âí±c\¤Ý®«§fÆN4ƒzg,•Íø-~Tß@‹Ê|t€Ö½?}úôùó(ºªBØsž·E#å=Ði鬴ìxMq–Hd_Xîɼ#ëÕåMCFŠÈv¨–þ^lííåÛì!¦ÖZy|Ç57?“f]þtÉ1sSïƒßÂðü—Ý…‘ì`­MMÆ*tCWO¯;™ãè€u‰0SÆ8Ũ,+ï~Éþ¹Ãég~ó»vóÁ @w-„-J«Å+t áIÈ÷MUÙÌáõÊ9‚)CÍ„nl¤Ww«¨eÜêêõø¨Â+!áÈX!¾ËFR¬¼±O¢XU ž2RC(0^ˆâ0#}EGÃôôê+z(A9q±êfîö÷ÎÂ"•ä*ÆüŽ³ùE*n¼9a€!Ü6ÙCqf?n«pïHxÃ2w*Û%í+ê•·‘Š´) 즛¥%c¤½Â§A؉wÍ`Mß8·b‰›@R@­~‰+]9°"Œ`:Nò¦~õh‹“Kl !òái*‘#àÙdkö†µ¹GaÐ`‚§0÷¡j‡fj®$0 ðdê"+‡Æ ÜiÉ ÉžÁ»zI{F£J(ÉÍ{ô¹ý·ýÿì wëôŽMæ©««éûÙñýª· OÛñuÙÈ9<!õn“5-ÿOÿÎÿÑ{vw8È×µáà"ÐÍ4Ä”† wJ2Œ+£¡„š"K @P iµE”V*ÅŠ¹RÒdQ;M‚Àm"{7î¼Q0¼j_2ùÎz#z­ûd Cé“]Už ˆO*0P>ßL‡ ƒ™™5ÄÕ-Ga¨([^}ZSÅ{x‡•·§­îÓ¢€ÛƱÉ?ìÞuEŽaß¿­OîÞh­Oë5úL¤–쀠;·hV„РýÌ4_Jä©ùCAÄ ;7k…²ì&¦ ôÆ$QŒŽ¥n±6b­P@Gç¡M³LnÉ…Ø™KŶ*m*Œ·‡ ¦|©´[VWƆÁ;Q_Y_¬÷¨¦„VŠ¾ö…&¡Ñ"WŒ¹+†קׇyhyº]_>»‘[ê™8[;6˜èJ6›hIL·Ž“©ìÞûêåc‹¹w¢Õ”ËÄiºðî³áò0[lJÏ”âÚ‘ÅÍJ†XÏÅ0Ž¹¾ÂŠièxöü9Iô2¨ªÓÕˆpÙ—¾ôáéäkª5y¶.wq­ÀãÜ€m‰oæóveÝ;eʶ#—”Nf:ÀN?^]Êu{s[('jÚ$ÀóM\1§ž¼óÒzZ—umS{çÝw‹¤$ù„7 2wm•Ë¬9àÒÑlºþâ_õ³>ÿWš–›Éõ±´¿=)3­#ÆQ…`Ì®Œª ‘£elb0ùª7Kq .V©«¢9+9œ A×a-oëˆÊÏ8ßfayuNLI‰¤”ï‘r¤ÙpÂÊÞ'ÍO.-œòJ*Ã,dš+é‰;±úÉ«d;éSÿÆ六{ªœ¡—­´-FL¨µTh!y¼„î¸ùΞÝÌîÌ•ýCn"¾ ž=EÝ¿„0 ÄŒº¬Aô´]îN`ž—àý %(KKU! @®q‰ƒÜŠ¨*…iQš™÷^!8‡Û& †Sôú`ÊèOVJmpœÚ“?ô£úÇÃo_Ú] 51++¼E‹Ÿöãþ.Ñ[àω# ¢Ir³Þýý;þæõå‡.ýNÈúã]ê„eÌ»¨-Žn%C€õ¢‚-Œ„ç!\’_H´Tå# çA,Þ03Òm|äzÎp;ÈwëÕ(Èè7BZó¤:D#t_~?Êœ%™tUÑBÐ<Ôî—üvâòŸÉ›d͈¿â¾.7³Á†ÚÀc ú-B]7á±» JR2’€SŠ Q¥1è¡Râ‰6C¡Äÿ¦ ©¨8Ùú¼ÞÁ¯×ÉèAü ÜbÊa†èM[®¬:ÚI˜_¸AÁE…Be%S«+/1ÈbÁÒª,/2IЉU>]8±›k£´W‘V¤91^Ñ£)ØbX;*F  ÝL.7kÝÕ ü£›—§™=²!‘MM+®º]Ù¡>1‰úFÄÍíëÖZ°gLÓÇ_}¹®¢Øå0¢éâêæÍH–ó.\²hÕŠ”˺Ôä ÊLÁ†Ê 8¡K}™§v9’¹ŸSS« ìZŠˆVIظ@µœHvw“u÷—/^Q¶Ê[Ѻ˜ ?”Êe_üÒ‡Ë2@ýÞÂåXkƒ€±¿q\a7}Øn³jç”íþ-[cO.z»÷µäP—)Jò<žm:ÝûÝÍ]ôAÆâÕÌLò)·$&{÷Ý÷nn®{_å8^]<~üdÕšÛEH÷,¡I™ 7kR“ë‰^þì÷ðýßòôÂ_†Èl`·Ö{'e&ñ˜Nç–aFêÊN#[#A§H;ÈÇhm‘ÉeX«Ö¾FÛÇ|ϱƒå9³ÒãÞ²Úoºý¨Ød[íŽ0Q*˜&ÌØ;¦¹Ýô[»´ùÑá+š¹w ×ù¶ 2ˆ˜ûŽóS/hWÇ:ã†óõ°¡yîÞu|¸;Òj¬†qY #J¢ý}PâmgǪ–ìÈÊBl+œ›Nµ}꯾5¥oããIk:Xoè:9þ)Z>G&wý9<;»%…éÒLJŠçHŸR¹–ÂÇ3BTA ¹¦E¸»øö¿ë×ýËóƒumQõ¿Æø-TüÔo €?ÇŽ(Yì<àÈÊî6O·ß÷íßò+ÿÚ¿r½þØŒ$¼[‹Ö{PII0+n, xG'µ-2“‚}ˆpÊûðñŒh³%Ý«Öµô€PÃu6Xô\­Îî–. µ£[Àae¨CºUKÛÆÌ5Q€Š<¬ì$„5W·’jÃKghÝ×jZNff$Ùؽ›¥¿¹@J¶õ¼‡3ØÛ¡Éj¼¡!»ïíC Qì—v\¤üúà\…â‰|v²ÛõËõˆ£õ4É"‘´aòH+ƒÃ2Á‰Ì@ewhA022waçÒ |ƒMa65‡WW[“±síÄÕåã…«MìÅ&IIà 6(«,FÆ3m15\‚wÒƒñ”²k´‹BE¨»à«ËõÉ:Ìw8e”¡ÃHgVÉ=ʱHÆ(kõµ»7RÐ4^>»¾yuµÝÁÆ6Ùñò(tNÌ^¨@ÕŸIÎÅiYõ¬PH·ŒQôx¸€GC??NÓáЯ™™%ÔÄQ׃‰FÁwĨ¹»™Õƀ崼|ùŠœå.±£S›)÷õ*Ø¿ôQg”™bó\©pÙîa±ûjâä0vAúØ‘X ÷¾Žu°ÿ½ÖD<§Š*hÞÕ/]ʸ®ëz»,·çׂ$™¦ãüøñ“ÛÛÛÛ›Ûišßûà½îŽìc]F•G›‹û“ÃòÍw_üë¿ÿ{üùG.¸®€–†ÊUÐþ-˜0¹Ñ*û*ò'ª/ãd@Ô‚ÒØã%/78UUŒb´ƒê« ƒ‹¢e›‚€ù:Ê’Û=V9I XèXÓ]s-(“–œÙêX}åÑn–›«'|¶Î ݽYëÞYí~U.ŒËnðþL6òlÀÊ­]D·<*cž€¸c“•¥=Ä pÏ%Ãtù«.:DµÎ0Ìß|Úûè¨?îU^¬09˜ìOÕ›y&Dwˆ`bƒuøJɨ©aš“<¢Þõò›.Ë÷,€ÁÍ\/ÕLíÜp[ĵ$®òY«ˆ\xät¸&šØ³ÈØ"Hœ@\}ëÿòŸÿwÿ£?~·è¦0[ö¦È[´øé>os~r!+ƒmÂp66A.\þÇÿÕÿæoþÏáÏùN_o&Àî–e*@ؤ~TZ¶( ŒSá”(  ôԶܤIR‰<ÊTNjQw¨‘&e yÃ;-JšiûtwÀ›ÍâŒì#ªÉ­º{¼}8Î}u”Ï,ðFf!ìQ‘m"šmuWd¾’Y¢ @§µ­èÛ¢]im²¬amJ7»ûÖ1qŒh"$ã“CuW€>ìy6JClTŸ0v¶fZN Œ 19¢Õ²¬ÉÝ/ϧ—ËÑî24ƒ\Ù…Ó£-ŒÇ“¸¡¹ õpîSaã…«`ro6ooþ—YŠ¼Ì¯x Åשµ˜òïðÃñ8Ïó­îØZw/o” A“Gï z¤­v¯<ã÷\MèâÖñÍ3¨`YÀF`f³óŽ®ÛÅ;2k³S"­„‘F¡÷œKRš µÖ¸¯d“ëp8ÜòŽÆÕœ¾êîætñhN=ÊX_^ø^ô"ó”Á–Û.óMcòUä â´.æC2M‚a,麼ÂëhL Ù¢(Mz\¥6µÇ¯^¾¸­Bìt©…ýæ”6m¼{áËmc Ä™ºßv¦ožëù ŠŸ;Á„º~]K‰A ]×7¶S¹ïá°í‡Ý…ÊúMXN—ÛdYžR£áø.Á1έÆæÑ‘áÉÅ•»w‡ˆ‹«‹tvw6ÛÙŸØÜѺk!./yñü‹åÏûn=ÿèòÐîN'£™èê ƒ,`n%òmU$†„_B4£„NB´±‡Ñ2FŒTø ÅE ›ùgĶ²”CIfä1Ì;[7‡&|âQ³‚‰º-@lˆ 3[{os»^î.ž>YÚêtQê2cÏ¢¥mæ¡Fp)+a—ZC…ë-1²•™ó€’(¹ŽÚö– c‡oA«lÕÁ„ĸõîëµ]+=ì^}Ž] gW4ÞÀê^aÑ«Äeøꪌm`oAâ uÂÍÔšOÖ›ÄÌ>¯ûgêðˆ+=n¹ÚR{>M¼£—6LÏ?aõ¹|³nê1Ã’L[Ò"m(øOÿßóGßób±÷˜ÊÕÊ–/óüíñ“êxkü$?Æ– ‚Šó6ùºø|ñÞoûÝ¿ï§~ë·|æ‘M¾6h2ë}5 / É3<™ðtH6Ð(Yüµ(~Ð&ËKMDœ‘\½¬Ò§Tð‘®©Í¡ˆÍÚä½K= ±1[f*’Œ b ”‚(—Upå¼j£¨ò‰[ý€4EI™áU„Hö®Š€Æ¹¯§¨K°ÐcjÈíüH;Ï(Ë‹ÎÒ£5vÂH2«hÀ¦˜5Æ6Ñeˆêx™,Wj`Æh£„ªÈæ&]=ºxýâz²C×:Éœ´X„hª¯A๠øÄ| 4cà+ïHšP"[!¸ý9:ˆõ"̺0îÓa>\\tiÁÊf=Úoî´M›†~¸:‡>7¶ÒÞñÎA^Š¤”ÝhÁ# IrúÕñpww×É5CëÝ F)M÷Hð$a­&Õ½»£Ç€„FÚ„.÷n†ãñpºíët—èèË2-“MÀF‹Ól.ì½CaZƒzvÉÈpÛwu Þ!áv=Éæã4»w²üsbGgõfØÙeUìÈ°ÂœæùÑ•½zõ:‚y#Àh’1†?23*óþž`É¥êY­K¹m1–wÙôª6ZSb¬c’ÒþQ·›ç&Ý,‚³£>Ö$ uôÃÅe÷NX÷/‡w4ǧ\$F6Y›çÞ»à½û|8F Ä ­G1ƒîÝØš5êð†f²ô¯øó¿å°¾8έ¯i™ëÃîÏlŠ¬·–” ¯}OlæTäÓ£¨Ì°=èŽáǵA{¢V.ëBˆ)° …[|w›‘¦ýggʱwˆ-'•Ù^%¨V`ï+'¾^o.Ÿ>¹ÃjÝCP³ûs+æ›ñl–9¸*ÜZO„äÙ`¸ïk÷‡™’r*ဢ'Ýóiƈñoµ!íQFBºl†äÁøùxî²AÃR}ÏÅÔ“c<ï-Ó2-êפOe ùr Ù£n \'Ôšf®‹§›M¹ñrwY¾Ò½–ë©L÷Ðbˆþ—ùE÷Ê=³mt•2¦rX< 6/eh×SŸ Ýüv=þÈõá_üÁß{š?“V¨†Íý²z{|:ÝÛ)ð6 øÏCå£óŧÅÇéÒ_ýÃ÷ÿP¯ž]FîŸYiªbb¤«ucé!©tœDë[LTÁ'GFiÓwXMÂlß@ü–žòM}³ &ïrGwdeÅP.˜åµ™~5  »r“Ø’‹–QÄ€ÕÎl@ûÒ:Û‘¦D¯ tþ;ÞÂÂÒEèϧ k+›¥Å|3˜cîjóª.ÓñêB7E&ðöŠ1ïÌDˆ½Úd€PEؽl&ìÉ]5DB¡»1NHßcÔ´?a}vº¾Ãm\nBõ×¥Ç "ïOwH]½÷5ÊZ–íĺ, ‡~ê/_¼v‡„µwÒ@°ñòÑp¶p£Žæm\ÖÅû–½=ì»É2Ò»Ïó!‚,ÝݲJÐzq8ÌÓ,W³B|ѹ6ÀcG°Š¶ÁÎ#]nj·7·×7w1ËA?GÚ"­‹_úꇧSu¥Û|Ö7QXiü»ÍÃ;5¿W{ˆ¯ •í œíÝ;a÷»öŸUˆ6{²µ~quåÞ%ÜÞÝr¥Å„Œr¯1*™¢ò×å“«ËËK‡ž¿x~yqyyyépyä D”Àɬ“hóôn8ôå/|ŸÑ7¦þ’jÝCâ­ÐJk)³¼{@`ècÜÍØÌ §" ß³YXmè´òÕvÞˆ±IʸUÆ:à€Ó—0…lüRfúfì/¹ßL¬ ‰ƒ´¸ö H$WE?„>?9öɽÑ{-•¼¾—aC¿ 1+·YçÈs(¥rΠç/ÁÙÚS-Ðí‚ç«&é&&wH»^+cœ‡B¬œ†¡ZãÎ^ó\˜‡m ½Q÷ö [ÇÓù) PÄjì§>[´vÁWEs·k’¹›âECæ»ìl–Ý í;òû‘Òöô=ôš+Š¸MÍnÕ®ŸûÇþ÷?øC7nN2›˜Ñ¡³x{|Úó]„·€?‡& Bµ©5÷Õo¤ßô[þí¿õ—ÿ5·¯ŸÏ•¥UU2!F¹g5Äò+¨”Lä1³DÂÙÞ!Ã’8$šÜË›”«§——}PÒﮈŒ¶šz_]t/Ö~iDQTQù×L@Õ˜uY ©4†F;n>ÌMñ YÎ-È@¹ݽêÝ ¡U$?÷uÝ&3#ͼH 1;Zd T!ø‘UÇèZ0”ýÎz(6@0Lb­˜K£·c—Ã:ÜŽ·¯OêhœÂ•Ü#c¸±©† öæ»Ç4{êÿ|Š|{Ak”o"`ˆÚ;œÚ­Nóåá0M Üh]QEÎpö¦qÁV–…v—Æ+eYO$÷ `„¹Y–BÍ}¤‚Ö#bØœ®pt ðÈùu©Å‚±TÓDëxsc³fnê¾úê2Ùغ÷ù8“fŒš³‰K¼ëöæîâê芌‰•ú@]½eÞü‡±Àrä™ÑÒ!³ùæî¶É¸ö ´e‹ld¯RÖ´%ÄÜqÖ‹N(xj’_^^.‹/ë‚`À sÚ—ðmÍçî/ ÚÞñŸ ÛòÑ ³ÕùÂ0$ÏTî]m¿´wŸµß@ƒ?un ?f—ƒ8.FbRôÌ®¤’ú*ë)¬ÙñxŒYOž<™ÚT`]žà¯:v“FS÷• ´>n|Ÿ×ß÷í?Õ^ÿ(mò5â=+äΖü|s.q0H”&cVxÜ–?sÍ“%ˆm$¢·ÉX'ÅIS´'Æè‹4›¦¾:@ bF œàe†Ë¶”F†Y¯HM ¢!¬wMX°^>ºZ '=Í`©çÚ«bùCB´ hH%dUþõއ͙ ƒ©b†ðÜÍ&¡Ñ"j5m°v¼J‘•³ŸØ_io§]òD:ïäÅl©‘‘6luüQ,>2"ü”ŽŽhˆ©|ÔÊ `sAÔ•¿. ÔŨW½ù“\QÖyŒG3åR[5z©–U~ýõÌÞÝŠèTFPm¦XC¾[/Ö|¥¶¬m:Ü­Þ/?ø?ÿæÿà‡_¶ÅÛ®}v;Êøð-‘ Ýñä€öìKÅ/ø^¼ør›¸.NÂ;#áSy>LP5¤œÖhÑÈI›w$!kÊŠ—m¨]½´r…Ǧˆìå£U)ŒF4hU,I#Elµ›‘‡³T¶VÙ±áŠZ õã“GÙè×fª|3÷lxa6{[ N “OBô¡Õ¶üÜurou¹y"©‚©ìÌ!hó»CÕoW'‹®´I!«&« †œÌí¿½énÞ¤"ë@Ñý/ŠÕF¼x.CÌjˆ]ä<ùÜVÀÉÊ)#£•˜ÀˆŠo1œ1ÚÞ,%´S3Ÿ¥N‹ÁÚ̆4Â2Ä‘NXI\t¦Å}†­ËºLWà|ùwþþ?éWߢîê¬Kùíñ“ãàýœS€î™t<ßsoOÿ!„çÕ£6"Ôå4r¹þøïýümŸ½ÐÄUÝ›Yf¨†ž°QÇ!p£ØSŒG<:q­1» ‡äÓîÖÉöNI˜«ŠY¥„,Ä^X…'3œPæ»Ü™ ”¶vG¿¡¨ÌSìE(VI‚ýà/÷ðùºÖ†ÒŠMC®Š´Ÿªª®7”1sœÀÍꪾ¹0M ˆÒBPe€ám®4Ð2³b˜Fæ@*ìPø;ÔRï„ò¥ç˜ñWÊÕ e§Ð­é°\Ÿúâ YTSeNd„;9µx yKTˆ¤1ˆÃ:‘ÑѧyžŽójè/‡äÕ˜ÕœT’„ªž“Ü.™7)…´‰!¬šrjŒE‚5Œq)ˆeg%tÑ'ûðúãÓäIr7S¬5¹¼±%¿xkæ2`YWïòÕá|ùâ5ÄeY“—Ôèî6Ûñ8OSM‡µÞûºvþk€EìÔú̸€‚eäótp÷´¼äÑEaj¶ö~y¼h–Ì‚³Û2®1âðÛ H½>‘íå‹—ëº2ËzDû°¶J_þòW×N’yÌÛðc»ùn©0½jí¾´Ûm{Wðþ\¡ ³7:Π~~i—{TèYÕ.ìòx±®nÖn__{ÏueÌ^a3’0FÓ=}÷›¦f&šÉåî±[Ó•,DÍPb[åÆ«W?ô×ÿÜïz—·­ŸÌ;”ù%nþìýk°µÛr„=OwÎuù.{Ÿ³÷9GGGB²-‹ `T 'œ2ªTq±M\ÁEÀÁq(þP•{Q©J©JB* I\ .BA°Œcl$Û²- llc0[È2Žt,é\÷Þße­9ßÑO~t÷c®ï;G²ÿ„³÷zôíµæšóã—ŸîVD†ztÈ ŠflD`¯Ì°mBÒ‰wëîš$>–D—©¹#8 Eñ]í!fÂM~)K\®UTOA~6 ‚ÝöýöùÓ3 {ßÍÚÔa}sóŒ…rbù8¥wÆvÎ (³'%MÏìá1¶ &«g1ü.Æ1¶–ó]œÃÄão@@.K:¦P÷ 9YöÒXÀ<ӳ–S¸±SvWc]ü(µ“§,Ù—z´¹7€Ä~ÚÚ—ö÷þÉßüù§îwk‡ hîa~_¸â·Àu±No®Gà[ïšlËðÏÉ{7nÖpì§üúÕ‡û—ׇƒïb4uZoÕ¶1yÊÄWvÿêÎ;BD…¹TóÀ¨-läÁž=f›™5QÕŠÜ„ ÉÝÑB»È¶ñå—ÿ®_òü{ŸÑö{D®y?G“‘ž]ÉŒänÍ< ¿eÁÖ”c?3+.†ð,ˆ\Hw„EÆä,p½V€ˆHnØ>ìrŠ&žïÏÍ˲ŠM˜@ƒRk;¢L¥ðƒ0Šê¸ ÎƒŽÏnNÚ£#Õµ¦Ã~£ÞØë™.›cñÁ¬;FPu¾¨öòÅÍ4‘½.¿ñ-6Àü¦¼ï©–@ó=ðh>F"(ï°6}!‹^4É©äƒ17ÂèrÛÕq;ÎìF“EšDåO¡‘ uBöiÏD©Ö Èš ßüj ÃAÄ0¢XnºBQV!@‘Ý]´;îÞt¦kƒ<›WW6ž†Û«àÐ4as—¤×w¯øîïï|×¾»<„ ÓW‡«›ÃÞO ݵïN³ åsoh¥mÓò1Xc;ët}uí½W(žF£@Cß÷ëë«Öš…m™˜O?\ °Ú ‚(yoÖ² âG|TàÀ@îÂÏýÜWöó:Óiy²ü狵Hj6æš®ÿý&¶ÂÜ——¼|¡ë_ÓH£~8n‡ãQršïÏýÞIƒw³–ÒÀÌZÖN9Ø&ÓͳÛvØh;™ _ IƒCR‘uÛÏ¿äfÿ•ßû™ýÅW¯·Öw¸Ÿ]‘TsRtk›ˆ4 ÙGBË˜Ç …S˜³f%ex1×#ž"1øã½Rç‹,…x±Á•ÍŸ•qUVúæè¢:iWÇóÁ¼µ=R„ƒâ˜I(Ó,Z&Óó@?\š>õo¨„»bDàón™>¤´GË=GW?4?yßïýÀýÿÕ?úïüIÛ’òU³÷x}‹]ËÞ/<&¯éîPcAÛ<ü‡á‹ÿöðç~ù÷ýâýþγ¶÷ýÐzw#ƒšÍ¿K;ƒS¼‘¬Vâ³šÝ ¹àrd£&’ô ѤLÜ"ýGº`ä7Û¤.ëá´¶*Û8˜ (UBPr³ØÛty #Ë\RŒÞLáúhm‹HÅð±„æC%SÆ®S9ÜZ žÃ ›ó"±ˆD)]hO§eF »ËhÑ”™Ä¬ñí4[Hýÿ¬Ø÷Ì]ÑÐ ÁÀS\BÐvuìx{<¿s¸‹¢o×6S³{ì°H$‘Û¦H±5EÀÔ¸Ú0yÕ½üÍá`/iQã±OÌjkմĘªïîðsEi Eà¨ÓÌÜu´íˆ­kßûšî eÁyœÓÜÞ©p)ò~suóòÕË?÷ý>R=£Nûáê˜wïÁõv n؈–[dy*e+UíÓR¯*N“Çhíîþt<Û–d)º #X:v™yö9-â¼tÏ\ú˜Ø'OŸ¾øðË–¢NÔ&]xùRðbø,>{å,Y-Qœá‡Ðk¹·ãÃigÌ¢+k2Ð^&Xýöð¤÷$wÁåîÍ*ø‰b¢÷¾µ]Þ¶Ö¶C|™Sa0O(ˆ®!.zד+¶¿üå¿ô{N_ÿ雫ãÝé¾ú!æÜ“t3™Éš2Tª,ú²ÅS„Æà=­ëÕêZìüœÌiÍò¦€à€¢å£P9ó!ÊÌšºK oqÙÒçÕyGÄ,Ô‘±(É¡ÙÕ“ë;œaÜ÷4&\£`œÃq…¹½bå‹ÅRŒ±U.ŒG^ü¬ºELÞEÕfhùÒ7vœÞüY%j²k§²¢ ¬¹_êwQ1È„æÕvH-8Öí ÀT–R4(T¶TsÈ[ãñpjèäÞK ¦Ñiå¸TË9_cbŠ?ZV!ô9çKÈ.Ô¤^¹HkJú/À¨L~ÃÔîýn?üä×οëGþ?§Ã{f`Ø»‚Ë›µ…üûx} _ÀÇó*Y™NkÀÞ¯nžý›ìßù·}æ³Ï¯7wHÛ¶NçÈïU}e§(Á˜· ç…;1p7á—²ÁK†0ŒÚÄJ¥€éáü(HÖ ~¡µä ¸GÊ¥•Žƒ¢›i(ê`´îNh& q€Šf.ÙQkRQé–RÐã/(¦Bƒ‡jÂR—Œ †cLåE\—ÌiƒGupÑÒZh5ó(÷14Zª/fQ=hbëšàòÐ\Œ(%IÎ#7´Ó‹ÓGzXzê‹"AØ„ >î–¡‡›£ÌdÈnÁa…‘•5d*ÉTY‰’oºóÒæ+[<4_zH×wç„aÞ‹8kx©(ƒümÑJ¢»ËèÚo×çÓ‹]2¡ùVÉؼ¨RI…¦œf꺺¾úðþÃëí¶m»û(¡ï©º€îîî¯oŽ{?õ]QÝZ“{ ™ ¯‚:‘Œ-úl°\|µÚÅé|tØqª{öýÕ:GcÇ$8Gýœ@€Î{úìÉ|ØÚæÞí  snðæÀæ*¦ Ó ÉŠÅ]BÊÊ 6=‘ól(f>Æ>ŽŸ*Ü7áPÐY ðÃÕ‘èáðÞ£ðH˜™™ÑÌ»fl08úv sM'K¬1CÝú8{éjéî‹J§‘uÔ°«áÎÛ‹«Ïý¯ÿÏ?pøtô7ïµwÒwöx}«]o= ïuáH}gÛpËW¿ñ×ýÚ«ýþ@DÎ蔟!˜, É*M-!ËôšLišÓáâ ùYµ—Rk•Ë2ùº%aÓB]ò=³$]D‹ïÎ:Ù!“öQNòyÖ¯H ;à;*ÃmÈÑb?‚â¨Z4&2\¦+„A¢ØqËyVžœÎ«ŒŒ'c§JOFx¦Ev˜¥¦f9OIˆIl8ÇŒÅ/›c¬JB‹n(:eÝÚy{ýò®¡¬²«+WpŽØ ÞÃF3]†ãí•[ø’’ì”Æt¤Î4`Ö2¿!ÃŒ\‰i×\@BTžFÂüó¼giû²"EÂD_}uÞÒ™þÕÓ‹,háé¬2¬¹ÄÝ{6ìt¾|õR»|÷ý¼ŸÏ]Bß{Öd¤\þìé³îûýé´µV¼2}z§"—_o‚ÜŸ £ºjOùU»:nf…6Œ¦< Ý8/0ñ+Û!!E°©îÏ|ðá¶m€ýì—¿væ ÞœÿqŒßª &:[Þq‡“™ï¶Ð‚q0 €ÕÁJF‡1˜ã‘ùíó'î=ŒÝó~Úï÷F36Ë+,…‚½Úõí-în!ꚥ‰Ÿvfƒ8öf‡«¿öw~ïg?õrk{è¸ïfM XŸãÝ·HG†î8&rA4·j À„ò,T^O·\­K"®»(€åŒcÅ ùG£7œ]û˜ÜER, 9ϱ'»º¨n{»nvsèÙøU†w#ÜWb¨Œ“zWîÂõyÆjÏZ´õ”é‡öª-VQR7#{Û57RÞ5ÞÚN,e6¸ƒeWÅ©Épîb¬,ó@†—†Ã¬Q''«€zSßLׇntc´á£EkŽeŽÁ+ÄY`1jWÕ<Ï`¿²¤ð:×C|æœÕc5¹ZòúÇ$¶M÷ŽÓ³oû_þÖþñ¯ïÏh¶Esye4=^ß‚×ûÅÓð9™ÈükÆ3“÷ŒmúÞ;%COw­{WâzÔ>:Cê'v”•ÎÉôÓ €ÝŒ´šå¤C> ÒEÊa6tLr1ÿÒt˦‡;(?,Z€ÜÏ=ˆ "Ìš#ÁY8RË´’KfÔpÅå_‡Fï[@€$‡Y?öcÛ^~ôzÃac»dpq€p›ºsV~rƒ6¹AQ(dÂñhüp³­YwIn3CØéîtu}u¶Þå´¦`f',#Iµ€à×Ée’‡®ž#§GÓr&ïÏwÄñØ602J‹FãdŸ“›"–U™ÐSP€CÇ«Ãí“›W¯^o‡+ŽÎÕ"[`Îtá ȱ¦q¤óÀ­8~ çbK\š r OšêÐø²ñ‡lPåÆÍlïçÈhRªŒ”pËr´Üúl8Ÿö›§·¹°Æêx—"ƒvp8Õ½øÚßðùëo¿U;Ÿ]¹ù·f’w3›-O$*|•9·Ê½·À1ÍâWE¶Ö@àXþ}+¾’×Ò\Ú3ù^eä¼: ñ0+‹q°¹Wl»v˜Î8¯ŽíxØQÁŒøtÏb€(—èš·ÉE]öAjDªf@2Ýر¶3bî'ÌùYG;dI|ÜÇ­¿Áui—;»öšRk„é­Ü¥E´¢ò·e‚äúÕfGEóÈ xæh YÕ_tXãñæDè=½lÞ……JXÏXÝðµG¶Âïã\ŒxFš‚%53s{ÔG4²)’NI¸(ƒœm»ó¾_æ·ÿà¿ÿç¾Ü{߶ #%Oë75·¯ÿ _å1€Gàã}¥G‚èmD—žüÇé§ÿôŸÿ‰¿î»¾ý!šž=S‚V¾KHåeýírO¦ØcqåQp/eÒ%¦K-W2„iŠ¦zßpuˆætÂÆæû.t¹èãÞaªÐÕ£pD)ºäQá_€¸R¬lQ2,ƒìÉk©áBðé›+&Š Q@ÏžA CS?pñÆ8¢‹…OÇGý»´’ÎÑ`}žÉ;h ,š¢Ùá«Þ}\  %}¢°Å iU羫“„ñæÙíëw¬†A†6ÆI ûJÎI½©’°Ro:––¿L,l·øÄj}kvXŒ{ÔÒÍ&vql˜Q¤oA»¹ØDºör¦1ê.ЮxuàùµNª¬€@– KR8¢E«Á\ݬ·§W¯7n0ï{o´îiØÛÝùtýäzï½m­2ht®O:‹–¹*Æy.S…wˆ,+‹Ù“íþ´kã¡mñ®±‘•ŒÝ0Ž¾¨0±QÚ¨ÝÜÞîÒÝë³»"u $<¸Ò©Ú53´2ò&ê$-†×˜Ìa¾¡6)°ŠÍ¿žyIÞsÁÃHêò'Ïoº÷(øäd kmËóB3DŽƒ‚ë¼¹¶m‹2v§g ¨x((ï‚K4ù§[ÿeßö^ɶC¤óÖZ¤¨÷€ÝÑ̲|û„ƒs'-ëÁñoÂOb¶•bàa8É´©RŠa`¾Å棆›?Že´L©‚©¨ã¬ÚÓuí¢»öÃíÑŽmg/x]ÍÚž ŸšµzÆrÉt¬—J Ç‘Ù-–àrÓŒã¯ñŒ¸ü†Úëö骣Æû†“`|哺4R,K£ C–®¤ºÅ á ÏcG'—IÉ’C<xÜîé]¦¬ÿbÁŽ±…© 5”;³¿xvm¯OP¹K)(ÆÆæúÎ eŽ· oKH(zœu9Ä~Æ+;üÙŸøÚÿñŸÀõûSäá…„[üãõ­v]œ†º €óµ,yº!AíÛáüÑû³ïþ7Þ¿=´Ö{G“±iyÖAG†1á€ÂX~á‘IXh.šÅNœ=þLUÄÀ­ùù~ÉÂ4Wöˆ)œk´£Î÷BGi;%&&–°m)ZBx®À&œ}+SDåL¡2ZPe.CÉÕ3'½{–§>9ü½OYïYОþóL»;{ØŸAsw˜Ø;Hhtàa3,ž+h$®ø!¦ÍbtwcS—i¼¹ººy¢Äè’úlÌ@)QJP#mëI“Â\°‚›¡|Œ×0æqò–±*ðùeèb¿•= D²ià”¬–R5¨ÎrY9.ýöxu¾ëî»Ûf®QsÕSÇ'‘© 4¯ÚU·½ï½ÙæÐÖïÄOçׇ«Fëí@u£L¼,˳X!úD‰XÜ{³-ŸcAó#'“9¦1vÞw76ËÔÁ4ðËàœVáx„„(£Ø‘è’mÛõõMß›ôÂå³"pØÎól¤ýPsŒ§€ì\ª‰…532@b$œïÆXóu½Óø.J†>°{ÿÖ°·½ïÇÎçn´(dÞ̺«èÝ#VÖ»lk‡ãq|%„¬h ÁèîQ!Å{!ïׇþܯú›¿/¿ÄÃñ棵¾wÚ&Eo= b³Ý“K66á2-«YT§¿DÍÈáÉY^&¡fbè ¢Ð¾êã+æ‹ôâeÅãåFÛ«Snž‹oãqY—ùáúhǶ›Gs¸K¼¢3£,9Uxx‘é9ܹ ®Þjë ­ñ  ªàäg§Ñ²h²&jMÀè<­âôõ<øŠ|`×df§…CåP†Ù\yJ³†X8E€u¨€Zš à±áx¼7îeKD/mR⫺.¦ öÈØåtÉz ò$€Ñd¸w¹r‚†.^”!«ïChOÑvé…÷üÝî~·Oû©ÓkcË¡s1z¯oñëÂx\ØÙ5œOð oL—ŽÏ~à÷ÿÐoøµß«/Ÿ^]ïÝ›Qp˜búà"à4î›ß0C¿)ê®.½$Ú–7¡á¶Šæ¿ a”îòBÿ̦Z¶yï;jœ}•B£T×°^_|ò9x{aØ ÉweQ Åp9™fÆø=ëî_è˜ü™SÇïQ< 9$Ó¹Çx6+§vLd ¡Æ#¨ƒ Z³çàKU ßÌXq”§sˆíŽN£ÓAØØî_Þ06¸Õg/4Á™} Góæ]½“’Z"„7Ûä<$£tâPä ¥3¸ÌÇ{ø`RŠ˜óY ÕÃ:òMâƒ3@¥Tlaöä ŠMPž_ýb;ºï¤uïÍZ­c¹ÿ¡ÜdD4ˆ4¿mv8´3Ü@ë4â`‡×÷w2½û©'wçWïöû¿|×wõýÌÖ¼{ €z&i¸÷Ó¯€bšUl!½17¢Q®¿¿}{}s°ƒ$]~ض¨ròLDçã©û“"`çfí;NÝå`&¯Wpå­×êçuJÕæ›Ð4ÇÂ,)µœ©7Ð?06L9¯ä„bBl<ùÉöÓNÒw7ãÞÏFzóó~6³¾ï·Cs Z;¶ÃAæ@ô¹*Þ !i­«7š³Ëq{ ^þÌýoþÞãé«ÛáìLq|ìÐ"c´GeÏ8ž»vŒM•—\®8çõ‡Z˜eÂ`Õ‹©©3žpu¼{ÀûÔöâƒ^|õÅÕv¸?ݬ©™ï{ãô«›ÃÝëskpuɹÑ#d•e#¹´Î†ˆüä@#µ\£]´×|•%^l+×ùµÎWǃšžÜÞ¸w¨ áUÌ5ö[Á‰ ®4Ý…­Ûu µúU gࣱ€ó8ô…¿€M5áóßüOm0—1¡£„ò‹"¬a7]¾û¹÷]žÝ§cÃïêWW×÷w¯Ú†~îÜpu8<}÷Ig?ŸÏ‡­:nŠ]þÎgž]ßÞÊ Tct¶3dš¿hîêp3]›šüô•_òîõ÷~î¨óW¯ß?¸ïG nX¥0Ì2ˆEЈ‚™»;É‚9•\í€zþðËŽ0£r&l„¶¦cýBh•54›–­g§NP‡¸öNò»ÝDXÖV–@™ä­µvs<pnݲ¡qVvVíÉ“ŠõÂ<(—€>~YåYÒ¶co-Gx½4Ðörª‡–fÿÃ9Ñ:Ï%ëØ %7,-çÔ.7Ï—¼ž+}ïMÙùƒYl+;lmSƒ›í$Á   zØVð JçhúÙkr äkiÖyi=s½‡ù K×dE¿øhpß·f›ôòÔ~ö•ýŽþ÷öÃûè2ÝôÁµ{¯Åõh|Ì®‡'sÖZLèmó¾ëêðîþwþô÷ÿwþ}Âïl£œT“Y×¾º%è—’š³ ÎtE$¿¹ô¤€ž9)h•S´r4Ëý —¾äRùÙÑ[x]±/)àòyT?Ž’e)B‡b)Y˜e†Ö‰3²Êm\L(‹)ª 'µªögÀÛJì3°™|Çœ¡²pª uÎóDõÓ†`¸t f¶{ÅHc!ª¢Æ?1âä  ÏGg6’âŽDˆ„ÆvÓöûóÙOQQàæênÞ ›u9Ì<§ºhY—< g¼”êz–¡ŒÇßzÖiªyLÕJ‚¯Í ƒ]ø¼PA÷‰ü«O4X³¸ a’ºØ¬û ª÷›ëí~? tt¯v@TPºEÚî'NÛ*þGg‡ß<¹>ßN¯öÃ᪻ïôîpšI7×Ww÷÷`”J¡-¤Ø‰‘%ãò -Po4°b¾ÕÊWü"æ»Lèb³S?·h’¡,Ø8^Ѿº6ˆdÇÀ©Qê&IËN{Å¢*Ñcn°ô& 3ô y®äˆŠ:uÀÔHXÅvXc@VB÷ òÑÕ­YwvïçýÔ»G66 ;Єlø]†ëç·'ÛfæhÍbÒº÷Ãõáéó§÷Ø­\n<¦A¼ËhÛ¡w±í›Ý=»úð?ÿÝïí}åxc§~FÛž±HX³ÜçÂBD»d°DrBœæb~h þxCÆ!Yó( eÍ06âã=Š„8 ŠYŠ‹FûqìŠ{?á #±Šr7è†ãÕU¿æN°™Ô}µâ©)DÞŠºWƒãÂÃ’€Jk™•ãü˜Çöw_rpÓ&ÏEŠü²3.mŸÊ˜cXÎ.‚¹X¶DÇž*ŒØS©Ô ¨“ù&&ƒÙKF°#¼ŸeQÆ×»Çlãvp ½ø<Ö%=| ~øÃÆ–ˆUB—Ͳ赘u/†$U %ocÛ9ÒsQÖHp‡õ~hêîövºùÌÿìñ;î·÷}Wk&Z$Ü£QÚ˜ñGôÿñ¹ €ÍõóØ契á•áŒç“®®?ýÏÿ¶ýü?øo›í`NhÝ£F1e6]âEòg™Ÿqk@€»EÂk~N ¤x ‰ÖÊÃ4¼A‚ev²EBeh)¼Ý;\„£Êë/0=fÃ/Ëx nÄŠ)‹™MQDÓD”œ– üuA©œßÂáÒSû~6³paŽ“ãúJ-çVw‚4ŽGùÉÏn¢É‚†!cåȬƒnùä¬}¢`ÿõÈæ|º˜˜ZµôƒÅ<—&®ñç>z Ù"ÉjZþ†XÁ‹=_SÌ$ᧉä~{¼yñêed:sIgse Ò´)æár÷ͬÛÕíñî£3…Mm÷ô*AOŸ>ùêW¿¾éj€î2yXq3‘ìÞ¸÷ñ÷ÞckÄ´D˜#cõ±Ž)dPýº»»?,(1,¦I½X*ÏjέPùóÓ¯ZÐg  2ÇÖ­²‰•kð ТÛð,;“«æ媞†«[UÍÒÝÍ NÂN÷wÞ ß ÙW$žaïw7ŸþÔ¾wÒ$vÇÓ›k(jû»Ó`<ŸÏÏž¿sý䦛Ôàò­ç®3DRxIãÁº:èþÅÿ–ïû6;}m;x”ˆ‰ûåô³„ɲ¥jÏ/¯.  ™#ŽEžÉmQ{Ři[€Ë 2}YvF#X6â`œy*ѸÉEg´}TT’º¹êÍ£g…»—_ºr½²VÙò€‹¥~‰I»¨ŸeHóTå`ëÁVÌœ†åVs:W‹áÒ|îšeÚ.EÀœoVrYN&ÊúÔ(‹ e…:½˜ %(9äàä|™µfÛÕÙÐCýäyO’ó‰T"ŠCÝ…w¿âáùð,”¿Ì Ó/TÍvÆã/3'kDÙм‡û)S}LÂÖº·3ßû¿ûÏÿ‰?ûb;~¶™š™«H‰SýÍpÅãõ-x €Ë¥)^Þ¸øð×é;2Ô ·ÿÁŸý©?ñ=?ùý¿ì Oü¼ƒêòroq©0ÆLž‚=½ÌêŽÈE\d)÷žv²>CÒ)ÝbÁ€ «ùÉUì´ÖŠÓ>*rpDxCÊ2kÎ +³{øÆIJH?Ê$>Î@»w3¸(I‰Ë8à åÁUù•§ñÁ$–b$Ë¥‡¥ ü …?à4Êòª'Z«HÍå8kxèK‡‘ˆê.e0•Yjèèq*dzÎÚ;öšËܺKV 5|I9P‘ù{è´B>:†ç{Ú*æ´#Œ Ï‚êZž¿vuÍï€öÕhªc€Rµµ&r°pÞÕAÂõäêöÃûWhaUÍ ©õ¾«ŠóÕÄŒ¼íæö¦Ÿ½ßI»-:‚¹ûÕñzk¸ÐCG^]"º3ŸËÃv÷ì;œ¡% Éjîyn£[uÌwoÖ¼ïg`Û¶f6ÚA{Ô/JçßH|‰ý—{',ÿ½ÙXN ›k¡ª´˜¨„ Ñ¬Õb8ÖR3‰ûŒ’2½¬¢0P`Q´_»Ð .8$Ø=wBkvÜûý‰2ïpù¶"Ê"À¶öúþþ矾½yºëL‹Â-Ü=’°ãÑ£*+b mfýõß÷…O¿×Î<¿t† Е­Q.}üi Î&\CÂÖ»2öµ¸ '&Í9†º¹æ;ÊM#°z¯ ‘0:Wh|®ÃõE‹r£ÖZƒËw¬©ÙvuìdÏ£/M@œç±º \˜4óºÌ‹ T?r©§y‰êS>p,Ä›6K‰Ìø¸_š÷óæвOHÙ« úŸž$TX#>5IËЙ¤«z‚ibÍ1†Šq€.Hæ{d† Ù6TÕb(šW)Œ•Ó™”%²HrÔ¹-Û)G¶l‡áû/‹dl“7æ9ï£ôüXŽF.4D¨tçÉnþÂOÿÏøÏÞû¥w÷gcÛ»h^óv±Ë¯×E‹ðsyA‡¹Â‘U ‘ŒiŽÈïøEŠ¥¢ÌhIøÂ¥eû˜4,Çcø˜ùbf“Z-6Sn§ªè·Ê0Ô"Ü£‘‚woF@vÕº¡ïnnn\j.Ì*2ÏêPÀ-“K/¢¨»5•ùlåÑœ˜ãÃK@,,ÜdK~ö˜äÉ`-XÂèi[T÷*ˆØH~A$ÛºoŽ×¯î_gÍ„†îvojpT<‡‚"³yp·o­Ÿ\Ýï§îöÐïFªûóÛç_ûúÑ©—ÌÐ**ûsvU¤v—(ÔÕ—ÍèÑÈ…½>ˆ0šwoí°Ÿw¨cƒYƒƆJ ;¿7@EÀÂíÙç\Ö´níSA¹ØÐy”rÃØй÷½ŸÝzëÚãi÷® C™ŽWÚï}ßûáêÊswÙv8OÏßy~<^í<Óà¶ê³2A¤"±ùGŸ{÷þ ŸÞ°hä.lŒ‚Ÿ È; $g3”ùw :¸ÆÙÖý"¤/gêòJX™(˜õåF2'KßÖÖO{=í}§Á®{¿“Ñ6¶›ÃÙtV*òêÝ8F¢á½^r=©oþr9»¼vñÑ°iVÌ=¡vùÁu91 èÅ*Ÿç\å„.’a1æÛc÷M HÒâ#5‹¦ñ÷”oÅà™e9I26Û ™íþœtYŒGOÎÈɳÇbë¥ÊD1±ÆJ\Ì_y‚jê4ŸkùU`Ò IÁŽ“vŠháU0Úìïÿ¯~ó¿pûÎç_½zu¸º’G,MY9ï÷ܯGà[ýPðd „B ˜Áï7œ{çSÍoù­¿ýú?ú ýôµëãÁO™Ù9à›{*² @£ˆ á#ÁYŽ¿¢±`ÖÉó)h\ Q‹ÌG-:*z aÊŠôþ¼á§ÁØzß=Pºc€Ä¨rçQ¤õ¡o8ÐhY«§ª½*Ï¡Tþß—! Á–­ $¤bAeb–ŽŸ&èO:Pfx^ gJùòcUð¤Ø$q/bCËöW*øø!|}æLˆròƒmæ®Þ%Ѷ#L­È¬5¡—Xe­)²âr¨ʸH¹ ¼`MmÔä ÇcÇbbæM¦Â£ edJFub½œÿ¬²—!щ¨ÙƒÓ¸Ë7;p8G TÌúúŵ2›y8 z»ÚÚ•¼Ÿ]»Ù1†ØáÇ««­úÞÓÙ¨®„fiž™wG£$³¤-wíå’iŒ|úˆ%•¬æ!–¶Ÿûa;ìûîÝGF¨'Z!„Ѭ6ÐÁœßªô‡Úà UÒ¸'Á Äd#¤±#.Y‹ú£¹"±ë#{d´yæ8ÐŒj£³c½‹‚Ÿ@ß\.Qr l*âú°ÁÝÑ2ûúæÆmw§µ}ï··OooŸŸÏg€ˆ`$j»#Ö/Ë+å×ÃíüõïûÎÏÚ«/Y£g¯kuïè¦Új(y4±\ 7Ê+b™=9ÚÎÿŽãŸÑ‚-¢Í7ÇINInçú\ÎhÉYÕ—”C(îZÙ [ç±ù.·Ý´[”³M½¼Ê%5Ž(/†?¯Åݱœø‚­ÃÚ™¤⤬ÔÝ¥µ|ǪáX‡8~­‚ùú7+îÏ°qg¸ãLÌ ;O>L!kóhÞOª\„‰ÜÃúË%ʼˆØ%¡v]¯35‘ËÊå_GŽ.õ:ëAVN"Ó›”V+AìNni¬Ä)£»:®¾íóø=¯ûgöó¶]mÑóXX¿€õy¼¾õ® àq‘¿¯RñçYÂ_JT0(9­ôQ¿¾yö/þößõý£ÿÀG_ý™Ã1kz(—$ŽÄ_ËÄÔÉ µPæîÆÅ’ä¸èêM6¤îäXÎ*¬.‚p*<ÁæPÖ2F^ J.d•(šÏó¼ ð»8ª§ØÐE—Ó›Fζ˜ yoÅ×uÐÌ݃âêšY¾…Ò^_Tz2µõÔ:c™¼›£Ÿ3î‹€.ÊÁ’\ëQô¢ty¨F£²2P“Î6±ƒí¸üÜ»¶Ô3#5§+ЧgWšŠqœ!ŽÆ”š“³™¼ Á§*Dšã*¹¼ttÂnz‰ŒÙ „r[¥þ÷ê™Ê|µœ÷xQMmç¾_oüþu§ è¢Ü¶õÞIÛµH-çyG·nf0àúöæ|Þµ{GoÛÕîݸuî·Oo_|øB=*Çû6u_ŒKÍvïM Í4,fl-u÷E3Sî$»d¤5ÛûN3À_ŸîŽÛá°ºŸš™gù¯ô2²œ`“Jç=æô °•u @35¹Â?mk±¸#¦Û¾öšØ,Æ·$'-¤DÃèww÷7ÞE³,àˆÔ}¿ºº9÷“ÙAÞ»týä¶û¹¯^¿º¹¹}òäù}ïíÐÂ…Ù™8o#MsPðãûÝÏüÍÿ¹ÏáõWZ›iù%RÍÇdçèÐxù`§ç@3A‡/¶éz¦—C¼~ÓzíÃ-$GeÞú8H5¹ãH“²fÝ@°+㈯LÜ°'û’= ÚXz:ßj„žŠªø–ëâù*H9NÉOùé…ر<Þ7°-±ÎÛƒw–dŸ¯=œòå&ÂÜõÖáG@NXÙ"µ{s½‡é?̇¢\Uìx7sb‡ä0¶žáñfU›(^•‘),“æ}ˆ¬*¬\¬Á ¤Oã,î•Œ‡„O±‚ Éús…š’I4s¼Ýï;Þùƒô'ü?½ÞÝa­Øø ×·îõØ ø[ýú+:¢% † C†Iiâ†~>üùŸøÒý¡?õwþÊïõÑ—¶í}8žPÅÃñìúeW­ÀI4 (y/4l‰ ªƒç±¼ÔåB 5=’ #Qò?Šß«J$†ýáRË —Ó‡Æø{š(ãõ÷`d’gIûrç¥6­¯%.õ  Yˆ­*Üå'3Á èéNf¸àrIB»øP}=2ˆ\ÃKhÆ÷¯b&H]U.ªñÝÃó4Æp5MR1‚Î -€Ö6ÛL½ æ§8´x<îŒÈDŸO>Òëå0šWvDZBbÅÁÃÄÉ[šÃíèÃoˆÜ^¦ä÷Ò#”ït(«¼æ2£R«¡ÒAîÞHÉ­Î;Ìi$·½ïF¸»eQ¬´(úÞ·ÖjŸIB‡‹ýé;OöwÜÚ¹»5ƒèݯ®/>­¹wIÖ2ÆÈîxØ»¶C“{ãæÚ]hl6XRŒŠá1ß=á;\2—gæ½;¸¹Áö½»tÜ6¹ êH—bÐIdVÖ5‡Á ¬GRk¶›+Ò~ÓCNZ3ËÚ¬ùfÍóÅè7m4C‹MT{5|ŠC}ww ‚w‡ÐH%5ÐtØìu?6w·CsÊÚv>Ÿ¯on¯¯Ÿî.Q}ç”Âqx xWãÐA6î§/ßw<½î/6u¹ö®è`Ø!3óáò˜dd"åy«» Qì‘šŽlËaY1mTQªTÁÒ¾3']¾Bv@s!)';‘5Ì`Ã3§¶ሬV82õMêu"U"“å(_ò7Ô5—ªhÀVâòߟWW §þòÁŸ÷ë )¿ýO¹`˜²x‰Ù ;Ž–僓,JX†éJGÔùÉŸ˜<ª%6;+¡'ä›AjHΧUk>…jÝ•á¿É+ãÁ´üç2€Á”fˆÃîIx×ÖŽ§ý¼Ùv_C{}×¾~:üßÇñø¹ˆæi•c!²>‚Á÷%a×ê‚@P²†}?]_ê÷þð¿ó‹ñ/úÜ{×»vЀ=ˆåX´>@BÞ—êƒX™p”î™4ŒT„EBûG¦ w Ù+Ú^@@ÐÈÜJ?ïªl{å› Ó\ÉN¬Ì™0'"`Õt;—d{©Àð¼Æ+óÕÕ“ €Tí$zé_’\’Yêô¡pqwÔºèP\—ýV÷ª„‚„ÉEÊ¥2^èÔùÆÌ«ÒL³˜´™V9‚{GÎ`¹ÈÃEš@áRQ•¢œ3QOEÄf´ŠD§ ×b¤LÓcà¦BW“²RVbŽpb/+Æ™uT;*¸ Š´Ãv¼÷»ðð&yf>3œØ­w'‰w4‡óÙ³wv벨ªÍ6?û»ï¼ó•¯~-æßä¡û^V5´pzùo•N½`»M´lîèì £•ý(+X›æÜO€o­)­oë.D?¬4:Ý6:z¸Ø‹4‚ô%p'mó›ËÅ ýÏ=y±âL^¹(ŒãÐD‡¢“½ËûY.8Ý"5:ÊûZ—[B^?^`b‡ÜÝýêú(¨ƒgù³ëç¢Dt÷­µîNXE¥HÉÌ.¢ƒ ºæËor÷Ï·ó«—8X41ò e†fM{JŒ:œÃóš6Ðïrì9felÿmµàÀú§ø<œÒ!ß<sSçæçüÎÉ~ "¥BÍsä^Vù­à ÈðÚ¸w‚õñ??0øFï`}þíИ¢¿y‘u–Ç]ŸþÁ‹—_õ–iZ,˜ÒL\>q1üÜ,iqP48`̺ *3Ú£J°­m$Dj 4â"ä£J©«Út ±6Ò´ jA§qðæ¯ú…yóç™úaNÀÍÐ÷níêþþt4ÙÁ^žš=ÿ®êŸüìæÛN÷j[spª'ÎÅx¼>ö¿ý»þÚøI—[ o9J×Çêº8æ&}ÇáØúùkÿ“ÿþo2ÿê±QÞAuuƒÉ#´‚Î ÊùRlE²ˆÊK°r8¡Rñ”ÄGÁA*RzSÎçÝ…‘ævÁÅ-FhÞ=ŸîÖwTG•E焼AÅy»ªA¡SrÝ ÿ9L Î/ÍÛHŸ¢¿,†Òï«™Qh T×ÅSù@ÿeÈ1jÕ;—GÁ…U2Þ5Ÿ6§Ä(pRK¥•Ž¤âÑ‚ÐÇ4,#®_¢J€О3Ϲ0ù ‹ÖFýqQŠG…ðv jÑØ)*„‰Ôíè"{u¿CB æ U‘Êë*µÌ®‹Å±)ÐQ!³ÈÞÝÐ>úúG÷§sLTøÝÃ1› ήŽ[g´‰Žý;I Ïqò÷ƒ9ŸÆIfÍ9!Кíý|ØÛÖŒYȬ©÷ªåJãö“?ùSw¯Î êѬ:R_aQºIR}Ô¬¥¿Üâ9h+ óüƒ€D)edD²,p¾|ùªq3°5ÛO‘H©´ l“Éüé§oŽ·8»ï¯ägnW×Û³+§ž<{uÂ|Tì'ŒrßZÐo~<ÿôßú×¾§»/¯Ž{ß[òýsE“ÂSµ›x6iâcW_õ æ­× æJ„-T‹Õ4_>ùœ»q.):µ§‰‘í@õ(’–%èe}a³9…âa^ f½ë:.Oã2Ío |ëÏOÈo\ÙX4ÌÊÀ &$ZÛ咷קûw°óœ3H˜Nlt·hï;M 1üñè…t›v‘Ö{÷>úè£Ýû&wY‹×MpÛ(xð~—í£4”pm\ÌŽ|œ ÿp쀢µ¶ïgkv8lÖ"&3dµXl„ýÅ¿øÓw¯¢òM8À«S]m{—3z‡’4𵟧}¦Xft<ÜmG9V¬ªØë—w{÷CÛ v:hš¼7¶àaôCÿ³ïÝw/ïÛv½Ýúž<{ÍÕlÞÐBœcœScJÃU^üôßöýŸÝ^ÿÜ“«Ã¾KìŒÐWn·´Ál™O\€®¹ ST öà ‚ä¹bûÜ€CÔ,ýákÖ…`Âѹ‹%/ cæ½Ý™-¼Ò8B8)P)ñDa‘ñt,+aùµðâšòéâ/"œüŸÍá~3„Q'a¾ó?"óâ.«FÀ¯¸›SŒ‹)Ï8Ñ``Ï4Xï°úšü”&Í2“šÒ—:ä u2bÑ5“¡-K«\¼w!s.â•Á­©±jF°k34;œÎ®«÷×üñÿ÷ø‰~zÞqrF"þÅ <¿áõ† ·ƒ†Çëã}=À~4 âÖº»üðS?ûáý?þ+þ¶_¦ »G¡OW3+Jm¸Ü£¸"RÅC † æwpdìrTƒü‘þÖt½¥ˆ:$ÙÙuyŒ’ǹ»+l´¥3ßîk+^äã°Þ21ïxÓÂlˆQ$­‚ Hœï¼T)¥VÏ}j_Ýx#>£ÄsøIôD!âeüùíoäUå¬d¥Y›맃ø¤š¿¢œjeØ}y÷ÌéuLà¾*üåNœDéË P!… ‘ˆÙ'¸ÐUEð*íŽrÀægËu»ZóV^öÕýLµX¥ãv|uwç-¼g# pj3¢÷~´Mî©_k÷Ì:Yd’š1R-·CãÖ¸»z´®K¶ºƒì'?étmW*Ûg¶ÍÓˆ™càµZ'®ž¼‚0¨ïn¶¹÷óùÜ°mFŽDäü£¨kp C¥ß 0BZ˜qW~žÐYñ&Ã_Áév£òÅÜU‚àÜ÷‡;ŒpÔ&Èe¶ºmÜÑq°ûÓéØ®ÐúIhÏž½³÷n›´{”% ÐÑ+úHWø·-Œ•ðП^ý—}×{ÛýGW»?ŒÍhRÖui«ã9*ñ¤€ðÕ¸Œ~>E„²üåé[8jó/çJX%R•"¤pƒ™\¶yÔJ:—шŽ-0§×Û†[kAبê[]ðð@v©¶÷r²1OàøqáC-~c¨‹pX¥Öœ…K,¢9‚å*+cÔ2³Ê‚åpZþ¥\]‡TÏjUŸ@X­Q<:eHXù–¬÷]º8:Ð{•Û­´ÛõxbÍÁh¾U Cu<]µl:uÈÊ6Qê‰êÇw¨Ãíö?ù‹¯çïùS‡gßi‡¨:ÃÕ+8|DÿŸë± è'ý;Ú™GjâNg»ýƒäßûEßõ‹¿ýsOWØO§ÆƒäûyÏŽ¼2zˆrà èrŒL"` QîâŒ"Ú̪ô€€|iå~¤[Î[Êü I˜”e !¥vŽÌU“)º$u 1Ì`P—uQ8SB6ÅÊ©™á€ëŒÅxÇ )ëÇS鉯Ã<¸ð× T}Q/Kr1e¨‡*4qâÍà lžÿ\¸Ï/FÌJÅÆÀ˜#ˆ²Ä̉l>eÔü¢‚‰òÞ-õWÎÏäHTF¬݉.,Ä}Õk>R³2¸‘™æøLÚE|Óš€<–OÃm†òy)'×eU÷Ó¹“íæ°ú~ö¦àÆTŒ]‡¶Él°G„ÞâN’¢<5{XýÉ“§_ÿú×”êÛ tWƒ©»µãë'Ê×[ὌgÑëWD‹Foc„uô$»DÚ¦pßÏîÎÃÖÌbÖ½–Gˆ4‹œ‡X[l`€ÖÈ´S9S¡ÑT¹ å8H¤v"³0”tÄX4Žóéý¿àضƒ÷^VZ|ëNê,½óþ;wýDk§îÀ†'ïÜv?YÛ¼w@B7… EmwCôº‚.täý{ïú{Ï»õÓÞ3Ù7€PïHA¶ g¥ìUä6ôz¬lÁ1©IâJ)¥9Ío9­ óíò¯åòÈÔÌyhc¦óŸ8¤a˜åÆ £ÁÌÉT–`³5ºD§DS«Ì¨”:äÂ:âäås,ü[„Ï7»Dlß|ÞBŸzóÏ—„$ÎYxsÒ€É5Åb´\ܳŒÿ%‡*^Rp|ÓtD6yXˆ}Ö8»G‡l@ú(7œ Ó¢Zœ?9‡—çDºœ(>˜Ô/*Oÿbm ]½Úqt]4m:M²»3Îíßüû—oŸ|ÛýiomÛ¬’ñÀ½õx}2®Gà“{Ó>ßÉî5¼÷Û'ïÿK¿ý_ûþ¿qÿèÕííQ{!ÒÜ÷h§@DP®p†õ'ü d§*& BÜIÐLýƒV¾ ¢2 ‚ó08í‘%9qKyb$ æ.Ð ³‚°‘qeË^‘ '}‰Õâ‹FŽ-ׄžJîæ¥.âDÛŠ­*¨—¯£4Öpëa±`êƒÃðXD09n¶Ä€/ ¸>’škêîÌ윸 úéOÝà8ýFœÜŽ|ÃX€E·)ÁQh)êÙ¡(ª©,JÉ2 Åä(˜l `xŽ/Œ‡Ô‹¹t`HêN°Ú•y¯1RCø_ •– RçÑ(x¿æBÔõó. ·f:u7õ® 09{3œ÷ýhÍ]I*É =ÝedµÃËÔð¨ú¿«·¶‡óý)‚iá5ù4˜±Ý½>¶]… Þ¢"b Î¾çff¢Wù¤U¯‰Nî-žúikÍØ œO;‡üHrŠÜÒZ 0uc@d}ZåÒœ0‡ \µAr5 ¯ Væ_‰Ê½aÙ½v>ïr% ÷žµhŠ¡GxÀÕñúÕéþжóywèù³çÁÇðÞͼ“èM$Œ‘» 2Ì I½¡7m÷_ýë¾çsv÷eÛ»•ŠÂŒœNRÂU~ž¹‰Pãª.cÊ3¸ µ T'$-ì™<õ „=ùX¿µÐo’í4vl.KÑìÙ%Ylé .mè΄j}˜)Øç"§I^y®óá8þ)(<%ÔòœË–_˜33Žuù¶å xø¡|K!«©\EüÈêé«ù‡ñ Ò0H;€¸h­\î©”âSH£ËF«ÛÆ0Ç„/óW=Ì{c…ýó”¼qU—ƒå­q(9ž ع!ãã³îoäî¸}ç»ÿçÿô¿òZïÏm;˜TU=0gìýÒ®Èìòoá'àZ±à”5ç7·ýùñôý¦äþå‡ØœèMÍÕ·fÕ kz8åØ£ $ÀU•ì»2ha‚»¢ÉR Ê®1:ÒSå0+n,$’ ’„PAƒ¨ ½œÏB¼":÷s³VÑáv]øüÓ4ʈÄhq6$»Ê4U^~ŠUHnÎr€Øå…:uCí¨_Öت8,Ì/ú¦Gsb‡ñûêHª»&Gùà(VQ˜P„ÞÊgÖ½Y⸃¼{äË®Nh%«j¾ñ‹þV‹ê#Ä,-—Ì(R¢¡ª>¨Eµ"³zjþXêxFO:ÜVÍ“3â΀OæÝÝÝmÛ¾úòCÛ³N&ä~Þ¶M]`TtÕ:³ F¡Ã³À'äP@´Þ»ïþч¡Ë@Ÿ…«ë›>xé»l³§ï܈»±x13 5†œ&ƒôò°ÙEÒ =úzˆæýx<¶Ôäf°Ÿþ©Ÿ{ñÁkk›]3‹['ãŸ^Öï<÷nÙÏaÚØU¹ cŽÏH ÉŠFÓŽû×÷Qª_.ÉoŸc,=¹¹×˜F)ƒ‰½L_ÿžÏ]ßèµiGwQ’£\ÑÁ5÷d†G&Õ4X3_8qÐøbaœã2Éxa±çi®âgA•swâÉ|{<Ó4¡ðF3*öÂ6'`y`w57Â{•cËu![”´_ ubÄ~ÿ7-™·‚Ä #çó=‰rh\üF·[n¼¼gÆX²Þ'澌¥7Œ³2£VàŽ¯£RY\(ˆœ·lfù6…‡€uøR˜+þky Ç&Š1O˜þ`ð« ˜ÆÙž£ T[ËXœÆyÄ⌴ †„ïnF‚÷çÃ_úúýý±?çí}ËMg©=ñ ðóx}²®Gàñš¢9˜ ™¹w4<ÿ“æ/|çwý’ïýÅßöÁ«ÇæýL Y åaVâ•[x”õáCŸ©/ÔåK7 ËÑ;B²Õ§ ŠÛÑ¡÷ðh…ü¬ qèjfÉ"::=+£DÀùˆ m‹¾@×. n²Q%ÞW #_¾V01v:p¦wœƒSáqNu`)Ó'À T@FVmöðÊáÍÂäf—AÓ€ËǪÜÍñü Ëá*)I˜(·ž”\† !Ø\NnÈ´T ŠŒWÖ3¿$ÕáPnÃw­ž-lfIXbD R1#õ°ò+Òm™ûÖÒW=êâ¾Õ2ЖÊoTȆ:³ r &^ÙñÎÏ 5³­¡¬û™˜».yø©V—)D3t÷«ëëû»{šÉš÷KnBÜßí‡Ã›I¾aÑ\ âÓj©ɬëa.”%íò† rѲ72‰î€íg—`­&nRs´Œ¶D¢ðŠ†™T;E…’ð#²ŠGêð¼É¬ w ûû¢X' Àßâ‚wù;ï¾³Ÿ÷¾{;nçÓ~ûäÖÑIë.4Ö|´HáÛ¯co8P j"vùõÕ«OéÅw|êýÓ«oM.÷Ýq¤HÍG•”^Ã5<$62Šx`ØÁš»ôâØóf ±{]ÀÒ€™Ãˆ¼ !r ¤‹NŠ”µNÐ2à#- è–Ê=rTT÷:Ô1œ(þR6¯Kû†0ÊYYË]ÇÛ§3ì¡o.Õ\ÜyÒ꛹üå5vñY–yðmÊ9aºYhÈ{0úFg¯š/›ªZ¼[Uß[U°R*§X! bþ\UÆ|¼¢Uy”éx¿ ”xTªI{ß[ã¡Kûi¿2 öòÞtýùßüýíÚÞïgmÍ‹/Ð¥µþx}B.áÑx¼°H€ ¤'hç³®¯ßýÿÊ¿þOü¿©á  ÙAÒîsÖ\–ÛP4ñ­£ð–z¹Ê‘FþA•;+S$Edà¬À‘)aÓIÐ-/VÆ°Š­_"~¯ Ü R†¦÷Q6ˆrørz†BId¡µ¡ÄŒÁ!˜IiHóKk’â?Õ7I³.¶äÄ·¦ÖëQRº8Çe5å óË:§_m¼Tàf"#4˜ñË—ŽOHƒlŽ¬‹ÒYÃ4o&G7ãà­W›Œ‹b+GêèEJÔ‡¥H˜ÐÁÜ?ÀäRÍ_kžÍ°îÄú˜P—;bì©…ßÑ›í'ëîîjf.íÞ[kÓ#™9îiMÀ—`ZšY(lÖ®¯®ïîî^e^5³«Ìw¼~u¾}Ò$ƒyØÒ”\Y{< ¥r/øÒ«ˆ%íÛcÒ¢…­‘»ïÞ›9·f4Ɖ4šçAò¹“0¥YtØڬàqE«IgG4T1ÑÜšH§õè.æKé…uQbZmÌo,Ä´‰Jð^ý ¿ Çx/à¼Æko½. …oô¦y®¯ ÚØk¬ùzÛP§Í1ÄÉJº/Zã¼;Jª¨jˆpr$FTð¶þ•P=øP[dŒiŠŸáKSñ˜°JŽÒš¡.|fFoÉs¸z͆Žt/ç=]ÀŽÆ#ˆÓ~6Ûš53ëjǧŸý?ýó?¬íýýŽÍZ(!¨Ë¥{¼>q×cÀã\.ôP Içíp}tèõ?þýÆׯ¿zu ÜÍ¢\²¿R3h ¢Bñ*OX4ø)â]Á4a¢òA|p6#¿U°îP› 4¡sˆúicTÓ{Öx(ˆQ*$=bg†ë/Œ†ï-ÏJà£ÀoÞM ŒxÁ¿dù¯.e±Þ<‡y>9ßÍámÒjó¥Q8ÙºOW÷]J=.o}(ò ‹•¬HÀÅ’P×À];“r0î›æI,iÖe!˜bäTþidˆˆ<¯zï´VŽìŇf0fÝ2I6ò›yØW®> lVÚÌLíõ‹×”e|&‚1†Û'·¯_¾VÕ"ÛŽöìÝwïû©‘.XãñúúÙÓçg?BÊŽÁÅvàFÂùÜj­ÛýWþÆïýìõýן_é¼w¢ŒŽX#6ÉvyDÏÈ?#0¼l u¥ì‰¨JX¹l¢"òÿÌŽÊåYÓ3[±”7€ˆ¶( :D7AdqXn˜n§åܨh?$wÞ>b@'`˜,èÒš¡ ÌÃoUx¿0PøG‡ª­›Ža>X›ù·‰¡C‰xr‹ó»Yu©ƒ(å2þ°X0a×øæ…Ãë#´]ƒLäãéAÏ2>hñõ[Ä~¢Xe‡Ý²ÆVAh‘Æ*°ODyZí`Aý.Ü£pMBn¦Ã{Lž&ùAXŸ èÚÇì `Õyt©Ñ[»;ŸÌZÓ3¹lÛ‘ön˜Íd•ü+©Bý1k‡ípß%ïAö Þº’Ξëîî|Ó7† 2o6‡§q°â‹l±FÆcyÚÞìñ,aïкÜšu—Q{wší½' ¦¿˜YU] H¬ÍÂ5©±yÒÆ܇íXÛiÊúÞ¥`ÌÓ=hL xÃRÑ“çÏî÷{’î ¹µãíÍ“ûý¾ÿåp$ä6ï{¬|GÄýÐ_~÷§nžì¯æçÓV²Ë••ïgþ¤GQ«BäÄØ~XâZëµâÚ:ƒ…ùÆñᛀvåj3‡=¥Ðãäx”ÕH·s5©*á]ÌÔ«ÑÅ6o%¨8‡¾¸«óõ æ™QÒ…A“g;¤Ç´8X‘±9´¾¿äÖƒÇåüæ|ž!n ó¾eŽü­¯Ž[blÊÒÁº´Y–uU¬ÆÒ*Ycå ìž í㻲fW2[È:‹€!ªNݬǞŒAÌù˜ï¨•šÝiòì ž¡¼Mõáls9>šÜN»ofçÝÏ8þÌ—î~ïø÷ÛíwìûÞ*Mnµ;Ñÿ'ø)@׃+Åt INn0ïÝ7»ù3æ?úžïùž_ôŸqœN; #Zß匡$G2zpö]Í |9P¸u*Í!n¥ÁØ)Í„‰x’ŽRH‘¼Œxí NÊô®,y¡ Ñœêò-sXq– B3nAte Êô¶–*©? ¦:W²oÈÝÔñ€éÆ›þE•ÎöÕ¨k€÷Å9ŸßSžÛ©`ézðïºÌKuï@áQSéaW¯Âƒs¡Æ ­‘Pç¤Ád‘·|žÌ’è1£—€bÁ2H(óåø.ÀÕGÀè­¸Ê|’» €¥ÉY™ñU浿§y¹ØS¬˜3JÒ½7ÙÛÙ»H¾{a¨­¶¢×–ððL“±p×ñúê|în^0"Õ»*Ív?÷ýÌFÚf™§ªâÖ×Á\±WŒ\ãÇœùÒ˶6£ÓOÇ¢Ô·€>Kƈrÿ F2ËQ<ö£¯ìeS  d—ÁtÂ^º;Ý'M ¬YnÜ»äÏž{VVM;(p- øê æ"fO±eÇæ Í|¡ ËÂç$6Vü˜þ—ñlÓwà 徉Æ“|̤.~›s}‘ƒQfçäOX?ªã/œyçºífrwKž{Í Ð êëÚÇ®*:¡ ñ+àîõý«—¯¨ûöÁŽ÷÷þáW_G f­koGòüÚ¬gÈ$jb>×Øäãakû,Áº]9£Ÿ'd¯^Ý}í+‘-rÃè-«Î‰3Ën¹¤a/ÛÉ€J}ìHPvÿêÞäÞhvpýäØl»¿;í:?yöäps LcložÞl‡cDP "z¥áڣĩÎÄÕ¡é£/þíß÷~{õ¥«í¸»Œ2ö Ô¨ðÚ²É/NK •+c«^P÷´LwîÐŒ¿­ùæýówð(•U5Ÿ’†Þi¢É(6ÐÎf»œl,û4òm o3%e­-¶µª&OJ§úç¢Þ9Þ6} òz“¸(ƒêMŒrýæ9®æ÷.™˜‹h+¿<ÆÀ´ónÃcX?ËÐçLÆÈôW&”;-si²ìÄâç©É¸ÜAëY[D5‡á²¼àR`âBâ2—2œ,¤ÜÆ'²QîÞÍ,Ê'˜±w¶­mîû~óùÿÝoý¡Ÿùðx¾cÛ‚9& «Ûãõɺ.N¼ðh<^o^oÈSF3ºïÛÖŸÜößðýƒ§WmG“Ÿ­Ì)SÈ•ËHò"“ãI²é§q  ©ÙC¹ØTlˆÂžŽÊÐ]õA‚9’Õ¦¶„¦€–ÁULˤÏ"´(<ÖÙ–8ª¸ÁÓ£LWt¨¶pâHü¢Þ©›RYbè5wš5XþŒvËicQ'؈vñã—"÷›· RGÀàWD]/O%V÷ }|©ÛK&LdzqÛTù³GÎ9âRÇeç [’(rÎ-ɵš_Sëæ_Œ#rÕÈ1Ÿ3fF l„¦T[v‡»Ó¯ïÏB`‚šEµp©åG\Õv¨¦« ŒÃÌíçþêåGP7¢m7çûþµ/}ZÛzw3:Ï×O¶«Û&tRFó²sb‹³Pˆ™= ;eBæ§ÖŽd"˜@6Yí£_øõ—´Í³Ù…Æͽ’w»°Ë@ÍíV[›@Ö5¶¬­%0£{'í°^|øÂÔÔ+ø`ÉÄ¿zrµµÃË—/¯nŽ7ÏžìØ%ll¶m»yú´³Ÿ#‹a4bR¢.Xž´Íìîkÿ…ï|þ){Ñl·€g W>Òx+«§öêÄYÓꩳ»\K€T±oÿ´yp!1ìÌ\§ Ùл 6Å¿4· ¤ÃÄv¦ZÁí7Ƌื™ååÕGùþÇâMWöx½¾xùÓ|’ÅZ"oûÈ2QózøÓÓòæu1¥%â~Ñ¥øZ¾z|LƒD“[ô aXíu9³ÛócY{÷AT#EzÉíÉš|û4háy°ù‰KW àoä' ž–cÑ3„}í‡g}xì3üëu£ÒâCw^ó·O]NôÎéT¯·fp#[)O­Áê>>] Œýc¹­v@þ`<:\êî= Ô …73 ¨Ã Ñ›Uf¢—´,4h\{6—zÇ`{F·ŠŒTì ‘d 7³ufIul†óÙ#R¤AÄOû‰=êbE§«H€C2n9AÙ³‹Dkíx>¿jÖ€ð沞’õ¾Ûfw¯îÇ[TàtÙÉÅ“­©iÍtQL®> ·gÏ8Lö«‹€Xfq„%‘y¹1&Í¡Ö&rgYvZÁËitßAc‘ËÝ¢ÑÎç1JWT®¯’ÚÖ®n®wõáʬîѯYÔt.e”Ç sM„ÐÙ_~Ç;íÝm·ó=zìÄß‚B5hb*x¨Hµ!‡m¹RáÃIÞ±ÑúÈ ˜3Q?9Àõ8Vh9] ôÍœM0Ypý7‰¢ue$6F{Îs‰ýÂÃA0»d`HŽ™ªÃÉel$ªý…x¨7>x’úXê¾ãº4’piE¼ù—¬»lñ|,¯/ÆÇâæ7Ô#«•Ÿ© TrÃâ£!Ms0e_æMÅMLiM-*-~–'Bª­¦Èå%B}ñÅsÈ¥r¹÷èS.õØ„)wÑœÏçÖšºÄÌHrÇý©}å¥~øÿÇ:¼g¤õî4«›¬ƒy4>¹W– þÿó(¯ÿì^C÷Ð)Ôu}õÎþ±÷;¾ó ŸûÌ“N¸|»9¾|}wµXÐíâ©Y´!£g!³ôõš5ÀÌØýdfpx:»Ê™tš†Ã':0¤PUA8ü¤ã{Øb¬ÖT¼Tå±f‡ 8ðJ‚ØURU0 »³O¹ÕGšäpYq„0& Z€¥ ÈoÈtär\y¹ž€À’õÞ˜…˜[`ÆCÇã¥wO—ÔV¢︸Pë+~)«`Æ2òIã¦å«ÁùP9‘-NH dC“'lTÝÉ`uÀbÏlïùÄ5N  ·œëâ­ÓC>@ $[=‘›W.EÉÞ;`^^¾F»j<õVÜœÇ(QªRßPË{wÚŒºGÙþ«ëëÓù5­° Îèó*ƒÒ_Þø⣗OÞy’¹-ƒ,Q©Fz÷@F5)tˆ¶”ñ¹`Q€Éfh‰°iÞëÒ½™³žg$²}Vd—§­Uä¿ðY»l¿?›Ú:E¸ ,éðë›ëü”§ùf[Íá{š: åƆNY#­“îz²¯î¿ú=ßõí¯?úÒíaÓ.ö4X_Ÿ+ž!¤œÀÜö»»MWÖìüî6^œÂȱ)'ñÛñ`3JRó-Š]r3‰"EKß?š#ûL¸@6Ó(KPS@ÑC}€ÂBüÕ`¤"4ãܯì­ZM].àdã·üD>‹†ÈZþ3w ~xùêò|p’†¦ïc~t…÷w{Ї4Ønk ƒzÛ,ŒPë AŠŽ+áV`VŒˆ¬ùÂQalJæ……ô66 ë,å“Œo-ñ8î5Ç>c@UÊé1U#þ)É¥m;Bt¨÷n6¼<ןûÍÿìïÔá}ßÉ ٺĹÈêGø÷É»æŠèòµñ·‡gúñúä]+i±üèûÇc{ýêKÿ½ßô£¿¾º²¾{k[ßÏ-*ð“"}Ú… qá*‰pdQf “ÂF0ÁåP:î,º}3KÐÇfjWøÖ5äÊPr>X*KõŒÈÈïM¥ªúºüE*ÂÃ$®”žÄ•ÂØñ§ä…,\!ëx4K'n}iÑmJ³–6š SMšæÁ[Î-‡‚¬ß5=/Þˆ ä×/Ó¤ë\ÜmÂýU¡,º¤ëX‘lÂEO¬-:F#§yŸä+í¿4W†™4¥“ *¼Á ­L¤p½_ößô b~hѾ¬4ÊØJ²½º?ѶÈÿõX%“¼2ëñu.o­¹üˉ¶_¿zÑŒö—úËÖ.‹Ê@2\m¿}zs8FüIAP b 3yDôÚ /¶¯ÆlDï¼=íÕË»¯õÃÖ6wq¯¿³ŽK#LŒ»¬Ö˜ð‘–à4#¸ïÝŒ‚©k¿;£wRD«,|“df‡«íêæŠFn  fm;^·ÃæKÍÚ.ç&ú>[î+vàhº~õÅ¿å{>£—_:\o§s7úq¸ êp‡M¥rìænÏ#ŒÈ|–X_Q}Š/4{V|*rÔu³ŒSÞ·æ¢Ì”µ]@kÑ*®ä's·–(³½šøËÉ÷\&¡ºG·-htþ°Ôo¤ò„ËÏÎÊb(£gÎË;^Þþb`XoüÌ7Þº¼[ãÈqÙºex–Bšz%OK$²O ÐÈnˆîÄù3ÿ¡n?…ÄýÆ~9øzÆåáW'ËÐ˳ÅOw[_aôá–„}Û¶µSž|öŸý~ø‹_?¾z­mÛX9x–1Ù‚þÜ}‚.ÍSùh<^¿ «`l δÓííá7üÿîå˯6Ã6EO( ÁYû-eËvrÉF!‘kËp˶ðx§dÌjëÀ%^  p¡Ô+!˜%ËEf…í ö“¬\Jde ¤Ô_Õ’E9>"5êdD~¦£_ž’|£¦k(æͲÏtŽ'n Ù½/Ä Ö`êGÝÐð,Ø|L¬Ä†RéÅ_ÞÍ4~.à⢩Ëã"—±”È|Eé—r~<ÁbJÅÜÇz —y^FQÿÄ¥.ˆrÒFÚ íUûùÌÑPLÃ:^ÚbE­Ï=•ñ%9*ùë“ÆØ…)@&œ ¢öëÓ½,øF OËb”’sØ}„EË+8T¡v{÷“ ›mù§~ûFlÞe ÎNAM<èé³' `ÝóFÖ!¢DY2ëƒÎTU,ÍlsÃøÈlsçAë"¯J`ÝH¹l ,Ñ«œˆª¦%¸ @33Ûî^¼†L½[Ô½-®5­]ÙÍÓÛjbpo›±mÛõwÑ2p—vL9Ý´Øf„øêËÿÅï<>ßîŽÀýÙÙïÆ`6‡(×/ÎBÁÆÜ豌fÊÓ\&¨–bîª@†Õ¬ÃüÏHV‚suIÖ:Ì„&²‹dëÐ|ß\”‹|ÓU>øɈeý¦Ô€üò`ö'×åO—Ošˆ´^_l‡åT]¼Uš®Á¤Ú§?þžcÂhŽBAÕ™wc-«|I„ÈI—BPëAPZ$MC,¤è¬Ê ¢V°åÇ_.Ñ¥ "”Ðò{˜ñÀâ• qÉÌb±ö—=è„œ‡Cz{çÿØOüÑ?õSýüÄ6Ð(ŸÀÐÆÌý?ˆ_×'æzÃxÌx¼¾ÉUN^ üìSsýõ/ÿ­?ôGþÖ¿í—ß¿þè`ç¨âW…íëí‚Їë¢4SÔ뎟abòŠ tïÉZ¦}8Ì„/:„†€4ï>FÉR»™_Z;Ä7-ë]:¢6QW'‹Z‘ì…Ô¸^FH(òx¨¨Xß ÍØÒ†Azh* 5†dZ{¤),`-À«$³V.ÞD $å6ôŽÖè€A×Yp+Á9½õçÊyDGÖ¢ ËGm®¬Ûa½[`} býY‰Î**‘ƒ¨pC…\È^t#Ñ$ºv,šøX5 {àçåO™À5ÐUŒ&ù¯Ùîs€£%ôŒẏCp|%Eû]¹É ï[k÷Ý…hЫ¢ Éåå{Ì•ï»7ki¸ƒß '3£Ãí`¾«ûÞl“‹fR§l¿?ŸŽýp½ 0—÷v€IÝË(‚ÊD‹é¸OÓ+*ÞϳÕ`c ¬¨Ÿ8<× _l%òX~eÁA.i$=‚]€Ìlß÷Ãa;ßïrƬ{JR±?¹}¢Z FÁ(³Ö‘ÉÃfLj ˆq¡€MaBÞ÷½áþÛžÙóֱߟÙÚÖ$· åGÏ}'„ñ," NʹÌhAb;ƒE£e/ˆÉqv– Z<Ñ+’+ […U7Õ{›h½`‚¹ƒÖÜ•–Ì03¶Ùz{{®HàO-)9õDCÂ^ß^j]k[o‰ IƒZã—¿¬ˆwŒ¨~åH‡ûÃ+OmAú‘V‹âÞ<ü¶!ŒË°ÊÚ»ÐtÞƒ="è0Oa&œ¹ ÖÊKŲƒb§ º)jÏj Uh&Ö6þ]ŽòõE¢¤d/MQI…b´<[áq¨•OaM—Gø* ƒÔOâînÖ|ow»~úƒWèÇþÜvó9¶h¯ʱÕj§ŔޱÇë“péÍúh<^?ßµrA’¬/8ˆ½ãª=ýãâßÿÜg¿ðKÉvM÷Ԧ准Êù^rÆ“4!:‰VŠªPQô.¥¹z ic Qh’÷3I¨Ú!§G©ÜK® B,Ã#!@w ‘'J B¸£À‚÷ ëçãcR—`*7É{ï°éòO0áºp+—·¡/ôpr{"°üˆ/l‚‚vI6õšÌA±(~€uÎ ! ô_ÃMa.:ny­û¸ ñ ´Xˆ *Fååéž¡ý𠦿ÎEÑšéví=’Γ†á=Kýƒk ACÓ'ÍøÎEаg“5c¥P„]{¡……ý3(TðGÕÍ›Áw€àƒgÏÝtÞ©ÆB2žMð9ÅAwÙvÕ{7Û[»C¢Y€Qyï4¼zñòÝë÷Z3Òöói÷²|ÌB ñŸ‘Nز‡çîE o˜gç, .ôà0·²Û0 ¼Åw9—²öKÂ.Wž9Nší»›±»={þìîÕÝ~Þ-žˆ–;\É"›èm3Á»Ë, \b;^Ùvc-@Vnª@Ò£ò¾™v¿ÚüØ¿þ=ßþ¾¿ú*°™Ã»Ó÷Ž$ú‡…X±ßÊ ¾×0<˜ˆ‘0íî¶ Ôp󤡊zOë´^2'Lf¢9›šíª”.£ŽG2æ¬Ä Öo›çrùy˜+öcµBž!­ÿ¶ÀÙ×Àëó·å¿S,`™ 7¡Ç"gT¾•LK?JùU¦À\£"‰çSˆ†§Æ¥oã MôLÊŠöˆ ¤Hµ)ÑÎL¶Fe˜ ƒ—eOä”Hi½ÌÕ˜èœFJFYß«¤Em½i‚¥Žq}¬C™”GÃ{$ý¸¹;šIöjß}{ÿ_úW÷Õõû§ÓnÍÈæe|N¼_`.À7Z›Çëcw½u™ €Çë›_Cn,Ë@¤†Ý÷wÞùÌ¿ñoþÐ?üëíõµ]šz8;8o™'ž+X¹xBS¦5« ðÀm!ŒÚ¸u_´`–+Ð +å€Ü*sIE:̬µ¨ŒFBr8CÑö¢˜(‘x O«MŸF¢ˆäN Y $–ÄñÐâeÝ(ÂðüÔT†SCäÈÀÊQÞýp$ÛÔ&5¢Üèñah}q®ï‚d¦h–Þ7©¼ 6æØ'NL´=ÀÂýê#lp1zeê`Ýw&šµjÒ¬ùÔ*ŸåT§ £²·'4ÕöÈH{#ݵˆ@JÔÀI ž–)˜ê r‹8XïüºµîîÑšÁú.š »€ “•_Y¥x¼¨qe¨s;Ý)n‡&œÌZß½‘ŽnŽÕö~¾»»»n‡íphÂy?ÐŲ҉¹P ¦·DÊÊÈ=L’äÞÝ¡Ñõu ‰fî{UVUí@tæCÚ"Dâ'kv¿ŸŸ>{vµÝÕýdÝ{Öýq(ªµJlth;n"ºÓš¹ËÙ·ƒ×z…³Æ«!iq$´ûõÆÓ×¾ø_þeßíþìñŠ.Âݬül•#(Ð`5QÈ)€¢c´\Í`K˜,>•³0&µá‚³…­Â̵.wÁIš3·æ’³õŠ](e93W)Wƒå¿0Ï–7O%Ç®~‹ÒŸIÃùkìÉ‘ZñÆ// q0‘#/O³ÞøÄ/òá_¨ˆ ë"MMs:fD¹Ê8Èè̈ÜTUØS†6™;N›/¾·c„ÎfóÚ"c¤Åœ’>:^Œ1q™Ï¡†}…qúÚç\—tª£¦È€Ë×úôì„4‡ìîÙ&pïÎÍ$í÷¿ðÏü–½oïN´ÍʆK9W(iF9úÅŽ{¼>‘×cÀãõó]ÅY¹ôÅ$Âõ]Û†ƒÿ[¿î¿I¿Ã&É æ½Ó(ù¡R·ÊɧðïÖ/÷XÑCdl  uÖå€EÃD×n°ÑDŒ•PÄ^¦&)\“0J6"i?b°tTÉ,ªÐ”ÔˆDí)M òÞ)8Õ`ë3ÅB¿ç“O±;"ôŸ?•p¼uh\¬Â«ûú‚ïÏ2>ÆKÅ‹ FŽB<¢À昧‘@ îÐ[¯Å=6ÀßiŽŠP¹YŠ0ðPÆëã{­Á]î½ûÙ,=*²zþYØLDý;(F7UôKCQ—'ƒ̬ô2:z¦q(ÄÙщ¶½:Ýw‘íàpJ½kQ‹ÀØÕY&ÐØ3‚: ðlß_û®Ÿýé/Á· ½ÑE×&®[ÿóŸé¦m³~¾u÷òúx„ÛÕ*[”‘—PÑ"OÿsŽš—š+B|ùêþïDdYRríì•F¹aÌV,qZMŠ Ê3Šîj[ÛÑa|çù§¢:¦5~é‹?gNó(@Š"1ÄtºZ{çSï´ë–õ¸È­mÇ«ë3³ÛÀWe‚nF“«AvúËßÿ]Ÿº:¿<šCÝ…Æp èËrè(SÍKzæ1¬ S²ý}ÌÚÄs¨(SzTàŒ½Ñ™LÀ˜N3ئք¨ëÏHb‘Ï4·â°+F0gœ&ŒUÐÂË»8ƒoèñB~e×-\îàŽïJ4xðñze®y©ÄÍ[Þ«ñŸËo Ï/Z£6AÞ6-Öa¹@X|ŸÏ/ny8aê‡M•æªË#ÿç“v —;÷1ðxý¼×›µSt›è4ªÛë¾ÿáýãǯø›öó«Ö6wgkr{P¥£î##ç3ü²PŽ©ïRBU›àéñ,jl%þ½“x³- f±Èô ¥RÍ@ï þ. ƒ$|ÿ“–oFÀ”[Ãáò3ÛÁ ¥ä äŠXëÞ!DÓ×™¯šìì b—¿øJ“ÃÄÁpO§‘…%ßSlóÒO¨7²K„±s„«_Ž äKµïŒû§vÊ1 ¨°r„Êq`d²^Z%ãÇøyxLY:¹p$ŠáUÐ4qœ¢WxâƒÇâBïn¬mfÝ÷Ý÷ˆù”¥Ó· _—4”©§é8ÛݤZ]Í£†b%‡,þµ,þ&,]¼ãƒÑ»¸É}ï]U™:úHÏŠöÝhYÔ1$ß»™uí¤Y#†êF]ˆ8¾m?÷W/O·Ï¯wïl‡««§§Óë­µb&‰)kV€aÒŒ˜‰ƒ³a…»šqúñ z¥º°VÅ‘Hs?5kêp¹¶×§Óóçï^ßÞžöÓáp”÷ýtƒ½¢@1ã!É]ýpuÑllFpö(žŠ¢ˆÄsb]4Ð3G¦¾ãíjeêçóN¸ƒ YùX#x73ËQOj4*ÔoÕB­ÌÕðÓgt(¢45oÙŠ‘3Në€g?¦ìõk( ¤ö]q͈lfW‡qVFÙzý’^Ãåß!EbXsŸ/g¶„†²7û|JˆºÞ8ôËïC `P`òCÇkµBâ¿C„Å*å[){~…¦™P>×2Ë·W/FÕ,›švq¼¹\d¸¯V4¾NeÜާݴ,i8ŽÙ[¤$Ã&Ÿ6¤æ¤*Š Žåô±Äv>¼Aܵ›ËÐhæÄÞ!3…ЀÝßo_|qÿ#ú/øöií‘€dcƒ\®[E§–%z¼>9×[ÀGàñúù/>ü5óÍä}7»ú~ü?ýŽïúÎ_ôŸÚû.]pOY C‡1¨­rhðc§,«ÒÉ‚‡ƒ.NÏÉÀLpww@–_©°°F;ýG¶ÙÌ@ æ¡"{2¹ŠÉ ‚Fô`û„#IZ;Ppïá 'uΖ0:'bÍÆPoU?†Hú˜6B¼3ã•Ïœ¥!ðm¸éUè/ž/CÛ—Ê@Å(lÅ|g¥ %wáÅ/žôêšBGÆcTêÞ 7ÕÛcáÃ|›%w%l'Ïð<º{¬ m£5õ ¿ÆTÉ‚TUñƒü*k\ h¦ú- óÍGš3Æê ¬aBC½gÿj€nfÍåî"œ Eï‚›…‚™°ã±­ï{-&·v8:ÇÌIÑܺ÷¾µÃë—w7O¯bË·ms¿>í÷ÛfæÕ¼ƒ”Ðá™&,V㸌UÙÝim€@ ždƒ1 59¦à•…™@Bîg›Ñ{ÉC;õýÓï}ØÎî¶ÜE°Ÿ{¥Dc ò«)àxsÅmPüÑkªÃ2óùf{Â=Ò Ž]ûÕá|uúàÛÞ}÷õËo· °*ÌEdneCxþ¡œì0³þ$­Ý;æ ¨‹!2Å’c£î– öàÉ#{‰¥‹³{Sл—j³š®„±ã p­ÑB,I=c¬çåjMœ ƒ"EÉŒêÕ;rOpù|šOó½Ë¯sÆÆŸ´¾!Ál-Øü®‹sD´2ÔÃMpùÆi_¥…Àꘀ:Þm]±yª<3€DËLþ*'5=îcî*{xÀXñ€ø’”˜ùÀ­ÔUÕûJÝP7Âƈ­N`Ø 9ž›«H%ÓRQ¤ÅIC#Ô‡Ÿp–L¾ùéþpàî8í¦ë÷þùßñ»}{·Ÿ¼™ ©ZYVë–¸@ÿ×ã…Gàñú«½Jž“Öì|î7×O~è÷ÿä×ÿjÂÛ‡µmﻉ4ö‘<ÀfÏ'å¶J[–c|@L¦£E’²!™@k¬üç×(õ¯’àéÛ)—”g&ab³J½¬Žªä "cTªDÁbbúKe™Hzˆ Æ&xx™ú›…2GÀ`A ,e«5é õO:¶¹À,ywLE'€ðžzl.õåM+§F‘4‡ŠÌägE‚Fãæ®ìXYŽ»Jü ÙˆÖ½{\¹*•9OäH"éµV/å¤ÏÇ*è&$`ï>°Õ…15·¿œ"±m »ö¨iå*C(6ZŠ†-1€@Š€ù ;øööö|ÿ‘ïa«Å’{l}¹ïç½w<³Ë·íêt¾§5$édr T°)ÑG¿5(Û¡&h…¸øY…÷0S&’’axD`kãyïÏßù´¬ÁÔ 0Úù| +â$LÀÍí%X÷rˆS2‡G-àd11_ì­Þ®›kõ¿ò×Ïwœ>úâõõaßw€fEÔÉi¬®bÖÎGOæð2øÂÚþÁõ÷ÂÉY *bÿG¼Ýk¶)k‚uÀEO2F {®SË H€fu€Tæ}…¤D¶‘,?w{Áî7vËâÕ?6‘6þ²çÅ]Æ—æ¦Çç JÉ„ìÓz¼üÓr_[áuÊDpÔré?µ…º²Ùx>ë ž¥GTÔHXé3Öj4ºœTšÃ@„¼J ¡ºYlãÛ3•G«b‘").ÄdÎB‰”¡×ê`‡Ê+,,÷¡ÒÖ³ ȱC¾Ký@Û®6Áv?Ÿæ·ü‹¿×¶OŸî´µ6¾w$¨<^×7¿s¯¿š«œ"(ß‘|ÇvÀíMÿÕïßw>ß5£ÂÜ~*IDATä[kÞûB'PRVCEcÝkC,ôE kàŒO¿L æR„Gœ`hKF§áüëüÿ!Ì+æ :qÖoó£eJi¬B‰¥3s” iˆ¦ë$‡ËUÝÞ-}šÏ_Á ý«àa:¹ô@%GƒÁÊÚ’C)fq˜ù‘õa&“‡õÊXÇ ×?Ë\‡µþN\\Ó>·.¨1ƒû“¼3Æ(Ifvyñ—ˆ›»»û º«“aW”ÕÓü¢˜eWNÑPý9iš¢Žjd™—%Y6Ì ê²>É×÷÷g£†i7~X LzÉ@UñšÓ‰‚Øí/ñgÐÃÕ^L¡b±œ°ê³ï\?¹rÁh?ŸöóÞF]¸e“ÖL_˜jë”ÂŒ²»»Ó×¾òA³hf±Öd@ðCc‰ÖÈ­ý|ûìípMkÞ=øÙ&ûêW~ÖïÏØ{‘´P \0séýïü6Û6V[DP‡ÜU£#þGÒ°íê‚_[÷×_þþ_ü™íîëÏ®y>;ƒîocÿ…¶F/<䤨̒‹ZL¦qVÝP MѲU°˜µèw–È3À’ÃXÝò òN¬Ääh3<¹ÀÉù(“ s1À9æe¹ÃëÕ·¹)#Ѓ9À…Ár9‰Œ/¾ÌäµÉk4ò›sŸ{aît©¾3AòVœöJ}›Ëßs„AÞf/„臮ýñ£©mæïËñ]'s~RO¿®oSÁ9î.K{Í8Û圭¢2¦$Êwl’¶ƒYßy<žÝt|ï÷ýððg~üg÷ý–­Ûì¼=^ëµHŒ¹Q#×_Ùµˆ•‘½FÖÔw~øâüïþéïû¿ÿ¯ï¾8ï;œSjöpœ¬Ü“eG ÑWI…¸B]‰ªÉÃ鲈~¦|Om€@1ƒÌñ›ªLdpm3Do\ø¿œTpï^C­D‘¾‰bÅêš+ùx=^o» €Çë¯òZœ)©:´gòOþÙÏ|æóßþ¹÷`ûèàÙ“¨<÷Ó>.•ïJ3¹s±4âé6‡ 4Ûƒ‹ŸÈŽ£ÈõJÌ‹â1 …½MÙ#”’Š€ž†F”•<3åŠ=ä©G|èÏÀÎqo»z*_ƒáª÷NU©Î!øITë±R¯ÉÊ–V,íÂeŠ”_XnE€hõÔåcöø~—WåXf%íÉÓÝcðÊ•=®OþÚ½Wˆ!ÁÈØØq Ò]F…§QµX1ocÓtœ#ˆQƒ[kç½?÷SÜš8ÑÐ]†MêÑëv.ºã.öžØ¶íxd‘‰äæ&3ž¥F#Ð ÝåÖѵáôäðêÓOß±~pÙ»7ã؉5Õ‰áÓíJ–øÉ 2YÃN+Øk®åÆH¼¶;€ úmÆ&4µC¯ ” 옘/Âq’™‚m%ŽCQ/ hÑ‚ÐÇáQ½¼ç.·lÂíxð,ü&*`ØÉoƈ·_ËëŸÊ-HÐ_ž¡,¯p嬜åìÖªä‚&É–=À„¨îOše”Q~•ôEef†quÒbHiÿ>;EÎ <ŽûLhË=: µRµ_†a ô®tGHQ[`4Ì4pËÕçÔIpxgÛìàÝâ®ã̧¿ëÿÐáêÙù|¿š÷Øl1Üi§] ýÇëñzx=×_Ù5d¶&RHal:ïçwßýì¿õûÿÀ¯þÕïá ««M»”n3N6`Áƒòð]*94H@Ño8½#–’\(zõåXs'¸÷=¾mw˜µñÅQd¼¯£(K £ ðàÙ§_" •dy¡Dœ²ê6†O$«©ŠŸI€$@U'àI€ÒJÅ>¬îã‘”\AŒÂmƒ‘ªv’mæ\å×ÇÑ%8áúŠ€Q=gÖ °õŽÚùù÷¥¬$—˜xà!5¶ó-ÆV?jÜ8ê^FÄ;›0´£«ŸýLa3£Ø]€“V ìˆ!x vLÕì`XVÅHAÀ¶tëG´ÄèYoŠã™]¾Ù¶ïtd[¬ -yïÍÚæZ†mdjÍ"#OŸ<}õÑ+6S¯ G €à~îp]ó>Ö]‡ãõéþNpÉƇYîb°9Æ‘‹$,:3Ü“á:M‹(ñ+F$aøt ÁÜûv8ޟΟ~÷}?ºu¸Ì6ï°èǨ{Wwî·µÍÒÃKë®Û§O{¶&®ÀVkJ8ÄÙ$Ý£èã¶^}ð½ßó½ü›{v Ù÷‘þ[‹¬Á½ €ušCJŒZ#F3LU7òÈõw±¦„è¤D'DsÚÞ«·R =¶1>¦}˜°VOÚ×´/Üáåå+Ëô7ÿ´Þ1è%VyÞ~˜¬_€B¾Ã ß•ÙÊnóvi[Vk½@Ú£cv0ù95Ö$÷°Ñš°ªÙTûÌhÝ H¾[†|jÛggñ¦’ãI3‡}Ê@”ób™“rkäÇUaJ UQ÷^ç&íEĬ­?XäÍ Ͷ³÷ lvÜÑÛñS¿íwþÈ}ÖÏ­5ËrY%e©9ìÇëñúæWäpÈ ‹¿½!V¯ÇkÁýëkžó©ßÞnÒËà×þšóÝk6nhÃ7aá­©@ïJº¼€ëyïòa†•b±òœª2F0>2ÝÓ¾C!«E@çÆÆôÄdµG>Ñk 4’V¼û(@DD,ƒ„ÔòÛ—#’¾ÑFë1T­B7ÛLp¸{5…X´â¤.©f!äðOñbž¹.€–—ž?L _, ”ÖHO¾ÓÔîi¢%Ò׸ï%@áò¥‹¶úy¶M©ÒÙHµ Ð0ïT›ãŸ)+¡HäE¬€$å:í÷€oÜȈç,n1.ȇa¹ç‚púÙ1>“[NAÂn¹Lcï²m{}º?Ç’Zà`cyܘÊ02z8¡å&ôîÞõ•ŸûŠŸB”Ðd–Å©îmÿü>V@¹ÚlÇWܽz)î-v…,”Y;£\ß 7À(Þßï_ûÊf›ËÇ®ûªœæe““ ¼{;l¯O÷ï¿÷YÀth±…%µäáˆÄÚ¿ò3?ðûÄŒ’ ½ñsŸÿB§Éç•  ­PLG°mkÀÝ—þ†ï|ÿ°pÕººƒMê–5û­6ÉØ­ª“ÕûkíW¬67Á d \ÇFE IÉz¶¬¢ØŒmë` trBôh¦5yZÆÀrŽ35·ù|q®§ Œ‹Û|³KÞóv@°a©¿íCHŒà T‹7…OÉ0Ô‘ç âiˆØðˆÖŽhiù%í‹u/¤õ‡“tÀ,ŒAÍìr04youlCÎja/Í#ƒ*É"â|öbîù1UàÒ®I³3S65„®îÊêÍ3RŠǶfÍ;`²¦NžüÉ¿û~ñGþø_”žXœ‹ŠÝÕZ.¢ûñz¼êZàÒܹ[ýéñz¼~A—tùc˶ñtêlíGþÈþ¿â¿zw÷âxØ|¯z²ŽàØ´ŽÝ&ÂR&TÝ\e[p:(ƒUiô*Lÿ ×±EÓ)X!Äf’6krw¸²pKº^¢á+òþžõ)I–= X5ˆœh];Da–î èL¢˜êD&²íÞÍcîGbR ŸWãI02"–š¥¡^À”UpIAlšššé …5H Zôø…†«õ©t€–o¾uyapŒ'¨”jTD5ÇŒ9BõoVQ˜ˆ/EM®`‡(q8\ÁuÚï5fÅ*DβjÆø…¹‡-L‰iá”å  ¯û,RdÃä„w7²ïûÆvÞwênͺw3…:=¥°\*§{ѨH6ÞÜÞ¼üàe|­äfÖ»›™ 9\>íe •\8\O÷ÞåV½‡Yß9rèY-Š¹»‚P½±—õca> º[Ür±Ùétþô§>·ÓZ³(Ü$—Y”l²ü°ütº7Pf˜Œj¨ˆvóäÆéb&kF7¶c\=¬ü(Û6áô¾û3OÚùÅÁ‚ÓA¹[ ÿ:³ªf.0Qlï!abw‘†JØ©Áj@Æ>‰Ã¼#z†ë¡Í\P„غ ¢±ãm_¤x¸4¢£\• Å=¿œ$Í÷rœ¥åÈ tš».^Þf"î!¥Ç(†Ú.¤ ¯€´+44ÜùIÉ©s‰Bìˆå+â'‡Ø ŸHœˆÊØXØfD4˜Ëã­pl‹Nw¯É Ñ ð, ÉŠ—&Í0mY”èš^ûñµõ{ŽÓkU ´¦x±&óiòD¨Æ¼6 Ââ¯êê‘ìŸM¢_u'nMn]$Üa’^ŸìË/üüØóð.º ôÅ\­g{hò=^×7ºÂ˜›æÑx¼~!×òe‚Q3zwjûÉ¿ôSßñ~ò»þš/D^##Û5%tVÖëU{-̃Ñ)˜à¨Ê|ZÅÃ]\šP”­»Ð£9½ò.$wxöêTßù©.RÉ…ˆœ/ù¾‹ÁëÁâ "ÊsŸÎ×QòYnhÞ=4ˆÑZ6yô ¹7Øà%  ᢓ+î11À´Åªú€ªY .]‰»Òun7ÎêƒïŒé?+å?£Ò{«Šš¿}7<¢ÖǨþ)ÕüÐqUVKí.^<[ö é›”:èp¸–«÷Ý»Ì2o³x YŽßÑ}Ê|8dÀˆœNÙ—ö{>ÆéAÕ®‡×§,¼‘-PìaCn¼:ö–ûÕÍÍ‹_ ?T7I‚›±ŸÏ­0 !Ñq€v8^îï‚Dš;Êê"|¶ò^FHÈc°(Tœ…8yòà;9Í*ôA’û®'OŸkklֻ¡è=½¾’Dlhûi‡§7Téo´îûõíCî% ¨7&3`WwRÜ QzºõçºïæúôúåRd´—Œ2Û€ÞÕ šæÆHs°÷}<# a: mÆM8öÅx6Žg nFHG;Ü{GVs­Éþìýù³­Ûu†1¿½Ïm^ <´¤DYeK¶ËJl%Š£TÛUqENþËT¥’J•]NÉM•­Ø¢%9”dQ EA¤ÈPDKÍÃ{÷žý­9òÃlÖúöÙ÷$÷Þ=çìý}«oÆœs̹âšÒCmá·îÕ5 mãÃóÇ»J¬ùû¦ó’áª3'q:Ùþ_Rz⯊˜†ÉuRŠqÿšXQ MÞV™Ù†ë­—/ž¿¼Dð¢¸1­DzLÌå:`0bP²’ÌÚ3;λRŽ+“NÎU—›l×ØŒ%ÊŸÅW¿÷§ÿħ_}çÏ_>ìû~2c˜F”÷?TVHÌ×B×\f¯#3{÷(ór(Àóþ4µ§KäY‘‚ ¤À,Æ2¡Dººßµ@qX2µ0¿PÊçëB©•6q=—qžùõR¹J½Ø냭@¨|”{wíx¼º~í@òɦF|' mCb•U†¯Äž8ãÐR$œÜŒC_d°°MÜ"n.°…âF#o”T)Nâõð®Î;3Ê[Aê6šVÙ,¢co{é…%ÞÃTˆë&Pj•a-æ#“Þ)Ä5q‡}›ŽQW¾sΆ¡ë4ÜÍÎ4^vßúÌÿýÿùßÂÞy|¥ÓiSu+çNüT༧{ú¤t¸àjúÌìžîéÍ©'IÁD…!§“ ûÿõÿòû«mcXQ’'@?°CÖ#òàE6 õ¥Ÿ2Bóo Î[rk,4UŽ]8ŒËŠÝ9õ¢n³JTÓ‡£*u(š6›Z%jæ_hFÍõ]È àÀDǼe ¦×\/¶jQ©éBÀŒßŽ¦é¢ú`œðN…ò”‹èøÞÅV'`ÊjÕÍ]û+Eçá:ž»uÞ·òû9®fë«ä0ïäÍBǽ\6Ë̳Ý}¯Ê IÕ‚„--ï%JòZ%ºVËL«îº[†$l÷ËÎôJÉöæaN@2gGh²Ý/_¾óÍokD˜Ù„g’ë¤go?¼ýéOrŸ¾¾¡@·ýòx€x³ô#ç]êm5òë Pñ—õ}½¦§¦¥»€kqªíb‘bØM_·ƒ©ða˹YE<'a#èÄÍiN:Y69Ë•®&î!y× ÀH+8+¶„‚}3€žÍg?m#]žn¨_òˆ’Œqwc,öp´¬Š0I´­$3›m<Ç.^þ÷×ÿî?üm¿¼°S¹ie°Ò9ˆ‚/cqO÷4S/­u’(@wáñžþ0©-.À6Êq¹€ÿÖßú;ÿî_þKÃ÷¢ØS>Œ›†à­@¿’„€_ȉ›h5Ï&Š«\ed%×Ç…»NGœMLI„ïʈ“u·VE%q/˜+€eûÆîfKïB[¨V `‡¼4ñì¦f<ôþÓ&×Ù•ç×4òàã<ƒzAkµgDÓ<-#^zì)°e@ž¹þ [žg¥Âlõl½†8ás4WnT¢óŠ›»Œ*3ò†åGAeý'eì^ÐñŸê,Ò¶¤Â`¶m4ó±»vÀIÞ÷1ø˜ô%¾³«í²¾ž”’fo!ߊ ßâ1Æ…^êÃÐHæ]ÈÍ5.¸RàHÏl³]¢à.c’p|\Æ>ºÈ´Vå€ÌQ°Ó‰ÚÇpP”7›:Þ3>•«¢%Fƒ#$bög9¡ÄÂî #ÀÐÃó·Þz÷2†¶ˆÞºÍ4Åä ¨J)òtO#C^ÇaOÛóg¯|WØÃH¯0A1¶Èú.ñâõÑŸøôKûø»ç/ûiÛ 7.v©á5c®ðkzó•Ûéa´ÌL3—gP+Òå.I³ÒÌaråmuÓp”4EK‚1?"j—kØÞä»Õäv”rz-Yøõœì —ǪGjOAݯl»«¶GŽ×ú^ýfU–]WéEϱôøhÙ?·¥Þ˜sᥡ‡˜ä4Ë-sHÝžw‰Xˆê%»÷‹@L)ÛÝ3ÛòV/J4ßù觯~壿ýË¿v~þO¶œÈK+ß±ÿ=ý¾Ò! èSù÷žþاÛJ «'" ¢¡£ó„BœÚ~ý·~ë ?÷ó?÷Åp¢ï#B¹_ü²‘u×áqPi£N*FˆÃT,•k1Ugˆ¥´ÔN¦P« V½l¿Å/—€Ïr¯óØ3pPÖÃäž{Š,@Âå# ~àÚئŠ ^âò«eÎHˆD†©Âå$ÈM‚+Ä€p ÖL·ÈR°ð†ß`fe2ˆWëú›Ô§‚­ VÂAí_¤Ÿ–¿hëª ŽôdX†¨'Fë ž)€>3¬¾ÑÀ1“Î"CÝ,˜¥ ëÏÐùPÚÀ AÆÍN'£ùpƒqs–19NØzÒU§©‹^œqËé=¡g0Ø(ŠÐ§ÍÆ>¤”C X jç€d2Ï5CJF8ýå[/¿ó§q¸‚ÑdÛißå.™äÀV£“¢@³„†;4.ïnÝ-w¸“¨€z“X’ÏОz`üÓöÖ;ïîˆZæ÷¾ˆ %ö›Há‹ OÆsFa'wןùà•_”R=S]Z<!¢HŽñ|Ûß:üþóçÛØ÷yÙ‡™c "Ñá‹ÜÒ7pG}Ú´Lî·šLîcß]Ü`¶Ó`[b]ZÎÁœº”†±¡'«ñ­ •.œ·ÜH vfÉÞh®ºuMÍ™WY3s®÷ä#þ› ¯q¸zo+_¤-¼LL­ù’ö»6œNÀ%!„¤7¥˜Y@¶[ —ÕûZ5d˜Y×”¾é.“7`#ôjž ,½Ï‚}SÅ¡²B$®_;ªDŽÞûË€)Ä­#U§ãÏ©Ú ¥Rj©Âíg²¨Ó L)Z«$›LÂçá;¶a¼„o–ˆÍ |4ÆàÛÿÙóÿyþüS—‹Û €¡BèÕê”uw¾§{úþé~À=}rÒò/nJsçC{{Õækî/^¼ó?üÒ/ý§íÿt:ŸÏnŒN`â9$_2µÆWŒ‹¬óÖ—ä ˜P ,ö|Áãʦٌ¥î ¼¬º ö´)dzéBmñ%MI=#|µOjU™[i˜|á#hQS†D"±`Q·2Ê ô}¿lÜZ1šÀ¡Ž¨–}B±4<]+æø¸Ör½ÅŽp{ŒØsDË\©+fÁo¥6®Ì*‹Î»SõË9Ì”¦VÅqu¸¿íåø† bÉÑâ!k\U¿ÕÝ q˜¬•$˜¹@nLµiÐðÍŒîû£ï';×y\LåÁj}_A ~ž(¡Åe»¬à4ɱˆµ1ã~;â’5åM²u¡ñ?¥ñìå |÷{ض¸¸@’ñ„1Ý`#î0ÒhÄp?­[æœÏçÇÇÇ-®V+€cKP¹[E·wÄkÇ+%Øp;½ûþ§÷´~Øpl}š¾äDpò’$A.ùµ,ýCÚÃÙN£-@JNG-È€[Çó §WßùSâ=¼ú6Nhì8¯håw>`Îi ”†³£ÍÇ…b®ô2.›±bín»+‚}:O´i ÷ßØcTUÕWårS¸ e)!ßǬ:.•^®‹£4§õQR‹˧ËƲ>UòF‰QF¯Öˆ‡fÙ&³!W·ª6Ð@ùFº‹}=vfI‚è§`{Ö<«Ë„gê3k k >(ŽzÒ‹Š¾Áöq;XÎÈÛûDŸHO6“å/ÞxYWy«²)ûÅòjdc ç«Þ_©2 ˜£Sðxyt#¹$w#]ÜzþwO²Â F6¡µ.u_ƒà@»ÄmûÞãë]ON“#¬&´»Ÿ¶SŠU![fcäcŒËþáï~C]Nm›ñÂñ™/~Î7H£û˜šÜE~ŠÖ_¿ç—×àf„G"m; †S¼w¹èÛßüŽqs׆Ð# À¸›9ð©O}f°.É.ý0ªy³Œ“ø¯}Ýv—F¬m‡œöéÏÞ6Ðvw;RÖ2¡DÐi.mÏõ{¿øÙ·üõ9X] ags:b\ ®AØÁ„šbúAM èq3—ØדCûää…êUZLñ$:föl{¯&t?ôO>D•>Ý¥Þ˜ž"¼ãšêJü`ï¡eŸXàonz¼®#sBÙZ¯+¬®v‹„Kl8kf ”Ÿ ô/Kd ò Ðï„»HÛ!rsn¨ExÙy5x^мL—jRU(tˆž,±w«¬šÕõK§¦CÒ@×­§u:5“T׋—½dÊ ò¾—ú€%¦ ”¤@Èû¨Ž»U€(mœ'ÊŽ?¼F>*ЗӴ~,PÏ•qLá“ÂPœµ÷ •ý ÀZ›å xÅ\¦%ŽÆ4†O\ ‡èFnÃGi‡Ñ°êæ4sœ)ˆ¤x’ù…på(+G“P=]‚H0ÂŽQñ {dUúõÒ¦e-[ZçÉ‚V‰îj2•M7§Xr R%ž¡Ú…¯èõÀ~’aµ~©Ävz¶‹Ë‡7A`F˜—¤Œ uH`Ï©]"—NŽ³ß6^ÆåùöðñþxQ«ÆƒF³mxÜ>'Ã>¿!h:h§Óöì</º€2ɇÑêA*¸ÅS¤‚PÉS.8=ô±»û7ÊavÚÇ0nq;eåß[òQóehìtÂûŸþôîn§“ î0ÓH©ú@…ô-ZF8ŠÅ¥M϶óÙ¡Ý}‹PúH•Ð ‹‡‰Â}ãGŸzÎgÜé— ;ÚSIy±øˆQÓ¼MUJO›lOJ¶¡ä$˜;\p#Ìh[Ì5ëËe%ÿñï¦VyçÄË|‹T¬zTÉW+ ìj³:ÑÜš¾É@™ÄôEÄm³jf–<íiM.ì¦Îºäõz`ú/My¥>`möJMVQ„FM±4EíClø@Ý© !%XÄÃì ±’O•¶ äFMBÈy˜NäLƒ@ì}«1q1û"ƒ<7C±ä–zsÀJì›ÂÝ´ùfÔW‰)Û¨z dþ…jÁ Ï”× r‚) ´0ˆ¢íc°Ùöêc}ã;ßûûÿø_Øöú“Ûè¿«Gÿ÷t+Õ¦qµ»Ü€{ú¡¥yàAuºÄ-×Nß¾üµßýÕ/ýúŸû³æã?ÚNübÀ(µJÓ±Ù¬`g\}ò€µ‘g¼£t5I È:0Õ3”jNFz«ªúôKlñЇ.‰(ÀÆ܃%R>áŒçp)¸Tñ5¥ŒŽHÁ<µغ…Fá¥R#’4‚Äb›)¨ EbÉÃœI à$V,Ži6©7t58˜W2(¥"ùGÓ™lâ…uãÈ£¨P`½¾™ð@Ë¿ó‹ÃœáíË'”9èì'é£w§ µ~²;§×ŒvÓpß‚„1Æ~3c‡¾iFre”(aÅ]Dø×ÆIN‚#LzØÎûå‘pØæ®ôÃ,ÍGž1I²É&høË·ÞþΫo‘†gÅåTÆ F„/=Ž´I…¢Pçó‹ËëWi€„¸•L´dÔE7‘ ‡KXh cJ€Ûö¸ïŸúàs»ÃN'‡‰¼»Ú<$e„ýIc´×^NíÝýSï½{Á€Ì¸í>ÚGÁ¨®Àþ°=¾ð>ÿÞ»¯_}ç­óyìy­x¡1ié”ÙÄôÒÄV”ÇI©õ ðôJö³ÁD“…ÒÕSÀÒZ )l±.®BÆ…Ô‚Ê‹y+z¤¥n™ùÖ·c›bsïRêßIOéãGNS*g–bÚM±¤7Ž”¼0µå Ý¥¶ˆÞ¨{YµH#QŽ«±@±u—x6¥ãoo’·Ž¸INÐr‹kR^iWÅyD#UÜË"/Ê|½QRzùbÌR’ã–®‰é³ÞûE Ù—§=Av¬è¸Ê2R‰0Å £šKtlt FœB€Ùëñx採a›aÛ>|åçgŸþ/þËÿüt~g¿ø¶BKqñ{º§?hº ÷ô£H‹‚44Æ1üùéÙÿô?ý?÷Ù/¼õòä7!ÈÅHʱõMìëvT¬uÖMí…vÚ/ø`uû’¯É+çšC¡Ò±°Oºø7¢Î#BT¤“ƒ'Q'OVå!C`j‹sƒ¡nr’ôFʘª6¢¸•J*@'…ˆílÛeŒ1œ¶Éãnê þ0cYÕxñ;73âåË—}÷ã(Ú¹< ×ÙâC7õ¢)éÌ™7ÚÃùÙë?¦Ñ` m,ƒg%ÛiÒ†\m¶9@ã¾÷?ø`—oÛæ#± Ò~ä,u좈_fu 1Ÿ˜KÏ^>·ÓÙc±™ŒáVþµÕÛ’‹Òy£½þè>ÿ¾ôÏN¯_¿:Ÿà¶ûδæ¾Û®¸ò™s *ô˜\žœÏCàé<¸ äP©Ú¦Wò^z*„U#™? ”k¯÷©9OËå“Eгµ_ n=Û&Úã2õ‘èQÀ„¹“ƒÄ­U —µYpµgbßem·¨»cM—¡Ú•ß}ÁËuYyÍ\jÑ·°´Ó.½‰8-Ž\>Br°-C,qSÊÕT©¬ùÏœŽqVl³%ª¤‹rp(e;{<È…ÆTF€ÃVV3€Ì6•ÍN‡FªŒ":nÈì›÷Òº#A¹Ðv!#· 6asaHpq;?ú~â‰<¶_ðâ­Oý¿þ³ÿîôìÝW¯Ü¶­ ?‡XWÓêžîé÷™î>÷ôÉéjRüAó |8ÀÓ —Ëå?ùOþÚç“$gïâ®Ök#ógG3Æ J+_[}=ßè#ñˆ¸x£2KØŸUy–çA‡TÁ]5?Ô"Í—®H»×Çyi]J3–سøµlÄ×4‰ÒA±4ê©coœ+Åq Ë7Òê-¹o&Äì&( ðìÆy¸r{–f×}ÛÈW«±OŸúËd9` ©÷›Ã»Þs´~QC¦ná*·õ‹ ‡tµ[ü ey†`Š »»|ø¾•,t`ÍYÚ¥.ºÆIçêbšÓ^ûx»°9M’i WšÑ16³1D¸íøî·¾;.»Ç&—Þÿܧ¶Ó6NvoNKIvC¤¡ÝÇ~yMˆ®âÅÉúîßú懭hfE}3{ãý÷?5ìÄ“¤œ¼;%Û©ü”ÇB6ö“ðݯ}ó×[ƒúÔç?§Íœ$l×nlÔ­0vmÛøè>ûÖKÿø­ó¾_Æùdûîf¬‹ê¢,ﹸqKÉ6$êÒh#Çü”hàilfyaHðRÄ°Æ ¹Û‡U‘¾7Zþ2¿ç\m1¶5Ìßï=dÄÚpx|$ ÑúéÑâµ”Å2ÇÌ­C˜ ò–&æ‹£6.ÈÈôsãP  'ë¦Ä¦®•'ÈFÆ #,=ÅÁðû@¸…¿/w‚5Þi”¡ýÕÌz‡%c.X6—GïŠõrtâ´iLy þˆìRn¢×>£„(¶¬8]èMÄ‹Aº%„SâIYQÖû†;¶ã2¸!8ÿýð¿òOÿ¥nl‰ ½,ó{º§0õV¸ð4p·ÜÓ÷KhôÔnÛæ>ö iÛßþ;ûßûËy÷É›(ꬕ‰¶ÓÊo‚•ÖÇC “²2bOžï,¦*PÁ€8¯‚5p€±j4œ²yD™…ÑU¤b«kh„ÓÂÜÇA^@\diĦŒïœÝÒ œ¿¥™:j´ t‚£Œ4·ÇãNÒPáç«aIG*Ѫo@^`%sDòhNeÖ÷† 뙂„“ éXʼn½†å<žºùIÃñ~h¦ëÈC²¼²ˆOU¹x¦²+ŠÂZ#(‘ *XeÛɶ1C.̨? |1uŸ•µ2Èý¦õŸIÅ ´"¹ÉvHò¸ºò0%›MC¾qóQšsóßÛhÔ`Zo¢K’ùP»K«Kžc˜ñÄ“ÆeQ½Q&;$…ÀèI“ñõeç½w¹¸ôí1BÊ-1Z:«)’X(®qáôðö[ܶ¡˜xcãæÉùuH‘’ï¼|æ¹½ÍÝpÙ/»m§}ßi›§Ê 1'3jè±Í=I{ùTì´Ôp“È-7’A WÆ~ª)ê} ^-hW®-µÔô—Ã\­¾DÍäÚ<æ´Ž[ôËëľBz™¯ó SÌj|ÌLì›_OBÍR—ë¿zVlÖe‹L¸B,Ž˜Ÿ!,ª–*YP¹[Ôg"R†w4Š4ÌÁÅM&丹훊Š)±h’Œæî(SRÎÉ ¼±6ƒÁ±E›Ò-ÔÎ9m¦eäZ¬²ÕF‰°Ef`.¹E[㊃iƒÇ§T–·Ý=$Ëðo}çÿ÷+ÿìüü3Ònؼ…ó¤;ú¿§ß_âÕÏL!<Ù…îéž2ñ9/„³T‰n8}å+_ýÍßø­?õ¯|q`¤OmèP‡vi•'¢„±¿2zRû/k=Sieò{ãîºr` BÅTŸIôõF«ðg´>»K˜Žd[PZßT:P3Õa ÉCæå²0φŸ@ч ù†¼¶iÖ*„$nä&`tXöp*À’ødÕŸmWÛZ¶•lQBB1©,íìd J` fp“Š¢‘lðˆ"8`d?µwûbcõ–&@ϼuìðà.4Õ˜®Ú—¯ÄÓ)ò3‹È Ë&Ò¶=Hî>T-s¸EH§¹àˆ^Ú×ì6ƒm¶íc§Ùù´Ën0' i;A%£§'GíÙ™¯/z=‚S­©ÿ |¿ ÷’:´¢#eY•ít>\C‹½Àà®ÍÂHý;vë··ó³‹;·“•ŸzÎÕìÐêútK<Jˆ<ËüÅ[o]ʵ49Û}l4£  Âø'mþÑgß{—û÷ pظŒÍèç‰-Ó…{vF„Çμ™á_ár bF+¹Y¸Z;,1´ï9mæ”Ç:?{©§<¯´ÓG¡ÀÜ¥EXD´Ò&,è|™ê5—K¼_>Ÿ’VºëdÞ,—â¹têƒ%p)½J¸´¦´€Ð›m±³DŸ—RÒËë>/Ô¦ýž†&倠0’´Šat⮺О°¶‚ØL$5³ÏBðÌ"—+Š™ÉyN‹Œ‹îƒƒÐà вٖuc‘²…ª“¬³ #0µ¨`fu$“Ýç¥3ÒIÐÀ€4BHÏ{í»Þûëÿíu~þîããëóÃ9¼wª¬"zÝe€{ú¥«™s·ÜÓ'§?¬T@Èl -)7úØŸ?ù÷ÿçÿùýϼóòù³í|ò}"@ÆSð°Ë`€edÜläEïe¾©¶SnÀÉ’&x/mè”2D6tˆå®8¸2‚"+ßT ­ÊªúÐç 3ä }'Oa·¨€Gnif\\Và ؆vK¿çÌ-2Ê» ‚(®.3S+É4éÓ1.X\NKfìðrÅN©¨°Eš“•± ©Y”Õ±‹þ+QM…ù_ĸÎà .€M­Ô]U²J½2HЙ8fŸˆ:vä5ýfžéøËíhQ‘íãRÐ\gÛ/‚ · 8ƒ #Ä(IÖnaÿ’ž¿xþêò±¸Ó²ƒµÙiøˆÅÅ¢Ó”›y8äÍd›m燇ÇÇG÷=ÑbpxZ",¡lÀOÏž=<{¹K¢Å-ØÑöšÓÐ&„eš#>™ !¹+ãvâÅÛoùö=)kpˆF‹õ»m›]òó¼úðOýü§ýãß;Ÿé»`}pK~¿+%¶ 2ap±ËK‚N7!w9‘·«n6 ¾;<<¡KÇ@Ø%ë5]Û¸`AO#gU±4£œmdvÊŠA—”òaí4š´æý­ÍwÊœ•§\.Æ€[àP]X£z°¬ñ×_z]¦ô›íŒ}ƒfww`ë“D¸*#žOŠ÷ƒ#IšÃb{U›,RÚ`gê¥A´pí±ŒÙäò0.$n¯!ÐñLÁ1òocK™i¹yÕ‹šjZoÆ$Ó-îIp [Äx ¯-2ôQ6$Ø–Ã.?4×tusÆ&aya<á§Ó»ÿÅõKâÛ—GÎ'“G´êýßÓ%…p èÝÍ{ú!¦<¨ chÛNâëÿè?úö˾O’ûp6Â̽Àñ`Õ†’¯˜¹J‘šÀâð÷© °¢ ­;R+ìÚ£€aÁq𛂠û$$ÞZYßg¤–tŒª°8ÀR¤5}ióª|i´â<µ8.½ïÌ:x°)ÔíÑ. ßǾ5a¨,"Invbõ|‰3Õ´’ƒ¬Ç>–³hÒê5´Gã°V«©;7¶–k-ÖÕß³F•áÊU‚Üt·Ë&ØN¨1'Á’uÓ¯0«F@ Ed}èœP3Ц$ø>.“1OI«††ÂKxioQKââ$zâ§mìþÑþè§-¥OTLpãÙuÙ¸ Œœ Òpí_¿÷Égï½8?÷*®yʻ͂ãëîè:™lÿðO}æå ¼>ãb>·‹{É@­÷le¸ö{zÀ[ܲ—¬¥ðÕÝÎ2bGÒ˜׌!xGi›VÄt¢YøóWèºD‚e{1­óËïOg®CM¶ÃÞuøõðê\}:–uý$ÅvXÔua.Ü¥äü¸õË,c]vÓ4IÅ á@ôÈ,*ã%Õ•^$c€”û ²åº8*b+Í}¯”0È[_réxìéËÌÜÿ:«jÁ5–a*¢Š,Ñû ‹U»„²—àICƒ©…!`2’”Ì÷tÇÒA"Ý~ ”‘‡¸›Cf’çÿäŸ}õþÇ¿%n§tFÁlÉõøÞáÙ=ýà)OòZüñÑÝpO?Ž4±?$Ð cïïýý¿ø—þÒãããvÚ¸ÜݶÍ}ÄML¡~Ž]<”Ì÷×"ÎmK¶¶Ì9\Ë Šæ)æÕä%‡"ßRT¦í"›*˜£+Ÿ>¢Éå¡ÉJa,Qž)T yw+Kp¶ÅlΠq Ë0Ò!ÀœïÐë‡a]\Õ° ƒ ÿŶä;aà>”¼óm샖a³ f {ÉE(ä˜Ê„ö,ŸçUî(#}[Qbâé‰c M‘q=¶Ó‚²  >åÍF©÷‚´Óç÷u6®Ã×-ó>4§ü“‡ÿòpÞóŠžLõe§íÙãþ±Ñš€ƒ‚DnñXƒÂO‚®°(˜ä¤ÎÛö±g ú”ãDQ>öSÜExûR§óÉOç˸D|ôaqáñôH–€ºl˜DD’-(ç’Ùé´á²¿V„sñQ¾±î¢ÛæÄË·ÞÞ%XGâ"¦Àu@¶ óDpAÐ&¸ëMÒ{ﾑ@ ׆”\á ÿÝñí¶¿úàÅö’»í¯Ž\-!›2¯gàÉ0N™ršœ>jä•L¶Ñ‹›àðžZˆœ¢Ûc¾XE‘/GjÏ¢¼b™à$+(Ú‡»õ +jgÉLªœ%|Íxõ³²f™¢Ë š‹3y51¹ÀÏ%0'ÿêE‹’3µV —?³Š¹$“ì·H Žž×1¹½…Á¶>,"f‡!4󹻚ÂN¥\øîRŒ-“!¤’-bŒ!ÀàÕ–¤Ô$eËÚ½k5£Mh4¢¬SwXŸ3Š.ŠÑTo).mºïSýÀp-9"LÉ®chp¢+!A9)‡4‚6DsÇãk|ü8þÞ?øÒv~7vw6›ö¨Ã@ãžîé÷—®„Æ»pO?ŽTÀ ô“~ë·ÿåŸÿâ¾ðùˆ ¸möñë×çӉƺ=&R@'Ô9NäŒ7³¥Š dê,exI•Äú„gH•Ÿ&"-nЀ¼¿h*fÀ&:ÊõKY|ÙK•lAžØ2RhykL8qŽÔELeH~öÈÈÿbèÂRßÝR^‰a{†JKqêîfy%Çu”Ù¼• P}X:ƒ„ûݙѼ¢d¥Ð-ž#Ö6÷ú`2ø÷ZYŠRt»qÂõa=é°%+èæ“ ºXÂbâyMQ¢)–†¤(5â#Õå~>?×p™Ü=âć¾8Í2@P\–qAÒ„eÐÃf¯‡§•аpJ6j‚€‚zxþlÿx BFäL¶‘ø¦e–#î'©‘˜–$¶ÓÃ>v÷ÈhƒÞWgíÐ[ï¼ç´€%02lûá$’ @ßâWÔåé™É>ìát~þüâ—¸¨w4©;cojÈÓð³=¾°?ûî»ûåÃæ{øýtR^>§ÒÆ‚Ö^ÔHc“ÌÀð*Ú"®+WzMÙoxI»9@¨U†&a½œ›u£Ãñ{Ùïšô)|BóùúpY9¨_õÌ©µö<{å|¯~䶇õ³c~È ³‡cÔò]¡€÷qéöäËŒšVÕ }Þ𛞂ÂÏ‚4h+U@ŒËÜÃr%‚-Íé|<|ͽd¿`jÖK“DX ˆ³fÆN-©¬ÄÔP—8Wë2: c^U·ÈËÎûBo‡1½œb8²w|ç⥿@eCÔåxÃéy¸Áiúø‘Ûó÷ÿóÿ÷y~þ©ýµo§p@ùê0zTîèÿžþéZ†¼S€îéGÖYÔ| Q>p>Ÿ¾õá·þƒÿð?~8ŸO'si³í2.–t{ a›9°Á[kÜ„E²ÇzçaåÅ^m4'T`ªú» cÞç¢>êZWz©::Ú•™öuJ#¨÷ý¿(Ü2Ö¤ú,â0¯É@X’ƒ‚ÀÓ…N D¦Â²Ô¾éßzSóª0°[úL×R {a=/¢SÜ,t›Kªb•ùêì…Ž¨å»üjýóÛXZôZ+÷t.Mhw|·ŸÐnOBCI's4‘Žyeû!#¥t–‚‹ž*F‹òùUzòôuôTÀÒîçWcäUÀåfa#¼†“FTÁ&~ôñǧgçÓù„鉭Ю>ñ&M¤²°™24¥_}d&÷ï~óCÂ@žÞzg;? ýKAÆ• —© ÝÞ»wrµ†5…‚h.þ­oþîŸù´¶ ûúÈ[&ÁlpžyyË¿÷§>xŽË‡¶ïû–¶ª JäiN$Z:›Ò/¥ÐOè/ªgëÜ?ÌU,‡ÉÛæ·ʺÁÁÂ^ö*äÎÙç9ë8g§{Òz¬ÖÞÚ½ýŸLë7ÌóFºëZ`!ú'‚E¡d…#o^\^“h¡@ª>,øÌþp%zÚt£Shy0fAËHY1 an-z€jVcâ_Õ6–.;ê= hþܱ‰IÓOF¤ ñ«†ƒËøLS@ÊÖ‘­²Xe¡,âS808I¯i®hÅ„*vØ*õMU~8ÁãdvÙÏßûëÿõßþð#<~¬Ó©n¹YçÕŒÝÓ.©§æ2±îÀ=ýÒѹm‚1Êeçí2öÿãø?m ‹gIJAlã¥!†­Üœbï–þêD‘vú¥ÀÒÆ”ê7pún¦]W+”L´ó\¨-!x¡òyx–ä°ÎHC¡&b¦}š«0 MØZ‰h—‚–¾êàR7Áöwåmô‹îqÕ…ªWÒ€7HÅóM%VÁ£ª:¦¤ü†9¥¢VѯÅÜõ?h:œ§JßÊE¼Ë>?Y¬à¥‡ªVoL][MZÖ¯Êv‚¢xÀòÞ€ò’Íþ)RE$g*09}\†œ’°Á;㘂 ¤0†;|;…É5ok¢Öàå6’úZ¥¬!÷ýñõÇúðï~ë{¾ãù‹Û‹w»·Ï¡$&ËÈjK8È5“Œ s1¢Ñ 0r¼Þ?þÞ÷>øàƒ‹F»ÿ’$<ŒJ”ìÄqßù…O_lgø¸Œí|û0 äÅ6q$ i’b"kî4èÁÕîåuÎ9‰ûœ¶£˜+Ém›ªãVЯbázÖÛ˜âñùªpÚnL¹£ãZ¿==Ñæ–T^aÕ\r¨Y1qv6-"íd6Ôã¬3U\åÎEÒ¨›¨>Oì.€Ü\·£p½ö†a«=‚¦§GçÝYˆ+‚ïQZ6—Pü,í¸îÇ8?ZÞ뫸kwKƨ#„pc°ræ½È»p[ö9ÖõÁÑu´¢S"é0sçÀùW~í_þ“_û2/Ïì4¥i©ñŒÝÓ2Ý€{ú£OµÕÓ7ÿÔ§ßÿ·ÿÿåeÜÌ ]Ä•Àq¬¥þÅ´‰ÌØš§¹Õ§¥1ÚŠ±¦ó-¨$‚:Aò"‚…ãÒÉDÊdjùëÌ0ï&å¡\–…€s!¶Ôñh$ã—Š(þœ&®Jî‹(ZE– ì³ý…¼ ¤ Nyû†íÚ¥lo*¡'L`ˆ3ãúŒ]=…¸Œ¶@äujú"ƒM ÛÕ&ÒlvÕ áéÄá2ƒ¸jŠ€ †ëÊõÇÁ\Э\3_ÿ(X8… «åBªýá óáÖ™»˜íN™½ºŒ½¼TPøf›»§+Jb#hVT˜ìö9u+z=ôl†mp ‚´-‡B`0‡ÈÿÁEñ¨ 7•~ çr9üd…sÙmP??êy]]Í‘Ù·âN ÑqŽ—ü´`÷6™5¦žå•Á¢&ûRǧ˫7ƒ[ViÁ&±rYBƒðC•hݼTo]vµqÖDZEؘ“°ê”´–1ÞÇ·?Ôýßý‡ó§”±iOe–;»§?\º)Ü}îéÇ—¢ä™'›ŸpúÊ—çƒ>ûó¿ð ®á‘U: $Bõ= Ö‰uÞ2Ø\x„¦¢+x°Tö ’{Pú¼jJ”÷¤çðâr‡t-Ú¹-qw ió2Á‡–7κŠoÊݹ¡x„Ç}>#,±8Ü2@@§‡ü@ë…\XB:"’›„ ›õœo¥¦,é ÌáÍö¬È}¥¢f1TúlhCy ¤bŠ j¾çTz¥Â/‹(›Cž¹©ôÌ’<2r¬“‡±G³Üb¦ôºwœR ÅP Cq«WÆdú•ÒššCËH¯Ž±ìOW§ÎD áô™lsИ.Åeé ªPÇm _[ÿßÍSiÅ SïX3ƒRçñZӉ뭯¿ñ1/?çP+Ü· • Ô¬cV‹õiÝîJZÐá£%µ»eœú·6qG›FbÏzdr$äˆkh7RÛ£ãõe7;K¤i÷q²M5W’·ò†…b2g~Ž\eß=ÕF§²…%ÀÍp(î4šøêõ«ËeŒ 6;Ã8Š‡29]wHOy͘ap&CeI+åg¬TJ#§jÜÏ £ûsîoãÕgßßLŸlÔ€ñL€W°¥·e¬rÇ-ベhw›ŽæÊuhÎO ̽\œ ×ÌønÚµàª6s`]ÚË+Ç_»·Xã²¥Ÿ|¤fÎ5U–)¬c6Ë zò'—çci^Õ6Œ)³~ÙWÇì¦0P?–PjIŸ‰ƒ¤óÓ‘+VpxIí+Z7‘¬4Tk/_bx•RhÉGš–„°)Ÿ¢·‰ù ˜ÏeÒ㔇Cˆ÷¡1”ãy‘®Ú¦Ú²ÉÅ­>ʬÉ6­F‡orÀè0ßq:½õ×ÿ›ÿñÃ×Û¸lÛ†$}ËcOOG÷žîé˜r+H˜é.ÜÓ4T;G¤§Üº3T¦ìD‡ÿÕ¿úîØLò qïËDY¦ž¦@§òº™Ðf«g¸Ó"”b4q`dŒÔä©•‹q7©ú`Xør_‹»°dÅ6 «ðs:¶IÞ.Å‘E pÞíÅV ! ~¤ö„gohÕökͪåõÇyÇL´ u£lÖAÝ9DX<íÝEåpVÿЄïÈ9Ñn*‚³Çs÷(ózûP=pàC¯ƒ7>¬¿º¨7¦9¯òEŸ³ÊU^'±T(CÆ<5Jhkê£È§0c¡”4ÒT½;Ï„P¬I(‹öc1A¦ÿI˜/slß{ýÚ¶çÃÅ͆û¦ŠßŸ&+CÄ ªàE‰UÅ®& Àô`!_&IMåWìÕ«ÇËî§í¼OóTçÞšÙù3û+Ëâj‘«×ꂶB#G]°JÈÃ. ž¨~ûÞ~òWeôºL;¦XšÖšyßÙ8>As\'[í¯uÔ³MË°%Œ]&Óä‰ôÔXºã“§ãõ¼jaëÜÒ,òðŸü{£ˆ›.Ûéíï,ªçÚàòõbÔÒö8añòÍÔµÎ-Õ`á$>pCÆjcbe©çd¬4§”!2¾™fÅŃ2Ü*Ãm•®}âxt¼þš+˜Þ\½ŸÇÂXúþj•˜Q -©ÿás%ÎpŒØž­6Ã01®ƒI[JlKÓ(9ò·~åþÆ?ûͯR/Ò0<Íž–Þ²ì=ÝÓ&Ýî {ú‘¦«=ËŸMªÈcƒ"þñ?úGÿÆ¿õ.ã²ÙVW#5(3÷à¸ÛÔv÷Fé"\'“=!ˆá–éê‚ÈÂÄ°4§­ó@¨“H…°U<|KU¸diRÓª (’ꨈ=?oBí>ðªQó‚â¼Ì륤FóÒEŸÎ€òNïƼÇY% ®Oæî#Ï]˜kïÈ×æ y²NÆp 4Λ#XšÄeˆ'ú/ÜU«Ú¯®ÉŽÍJ¬:ôÆCäB réúÎ)”ÅæseYž'PÛŸ@¥>¡•0É[Ьgä0º…Zò‰™3RN n<ßÃ[W 4ïe9"֡ɶÓ뱋[¨K_ÏdŒpHƒ,Ÿ‘$U”ì·(oSÒÊpHŽÙú–v¹E\Ýá¬âCR%Ì ±h„òšé(„K4ó@ü5é«©"/9$ÙEÿè3ï>˜¿2x^À0“Åõ¶ˆ`xÁÐ÷X€©ƒ¥0oÈ®éßËåÏ÷-g¥r¾Öûo‰’h;'²®0¨ù´Óœ¤Œ$D!ƒ-Ö8|òî¶ZüAááì—–+kîv§¸¦…/¿J–d#~ î_(i´Œ¹Y´r`b—3YE–@ž¡àqqÏ.3zM ¤3mAШꢊ—;•ì¶Ü‚mìn›özÇ·¾óÝú/~ç´½í(ŸUÕ"¦avâ=ÝÓ"Ý€{ú£IšÎ(‡ ® Û—¿ü•O}ðÙÏ}þsž:îûàfî^>ͨӖû~^yèGöŽ,—¸>,P¾\–Wz;± ´©ÂŽ—ºfêtëXšù“qUC" ئÎSòyS1R¥4[^¿3hNÅW†ˆMJV· DÄz# “@•ª¬¼@GÄB "òs/•˜ƒ0žD û𰢋tïWJ™~’<üÕCЈ‰KYõ®®é:ê;o¦‚‹åx©Tó¯~nEÒhÑn°(Mk L¶®ÕÀÒi/U©‚ÕèÆN!lÖjb¯ÖN:ÝHŠ§í<ÆîyQ@ºêаÅðíWüÚêtQÄòmAâ)ʽ±NI›(æUÑú-1®©&à‚!f|MâÉdÏF1ÿ,qlNõüݽçC.”ð@Aá±èZ9Dî® Õ öá§_â­Ó €yÌ‹ zxV)Œ£%¾Ü½UjdÕ`Àp_%3¦àaýDhRtè)‰îƒš‰û›>$”¸Þ>#¶ÐIÔ[Ð\7S‚D³hjÂvMÅ™{ÃÊRY’úë¥)–xI\Zì0‰éÓ±§Ä…ÄÀ¡ ©´dôªf΋ +’ GNZ-C×v®({*ÒfwD»'|;&-P¼iŠQ)þºÛð }gƒ±6a)âP—¿h­ü"Õü%ÓtR‡Hf ¹{¨dUü, †™`—GɥιÛá\¼ìÉ›C\÷$®’+Žx«°^U?£‚áå^.ûãëÝì4¼˜f þ8?³×«˜£HÖ/Ð\nlA! ùa‹3˜K›ë´=¾àG?ÿÞ ™Áºe$u£›g‡§-i|AŠ ™ÀËPU˜îÙI„¸ø¶1îJGK±%û†}.ˆ©Œ šYëÕQ;Nþ`¯Vjs÷m¹™4ߘšëæë… ¼ŒmEÞùvxÀ”ž–ÆM°ˆF*H´ˆÙ`ÝÇ b­ÒuÏ'AMU«CÔÛ$œ)t•8qÕæø¥ö»jC‰ëñŸÕª> ûË®Ë^×Sž™ä–´Ë¨XôäO6ÌMÕ3á2ôðü½¿þ_ÿ—ËéñÑmÛ²²Ù²uœïéž~hIóÜ[¸»pO?‚Ä[êžìó™>ÜÎÆÍþ½¿üWÜå°ÍâÊÕes:r3‹§¶ý©©´¹c×á>+Vìš™ßÕ¹Z'gkóÑòE3­*î2“Â`\tߨ ¶vn ¾ìƒA° ~Ix¨gP~ÔQ* aÊ„d€LÛ©ÔÚ¨³¾„€8>…Ša‚À—€\ž¦j‚ þhN›'C©£õØõ–â»]´y—œ„æQ¬¾²KÞ×I©ú­N\î¬*‹Ñ|ìÊdÁVµö4˜saÆÑ_ÿäá©c³—&Í/Ž¬øt¨ˆ+HØœÿrÉ@w&ƒ ÇcHšVêÿ„¦|é¨NV·%\¾DÊ>·dä'’ÍùX’Ê.ûãe”ŠÎ\#¶¶ºä‡=HX6(¤0XrbrŠïa>Àƒ]üßûÔ‹Í_=?ó²;!È"˜OUq[.ýèe”²hÈÇ:†ð:qçŠC¯&cuÂAœÐ­gÔZðabÌ~Òú\•×²è ìŸî‡Zê÷dQÝx¸ÛrÈj­ßÒÈ2ŸU›VôX¢Uâ"$kJáž•B•¼–ÍðöÖ¬`Å_®-`©ïê™1›ÛKïØiÑ#”cåÁIv¯'&ÑÏû¡™ÿœð¨ 2ÒSð· –ÇÔRÿÜ ÝÁîŠX›”/C[˜07<Õô5–\GÀÀÂŽ”æõpXJ€¨ÝjN£Ü^-¨U ˆÝ(¨•Ó»§U>=)o$ßʈAͧŒÞ,RbŒ·ò¶¯ÕŽÊü2ù´¥×{gF¯ Š‘°¾X#œ›9ëÔ¶FÙ×¾úÍßúí¯ŸOïº Âä^ÛùÁP2ã2á=ÝÓ6Ý€{úá&¶ûOL þž|îÏNÏã7þùûïêS|šÆ1†qCAíÜìuu¢´:«OD} AטC²"±›è¹ÕYÜPwÇrŽØpRy¤&i'Ïy׋…'ê,J–¨3'«¯e,XMÐã sä]aæTÜȪ©·NZÝp‰¢Ý¶NKyÚÐiä¹Bå·DCÊ3(å…8ËŽRZ`_êÞ¸>Nv÷ dtóHR¿% n±¬`Sáã&–AÓ”âf6¤<8çtvÖ¬IXsTÜ)1=¼Ó™Rl?ÚÂCÂmºê³YQÈcšÒÚ’PèKrprµ¸V¢LÄÃÃéãÇGØ9I9Šž‘…Ž<Ÿ¢FîyÅ[ÐáÔ¸‰îîF«+Òœd¢KuK1†½uÙ/§ó Ci:;ž‚<ä{O÷ô£Jw Ð=ý¸ÓQ¥‘[mé ÷‡gÏ?üèÿü¿þßÚÉNçS\(¨ôÓ@k˜Š¥Ó:N™ÂEh6G;Xluä‰B†]/K­èŠ8pEìh.ˆŸ¤ëbØR]–f8õ;d\/„äF[PKÁ;„Š**5ÕYmä˜-¨Î0nàjg!ëÒÌ­Çmáx‡¸‹ø,#ê¿Ôhµè§\ƒ¢,† ¼h¡®sü¤eö®¯_}ɇG›gÑZÆä5”¦Pu½Z=8s˜ŠB,°¾hU·f^äÚènV÷– 'öÄ“œ”£n0‰paÛ‡? '–nNôövh5BcZ‘^W5b(HYRŠ÷¡°UH"ìñ2.—KŽ·¥eÙ)¯Yæ!T«¹À&’^ƶ$‰ÃÄφúø Ÿz†ñÝ“‘0i!‹)Åpšô—néyg‘™j:Ä$ôÖd_O•ÃDT7&m8è ^RNÎâÙµÅ溚ÆËäâúËœ=˜†ºÃäX'Ò÷ ©ë›;ÈA¢=ì¬×zL†Õs£æµÑÎ#ÃÅ(Õ!NSR!I0ÓG‚û¸Bqš f÷LH ®7°øzºƒí.ì—kÓã{^Þ[S±v¥51-CáãM!Éö¨8bË=ÔGÇîMgâ¨aï žwÇÓàîf'Nn¤1ìáíÿî¿ÿåW¯9±ÌÝ[dzäÙyw vO?¬¤¹Ä–=ç.ÜÓ1]éd€ç§‚¶öÛ<Ó÷‹NÏλ?þ•¿ò¿Û/®·qõf‘€d?÷^݉õ¿:*»Œ1xxŒ$8æ™þMuÇí„0äíQ_õ©O×åeEš(bíºÏ Ø,Ôf}`¥*šXÌZ˜åÎ*® ÚóžË¢™¬­ÞhÔV¿'€J­„FOº¥&;Z’R ‹“+¹`騅œ;k0GûÍ×y±ŽB…ƒÄ‡†äK ‡R£sJ?)à]•© j­òW'sesœi‡ï&»‰ ð$~!J+§ï!ÑοÞãºÐpÑØ` Yñÿs`ÜGÔê &*giãŠÖœdš‚—}¿¼~ ‰Â±Í>ŸýÐþ\rA•›bÈá…ëºÎÍsbF—…q6¥WžS†-$°Á”Í­¬žËÏ[²V+òáZ£ÜÄÞt"\‰QÇÇ’NY_y.̉ös“TS²–ò[Z˜òw7‚Nºjïë­>!¦Ópö§¦ÐØÛM6··¥øYYÁ‰m샛!…†‡_ûÒïüÆo}]~æVW©,nhO'À81îéž~tCÐ]¸§?â4§dën€pwÂǧ?õÁŸÿ7ÿÂëÇקóÉËFÛºÎ&0ÄÕùW`ŽÇƒ¢E¿Q7gJ(Ð"ÑT+tçñµ«)RÔý¾"P^eÛR0º-ª®%Κ¨ÐTngÇúÔÙ5yžwÖ6í¼-d›p¬D‰#éšÆŠzÑõ¯}£htCiý0#Õ'ñD»NnROQLÇZÏú'%«k1¾~}]ëÒÝS.éQ8–ƒÉíhÕä¬c-tU;”HeÝP[^ÎÚì®bÀëøÖË‹”‡y¨®„ÃEØ^ïÇÉn9€ªöD»Ã–5E¼¤"}£lAˆÈ–TÈÑ 8öýñuƒb¹{ÎU´D:¶(Ñkx’‡7|Ñ–ƒ=Ÿ!S$ÑȤ3?þàít>yR6Å]„T©â–ïêïuè¹b§X1Ù¥@h‹ÁÕÝôê@uÞRÊ“Çž¾§C­ŽÚúÞԤuÃГ–*-e”bî<¼z®¶ž T-ÏzŽ³ÒtB-6!‹KC Xç|b]N•û"ROŽ>ÒêÓ;9—KýØuK‹0•v†ƒ¬W-.Bc\Ÿî«¬ßŸ ËÁQE­¬­‹•hÖ®ŒÍj³sV9Œ2 ‰‘›|lvr0ƒ8v}øáþ7ÿÎ?ÚNï¨cdå’ƒzO÷ô£K7€»À=ýpÓï#;œšóÈKÆ‚oؾöõ¯¿ûÛ¿ý…/~q¿Œˆá½uÎÝyÕðöï^5Mžt”d ¨+$ÄAó²ùJ‘pÚåópâ²\êÌ%°É¤/~ê°wí±Z¤æ:Ç£z‡ì‹²tTB.!üVë­!¹3žÚª$ZDØPn¦"+(Òf¶gÆO:mÜ îò¼à‰T\ržÅ6‚’Ë »ŠÎ°÷EY}˜ J›>ZÀsˆSJ’G{éa1i4âX *à5ö= º&•å!ĀÄ*;ÈI`ÙW5FÕoý{"‹àxÑ“«GR›©ºìj£¹}CšT¨2%¥ i¨àK—¹?ŸJJ™¶"Œ¸EÂYTòkù(ûx6ecu* t‘ˆuBÈ£f5 iÛö—vyë´¹ûá ¬¼ÏËÀ`±gؙܬèu1\í’¼«Õ¢´ò-Íy²1õ*Ë‘[†ïøôDÖ;hKNKLHvH ßù Î ˜ÒÔÄ¡Xòêæ¨K‹·¬‹È N }]óZnŒmƒÈÊPŠK|ãySAÿˆ µîn½¡)\Χ1µâXÝ8ë–”®»–9ÞgÌdäH_ãdÎ.©Wrëò\c¨m õ|é5²2ÅMëý§´9³£ÕqêAjcÊy¡¤©8ªehàI0š=îF´ïæ8ÿÒ/ÿÝóûûî›ÅJµ¬ØÒ{º§yº ÷ôÃL5F±#†šd¸¿xxöÏ~íWßï}{8mØ$@tŒ nzüpº© -'AÍÈ?ê˜MMLŸÓu@yü§¼âƒÂN '?b[àʆåŒBf^Ž,€VÊì’§‡Ã´‰×ßqPª ;þh”LÖÔãÜúÖ´.dD¿1äÅ@!9¸‹ó‚छX(Ã"ï´'TDqé\êÞMZ™O––ǣťøž™NIJóñ¦Ii:L‘cíýYRÛµ,’eß²R8¹6Öh” †z99XĨ ói-XEŠh„ &-(úàØhضÇ=í}%'¨+Í#L=óâgÝrq¼»ª«:´žwYiõA¸¿W·K=«Ê|Eaͱ‘pЀð,vm6]>xû­qùÈl ¾øìc/R^ÊÔ!“[IúsЖ@0­ÓîG;Ë„¦=ɸ4-“—„¶Ìµe—˜¯,¼š+]ô„Ýó#&$çUÛ¯D=¯^ꦠ&˜·ªÍ\ë¬OTÏç³vÒ2XS4Ia0@°6Ñ\02/k–5ˆg áÝÝ _HI Ä¨kªD”Ö¾,EKi7~ë®Îë»o[ÎAÍÝr‰)¯Œzv{ \ÏΚH”ì¥ë—(Ÿéà à€ês̨õ}¬k©}ì› öxñó³·þÆßøŸÎ§w_í|j¡æÆŒ¼§{úñ¦;èž~RÒŠÕ2òòLç¶ é/ý»ÿÞȘ'¡?tFsf¶Fkºb 6Ư“7Ô8yÌ·*®;æ/âO n `¨Ât£¢&¢:ry‰EÖYWÞq„eÀºÊ»LPF6<è Ã`’À§1mp~ú…î‹ù†ì¤‚ëÊóÞú ®:£)€nŒ¨v*m¯ÑShŸ¾ ‘æÂ'¦ì-M ®úÑt|U5¹ÿz2àªÙöT-31âUe)}nç¬õÒ¬ŽM+©$جvã¨Ä¡16ÈOch :(Ž9Å—iáéM¸”ÜN¸ 88£ÇDχȰñøx1n¢ó¡¦+;6“•{,4Ht¢™†ƒÚ¸›_>û©gzuÞà»lˈ©èÔs¦ÿ°òü¸î½0,k1Õa5vƒž.óßOLs©¯rZØ»š»ëY¸ÏË{úÁÓk¶Äáü•ÐrÉÍÞ{ÿý?ýg±BÂæ(íš–¡–b°°9Ö[™ú±@yº—yxÕ¨¢{Âv0¸%œÚ¢Ìæ¤ÖaÂìè œfÒžÔÚE9Ô¿­¶Š‡Š]­î¯2ÛjûÓå ­,Zd; V@˜ÙC¿— o¥‹³ª>4RtCò*(‚NÃÜà!£L¦dq—åÇìý *‰§øììŠvL)e!†iâéT içz’䣴’ã³úÛV~!H¸÷(÷xõÜ(:oýi}b¦¨|LÃÉa.™dû£vD©"`ËA¥DH!"cFµÀ5[R¦±ï—Ë^ëbFªYÚutŸ˜a᱓pg˜äàû™—O½8½õpÙ¶!w‹Í–•Sx‘²¯FõÅÚÇç\ .ª®†õjP~ûÕͲ~D^&À² <-†sŽÕÌ}OÓ”¤ëBç×æɵ7ž4¨÷FÍlÇ\ë Η¯€Õ—<3‰mmÉ”Ëv+½±>7“–.\Z³ájRgSq—ç«8íTuI‹­<ºØÍû&Õg€Pá€×µQ5âÚÇp¬×€àt'…‡¯~åÛÿèÿúÉÞÎê°_¹ã«{ú±¦›ÀtO?´ôÉ{Ù¸ÙÅ®ë.3k Cßüæ×ßýú§Þÿô§¹ÙnfwFÒ*5–³*7ÛÒkx¢’«³-Îëó; Õ¡D Ûhzή¹LÜXçtnEb©RS7•Qz"øFÀÐÃÜ† ôŠ‹e{-X\JýHP}ڰˇÌÒ´o©lø mh›4€`»¨7KÙ‰’äu>+o×â·ªÈäÊ#Ôc‰s½%,P© ðA?˜‰Oa{Êsªh?.1ùÆÇ»á:£‰¨n‚BO´àU¯¾o×dM§ð‰âŸŒ2yüC4;–¹Ï>ÊŽÝó‰›waÿÕÛòbÎÔòdÚ1Qøœs@§‹X L¦~­Ë:TÒé¥Þ,¡j2áÔ+9ËÎ}5ÜôQ(×€H¸‰í²û~Ùÿɯþó‡íåð›E‰+ëhmñ]¸§ºS€îé2}ÂÆ×Ç›rW×v:|yü‹ñ/Áx:%ÑÌ}¢ñ5Õ9‹§x}ÓŠ$ÕÍMHÒu ä35FERªêåq­YtÊø7n›P–DFÕ<ÛHnÓ¾'Z=T‡.&(?ÁròlÄ4¥ðãÆâª*‹€Q}ÎÂÁIõÎJŠy™äríÒ¾ÔÝçUSäªq ¡—rWUݲ ÍnÅá+¥¼ü ž+á§Ø9òÑñšƒ„«ïÖBT=¼NÅÙª,³aõ‚…tõѱY«$`«®\η3øSá"AZ\»ë•›UÜxÃ÷p)^J¬Éàhu®V¹j&îûþø8‚¯b³¿`lBÁ¥Ë"ʨkD• d„þðÙD;Ãðê³ïmæŸ â‰ÓLÄupÈ=™Wœۚ݋äSÂîº ú-“p1?3Âuá¸úŒ‡o×/O^QNå±ëY˜«°%½ Ö_×i]ì…É%ûEâÅ*¸¨'@ž4“Þ¸š6"8”‘YM ‡ª'÷ÚKë乞HOŸ›]R|5ín½1å%å7Ô×½bÝFѳ„–Oñj ^•Þ«!'Бý“{-m•*$ÐÜiûÀùôòoþ÷¿ìzð ·-®®‹•²Î¦[ýsO÷ô#H½¬³îNº§Ÿ¬tµ#¯{¤;¶‡m÷ý/þ;ÿ®»œt“šS9÷V¡!& ÄÖí` ÒO£¨ÁùªŽ@Íá†5"gê¶M”³Â‘ȌʡÛH´h몋̯&9Ú2F R©ü{´î«¾è?e>È´2‡å¡® žÝv—ÌÚˆ4ÂdÛ<_U‡»CÄŽ‰‚a‹Ø ’/Ä .9 —ŒÆRÎ{°E¼}$ÊÌO00ê„ ZÇ=+šx“:Ç[€ézⶱƔIO‘ ºuÑñ?ÉüiY™¼Æ¢‘ÃÓg»Ñ]ºÙ㌗Fù£HfíËdž f%U‰%žü…$+C¶Í+Q('ããñq§Åý½Ó<³vb3ˆ–L&,Š¹!(nŠM™Aãáôñgßy8ã²a'è‚Y7t1“-P6þ ô¥·®‡aùSxòí“gfó1Oœ(-åøFÉÔÛE5´^ª597ñèäkóËZññå,îpË–>\žy`BJøñ|\G¬dìÕ-Ývë)nJœ?[ Áj [žìWÓæ,Ží½~÷IžK¶i”ƒÇõûW²¥ž˜ âšÝ*DT­ßÌãÈE)€ÛË_ù_ú½ßûHãÄ“Ñ…'VÉ;¸º§gº ÷ôS“4wÉbtÄttÙ/Þzûÿì¿þz<ŸŠ™sͼ'è«"v9¼ù¤¤…Öd­H×'a[ qŽ$Ügó+í4ú|¸Öþ$€ã<%ëÐI?SM¥iœ¡ñ4!XéŸxSl“yõC=¿–›-³µöã —a‚ÖRP™C²Èy°JîÐê0w×ÞÛË×"U_Qnˆ1&å©;J]Á#Âã2|9)ß »`g“”Ÿ•8o–z’øô§.ч}qQý7àÎ2|OÒ›”RièoÌÌ©¶ÀÝ?¿v—»¸†ôEn5ÿ(ø‘â‘7hA™«j)´ô»ïãò¸q§—ØSfÂ'r©Ï¡•ÈÉ!Еñu ØLnöøî³ýg8ah؉?ÙØr:ç¼›nÓ+¬àvwÞ ãαƷ€×ú×\™<4+p¬¿nȇ¬¦Y† ¬Ïíæ(IÜž’ :YÚZ«J€@›Ä|\s'J7ç–—°%æBfé ´—›ÍM¨š›BíÎc§­bÏÕÖºÖ*_ó$³nzvÀóǽ¢ßœÂdóᮞ™Þ1ÿ¦<6Oã¡P¿[커¹Žo|óÃò«¿ex»°…Q+,¨œ³ûžîéÇ–>A ®ºøî.ÜÓO@j%  m/þÜŸøâÏÿÜå²—Âœë&.ˆ°ˆŒÿ ô1ò¡´~Œs¡W§ÌYÎoKlžÇluŒj·Ôu>ZŒ†½8Z±Ú¢ÃMu67Do•ÊÒ&æÍOðÆFgƳWJ› ‚P_XS!.Íñdm{ —Üå‚÷½² “V á©‹,øXšB³Ç×¾áì<¥vUeŠ?€ƒYÓƒþ@¹Ð6m í IÚfwˆÅݺQž¤‰óÕ9”Ç[vÙF¾6?ƒQ£Q²Jôóŵﻰåû Å]ù×Ú^u“SþiWŠª'…1üòú ©ðã¤Ø¡s²•³AèËñÄ’œ&°íãwNû{/Nän™çØþ\/ -Xp=Ì늗OÖ9ðÐ#§lÿ©ÂñkšXõ‡ÚÅrZò³ê_uøøŠ³¢æšhÒÊœQ+P†>th/ ´ÙdF†¹e¡ä­b‚m•É T+éPùã’˜Ô'`©I.ä•}õ¤Wòƒ'»ñÊ·jdîlOúê:Ç.®z/öÖQÛîô™:H œPQ¹i-I¢™Á1Üi€ñòšâé—þöß=ÛÛ!q«+5ó¿ÁY½§{ú‘¦»pO?Í)&)9†N§Ó÷^üoü›ÿöó—/:à…e40ZD¡ }ƒ*–§Fy)/PŠôÃßqo²BÓ^|<–ÖCðMi]Yy‰A¾55Ü“†z<ù—¼•$i9URYÊwŽ· qç^ ²`ÊÕôIØHûGeäPD¨DÀY¢»îða¶AZ‡[ù1Ù)Û  ÍÞëž(ÝŒã]'tÖ#Þ\¡wй ‘9™nÈaùÛ7‡WX8BT£ÀÚ›“ÁåvÔ ®˜J8µ¸èâØwIX"˜òͽziz$$C>V&5Bc„P€> dDw7³¶Ò¬xÏj’T,™ÜNØøñgß:oxMƒ ÄF‰Ü'ÀΑÌü9›z°?,Ÿ÷b«ŽšÛ«äÚnõù:ß® jâ®Ë£$PuŠ9¶ÈNÙ¸ƒ •ºù¹ºáõBÁs¥ã ±ˆa} .+çè4+ÆP ÁÎ’€¼÷Åy\ hŸ@„º1‰oyë_÷ß›òzSžËË·?ª@UóbGÞ|z}q"P¢KAKñ+/ŒÉú>•2ÆØ7n ÜwŸ½õ7éï§ý3kí)ÈÞ”Ñ=ÝÓ:}‚Üš•wàž~RMÂ<.}ˆ4žøz\þáåmWœqõ-QçCÀ¤8𖩬‚A gVÍP#ŒÄe;¸ú| 1¡éÑN¼´B ¿â¥âá+-W© ƒË›D(øY ¼ m`†Ì9µ[ºÑ¡O·ú6`q@‡Ž˜‰­Ã›j¿ZBœá-Uflš…7Ðœºö삎ݹ0Ý×êç“¥w w²†Vî©@0¯2ÃÒ G¤Ë ÕÊ?!ä c$D3†AXÖ%y÷Ä š¡w3ÐY×"Š@¨B'Q|âèêÕlZ–±˜õóŸV~? Ä™4roy˜‹4V £du«‹À®`%¹~UkשÕÆ?L¯#¶*Ü>0!ÑÅËe Üzg›{¼Y] ½4¶»°Iöôá—Ç=@eBOuM‹m²®Åò<–ž 9ü—÷žoÏvã…f§b™ûvÍ':‚¹«¾Œ2¦îê$zjºáÕ,¨_‡Æó0B ,»¦þßÒqW‘E!©¡ëBrN‡S ÛKúvZ¶“ª 4W}L{¯/@&¢ÈQ‰ïSNhFK{ 2®_õž·˜°´V!’?Ù^Žµ~òeÊXÆ릃þÓ×Öt†,rìt­ãôµÈ-wÐCe» Ãœ(þäZü•±ÿu%†ª[c¢´¯}ùwý7¾lörÈOó–n®ÒE™xïÈêž~¬é¦p¿àž~âSá»ÌÌ `·Wû÷¾ò;¿ó¹Ÿû9‡ n0:<®Nˆ[l§óeäÕÖ]5º¢‘._i'SÝ;ïHCÂö8–ó2P`ž8¬‚Ô²÷+uMÀzª²_œFew W¬R0„òDh¿7Sª'#¸{“y€*•©Öꔞ1.+ˆÒb€˜Žƒ`…ˆáûb!AwI„ÙfÚ—¤ºÊ9q‚º‹€F·>  Ã#6kÇä´J AË«ÆÁ¡Ý˜ä”#JøHÚÃõ¡Ï©­„¿I‹¼$ÂGšˆãJ²Xüôû«-X€»[}è]q=‘˜œSÕ‰¤™ùs|K¼1›l¡á]ä©¥~‚êj9t9¸¨dBïj÷âi“Ò˜üdþì<ž=1ÂI~ß`Õ #îð+eµjuùo³­¤ŽÅ®OÍä9’Dƒ·¹[ààÓ·¡Í% z?jaÞ+V+3ÚËY»#½ô]ÒÌЭ©xNÍ*W’˜³Ô› ˜¤/,Êt†µGÙX*„J•á¬WÓTó/÷[Ü4À¢ÂS÷Ò‚f G!S¶xÊFÈzL¹¡ÔXw¯´õ)-faå­ÐÊ9¥z~qmÊï—IŸÝÜ“¢öè¹€‰žÀ±Æ h{qJdÖnÛÝ_¿ÞÿùoüÎi{¾ïãtÞ4Ò8V=¬©˜øþ[Ì=ÝÓ5½a-ß-÷ôÓ”Â;0u¿NÚéÑÇŸþÅíáù³Óé$¯J†ÆÝ¢ÏL—‡N3Ž GR\Â6ôâÔ1é*Ä8Øó l,¸ú®¡”TÖ‹é€û ®£ÔR´5ìeÂåÇÝ)ar­cMéQX'¬Ú<“Y*—oóãp6Ãa”+k?êl+¬4á4Àò¬HݸäÃ7nñe!4Inu÷±(I-->D‰+*GÎ>HVM\­d¦4€ tíSNÓ4+´^º¡Ð$ëô.¸ôô+×MRÇÖ1êq^¿),{ýNºh÷ŸK›ƒ1ï4j{}Ù#¶£gJ1·¼\ŒÖƃÂÓPÑ}\^ï1qÌN‡v$óÁ—Ñ\+ϸ+Ú`9t¢NØ?xoÃøÞfd#€4Î2lr±Tn8‹& ›ËèºßžLÅÖ¨U¼€ºÊ«ä‹ã(,ò ŸdYéf'¼¹R À|2¥Ö )Ú·(ØMiÓ‘Dpƒ ¶y²Â"³Pê÷®Ò;Ñ×V;]ån×±¢OOÿš6‡>™ûÜTÛ…tÈ1w·cN¹•±Wà¡2ênuÝÌüøj-_U-pùœ‡,ú«øœO @šÇ•_!åÚ³_þå_1žÇEÛ¶¹²ê´šáo©îéž~äIhï¢9ÁïÀ=ýÔ$¶¦ŒÛ|`;Ÿ^ÿü¿ño™N’¨¸.I'¾+Ú7A€C;—c?É!І­˜O=Ü&èSЙÀ‘ý¿: <´ª¥È_PDcJ,Ù_-¾|ªnó­g§F\Þn—ù ióBÕŽµÏz—\ Iò¤S7™4i`¹„e‰ž§í¡µµníE&‘ö%eŸ{P¾%iÈGðc¢ŸH¤”å®ûÎrþ.ˆ<·4vþ³ŸT¶ùaLš¨àŒ‡SÐü:2Ÿf­o샓‡ÐYaÑ ¸|[ë—è=7å«:fýâñŒã4À|}Ù‡ËìœÃ6›ÂúÌàƒ)Õˆ¬+ºûþ¸+CñsB£Ðéq¦¸“@oÈ70Nöøéwž™^6i8h„QÎðå%Ä `o€œ (FRÅŠƒu¬EOÁ+ÉkN –¾¼O£'þû0ìÒŠ² ]ÁÓ•sÍìš@wNS¯í‚©ïË!âO¤<¼¼¾"RhŒÛ¾²sÃë¹l>s¾s­o4õØCO¨oÇõñ†Ÿ¼‚kºÜñÛ ­Ûè“eÊë/0[©ž¼1›jÓ´øz¥±‹µÝ^Í[¹h&ùî~:½õþá—>úÞkßi犿[–¥’Øf·ÝaÕ=ý¸Síˆwàž~zÓT 5„Ñ€Î8=<ûÓæÏ_†o'“Ó…Ófðíúª¹o©QnÃ|k©9¶zßǺ V½EL Ñ#+xƒÿš^wGË×Âa”%ݧº‚Zðf!Øë £ŒU0`A)Lüšâòõ–(Y §­PU—×ÞÕ@°p©² pyWŒÑ)¸×ÁŠ·”Nëš›£F Yi&*ÚóÚ¥¤k`•@æ ¬ØlÁEm]9ê{—°¦ß¼Tí(<‘U·û ‚Îø/ ý3µåjm éÂû1|ܱÎh·Eðq"²˜h–ûpßw€¶V» ö0§4>jºTÏ HúÅpyï­Óó“w ƒ ~º] [³¯Q›jö^Ý€'N›Ý¶¢øήkìc‡¯¯WdK9•ßS7ÔÑ9×êñ[®Ó²óX XJ_Ì:‡9ؾ 7‰â<¨²óKîàͦ{ñ©h¥î.ÌuÞb@2úÖvÝ>úóÓ=¼š«ž‰¥Ð5o¥´ÒϬ߯ý×j“ÎjÁ28>û´ÖýôúuûÖkËœu¹q°¦ã쌒¨Àr“¶¯~õ÷~ëÿ÷5Ã9]¶‡žÔ÷tOdé.ÜÓOŠó‡ ‹Üf)¼öñ™ÏÿÉÏ~ö †÷Çýdͺ ÕNœnÚ@C©›$Š’—Bˆ}Üôž?Äò ™|èh¢ã°È/_Ô™÷òÍl[Ð(RïuóáÖ…è\èH¥uÕ‚«g~“@€æ˪¹5éæØLªRá/d25‘,K ZXÏêøL“\V¸\‘‚ˆ*º•¼ *›Ñèî˜9xÚ±QyG¨±`ü:ɵ@Ñ› ‡jÔÇgJ7ž¿®ÀA–\ª˜ƒ\‚ Ê<‚ÅŒ³Lº’a<Ä£ǾïÀIc¾Â"«óÐo•©+œ(ÜýrÙQ\Ñ lZ’V³ˆÃlˆ”Î|õòo¿8CVW…äÊ »I”í€Löļ¶´tYÑÉÇÇ&‰bXq¨±U¼ëœž]-:vn*yæ*Bë¥u'“è&-´*Äž’_æbX'FrÁÑs?Ú\ 7Á`†¸n¶T^‡_SU`11Îꯩ¼O»e G»™O…£ÙÞ°vŸõ‘?,N¸’î®&ùlÜ'Ôø y×Oq» áµùTÚ)%nüøõøÇÿøŸø IÜ«ø ×U¤Òoå©îéÇžÞ Ü€ïé§(C  &|uéåÃó/ÿöo¾õâíg/^‚Ûv:Ëw/~Nr*Ð\NXäP…n`ÛÐ]AH{@àõò)Dë{ƒOÐvÓ†C\yÛZ: `dkd›L8^œÄ…í:Aª–g˜F ìØP])jhLØÆVéMÐc‰Qf˜þ%Þe+“ä~JÙ ñ7iV± Kf¢õ°+Ÿ€“Ì¡×n­`n–ÒÂàM®~÷>[V Ñ6Ñzܪr³ZêÍ Ž„Dð}¿ªàêðD¨" XÅ·- Ôàµ5¤û²'Cÿ!×’áAo]Þ%%è8À%K5ØcÄÔÏFèËÚ;œ9å@ˆîRÄõ™€8*˜Ã« $»à‹»P+¥Æ[¸Pg ÅðRÈq2¼ýìAã•mtÇfLwùìUªÚ (n†¾Gë<Ÿ²æSûê6ê刴`½¬’+yf)ï°”ÔáZº+¶zŽ{ÅÐIÏ€9*y¬Mdt}øj÷²›øÖM0`餴E×çb‹Áj›*y}iÇ"},A‘4[³¤z·“[—±ÌØÃЬVƒ£[EõýòÎüãj¿¼úQÏq™_kÇ¡&žúb-îû§Þ·uh²_—)3·ÅÚ9bk)Hí>Æíò¸o§ç¿ú÷å¼=÷݃tµJxO«87Š¸ê÷tO?„ô† w·ÜÓOQJ …À?­Ž$ñüìãËã¿þçþ‚(À3+à؈PôŠ 4aÌ“ªMáZNL·TÚnH²Š}@§Ìõ¢ItÍIÊòÍÌX¥&:»ßGµEts1N÷ÙÕa&“E¯Š¾äwº&)ouÍóÝà Ú,â^õ‹€­QNJÁ¿@º2¬—Ö±ÅqZúK/8$¹K#ÜybÑòTÙ“’‡“kÕ¤áZWmö~¡_¬;ÙOŠÀD1»Š%¡9<)0›EI˜ µU-™ÌO—jµ²L"ël™—à^uDRJ²á„ÚØíñq65ú3NI;ÄöÐQ–3€„ËeI¯E·^65;ÓD5ß9“o¼|úó‰ûÉ|ìn›Á=®¢ ÑŠ<€"•â-tŠÏßVA*¦ÍªŽÏi›O=%ª_Í7¤«Çn<Ï–6{—q¼Ê‘ƒ>Ì&G'³=6i“‚êCÑRˆgò2ŽÂ7B)Ö³ R ¤ôá†,E6Žîÿ ûÕL®V^÷_ãûÃâ­îXÿ™»OwÖ•tåÁE¨E–å¬ù^¹®zÌè«'Ojn˜yÑ9‘Ñ< D]3švØvú'¿ú¥×¯Ü/°€2}ÝhTì„;¬º§{ºS€îég#fN\‚rÛÝy²ÓÃùOþ+¿è-®*‚~)Á ` [x²â餅%7ðr—|øE)ÐLîSý\GRș4â'øÉÃq•aتî^y«×ÓrÄ®‹Ös2k(†‘_#‘W *³a³¬z5þ0øÈ3,ãä–bæÙFó.ô  mÏ//%¶n5{È’Ð.ÖЄ:®¾UþÑ>F5Òáȼû]S•WMf!'ºl-`ñ¶ì×;‡Í²T¿ ¡äš›ÑÃVºß*»ø`O“0'PY¦'7XÖ!§».»ê–(dwrzy È;Zæeàþ¸ ›ùRË¿^ÀCõD\Þ{ñðü<Ìvý´mîBÏôÌF‚¬ìŒHö‹0Ê+®CÖkðØ-‹\U?§UmTŽ×ãp“æu}Ô=y†kÇÖKó¢²U%GMßr®ÙÆRñ²l–—©YÅt yl›™Hð’™Ô¦§’¬o6ö¸‡´Ø{hè­X+¼ nƒkÍð[½H\•Ð™ßxZDZÔ]ë¦29Zýo?Ú¾âÇ–´›çKt­"×*åv%dð±ÀRã°E8i Eð ¿úÕßýòW¾nz¨+s}‰hÝÍï€êžþÒtO?)Ôý¥õ^¡ ¦ã£>üÆ׿úÁç¾vÝTõ» Œ×ò€v¥¢'Ï&Ͻ>BlLÄ§âOź>õ„mÁÛ‘à@ü&$·:‚QgSfÙºAE°nX´°uÚˆÔ<N¿ÝC¬öE&#Q„;îàœ"DV‹fšH‹Gê¸B+ÝØ÷y €@†É;ÔxB Su產ÑtR@u¹à^u rÓÓ‚ƒë¹nˆ\BNTñ*¨WêokE 6¢Ü“jõÌg[Â)é“1%Ê6熺£·¦LË-¹ õ­&@m1¢ÍåAIÖÑ(¶ ½ŒÁ¨|.œ¥ï–nž½¨åƒ¥WÑbU—¥}=t¤ÍÞ;ŽÞñ—ìBÍÝ”CjG.Í—[Ö’J`C¹Mן‹ [X¯*½zBÖ¡ ‹47ƾÙ6àÔ6öñøêò;¿óµ³=¡6ªYÐ+xúÙî;ú¿§?šô†™wîé§-M?ª„„¤A“ûþüôìw¿þÕ·ß~çô𜧓òŽD.  ®&È(û<±¡¹ËI¦™yF_œÐ-Ž «è8ªLúœKÂÉB-5òÆ\Z…¯T»”uƒú ?œPÉY_[Ž•|f"&ÐK ªàTäÔV‡É J|¦*thok¼8½œ#$ ¦ç‚kô•FžØ}'H*<1R¿˜7•&È€FA©J5¢ƆjÙ‡,Ô NîÒÔ¬ü[FîS­™È 5±E Êð­,ö¾„húc,iêY‡i`!È|vƒ(³îî| Œ¦npL'…¼9Òú±Üq!Éh§m{}¹ ÍBzÌq qÔ°(m®vºèä1÷A€‰KMæÔÓ$ÇfÚüòÎóçð×n"1Æ0cI)±ĸÆ!|äâÒ3Vç¹ûtë\ûeÐÈÅ„µ •Ÿ· UýØnÀúnŒÞáÓ¾ƒíö×ñg£Oæž1ÚS Yf[ξ¬¹Aù£Æ.&n6PŽ5Z0óTì‡zB‹8—Z‰Eê•Ì´&†î± ÝÄœëX`4[Fiðú¤?®ÔK?-ÛNõRw êe´È»v÷ÞZœfãÏësó…5×Í^$Žƒ(q¬,sçZàbxe‹^=¯à>@ÂA™»Ž16nÿüKÿô´½Ø‡63ùì¬YßÑÿ=ý„¤[ë¸S€îé§6µ»¦î°mcÿWÿ쟿l'Ú7LEÀ{Ò0žŠºÌzR©‚¸\¨2n…R¿Ay#Y®Öoèí8[O ίץ¬¡É£M^ÁBMϵa»ÏȃFù6²èåì•  ã*/aaUú5´9|”6G:O£TÞSõü›Ê¯õ”iÇOï;–á‚…<%”ÁŒ¦Â!‰ÂC#)>#%÷@’c†›¬ú$ĵ‰IAép,yøû"cðCòÙÉà¡ÿ>XBÐb™úN+âþü WÍá M¶-O‚QÔ¦D i Vê[Šž}#‰pðM´W¯¡<—±¥Jkñ1@YagI( rWÙ‹80¨SöB Wûø³ïU`p1—y×o]¡\æ©ں47¤êþvNàÅ2¸6Ÿ³µOÍå¿åñü½ØSÐ@-ÿ•ßwµXpÖGæü¨‹ Ög-ͽ`ÜMòǪX%ˆ¦ÅlIÝNÂÍ]‚6{þ¥_ýÒ«W÷³m)è?•‹îðéž~¢’æVºlwwàž~ZSMPå%8…²œ0<<þ¹_ø3CÚÒ?‹ä2rh„SWžL §7è uX¨Ò"_+àÞö‚ÌV ÃV/5õ2Úà.ç…E|Òö<¶omiÖ¶—å“ÅÉÅWqJ,ø±.ûÐ.'ëj¥_&fT¨m牉†sW ïCZ9H9 bZ ‘Є·ê,£z¸¶¬°+„ˆE³!]‹Ê7©1ÅëZLA˜Œƒz}âÉë>´p´ ÛE-Í^‡$ý¤[Õ¹BÚÆÀO‘¥¬‹6mE¢qíÒsÆeÜw(4Ôdµ”Û~Ã)œhæ¾—Çv;†æ]  &hÜ‹,’7©ÄEQæä¼Ê¥ýíxy¤ÃA+ƒB¡ÒØ€ŠêºˆÄ:×Bó ¤ ­~C:tëo‹*ö 9°úµ2[è, ¤íLj­Ìbß„÷Z##Sªðøts<›¸‰ôº­í%]G助•`ÚÂ$˜º´€½ÔóF7iav ÉÜ›Ø=[w|Ùc¦T2KŠœž¨ù}>rXWÙ/o-‚Âá™Õâ0Í!k-Öá=,µÒô+õí"Ö ±3÷òOYGÚè>ñìw¿ñ­¯|ù¦‡˜¥|Ã"Ÿ3ùéw÷tO?ötîég0 A‡ð©E áÏ|þÓŸûÜqe¦1Y*~êT×Ä(‚:«Ooa½Ò`]¹µåU†ƒ>þ'ÝRbÔ N£E¢XßZN\–:Š7ÎÝY…ë¯t{ ¯º±Yùkqb}:=eõ®-F¡µþýêÛ®UâOå'Z>7ëH^š˜Ò&d†+ì› ”á%Ù&|oÓÔª3ªÍU`QáS^*ñ¦¸Q£dR…‚¿‰^}ç@ã¤)Í®˜BX}ß]V&‹e@ÁH—l\mì!è%Œ4­£¾ §ÜwN`½”þÅW)Ԩ冯ËãòŒqCšVR®V+#„áê£|ëÙx4y6""ÚGÓž\·Ìߘ2ɺN®5ù·v¡µÎzæ,hõö´_óž$òà ½½\zŽ³Ê^QòœÆÓáPD –C#7à,3Gš$»eæXÚמ®I« c銔Êsï™°¶Úr°µ”UçÐ7 ¢¾îj®rõ8®ër%1uÏÜx±ß²k¬‚ÀQ`èLü~;ÇCÝçËWÛS|¶ˆë÷jõI^7#†d?=¾¾|éK¿qâ3Õ"}“ˆN÷ô•n w€{úéNy@N¾LZmÏÛé›_ÿÊË—/^¼Hb5¹qÚ¶Ã9à(¾RJ¨Kúu>œ„ ˆ³LÿÙ#ÝÎ:>Ç|1·©s`L’t*}WØÿ¶žªTMÕèúo¾¨õFy94Ö˜}6¿ÝÌöàLâÔp„]žÐŠ^o¹øÍh 0–òâ¢LW>\¯× ®x)A'ÚCeÀ]êÈC 쳬ɿª<)w"\8¬—±D¦çF‚öäCgï•þîe¨YäòU°wÂ&:BÜUõ ,©r ­D‹„†ÅÒîkª•ä´¸2 Ø!1ëeÛ¶‰î|¸[º–ìùST·2p‰äðãƼaÙÞÄ”c°Ðådzùp–^“pÈÐ^˜ÍÄg‰Y“¤±hRÕMZM95h3 è8õGNË¢@N¢éM ޻̖q˜a„—ÉSƒ²äÕ*€…7–¯«>lE{>g#LRfÁÓ\ÝJÛ„îŠÒ&éd›U8eÙ9{.‹†[ á˜=ƒj-ZÍ>G»î_wÂìØÃÎýêëþ¨.^ 7_ì æÙªÅh ÕLq•É5Ž¯R«X©MX(š¹ºá$;ûæD©Þ̨Á$œ¾ûi;ýú—¾t¶ç>r•‘î ëÜÓ=ý´¤»àž~úÓQ#”Çk;_ËŸüÓnÛN =œo“‘’v ;fœœ§z}¬îRWAª¸;G}ãÓyu¼]«°˜mj­S[õQ›žæ|SXû@óÉ…›¯‚˜`x) ?èsñ˜ITµÀêlÉ •\ñ=°¶Ah`·™Èp^€Õ¥_) &‰ðpPýÛ¬?CÒó‚­"ælq‚a%”OÉ `]®{ŒÉðj,ž(¥%»·09eì)Ï‚ ×ï˹s‚˜ô’öfo„g§••B‰ê<¿Â$úî—Ý•7ÌF‡¸! âÔ„èËã…4¹ÓÂ9U‰@Я€Mp—Np³ÇwßzØx9Ùp_.,®ÁdM\´Ç+ZÆœ¤ÂÖ,jÉaN¥Õ3·,Ÿ]I¼ž„ýÌ1õ¼Ša«òOÀ/ËÅåšpV{9á|„Û<®B¦ !Œ…tĹ.bî’·Oˆ²É±´>¡›[³w6iΠµÞÙù×t÷þf}x|ó÷“níx¬Zͤ9ˆ¼ªãAiÃ:FëÐ<Ùõ²Is!Ïf_¶˜xØ–—p‡¢Aáž.'é4;ÿ³_ûõqïbúˆÿç/wàtO?)6¦;èž~ÆSÃA pÛìáÙþ䟀Ã6·ºÔ‘]¼ “E4Õ÷-),Çmnýð0á᱓¬ºÑ=ÿq0™«¡–æzz­ ¾Ãu?Ë"]vL8ú´"ÏŠoÒU¹È-uXÏ6µ²t‡Ö†ðr AÜ Pü“õñ‚áÜfŠ ^`ùæŹì]>hðl׿[oB‡€òõ{±VÖG‘f"Ðð‚fÔTI\eb—ì´™å­N—9Všøu:Ý;ìF¡ê%ÈòÉž#àî´ i‘ÂããÚTÒ'˜„‘CN0œ/—h¬É$ˆN9¨ ™Ä Íþú½—ÏÎ_[Yø¯k™u·Nr­ŸnêLŠè®F,fw\¹WRœŽý0«æ\\†ñ˜å©µÄÙ_]§ë‰;Wá´$±ªn£JÎ «™c7À`›Å½Ë(›áUýYrfÖ¬ÍZ«{‘@¢ ˆ[p«³å,¶Ÿžºùa)Àa®.ý‰@ÇR:Q™×Ž}ZæÃOÆ‹¬²Ìª7¾t ×)²Zº!“üw?j#€"üH¹žûúW¾ñÍßýý, ŸÓÒ¥¢©d÷tO?±é¦p§ÝÓÏTR‚H„¾ÔÄǾ÷{_ÿÚûŸý¢LîøEÀø&¡+#®äU½@·y×Uå½ü¬;úøÉÜúðËÔà„¨Cf¥û(Ù/žGPBÒˆzjBuˆÄ¯eȌ׳û ‘ªE›Ò Ô] Ù¦|$Yäëi]à63Êðî`“ ²(ëûtŒÑ!+¹†.T§rñì–Ái¨¡‘t”4¡°Ô„Ÿøªû”—íèÑèÜ¡a …õE!c À¶Y4Õm"iîÃÒè‘Ã#Ø[pO]R½HñèbjÈJŠÈàKq›E„ÊØ#AO–…wn½æCçóæÉ­Iq/·âS(§Œ6ï ¯‹À¤³zû‹çk«”&¼GŒ[Á¦àçYc”kÇ•vÜ×éÑ{L¿’eÉz‡'º[ÿ^^Òú¼z`…ße,ªJ„v#~Žá°ÍeF#ONÌ]@&çdxÿä¢OƒQ\µf4NL>7%.(øJ‡}ä×ÝHÓÀu0û5¢¿­r°Ž]€® ×û¡9ÒG±lYç%Ý«p«¾K`ý¬ÊZ4»Âm¹¶uÎöÆ^Q›c5®7¹±¢·I^ö}ÛÎò nµïƒ<ýÖoþóÓöÜ÷X;ó† ‚WßÓ=ý¥¤ÝœÂÎ=ÝÓOIZÎzJÒðóùüÑxý'þ•? >O‚x„ö‡[ü1C…ªÌ“73€«¨,¡ƒv 6…£ßé÷V#t‚‹ÏœZGe D‡HcÊr’¢<‚¹ä}ê½.–u0‚Ô(N{·&»ðH©ºqŽðì•Zƒžó,Þ3œ{KyRεűå8ßtUÊ:œ7*qû¯¥öËd`u1 Ú ÷\"v’ <ÚEØæm|©B ðÐ"çš[[ˆðï7È)ëFÉOÙöWU]›;ËUj^õC89šíÞP²G=­…?Ö7ždR˜~!÷2½5X÷ß*`}#k) "X-Æ„Ù‘µmU•–[ǶÙØw3ËÏpþ­ßüíÇ×í´3¿ÜÂ3¿;Lº§Ÿü¤:ÌnøÜ€{úÙH€yqƒÜN›{DC|¬0ú$¾¼q $ >~{\Eš‡n¿bOŽ½új*…‹ê0³,•x¤ˆK‚¬eösóƒì1Å‚ƒ€RÿµpPUð¯¹è©é2 åå€$äŠ@P´Vu©<ºß軎$ÔŠ{B½ŸMm*OzÝj÷ºèÔ`)¥D—ëZy¥U·wVq‘ìztµtwÂ?Ö[~±¬uÞlÅiÁÑÒÆÒ»†€š†™éÂħEãÛÖ˜ä‡EŸLÁ¤<­§NJAÄöúqß´Í%À$˜™K´¼ƒj}©B-Ö·ºY"ty÷óÆýtR¡"*ëbå]RÏý7,¢ƒ ÅùøüÖÊ?8´Îv’W× Ô3¿Ÿ4W圹eÃIÙ+&î„›5ó»º&™,®÷ÚBæ±hg7´qNmTDÈL±´£A 6¿ª­u‚GI½e<íÜ–gC±ì7vˆ?xº)b}Âç( èÆOD‚7ù†/ÊlYÖµ.Aªå¨§ˆ=Eš¦YÙ·¾ùío|ã÷6œrÒ3l¤=úìßïHéž~’Ó]¸§?©e€8ãT¡6wÃó—ï}þsr„YBŠ!˜<ñ™,ƒ;/º®H‡s4Ë ´îú°šµÒ*d¿uÒfÆlP{8­½#!‚bõÛ~ý8漜nÍôQ—šçc²Y'u~ S g“sÐf3¸à­ ¾jÝÚæ<4[S[Ö‡ÙwK5­wvI³°Îë„ öG&µ¡)¢ØWs–bY‚Ãe÷¥‚EÖRS|Sp-Å'.ñ1'L¸Ù%y¦Ê-;À¤k#Àa>6ºkCG tÑ’ä4Øå¢}—DÚæa蟠LðýqgUP@‘ 4ÌŸŸõòÅØÃ(e$A—Ó|Nœ«‰»@.ÜL³c#ŒQXd²{"K¬\w¥µèÕ°CN|J zÃáu…:¹|ˆ–¼‘<á ¥=±;À¸ˆó#›î¨e6s×éÐY.úªxl\Æ5/¯ÛpÝÍ7ZÞc5mZU˜Phwf½öFì#Ç-çÉàϧqåìϯn3]ïuÇ©×м%œùáÕr¯Ù’U=œ«÷üêãû·û„3f äÚEûç&ÝÓOCº)Ü}îég-Õ®ŸàÖŠÞýÀí£ïþÞ÷^¼ýüåû‚bó8 'Ê“/½àØ¢DTn )ÆxƒæèêèáthS•#¯k–¶Ç@ÈËaA_J2F‘³S±ÌvÕôf-)Èj]ØÂ*GtUrCH"nõ®-&ISü¥¢ô¥«h`æ4ät°„̦±´šìfÅ`+..ØNæÒ"d0ÀÌ(uè!1ót3ßÌ_<{_̘"OÙa: n"ÊÒN–Ú!TÕ‚”’3%æféQ¬”îâi‡BεeÍâJôÈéÑ“rY‰³"‡5²Î¹žèª®-*Rf=Í8Ó&§É3Çæ‚Ïøñ9M[*«²Ón]7{MtIÌØGGoÅŠ¨i>®Ò".6Ú=Šœ¨‹««âÝh–Ë¡Àt+ºkG/½xgbí.=xýÔòÞQÈú$ $ Ã`ò F´= h‹Y|ο6æ!ç¾d$2âw~ûËg>Œ!3!=|÷Ç®ØM¸§{úiLw À=ýì&6§ØSe³m¯†ÿÜÏÿ™m;ÉNI¦ °‰Ú:´ –0>MÅÆÄ ”Bã‘4æ„`Êq°Ä}>(œJt˜óöòx‰àHC2lé"Ï.ï¼}&OF ÑLNÂSc˜õ0¯Z`9tSŸ%Åh? 4«×0s *—×µÄ1 `ÆqH\s{š ËNù·Å°#ø\ÿš¹Î•’s,&‹pÀAØ!R¨Tþåš7é@i Éá…éÃ@¢=uèòò’„òk†þ›­XŽ¯7–Ž! p#6íþz® –7a‹4Ôåõ€D8`î‘“„±ÙxñìôìAà#Öc §y_Z•²@M•±åx5ߥbBÐZÏ¥rÈsŠFe¶ªø ×>ÖOtüåÍBÂQÑÕ;1œA MÜ–…¹…P³=\yÕLJ¬=º»hmvš­¸Ù¶‰ v¿¹¿±}ôÕsPuNýgfͺ¿n•[Õîõù†Ö?ßÛ¾9O˜[ó—’øjˆ§`¸|ãùë_ûÆw¿ó]‹@ld«½Ê»·ó;Fº§Ÿü¤‰$抹S€îé§&]míßýr7]è4hìÚÆï}ë+ï¾ÿs‡ÛÀÓîãD ¡-ónÚb•É  Çy @Q¹òZìc²íûŠ›ê2Ú g^GLc„7Ó‚†‚†l¤.HzYk]“ÛGµ‹æN˜Gc_É[•¬ À®€G¡lšbdÜC7-8<ñ52êÁ[$ŸÌ~jóók†ò-Uª Ž½Ÿå'¦ŽZ‚ó–6hx‘Û™´gõ†RpšL¬Z5Ó:+‡ÆFBú•'dÍÿq’]òõr—% yëzsƒ/kw†æè[¦="f¦§AVØ˃‚kC ;âó §ØF‹é­Y\¼U>ßdĨ$ܶݶq~vrí”Þ-SèòÙùª1›È>ÅËR¸æ€Š\ZZظŸ¨±DÄÙmÐÕó„äF[:®^Yûð8½®pëÁ⻼E’\G©™’a£ÌiÒæ4цót•Ã .‰Á× Q`3¦XG1˜vƒÿÏeÔ"){X'fâø²è*îÕuãfûÒº¹vQÍZê°—†¯²;èðͭ͘WcÚÛÑÓºþŠV® É 7?>Oôr(!z&{dUZÜSU[ä""´}÷ÿýíïœpÜ—;ð`µQ»Ì¼A¨¹§{úiHwàž~jÒ‚û 'qhÃöчß~þüóÃ[ÜN’“`CƒË%»$å‚5îW¡ÂÄ!£n0µ¤€åžÛx’«µÂKí9 Þ*‘#¿)"‡÷%?„µÀï°€‚;h„l³Œ€fœÀBq)‡^UuáᆙŒ˜t¸òR,QkP"`Ü6œ°àN°"¤6ó#X^Çã]^x4ÏÔÈ2£Ú»ƒI‘q™CvíÂÜP¹DÓÀÊeÛ7$¼wyþÙ Œn©æDóé…0…¨³!¸§Z_õáöSPHÞœãÀÙẠÈ4Q1&Œo£¸¸ÀÆÍ!>´TV=¦‘M6R$iá„ ¶“Ǹíkó”tÈ=l6|l¤4¤Ë |ûÅ˱¿2C¡ŸGc¸ºË;à” ­u~ÈiSâë ç<)„ØÂavRN÷º®$îÚh5ÂÞZ-?”r3›+….à:©ä‚e£Üyµ‘ Ä“ žWªYAÒ¨rŽ$áG ­‘œ‘ð¡e¥Qž~8åw³ÚîJ$ž¨»~_$‚Ùd­õصHº®¡ÑH/”Z ‹813>jþÛ]d¹ª|éç®Ì ˜‘bÐìê«jF,;亅µŸ¬ žEÍ-·T&S^ ™yj d4”Àã‹«Æ.÷¯õkOá8ßœ©e箥wd(ÝÓ=ýä¦Z8W2uR€pK4²ºïéž~JSKé›7d'{=üó_ø;=s£;7; £žâJn6ëè—‹šurŠçÁµ4Ô…(¦š3•Ïó|¯dÂüz”¢–‡g30¤‰¢Sˆjpz¦Aè£2y2³r&³þæ<Ø—ÒîøЕi5S_K®Ý9OòŒvr¼W!$³Æ•V0’ý3}–£«má‡;Þ V %»ï~‰Û h|A‰9`}O[ ÕÃ>»ž3Ò5hŽÙ.€dz—d(!J¦J½s%.ƒB<3ƒ R)•£&Êȧ**PŠ’<(±ù®×cˆ°9d"ÝøÉE Øã»ï¼†­Vä²0íмüé2ÓÒªf_T?¶ìܳúDI¯⦳”8§UË<¬@º€¬œÈ{~®%ÞLÄ5d[×'Pc< ïA¤¸ §]fëãBe-ƒ[œÀxù Üfu7n=RW?zSY}ïjH?¡q3öŒ6@Þ4 Äl‰®Åœ¤Ó*V}4;p™óoèëFÿK·.„È«ò &½¡˜Ox¹¦Ü¤]VäˆK»8Ìb„»Ÿ¶‡ßüäAÛBÀ]¯u?”xsg¾§{úÉL‹ÌºÌç»pO?£‰HÖÄ„H5äÔfÜÎ|æ‹ânEóYQwzɬð@î®rž,žç¥9GÞƒºž¢ëóñìD‡ Oj{µ(1dýÙt™¦»[~u8v Æ6»'½Õ8D°e\ŸYºæ:åšê! øì4 P^U’D1ç•oKuñ"ÒÔA˪t‰ZZ$£C*ÿfªHüq¡l¤öó $<üq›N™5ÄjŒ†…véHðûÄå´P]ë)—ª5N{Ã8W‹ Bþ߉õ„¸”.;a*¹!ÇäÝ—‚²ùÅBê^ÍŽ,ÎRdÀáx¶FÛûë×IoGúÙ_¼8o'ÕÌJgŸ½-µÇ'FǦíé…#Âny³ÕWsVz"æ’ Ø³ v ©aÚØRjZ.D˜H~]ŸOS÷ÐBòáúM-Þc“HžOÃ6ó"€´M¬‹ÞTNp_ù‡pWƒ¾Ì—Yפ,Ii>±r’±ó ±.½ž*M º5ãɨ[žE]u×að¦à}è×uG{òÛíîfu€û“RÏ’ Á«z¶)¶Ö€p£I}…_{\G-ãöÕ¯|õÕ«×t+íHÝ"Ò»ÄÚ\<€{º§ŸÈTÒð]¸§?fiQä5•[‚`CzþÖ;ïú3’ytlÙñ3zÌAv(íz¤ƒY‰¸[;»@ô@”©›¸¡C¸Nû¬©¯X*XHU ¦ Éz3 ꜽÊ;šo"êvÊ,Ÿ€™®1Š0 L…ÃJ—Ù|ªê±`þæ8û,»a2C‚¦$´±¦86óiK%m”û@1Œ…áu<ÝY²_¾Š#PL Ûûè¼Â9æG½l·x~hòìL)ÝD\NÍjßâËÑ#‹ê•ÃÈÄLœÎ*Ý8—=>:° Fn.ß_ï!åR¢]ìááÌÍ1Ü 7†•q8Z@Fí„*0ììsúGÕ#\¯UƒA“jV{ ‡±?öø*w‹†Ñë«.gZI,·ÑñbCT-æ¸Q]{¨”$²ðßØÛ°Mjok 9+·ž|š„㜩5/–Y>a´–P9×iì¢vÝ>žuxãéO„€å Ígbþ¼†ëê煞ʪ\¯VW£ƒ¤§£P”W‡]áï7Ôl’$W1† –FålÈ EtûðÃï}ów×´5cóJ¢¹êÎ7 Â=ÝÓO`Š#íJ¸ûÜÓÏzêSªqIº™ùÙ¶>üÖógÏž¿x›nضfn0õuVÜ’>­Ô>©ñ@¢ÏºÇÈ›¥RÅVáÍШO5Ûr%Õ"l4J¬ h‘b"@y)´^ÀŸ­Ñ F~–OqŠ¥kÏjÊú®.õP2ãSz>æäT©³ƒ.R*ÐÕ‰aiE3ÚαKP…îøÕ5‰<ë,´Þ»s' ä ×Û,hiàâ#Oé/ÿ< dÒ½:¥½úVWýT£Ù²”!JU¾Ú(ÄójèÂÐèïÈšùeŒÞE[ù‘w3zj„ÅŠ(-¿ü|Ú.®rmLI„ƒ¦‡ó‰¾ãëß8Ù)Š±êÂi_8öÂA>½Ë÷ôÓ™î€{úã—!;@±Ë?óÁOççÃÎÄ%1‰#VcçÉ‘çµÚq32ÌtŒÃÑT–Ò^Ÿ_º>_ßƽ­yº¶ò+!E¡œÈƒ @V`çJ —ÕbÀõ¤ËÞâJÕ··ŸÞ,TGý¢™+ð•è å|—tš–&¦—¶xJ(p»?®¾¸‰P/µõ …pgx.eÔ¬§½vS”:¤e?1†ÝHµ%=Áî\òXš0™Ë‡Â®Pyo3×õ*Ü*ZÀè­sãöµ/årÙ1"FÁäý_uÁ'tÇ&ÝÓOxº ÷tO¹8“Ã@ˆ4nÏ^|ú u<—¾Iú/õð5ö]¡dødÌJ^)‘XÆÌJÁ'uƒãRôÓÊ/€gA O”çO… 4v$ä =Ï‚fckwNO Zãì@n¡ð„Q-Ì«Ö®ª_[KW_ÞHST86¿­3„ãw>Âq8ì * ^0÷€Ñ¢ûÔ!ÌFz»ÍS8tßË–VÞf,R 5‰¶ô^ÏÅ㜊2´)¥¤t`ûØ|Àûedæo½õ  _’é…Ü‚Y5m4a†Pô |IÈ E蟤5®Ì+¥þö Ò½º Æœ‡…ã²wºƒÓ´âüem.€²ó :š«éþ'§9Yò/ûfÅ5ÈZ1z´1ò<èÐ[6eÿ­ø.]Ý{CLŸâÜõ+WÓÿ)ú"eÜÆÛ«ª±+ž”£òì¿jk½1ïÈ›q7gW}ÿt¥¹"&]åØ.æÓq39œÕ6'ˆï~ç»ßýöwLÈhëú½!e¿ú}6îžîé,Ý€{º§žÖ^±”’6ˆï}æáùË2d¸¹›Ô‘I †,`¢–Nå cÌ ЕΠ%+‰¼¼ czé8'Ã!Ï­†}XØøv=– h-šlͧ ÆM°A¤Wå( ‡^-ýéÛ\åµZnÉ¢û¦?(¹¢9WX>qâúYI+"šŬMÿù„–š¶…Ù½É] ˜`Æ}'Z=ªÒÂÊ`\Þ·SÐdºM<{#EÈ‘ž{dhÖqèÁetzp­Lt…Õ"A$Ë'G1 îp›3kêÌ!€æcsaìÚ÷ÝŒ/_<|ÜBÞX«ãSøµIXÌ0£Ž’ÚHÈ]HÖZÔÐæ·Ž¼ìÖ?•K¥&óå–žW7p‰äÚjmM7Ù9WsPN—\32—D“L$xr˜@µ°/æmi˜ÉË¿RâkÁu1_µò–Ty|àð{ÊÚ¼–¤?áh^–®Ö¸æ¸T"7¹´[Ñ\ý´Æo¬EeÞ-¸UÓc¾‹à(ϬV¬5íÛ(´ õ£(Et{rЄÇÇÇßýú7 $›Šžši˜ÒÎq¯ÏOîéž~ZÒ'¼:ò»ûü¾§Ÿ¹ÔúŸÚÐ JÎͶ׺¼ÿ™Ïc{;Á:Ðàó„Xh· ,î hÕÒZ ‘0=Ûš®+jñ0,ª¾©4Ís¨Ë)\>•‰ßÜäâ^ñó§(:†Ñ24° ÛÈ­•¿â’%+Vt—˪+™˜JjyBŠZ]˜’¨ò.-4|?ž¼=¡VÄOŒXl¤vól'Ž~ª^ñ$qtœRÉ]E,(º*2àêr]h»9W\d w¯1¿*˜Ì‚Y×Ì)cìÁøè×ñUêf2N ‡Œµ€Ï” eçÈ€Vzº;p"·×—Ëë—ÏžŸÎ›cÀÓVW/®K@§¸¡¬§cü#×à¬ËZ›C"(‹kíæ|@]>}EŠYgÂ²è ”.¬_{ 0W]˜0¡¢d€ÑNÅM‚“€©rq~ ®ÌK›œ?<,±äÓ³VûÓƶfýÆûIËî ¢åáóE|8 O³˜‡þâÐr-ô¿1¦Û'¤Cõ0½Žë•|Q‹öv]´æp]ˆ‚ÆÌwš±˜×ÖyÞbñ•ùeƒÉÅ-MO-O¿JwŒtO?ùé€üú*Ý€{úYLl¼²€ÂÅÍvâýÏüüÍ6èZ_·»œ=u¢äõ¹åZ›)áR(}‘2QBsˆç±ÒHzÒ+êä[®ÒC/´>pK>I=·æ\rPZ—×Z¢\!âM5ôAUÝâÓ"}LidÝT·øµpD‘™ŽJ¿jÍtå<@üúˆF…Òn6¾ƒ´´vìuçcí¢è’ ž†kØâN\;,¦`‘XáàºÐl„£Ü5@É(|ã`iý©rhîah¯ZÖçR‰ŽZ2h&‚pŒÚ¥¢€€ ØÜÝ5N'³º1Ž˜ƒ;ë2ë;Ûë«H,WúP)ÐzØ44;tÊ 7CúW'åH§ˆ'ý”úY•°·¡xzPÞŒW/Yô_ñ¡°I›` •@­ yÑ }qíÙOœfÑ\aãïŠ.s˜Xäÿ'Ïñ0ŽZätý–v.ËRùÉ']©«¬gfK—}rZ ù¤~=ÿ<2xòÛÓ¿ê­ëœÖ¢NìyÚh_ÿÚ×Ç>è-Õ¡÷X3yZé;Fº§Ÿütîéž–´Ü<•°Êf:={ïSŸwl‚™ ¶É”ÝâÑ;­Ž*á5ÿþ§ŸáBÒHü¸g[}Õ ²&Ó<å c®Î¥Xe¨Ÿ§«w‘1_/>ÉíÈœ˜XOòXÆ8ï Õ€…5´r€@4°Ô´ãKI\ZÚXhÕPb£åÍlRÅð)g4ºŸ lŠ1%þ¬ òºÇ ¶*½#p–˜€¤•ôd\«Âk ºû¯ÞQí”ÅTSÈ‘ƒ®®g‹NkfÕbwÌhÏ®×çIâDúùC=^“áØ0*e³ð[®×T’#Øõʦ¡.ÇŸ`:âÿßÞ—-I’ãÚУzÑôÌ\-×L2ÓÿÿšL&ÓÒÓ[Ue¡¬¤Ó#"·ª\pz&+ÂÃ; "¬ÌcŸ…@ûVæ×j£(K=Fß;äp´OŒ†ÖØ2Õ=4½ ØðÑÁCËD$Km´­drê–1üT¨s<ò·žÉL}ÏVGÉ'g»{«x$ ]°trñçRêÆÐ…óýÉÌȇzLÕ]uòå”?¹pu…¾å™;ˆN¿þ¿_ÿúãbjdçHèP-Ž².‚TxCX u@ácÂØ¥ió$JzÝ}ýëë_ÿ:ýüÏFˆ£,qcêhLܸèì:*s#žÍ),Då'BkB™[kÆ¡Uµl륮QRMK¸eÍ g¡bŒ×ËD“…‘¼ÈaàL™•Ñ0Q™…‹QM"êlñP¤pB™Øx§¬d©©Qæ$•)þÀé{ç.1”䫦¯òÌ@¤¥©F£eR†1é†é|™@¨«°‡ã7‹ý#úhsbµbŠG6NMÂA÷´)AÎÅLÈPv?H/¹'zï‰>¯· ©F>yÏÌ DæÏÜ]þê] á%ŠTxÞÊUn!ñÀŽ†Ð¥æ9Ì«òwXOŠ‰¤=÷ÞÚÖûÙ\2ÂUÔöç½E*ÊЀžj{;Q±{ïj®í–$ÌÑ©DŸ/†mvŒ1[ß1›‹*ˆpê´8K[2yøw.°} -@ÜÔe%ÚœBG¥oµÜ¹AÝñ­‘B¢õž#‡¼ÆqWÚí ,ZioÊ5 ¶õ¯ªT’ñÚzgbY/³~„3ŽÁ”ß?+P…ý "ÏNl›Mò”vH{`£X#¯S-"ïžñåîóŸ¿ÿ¾ANwç–dUwPÿ<}(Þ"Ê ð1ªuL yÐZûrÿÿüßÛé£150zº©s:*À‰>w±ŒéeXJÝ,ð·Þ`ªzŸ{¡ÌsšœÔZ„ìée÷Dákû¡­?5¸»í¥„n…ÔåXTÞÆe]Ê Ý`C”Frê¬PR1˜6i!yQ‹›ÁD R“›Å;#!'^T±a’®Rpi¹=È´Ý«ŒV[MU"ZÃF FïçÎgâ¹ÎLJÈê/˜4˜©Y,7i^¹9<uá$¨ˆ|jŒý—¤”˜‘ÕWNãR!&—)ZèUÝ^ÅC‘aÌÛ¡‘Dü̹[#ïl÷­ºNq¥Jdã¢÷skò¬9<ÈáJè) J6þQD3£÷®±›8^Xy Lh8÷NDXÎ-#e°êØÀZ ñ{9éÄÔCŒÌæ]âAZ+ÊÊþŸ£‰´Þ‹õSB!^\GÜ“æÖ ö¦Ïd9VëäáWµ!ÒîPJÐ_‰@ïúÝzàשˆÖ÷:eMI;–æ®bIŽ>ïns©oŸ€‰˜Æß“˜£J–Þ1Î`¦ÿù?ÿǧö‰{k<+v~£’Ä.»¢F…7„˜ÕiDß$ÔX/¼/ŒïöÄfD}:>ŸùŸÿù¿v: ´u0Ð7b ip¢÷à\,ª,*6%ÿÄAÎc‡Ù–ÞQ×n,­çx,./¨eƒÒ ÖxÜ6]c¥•`]°ŽˆBø.gŠ@æ}+¡ôThŠ©Ï6ÛËp»_±á Ñ™Á]¨[kݔ螑AWä'v¨I’± ¨ðÀ<ÆŸq;›ÖD# fî|NËN£¹7ïÉË¢ó0'* cR-ÙjšÄ<˜æ?ú&D™’CËØyóÀÏÄs:ñ¢¬¸fØ9»6&MçJê§ÂóNÔ >î8£&jÒŽ `fÌÔq¤Öí(&&øa1øux1{8ýˆúÊVG™1YCt&5b&i `sw ‚ÄRÕ#©¹1NwD„Í M&-¤sÍlÁ@“}HPbò)”(ü¾ìW`ïÂýÌ-`r ¶6™?BšC5æýaïÂõÏ©†"íltËêE]ÂÌ©ãíeÆoée=ÓææörùCö®Âh°÷èý¯ÿM`¾ç¦ÀíʦDV_‹Þ"/ ï‰ ‹ïkcº?õ~úáÿüoèÛ„Ö€³ì4õdÝ„ØÚÚÂy­$ ’ÆÒÍ<ØØÒ¤¡'Y\ulÚå¬Ì³'a‹©ÑÑX`÷ëã^‹eôÛÙ2àÆGfy@¤ñÑ3É '¥fÉ-êS{·H tRþyæ®lS_<ñë‘J΀¹¡Šm”nôÞ‘W_£ZÔÀl¦Qž¢ÚÝ€“uŠóžs?7=ÆUNe#¢¦Äþ”™§370z÷9Ê]Á³ù””µ¶±qŒšK }ȃ4 iJ»+eqé4(&µNÝ_Õ*2R&Œƒ¡Žµn>¿‚”m»úœYÌb:Ið¥0 B>l§7,†#E$ ⮥Ӫ@|&x„œ®-—i¼ñ¤“mÊX[ã¥ÑšKÂ$¡ƒÐ DqrB“bn M¬ÀiCE;öÀÏ0Hy%6÷ ÌGE¾Æ„ÊmtûâIÓ·°nÚßËÖÐ#Ceæ&—ö[‚²-3Sñé¶á°cßWÀö&Ìo³ mrH7¦ØJ|©ÖÒ†²Ùщ©uþý·ß¾|þ§§˜ÂD^{ìÒÂqvùµZ(¼$±ø–Pø  ý"F¬©ÛýÆ?þü÷ú·369J‰¹1õ.Ê߆L¦U$_rRlG2>3¹÷†eyWk¶iQçÞZËDVY»s”ôC¸ ÿpƒÝw0&ªªi£½gp³¶–(–,”õwÂÆÆôZ³¥UDK½÷©iï›M¥ë.Qc3Ç×ÿHM/¨5Ù è|ΆC’8”Wÿcfæž„mºF­³ú•2TùMÔˆh£MDç35Þ$dgî@Ïjpé²ÊKµ;>“ù.w ‰e‘0”¸…D”w~ú¤Ä\òê¬! ;™™ýGŒ^’@Í‚9™‘ˆH£K‘ˆPÜ{ï4—…MeÓ—èöTÈÇÝѪÁÌ•˜Ð¶ÞÉ%Váe1lCÖÕQ¡á·à• æcܤ P³…ȉ§Ž‰– ÂÆtbSãÙß:ã|Ú\"ÈÓBÚ]K™„?HãÉZiÙI¶5.‘™Ø“ìe¼Nh­®NOWÄÓEÈY¼‘"W¬¾²¼Ó¾Õ‚ýéÆthy¯oJ‚£r$™ù\`úšÞÀýçÏ¿ÿú¯FæxÿöŽ[Š¾ ojÜ>BMÅèÔZûÊ÷¿üãßÛëÜÔpâso;Ý4ß>ê|Æ­ÍPY¥aƯˆè¬î’ºüÈt# ÓOª¡8“ß+–-è‰Dø êk½²+s¶öú’5u*¼X){‚q×¹‡Å «,tÆ™H”ùZUÏ÷Ü»ÅM“–>$¨§Ç… !6ï•1²ì‹Ïã-@*~¸Ù‹EÜ'áøèjèßšÈ`†=ZŽÞÁg“4­ ™S9A„"‚9¹kxŸh²œÛÓ3Ý"a#{ÖšÞCLLç4FñmVm,ùI$ôzפ:wîr¡ƒf +ÉÀ»Éò°Y!ÅS<ȼSäMcg4¼RÛÐV2NÃÌG/7 ÆØ$L*¡1wÐÆÜÐ6 øã½ë£›cÈǦ’ÏQË_Ú4VR)ˆ|yåèÛ¨‰/¥œ´û)‘!Öð“}ðùèéô:.zâ{Ί§f,Éú,Š ¼ü\þƒ© ˆØ;¤m#.ÒBˆ¾ƒc¥Ö&9’¤Qoû~þõÿÅ©éÔÜHGRJ¡Â›FÒh/ ðÑA¾`˜a41ˆøŒ¶µ{Ð/ÿüw¦ ôCïØÚÆèàÎçNfjë}ÃÆè±{ïë-Çê4,9jAÊÍ’™?¸©/c½²ÄnV®Qžé/H7nîcÏ"ç8qŠ¥˜ˆ k©ì›5‹>P“ÓsÕ¬ˆhÔH÷ØÓbîÔHv"r‹UÍ«×ÈÂ^‰ºÕÁÄ &×»³†ùÖo´fj¿Ôº{° BÒ&̽¡[iÏÐóÎ@ˆbÆ©Y¿x¡†–4Þe½àÚ`oÜž bØyÁå4ŠÈ:O¨$£æ=.ÿe:ª}’f?ë-ƒ™Dè¡_Ö÷‚NÜn°?a˜C¹”¨+¯·Ñ+lZ7'q×~°¦¬2"ئ·»·1+5 ïqÙ'æ©un}˜ñ‡™H¹!U¸ûþ—M°nõL™}á—‡vrYè`9],°Gk®5ÌpaÑ5cn!Ý°ý¼O=†íFMUY¥M·Ì;ŸñÐ_ïT€1ÕèDE³ÆƒÙŒÙÄ`‘Ð~ý¿ÿÔ)fmä9Éä—jY(¼E”P(\F yÑèq'´ ÛöË?þË=oh˜¸màÎ8oP“íQg‡†!Z§™as›ƒøØJ&aÅJk:JCg‡öÍÕ†yDž±ÊžÓoXLöiÅ…:ã'“rœ IÏѳ2k˜£^Òâ ªi´Fܙԃ֖n¡‡ÊémƒÄIgïñŽñ YTÐ2BX\ì¥d{'ôÞ)×Mï‘í¹¹gb$­j²6H¬Í{æ3±n¨’Îè•SK}n¿¥ùJ;Ó˜ËH¸¯éÀ IÏë°k{A‰óZŒ©2qR¾m‡vA%)3o:ØFvÈê–F‹‰™peœÌ3ÎÏ[µ£¾iÒ µÄ¼åAÛ†±®ŸøvÄi­]åÔäda©hc4 Ù© 0!ÑYZ›mj\Ê w7 ·V—Ž°3ñölÒ‡ÉÅ%õ€ôJOûO…›ÃÚfæ>ZÞ{—ù[Oíºû`±ÁAëè?üô÷O?ý´1Z7n#_I8GÐ)¦‡6e%¢™¦˜§*R4?ò˜ŒÁÛ6ç_§¡„œÉN£ZÔ$žÂøñÖ9=TÊÝ|å§X7ÅšÚެعK\O'vfyÂœƒeCï½µ&õãQ§,f9œb–†¼4R51õ¥F°=Ù*Qïgg‰ IÌšlC‚Š-ZyÕßÜS˜PO_ÊÂàLYµW8;PÛuŽæòQ˜óµrfõHMv\B0ºf™PpÝ ä%`î6ä›Ê ¢¦E­%©,•Ìº*U3mçäÆra,M­L“Ã5MÕ÷'Žßv w]EPç]+¤¯tÜé»Çv¯I7ùãlµeƒÓƒ&ѾM¦ÔSÊaÌã=:rò”MOršßÈ’’ó3zÃær˜q`ðûo¿õ»{&Éå")íxÞJ(¼k”P(\ÆÄ â23¶{ôÓÏÿá§_:aóùVU^vãËä¤.©]1®€±C0» £’qʯ™ß¨¡ §$Óª‰à4¼˜â<.Î<¬åA'‚gi~‹X!P•¿&Ø@gÜÛ±_¬lRzÓ#L‘«FÿBñ*+ãcf‰ˆª±#Õ…³¥Âr´#ƒ™©‘ØY›bµ“rÑñ“<¨ŒZÏ;[÷C‚1ˆ5<}sæŽ.gœÉ|¥©âýéNºÆ  Zh!Óœš6q:&˜Ì—‚ÓHb¤´†6clT‘¤Rl$&$ÑÍ×ÀÜs‡÷¾Å¥²üTtšnbåU–Ù '’ìDë„©èq%\)œ–‘9 jyPšS)eWG ¤zËY±‹CÒ‰©Ǫ¤¤/¯yÞŒƒìÊÍž2¯~JõÒr.ùÇÅ#câÇåŸÒ‹¢{Î ¢®Q°¬T¶U•I§ŽuØK SÑ=¯×X :w2 ¾ ‰Kˆ ïINóèjºõåó—¯}‘Ñf®Æäo›¼l÷¢=…w† …[(£‚ÌZÛîøþ§¿ýòÿœ±1x‹åžÅ“±š<„†ͨœîl»êp¤Qi±´­µÓu[ ŽÅÖõåùÑ5‰È³\6¢Ž™ˆ]ÎÆ+®Ò8–o]ìS`i"œå#‰ž³«ÞÃOHöL\áÇ<ÊLÕf1êÌÔâ`53 ÷ZqnüFMŠÐH|€:iEй›E–j0 4 û)ÇÌ÷à‰zMÇñÿL*…Pµæ…bv+îÑñv ¶uËê†ÈGk ¤‰á…#¯´mW­¹õÞÀ}Çž(W &À„ÁPc†Á-b/u½Z_yÀ+r°ÉÉêÞ¢¨IbgSkzg3…2¼=§ïçʼîØß[±väÿæ–¸Hâ OâBcLÝ_a¶ÁdU¿\Èe~銵[¼»x¬ÆT3g=˜.Õ ï! ¹]vä¶<âW~½Èn u>mr¸œPü~þý_¿mõß6_‘þ÷²Ôòz¡ðP@¡p4íÐËUŸjçFûåŸ>aûdºKc@bì“xÒr1öKqÇ ¡þŒPÍËõËÓ”íx¦ÑÎ?ÒóLl~æu<ÓóNç}ÊZI׆»i soçî4ÞKÖblêrŠ„=§VŠMUÌÈ7íµÒ!¸»m"š&R™eHæSn÷#Ì2Ú/ØrRVâ?Ët–ƒ„MÙÈwæ6øû*ã%rã­\h߉ßGyÇ.p"wÙ*L¢Ñx?ÙHõfTsjµR¿ »ŸÓPÒÑ›‹©"î4Ôv Ç’NN2'‹o"/†73ñåò0#9Ó'Ûð™@*úSóÔÛÑqsX2tá+zŽúç=’ÉbèOX‡Ñ¢Câo¢ »ÓF}Áð¾XVZ݆]€PÅCÔž‡!jÌÍní¢UѼŒÇ^wœÀ nÔβ—Å„Þÿø×o„†Þý”qÝOPWqè‡U›í)¼?,. P¸¦ß< ãoô·üÇ{úÁD…†ìù)6:lD—ºspú7-©Ê™“å+LæO$6+£’Ik*u†¥zºwOžy÷1nˆ²Xùu_“·–iœR¨AO¥J*pmMqõO9eKþÁô/"X =JÌæ_Á‰b"‚ ºàüåÎ&‡Î¢ìG3Àæ¦Anr`¼’`ý™ÍÿÝca÷j6;ùp%Z®d!Lƒ"è°S{q¤6Û*¤óꌓy΃YGÐ='wWZ=§et8+Aó;•iR¢êa\”e°Å‹Œ.é Ц¤ß­½4ü¿íË Þ^¨ÕÕ¥3®ÕÓ÷"†*-¢ûωΣüñ‹ðR0[­õ6Ž'aí!Å+Q |Ð^y·Ê‘ÏŽ3»HÄL‹©SXö%´Þþøí·~&F³ù6 y…ÂÇÁBÀ(L¯† !-CÄàíÇŸ¶Ÿÿh³uH×~SôÚ¡¡¦‘$þç “YNë g]ܬÀ4àˆc¨,fÍL+·žx…à´zaðbL1¾.Ìt¢©*²K˜ùÞœÁ¼Öf–)Gc%r2ÐAM³€%T2üùIÈaÕ ÷Ð,:#™ºÙ»H[†•1O|I¡1ÑI÷pà&)k&; ºØüvä4™‚RÌ!ÀMªœC…ø8 ¸dfg+h˨¹Ó +ιG:FŒ×”x?z¼}r£åÑ64ŽÍ+¨ y(3[pO¤ÒÊظÓÆ ¨å‰ï’9ÚТ+ƒ”±>TôÎ*ŸŽg\oLjݜcððvéc_î剥Ìd"žÆËq”†»ÒW&¨¾Íà0Øq%½Ó|¾z4à_?& ðoÖÿ~gÈŽ…ÂGëÇ€: P¸_Þb!Ñ@÷Ÿ?Óéóvú BDˆdn™9%sÙUµãèø&›×FÔàk"AÙÇlþ¤¥Ä_¶7›éJ†ÖêlïÀ¾áÓÝÝ×ÏŸÿ:¡Ù™˜¥ã'(¹â W€š'……ÅBœc½oǧ¶}ùýןÿÞp:5æ  Þ{“ƒtB—–l¹åŸAgÚAÔíä2&*G^|ÝÊçdËm5‚Ç&³”(¾Ìϳûl^4>8j¢a-ZpSŠŸ`ž¸Lz"/ô¼!„“p¡wn$Q}‚-uîNnÏ #~©™M¨>! =m¥fkcwU[.aØä¡F%ml·Ôˆšp"ÐÐ:îÁ|¶Ü…µrwïn'ÝŒ1òV·RZ( ÀX†vó]V„Ù„eF t7nåârsãÊZ ~Âðë4“"ŒÌ\-94Ú¹b’w­ÆÓ£LhºÔÎZÓÞæì%©¹ù†ÑðÜ„’D>Ma¬Ÿ­• XrY~=B—rËî'Ø# Bb(@LÍ+Å2áÚ¦ð8FirÚ^ZÃÆ›t‘ëÞuø©u~Gz—Ùn"›·¤€>*îYß*bEÈ`êýþónhHãƒ÷PQšB!¡L€ …k ³J`ëØúÓßþþïàèUóžÍÑRWÕ;f[íý¤J3ÍõUú²-;m eFÈ«´RVw^t„qP2u´…šƒR±iY×{VÖ)N(‘¥9Õø*Zú3ß«X€0á&a.3¸¤cæTJÕ&-àµÕÜ‚_‰×Ç­È%õ‡1¥Ìpœ “ öÀ8äKct·Ã¢$72wânQêÍÜ„»XŒ¼9á@æhÈÙ…(Ä7 ÞÖIîcíÔÙH·pÝ›œBb…˜x}*ðXÐÔåÙ¹$Âûä1áI…M@Ä].ljÚ—&0›[¶› ¨£5‰5kÎû}Щò~|w.›äO”wÆ ,’4´Í¿¦¡ÿï}²˜ûoYö1Iý–“tÙexo%Q2g‘âýÂf}H¥ÜÙÞZ@LˆqNƒË†1‰W«Ðor­uüùûoܹ™Œþe:mÄØ~þÿ±KÔûóN¦ÉR&ÈÄq“Órü,ææŽe%;ÜÛù‰Ý(k¯ûx†®ÚN®òÂ/k´ÀDÊÏfºaÆñ&y3›4™ÆÀ•¨uã†úã™ï›7ŒˆLÐ8— M›‚»d×™µð˜˜e’Ä7s;™ Ç°^`¢´ •§>‹q¼ù!ª*çðÜÊBá=À×ÂvFÇׯŸýôÓ¿1¨÷ŽÞ$<£«½)K›3&’äô·§\ÜÍqÔXçGĈA7Óã@`·laÕ³gJ@D;ùm©fgM'ëráåÉj`£´œÕ̃@b¥M¸8¡ðƒfãt¬9Ä¿&– ²Fç{-’wFV×t U¢Ðmç†êhlÄ7Ìi[KËÞâªéìFÚ„¸ˆi‘m×íDƒÀYÔh|’Ø\²3²ÁÓ‚ ºd¢NžÕØeVÝ¿}Ï0•w$ éÎTòÈbÒ„ÆI°56UtoÑÍ:þèó¿Sõ¢IRÊÌâ)’JÔ?†…Ö\&7ö›î”Až„Ρœ¶GÏ>/@0ÓG7B# ëÑ^úÎt"2òî2ÙµÎw÷ç¯w ä±ym/É$£bÿ…´Px‚¤;6P'´þCûôcGCo['WvfÖ°Éòæ{bª£¼èA(ÊÀz»‘>êR9µ&¥à ssãÓ®odf0ºß ¦Ï[¬±¦¥‹;Aë˜L¼|WA ý™É CYß2¤Ì³RýLnÈÌÜ«Aä½å†ÆLÛ,+ä:3‚zM{8sS{#ÚÎC˜lYG3:ñ=‹£ð¥à?šœ›0e׉õkÚ­ÈF¶‹é~Ž© },±ÛS%áb’P)íšD ›žømjI­q¦Ø;³«¢60Éý6r–”ëΧR þš>%öÏûÆy:ú¨ëòÞ-Ïi8å_b? Ì'húËA¶ÆqY#Z”Áé@:EcgiЪᤳž:#v¨Ò‹±›g€ˆëÓç?þl>ßcƒk·[Y(|L9·¤aYì¿PX£L€ …Ç‚\ÑFÌDöãO¿Ç'YˆÔtÕÍ{lÝæaåÖuX¿›Ž@ºhsZÒáwÅ¢ël4Û­V½Q—–l¯á÷“Ó†9:(ÂÁ):ø‹ô!•­Æ3Ý6‘q©˜8l¼dp` ²Ü#Þ(2E<ȘÍ1SºC˜Y¿Ë©ö‰‡–ÈL-±Àè!ß13ãæ=`ÿ¦Ü=ˆâ²¬î±ê.Œ­À©ßárŠl¦L <õrNx× ‹$˜9Oe¶½UŒ*z‰À‰gš|›}@‡ÄCÁTHÝú9ÔÊG§Ò=¹û£4‹Uu7»‡ÓH›’Ï“p “µÂA{ûxcxJž¨ƒ‰¶3ËyÉÁá;r´03]â‡È¡@VkËDðRI¢Ù%Þ]2CÒH¯Vxc.Âþ;÷¬_‘¶íýìfN‘Qô“ÈD N¿¤[›ksZ&³øÇšmâŠÁu˜1XDøöµÆ jIΑÑÜãû¶šoÔ+-óZÚ=5ÁKŸ ÚîPR÷.{#¡E‹è¾€o¯Ù`Ï-7•˜†ëì5Ÿîš[úÐø!%4˜K2ÂÒ/yÃ+~ºX¸Á³ïä¿.{RÞ<Þ™=#ìf¬%M¯¢N•fb5H¥Ñ%&êÜ@Ô˜ì@pö·w¦Fý|j'æþùÏ?7 ‡0`’¼²oC±ÿB!!-‰% Ä°¢‘qbbîø´µ»Ï¿ÿôóß;ß7Úz'´÷±uU÷šÎjæ©¡NôsŽ4ßj#ØAÏ öu£8™ZÙä‘Å0îFÚ²@0B5¤A-H”ˆ³ý†§lˆ’²A.ÂèÅX©•oÄN¾ƒW •kl^ Ïj'ªŒÕñ-sÒµ»"ühòùMæÕQ#"ÂÆ[fmFÅ›¹?ºø“ˆºçœèø²Æô›]Ó¿£A<ÊòÉüiuȲY¦A%=eJÁ2Wt)«ËK7µÈ·í¤¡ûÇÌ.‰tœÄòwC­¬Š4Âû¼’ Å»îî!pBöwºù€µçhE«›Å¶`ò9Ο†<ø '$ñÔ;ä¾{@ÆøŒëâqm’8¥ö>ñ·DkÑ?ñƒ™¹w!ò=2$Š7¡$Æ àÌgæ êÏ°©µ~nm÷»ÏŸs|*Š6¦Á1¦P(ìQ>…ÂÓàK=ÜÀÀ gî?þøOPclbÐÝÐ÷@3"<‘"•Ì]‘àHq˜/>d±Ë þ¤dŒ¤(¯¨×R^ÞBcEØtˆƒ·¤¯ÜK+dOHþÙ…CIìŠ]9;[¯î×o¾ ³#ÀXJ¯f–bF>9›«1—ý±b²Ë}bO83Ÿg9Q­‹`ÂX/¬Þ#ä̵×4kÙü¦i´x*á;;<ˆñöì§bó¿mýZ™§7›çKzÁý÷Ý’úÇ ËÝ<Ý—ýra¸5Õ;ŸAæ­š¥½D`F£6»Ñk¶fSàn+åm´¤·À·û†}¿'`&ì¡«(|µœ—äܦ‡x=mÐ0ËÛ³÷ûû»/_Ú¬z0%ú €B¢‘ÿÒÄã …§`ž$¤Š»F´}Ú~øñ,ô@gâ6šŽã–yâ×k®½3¾6/û.šéÐ|ÏÚ½rÑE¸s.ù( ˆ‹!Gd }FGã¤F¸6{Yîk50î©çfzJWwyðÍqcmˆEèÙóbù6¾s¦œŸKB¤7~¦˜ÞZO›ªDW³·.Êå§ø´«Š1¹|1-D*£ðØL¼ &?p÷œrˆZÓt˜ž˜Ÿžy$­Zäj#äöw¹È Òx˜›ñ#l–îòN…‹¯‡/Æø{\¶;‡Í1B.̬wʨPxfõ±ó˜v÷[Ãö©5°œËtÓmúêkî¤òóÄ}|Raæ;iu={!òĘ/â˜Ñ/å–AƒýìL4v]C0ŽÄrÙ š&v¥éH7ÓˆB>\aâ䇳ù¹³=ST+›{FîZ€Ð`:Õåéîˆ`(V(¶•Ñù,Z}ñ0?Èž‘E=xH=bŒæ ½H!Ý 4s•iª#±Å•p±hAˤÎí•vÝK9YÉŒ·¥=[lú$/TÊ|V÷Z„ Ò\Nt”G[¼œf´ø8™ò=Q{§Âw%8Í¢q'i(wö‚€OÜ8cÙœº8ªg†4Ãß×d±p6Ð,l-È1$ætÌs7I*ÖþÒ'ù]åå$sV'²¢J]Ú’Úç¯_!‡†`ß²àÂlû/¤÷Â~N”P(< ìRwÎÎçO­Ýùüé§OÔCM]]™´W¾¼c§uí1:I&\Á &.¾Ol¸ï€¹/ó˜RcnX¬·™J%¢4 ½hÌ7Q–ƒ:Ì û*(ßbÏÎy #S¾ ÷ä–­n(>:lG!œõƒ†t„a³%41{2¹Nœ5àl5ðä}œˆK4“»JÓ0€:Ã} óFÍwkãw´³há¬úNrTj ÿ2‡ªþº»¸ëYÌÒ‰HÆ…=4 (Ó4ZRaÈ KBl⡵GŠk"E&«<¤¼ø¬Eô’êÀÓOÜÇê¦çF;´é¦¼vïëK»¿¥ÚaΌ׀¼/¥‚M~˜­¢áfÀéKØÊà¢ù­©èdñ¨$fYOuK¦ó×»ÏÄÓðL]öÀAC …J(žºŽE€—Þû©ÑùË履~NÔNçN>)«a0:$ŽÍHi)'‰aÍv%“ä‘"ñDŸ¬ä·°“áÑëüÂ}ÂRc,Îc`ì;“0οŠ7¬“„׎VÉjI¶x1¢@æ‘íå)ûzè9[ƒTÿ>L ϘË`”ìG +é‡ ÌÏÄxÉðˆûM¢`¯F6`ìÊʘєÉCÞr^ýe}Ý,Í °ÆJæ]üuï¤wš¡¾´CŽ%O›bnèßl<ä>ŸË¶ú¬-z}”Í€¡õ0 v6H¤Én¶ªó±mÚÌÑÙ.CÃÌ›qfÔ4UgìáEý§7ĵ}$€Ä÷õ?|â…¢SOO ÛÈóÔ«@<&ãÞÌ°AÛÉfµI¶ Þ¸õóù|·Ñ¦²¥^ÍÎÅþ …ÛP@¡ð¥+­iŸ íîë×O?nÌètæÞÄD,ÁDaœ8qèÓrÜŒl¬LÓý¦*þD_o¦Ýý¬aȘJüãćs|½0*ª1S—]“ ¢‹ÅÙxQ3= Ç¦ÉªF!܃æ†P= Y¨—阅‘[)£fKŸŠdݯø?úÔÐv$•ëA=€‰ÊsÜt–ñáM) º%O眱ðG§ŸÁë½XAuóX²eni1`ópwúæâ‡ñ:ÀŠäö²åæI¼Zò ³­†²= •Ùt,ƒ²k§ÆÈL‡ÙØ@eÄ%3I;Nã Ò;V~ŒrD'AGŒ¯èv‹‡jOÅ·¾B"ê/"®÷ØdÃ>¥ ok¤æžIþê9}ìX$¸Êiú’còiN›V$#ܧ‚ óùÝ•ê¢Ø5 û+ç8ôñfb€ÑÏ÷÷_ïN$/Rs —Dxß/…Bá:J(ž ¾ÛjÔ‰ôs¿¿»ßNÂj@×óž\jô;$ûr3$Há5lß;Epn½?¢ì;ˆz‚¦™ÇdEh²²ÓVßfÄ•ˆ?yJ=yâÚˆƒ²x—¨ÓV!†ì'À£ ªÖZ­„$ x&›CBWT§ÜN4—Áˆ”ä†i¥¿*Øx·’]‘¬$¤I× æ²/Â_–£üP'ç’B1Y›ÂúT3™B–ŽÍIC'wÕ½ÐĹJ©@)&ÏȽ&\øñsÚ–⎅Gùs4‹,zåP§Rù%Am!½$Î Û`ŒM3õûÕ1ŒpʱFôÒðx5éhJ}I_2÷!{a³ð5½VfÎi<×eìáÃdRc&Š< /’øÄGC皌‚†3ßÝÝIWéC>¾,‡:z …žgì|¡€Bá™ )ÂÏ ÃÙˆøþ+7â¶)±â ºÿÚ`ìÐ#¶ k-â8×ìF9'¦¨†xX÷& {›˜[WÒœðH¿ŽÀ#í¡á—A|Ué>‡òµï\aóý©Ýy¼#n˜³I,ˆݵÌé]:ìŠÄÞE j¤,v$äthuYæ°t饑%3åžAfRY¹dÀÄa¶ƒÔJþð~ ТS"…õYí¢DqŽR‘6á¡û8M£´+§F!,É+6”Kì_\í­>@„. ?#ÔÉ<sÊmú‰³v9}!»5Ê`·7tT¥±r,ÙO£'É”ÖQâU iÇa,ò˜üS²:öY=2ïѽG`U…§>Ê)É.ªHÃ?@ÞI´¸·FÓyÑ3ìR‰ÊDçfæ~fœÃYFwkÂÅàXø,>6.¼aå§ …gEZ_ÕŒ…€Î[kç/ŸiÛœt0÷ñI×F^\åCí5Zp§?ƒ~tM†FêTƒá¨¥Ñ[6…Ι’›j-§Ý‡L çôæŠþ_”9g;3°}$3¤É—IÍÛg™‡æ]ÚBRN«0áòCuµ}x!ØL­€E3¯î…¥ÜòaÒo§h͹E!'åú¡®V²êe\`ÿO¿¶J2䞺ÄðŸE’XŽíçÁ-£z˜¦öÔúFöA’ÛÍÙ>TZbÔŪ˜¡§ª%·ö¾cK(ˆ …gEÅ«A]:Î÷¦ƒ%\ãé+‹¹¥¬Ä¸§ë&uø*é ²DNÒŠËk¸p±Ž…&øˆ/Þ²úf†4Ýï{;]4õøqH'·`Zu„ÁhàC‘ýÌVÃy­¯ùoÂy‹Ç…‹·ë©CykBxfð€'Ã0` œb=I%ŠŸükw!Pãð[}=­vâwœ†Íår§ŸÓyÁÌp3wIßZ笼¨¤¥à¥mÒܤ—„ÍÕ/«1—ÇééøLÈUlRWüÆùøñµ) äV+Ѿ>!Ÿ‚1ö?^“4{-ùõ#4Þ0~pñÐ[ÔF^çE|[7IŒÉí¦>0=¼›tæ÷†þ,ö_(\Ç°ð €BáEàKbh»Ø‚ŠYvâm‰±’?{AàyU¶(ëc¢È>ã™-¥ˆ<ê—G–×'>=c¾û¸0&1Ò ßW˜7,ä½ÛÓg6e÷{š,¿&gXûˆ-Iy—BP&ÚpK¹3åy¬.î`ÙÖàô»!=N”áò0Ãäºa&w©v#Ÿaªû oîž'‹žÆpTïN-Ò÷”EqJŸS\÷//1j 2½ÊDJˆÝ»%(W&Ê“¥ο …Ç£€BáÅWT‰u­KOZX»Qù¯k9Tà;ú²S.„¥Õš®-¯<Ýæx}ùɸš ï(û¿ËêÆ^þ¶Ê™yW¿[Šz(+XÞÑi÷,9i¾eÊh:v2ʬnM‡æѨé§=M¾šÇR »Wvó8ò_¬îBi¨a¿€¹À<x*¼ez8Ú&¤Z„Ÿ5Ï?%Ñ,Mÿ‹^4ÄsÌИk¹û\ã¾eóŨ;Oý‹¡qf±ŠsŠ`ât”)æg}¦º ï^“íÛ•¢Pøh8`þM¬ÖåƒP>¦á§¸è Ôý» ®cKÅÕ@î÷³v4]'R˜rY>²(Øå„Ë÷ߘھ<™»<Wë¹<$¯#OÓËXb{Ë„½€|[¶YTX¦–9¢gJsÔlúi_6ÓäñÁ™MÞð¿\¼ÈkäîÃR–Ûwû5‰åU 7ïRZÃÅþšdÔw´räñ±,Œí;zú©h¡ðL¨€Báûa/LŽDˆ[nSuãAÖ´[kýãJ“w˜×QÁŽŠ÷Ðõûòý7¦¶l®§Ó±«õd©%{ÛýmÒÇuÁ2‘+7쬲ê›G׵ѻH™žP‹EF/1˜_Ž$¬záHZÈDß÷æŸVÍ2å>àfñ¸P(\Dí ÖЧðõBáO¤ïžHá[b¯ƒÇ®¦ž]JU—ÿåÜ™ …‡a?mJ( …Â7Á#TæÅø_?&S.Œ\coôT_c¢PxäXÌ…B¡P( 8ÒîÓ¨š_êû  …‹c1uË P( … 8âî{Ó ÿ\Fû…ÂëAÚ|¡P( …BáYPì¿PøîXãR&@…B¡P( …Â;ÅŠæ—p¡P( …B¡ðP@¡P( …B¡ðN±rÐ/ P( …B¡PxïØ9 …B¡P( …÷‹Ú( …B¡P(>j P( …B¡Pø˜( P( …B¡Pø@( P( …B¡Px¯Xø[@¡P( …B¡ðNÁ‡' …B¡P( …wþJ( …B¡P(Þ1hø( P( …B¡Px· Ú( …B¡P(>j P( …B¡PøÐ( P( …B¡Pø0 Û€Eô B¡P( …B¡ðQ;…B¡P( …ÂB …B¡P( …ÂB …B¡P( …Â{G…- …B¡P(>öa@ËÍ·P( …B¡Pø¨€B¡P( …Bá¡€B¡P( …Bá¡€B¡P( …Bá¡€B¡P( …BábåéÛ® …B¡P( …7Z\«€B¡P( …Báâh P( …B¡P(|\Ê4¨P( …B¡Pxg¨€B¡P( …Bá½báЮêùk P( …B¡PxûPaàúÀÊu¸P( …B¡P(¼9€V¿P( …B¡PxïÒ_&@…B¡P( …‚˜]Ú¨‚B¡P( …BáÝ@€Òò …B¡P( ï{¢} P( …B¡P(¼-ð±†ÿz Ú( …B¡P(ÞÈ4ü{MV( …B¡P(¼[ððÀ% …B¡P( ïÆøç* P( …B¡PxwàéC’J( …B¡P(>J( …B¡P(ÞøR˜Ï …B¡P( …÷ƒÙëw‡ …B¡P( …÷QýSí …B¡P( ´Ûà¸P@¡P( …B¡ð¾Àài ¢ …B¡P( ï»nx•N¡P( …B¡PxàñÓcL€Šý …B¡P( ¯WI{»í¶B¡P( …B¡ðêq¯à8JÐcÒ, …B¡P( ß —;×@¡P( …B¡ðž°¢öùÚƒw …B¡P( …«ÃE•~¦û Z …B¡P( …×@`V¦¿×îïw•G¡P( …B¡PøŽ0RNÐHÿø°_n+_06{7Ö‰¯d.¿ƒ–|—¸0<–¶š…# image/svg+xml prism-1.5.1/doc/images/rust.svg000066400000000000000000000062641506127434000164120ustar00rootroot00000000000000 prism-1.5.1/doc/index.css000066400000000000000000000024441506127434000152440ustar00rootroot00000000000000:root { --color-background: #1c1f26; --color-text: white; } body { background-color: var(--color-background); font-family: "Noto Sans", "Helvetica Neue", Helvetica, sans-serif; margin: 0; } header { height: 10vh; } h1 { color: var(--color-text); text-align: center; line-height: 10vh; margin: 0; } main { display: grid; grid-template-rows: 1fr 1fr; grid-template-columns: 1fr 1fr; height: 36vh; margin: 2vh 20vw; } @media only screen and (max-width: 1200px) { main { margin: 2vh 10vw; } } @media only screen and (max-width: 900px) { main { grid-template-rows: repeat(1fr); grid-template-columns: 1fr; height: 72vh; } } @media only screen and (max-width: 600px) { main { margin: 2vh 5vw; } } .reference { border-radius: 1em; box-sizing: border-box; color: var(--color-text); height: 18vh; padding: 4vh 0; text-align: center; text-decoration: none; transition: background-color 100ms ease; vertical-align: middle; } .reference > img { height: 10vh; width: 10vh; margin-right: 1em; vertical-align: middle; } .reference > h2 { display: inline; margin: 0; text-decoration: underline; } .reference:hover { background-color: rgba(255, 255, 255, 0.1); } #logo { display: block; height: 50vh; margin: 0 auto; } prism-1.5.1/doc/index.html000066400000000000000000000024211506127434000154130ustar00rootroot00000000000000 Prism

Prism Ruby parser

C

C reference

 Ruby

Ruby reference

 Rust

Rust reference

 Java

Java reference
prism-1.5.1/docs/000077500000000000000000000000001506127434000136025ustar00rootroot00000000000000prism-1.5.1/docs/build_system.md000066400000000000000000000144061506127434000166340ustar00rootroot00000000000000# Build System There are many ways to build prism, which means the build system is a bit more complicated than usual. ## Requirements * It must work to build prism for all 6 uses-cases below. * It must be possible to build prism without needing ruby/rake/etc. Because once prism is the single parser in TruffleRuby, JRuby or CRuby there won't be another Ruby parser around to parse such Ruby code. Most/every Ruby implementations want to avoid depending on another Ruby during the build process as that is very brittle. * It is desirable to compile prism with the same or very similar compiler flags for all use-cases (e.g. optimization level, warning flags, etc). Otherwise, there is the risk prism does not work correctly with those different compiler flags. The main solution for the second point seems a Makefile, otherwise many of the usages would have to duplicate the logic to build prism. ## General Design 1. Templates are generated by `templates/template.rb` 2. The `Makefile` compiles both `libprism.a` and `libprism.{so,dylib,dll}` from the `src/**/*.c` and `include/**/*.h` files 3. The `Rakefile` `:compile` task ensures the above prerequisites are done, then calls `make`, and uses `Rake::ExtensionTask` to compile the C extension (using its `extconf.rb`) This way there is minimal duplication, and each layer builds on the previous one and has its own responsibilities. The static library exports no symbols, to avoid any conflict. The shared library exports some symbols, and this is fine since there should only be one libprism shared library loaded per process (i.e., at most one version of the prism *gem* loaded in a process, only the gem uses the shared library). ## The various ways to build prism ### Building from ruby/prism repository with `bundle exec rake` `rake` calls `make` and then uses `Rake::ExtensionTask` to compile the C extension (see above). ### Building the prism gem by `gem install/bundle install` The gem contains the pre-generated templates. When installing the gem on CRuby, `extconf.rb` is used and that compiles the C extension with mkmf, including both the extension files and the sources of prism itself. When installing the gem on JRuby and TruffleRuby, no C extension is built, so instead the `extconf.rb` runs `make build/libprism.{so,dylib,dll}`. There is Ruby code using FFI which uses `libprism.{so,dylib,dll}` to implement the same methods as the C extension, but using serialization instead of many native calls/accesses (JRuby does not support C extensions, serialization is faster on TruffleRuby than the C extension). ### Building the prism gem from git, e.g. `gem "prism", github: "ruby/prism"` The same as above, except the `extconf.rb` additionally runs first: * `templates/template.rb` to generate the templates Because of course those files are not part of the git repository. ### Building prism as part of CRuby [This script](https://github.com/ruby/ruby/blob/5124f9ac7513eb590c37717337c430cb93caa151/tool/sync_default_gems.rb#L399-L422) imports prism sources in CRuby. The script generates the templates when importing. prism's `Makefile` is not used at all in CRuby. Instead, CRuby's `Makefile` is used. ### Building prism as part of TruffleRuby [This script](https://github.com/oracle/truffleruby/blob/master/tool/import-prism.sh) imports prism sources in TruffleRuby. The script generates the templates when importing. Then when `mx build` builds TruffleRuby and the `prism` mx project inside, it runs `make`. Then the `prism bindings` mx project is built, which contains the [bindings](https://github.com/oracle/truffleruby/blob/vm-24.1.1/src/main/c/yarp_bindings/src/yarp_bindings.c) and links to `libprism.a` (to avoid exporting symbols, so no conflict when installing the prism gem). ### Building prism as part of JRuby TODO, similar to TruffleRuby. ### Building prism for embedded system For instance, you can build a static library `libprism.a` targeting the Arm Cortex-M0+ embedded system by the commands below: * `templates/template.rb` * `CFLAGS="-mcpu=cortex-m0plus" make static CC=arm-none-eabi-gcc` The build process internally looks up `_POSIX_MAPPED_FILES` and `_WIN32` macros to determine whether the functions of the memory map are available on the target platform. ### Building prism with custom memory allocator If you need to use memory allocation functions implemented outside of the standard library, follow these steps: * Add `-D PRISM_XALLOCATOR` to the build options * Additionally, include `-I [path/to/custom_allocator]` where your `prism_xallocator.h` is located * Link the implementation of `prism_xallocator.c` that contains functions declared in `prism_xallocator.h` For further clarity, refer to `include/prism/defines.h`. ### Building prism from source as a C library All of the source files match `src/**/*.c` and all of the headers match `include/**/*.h`. If you want to build prism as a shared library and link against it, you should compile with: * `-fPIC -shared` - Compile as a shared library * `-DPRISM_EXPORT_SYMBOLS` - Export the symbols (by default nothing is exported) #### Flags `make` respects the `MAKEFLAGS` environment variable. As such, to speed up the build you can run: ``` MAKEFLAGS="-j10" bundle exec rake compile ``` ## Build options * `PRISM_BUILD_DEBUG` - Will cause all file reading to copy into its own allocation to allow easier tracking of reading off the end of the buffer. By default this is off. * `PRISM_BUILD_MINIMAL` - Define all of the `PRISM_EXCLUDE_*` flags at once. * `PRISM_ENCODING_EXCLUDE_FULL` - Will cause the library to exclude the full encoding API, and only include the minimal number of encodings to support parsing Ruby code without encoding comments. By default this is off. * `PRISM_EXPORT_SYMBOLS` - Will cause the shared library to export symbols. By default this is off. * `PRISM_EXCLUDE_JSON` - Will cause the library to exclude the JSON API. By default this is off. * `PRISM_EXCLUDE_PACK` - Will cause the library to exclude the pack API. By default this is off. * `PRISM_EXCLUDE_PRETTYPRINT` - Will cause the library to exclude the prettyprint API. By default this is off. * `PRISM_EXCLUDE_SERIALIZATION` - Will cause the library to exclude the serialization API. By default this is off. * `PRISM_XALLOCATOR` - Will cause the library to use the custom memory allocator. By default this is off. prism-1.5.1/docs/configuration.md000066400000000000000000000142321506127434000167750ustar00rootroot00000000000000# Configuration A lot of code in prism's repository is templated from a single configuration file, [config.yml](../config.yml). This file is used to generate the following files: * `ext/prism/api_node.c` - for defining how to build Ruby objects for the nodes out of C structs * `include/prism/ast.h` - for defining the C structs that represent the nodes * `include/prism/diagnostic.h` - for defining the diagnostics * `javascript/src/deserialize.js` - for defining how to deserialize the nodes in JavaScript * `javascript/src/nodes.js` - for defining the nodes in JavaScript * `java/org/prism/AbstractNodeVisitor.java` - for defining the visitor interface for the nodes in Java * `java/org/prism/Loader.java` - for defining how to deserialize the nodes in Java * `java/org/prism/Nodes.java` - for defining the nodes in Java * `lib/prism/compiler.rb` - for defining the compiler for the nodes in Ruby * `lib/prism/dispatcher.rb` - for defining the dispatch visitors for the nodes in Ruby * `lib/prism/dot_visitor.rb` - for defining the dot visitor for the nodes in Ruby * `lib/prism/dsl.rb` - for defining the DSL for the nodes in Ruby * `lib/prism/inspect_visitor.rb` - for defining the `#inspect` methods on nodes in Ruby * `lib/prism/mutation_compiler.rb` - for defining the mutation compiler for the nodes in Ruby * `lib/prism/node.rb` - for defining the nodes in Ruby * `lib/prism/reflection.rb` - for defining the reflection API in Ruby * `lib/prism/serialize.rb` - for defining how to deserialize the nodes in Ruby * `lib/prism/visitor.rb` - for defining the visitor interface for the nodes in Ruby * `src/diagnostic.c` - for defining how to build diagnostics * `src/node.c` - for defining how to free the nodes in C and calculate the size in memory in C * `src/prettyprint.c` - for defining how to prettyprint the nodes in C * `src/serialize.c` - for defining how to serialize the nodes in C * `src/token_type.c` - for defining the names of the token types Whenever the structure of the nodes changes, you can run `rake templates` to regenerate these files. Alternatively tasks like `rake test` should pick up on these changes automatically. Every file that is templated will include a comment at the top indicating that it was generated and that changes should be made to the template and not the generated file. `config.yml` has a couple of top level fields, which we'll describe below. ## `tokens` This is a list of tokens to be used by the lexer. It is shared here so that it can be templated out into both an enum and a function that is used for debugging that returns the name of the token. Each token is expected to have a `name` key and a `comment` key (both as strings). Optionally they can have a `value` key (an integer) which is used to represent the value in the enum. In C these tokens will be templated out with the prefix `PM_TOKEN_`. For example, if you have a `name` key with the value `PERCENT`, you can access this in C through `PM_TOKEN_PERCENT`. ## `flags` Sometimes we need to communicate more information in the tree than can be represented by the types of the nodes themselves. For example, we need to represent the flags passed to a regular expression or the type of call that a call node is performing. In these circumstances, it's helpful to reference a bitset of flags. This field is a list of flags that can be used in the nodes. Each flag is expected to have a `name` key (a string) and a `values` key (an array). Each value in the `values` key should be an object that contains both a `name` key (a string) that represents the name of the flag and a `comment` key (a string) that represents the comment for the flag. In C these flags will get templated out with a `PM_` prefix, then a snake-case version of the flag name, then the flag itself. For example, if you have a flag with the name `RegularExpressionFlags` and a value with the name `IGNORE_CASE`, you can access this in C through `PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE`. ## `nodes` Every node in the tree is defined in `config.yml`. Each node is expected to have a `name` key (a string) and a `comment` key (a string). By convention, the `comment` key uses the multi-line syntax of `: |` because the newlines will get templated into the comments of various files. Optionally, every node can define a `child_nodes` key that is an array. This array represents each part of the node that isn't communicated through the type and location of the node itself. Within the `child_nodes` key, each entry should be an object with a `name` key (a string) and a `type` key (a string). The `name` key represents the name of the child node and the `type` is used to determine how it should be represented in each language. The available values for `type` are: * `node` - A field that is a node. This is a `pm_node_t *` in C. * `node?` - A field that is a node that is optionally present. This is also a `pm_node_t *` in C, but can be `NULL`. * `node[]` - A field that is an array of nodes. This is a `pm_node_list_t` in C. * `string` - A field that is a string. For example, this is used as the name of the method in a call node, since it cannot directly reference the source string (as in `@-` or `foo=`). This is a `pm_string_t` in C. * `constant` - A field that is an integer that represents an index in the constant pool. This is a `pm_constant_id_t` in C. * `constant[]` - A field that is an array of constants. This is a `pm_constant_id_list_t` in C. * `location` - A field that is a location. This is a `pm_location_t` in C. * `location?` - A field that is a location that is optionally present. This is a `pm_location_t` in C, but if the value is not present then the `start` and `end` fields will be `NULL`. * `uint8` - A field that is an 8-bit unsigned integer. This is a `uint8_t` in C. * `uint32` - A field that is a 32-bit unsigned integer. This is a `uint32_t` in C. If the type is `node` or `node?` then the value also accepts an optional `kind` key (a string). This key is expected to match to the name of another node type within `config.yml`. This changes a couple of places where code is templated out to use the more specific struct name instead of the generic `pm_node_t`. For example, with `kind: StatementsNode` the `pm_node_t *` in C becomes a `pm_statements_node_t *`. prism-1.5.1/docs/cruby_compilation.md000066400000000000000000000071461506127434000176560ustar00rootroot00000000000000# Compiling Prism's AST One important class of consumers of Prism's AST is compilers. Currently [CRuby](https://github.com/ruby/ruby), [JRuby](https://github.com/jruby/jruby), [TruffleRuby](https://github.com/oracle/truffleruby), and [Natalie](https://github.com/natalie-lang/natalie) have all built compilation code on top of Prism's AST. This document will describe, at a high level, how CRuby's compilation of Prism's AST works. As described in the [build system documentation](build_system.md), there is a "push" Webhook set up within the Prism repo triggered on each new commit to send information about the commit to [git.ruby-lang.org](https://github.com/ruby/git.ruby-lang.org). This in turn runs [a script](https://github.com/ruby/ruby/blob/master/tool/sync_default_gems.rb) to sync over new changes in Prism to their corresponding files in Ruby. Any failures in this sync script will show alerts in the #alerts-sync channel in the RubyLang Slack. The result of this step is that files are synced from Prism into ruby/ruby for its use. It is also worth noting that [`common.mk`](https://github.com/ruby/ruby/blob/master/common.mk) contains a list of Prism files which it needs to correctly compile. If there are new Prism files added, this file should also be updated. ruby/ruby uses the Prism code to generate an AST from which it can generate instruction sequences. Compilation in ruby/ruby has three main steps: 1. Compute an AST Syncing over the Prism code allows ruby/ruby to compute the AST using Prism. It currently does this within [`iseq.c`](https://github.com/ruby/ruby/blob/master/iseq.c) using the `pm_parser_init` function. 2. Run a first pass of compilation Once the AST has been created, it is recursively descended in order to compute the appropriate instruction sequences. This is the crux of compilation, and we go into more detail about nuances in the following paragraphs. The code for this step is almost exclusively in [`prism_compile.c`](https://github.com/ruby/ruby/blob/master/prism_compile.c). The main function used for compilation is `pm_compile_node` which is essentially a huge switch statement over practically every node type which computes the appropriate instruction sequences for that node type. There are several convenience helpers, such as `PM_COMPILE`, `PM_COMPILE_POPPED`, `PM_COMPILE_NOT_POPPED` which all call into the `pm_compile_node` function. There are also several functions, like `parse_string`, `parse_integer` which consume Prism nodes and return CRuby values. These are all called for their relevant types within the big switch statement. The Prism compiler also uses a concept of "scope nodes" which are not standard Prism nodes in the AST, but instead nodes constructed within the compiler for the sole purpose of making compilation easier. Scope nodes are defined in [`prism_compile.h`](https://github.com/ruby/ruby/blob/master/prism_compile.h) and store information such as locals, local table size, local depth offset and the index lookup tables. Scope nodes can be generated for node types which have their own "scope". 3. Run an optimization pass of compilation After the instruction sequences are initially computed, there is an existing (non-Prism based) optimization pass of the instruction sequences. There are several optimizations currently inlined into step 2, however, most of them happen in this step. Specifically, any peephole optimizations happen in this step. By the end of step 2, however, the instruction sequences take the same form regardless of if the initial AST was generated by Prism or not. Therefore, step 3 is agnostic to the parser, and should not require any Prism specific code. prism-1.5.1/docs/design.md000066400000000000000000000102721506127434000153770ustar00rootroot00000000000000# Design There are three overall goals for this project: * to provide a documented and maintainable parser * to provide an error-tolerant parser suitable for use in an IDE * to provide a portable parser that can be used in projects that don't link against CRuby The design of the parser is based around these main goals. ## Structure The first piece to understand about the parser is the design of its syntax tree. This is documented in `config.yml`. Every token and node is defined in that file, along with comments about where they are found in what kinds of syntax. This file is used to template out a lot of different files, all found in the `templates` directory. The `templates/template.rb` script performs the templating and outputs all files matching the directory structure found in the templates directory. The templated files contain all of the code required to allocate and initialize nodes, pretty print nodes, and serialize nodes. This means for the most part, you will only need to then hook up the parser to call the templated functions to create the nodes in the correct position. That means editing the parser itself, which is housed in `prism.c`. ## Pratt parsing In order to provide the best possible error tolerance, the parser is hand-written. It is structured using Pratt parsing, a technique developed by Vaughan Pratt back in the 1970s. Below are a bunch of links to articles and papers that explain Pratt parsing in more detail. * https://web.archive.org/web/20151223215421/http://hall.org.ua/halls/wizzard/pdf/Vaughan.Pratt.TDOP.pdf * https://tdop.github.io/ * https://journal.stuffwithstuff.com/2011/03/19/pratt-parsers-expression-parsing-made-easy/ * https://matklad.github.io/2020/04/13/simple-but-powerful-pratt-parsing.html * https://chidiwilliams.com/post/on-recursive-descent-and-pratt-parsing/ You can find most of the functions that correspond to constructs in the Pratt parsing algorithm in `prism.c`. As a couple of examples: * `parse` corresponds to the `parse_expression` function * `nud` (null denotation) corresponds to the `parse_expression_prefix` function * `led` (left denotation) corresponds to the `parse_expression_infix` function * `lbp` (left binding power) corresponds to accessing the `left` field of an element in the `binding_powers` array * `rbp` (right binding power) corresponds to accessing the `right` field of an element in the `binding_powers` array ## Portability In order to enable using this parser in other projects, the parser is written in C99, and uses only the standard library. This means it can be embedded in most any other project without having to link against CRuby. It can be used directly through its C API to access individual fields, or it can used to parse a syntax tree and then serialize it to a single blob. For more information on serialization, see the [docs/serialization.md](serialization.md) file. ## Error tolerance The design of the error tolerance of this parser is still very much in flux. We are experimenting with various approaches as the parser is being developed to try to determine the best approach. Below are a bunch of links to articles and papers that explain error tolerance in more detail, as well as document some of the approaches that we're evaluating. * https://tratt.net/laurie/blog/2020/automatic_syntax_error_recovery.html * https://diekmann.uk/diekmann_phd.pdf * https://eelcovisser.org/publications/2012/JongeKVS12.pdf * https://www.antlr.org/papers/allstar-techreport.pdf * https://github.com/microsoft/tolerant-php-parser/blob/main/docs/HowItWorks.md Currently, there are a couple of mechanisms for error tolerance that are in place: * If the parser expects a token in a particular position (for example the `in` keyword in a for loop or the `{` after `BEGIN` or `END`) then it will insert a missing token if one can't be found and continue parsing. * If the parser expects an expression in a particular position but encounters a token that can't be used as that expression, it checks up the stack to see if that token would close out a parent node. If so, it will close out all of its parent nodes using missing nodes wherever necessary and continue parsing. * If the parser cannot understand a token in any capacity, it will skip past the token. prism-1.5.1/docs/encoding.md000066400000000000000000000070361506127434000157200ustar00rootroot00000000000000# Encoding When parsing a Ruby file, there are times when the parser must parse identifiers. Identifiers are names of variables, methods, classes, etc. To determine the start of an identifier, the parser must be able to tell if the subsequent bytes form an alphabetic character. To determine the rest of the identifier, the parser must look forward through all alphanumeric characters. Determining if a set of bytes comprise an alphabetic or alphanumeric character is encoding-dependent. By default, the parser assumes that all source files are encoded UTF-8. If the file is not encoded in UTF-8, it must be encoded using an encoding that is "ASCII compatible" (i.e., all of the codepoints below 128 match the corresponding codepoints in ASCII and the minimum number of bytes required to represent a codepoint is 1 byte). If the file is not encoded in UTF-8, the user must specify the encoding in a "magic" comment at the top of the file. The comment looks like: ```ruby # encoding: iso-8859-9 ``` The key of the comment can be either "encoding" or "coding". The value of the comment must be a string that is a valid encoding name. The encodings that prism supports by default are: * `ASCII-8BIT` * `Big5` * `Big5-HKSCS` * `Big5-UAO` * `CESU-8` * `CP51932` * `CP850` * `CP852` * `CP855` * `CP949` * `CP950` * `CP951` * `Emacs-Mule` * `EUC-JP` * `eucJP-ms` * `EUC-JIS-2004` * `EUC-KR` * `EUC-TW` * `GB12345` * `GB18030` * `GB1988` * `GB2312` * `GBK` * `IBM437` * `IBM720` * `IBM737` * `IBM775` * `IBM852` * `IBM855` * `IBM857` * `IBM860` * `IBM861` * `IBM862` * `IBM863` * `IBM864` * `IBM865` * `IBM866` * `IBM869` * `ISO-8859-1` * `ISO-8859-2` * `ISO-8859-3` * `ISO-8859-4` * `ISO-8859-5` * `ISO-8859-6` * `ISO-8859-7` * `ISO-8859-8` * `ISO-8859-9` * `ISO-8859-10` * `ISO-8859-11` * `ISO-8859-13` * `ISO-8859-14` * `ISO-8859-15` * `ISO-8859-16` * `KOI8-R` * `KOI8-U` * `macCentEuro` * `macCroatian` * `macCyrillic` * `macGreek` * `macIceland` * `MacJapanese` * `macRoman` * `macRomania` * `macThai` * `macTurkish` * `macUkraine` * `Shift_JIS` * `SJIS-DoCoMo` * `SJIS-KDDI` * `SJIS-SoftBank` * `stateless-ISO-2022-JP` * `stateless-ISO-2022-JP-KDDI` * `TIS-620` * `US-ASCII` * `UTF-8` * `UTF8-MAC` * `UTF8-DoCoMo` * `UTF8-KDDI` * `UTF8-SoftBank` * `Windows-1250` * `Windows-1251` * `Windows-1252` * `Windows-1253` * `Windows-1254` * `Windows-1255` * `Windows-1256` * `Windows-1257` * `Windows-1258` * `Windows-31J` * `Windows-874` For each of these encodings, prism provides functions for checking if the subsequent bytes can be interpreted as a character, and then if that character is alphabetic, alphanumeric, or uppercase. ## Getting notified when the encoding changes You may want to get notified when the encoding changes based on the result of parsing an encoding comment. We use this internally for our `lex` function in order to provide the correct encodings for the tokens that are returned. For that you can register a callback with `pm_parser_register_encoding_changed_callback`. The callback will be called with a pointer to the parser. The encoding can be accessed through `parser->encoding`. ```c // When the encoding that is being used to parse the source is changed by prism, // we provide the ability here to call out to a user-defined function. typedef void (*pm_encoding_changed_callback_t)(pm_parser_t *parser); // Register a callback that will be called whenever prism changes the encoding // it is using to parse based on the magic comment. PRISM_EXPORTED_FUNCTION void pm_parser_register_encoding_changed_callback(pm_parser_t *parser, pm_encoding_changed_callback_t callback); ``` prism-1.5.1/docs/fuzzing.md000066400000000000000000000057311506127434000156260ustar00rootroot00000000000000# Fuzzing We use fuzzing to test the various entrypoints to the library. The fuzzer we use is [AFL++](https://aflplus.plus). All files related to fuzzing live within the `fuzz` directory, which has the following structure: ``` fuzz ├── corpus │   ├── parse fuzzing corpus for parsing (a symlink to our fixtures) │   └── regexp fuzzing corpus for regexp ├── dict a AFL++ dictionary containing various tokens ├── docker │   └── Dockerfile for building a container with the fuzzer toolchain ├── fuzz.c generic entrypoint for fuzzing ├── heisenbug.c entrypoint for reproducing a crash or hang ├── parse.c fuzz handler for parsing ├── parse.sh script to run parsing fuzzer ├── regexp.c fuzz handler for regular expression parsing ├── regexp.sh script to run regexp fuzzer └── tools    ├── backtrace.sh generates backtrace files for a crash directory    └── minimize.sh generates minimized crash or hang files ``` ## Usage There are currently three fuzzing targets - `pm_serialize_parse` (parse) - `pm_regexp_parse` (regexp) Respectively, fuzzing can be performed with ``` make fuzz-run-parse make fuzz-run-regexp ``` To end a fuzzing job, interrupt with CTRL+C. To enter a container with the fuzzing toolchain and debug utilities, run ``` make fuzz-debug ``` # Out-of-bounds reads Currently, encoding functionality implementing the `pm_encoding_t` interface can read outside of inputs. For the time being, ASAN instrumentation is disabled for functions from src/enc. See `fuzz/asan.ignore`. To disable ASAN read instrumentation globally, use the `FUZZ_FLAGS` environment variable e.g. ``` FUZZ_FLAGS="-mllvm -asan-instrument-reads=false" make fuzz-run-parse ``` Note, that this may make reproducing bugs difficult as they may depend on memory outside of the input buffer. In that case, try ``` make fuzz-debug # enter the docker container with build tools make build/fuzz.heisenbug.parse # or .regexp ./build/fuzz.heisenbug.parse path-to-problem-input ``` # Triaging Crashes and Hangs Triaging crashes and hangs is easier when the inputs are as short as possible. In the fuzz container, an entire crash or hang directory can be minimized using ``` ./fuzz/tools/minimize.sh ``` e.g. ``` ./fuzz/tools/minimize.sh fuzz/output/parse/default/crashes ``` This may take a long time. In the crash/hang directory, for each input file there will appear a minimized version with the extension `.min` appended. Backtraces for crashes (not hangs) can be generated en masse with ``` ./fuzz/tools/backtrace.sh ``` Files with basename equal to the input file name with extension `.bt` will be created e.g. ``` id:000000,sig:06,src:000006+000190,time:8480,execs:18929,op:splice,rep:4 id:000000,sig:06,src:000006+000190,time:8480,execs:18929,op:splice,rep:4.bt ``` prism-1.5.1/docs/heredocs.md000066400000000000000000000063611506127434000157260ustar00rootroot00000000000000# Heredocs Heredocs are one of the most complicated pieces of this parser. There are many different forms, there can be multiple open at the same time, and they can be nested. In order to support parsing them, we keep track of a lot of metadata. Below is a basic overview of how it works. ## 1. Lexing the identifier When a heredoc identifier is encountered in the regular process of lexing, we push the `PM_LEX_HEREDOC` mode onto the stack with the following metadata: * `ident_start`: A pointer to the start of the identifier for the heredoc. We need this to match against the end of the heredoc. * `ident_length`: The length of the identifier for the heredoc. We also need this to match. * `next_start`: A pointer to the place in source that the parser should resume lexing once it has completed this heredoc. We also set the special `parser.next_start` field which is a pointer to the place in the source where we should start lexing the next token. This is set to the pointer of the character immediately following the next newline. Note that if the `parser.heredoc_end` field is already set, then it means we have already encountered a heredoc on this line. In that case the `parser.next_start` field will be set to the `parser.heredoc_end` field. This is because we want to skip past the previous heredocs on this line and instead lex the body of this heredoc. ## 2. Lexing the body The next time the lexer is asked for a token, it will be in the `PM_LEX_HEREDOC` mode. In this mode we are lexing the body of the heredoc. It will start by checking if the `next_start` field is set. If it is, then this is the first token within the body of the heredoc so we'll start lexing from there. Otherwise we'll start lexing from the end of the previous token. Lexing these fields is extremely similar to lexing an interpolated string. The only difference is that we also do an additional check at the beginning of each line to check if we have hit the terminator. ## 3. Lexing the terminator On every newline within the body of a heredoc, we check to see if it matches the terminator followed by a newline or a carriage return and a newline. If it does, then we pop the lex mode off the stack and set a couple of fields on the parser: * `next_start`: This is set to the value that we previously stored on the heredoc to indicate where the lexer should resume lexing when it is done with this heredoc. * `heredoc_end`: This is set to the end of the heredoc. When a newline character is found, this indicates that the lexer should skip past to this next point. ## 4. Lexing the rest of the line Once the heredoc has been lexed, the lexer will resume lexing from the `next_start` field. Lexing will continue until the next newline character. When the next newline character is found, it will check to see if the `heredoc_end` field is set. If it is it will skip to that point, unset the field, and continue lexing. ## Compatibility with Ripper The order in which tokens are emitted is different from that of Ripper. Ripper emits each token in the file in the order in which it appears. prism instead will emit the tokens that makes the most sense for the lexer, using the process described above. Therefore to line things up, `Prism.lex_compat` will shuffle the tokens around to match Ripper's output. prism-1.5.1/docs/javascript.md000066400000000000000000000057701506127434000163030ustar00rootroot00000000000000# JavaScript Prism provides bindings to JavaScript out of the box. ## Node To use the package from node, install the `@ruby/prism` dependency: ```sh npm install @ruby/prism ``` Then import the package: ```js import { loadPrism } from "@ruby/prism"; ``` Then call the load function to get a parse function: ```js const parse = await loadPrism(); ``` ## Browser To use the package from the browser, you will need to do some additional work. The [javascript/example.html](../javascript/example.html) file shows an example of running Prism in the browser. You will need to instantiate the WebAssembly module yourself and then pass it to the `parsePrism` function. First, get a shim for WASI since not all browsers support it yet. ```js import { WASI } from "https://unpkg.com/@bjorn3/browser_wasi_shim@latest/dist/index.js"; ``` Next, import the `parsePrism` function from `@ruby/prism`, either through a CDN or by bundling it with your application. ```js import { parsePrism } from "https://unpkg.com/@ruby/prism@latest/src/parsePrism.js"; ``` Next, fetch and instantiate the WebAssembly module. You can access it through a CDN or by bundling it with your application. ```js const wasm = await WebAssembly.compileStreaming(fetch("https://unpkg.com/@ruby/prism@latest/src/prism.wasm")); ``` Next, instantiate the module and initialize WASI. ```js const wasi = new WASI([], [], []); const instance = await WebAssembly.instantiate(wasm, { wasi_snapshot_preview1: wasi.wasiImport }); wasi.initialize(instance); ``` Finally, you can create a function that will parse a string of Ruby code. ```js function parse(source) { return parsePrism(instance.exports, source); } ``` ## API Now that we have access to a `parse` function, we can use it to parse Ruby code: ```js const parseResult = parse("1 + 2"); ``` A ParseResult object is very similar to the Prism::ParseResult object from Ruby. It has the same properties: `value`, `comments`, `magicComments`, `errors`, and `warnings`. Here we can serialize the AST to JSON. ```js console.log(JSON.stringify(parseResult.value, null, 2)); ``` ## Visitors Prism allows you to traverse the AST of parsed Ruby code using visitors. Here's an example of a custom `FooCalls` visitor: ```js import { loadPrism, Visitor } from "@ruby/prism" const parse = await loadPrism(); const parseResult = parse("foo()"); class FooCalls extends Visitor { visitCallNode(node) { if (node.name === "foo") { // Do something with the node } // Call super so that the visitor continues walking the tree super.visitCallNode(node); } } const fooVisitor = new FooCalls(); parseResult.value.accept(fooVisitor); ``` ## Building To build the WASM package yourself, first obtain a copy of `wasi-sdk`. You can retrieve this here: . Next, run: ```sh make wasm WASI_SDK_PATH=path/to/wasi-sdk ``` This will generate `javascript/src/prism.wasm`. From there, you can run the tests to verify everything was generated correctly. ```sh cd javascript node test ``` prism-1.5.1/docs/local_variable_depth.md000066400000000000000000000227661506127434000202640ustar00rootroot00000000000000# Local variable depth One feature of Prism is that it resolves local variables as it parses. It's necessary to do this because of ambiguities in the grammar. For example, consider the following code: ```ruby foo / bar#/ ``` If `foo` is a local variable, this is a call to `/` with `bar` as an argument, followed by a comment. If it's not a local variable, this is a method call to `foo` with a regular expression argument. "Depth" refers to the number of visible scopes that Prism has to go up to find the declaration of a local variable. Note that this follows the same scoping rules as Ruby, so a local variable is only visible in the scope it is declared in and in blocks nested in that scope. The rules for calculating the depth are very important to understand because they may differ from individual Ruby implementations since they are not specified by the language. Prism uses the minimum number of scopes, i.e., it only creates scopes when necessary semantically, in other words when there must be distinct scopes (which can be observed through `binding.local_variables`). That are no "transparent/invisible" scopes in Prism. Some Ruby implementations use those for some language constructs and need to adjust by maintaining a depth offset. Below are the places where a local variable can be written/targeted, along with how the depth is calculated at that point. ## General In the course of general Ruby code when reading a local variable, the depth is equal to the number of scopes to go up to find the declaration of that variable. For example: ```ruby foo = 1 bar = 2 baz = 3 foo # depth 0 tap { bar } # depth 1 tap { tap { baz } } # depth 2 ``` This also includes writing to a local variable, which could be writing to a local variable that is already declared. For example: ```ruby foo = 1 bar = 2 foo = 3 # depth 0 tap { bar = 4 } # depth 1 ``` This includes multiple assignment, where the same principle applies. For example: ```ruby foo = 1 bar = 2 foo, bar = 3, 4 # depth 0 tap { foo, bar = 5, 6 } # depth 1 ``` ## `for` loops `for` loops in Ruby break down to calls to `.each` with a block. However in that case local variable reads and writes within the block will be in the same scope as the scope surrounding the `for` and not in a deeper/separate scope (surprising, but this is Ruby semantics). For example: ```ruby foo = 1 for e in baz foo # depth 0 bar = 2 # depth 0 end p bar # depth 0, prints 2 ``` The local variable(s) used for the index of the `for` are also at the same depth (as variables inside and outside the `for`): ```ruby for e in [1, 2] # depth 0 e # depth 0 end p e # depth 0, prints 2 ``` ## Pattern matching captures You can target a local variable in a pattern matching expression using capture syntax. Using this syntax, you can target local variables in the current scope or in visible parent scopes. For example: ```ruby 42 => bar # depth 0 ``` The example above writes to a local variable in the current scope. If the variable is already declared in a higher visible scope, it will be written to that scope instead. For example: ```ruby foo = 1 tap { 42 => foo } # depth 1 ``` ## Named capture groups You can target local variables through named capture groups in regular expressions if they are used on the left-hand side of a `=~` operator. For example: ```ruby /(?\d+)/ =~ "42" # depth 0 ``` This will write to a `foo` local variable. If the variable is already declared in a higher visible scope, it will be written to that scope instead. For example: ```ruby foo = 1 tap { /(?\d+)/ =~ "42" } # depth 1 ``` ## "interpolated once" regular expressions Regular expressions that interpolate local variables (unrelated to capture group local variables) and have the `o` flag will only interpolate the local variables once for the runtime of the program. In CRuby, this is implemented by compiling the regular expression within a nested instruction sequence, which means CRuby thinks the depth is one more than prism does. For example: ``` $ ruby --dump=insns -e 'foo = 1; /#{foo}/o' == disasm: #@-e:1 (1,0)-(1,18)> (catch: false) local table (size: 1, argc: 0 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1]) [ 1] foo@0 0000 putobject_INT2FIX_1_ ( 1)[Li] 0001 setlocal_WC_0 foo@0 0003 once block in
, 0006 leave == disasm: #@-e:1 (1,9)-(1,18)> (catch: false) 0000 putobject "" ( 1) 0002 getlocal_WC_1 foo@0 0004 dup 0005 objtostring 0007 anytostring 0008 toregexp 0, 2 0011 leave ``` In this case CRuby fetches the local variable with `getlocal_WC_1` as the second instruction to the "once" instruction sequence. When compiling CRuby, prism therefore will adjust the depth to account for this difference. ## `rescue` clauses In CRuby, `rescue` clauses are implemented as their own instruction sequence, and therefore CRuby thinks the depth is one more than prism does. For example: ``` $ ruby --dump=insns -e 'begin; foo = 1; rescue; foo; end' == disasm: #@-e:1 (1,0)-(1,32)> (catch: true) == catch table | catch type: rescue st: 0000 ed: 0004 sp: 0000 cont: 0005 | == disasm: #@-e:1 (1,16)-(1,28)> (catch: true) | local table (size: 1, argc: 0 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1]) | [ 1] $!@0 | 0000 getlocal_WC_0 $!@0 ( 1) | 0002 putobject StandardError | 0004 checkmatch 3 | 0006 branchunless 11 | 0008 getlocal_WC_1 foo@0[Li] | 0010 leave | 0011 getlocal_WC_0 $!@0 | 0013 throw 0 | catch type: retry st: 0004 ed: 0005 sp: 0000 cont: 0000 |------------------------------------------------------------------------ local table (size: 1, argc: 0 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1]) [ 1] foo@0 0000 putobject_INT2FIX_1_ ( 1)[Li] 0001 dup 0002 setlocal_WC_0 foo@0 0004 nop 0005 leave ``` In the catch table, CRuby is reading the `foo` local variable using `getlocal_WC_1` as the fifth instruction to the "rescue" instruction sequence. When compiling CRuby, prism therefore will adjust the depth to account for this difference. Note that this includes the error reference, which can target local variables, as in: ``` $ ruby --dump=insns -e 'foo = 1; begin; rescue => foo; end' == disasm: #@-e:1 (1,0)-(1,34)> (catch: true) == catch table | catch type: rescue st: 0003 ed: 0004 sp: 0000 cont: 0005 | == disasm: #@-e:1 (1,16)-(1,30)> (catch: true) | local table (size: 1, argc: 0 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1]) | [ 1] $!@0 | 0000 getlocal_WC_0 $!@0 ( 1) | 0002 putobject StandardError | 0004 checkmatch 3 | 0006 branchunless 14 | 0008 getlocal_WC_0 $!@0 | 0010 setlocal_WC_1 foo@0 | 0012 putnil | 0013 leave | 0014 getlocal_WC_0 $!@0 | 0016 throw 0 | catch type: retry st: 0004 ed: 0005 sp: 0000 cont: 0003 |------------------------------------------------------------------------ local table (size: 1, argc: 0 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1]) [ 1] foo@0 0000 putobject_INT2FIX_1_ ( 1)[Li] 0001 setlocal_WC_0 foo@0 0003 putnil 0004 nop 0005 leave ``` Note that CRuby is writing to the `foo` local variable using the `setlocal_WC_1` instruction as the sixth instruction to the "rescue" instruction sequence. When compiling CRuby, prism therefore will adjust the depth to account for this difference. ## Post execution blocks The `END {}` syntax allows executing code when the program exits. In CRuby, this is implemented as two nested instruction sequences. CRuby therefore thinks the depth is two more than prism does. For example: ``` $ ruby --dump=insns -e 'foo = 1; END { foo }' == disasm: #@-e:1 (1,0)-(1,20)> (catch: false) local table (size: 1, argc: 0 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1]) [ 1] foo@0 0000 putobject_INT2FIX_1_ ( 1)[Li] 0001 setlocal_WC_0 foo@0 0003 once block in
, 0006 leave == disasm: #@-e:0 (0,0)-(-1,-1)> (catch: false) 0000 putspecialobject 1 ( 1) 0002 send , block in
0005 leave == disasm: #@-e:1 (1,9)-(1,20)> (catch: false) 0000 getlocal foo@0, 2 ( 1)[LiBc] 0003 leave [Br] ``` In the instruction sequence corresponding to the code that gets executed inside the `END` block, CRuby is reading the `foo` local variable using `getlocal` as the second instruction to the `"block in
"` instruction sequence. When compiling CRuby, prism therefore will adjust the depth to account for this difference. prism-1.5.1/docs/mapping.md000066400000000000000000000112531506127434000155610ustar00rootroot00000000000000# Mapping When considering the previous CRuby parser versus prism, this document should be helpful to understand how various concepts are mapped. ## Nodes The following table shows how the various CRuby nodes are mapped to prism nodes. | CRuby | prism | | --- | --- | | `NODE_SCOPE` | | | `NODE_BLOCK` | | | `NODE_IF` | `PM_IF_NODE` | | `NODE_UNLESS` | `PM_UNLESS_NODE` | | `NODE_CASE` | `PM_CASE_NODE` | | `NODE_CASE2` | `PM_CASE_NODE` (with a null predicate) | | `NODE_CASE3` | | | `NODE_WHEN` | `PM_WHEN_NODE` | | `NODE_IN` | `PM_IN_NODE` | | `NODE_WHILE` | `PM_WHILE_NODE` | | `NODE_UNTIL` | `PM_UNTIL_NODE` | | `NODE_ITER` | `PM_CALL_NODE` (with a non-null block) | | `NODE_FOR` | `PM_FOR_NODE` | | `NODE_FOR_MASGN` | `PM_FOR_NODE` (with a multi-write node as the index) | | `NODE_BREAK` | `PM_BREAK_NODE` | | `NODE_NEXT` | `PM_NEXT_NODE` | | `NODE_REDO` | `PM_REDO_NODE` | | `NODE_RETRY` | `PM_RETRY_NODE` | | `NODE_BEGIN` | `PM_BEGIN_NODE` | | `NODE_RESCUE` | `PM_RESCUE_NODE` | | `NODE_RESBODY` | | | `NODE_ENSURE` | `PM_ENSURE_NODE` | | `NODE_AND` | `PM_AND_NODE` | | `NODE_OR` | `PM_OR_NODE` | | `NODE_MASGN` | `PM_MULTI_WRITE_NODE` | | `NODE_LASGN` | `PM_LOCAL_VARIABLE_WRITE_NODE` | | `NODE_DASGN` | `PM_LOCAL_VARIABLE_WRITE_NODE` | | `NODE_GASGN` | `PM_GLOBAL_VARIABLE_WRITE_NODE` | | `NODE_IASGN` | `PM_INSTANCE_VARIABLE_WRITE_NODE` | | `NODE_CDECL` | `PM_CONSTANT_PATH_WRITE_NODE` | | `NODE_CVASGN` | `PM_CLASS_VARIABLE_WRITE_NODE` | | `NODE_OP_ASGN1` | | | `NODE_OP_ASGN2` | | | `NODE_OP_ASGN_AND` | `PM_OPERATOR_AND_ASSIGNMENT_NODE` | | `NODE_OP_ASGN_OR` | `PM_OPERATOR_OR_ASSIGNMENT_NODE` | | `NODE_OP_CDECL` | | | `NODE_CALL` | `PM_CALL_NODE` | | `NODE_OPCALL` | `PM_CALL_NODE` (with an operator as the method) | | `NODE_FCALL` | `PM_CALL_NODE` (with a null receiver and parentheses) | | `NODE_VCALL` | `PM_CALL_NODE` (with a null receiver and parentheses or arguments) | | `NODE_QCALL` | `PM_CALL_NODE` (with a &. operator) | | `NODE_SUPER` | `PM_SUPER_NODE` | | `NODE_ZSUPER` | `PM_FORWARDING_SUPER_NODE` | | `NODE_LIST` | `PM_ARRAY_NODE` | | `NODE_ZLIST` | `PM_ARRAY_NODE` (with no child elements) | | `NODE_VALUES` | `PM_ARGUMENTS_NODE` | | `NODE_HASH` | `PM_HASH_NODE` | | `NODE_RETURN` | `PM_RETURN_NODE` | | `NODE_YIELD` | `PM_YIELD_NODE` | | `NODE_LVAR` | `PM_LOCAL_VARIABLE_READ_NODE` | | `NODE_DVAR` | `PM_LOCAL_VARIABLE_READ_NODE` | | `NODE_GVAR` | `PM_GLOBAL_VARIABLE_READ_NODE` | | `NODE_IVAR` | `PM_INSTANCE_VARIABLE_READ_NODE` | | `NODE_CONST` | `PM_CONSTANT_PATH_READ_NODE` | | `NODE_CVAR` | `PM_CLASS_VARIABLE_READ_NODE` | | `NODE_NTH_REF` | `PM_NUMBERED_REFERENCE_READ_NODE` | | `NODE_BACK_REF` | `PM_BACK_REFERENCE_READ_NODE` | | `NODE_MATCH` | | | `NODE_MATCH2` | `PM_CALL_NODE` (with regular expression as receiver) | | `NODE_MATCH3` | `PM_CALL_NODE` (with regular expression as only argument) | | `NODE_LIT` | | | `NODE_STR` | `PM_STRING_NODE` | | `NODE_DSTR` | `PM_INTERPOLATED_STRING_NODE` | | `NODE_XSTR` | `PM_X_STRING_NODE` | | `NODE_DXSTR` | `PM_INTERPOLATED_X_STRING_NODE` | | `NODE_EVSTR` | `PM_STRING_INTERPOLATED_NODE` | | `NODE_DREGX` | `PM_INTERPOLATED_REGULAR_EXPRESSION_NODE` | | `NODE_ONCE` | | | `NODE_ARGS` | `PM_PARAMETERS_NODE` | | `NODE_ARGS_AUX` | | | `NODE_OPT_ARG` | `PM_OPTIONAL_PARAMETER_NODE` | | `NODE_KW_ARG` | `PM_KEYWORD_PARAMETER_NODE` | | `NODE_POSTARG` | `PM_REQUIRED_PARAMETER_NODE` | | `NODE_ARGSCAT` | | | `NODE_ARGSPUSH` | | | `NODE_SPLAT` | `PM_SPLAT_NODE` | | `NODE_BLOCK_PASS` | `PM_BLOCK_ARGUMENT_NODE` | | `NODE_DEFN` | `PM_DEF_NODE` (with a null receiver) | | `NODE_DEFS` | `PM_DEF_NODE` (with a non-null receiver) | | `NODE_ALIAS` | `PM_ALIAS_NODE` | | `NODE_VALIAS` | `PM_ALIAS_NODE` (with a global variable first argument) | | `NODE_UNDEF` | `PM_UNDEF_NODE` | | `NODE_CLASS` | `PM_CLASS_NODE` | | `NODE_MODULE` | `PM_MODULE_NODE` | | `NODE_SCLASS` | `PM_S_CLASS_NODE` | | `NODE_COLON2` | `PM_CONSTANT_PATH_NODE` | | `NODE_COLON3` | `PM_CONSTANT_PATH_NODE` (with a null receiver) | | `NODE_DOT2` | `PM_RANGE_NODE` (with a .. operator) | | `NODE_DOT3` | `PM_RANGE_NODE` (with a ... operator) | | `NODE_FLIP2` | `PM_RANGE_NODE` (with a .. operator) | | `NODE_FLIP3` | `PM_RANGE_NODE` (with a ... operator) | | `NODE_SELF` | `PM_SELF_NODE` | | `NODE_NIL` | `PM_NIL_NODE` | | `NODE_TRUE` | `PM_TRUE_NODE` | | `NODE_FALSE` | `PM_FALSE_NODE` | | `NODE_ERRINFO` | | | `NODE_DEFINED` | `PM_DEFINED_NODE` | | `NODE_POSTEXE` | `PM_POST_EXECUTION_NODE` | | `NODE_DSYM` | `PM_INTERPOLATED_SYMBOL_NODE` | | `NODE_ATTRASGN` | `PM_CALL_NODE` (with a message that ends with =) | | `NODE_LAMBDA` | `PM_LAMBDA_NODE` | | `NODE_ARYPTN` | `PM_ARRAY_PATTERN_NODE` | | `NODE_HSHPTN` | `PM_HASH_PATTERN_NODE` | | `NODE_FNDPTN` | `PM_FIND_PATTERN_NODE` | | `NODE_ERROR` | `PM_MISSING_NODE` | | `NODE_LAST` | | ``` prism-1.5.1/docs/parser_translation.md000066400000000000000000000024301506127434000200350ustar00rootroot00000000000000# parser translation Prism ships with the ability to translate its syntax tree into the syntax tree used by the [whitequark/parser](https://github.com/whitequark/parser) gem. This allows you to use tools built on top of the `parser` gem with the `prism` parser. ## Usage The `parser` gem provides multiple parsers to support different versions of the Ruby grammar. This includes all of the Ruby versions going back to 1.8, as well as third-party parsers like MacRuby and RubyMotion. The `prism` gem provides another parser that uses the `prism` parser to build the syntax tree. You can use the `prism` parser like you would any other. After requiring `prism`, you should be able to call any of the regular `Parser::Base` APIs that you would normally use. ```ruby require "prism" # Same as `Parser::Ruby34` Prism::Translation::Parser34.parse_file("path/to/file.rb") # Same as `Parser::CurrentRuby` Prism::Translation::ParserCurrent.parse("puts 'Hello World!'") ``` All the parsers are autoloaded, so you don't have to worry about requiring them yourself. If you also need to parse Ruby versions below 3.3 (which `prism` has no support for), check out [this guide](https://github.com/whitequark/parser/blob/master/doc/PRISM_TRANSLATION.md) from the `parser` gem on how to use both in conjunction. prism-1.5.1/docs/parsing_rules.md000066400000000000000000000027021506127434000170020ustar00rootroot00000000000000# Rules This document contains information related to the rules of the parser for Ruby source code. As an example, in the documentation of many of the fields of nodes, it's mentioned that a field follows the lexing rules for `identifier` or `constant`. This document describes what those rules are. ## Constants Constants in Ruby begin with an upper-case letter. This is followed by any number of underscores, alphanumeric, or non-ASCII characters. The definition of "alphanumeric" and "upper-case letter" are encoding-dependent. ## Non-void expression Most expressions in CRuby are non-void. This means the expression they represent resolves to a value. For example, `1 + 2` is a non-void expression, because it resolves to a method call. Even things like `class Foo; end` is a non-void expression, because it returns the last evaluated expression in the body of the class (or `nil`). Certain nodes, however, are void expressions, and cannot be combined to form larger expressions. * `BEGIN {}`, `END {}`, `alias foo bar`, and `undef foo` can only be at a statement position. * The "jumps": `return`, `break`, `next`, `redo`, `retry` are void expressions. * `value => pattern` is also considered a void expression. ## Identifiers Identifiers in Ruby begin with an underscore or lower-case letter. This is followed by any number of underscores, alphanumeric, or non-ASCII characters. The definition of "alphanumeric" and "lower-case letter" are encoding-dependent. prism-1.5.1/docs/releasing.md000066400000000000000000000077621506127434000161110ustar00rootroot00000000000000# Releasing To release a new version of Prism, perform the following steps: ## Preparation * Update the `CHANGELOG.md` file. * Add a new section for the new version at the top of the file. * Fill in the relevant changes — it may be easiest to click the link for the `Unreleased` heading to find the commits. * Update the links at the bottom of the file. * Update the version numbers in the various files that reference them: ```sh export PRISM_MAJOR="x" export PRISM_MINOR="y" export PRISM_PATCH="z" export PRISM_VERSION="$PRISM_MAJOR.$PRISM_MINOR.$PRISM_PATCH" ruby -pi -e 'gsub(/spec\.version = ".+?"/, %Q{spec.version = "#{ENV["PRISM_VERSION"]}"})' prism.gemspec ruby -pi -e 'gsub(/EXPECTED_PRISM_VERSION ".+?"/, %Q{EXPECTED_PRISM_VERSION "#{ENV["PRISM_VERSION"]}"})' ext/prism/extension.h ruby -pi -e 'gsub(/PRISM_VERSION_MAJOR \d+/, %Q{PRISM_VERSION_MAJOR #{ENV["PRISM_MAJOR"]}})' include/prism/version.h ruby -pi -e 'gsub(/PRISM_VERSION_MINOR \d+/, %Q{PRISM_VERSION_MINOR #{ENV["PRISM_MINOR"]}})' include/prism/version.h ruby -pi -e 'gsub(/PRISM_VERSION_PATCH \d+/, %Q{PRISM_VERSION_PATCH #{ENV["PRISM_PATCH"]}})' include/prism/version.h ruby -pi -e 'gsub(/PRISM_VERSION ".+?"/, %Q{PRISM_VERSION "#{ENV["PRISM_VERSION"]}"})' include/prism/version.h ruby -pi -e 'gsub(/"version": ".+?"/, %Q{"version": "#{ENV["PRISM_VERSION"]}"})' javascript/package.json ruby -pi -e 'gsub(/lossy\(\), ".+?"/, %Q{lossy(), "#{ENV["PRISM_VERSION"]}"})' rust/ruby-prism-sys/tests/utils_tests.rs ruby -pi -e 'gsub(/\d+, "prism major/, %Q{#{ENV["PRISM_MAJOR"]}, "prism major})' templates/java/org/prism/Loader.java.erb ruby -pi -e 'gsub(/\d+, "prism minor/, %Q{#{ENV["PRISM_MINOR"]}, "prism minor})' templates/java/org/prism/Loader.java.erb ruby -pi -e 'gsub(/\d+, "prism patch/, %Q{#{ENV["PRISM_PATCH"]}, "prism patch})' templates/java/org/prism/Loader.java.erb ruby -pi -e 'gsub(/MAJOR_VERSION = \d+/, %Q{MAJOR_VERSION = #{ENV["PRISM_MAJOR"]}})' templates/javascript/src/deserialize.js.erb ruby -pi -e 'gsub(/MINOR_VERSION = \d+/, %Q{MINOR_VERSION = #{ENV["PRISM_MINOR"]}})' templates/javascript/src/deserialize.js.erb ruby -pi -e 'gsub(/PATCH_VERSION = \d+/, %Q{PATCH_VERSION = #{ENV["PRISM_PATCH"]}})' templates/javascript/src/deserialize.js.erb ruby -pi -e 'gsub(/MAJOR_VERSION = \d+/, %Q{MAJOR_VERSION = #{ENV["PRISM_MAJOR"]}})' templates/lib/prism/serialize.rb.erb ruby -pi -e 'gsub(/MINOR_VERSION = \d+/, %Q{MINOR_VERSION = #{ENV["PRISM_MINOR"]}})' templates/lib/prism/serialize.rb.erb ruby -pi -e 'gsub(/PATCH_VERSION = \d+/, %Q{PATCH_VERSION = #{ENV["PRISM_PATCH"]}})' templates/lib/prism/serialize.rb.erb ruby -pi -e 'gsub(/^version = ".+?"/, %Q{version = "#{ENV["PRISM_VERSION"]}"})' rust/ruby-prism-sys/Cargo.toml ruby -pi -e 'gsub(/^version = ".+?"/, %Q{version = "#{ENV["PRISM_VERSION"]}"})' rust/ruby-prism/Cargo.toml ruby -pi -e 'gsub(/^ruby-prism-sys = \{ version = ".+?"/, %Q{ruby-prism-sys = \{ version = "#{ENV["PRISM_VERSION"]}"})' rust/ruby-prism/Cargo.toml ``` * Update the `Gemfile.lock` file: ```sh chruby ruby-3.5.0-dev bundle install ``` * Update the version-specific lockfiles: ```sh bin/prism bundle install ``` * Update the cargo lockfiles: ```sh bundle exec rake cargo:build ``` * Commit all of the updated files: ```sh git commit -am "Bump to v$PRISM_VERSION" ``` * Push up the changes: ```sh git push ``` ## Publishing * Update the GitHub release page with a copy of the latest entry in the `CHANGELOG.md` file. * Publish the gem to [rubygems.org](rubygems.org). Note that you must have access to the `prism` gem to do this. ```sh bundle exec rake release ``` * Generate the `wasm` artifact (or download it from GitHub actions and put it in `javascript/src/prism.wasm`). ```sh make wasm ``` * Publish the JavaScript package to [npmjs.com](npmjs.com). Note that you must have access to the `@ruby/prism` package to do this. ```sh npm publish ``` * Publish the rust crate to [crates.io](crates.io). Note that you must have access to the `ruby-prism-sys` and `ruby-prism` crates to do this. ```sh bundle exec rake cargo:publish:real ``` prism-1.5.1/docs/relocation.md000066400000000000000000000043061506127434000162660ustar00rootroot00000000000000# Relocation Prism parses deterministically for the same input. This provides a nice property that is exposed through the `#node_id` API on nodes. Effectively this means that for the same input, these values will remain consistent every time the source is parsed. This means we can reparse the source same with a `#node_id` value and find the exact same node again. The `Relocation` module provides an API around this property. It allows you to "save" nodes and locations using a minimal amount of memory (just the node_id and a field identifier) and then reify them later. This minimizes the amount of memory you need to allocate to store this information because it does not keep around a pointer to the source string. ## Getting started To get started with the `Relocation` module, you would first instantiate a `Repository` object. You do this through a DSL that chains method calls for configuration. For example, if for every entry in the repository you want to store the start and end lines, the start and end code unit columns for in UTF-16, and the leading comments, you would: ```ruby repository = Prism::Relocation.filepath("path/to/file").lines.code_unit_columns(Encoding::UTF_16).leading_comments ``` Now that you have the repository, you can pass it into any of the `save*` APIs on nodes or locations to create entries in the repository that will be lazily reified. ```ruby # assume that node is a Prism::ClassNode object entry = node.constant_path.save(repository) ``` Now that you have the entry object, you do not need to keep around a reference to the repository, it will be cleaned up on its own when the last entry is reified. Now, whenever you need to, you may call the associated field methods on the entry object, as in: ```ruby entry.start_line entry.end_line entry.start_code_units_column entry.end_code_units_column entry.leading_comments ``` Note that if you had configured other fields to be saved, you would be able to access them as well. The first time one of these fields is accessed, the repository will reify every entry it knows about and then clean itself up. In this way, you can effectively treat them as if you had kept around lightweight versions of `Prism::Node` or `Prism::Location` objects. prism-1.5.1/docs/ripper_translation.md000066400000000000000000000064071506127434000200520ustar00rootroot00000000000000# Ripper translation Prism provides the ability to mirror the `Ripper` standard library. You can do this by: ```ruby require "prism/translation/ripper/shim" ``` This provides the APIs like: ```ruby Ripper.lex Ripper.parse Ripper.sexp_raw Ripper.sexp Ripper::SexpBuilder Ripper::SexpBuilderPP ``` Briefly, `Ripper` is a streaming parser that allows you to construct your own syntax tree. As an example: ```ruby class ArithmeticRipper < Prism::Translation::Ripper def on_binary(left, operator, right) left.public_send(operator, right) end def on_int(value) value.to_i end def on_program(stmts) stmts end def on_stmts_new [] end def on_stmts_add(stmts, stmt) stmts << stmt stmts end end ArithmeticRipper.new("1 + 2 - 3").parse # => [0] ``` The exact names of the `on_*` methods are listed in the `Ripper` source. ## Background It is helpful to understand the differences between the `Ripper` library and the `Prism` library. Both libraries perform parsing and provide you with APIs to manipulate and understand the resulting syntax tree. However, there are a few key differences. ### Design `Ripper` is a streaming parser. This means as it is parsing Ruby code, it dispatches events back to the consumer. This allows quite a bit of flexibility. You can use it to build your own syntax tree or to find specific patterns in the code. `Prism` on the other hand returns to you the completed syntax tree _before_ it allows you to manipulate it. This means the tree that you get back is the only representation that can be generated by the parser _at parse time_ (but of course can be manipulated later). ### Fields We use the term "field" to mean a piece of information on a syntax tree node. `Ripper` provides the minimal number of fields to accurately represent the syntax tree for the purposes of compilation/interpretation. For example, in the callbacks for nodes that are based on keywords (`class`, `module`, `for`, `while`, etc.) you are not given the keyword itself, you need to attach it on your own. In other cases, tokens are not necessarily dispatched at all, meaning you need to find them yourself. `Prism` provides the opposite: the maximum number of fields on nodes is provided. As a tradeoff, this requires more memory, but this is chosen to make it easier on consumers. ### Maintainability The `Ripper` interface is not guaranteed in any way, and tends to change between patch versions of CRuby. This is largely due to the fact that `Ripper` is a by-product of the generated parser, as opposed to its own parser. As an example, in the expression `foo::bar = baz`, there are three different represents possible for the call operator, including: * `:"::"` - Ruby 1.9 to Ruby 3.1.4 * `73` - Ruby 3.1.5 to Ruby 3.1.6 * `[:@op, "::", [lineno, column]]` - Ruby 3.2.0 and later The `Prism` interface is guaranteed going forward to be the consistent, and the official Ruby syntax tree interface. This means you can rely on this interface without having to worry about individual changes between Ruby versions. It also is a gem, which means it is versioned based on the gem version, as opposed to being versioned based on the Ruby version. Finally, you can use `Prism` to parse multiple versions of Ruby, whereas `Ripper` is tied to the Ruby version it is running on. prism-1.5.1/docs/ruby_api.md000066400000000000000000000071501506127434000157410ustar00rootroot00000000000000# Ruby API The `prism` gem provides a Ruby API for accessing the syntax tree. For the most part, the API for accessing the tree mirrors that found in the [Syntax Tree](https://github.com/ruby-syntax-tree/syntax_tree) project. This means: * Walking the tree involves creating a visitor and passing it to the `#accept` method on any node in the tree * Nodes in the tree respond to named methods for accessing their children as well as `#child_nodes` * Nodes respond to the pattern matching interfaces `#deconstruct` and `#deconstruct_keys` Every entry in `config.yml` will generate a Ruby class as well as the code that builds the nodes themselves. Creating a syntax tree involves calling one of the class methods on the `Prism` module. The full API is documented below. ## API * `Prism.dump(source)` - parse the syntax tree corresponding to the given source string, and serialize it to a string * `Prism.dump_file(filepath)` - parse the syntax tree corresponding to the given source file and serialize it to a string * `Prism.lex(source)` - parse the tokens corresponding to the given source string and return them as an array within a parse result * `Prism.lex_file(filepath)` - parse the tokens corresponding to the given source file and return them as an array within a parse result * `Prism.parse(source)` - parse the syntax tree corresponding to the given source string and return it within a parse result * `Prism.parse_file(filepath)` - parse the syntax tree corresponding to the given source file and return it within a parse result * `Prism.parse_stream(io)` - parse the syntax tree corresponding to the source that is read out of the given IO object using the `#gets` method and return it within a parse result * `Prism.parse_lex(source)` - parse the syntax tree corresponding to the given source string and return it within a parse result, along with the tokens * `Prism.parse_lex_file(filepath)` - parse the syntax tree corresponding to the given source file and return it within a parse result, along with the tokens * `Prism.load(source, serialized, freeze = false)` - load the serialized syntax tree using the source as a reference into a syntax tree * `Prism.parse_comments(source)` - parse the comments corresponding to the given source string and return them * `Prism.parse_file_comments(source)` - parse the comments corresponding to the given source file and return them * `Prism.parse_success?(source)` - parse the syntax tree corresponding to the given source string and return true if it was parsed without errors * `Prism.parse_file_success?(filepath)` - parse the syntax tree corresponding to the given source file and return true if it was parsed without errors ## Nodes Once you have nodes in hand coming out of a parse result, there are a number of common APIs that are available on each instance. They are: * `#accept(visitor)` - a method that will immediately call `visit_*` to specialize for the node type * `#child_nodes` - a positional array of the child nodes of the node, with `nil` values for any missing children * `#compact_child_nodes` - a positional array of the child nodes of the node with no `nil` values * `#copy(**keys)` - a method that allows creating a shallow copy of the node with the given keys overridden * `#deconstruct`/`#deconstruct_keys(keys)` - the pattern matching interface for nodes * `#inspect` - a string representation that looks like the syntax tree of the node * `#location` - a `Location` object that describes the location of the node in the source file * `#to_dot` - convert the node's syntax tree into graphviz dot notation * `#type` - a symbol that represents the type of the node, useful for quick comparisons prism-1.5.1/docs/ruby_parser_translation.md000066400000000000000000000012511506127434000210760ustar00rootroot00000000000000# ruby_parser translation Prism ships with the ability to translate its syntax tree into the syntax tree used by the [seattlerb/ruby_parser](https://github.com/seattlerb/ruby_parser) gem. This allows you to use tools built on top of the `ruby_parser` gem with the `prism` parser. ## Usage You can call the `parse` and `parse_file` methods on the `Prism::Translation::RubyParser` module: ```ruby filepath = "path/to/file.rb" Prism::Translation::RubyParser.parse_file(filepath) ``` This will return to you `Sexp` objects that mirror the result of calling `RubyParser` methods, as in: ```ruby filepath = "path/to/file.rb" RubyParser.new.parse(File.read(filepath), filepath) ``` prism-1.5.1/docs/serialization.md000066400000000000000000000236401506127434000170060ustar00rootroot00000000000000# Serialization Prism ships with the ability to serialize a syntax tree to a single string. The string can then be deserialized back into a syntax tree using a language other than C. This is useful for using the parsing logic in other tools without having to write a parser in that language. The syntax tree still requires a copy of the original source, as for the most part it just contains byte offsets into the source string. ## Types Let us define some simple types for readability. ### varuint A variable-length unsigned integer with the value fitting in `uint32_t` using between 1 and 5 bytes, using the [LEB128](https://en.wikipedia.org/wiki/LEB128) encoding. This drastically cuts down on the size of the serialized string, especially when the source file is large. ### varsint A variable-length signed integer with the value fitting in `int32_t` using between 1 and 5 bytes, using [ZigZag encoding](https://protobuf.dev/programming-guides/encoding/#signed-ints) into [LEB128]. ### string | # bytes | field | | --- | --- | | varuint | the length of the string in bytes | | ... | the string bytes | ### location | # bytes | field | | --- | --- | | varuint | byte offset into the source string where this location begins | | varuint | length of the location in bytes in the source string | ### comment The comment type is one of: * 0=`INLINE` (`# comment`) * 1=`EMBEDDED_DOCUMENT` (`=begin`/`=end`) | # bytes | field | | --- | --- | | `1` | comment type | | location | the location in the source of this comment | ### magic comment | # bytes | field | | --- | --- | | location | the location of the key of the magic comment | | location | the location of the value of the magic comment | ### error | # bytes | field | | --- | --- | | varuint | type | | string | error message (ASCII-only characters) | | location | the location in the source this error applies to | | `1` | the level of the error: `0` for `fatal`, `1` for `argument`, `2` for `load` | ### warning | # bytes | field | | --- | --- | | varuint | type | | string | warning message (ASCII-only characters) | | location | the location in the source this warning applies to | | `1` | the level of the warning: `0` for `default` and `1` for `verbose` | ### integer | # bytes | field | | --- | --- | | `1` | `1` if the integer is negative, `0` if the integer is positive | | varuint | the number of words in this integer | | varuint+ | the words of the integer, least-significant to most-significant | ## Structure The serialized string representing the syntax tree is composed of three parts: the header, the body, and the constant pool. The header contains information like the version of prism that serialized the tree. The body contains the actual nodes in the tree. The constant pool contains constants that were interned while parsing. The header is structured like the following table: | # bytes | field | | --- | --- | | `5` | "PRISM" | | `1` | major version number | | `1` | minor version number | | `1` | patch version number | | `1` | 1 indicates only semantics fields were serialized, 0 indicates all fields were serialized (including location fields) | | string | the encoding name | | varsint | the start line | | varuint | number of newline offsets | | varuint* | newline offsets | | varuint | number of comments | | comment* | comments | | varuint | number of magic comments | | magic comment* | magic comments | | location? | the optional location of the `__END__` keyword and its contents | | varuint | number of errors | | error* | errors | | varuint | number of warnings | | warning* | warnings | | `4` | content pool offset | | varuint | content pool size | After the header comes the body of the serialized string. The body consists of a sequence of nodes that is built using a prefix traversal order of the syntax tree. Each node is structured like the following table: | # bytes | field | | --- | --- | | `1` | node type | | varuint | node identifier | | location | node location | | varuint | node flags | Every field on the node is then appended to the serialized string. The fields can be determined by referencing `config.yml`. Depending on the type of field, it could take a couple of different forms, described below: * `double` - A field that is a `double`. This is structured as a sequence of 8 bytes in native endian order. * `node` - A field that is a node. This is structured just as like parent node. * `node?` - A field that is a node that is optionally present. If the node is not present, then a single `0` byte will be written in its place. If it is present, then it will be structured just as like parent node. * `node[]` - A field that is an array of nodes. This is structured as a variable-length integer length, followed by the child nodes themselves. * `string` - A field that is a string. For example, this is used as the name of the method in a call node, since it cannot directly reference the source string (as in `@-` or `foo=`). This is structured as a variable-length integer byte length, followed by the string itself (_without_ a trailing null byte). * `constant` - A variable-length integer that represents an index in the constant pool. * `constant?` - An optional variable-length integer that represents an index in the constant pool. If it's not present, then a single `0` byte will be written in its place. * `integer` - A field that represents an arbitrary-sized integer. The structure is listed above. * `location` - A field that is a location. This is structured as a variable-length integer start followed by a variable-length integer length. * `location?` - A field that is a location that is optionally present. If the location is not present, then a single `0` byte will be written in its place. If it is present, then it will be structured just like the `location` child node. * `uint8` - A field that is an 8-bit unsigned integer. This is structured as a single byte. * `uint32` - A field that is a 32-bit unsigned integer. This is structured as a variable-length integer. After the syntax tree, the content pool is serialized. This is a list of constants that were referenced from within the tree. The content pool begins at the offset specified in the header. Constants can be either "owned" (in which case their contents are embedded in the serialization) or "shared" (in which case their contents represent a slice of the source string). The most significant bit of the constant indicates whether it is owned or shared. In the case that it is owned, the constant is structured as follows: | # bytes | field | | --- | --- | | `4` | the byte offset in the serialization for the contents of the constant | | `4` | the byte length in the serialization | Note that you will need to mask off the most significant bit for the byte offset in the serialization. In the case that it is shared, the constant is structured as follows: | # bytes | field | | --- | --- | | `4` | the byte offset in the source string for the contents of the constant | | `4` | the byte length in the source string | After the constant pool, the contents of the owned constants are serialized. This is just a sequence of bytes that represent the contents of the constants. At the end of the serialization, the buffer is null terminated. ## APIs The relevant APIs and struct definitions are listed below: ```c // A pm_buffer_t is a simple memory buffer that stores data in a contiguous // block of memory. It is used to store the serialized representation of a // prism tree. typedef struct { char *value; size_t length; size_t capacity; } pm_buffer_t; // Free the memory associated with the buffer. void pm_buffer_free(pm_buffer_t *); // Parse and serialize the AST represented by the given source to the given // buffer. void pm_serialize_parse(pm_buffer_t *buffer, const uint8_t *source, size_t length, const char *data); ``` Typically you would use a stack-allocated `pm_buffer_t` and call `pm_serialize_parse`, as in: ```c void serialize(const uint8_t *source, size_t length) { pm_buffer_t buffer = { 0 }; pm_serialize_parse(&buffer, source, length, NULL); // Do something with the serialized string. pm_buffer_free(&buffer); } ``` The final argument to `pm_serialize_parse` is an optional string that controls the options to the parse function. This includes all of the normal options that could be passed to `pm_parser_init` through a `pm_options_t` struct, but serialized as a string to make it easier for callers through FFI. Note that no `varuint` are used here to make it easier to produce the data for the caller, and also serialized size is less important here. The format of the data is structured as follows: | # bytes | field | | ------- | -------------------------- | | `4` | the length of the filepath | | ... | the filepath bytes | | `4` | the line number | | `4` | the length the encoding | | ... | the encoding bytes | | `1` | frozen string literal | | `1` | command line flags | | `1` | syntax version, see [pm_options_version_t](https://github.com/ruby/prism/blob/main/include/prism/options.h) for valid values | | `1` | whether or not the encoding is locked (should almost always be false) | | `4` | the number of scopes | | ... | the scopes | Command line flags are a bitset. By default every flag is `0`. It includes the following values: * `0x1` - the `-a` option * `0x2` - the `-e` option * `0x4` - the `-l` option * `0x8` - the `-n` option * `0x10` - the `-p` option * `0x20` - the `-x` option Scopes are ordered from the outermost scope to the innermost one. Each scope is laid out as follows: | # bytes | field | | ------- | -------------------------- | | `4` | the number of locals | | ... | the locals | Each local is laid out as follows: | # bytes | field | | ------- | -------------------------- | | `4` | the length of the local | | ... | the local bytes | The data can be `NULL` (as seen in the example above). prism-1.5.1/docs/testing.md000066400000000000000000000045321506127434000156050ustar00rootroot00000000000000# Testing This document explains how to test prism, both locally, and against existing test suites. ## Test suite `rake test` will run all of the files in the `test/` directory. This can be conceived of as two parts: unit tests, and snapshot tests. ### Unit tests These test specific prism implementation details like comments, errors, and regular expressions. There are corresponding files for each thing being tested (like `test/errors_test.rb`). ### Snapshot tests Snapshot tests ensure that parsed output is equivalent to previous parsed output. There are many categorized examples of valid syntax within the `test/prism/fixtures/` directory. When the test suite runs, it will parse all of this syntax, and compare it against corresponding files in the `test/prism/snapshots/` directory. For example, `test/prism/fixtures/strings.txt` has a corresponding `test/prism/snapshots/strings.txt`. If the parsed files do not match, it will raise an error. If there is not a corresponding file in the `test/prism/snapshots/` directory, one will be created so that it exists for the next test run. ### Testing against repositories To test the parser against a repository, you can run `FILEPATHS='/path/to/repository/**/*.rb' rake lex`. This will run the parser against every file matched by the glob pattern and check its generated tokens against those generated by ripper. ## Local testing As you are working, you will likely want to test your code locally. `test.rb` is ignored by git, so it can be used for local testing. There are also two executables which may help you: 1. **bin/lex** takes a filepath and compares prism's lexed output to Ripper's lexed output. It prints any lexed output that doesn't match. It does some minor transformations to the lexed output in order to compare them, like split prism's heredoc tokens to mirror Ripper's. ``` $ bin/lex test.rb ``` If you would like to see the full lexed comparison, and not only the output that doesn't match, you can run with `VERBOSE=1`: ``` $ VERBOSE=1 bin/lex test.rb ``` `bin/lex` can also be used with `-e` and then source code, like this: ``` $ bin/lex -e "1 + 2" ``` 2. **bin/parse** takes a filepath and outputs prism's parsed node structure generated from reading the file. ``` $ bin/parse test.rb ``` `bin/parse` can also be used with `-e` and then source code, like this: ``` $ bin/parse -e "1 + 2" ``` prism-1.5.1/ext/000077500000000000000000000000001506127434000134525ustar00rootroot00000000000000prism-1.5.1/ext/prism/000077500000000000000000000000001506127434000146045ustar00rootroot00000000000000prism-1.5.1/ext/prism/api_pack.c000066400000000000000000000213701506127434000165220ustar00rootroot00000000000000#include "prism/extension.h" #ifdef PRISM_EXCLUDE_PACK void Init_prism_pack(void) {} #else static VALUE rb_cPrism; static VALUE rb_cPrismPack; static VALUE rb_cPrismPackDirective; static VALUE rb_cPrismPackFormat; static VALUE v3_2_0_symbol; static VALUE pack_symbol; static VALUE unpack_symbol; #if SIZEOF_UINT64_T == SIZEOF_LONG_LONG # define UINT64T2NUM(x) ULL2NUM(x) # define NUM2UINT64T(x) (uint64_t)NUM2ULL(x) #elif SIZEOF_UINT64_T == SIZEOF_LONG # define UINT64T2NUM(x) ULONG2NUM(x) # define NUM2UINT64T(x) (uint64_t)NUM2ULONG(x) #else // error No uint64_t conversion #endif static VALUE pack_type_to_symbol(pm_pack_type type) { switch (type) { case PM_PACK_SPACE: return ID2SYM(rb_intern("SPACE")); case PM_PACK_COMMENT: return ID2SYM(rb_intern("COMMENT")); case PM_PACK_INTEGER: return ID2SYM(rb_intern("INTEGER")); case PM_PACK_UTF8: return ID2SYM(rb_intern("UTF8")); case PM_PACK_BER: return ID2SYM(rb_intern("BER")); case PM_PACK_FLOAT: return ID2SYM(rb_intern("FLOAT")); case PM_PACK_STRING_SPACE_PADDED: return ID2SYM(rb_intern("STRING_SPACE_PADDED")); case PM_PACK_STRING_NULL_PADDED: return ID2SYM(rb_intern("STRING_NULL_PADDED")); case PM_PACK_STRING_NULL_TERMINATED: return ID2SYM(rb_intern("STRING_NULL_TERMINATED")); case PM_PACK_STRING_MSB: return ID2SYM(rb_intern("STRING_MSB")); case PM_PACK_STRING_LSB: return ID2SYM(rb_intern("STRING_LSB")); case PM_PACK_STRING_HEX_HIGH: return ID2SYM(rb_intern("STRING_HEX_HIGH")); case PM_PACK_STRING_HEX_LOW: return ID2SYM(rb_intern("STRING_HEX_LOW")); case PM_PACK_STRING_UU: return ID2SYM(rb_intern("STRING_UU")); case PM_PACK_STRING_MIME: return ID2SYM(rb_intern("STRING_MIME")); case PM_PACK_STRING_BASE64: return ID2SYM(rb_intern("STRING_BASE64")); case PM_PACK_STRING_FIXED: return ID2SYM(rb_intern("STRING_FIXED")); case PM_PACK_STRING_POINTER: return ID2SYM(rb_intern("STRING_POINTER")); case PM_PACK_MOVE: return ID2SYM(rb_intern("MOVE")); case PM_PACK_BACK: return ID2SYM(rb_intern("BACK")); case PM_PACK_NULL: return ID2SYM(rb_intern("NULL")); default: return Qnil; } } static VALUE pack_signed_to_symbol(pm_pack_signed signed_type) { switch (signed_type) { case PM_PACK_UNSIGNED: return ID2SYM(rb_intern("UNSIGNED")); case PM_PACK_SIGNED: return ID2SYM(rb_intern("SIGNED")); case PM_PACK_SIGNED_NA: return ID2SYM(rb_intern("SIGNED_NA")); default: return Qnil; } } static VALUE pack_endian_to_symbol(pm_pack_endian endian) { switch (endian) { case PM_PACK_AGNOSTIC_ENDIAN: return ID2SYM(rb_intern("AGNOSTIC_ENDIAN")); case PM_PACK_LITTLE_ENDIAN: return ID2SYM(rb_intern("LITTLE_ENDIAN")); case PM_PACK_BIG_ENDIAN: return ID2SYM(rb_intern("BIG_ENDIAN")); case PM_PACK_NATIVE_ENDIAN: return ID2SYM(rb_intern("NATIVE_ENDIAN")); case PM_PACK_ENDIAN_NA: return ID2SYM(rb_intern("ENDIAN_NA")); default: return Qnil; } } static VALUE pack_size_to_symbol(pm_pack_size size) { switch (size) { case PM_PACK_SIZE_SHORT: return ID2SYM(rb_intern("SIZE_SHORT")); case PM_PACK_SIZE_INT: return ID2SYM(rb_intern("SIZE_INT")); case PM_PACK_SIZE_LONG: return ID2SYM(rb_intern("SIZE_LONG")); case PM_PACK_SIZE_LONG_LONG: return ID2SYM(rb_intern("SIZE_LONG_LONG")); case PM_PACK_SIZE_8: return ID2SYM(rb_intern("SIZE_8")); case PM_PACK_SIZE_16: return ID2SYM(rb_intern("SIZE_16")); case PM_PACK_SIZE_32: return ID2SYM(rb_intern("SIZE_32")); case PM_PACK_SIZE_64: return ID2SYM(rb_intern("SIZE_64")); case PM_PACK_SIZE_P: return ID2SYM(rb_intern("SIZE_P")); case PM_PACK_SIZE_NA: return ID2SYM(rb_intern("SIZE_NA")); default: return Qnil; } } static VALUE pack_length_type_to_symbol(pm_pack_length_type length_type) { switch (length_type) { case PM_PACK_LENGTH_FIXED: return ID2SYM(rb_intern("LENGTH_FIXED")); case PM_PACK_LENGTH_MAX: return ID2SYM(rb_intern("LENGTH_MAX")); case PM_PACK_LENGTH_RELATIVE: return ID2SYM(rb_intern("LENGTH_RELATIVE")); case PM_PACK_LENGTH_NA: return ID2SYM(rb_intern("LENGTH_NA")); default: return Qnil; } } static VALUE pack_encoding_to_ruby(pm_pack_encoding encoding) { int index; switch (encoding) { case PM_PACK_ENCODING_ASCII_8BIT: index = rb_ascii8bit_encindex(); break; case PM_PACK_ENCODING_US_ASCII: index = rb_usascii_encindex(); break; case PM_PACK_ENCODING_UTF_8: index = rb_utf8_encindex(); break; default: return Qnil; } return rb_enc_from_encoding(rb_enc_from_index(index)); } /** * call-seq: * Pack::parse(version, variant, source) -> Format * * Parse the given source and return a format object. */ static VALUE pack_parse(VALUE self, VALUE version_symbol, VALUE variant_symbol, VALUE format_string) { if (version_symbol != v3_2_0_symbol) { rb_raise(rb_eArgError, "invalid version"); } pm_pack_variant variant; if (variant_symbol == pack_symbol) { variant = PM_PACK_VARIANT_PACK; } else if (variant_symbol == unpack_symbol) { variant = PM_PACK_VARIANT_UNPACK; } else { rb_raise(rb_eArgError, "invalid variant"); } StringValue(format_string); const char *format = RSTRING_PTR(format_string); const char *format_end = format + RSTRING_LEN(format_string); pm_pack_encoding encoding = PM_PACK_ENCODING_START; VALUE directives_array = rb_ary_new(); while (format < format_end) { pm_pack_type type; pm_pack_signed signed_type; pm_pack_endian endian; pm_pack_size size; pm_pack_length_type length_type; uint64_t length; const char *directive_start = format; pm_pack_result parse_result = pm_pack_parse(variant, &format, format_end, &type, &signed_type, &endian, &size, &length_type, &length, &encoding); const char *directive_end = format; switch (parse_result) { case PM_PACK_OK: break; case PM_PACK_ERROR_UNSUPPORTED_DIRECTIVE: rb_raise(rb_eArgError, "unsupported directive"); case PM_PACK_ERROR_UNKNOWN_DIRECTIVE: rb_raise(rb_eArgError, "unsupported directive"); case PM_PACK_ERROR_LENGTH_TOO_BIG: rb_raise(rb_eRangeError, "pack length too big"); case PM_PACK_ERROR_BANG_NOT_ALLOWED: rb_raise(rb_eRangeError, "bang not allowed"); case PM_PACK_ERROR_DOUBLE_ENDIAN: rb_raise(rb_eRangeError, "double endian"); default: rb_bug("parse result"); } if (type == PM_PACK_END) { break; } VALUE directive_args[9] = { version_symbol, variant_symbol, rb_usascii_str_new(directive_start, directive_end - directive_start), pack_type_to_symbol(type), pack_signed_to_symbol(signed_type), pack_endian_to_symbol(endian), pack_size_to_symbol(size), pack_length_type_to_symbol(length_type), UINT64T2NUM(length) }; rb_ary_push(directives_array, rb_class_new_instance(9, directive_args, rb_cPrismPackDirective)); } VALUE format_args[2]; format_args[0] = directives_array; format_args[1] = pack_encoding_to_ruby(encoding); return rb_class_new_instance(2, format_args, rb_cPrismPackFormat); } /** * The function that gets called when Ruby initializes the prism extension. */ void Init_prism_pack(void) { rb_cPrism = rb_define_module("Prism"); rb_cPrismPack = rb_define_module_under(rb_cPrism, "Pack"); rb_cPrismPackDirective = rb_define_class_under(rb_cPrismPack, "Directive", rb_cObject); rb_cPrismPackFormat = rb_define_class_under(rb_cPrismPack, "Format", rb_cObject); rb_define_singleton_method(rb_cPrismPack, "parse", pack_parse, 3); v3_2_0_symbol = ID2SYM(rb_intern("v3_2_0")); pack_symbol = ID2SYM(rb_intern("pack")); unpack_symbol = ID2SYM(rb_intern("unpack")); } #endif prism-1.5.1/ext/prism/extconf.rb000066400000000000000000000105351506127434000166030ustar00rootroot00000000000000# frozen_string_literal: true require "rbconfig" if ARGV.delete("--help") print(<<~TEXT) USAGE: ruby #{$PROGRAM_NAME} [options] Flags that are always valid: --enable-build-debug Enable debug build. You may also set the PRISM_BUILD_DEBUG environment variable. --enable-build-minimal Enable minimal build. You may also set the PRISM_BUILD_MINIMAL environment variable. --help Display this message. Environment variables used: PRISM_BUILD_DEBUG Equivalent to `--enable-build-debug` when set, even if nil or blank. PRISM_BUILD_MINIMAL Equivalent to `--enable-build-minimal` when set, even if nil or blank. TEXT exit!(0) end # If this gem is being build from a git source, then we need to run # templating if it hasn't been run yet. In normal packaging, we would have # shipped the templated files with the gem, so this wouldn't be necessary. def generate_templates Dir.chdir(File.expand_path("../..", __dir__)) do if !File.exist?("include/prism/ast.h") && Dir.exist?(".git") system("templates/template.rb", exception: true) end end end # Runs `make` in the root directory of the project. Note that this is the # `Makefile` for the overall project, not the `Makefile` that is being generated # by this script.` def make(env, target) puts "Running make #{target} with #{env.inspect}" Dir.chdir(File.expand_path("../..", __dir__)) do system( env, RUBY_PLATFORM.match?(/openbsd|freebsd/) ? "gmake" : "make", target, exception: true ) end end # On non-CRuby we only need the shared library since we'll interface with it # through FFI, so we'll build only that and not the C extension. We also avoid # `require "mkmf"` as that prepends the GraalVM LLVM toolchain to PATH on TruffleRuby < 24.0, # but we want to use the system toolchain here since libprism is run natively. if RUBY_ENGINE != "ruby" generate_templates soext = RbConfig::CONFIG["SOEXT"] # Pass SOEXT to avoid an extra subprocess just to query that make({ "SOEXT" => soext }, "build/libprism.#{soext}") File.write("Makefile", "all install clean:\n\t@#{RbConfig::CONFIG["NULLCMD"]}\n") return end require "mkmf" # First, ensure that we can find the header for the prism library. generate_templates # Templates should be generated before find_header. unless find_header("prism.h", File.expand_path("../../include", __dir__)) raise "prism.h is required" end # Next, ensure we can find the header for the C extension. Explicitly look for # the extension header in the parent directory because we want to consistently # look for `prism/extension.h` in our source files to line up with our mirroring # in CRuby. unless find_header("prism/extension.h", File.expand_path("..", __dir__)) raise "prism/extension.h is required" end # If `--enable-build-debug` is passed to this script or the # `PRISM_BUILD_DEBUG` environment variable is defined, we'll build with the # `PRISM_BUILD_DEBUG` macro defined. This causes parse functions to # duplicate their input so that they have clearly set bounds, which is useful # for finding bugs that cause the parser to read off the end of the input. if enable_config("build-debug", ENV["PRISM_BUILD_DEBUG"] || false) append_cflags("-DPRISM_BUILD_DEBUG") end # If `--enable-build-minimal` is passed to this script or the # `PRISM_BUILD_MINIMAL` environment variable is defined, we'll build with the # set of defines that comprise the minimal set. This causes the parser to be # built with minimal features, necessary for stripping out functionality when # the size of the final built artifact is a concern. if enable_config("build-minimal", ENV["PRISM_BUILD_MINIMAL"] || false) append_cflags("-DPRISM_BUILD_MINIMAL") end # By default, all symbols are hidden in the shared library. append_cflags("-fvisibility=hidden") def src_list(path) srcdir = path.dup RbConfig.expand(srcdir) # mutates srcdir :-/ Dir[File.join(srcdir, "*.{#{SRC_EXT.join(%q{,})}}")] end def add_libprism_source(path) $VPATH << path src_list path end $srcs = src_list("$(srcdir)") + add_libprism_source("$(srcdir)/../../src") + add_libprism_source("$(srcdir)/../../src/util") # Finally, we'll create the `Makefile` that is going to be used to configure and # build the C extension. create_makefile("prism/prism") prism-1.5.1/ext/prism/extension.c000066400000000000000000001413751506127434000167770ustar00rootroot00000000000000#include "prism/extension.h" #ifdef _WIN32 #include #endif // NOTE: this file should contain only bindings. All non-trivial logic should be // in libprism so it can be shared its the various callers. VALUE rb_cPrism; VALUE rb_cPrismNode; VALUE rb_cPrismSource; VALUE rb_cPrismToken; VALUE rb_cPrismLocation; VALUE rb_cPrismComment; VALUE rb_cPrismInlineComment; VALUE rb_cPrismEmbDocComment; VALUE rb_cPrismMagicComment; VALUE rb_cPrismParseError; VALUE rb_cPrismParseWarning; VALUE rb_cPrismResult; VALUE rb_cPrismParseResult; VALUE rb_cPrismLexResult; VALUE rb_cPrismParseLexResult; VALUE rb_cPrismStringQuery; VALUE rb_cPrismScope; VALUE rb_cPrismDebugEncoding; ID rb_id_option_command_line; ID rb_id_option_encoding; ID rb_id_option_filepath; ID rb_id_option_freeze; ID rb_id_option_frozen_string_literal; ID rb_id_option_line; ID rb_id_option_main_script; ID rb_id_option_partial_script; ID rb_id_option_scopes; ID rb_id_option_version; ID rb_id_source_for; ID rb_id_forwarding_positionals; ID rb_id_forwarding_keywords; ID rb_id_forwarding_block; ID rb_id_forwarding_all; /******************************************************************************/ /* IO of Ruby code */ /******************************************************************************/ /** * Check if the given VALUE is a string. If it's not a string, then raise a * TypeError. Otherwise return the VALUE as a C string. */ static const char * check_string(VALUE value) { // Check if the value is a string. If it's not, then raise a type error. if (!RB_TYPE_P(value, T_STRING)) { rb_raise(rb_eTypeError, "wrong argument type %" PRIsVALUE " (expected String)", rb_obj_class(value)); } // Otherwise, return the value as a C string. return RSTRING_PTR(value); } /** * Load the contents and size of the given string into the given pm_string_t. */ static void input_load_string(pm_string_t *input, VALUE string) { // Check if the string is a string. If it's not, then raise a type error. if (!RB_TYPE_P(string, T_STRING)) { rb_raise(rb_eTypeError, "wrong argument type %" PRIsVALUE " (expected String)", rb_obj_class(string)); } pm_string_constant_init(input, RSTRING_PTR(string), RSTRING_LEN(string)); } /******************************************************************************/ /* Building C options from Ruby options */ /******************************************************************************/ /** * Build the scopes associated with the provided Ruby keyword value. */ static void build_options_scopes(pm_options_t *options, VALUE scopes) { // Check if the value is an array. If it's not, then raise a type error. if (!RB_TYPE_P(scopes, T_ARRAY)) { rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (expected Array)", rb_obj_class(scopes)); } // Initialize the scopes array. size_t scopes_count = RARRAY_LEN(scopes); if (!pm_options_scopes_init(options, scopes_count)) { rb_raise(rb_eNoMemError, "failed to allocate memory"); } // Iterate over the scopes and add them to the options. for (size_t scope_index = 0; scope_index < scopes_count; scope_index++) { VALUE scope = rb_ary_entry(scopes, scope_index); // The scope can be either an array or it can be a Prism::Scope object. // Parse out the correct values here from either. VALUE locals; uint8_t forwarding = PM_OPTIONS_SCOPE_FORWARDING_NONE; if (RB_TYPE_P(scope, T_ARRAY)) { locals = scope; } else if (rb_obj_is_kind_of(scope, rb_cPrismScope)) { locals = rb_ivar_get(scope, rb_intern("@locals")); if (!RB_TYPE_P(locals, T_ARRAY)) { rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (expected Array)", rb_obj_class(locals)); } VALUE names = rb_ivar_get(scope, rb_intern("@forwarding")); if (!RB_TYPE_P(names, T_ARRAY)) { rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (expected Array)", rb_obj_class(names)); } size_t names_count = RARRAY_LEN(names); for (size_t name_index = 0; name_index < names_count; name_index++) { VALUE name = rb_ary_entry(names, name_index); // Check that the name is a symbol. If it's not, then raise // a type error. if (!RB_TYPE_P(name, T_SYMBOL)) { rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (expected Symbol)", rb_obj_class(name)); } ID id = SYM2ID(name); if (id == rb_id_forwarding_positionals) { forwarding |= PM_OPTIONS_SCOPE_FORWARDING_POSITIONALS; } else if (id == rb_id_forwarding_keywords) { forwarding |= PM_OPTIONS_SCOPE_FORWARDING_KEYWORDS; } else if (id == rb_id_forwarding_block) { forwarding |= PM_OPTIONS_SCOPE_FORWARDING_BLOCK; } else if (id == rb_id_forwarding_all) { forwarding |= PM_OPTIONS_SCOPE_FORWARDING_ALL; } else { rb_raise(rb_eArgError, "invalid forwarding value: %" PRIsVALUE, name); } } } else { rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (expected Array or Prism::Scope)", rb_obj_class(scope)); } // Initialize the scope array. size_t locals_count = RARRAY_LEN(locals); pm_options_scope_t *options_scope = &options->scopes[scope_index]; if (!pm_options_scope_init(options_scope, locals_count)) { rb_raise(rb_eNoMemError, "failed to allocate memory"); } // Iterate over the locals and add them to the scope. for (size_t local_index = 0; local_index < locals_count; local_index++) { VALUE local = rb_ary_entry(locals, local_index); // Check that the local is a symbol. If it's not, then raise a // type error. if (!RB_TYPE_P(local, T_SYMBOL)) { rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (expected Symbol)", rb_obj_class(local)); } // Add the local to the scope. pm_string_t *scope_local = &options_scope->locals[local_index]; const char *name = rb_id2name(SYM2ID(local)); pm_string_constant_init(scope_local, name, strlen(name)); } // Now set the forwarding options. pm_options_scope_forwarding_set(options_scope, forwarding); } } /** * An iterator function that is called for each key-value in the keywords hash. */ static int build_options_i(VALUE key, VALUE value, VALUE argument) { pm_options_t *options = (pm_options_t *) argument; ID key_id = SYM2ID(key); if (key_id == rb_id_option_filepath) { if (!NIL_P(value)) pm_options_filepath_set(options, check_string(value)); } else if (key_id == rb_id_option_encoding) { if (!NIL_P(value)) { if (value == Qfalse) { pm_options_encoding_locked_set(options, true); } else { pm_options_encoding_set(options, rb_enc_name(rb_to_encoding(value))); } } } else if (key_id == rb_id_option_line) { if (!NIL_P(value)) pm_options_line_set(options, NUM2INT(value)); } else if (key_id == rb_id_option_frozen_string_literal) { if (!NIL_P(value)) pm_options_frozen_string_literal_set(options, RTEST(value)); } else if (key_id == rb_id_option_version) { if (!NIL_P(value)) { const char *version = check_string(value); if (!pm_options_version_set(options, version, RSTRING_LEN(value))) { rb_raise(rb_eArgError, "invalid version: %" PRIsVALUE, value); } } } else if (key_id == rb_id_option_scopes) { if (!NIL_P(value)) build_options_scopes(options, value); } else if (key_id == rb_id_option_command_line) { if (!NIL_P(value)) { const char *string = check_string(value); uint8_t command_line = 0; for (size_t index = 0; index < strlen(string); index++) { switch (string[index]) { case 'a': command_line |= PM_OPTIONS_COMMAND_LINE_A; break; case 'e': command_line |= PM_OPTIONS_COMMAND_LINE_E; break; case 'l': command_line |= PM_OPTIONS_COMMAND_LINE_L; break; case 'n': command_line |= PM_OPTIONS_COMMAND_LINE_N; break; case 'p': command_line |= PM_OPTIONS_COMMAND_LINE_P; break; case 'x': command_line |= PM_OPTIONS_COMMAND_LINE_X; break; default: rb_raise(rb_eArgError, "invalid command line flag: '%c'", string[index]); break; } } pm_options_command_line_set(options, command_line); } } else if (key_id == rb_id_option_main_script) { if (!NIL_P(value)) pm_options_main_script_set(options, RTEST(value)); } else if (key_id == rb_id_option_partial_script) { if (!NIL_P(value)) pm_options_partial_script_set(options, RTEST(value)); } else if (key_id == rb_id_option_freeze) { if (!NIL_P(value)) pm_options_freeze_set(options, RTEST(value)); } else { rb_raise(rb_eArgError, "unknown keyword: %" PRIsVALUE, key); } return ST_CONTINUE; } /** * We need a struct here to pass through rb_protect and it has to be a single * value. Because the sizeof(VALUE) == sizeof(void *), we're going to pass this * through as an opaque pointer and cast it on both sides. */ struct build_options_data { pm_options_t *options; VALUE keywords; }; /** * Build the set of options from the given keywords. Note that this can raise a * Ruby error if the options are not valid. */ static VALUE build_options(VALUE argument) { struct build_options_data *data = (struct build_options_data *) argument; rb_hash_foreach(data->keywords, build_options_i, (VALUE) data->options); return Qnil; } /** * Extract the options from the given keyword arguments. */ static void extract_options(pm_options_t *options, VALUE filepath, VALUE keywords) { options->line = 1; // default if (!NIL_P(keywords)) { struct build_options_data data = { .options = options, .keywords = keywords }; struct build_options_data *argument = &data; int state = 0; rb_protect(build_options, (VALUE) argument, &state); if (state != 0) { pm_options_free(options); rb_jump_tag(state); } } if (!NIL_P(filepath)) { if (!RB_TYPE_P(filepath, T_STRING)) { pm_options_free(options); rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (expected String)", rb_obj_class(filepath)); } pm_options_filepath_set(options, RSTRING_PTR(filepath)); } } /** * Read options for methods that look like (source, **options). */ static void string_options(int argc, VALUE *argv, pm_string_t *input, pm_options_t *options) { VALUE string; VALUE keywords; rb_scan_args(argc, argv, "1:", &string, &keywords); extract_options(options, Qnil, keywords); input_load_string(input, string); } /** * Read options for methods that look like (filepath, **options). */ static void file_options(int argc, VALUE *argv, pm_string_t *input, pm_options_t *options, VALUE *encoded_filepath) { VALUE filepath; VALUE keywords; rb_scan_args(argc, argv, "1:", &filepath, &keywords); Check_Type(filepath, T_STRING); *encoded_filepath = rb_str_encode_ospath(filepath); extract_options(options, *encoded_filepath, keywords); const char *source = (const char *) pm_string_source(&options->filepath); pm_string_init_result_t result; switch (result = pm_string_file_init(input, source)) { case PM_STRING_INIT_SUCCESS: break; case PM_STRING_INIT_ERROR_GENERIC: { pm_options_free(options); #ifdef _WIN32 int e = rb_w32_map_errno(GetLastError()); #else int e = errno; #endif rb_syserr_fail(e, source); break; } case PM_STRING_INIT_ERROR_DIRECTORY: pm_options_free(options); rb_syserr_fail(EISDIR, source); break; default: pm_options_free(options); rb_raise(rb_eRuntimeError, "Unknown error (%d) initializing file: %s", result, source); break; } } #ifndef PRISM_EXCLUDE_SERIALIZATION /******************************************************************************/ /* Serializing the AST */ /******************************************************************************/ /** * Dump the AST corresponding to the given input to a string. */ static VALUE dump_input(pm_string_t *input, const pm_options_t *options) { pm_buffer_t buffer; if (!pm_buffer_init(&buffer)) { rb_raise(rb_eNoMemError, "failed to allocate memory"); } pm_parser_t parser; pm_parser_init(&parser, pm_string_source(input), pm_string_length(input), options); pm_node_t *node = pm_parse(&parser); pm_serialize(&parser, node, &buffer); VALUE result = rb_str_new(pm_buffer_value(&buffer), pm_buffer_length(&buffer)); pm_node_destroy(&parser, node); pm_buffer_free(&buffer); pm_parser_free(&parser); return result; } /** * call-seq: * Prism::dump(source, **options) -> String * * Dump the AST corresponding to the given string to a string. For supported * options, see Prism::parse. */ static VALUE dump(int argc, VALUE *argv, VALUE self) { pm_string_t input; pm_options_t options = { 0 }; string_options(argc, argv, &input, &options); #ifdef PRISM_BUILD_DEBUG size_t length = pm_string_length(&input); char* dup = xmalloc(length); memcpy(dup, pm_string_source(&input), length); pm_string_constant_init(&input, dup, length); #endif VALUE value = dump_input(&input, &options); if (options.freeze) rb_obj_freeze(value); #ifdef PRISM_BUILD_DEBUG xfree(dup); #endif pm_string_free(&input); pm_options_free(&options); return value; } /** * call-seq: * Prism::dump_file(filepath, **options) -> String * * Dump the AST corresponding to the given file to a string. For supported * options, see Prism::parse. */ static VALUE dump_file(int argc, VALUE *argv, VALUE self) { pm_string_t input; pm_options_t options = { 0 }; VALUE encoded_filepath; file_options(argc, argv, &input, &options, &encoded_filepath); VALUE value = dump_input(&input, &options); pm_string_free(&input); pm_options_free(&options); return value; } #endif /******************************************************************************/ /* Extracting values for the parse result */ /******************************************************************************/ /** * The same as rb_class_new_instance, but accepts an additional boolean to * indicate whether or not the resulting class instance should be frozen. */ static inline VALUE rb_class_new_instance_freeze(int argc, const VALUE *argv, VALUE klass, bool freeze) { VALUE value = rb_class_new_instance(argc, argv, klass); if (freeze) rb_obj_freeze(value); return value; } /** * Create a new Location instance from the given parser and bounds. */ static inline VALUE parser_location(const pm_parser_t *parser, VALUE source, bool freeze, const uint8_t *start, size_t length) { VALUE argv[] = { source, LONG2FIX(start - parser->start), LONG2FIX(length) }; return rb_class_new_instance_freeze(3, argv, rb_cPrismLocation, freeze); } /** * Create a new Location instance from the given parser and location. */ #define PARSER_LOCATION_LOC(parser, source, freeze, loc) \ parser_location(parser, source, freeze, loc.start, (size_t) (loc.end - loc.start)) /** * Build a new Comment instance from the given parser and comment. */ static inline VALUE parser_comment(const pm_parser_t *parser, VALUE source, bool freeze, const pm_comment_t *comment) { VALUE argv[] = { PARSER_LOCATION_LOC(parser, source, freeze, comment->location) }; VALUE type = (comment->type == PM_COMMENT_EMBDOC) ? rb_cPrismEmbDocComment : rb_cPrismInlineComment; return rb_class_new_instance_freeze(1, argv, type, freeze); } /** * Extract the comments out of the parser into an array. */ static VALUE parser_comments(const pm_parser_t *parser, VALUE source, bool freeze) { VALUE comments = rb_ary_new_capa(parser->comment_list.size); for ( const pm_comment_t *comment = (const pm_comment_t *) parser->comment_list.head; comment != NULL; comment = (const pm_comment_t *) comment->node.next ) { VALUE value = parser_comment(parser, source, freeze, comment); rb_ary_push(comments, value); } if (freeze) rb_obj_freeze(comments); return comments; } /** * Build a new MagicComment instance from the given parser and magic comment. */ static inline VALUE parser_magic_comment(const pm_parser_t *parser, VALUE source, bool freeze, const pm_magic_comment_t *magic_comment) { VALUE key_loc = parser_location(parser, source, freeze, magic_comment->key_start, magic_comment->key_length); VALUE value_loc = parser_location(parser, source, freeze, magic_comment->value_start, magic_comment->value_length); VALUE argv[] = { key_loc, value_loc }; return rb_class_new_instance_freeze(2, argv, rb_cPrismMagicComment, freeze); } /** * Extract the magic comments out of the parser into an array. */ static VALUE parser_magic_comments(const pm_parser_t *parser, VALUE source, bool freeze) { VALUE magic_comments = rb_ary_new_capa(parser->magic_comment_list.size); for ( const pm_magic_comment_t *magic_comment = (const pm_magic_comment_t *) parser->magic_comment_list.head; magic_comment != NULL; magic_comment = (const pm_magic_comment_t *) magic_comment->node.next ) { VALUE value = parser_magic_comment(parser, source, freeze, magic_comment); rb_ary_push(magic_comments, value); } if (freeze) rb_obj_freeze(magic_comments); return magic_comments; } /** * Extract out the data location from the parser into a Location instance if one * exists. */ static VALUE parser_data_loc(const pm_parser_t *parser, VALUE source, bool freeze) { if (parser->data_loc.end == NULL) { return Qnil; } else { return PARSER_LOCATION_LOC(parser, source, freeze, parser->data_loc); } } /** * Extract the errors out of the parser into an array. */ static VALUE parser_errors(const pm_parser_t *parser, rb_encoding *encoding, VALUE source, bool freeze) { VALUE errors = rb_ary_new_capa(parser->error_list.size); for ( const pm_diagnostic_t *error = (const pm_diagnostic_t *) parser->error_list.head; error != NULL; error = (const pm_diagnostic_t *) error->node.next ) { VALUE type = ID2SYM(rb_intern(pm_diagnostic_id_human(error->diag_id))); VALUE message = rb_obj_freeze(rb_enc_str_new_cstr(error->message, encoding)); VALUE location = PARSER_LOCATION_LOC(parser, source, freeze, error->location); VALUE level = Qnil; switch (error->level) { case PM_ERROR_LEVEL_SYNTAX: level = ID2SYM(rb_intern("syntax")); break; case PM_ERROR_LEVEL_ARGUMENT: level = ID2SYM(rb_intern("argument")); break; case PM_ERROR_LEVEL_LOAD: level = ID2SYM(rb_intern("load")); break; default: rb_raise(rb_eRuntimeError, "Unknown level: %" PRIu8, error->level); } VALUE argv[] = { type, message, location, level }; VALUE value = rb_class_new_instance_freeze(4, argv, rb_cPrismParseError, freeze); rb_ary_push(errors, value); } if (freeze) rb_obj_freeze(errors); return errors; } /** * Extract the warnings out of the parser into an array. */ static VALUE parser_warnings(const pm_parser_t *parser, rb_encoding *encoding, VALUE source, bool freeze) { VALUE warnings = rb_ary_new_capa(parser->warning_list.size); for ( const pm_diagnostic_t *warning = (const pm_diagnostic_t *) parser->warning_list.head; warning != NULL; warning = (const pm_diagnostic_t *) warning->node.next ) { VALUE type = ID2SYM(rb_intern(pm_diagnostic_id_human(warning->diag_id))); VALUE message = rb_obj_freeze(rb_enc_str_new_cstr(warning->message, encoding)); VALUE location = PARSER_LOCATION_LOC(parser, source, freeze, warning->location); VALUE level = Qnil; switch (warning->level) { case PM_WARNING_LEVEL_DEFAULT: level = ID2SYM(rb_intern("default")); break; case PM_WARNING_LEVEL_VERBOSE: level = ID2SYM(rb_intern("verbose")); break; default: rb_raise(rb_eRuntimeError, "Unknown level: %" PRIu8, warning->level); } VALUE argv[] = { type, message, location, level }; VALUE value = rb_class_new_instance_freeze(4, argv, rb_cPrismParseWarning, freeze); rb_ary_push(warnings, value); } if (freeze) rb_obj_freeze(warnings); return warnings; } /** * Create a new parse result from the given parser, value, encoding, and source. */ static VALUE parse_result_create(VALUE class, const pm_parser_t *parser, VALUE value, rb_encoding *encoding, VALUE source, bool freeze) { VALUE result_argv[] = { value, parser_comments(parser, source, freeze), parser_magic_comments(parser, source, freeze), parser_data_loc(parser, source, freeze), parser_errors(parser, encoding, source, freeze), parser_warnings(parser, encoding, source, freeze), source }; return rb_class_new_instance_freeze(7, result_argv, class, freeze); } /******************************************************************************/ /* Lexing Ruby code */ /******************************************************************************/ /** * This struct gets stored in the parser and passed in to the lex callback any * time a new token is found. We use it to store the necessary information to * initialize a Token instance. */ typedef struct { VALUE source; VALUE tokens; rb_encoding *encoding; bool freeze; } parse_lex_data_t; /** * This is passed as a callback to the parser. It gets called every time a new * token is found. Once found, we initialize a new instance of Token and push it * onto the tokens array. */ static void parse_lex_token(void *data, pm_parser_t *parser, pm_token_t *token) { parse_lex_data_t *parse_lex_data = (parse_lex_data_t *) parser->lex_callback->data; VALUE value = pm_token_new(parser, token, parse_lex_data->encoding, parse_lex_data->source, parse_lex_data->freeze); VALUE yields = rb_assoc_new(value, INT2FIX(parser->lex_state)); if (parse_lex_data->freeze) { rb_obj_freeze(value); rb_obj_freeze(yields); } rb_ary_push(parse_lex_data->tokens, yields); } /** * This is called whenever the encoding changes based on the magic comment at * the top of the file. We use it to update the encoding that we are using to * create tokens. */ static void parse_lex_encoding_changed_callback(pm_parser_t *parser) { parse_lex_data_t *parse_lex_data = (parse_lex_data_t *) parser->lex_callback->data; parse_lex_data->encoding = rb_enc_find(parser->encoding->name); // Since the encoding changed, we need to go back and change the encoding of // the tokens that were already lexed. This is only going to end up being // one or two tokens, since the encoding can only change at the top of the // file. VALUE tokens = parse_lex_data->tokens; VALUE next_tokens = rb_ary_new(); for (long index = 0; index < RARRAY_LEN(tokens); index++) { VALUE yields = rb_ary_entry(tokens, index); VALUE token = rb_ary_entry(yields, 0); VALUE value = rb_ivar_get(token, rb_intern("@value")); VALUE next_value = rb_str_dup(value); rb_enc_associate(next_value, parse_lex_data->encoding); if (parse_lex_data->freeze) rb_obj_freeze(next_value); VALUE next_token_argv[] = { parse_lex_data->source, rb_ivar_get(token, rb_intern("@type")), next_value, rb_ivar_get(token, rb_intern("@location")) }; VALUE next_token = rb_class_new_instance(4, next_token_argv, rb_cPrismToken); VALUE next_yields = rb_assoc_new(next_token, rb_ary_entry(yields, 1)); if (parse_lex_data->freeze) { rb_obj_freeze(next_token); rb_obj_freeze(next_yields); } rb_ary_push(next_tokens, next_yields); } rb_ary_replace(parse_lex_data->tokens, next_tokens); } /** * Parse the given input and return a ParseResult containing just the tokens or * the nodes and tokens. */ static VALUE parse_lex_input(pm_string_t *input, const pm_options_t *options, bool return_nodes) { pm_parser_t parser; pm_parser_init(&parser, pm_string_source(input), pm_string_length(input), options); pm_parser_register_encoding_changed_callback(&parser, parse_lex_encoding_changed_callback); VALUE source_string = rb_str_new((const char *) pm_string_source(input), pm_string_length(input)); VALUE offsets = rb_ary_new_capa(parser.newline_list.size); VALUE source = rb_funcall(rb_cPrismSource, rb_id_source_for, 3, source_string, LONG2NUM(parser.start_line), offsets); parse_lex_data_t parse_lex_data = { .source = source, .tokens = rb_ary_new(), .encoding = rb_utf8_encoding(), .freeze = options->freeze, }; parse_lex_data_t *data = &parse_lex_data; pm_lex_callback_t lex_callback = (pm_lex_callback_t) { .data = (void *) data, .callback = parse_lex_token, }; parser.lex_callback = &lex_callback; pm_node_t *node = pm_parse(&parser); // Here we need to update the Source object to have the correct // encoding for the source string and the correct newline offsets. // We do it here because we've already created the Source object and given // it over to all of the tokens, and both of these are only set after pm_parse(). rb_encoding *encoding = rb_enc_find(parser.encoding->name); rb_enc_associate(source_string, encoding); for (size_t index = 0; index < parser.newline_list.size; index++) { rb_ary_push(offsets, ULONG2NUM(parser.newline_list.offsets[index])); } if (options->freeze) { rb_obj_freeze(source_string); rb_obj_freeze(offsets); rb_obj_freeze(source); rb_obj_freeze(parse_lex_data.tokens); } VALUE result; if (return_nodes) { VALUE value = rb_ary_new_capa(2); rb_ary_push(value, pm_ast_new(&parser, node, parse_lex_data.encoding, source, options->freeze)); rb_ary_push(value, parse_lex_data.tokens); if (options->freeze) rb_obj_freeze(value); result = parse_result_create(rb_cPrismParseLexResult, &parser, value, parse_lex_data.encoding, source, options->freeze); } else { result = parse_result_create(rb_cPrismLexResult, &parser, parse_lex_data.tokens, parse_lex_data.encoding, source, options->freeze); } pm_node_destroy(&parser, node); pm_parser_free(&parser); return result; } /** * call-seq: * Prism::lex(source, **options) -> LexResult * * Return a LexResult instance that contains an array of Token instances * corresponding to the given string. For supported options, see Prism::parse. */ static VALUE lex(int argc, VALUE *argv, VALUE self) { pm_string_t input; pm_options_t options = { 0 }; string_options(argc, argv, &input, &options); VALUE result = parse_lex_input(&input, &options, false); pm_string_free(&input); pm_options_free(&options); return result; } /** * call-seq: * Prism::lex_file(filepath, **options) -> LexResult * * Return a LexResult instance that contains an array of Token instances * corresponding to the given file. For supported options, see Prism::parse. */ static VALUE lex_file(int argc, VALUE *argv, VALUE self) { pm_string_t input; pm_options_t options = { 0 }; VALUE encoded_filepath; file_options(argc, argv, &input, &options, &encoded_filepath); VALUE value = parse_lex_input(&input, &options, false); pm_string_free(&input); pm_options_free(&options); return value; } /******************************************************************************/ /* Parsing Ruby code */ /******************************************************************************/ /** * Parse the given input and return a ParseResult instance. */ static VALUE parse_input(pm_string_t *input, const pm_options_t *options) { pm_parser_t parser; pm_parser_init(&parser, pm_string_source(input), pm_string_length(input), options); pm_node_t *node = pm_parse(&parser); rb_encoding *encoding = rb_enc_find(parser.encoding->name); VALUE source = pm_source_new(&parser, encoding, options->freeze); VALUE value = pm_ast_new(&parser, node, encoding, source, options->freeze); VALUE result = parse_result_create(rb_cPrismParseResult, &parser, value, encoding, source, options->freeze); if (options->freeze) { rb_obj_freeze(source); } pm_node_destroy(&parser, node); pm_parser_free(&parser); return result; } /** * call-seq: * Prism::parse(source, **options) -> ParseResult * * Parse the given string and return a ParseResult instance. The options that * are supported are: * * * `command_line` - either nil or a string of the various options that were * set on the command line. Valid values are combinations of "a", "l", * "n", "p", and "x". * * `encoding` - the encoding of the source being parsed. This should be an * encoding or nil. * * `filepath` - the filepath of the source being parsed. This should be a * string or nil. * * `freeze` - whether or not to deeply freeze the AST. This should be a * boolean or nil. * * `frozen_string_literal` - whether or not the frozen string literal pragma * has been set. This should be a boolean or nil. * * `line` - the line number that the parse starts on. This should be an * integer or nil. Note that this is 1-indexed. * * `main_script` - a boolean indicating whether or not the source being parsed * is the main script being run by the interpreter. This controls whether * or not shebangs are parsed for additional flags and whether or not the * parser will attempt to find a matching shebang if the first one does * not contain the word "ruby". * * `partial_script` - when the file being parsed is considered a "partial" * script, jumps will not be marked as errors if they are not contained * within loops/blocks. This is used in the case that you're parsing a * script that you know will be embedded inside another script later, but * you do not have that context yet. For example, when parsing an ERB * template that will be evaluated inside another script. * * `scopes` - the locals that are in scope surrounding the code that is being * parsed. This should be an array of arrays of symbols or nil. Scopes are * ordered from the outermost scope to the innermost one. * * `version` - the version of Ruby syntax that prism should used to parse Ruby * code. By default prism assumes you want to parse with the latest * version of Ruby syntax (which you can trigger with `nil` or * `"latest"`). You may also restrict the syntax to a specific version of * Ruby, e.g., with `"3.3.0"`. To parse with the same syntax version that * the current Ruby is running use `version: RUBY_VERSION`. Raises * ArgumentError if the version is not currently supported by Prism. */ static VALUE parse(int argc, VALUE *argv, VALUE self) { pm_string_t input; pm_options_t options = { 0 }; string_options(argc, argv, &input, &options); #ifdef PRISM_BUILD_DEBUG size_t length = pm_string_length(&input); char* dup = xmalloc(length); memcpy(dup, pm_string_source(&input), length); pm_string_constant_init(&input, dup, length); #endif VALUE value = parse_input(&input, &options); #ifdef PRISM_BUILD_DEBUG xfree(dup); #endif pm_string_free(&input); pm_options_free(&options); return value; } /** * call-seq: * Prism::parse_file(filepath, **options) -> ParseResult * * Parse the given file and return a ParseResult instance. For supported * options, see Prism::parse. */ static VALUE parse_file(int argc, VALUE *argv, VALUE self) { pm_string_t input; pm_options_t options = { 0 }; VALUE encoded_filepath; file_options(argc, argv, &input, &options, &encoded_filepath); VALUE value = parse_input(&input, &options); pm_string_free(&input); pm_options_free(&options); return value; } /** * Parse the given input and return nothing. */ static void profile_input(pm_string_t *input, const pm_options_t *options) { pm_parser_t parser; pm_parser_init(&parser, pm_string_source(input), pm_string_length(input), options); pm_node_t *node = pm_parse(&parser); pm_node_destroy(&parser, node); pm_parser_free(&parser); } /** * call-seq: * Prism::profile(source, **options) -> nil * * Parse the given string and return nothing. This method is meant to allow * profilers to avoid the overhead of reifying the AST to Ruby. For supported * options, see Prism::parse. */ static VALUE profile(int argc, VALUE *argv, VALUE self) { pm_string_t input; pm_options_t options = { 0 }; string_options(argc, argv, &input, &options); profile_input(&input, &options); pm_string_free(&input); pm_options_free(&options); return Qnil; } /** * call-seq: * Prism::profile_file(filepath, **options) -> nil * * Parse the given file and return nothing. This method is meant to allow * profilers to avoid the overhead of reifying the AST to Ruby. For supported * options, see Prism::parse. */ static VALUE profile_file(int argc, VALUE *argv, VALUE self) { pm_string_t input; pm_options_t options = { 0 }; VALUE encoded_filepath; file_options(argc, argv, &input, &options, &encoded_filepath); profile_input(&input, &options); pm_string_free(&input); pm_options_free(&options); return Qnil; } static int parse_stream_eof(void *stream) { if (rb_funcall((VALUE) stream, rb_intern("eof?"), 0)) { return 1; } return 0; } /** * An implementation of fgets that is suitable for use with Ruby IO objects. */ static char * parse_stream_fgets(char *string, int size, void *stream) { RUBY_ASSERT(size > 0); VALUE line = rb_funcall((VALUE) stream, rb_intern("gets"), 1, INT2FIX(size - 1)); if (NIL_P(line)) { return NULL; } const char *cstr = RSTRING_PTR(line); long length = RSTRING_LEN(line); memcpy(string, cstr, length); string[length] = '\0'; return string; } /** * call-seq: * Prism::parse_stream(stream, **options) -> ParseResult * * Parse the given object that responds to `gets` and return a ParseResult * instance. The options that are supported are the same as Prism::parse. */ static VALUE parse_stream(int argc, VALUE *argv, VALUE self) { VALUE stream; VALUE keywords; rb_scan_args(argc, argv, "1:", &stream, &keywords); pm_options_t options = { 0 }; extract_options(&options, Qnil, keywords); pm_parser_t parser; pm_buffer_t buffer; pm_node_t *node = pm_parse_stream(&parser, &buffer, (void *) stream, parse_stream_fgets, parse_stream_eof, &options); rb_encoding *encoding = rb_enc_find(parser.encoding->name); VALUE source = pm_source_new(&parser, encoding, options.freeze); VALUE value = pm_ast_new(&parser, node, encoding, source, options.freeze); VALUE result = parse_result_create(rb_cPrismParseResult, &parser, value, encoding, source, options.freeze); pm_node_destroy(&parser, node); pm_buffer_free(&buffer); pm_parser_free(&parser); return result; } /** * Parse the given input and return an array of Comment objects. */ static VALUE parse_input_comments(pm_string_t *input, const pm_options_t *options) { pm_parser_t parser; pm_parser_init(&parser, pm_string_source(input), pm_string_length(input), options); pm_node_t *node = pm_parse(&parser); rb_encoding *encoding = rb_enc_find(parser.encoding->name); VALUE source = pm_source_new(&parser, encoding, options->freeze); VALUE comments = parser_comments(&parser, source, options->freeze); pm_node_destroy(&parser, node); pm_parser_free(&parser); return comments; } /** * call-seq: * Prism::parse_comments(source, **options) -> Array * * Parse the given string and return an array of Comment objects. For supported * options, see Prism::parse. */ static VALUE parse_comments(int argc, VALUE *argv, VALUE self) { pm_string_t input; pm_options_t options = { 0 }; string_options(argc, argv, &input, &options); VALUE result = parse_input_comments(&input, &options); pm_string_free(&input); pm_options_free(&options); return result; } /** * call-seq: * Prism::parse_file_comments(filepath, **options) -> Array * * Parse the given file and return an array of Comment objects. For supported * options, see Prism::parse. */ static VALUE parse_file_comments(int argc, VALUE *argv, VALUE self) { pm_string_t input; pm_options_t options = { 0 }; VALUE encoded_filepath; file_options(argc, argv, &input, &options, &encoded_filepath); VALUE value = parse_input_comments(&input, &options); pm_string_free(&input); pm_options_free(&options); return value; } /** * call-seq: * Prism::parse_lex(source, **options) -> ParseLexResult * * Parse the given string and return a ParseLexResult instance that contains a * 2-element array, where the first element is the AST and the second element is * an array of Token instances. * * This API is only meant to be used in the case where you need both the AST and * the tokens. If you only need one or the other, use either Prism::parse or * Prism::lex. * * For supported options, see Prism::parse. */ static VALUE parse_lex(int argc, VALUE *argv, VALUE self) { pm_string_t input; pm_options_t options = { 0 }; string_options(argc, argv, &input, &options); VALUE value = parse_lex_input(&input, &options, true); pm_string_free(&input); pm_options_free(&options); return value; } /** * call-seq: * Prism::parse_lex_file(filepath, **options) -> ParseLexResult * * Parse the given file and return a ParseLexResult instance that contains a * 2-element array, where the first element is the AST and the second element is * an array of Token instances. * * This API is only meant to be used in the case where you need both the AST and * the tokens. If you only need one or the other, use either Prism::parse_file * or Prism::lex_file. * * For supported options, see Prism::parse. */ static VALUE parse_lex_file(int argc, VALUE *argv, VALUE self) { pm_string_t input; pm_options_t options = { 0 }; VALUE encoded_filepath; file_options(argc, argv, &input, &options, &encoded_filepath); VALUE value = parse_lex_input(&input, &options, true); pm_string_free(&input); pm_options_free(&options); return value; } /** * Parse the given input and return true if it parses without errors. */ static VALUE parse_input_success_p(pm_string_t *input, const pm_options_t *options) { pm_parser_t parser; pm_parser_init(&parser, pm_string_source(input), pm_string_length(input), options); pm_node_t *node = pm_parse(&parser); pm_node_destroy(&parser, node); VALUE result = parser.error_list.size == 0 ? Qtrue : Qfalse; pm_parser_free(&parser); return result; } /** * call-seq: * Prism::parse_success?(source, **options) -> bool * * Parse the given string and return true if it parses without errors. For * supported options, see Prism::parse. */ static VALUE parse_success_p(int argc, VALUE *argv, VALUE self) { pm_string_t input; pm_options_t options = { 0 }; string_options(argc, argv, &input, &options); VALUE result = parse_input_success_p(&input, &options); pm_string_free(&input); pm_options_free(&options); return result; } /** * call-seq: * Prism::parse_failure?(source, **options) -> bool * * Parse the given string and return true if it parses with errors. For * supported options, see Prism::parse. */ static VALUE parse_failure_p(int argc, VALUE *argv, VALUE self) { return RTEST(parse_success_p(argc, argv, self)) ? Qfalse : Qtrue; } /** * call-seq: * Prism::parse_file_success?(filepath, **options) -> bool * * Parse the given file and return true if it parses without errors. For * supported options, see Prism::parse. */ static VALUE parse_file_success_p(int argc, VALUE *argv, VALUE self) { pm_string_t input; pm_options_t options = { 0 }; VALUE encoded_filepath; file_options(argc, argv, &input, &options, &encoded_filepath); VALUE result = parse_input_success_p(&input, &options); pm_string_free(&input); pm_options_free(&options); return result; } /** * call-seq: * Prism::parse_file_failure?(filepath, **options) -> bool * * Parse the given file and return true if it parses with errors. For * supported options, see Prism::parse. */ static VALUE parse_file_failure_p(int argc, VALUE *argv, VALUE self) { return RTEST(parse_file_success_p(argc, argv, self)) ? Qfalse : Qtrue; } /******************************************************************************/ /* String query methods */ /******************************************************************************/ /** * Process the result of a call to a string query method and return an * appropriate value. */ static VALUE string_query(pm_string_query_t result) { switch (result) { case PM_STRING_QUERY_ERROR: rb_raise(rb_eArgError, "Invalid or non ascii-compatible encoding"); return Qfalse; case PM_STRING_QUERY_FALSE: return Qfalse; case PM_STRING_QUERY_TRUE: return Qtrue; } return Qfalse; } /** * call-seq: * Prism::StringQuery::local?(string) -> bool * * Returns true if the string constitutes a valid local variable name. Note that * this means the names that can be set through Binding#local_variable_set, not * necessarily the ones that can be set through a local variable assignment. */ static VALUE string_query_local_p(VALUE self, VALUE string) { const uint8_t *source = (const uint8_t *) check_string(string); return string_query(pm_string_query_local(source, RSTRING_LEN(string), rb_enc_get(string)->name)); } /** * call-seq: * Prism::StringQuery::constant?(string) -> bool * * Returns true if the string constitutes a valid constant name. Note that this * means the names that can be set through Module#const_set, not necessarily the * ones that can be set through a constant assignment. */ static VALUE string_query_constant_p(VALUE self, VALUE string) { const uint8_t *source = (const uint8_t *) check_string(string); return string_query(pm_string_query_constant(source, RSTRING_LEN(string), rb_enc_get(string)->name)); } /** * call-seq: * Prism::StringQuery::method_name?(string) -> bool * * Returns true if the string constitutes a valid method name. */ static VALUE string_query_method_name_p(VALUE self, VALUE string) { const uint8_t *source = (const uint8_t *) check_string(string); return string_query(pm_string_query_method_name(source, RSTRING_LEN(string), rb_enc_get(string)->name)); } /******************************************************************************/ /* Initialization of the extension */ /******************************************************************************/ /** * The init function that Ruby calls when loading this extension. */ RUBY_FUNC_EXPORTED void Init_prism(void) { // Make sure that the prism library version matches the expected version. // Otherwise something was compiled incorrectly. if (strcmp(pm_version(), EXPECTED_PRISM_VERSION) != 0) { rb_raise( rb_eRuntimeError, "The prism library version (%s) does not match the expected version (%s)", pm_version(), EXPECTED_PRISM_VERSION ); } #ifdef HAVE_RB_EXT_RACTOR_SAFE // Mark this extension as Ractor-safe. rb_ext_ractor_safe(true); #endif // Grab up references to all of the constants that we're going to need to // reference throughout this extension. rb_cPrism = rb_define_module("Prism"); rb_cPrismNode = rb_define_class_under(rb_cPrism, "Node", rb_cObject); rb_cPrismSource = rb_define_class_under(rb_cPrism, "Source", rb_cObject); rb_cPrismToken = rb_define_class_under(rb_cPrism, "Token", rb_cObject); rb_cPrismLocation = rb_define_class_under(rb_cPrism, "Location", rb_cObject); rb_cPrismComment = rb_define_class_under(rb_cPrism, "Comment", rb_cObject); rb_cPrismInlineComment = rb_define_class_under(rb_cPrism, "InlineComment", rb_cPrismComment); rb_cPrismEmbDocComment = rb_define_class_under(rb_cPrism, "EmbDocComment", rb_cPrismComment); rb_cPrismMagicComment = rb_define_class_under(rb_cPrism, "MagicComment", rb_cObject); rb_cPrismParseError = rb_define_class_under(rb_cPrism, "ParseError", rb_cObject); rb_cPrismParseWarning = rb_define_class_under(rb_cPrism, "ParseWarning", rb_cObject); rb_cPrismResult = rb_define_class_under(rb_cPrism, "Result", rb_cObject); rb_cPrismParseResult = rb_define_class_under(rb_cPrism, "ParseResult", rb_cPrismResult); rb_cPrismLexResult = rb_define_class_under(rb_cPrism, "LexResult", rb_cPrismResult); rb_cPrismParseLexResult = rb_define_class_under(rb_cPrism, "ParseLexResult", rb_cPrismResult); rb_cPrismStringQuery = rb_define_class_under(rb_cPrism, "StringQuery", rb_cObject); rb_cPrismScope = rb_define_class_under(rb_cPrism, "Scope", rb_cObject); // Intern all of the IDs eagerly that we support so that we don't have to do // it every time we parse. rb_id_option_command_line = rb_intern_const("command_line"); rb_id_option_encoding = rb_intern_const("encoding"); rb_id_option_filepath = rb_intern_const("filepath"); rb_id_option_freeze = rb_intern_const("freeze"); rb_id_option_frozen_string_literal = rb_intern_const("frozen_string_literal"); rb_id_option_line = rb_intern_const("line"); rb_id_option_main_script = rb_intern_const("main_script"); rb_id_option_partial_script = rb_intern_const("partial_script"); rb_id_option_scopes = rb_intern_const("scopes"); rb_id_option_version = rb_intern_const("version"); rb_id_source_for = rb_intern("for"); rb_id_forwarding_positionals = rb_intern("*"); rb_id_forwarding_keywords = rb_intern("**"); rb_id_forwarding_block = rb_intern("&"); rb_id_forwarding_all = rb_intern("..."); /** * The version of the prism library. */ rb_define_const(rb_cPrism, "VERSION", rb_str_freeze(rb_str_new_cstr(EXPECTED_PRISM_VERSION))); // First, the functions that have to do with lexing and parsing. rb_define_singleton_method(rb_cPrism, "lex", lex, -1); rb_define_singleton_method(rb_cPrism, "lex_file", lex_file, -1); rb_define_singleton_method(rb_cPrism, "parse", parse, -1); rb_define_singleton_method(rb_cPrism, "parse_file", parse_file, -1); rb_define_singleton_method(rb_cPrism, "profile", profile, -1); rb_define_singleton_method(rb_cPrism, "profile_file", profile_file, -1); rb_define_singleton_method(rb_cPrism, "parse_stream", parse_stream, -1); rb_define_singleton_method(rb_cPrism, "parse_comments", parse_comments, -1); rb_define_singleton_method(rb_cPrism, "parse_file_comments", parse_file_comments, -1); rb_define_singleton_method(rb_cPrism, "parse_lex", parse_lex, -1); rb_define_singleton_method(rb_cPrism, "parse_lex_file", parse_lex_file, -1); rb_define_singleton_method(rb_cPrism, "parse_success?", parse_success_p, -1); rb_define_singleton_method(rb_cPrism, "parse_failure?", parse_failure_p, -1); rb_define_singleton_method(rb_cPrism, "parse_file_success?", parse_file_success_p, -1); rb_define_singleton_method(rb_cPrism, "parse_file_failure?", parse_file_failure_p, -1); #ifndef PRISM_EXCLUDE_SERIALIZATION rb_define_singleton_method(rb_cPrism, "dump", dump, -1); rb_define_singleton_method(rb_cPrism, "dump_file", dump_file, -1); #endif rb_define_singleton_method(rb_cPrismStringQuery, "local?", string_query_local_p, 1); rb_define_singleton_method(rb_cPrismStringQuery, "constant?", string_query_constant_p, 1); rb_define_singleton_method(rb_cPrismStringQuery, "method_name?", string_query_method_name_p, 1); // Next, initialize the other APIs. Init_prism_api_node(); Init_prism_pack(); } prism-1.5.1/ext/prism/extension.h000066400000000000000000000012021506127434000167640ustar00rootroot00000000000000#ifndef PRISM_EXT_NODE_H #define PRISM_EXT_NODE_H #define EXPECTED_PRISM_VERSION "1.5.1" #include #include #include "prism.h" VALUE pm_source_new(const pm_parser_t *parser, rb_encoding *encoding, bool freeze); VALUE pm_token_new(const pm_parser_t *parser, const pm_token_t *token, rb_encoding *encoding, VALUE source, bool freeze); VALUE pm_ast_new(const pm_parser_t *parser, const pm_node_t *node, rb_encoding *encoding, VALUE source, bool freeze); VALUE pm_integer_new(const pm_integer_t *integer); void Init_prism_api_node(void); void Init_prism_pack(void); RUBY_FUNC_EXPORTED void Init_prism(void); #endif prism-1.5.1/fuzz/000077500000000000000000000000001506127434000136505ustar00rootroot00000000000000prism-1.5.1/fuzz/asan.ignore000066400000000000000000000001461506127434000160000ustar00rootroot00000000000000# for now, we ignore the encoding functions as they # can read out of bounds [address] src:src/enc/* prism-1.5.1/fuzz/corpus/000077500000000000000000000000001506127434000151635ustar00rootroot00000000000000prism-1.5.1/fuzz/corpus/parse000077700000000000000000000000001506127434000225462../../test/prism/fixturesustar00rootroot00000000000000prism-1.5.1/fuzz/corpus/regexp/000077500000000000000000000000001506127434000164555ustar00rootroot00000000000000prism-1.5.1/fuzz/corpus/regexp/1000066400000000000000000000000141506127434000165330ustar00rootroot00000000000000(?#comment) prism-1.5.1/fuzz/corpus/regexp/2000066400000000000000000000000111506127434000165310ustar00rootroot00000000000000(?:abcd) prism-1.5.1/fuzz/corpus/regexp/3000066400000000000000000000000131506127434000165340ustar00rootroot00000000000000(?:subexp) prism-1.5.1/fuzz/corpus/regexp/4000066400000000000000000000000231506127434000165360ustar00rootroot00000000000000!"£$%^&*()/adfas" prism-1.5.1/fuzz/corpus/regexp/6000066400000000000000000000000101506127434000165340ustar00rootroot00000000000000word| ) prism-1.5.1/fuzz/corpus/unescape/000077500000000000000000000000001506127434000167665ustar00rootroot00000000000000prism-1.5.1/fuzz/corpus/unescape/1000066400000000000000000000000051506127434000170440ustar00rootroot00000000000000\r\n prism-1.5.1/fuzz/corpus/unescape/2000066400000000000000000000000101506127434000170410ustar00rootroot00000000000000\\\"\\' prism-1.5.1/fuzz/corpus/unescape/3000066400000000000000000000000101506127434000170420ustar00rootroot00000000000000\b\0000 prism-1.5.1/fuzz/dict000066400000000000000000000006301506127434000145150ustar00rootroot00000000000000# strings from lex_identifier "!" "?" "|" "=" "==" ":" "defined?" "<<" "~" ">" "<" "!=" "{" "}" "[" "]" "do" "if" "in" "or" "and" "def" "end" "END" "for" "nil" "not" "case" "else" "next" "redo" "self" "then" "true" "when" "alias" "begin" "BEGIN" "break" "class" "elsif" "false" "retry" "super" "undef" "until" "while" "yield" "ensure" "module" "rescue" "return" "unless" "__LINE__" "__FILE__" "__ENCODING__" prism-1.5.1/fuzz/docker/000077500000000000000000000000001506127434000151175ustar00rootroot00000000000000prism-1.5.1/fuzz/docker/Dockerfile000066400000000000000000000024651506127434000171200ustar00rootroot00000000000000FROM aflplusplus/aflplusplus ARG USERNAME=prism ARG USER_UID=1000 ARG USER_GID=$USER_UID ENV MAKEFLAGS=-j8 RUN groupadd --gid $USER_GID $USERNAME \ && useradd --uid $USER_UID --gid $USER_GID -m $USERNAME \ && apt update && apt install -y sudo \ && echo $USERNAME ALL=\(root\) NOPASSWD:ALL > /etc/sudoers.d/$USERNAME \ && chmod 0440 /etc/sudoers.d/$USERNAME RUN wget https://cache.ruby-lang.org/pub/ruby/3.2/ruby-3.2.2.tar.gz RUN tar -xvf ruby-3.2.2.tar.gz RUN apt update && apt -y install libyaml-dev libz-dev libssl-dev RUN cd ruby-3.2.2 && ./configure --disable-install-doc && make && make install RUN gem install rake-compiler ruby_memcheck RUN git clone https://github.com/pwndbg/pwndbg && cd pwndbg && ./setup.sh ENV LC_CTYPE=C.UTF-8 RUN apt install -y libglib2.0-dev bsdmainutils RUN git clone https://github.com/googleprojectzero/halfempty RUN cd halfempty && make && cp halfempty /usr/bin/ RUN apt install -y valgrind uuid-dev default-jre python3 unzip RUN wget https://www.antlr.org/download/antlr-4.8-complete.jar \ && cp -f antlr-4.8-complete.jar /usr/local/lib RUN git clone https://github.com/AFLplusplus/Grammar-Mutator RUN cd Grammar-Mutator && make GRAMMAR_FILE=grammars/ruby.json && \ cp libgrammarmutator-ruby.so /usr/local/lib RUN apt install -y screen USER $USERNAME WORKDIR /prism prism-1.5.1/fuzz/fuzz.c000066400000000000000000000003221506127434000150070ustar00rootroot00000000000000#include #include void harness(const uint8_t *input, size_t size); int LLVMFuzzerTestOneInput(const char *data, size_t size) { harness((const uint8_t *) data, size); return 0; } prism-1.5.1/fuzz/heisenbug.c000066400000000000000000000011131506127434000157610ustar00rootroot00000000000000#include #include #include #include void harness(const uint8_t *input, size_t size); int LLVMFuzzerTestOneInput(const char *input, size_t size) { char *mutation_buffer = malloc(size + 1); assert(mutation_buffer); memcpy(mutation_buffer, input, size); // try all possible trailing bytes to see if it triggers // the bug for (unsigned int i = 0; i < UINT8_MAX; i++) { mutation_buffer[size] = (char) i; harness((const uint8_t *) mutation_buffer, size); } free(mutation_buffer); return 0; } prism-1.5.1/fuzz/parse.c000066400000000000000000000003161506127434000151260ustar00rootroot00000000000000#include void harness(const uint8_t *input, size_t size) { pm_buffer_t buffer; pm_buffer_init(&buffer); pm_serialize_parse(&buffer, input, size, NULL); pm_buffer_free(&buffer); } prism-1.5.1/fuzz/parse.sh000077500000000000000000000007001506127434000153160ustar00rootroot00000000000000#!/bin/bash OUTPUT_DIR=$1 screen -S grammar_fuzzer -d -m /bin/bash -c "AFL_CUSTOM_MUTATOR_LIBRARY=/usr/local/lib/libgrammarmutator-ruby.so AFL_CUSTOM_MUTATOR_ONLY=1 afl-fuzz -i fuzz/corpus/parse -o $OUTPUT_DIR -S grammar -- ./build/fuzz.parse" screen -S main_fuzzer -m /bin/bash -c "afl-fuzz -x ./fuzz/dict -G 500 -c ./build/fuzz.parse.cmplog -i ./fuzz/corpus/parse -M main_parse -o $OUTPUT_DIR ./build/fuzz.parse || read -n 1" exec /bin/bash prism-1.5.1/fuzz/regexp.c000066400000000000000000000007551506127434000153150ustar00rootroot00000000000000#include void regexp_name_callback(const pm_string_t *name, void *data) { // Do nothing } void regexp_error_callback(const uint8_t *start, const uint8_t *end, const char *message, void *data) { // Do nothing } void harness(const uint8_t *input, size_t size) { pm_parser_t parser; pm_parser_init(&parser, input, size, NULL); pm_regexp_parse(&parser, input, size, false, regexp_name_callback, NULL, regexp_error_callback, NULL); pm_parser_free(&parser); } prism-1.5.1/fuzz/regexp.sh000077500000000000000000000002071506127434000155000ustar00rootroot00000000000000#!/bin/bash OUTPUT_DIR=$1 afl-fuzz -G 100 -c ./build/fuzz.regexp.cmplog -i ./fuzz/corpus/regexp -o "$OUTPUT_DIR" ./build/fuzz.regexp prism-1.5.1/fuzz/tools/000077500000000000000000000000001506127434000150105ustar00rootroot00000000000000prism-1.5.1/fuzz/tools/backtrace.sh000077500000000000000000000006461506127434000172740ustar00rootroot00000000000000#!/bin/bash CRASH_DIR=$1 [ "$(basename $CRASH_DIR)" = "crashes" ] || { echo "Must be a crash directory" >&2 exit 1 } executable=/prism/build/fuzz."$(basename $(dirname $(dirname $CRASH_DIR)))" for crash in $(find "$CRASH_DIR" -type f ! -name "*.bt" ! -name "*.md") do echo "Generating backtrace for $crash" gdb --batch -ex "b __asan::ReportGenericError" -ex "run $crash" -ex "bt" "$executable" &> "$crash".bt done prism-1.5.1/fuzz/tools/minimize.sh000077500000000000000000000005311506127434000171670ustar00rootroot00000000000000#!/bin/bash DIR=$1 flags="" [ "$(basename $DIR)" = "hangs" ] && { flags="-H" } executable=/prism/build/fuzz."$(basename $(dirname $(dirname $DIR)))" for file in $(find "$DIR" -type f ! -name "*.*") do echo "Minimizing $file: this may take a long time" AFL_TMIN_EXACT=1 afl-tmin $flags -i "$file" -o "${file}.min" -- "$executable" done prism-1.5.1/gemfiles/000077500000000000000000000000001506127434000144455ustar00rootroot00000000000000prism-1.5.1/gemfiles/2.7/000077500000000000000000000000001506127434000147535ustar00rootroot00000000000000prism-1.5.1/gemfiles/2.7/Gemfile000066400000000000000000000003131506127434000162430ustar00rootroot00000000000000# frozen_string_literal: true source "https://rubygems.org" ruby "~> 2.7.0" gemspec path: "../.." gem "onigmo", platforms: :ruby gem "parser" gem "rake-compiler" gem "rake" gem "rbs" gem "test-unit" prism-1.5.1/gemfiles/2.7/Gemfile.lock000066400000000000000000000007531506127434000172020ustar00rootroot00000000000000PATH remote: ../.. specs: prism (1.5.1) GEM remote: https://rubygems.org/ specs: ast (2.4.3) onigmo (0.1.0) parser (3.3.9.0) ast (~> 2.4.1) racc power_assert (2.0.5) racc (1.8.1) rake (13.3.0) rake-compiler (1.3.0) rake rbs (3.1.3) test-unit (3.7.0) power_assert PLATFORMS ruby DEPENDENCIES onigmo parser prism! rake rake-compiler rbs test-unit RUBY VERSION ruby 2.7.8p225 BUNDLED WITH 2.1.4 prism-1.5.1/gemfiles/3.0/000077500000000000000000000000001506127434000147455ustar00rootroot00000000000000prism-1.5.1/gemfiles/3.0/Gemfile000066400000000000000000000003371506127434000162430ustar00rootroot00000000000000# frozen_string_literal: true source "https://rubygems.org" ruby "~> 3.0.0" gemspec path: "../.." gem "onigmo", platforms: :ruby gem "parser" gem "rake-compiler" gem "rake" gem "rbs" gem "ruby_memcheck" gem "test-unit" prism-1.5.1/gemfiles/3.0/Gemfile.lock000066400000000000000000000012501506127434000171650ustar00rootroot00000000000000PATH remote: ../.. specs: prism (1.5.1) GEM remote: https://rubygems.org/ specs: ast (2.4.3) logger (1.6.1) mini_portile2 (2.8.8) nokogiri (1.17.2) mini_portile2 (~> 2.8.2) racc (~> 1.4) onigmo (0.1.0) parser (3.3.9.0) ast (~> 2.4.1) racc power_assert (2.0.5) racc (1.8.1) rake (13.3.0) rake-compiler (1.3.0) rake rbs (3.6.1) logger ruby_memcheck (3.0.1) nokogiri test-unit (3.7.0) power_assert PLATFORMS ruby DEPENDENCIES onigmo parser prism! rake rake-compiler rbs ruby_memcheck test-unit RUBY VERSION ruby 3.0.6p216 BUNDLED WITH 2.2.33 prism-1.5.1/gemfiles/3.1/000077500000000000000000000000001506127434000147465ustar00rootroot00000000000000prism-1.5.1/gemfiles/3.1/Gemfile000066400000000000000000000003371506127434000162440ustar00rootroot00000000000000# frozen_string_literal: true source "https://rubygems.org" ruby "~> 3.1.0" gemspec path: "../.." gem "onigmo", platforms: :ruby gem "parser" gem "rake-compiler" gem "rake" gem "rbs" gem "ruby_memcheck" gem "test-unit" prism-1.5.1/gemfiles/3.1/Gemfile.lock000066400000000000000000000012501506127434000171660ustar00rootroot00000000000000PATH remote: ../.. specs: prism (1.5.1) GEM remote: https://rubygems.org/ specs: ast (2.4.3) logger (1.7.0) mini_portile2 (2.8.9) nokogiri (1.18.9) mini_portile2 (~> 2.8.2) racc (~> 1.4) onigmo (0.1.0) parser (3.3.9.0) ast (~> 2.4.1) racc power_assert (2.0.5) racc (1.8.1) rake (13.3.0) rake-compiler (1.3.0) rake rbs (3.9.5) logger ruby_memcheck (3.0.1) nokogiri test-unit (3.7.0) power_assert PLATFORMS ruby DEPENDENCIES onigmo parser prism! rake rake-compiler rbs ruby_memcheck test-unit RUBY VERSION ruby 3.1.4p223 BUNDLED WITH 2.3.27 prism-1.5.1/gemfiles/3.2/000077500000000000000000000000001506127434000147475ustar00rootroot00000000000000prism-1.5.1/gemfiles/3.2/Gemfile000066400000000000000000000003371506127434000162450ustar00rootroot00000000000000# frozen_string_literal: true source "https://rubygems.org" ruby "~> 3.2.0" gemspec path: "../.." gem "onigmo", platforms: :ruby gem "parser" gem "rake-compiler" gem "rake" gem "rbs" gem "ruby_memcheck" gem "test-unit" prism-1.5.1/gemfiles/3.2/Gemfile.lock000066400000000000000000000012501506127434000171670ustar00rootroot00000000000000PATH remote: ../.. specs: prism (1.5.1) GEM remote: https://rubygems.org/ specs: ast (2.4.3) logger (1.7.0) mini_portile2 (2.8.9) nokogiri (1.18.9) mini_portile2 (~> 2.8.2) racc (~> 1.4) onigmo (0.1.0) parser (3.3.9.0) ast (~> 2.4.1) racc power_assert (2.0.5) racc (1.8.1) rake (13.3.0) rake-compiler (1.3.0) rake rbs (3.9.5) logger ruby_memcheck (3.0.1) nokogiri test-unit (3.7.0) power_assert PLATFORMS ruby DEPENDENCIES onigmo parser prism! rake rake-compiler rbs ruby_memcheck test-unit RUBY VERSION ruby 3.2.3p157 BUNDLED WITH 2.4.19 prism-1.5.1/gemfiles/3.3/000077500000000000000000000000001506127434000147505ustar00rootroot00000000000000prism-1.5.1/gemfiles/3.3/Gemfile000066400000000000000000000003371506127434000162460ustar00rootroot00000000000000# frozen_string_literal: true source "https://rubygems.org" ruby "~> 3.3.0" gemspec path: "../.." gem "onigmo", platforms: :ruby gem "parser" gem "rake-compiler" gem "rake" gem "rbs" gem "ruby_memcheck" gem "test-unit" prism-1.5.1/gemfiles/3.3/Gemfile.lock000066400000000000000000000012461506127434000171750ustar00rootroot00000000000000PATH remote: ../.. specs: prism (1.5.1) GEM remote: https://rubygems.org/ specs: ast (2.4.3) logger (1.7.0) mini_portile2 (2.8.9) nokogiri (1.18.9) mini_portile2 (~> 2.8.2) racc (~> 1.4) onigmo (0.1.0) parser (3.3.9.0) ast (~> 2.4.1) racc power_assert (2.0.5) racc (1.8.1) rake (13.3.0) rake-compiler (1.3.0) rake rbs (3.9.5) logger ruby_memcheck (3.0.1) nokogiri test-unit (3.7.0) power_assert PLATFORMS ruby DEPENDENCIES onigmo parser prism! rake rake-compiler rbs ruby_memcheck test-unit RUBY VERSION ruby 3.3.0p0 BUNDLED WITH 2.5.16 prism-1.5.1/gemfiles/3.4/000077500000000000000000000000001506127434000147515ustar00rootroot00000000000000prism-1.5.1/gemfiles/3.4/Gemfile000066400000000000000000000003371506127434000162470ustar00rootroot00000000000000# frozen_string_literal: true source "https://rubygems.org" ruby "~> 3.4.0" gemspec path: "../.." gem "onigmo", platforms: :ruby gem "parser" gem "rake-compiler" gem "rake" gem "rbs" gem "ruby_memcheck" gem "test-unit" prism-1.5.1/gemfiles/3.4/Gemfile.lock000066400000000000000000000012451506127434000171750ustar00rootroot00000000000000PATH remote: ../.. specs: prism (1.5.1) GEM remote: https://rubygems.org/ specs: ast (2.4.3) logger (1.7.0) mini_portile2 (2.8.9) nokogiri (1.18.9) mini_portile2 (~> 2.8.2) racc (~> 1.4) onigmo (0.1.0) parser (3.3.9.0) ast (~> 2.4.1) racc power_assert (2.0.5) racc (1.8.1) rake (13.3.0) rake-compiler (1.3.0) rake rbs (3.9.5) logger ruby_memcheck (3.0.1) nokogiri test-unit (3.7.0) power_assert PLATFORMS ruby DEPENDENCIES onigmo parser prism! rake rake-compiler rbs ruby_memcheck test-unit RUBY VERSION ruby 3.4.1p0 BUNDLED WITH 2.6.2 prism-1.5.1/gemfiles/3.5/000077500000000000000000000000001506127434000147525ustar00rootroot00000000000000prism-1.5.1/gemfiles/3.5/Gemfile000066400000000000000000000003551506127434000162500ustar00rootroot00000000000000# frozen_string_literal: true source "https://rubygems.org" ruby "~> 3.5.0.dev" gemspec path: "../.." gem "ffi" gem "onigmo", platforms: :ruby gem "parser" gem "rake-compiler" gem "rake" gem "rbs" gem "ruby_memcheck" gem "test-unit" prism-1.5.1/gemfiles/3.5/Gemfile.lock000066400000000000000000000013021506127434000171700ustar00rootroot00000000000000PATH remote: ../.. specs: prism (1.5.1) GEM remote: https://rubygems.org/ specs: ast (2.4.3) ffi (1.17.2) logger (1.7.0) mini_portile2 (2.8.9) nokogiri (1.18.9) mini_portile2 (~> 2.8.2) racc (~> 1.4) onigmo (0.1.0) parser (3.3.9.0) ast (~> 2.4.1) racc power_assert (2.0.5) racc (1.8.1) rake (13.3.0) rake-compiler (1.3.0) rake rbs (3.9.5) logger ruby_memcheck (3.0.1) nokogiri test-unit (3.7.0) power_assert PLATFORMS ruby DEPENDENCIES ffi onigmo parser prism! rake rake-compiler rbs ruby_memcheck test-unit RUBY VERSION ruby 3.5.0.dev BUNDLED WITH 2.7.0.dev prism-1.5.1/gemfiles/jruby/000077500000000000000000000000001506127434000156005ustar00rootroot00000000000000prism-1.5.1/gemfiles/jruby/Gemfile000066400000000000000000000003201506127434000170660ustar00rootroot00000000000000# frozen_string_literal: true source "https://rubygems.org" ruby "~> 3.4.2", engine: "jruby", engine_version: "~> 10.0.0" gemspec path: "../.." gem "parser" gem "rake" gem "rake-compiler" gem "test-unit" prism-1.5.1/gemfiles/jruby/Gemfile.lock000066400000000000000000000011361506127434000200230ustar00rootroot00000000000000PATH remote: ../.. specs: prism (1.5.1) GEM remote: https://rubygems.org/ specs: ast (2.4.3) parser (3.3.9.0) ast (~> 2.4.1) racc power_assert (2.0.5) racc (1.8.1) racc (1.8.1-java) rake (13.3.0) rake-compiler (1.3.0) rake test-unit (3.7.0) power_assert PLATFORMS universal-java-11 universal-java-17 universal-java-20 universal-java-21 universal-java-22 universal-java-23 x86_64-linux DEPENDENCIES parser prism! rake rake-compiler test-unit RUBY VERSION ruby 3.4.2p0 (jruby 10.0.0.0) BUNDLED WITH 2.6.3 prism-1.5.1/gemfiles/truffleruby/000077500000000000000000000000001506127434000170165ustar00rootroot00000000000000prism-1.5.1/gemfiles/truffleruby/Gemfile000066400000000000000000000003261506127434000203120ustar00rootroot00000000000000# frozen_string_literal: true source "https://rubygems.org" ruby "~> 3.3.5", engine: "truffleruby", engine_version: "~> 24.2.0" gemspec path: "../.." gem "parser" gem "rake" gem "rake-compiler" gem "test-unit" prism-1.5.1/gemfiles/truffleruby/Gemfile.lock000066400000000000000000000007151506127434000212430ustar00rootroot00000000000000PATH remote: ../.. specs: prism (1.5.1) GEM remote: https://rubygems.org/ specs: ast (2.4.3) parser (3.3.9.0) ast (~> 2.4.1) racc power_assert (2.0.5) racc (1.8.1) rake (13.3.0) rake-compiler (1.3.0) rake test-unit (3.7.0) power_assert PLATFORMS ruby DEPENDENCIES parser prism! rake rake-compiler test-unit RUBY VERSION ruby 3.3.5p0 (truffleruby 24.2.0) BUNDLED WITH 2.4.19 prism-1.5.1/gemfiles/typecheck/000077500000000000000000000000001506127434000164245ustar00rootroot00000000000000prism-1.5.1/gemfiles/typecheck/Gemfile000066400000000000000000000003361506127434000177210ustar00rootroot00000000000000# frozen_string_literal: true source "https://rubygems.org" gem "minitest" gem "parser" gem "rake-compiler" gem "rake" gem "rbs" gem "ruby_parser" gem "sorbet" gem "steep", ">= 1.7.0.dev.1" gem "tapioca" gem "test-unit" prism-1.5.1/gemfiles/typecheck/Gemfile.lock000066400000000000000000000061471506127434000206560ustar00rootroot00000000000000GEM remote: https://rubygems.org/ specs: activesupport (8.0.2) base64 benchmark (>= 0.3) bigdecimal concurrent-ruby (~> 1.0, >= 1.3.1) connection_pool (>= 2.2.5) drb i18n (>= 1.6, < 2) logger (>= 1.4.2) minitest (>= 5.1) securerandom (>= 0.3) tzinfo (~> 2.0, >= 2.0.5) uri (>= 0.13.1) ast (2.4.3) base64 (0.2.0) benchmark (0.4.0) bigdecimal (3.1.9) concurrent-ruby (1.3.5) connection_pool (2.5.0) csv (3.3.3) drb (2.2.1) erubi (1.13.1) ffi (1.17.2-arm64-darwin) ffi (1.17.2-x86_64-linux-gnu) fileutils (1.7.3) i18n (1.14.7) concurrent-ruby (~> 1.0) json (2.10.2) language_server-protocol (3.17.0.4) listen (3.9.0) rb-fsevent (~> 0.10, >= 0.10.3) rb-inotify (~> 0.9, >= 0.9.10) logger (1.7.0) minitest (5.25.5) mutex_m (0.3.0) netrc (0.11.0) parallel (1.26.3) parser (3.3.9.0) ast (~> 2.4.1) racc power_assert (2.0.5) prism (1.4.0) racc (1.8.1) rainbow (3.1.1) rake (13.3.0) rake-compiler (1.3.0) rake rb-fsevent (0.11.2) rb-inotify (0.11.1) ffi (~> 1.0) rbi (0.3.1) prism (~> 1.0) rbs (>= 3.4.4) sorbet-runtime (>= 0.5.9204) rbs (3.9.5) logger ruby_parser (3.21.1) racc (~> 1.5) sexp_processor (~> 4.16) securerandom (0.4.1) sexp_processor (4.17.3) sorbet (0.6.12495) sorbet-static (= 0.6.12495) sorbet-runtime (0.6.12495) sorbet-static (0.6.12495-universal-darwin) sorbet-static (0.6.12495-x86_64-linux) sorbet-static-and-runtime (0.6.12495) sorbet (= 0.6.12495) sorbet-runtime (= 0.6.12495) spoom (1.6.1) erubi (>= 1.10.0) prism (>= 0.28.0) rbi (>= 0.2.3) sorbet-static-and-runtime (>= 0.5.10187) thor (>= 0.19.2) steep (1.10.0) activesupport (>= 5.1) concurrent-ruby (>= 1.1.10) csv (>= 3.0.9) fileutils (>= 1.1.0) json (>= 2.1.0) language_server-protocol (>= 3.17.0.4, < 4.0) listen (~> 3.0) logger (>= 1.3.0) mutex_m (>= 0.3.0) parser (>= 3.1) rainbow (>= 2.2.2, < 4.0) rbs (~> 3.9) securerandom (>= 0.1) strscan (>= 1.0.0) terminal-table (>= 2, < 5) uri (>= 0.12.0) strscan (3.1.2) tapioca (0.16.11) benchmark bundler (>= 2.2.25) netrc (>= 0.11.0) parallel (>= 1.21.0) rbi (~> 0.2) sorbet-static-and-runtime (>= 0.5.11087) spoom (>= 1.2.0) thor (>= 1.2.0) yard-sorbet terminal-table (4.0.0) unicode-display_width (>= 1.1.1, < 4) test-unit (3.7.0) power_assert thor (1.4.0) tzinfo (2.0.6) concurrent-ruby (~> 1.0) unicode-display_width (3.1.4) unicode-emoji (~> 4.0, >= 4.0.4) unicode-emoji (4.0.4) uri (1.0.3) yard (0.9.37) yard-sorbet (0.9.0) sorbet-runtime yard PLATFORMS arm64-darwin-23 x86_64-linux DEPENDENCIES minitest parser rake rake-compiler rbs ruby_parser sorbet steep (>= 1.7.0.dev.1) tapioca test-unit BUNDLED WITH 2.5.16 prism-1.5.1/include/000077500000000000000000000000001506127434000142755ustar00rootroot00000000000000prism-1.5.1/include/prism.h000066400000000000000000000333331506127434000156050ustar00rootroot00000000000000/** * @file prism.h * * The main header file for the prism parser. */ #ifndef PRISM_H #define PRISM_H #include "prism/defines.h" #include "prism/util/pm_buffer.h" #include "prism/util/pm_char.h" #include "prism/util/pm_integer.h" #include "prism/util/pm_memchr.h" #include "prism/util/pm_strncasecmp.h" #include "prism/util/pm_strpbrk.h" #include "prism/ast.h" #include "prism/diagnostic.h" #include "prism/node.h" #include "prism/options.h" #include "prism/pack.h" #include "prism/parser.h" #include "prism/prettyprint.h" #include "prism/regexp.h" #include "prism/static_literals.h" #include "prism/version.h" #include #include #include #include #include #include #include #include #include #include #ifndef _WIN32 #include #endif /** * The prism version and the serialization format. * * @returns The prism version as a constant string. */ PRISM_EXPORTED_FUNCTION const char * pm_version(void); /** * Initialize a parser with the given start and end pointers. * * The resulting parser must eventually be freed with `pm_parser_free()`. * * @param parser The parser to initialize. * @param source The source to parse. * @param size The size of the source. * @param options The optional options to use when parsing. These options must * live for the whole lifetime of this parser. * * \public \memberof pm_parser */ PRISM_EXPORTED_FUNCTION void pm_parser_init(pm_parser_t *parser, const uint8_t *source, size_t size, const pm_options_t *options); /** * Register a callback that will be called whenever prism changes the encoding * it is using to parse based on the magic comment. * * @param parser The parser to register the callback with. * @param callback The callback to register. * * \public \memberof pm_parser */ PRISM_EXPORTED_FUNCTION void pm_parser_register_encoding_changed_callback(pm_parser_t *parser, pm_encoding_changed_callback_t callback); /** * Free any memory associated with the given parser. * * This does not free the `pm_options_t` object that was used to initialize the * parser. * * @param parser The parser to free. * * \public \memberof pm_parser */ PRISM_EXPORTED_FUNCTION void pm_parser_free(pm_parser_t *parser); /** * Initiate the parser with the given parser. * * @param parser The parser to use. * @return The AST representing the source. * * \public \memberof pm_parser */ PRISM_EXPORTED_FUNCTION pm_node_t * pm_parse(pm_parser_t *parser); /** * This function is used in pm_parse_stream() to retrieve a line of input from a * stream. It closely mirrors that of fgets so that fgets can be used as the * default implementation. */ typedef char * (pm_parse_stream_fgets_t)(char *string, int size, void *stream); /** * This function is used in pm_parse_stream to check whether a stream is EOF. * It closely mirrors that of feof so that feof can be used as the * default implementation. */ typedef int (pm_parse_stream_feof_t)(void *stream); /** * Parse a stream of Ruby source and return the tree. * * @param parser The parser to use. * @param buffer The buffer to use. * @param stream The stream to parse. * @param stream_fgets The function to use to read from the stream. * @param stream_feof The function to use to determine if the stream has hit eof. * @param options The optional options to use when parsing. * @return The AST representing the source. * * \public \memberof pm_parser */ PRISM_EXPORTED_FUNCTION pm_node_t * pm_parse_stream(pm_parser_t *parser, pm_buffer_t *buffer, void *stream, pm_parse_stream_fgets_t *stream_fgets, pm_parse_stream_feof_t *stream_feof, const pm_options_t *options); // We optionally support serializing to a binary string. For systems that don't // want or need this functionality, it can be turned off with the // PRISM_EXCLUDE_SERIALIZATION define. #ifndef PRISM_EXCLUDE_SERIALIZATION /** * Parse and serialize the AST represented by the source that is read out of the * given stream into to the given buffer. * * @param buffer The buffer to serialize to. * @param stream The stream to parse. * @param stream_fgets The function to use to read from the stream. * @param stream_feof The function to use to tell if the stream has hit eof. * @param data The optional data to pass to the parser. */ PRISM_EXPORTED_FUNCTION void pm_serialize_parse_stream(pm_buffer_t *buffer, void *stream, pm_parse_stream_fgets_t *stream_fgets, pm_parse_stream_feof_t *stream_feof, const char *data); /** * Serialize the given list of comments to the given buffer. * * @param parser The parser to serialize. * @param list The list of comments to serialize. * @param buffer The buffer to serialize to. */ void pm_serialize_comment_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer); /** * Serialize the name of the encoding to the buffer. * * @param encoding The encoding to serialize. * @param buffer The buffer to serialize to. */ void pm_serialize_encoding(const pm_encoding_t *encoding, pm_buffer_t *buffer); /** * Serialize the encoding, metadata, nodes, and constant pool. * * @param parser The parser to serialize. * @param node The node to serialize. * @param buffer The buffer to serialize to. */ void pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer); /** * Serialize the AST represented by the given node to the given buffer. * * @param parser The parser to serialize. * @param node The node to serialize. * @param buffer The buffer to serialize to. */ PRISM_EXPORTED_FUNCTION void pm_serialize(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer); /** * Parse the given source to the AST and dump the AST to the given buffer. * * @param buffer The buffer to serialize to. * @param source The source to parse. * @param size The size of the source. * @param data The optional data to pass to the parser. */ PRISM_EXPORTED_FUNCTION void pm_serialize_parse(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data); /** * Parse and serialize the comments in the given source to the given buffer. * * @param buffer The buffer to serialize to. * @param source The source to parse. * @param size The size of the source. * @param data The optional data to pass to the parser. */ PRISM_EXPORTED_FUNCTION void pm_serialize_parse_comments(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data); /** * Lex the given source and serialize to the given buffer. * * @param source The source to lex. * @param size The size of the source. * @param buffer The buffer to serialize to. * @param data The optional data to pass to the lexer. */ PRISM_EXPORTED_FUNCTION void pm_serialize_lex(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data); /** * Parse and serialize both the AST and the tokens represented by the given * source to the given buffer. * * @param buffer The buffer to serialize to. * @param source The source to parse. * @param size The size of the source. * @param data The optional data to pass to the parser. */ PRISM_EXPORTED_FUNCTION void pm_serialize_parse_lex(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data); #endif /** * Parse the source and return true if it parses without errors or warnings. * * @param source The source to parse. * @param size The size of the source. * @param data The optional data to pass to the parser. * @return True if the source parses without errors or warnings. */ PRISM_EXPORTED_FUNCTION bool pm_parse_success_p(const uint8_t *source, size_t size, const char *data); /** * Returns a string representation of the given token type. * * @param token_type The token type to convert to a string. * @return A string representation of the given token type. */ PRISM_EXPORTED_FUNCTION const char * pm_token_type_name(pm_token_type_t token_type); /** * Returns the human name of the given token type. * * @param token_type The token type to convert to a human name. * @return The human name of the given token type. */ const char * pm_token_type_human(pm_token_type_t token_type); // We optionally support dumping to JSON. For systems that don't want or need // this functionality, it can be turned off with the PRISM_EXCLUDE_JSON define. #ifndef PRISM_EXCLUDE_JSON /** * Dump JSON to the given buffer. * * @param buffer The buffer to serialize to. * @param parser The parser that parsed the node. * @param node The node to serialize. */ PRISM_EXPORTED_FUNCTION void pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *node); #endif /** * Represents the results of a slice query. */ typedef enum { /** Returned if the encoding given to a slice query was invalid. */ PM_STRING_QUERY_ERROR = -1, /** Returned if the result of the slice query is false. */ PM_STRING_QUERY_FALSE, /** Returned if the result of the slice query is true. */ PM_STRING_QUERY_TRUE } pm_string_query_t; /** * Check that the slice is a valid local variable name. * * @param source The source to check. * @param length The length of the source. * @param encoding_name The name of the encoding of the source. * @return PM_STRING_QUERY_TRUE if the query is true, PM_STRING_QUERY_FALSE if * the query is false, and PM_STRING_QUERY_ERROR if the encoding was invalid. */ PRISM_EXPORTED_FUNCTION pm_string_query_t pm_string_query_local(const uint8_t *source, size_t length, const char *encoding_name); /** * Check that the slice is a valid constant name. * * @param source The source to check. * @param length The length of the source. * @param encoding_name The name of the encoding of the source. * @return PM_STRING_QUERY_TRUE if the query is true, PM_STRING_QUERY_FALSE if * the query is false, and PM_STRING_QUERY_ERROR if the encoding was invalid. */ PRISM_EXPORTED_FUNCTION pm_string_query_t pm_string_query_constant(const uint8_t *source, size_t length, const char *encoding_name); /** * Check that the slice is a valid method name. * * @param source The source to check. * @param length The length of the source. * @param encoding_name The name of the encoding of the source. * @return PM_STRING_QUERY_TRUE if the query is true, PM_STRING_QUERY_FALSE if * the query is false, and PM_STRING_QUERY_ERROR if the encoding was invalid. */ PRISM_EXPORTED_FUNCTION pm_string_query_t pm_string_query_method_name(const uint8_t *source, size_t length, const char *encoding_name); /** * @mainpage * * Prism is a parser for the Ruby programming language. It is designed to be * portable, error tolerant, and maintainable. It is written in C99 and has no * dependencies. It is currently being integrated into * [CRuby](https://github.com/ruby/ruby), * [JRuby](https://github.com/jruby/jruby), * [TruffleRuby](https://github.com/oracle/truffleruby), * [Sorbet](https://github.com/sorbet/sorbet), and * [Syntax Tree](https://github.com/ruby-syntax-tree/syntax_tree). * * @section getting-started Getting started * * If you're vendoring this project and compiling it statically then as long as * you have a C99 compiler you will be fine. If you're linking against it as * shared library, then you should compile with `-fvisibility=hidden` and * `-DPRISM_EXPORT_SYMBOLS` to tell prism to make only its public interface * visible. * * @section parsing Parsing * * In order to parse Ruby code, the structures and functions that you're going * to want to use and be aware of are: * * * `pm_parser_t` - the main parser structure * * `pm_parser_init()` - initialize a parser * * `pm_parse()` - parse and return the root node * * `pm_node_destroy()` - deallocate the root node returned by `pm_parse()` * * `pm_parser_free()` - free the internal memory of the parser * * Putting all of this together would look something like: * * ```c * void parse(const uint8_t *source, size_t length) { * pm_parser_t parser; * pm_parser_init(&parser, source, length, NULL); * * pm_node_t *root = pm_parse(&parser); * printf("PARSED!\n"); * * pm_node_destroy(&parser, root); * pm_parser_free(&parser); * } * ``` * * All of the nodes "inherit" from `pm_node_t` by embedding those structures * as their first member. This means you can downcast and upcast any node in the * tree to a `pm_node_t`. * * @section serializing Serializing * * Prism provides the ability to serialize the AST and its related metadata into * a binary format. This format is designed to be portable to different * languages and runtimes so that you only need to make one FFI call in order to * parse Ruby code. The structures and functions that you're going to want to * use and be aware of are: * * * `pm_buffer_t` - a small buffer object that will hold the serialized AST * * `pm_buffer_free()` - free the memory associated with the buffer * * `pm_serialize()` - serialize the AST into a buffer * * `pm_serialize_parse()` - parse and serialize the AST into a buffer * * Putting all of this together would look something like: * * ```c * void serialize(const uint8_t *source, size_t length) { * pm_buffer_t buffer = { 0 }; * * pm_serialize_parse(&buffer, source, length, NULL); * printf("SERIALIZED!\n"); * * pm_buffer_free(&buffer); * } * ``` * * @section inspecting Inspecting * * Prism provides the ability to inspect the AST by pretty-printing nodes. You * can do this with the `pm_prettyprint()` function, which you would use like: * * ```c * void prettyprint(const uint8_t *source, size_t length) { * pm_parser_t parser; * pm_parser_init(&parser, source, length, NULL); * * pm_node_t *root = pm_parse(&parser); * pm_buffer_t buffer = { 0 }; * * pm_prettyprint(&buffer, &parser, root); * printf("%*.s\n", (int) buffer.length, buffer.value); * * pm_buffer_free(&buffer); * pm_node_destroy(&parser, root); * pm_parser_free(&parser); * } * ``` */ #endif prism-1.5.1/include/prism/000077500000000000000000000000001506127434000154275ustar00rootroot00000000000000prism-1.5.1/include/prism/defines.h000066400000000000000000000176241506127434000172270ustar00rootroot00000000000000/** * @file defines.h * * Macro definitions used throughout the prism library. * * This file should be included first by any *.h or *.c in prism for consistency * and to ensure that the macros are defined before they are used. */ #ifndef PRISM_DEFINES_H #define PRISM_DEFINES_H #include #include #include #include #include #include #include #include /** * We want to be able to use the PRI* macros for printing out integers, but on * some platforms they aren't included unless this is already defined. */ #define __STDC_FORMAT_MACROS // Include sys/types.h before inttypes.h to work around issue with // certain versions of GCC and newlib which causes omission of PRIx64 #include #include /** * When we are parsing using recursive descent, we want to protect against * malicious payloads that could attempt to crash our parser. We do this by * specifying a maximum depth to which we are allowed to recurse. */ #ifndef PRISM_DEPTH_MAXIMUM #define PRISM_DEPTH_MAXIMUM 10000 #endif /** * By default, we compile with -fvisibility=hidden. When this is enabled, we * need to mark certain functions as being publically-visible. This macro does * that in a compiler-agnostic way. */ #ifndef PRISM_EXPORTED_FUNCTION # ifdef PRISM_EXPORT_SYMBOLS # ifdef _WIN32 # define PRISM_EXPORTED_FUNCTION __declspec(dllexport) extern # else # define PRISM_EXPORTED_FUNCTION __attribute__((__visibility__("default"))) extern # endif # else # define PRISM_EXPORTED_FUNCTION # endif #endif /** * Certain compilers support specifying that a function accepts variadic * parameters that look like printf format strings to provide a better developer * experience when someone is using the function. This macro does that in a * compiler-agnostic way. */ #if defined(__GNUC__) # if defined(__MINGW_PRINTF_FORMAT) # define PRISM_ATTRIBUTE_FORMAT(string_index, argument_index) __attribute__((format(__MINGW_PRINTF_FORMAT, string_index, argument_index))) # else # define PRISM_ATTRIBUTE_FORMAT(string_index, argument_index) __attribute__((format(printf, string_index, argument_index))) # endif #elif defined(__clang__) # define PRISM_ATTRIBUTE_FORMAT(string_index, argument_index) __attribute__((__format__(__printf__, string_index, argument_index))) #else # define PRISM_ATTRIBUTE_FORMAT(string_index, argument_index) #endif /** * GCC will warn if you specify a function or parameter that is unused at * runtime. This macro allows you to mark a function or parameter as unused in a * compiler-agnostic way. */ #if defined(__GNUC__) # define PRISM_ATTRIBUTE_UNUSED __attribute__((unused)) #else # define PRISM_ATTRIBUTE_UNUSED #endif /** * Old Visual Studio versions do not support the inline keyword, so we need to * define it to be __inline. */ #if defined(_MSC_VER) && !defined(inline) # define inline __inline #endif /** * Old Visual Studio versions before 2015 do not implement sprintf, but instead * implement _snprintf. We standard that here. */ #if !defined(snprintf) && defined(_MSC_VER) && (_MSC_VER < 1900) # define snprintf _snprintf #endif /** * A simple utility macro to concatenate two tokens together, necessary when one * of the tokens is itself a macro. */ #define PM_CONCATENATE(left, right) left ## right /** * We want to be able to use static assertions, but they weren't standardized * until C11. As such, we polyfill it here by making a hacky typedef that will * fail to compile due to a negative array size if the condition is false. */ #if defined(_Static_assert) # define PM_STATIC_ASSERT(line, condition, message) _Static_assert(condition, message) #else # define PM_STATIC_ASSERT(line, condition, message) typedef char PM_CONCATENATE(static_assert_, line)[(condition) ? 1 : -1] #endif /** * In general, libc for embedded systems does not support memory-mapped files. * If the target platform is POSIX or Windows, we can map a file in memory and * read it in a more efficient manner. */ #ifdef _WIN32 # define PRISM_HAS_MMAP #else # include # ifdef _POSIX_MAPPED_FILES # define PRISM_HAS_MMAP # endif #endif /** * If PRISM_HAS_NO_FILESYSTEM is defined, then we want to exclude all filesystem * related code from the library. All filesystem related code should be guarded * by PRISM_HAS_FILESYSTEM. */ #ifndef PRISM_HAS_NO_FILESYSTEM # define PRISM_HAS_FILESYSTEM #endif /** * isinf on POSIX systems it accepts a float, a double, or a long double. * But mingw didn't provide an isinf macro, only an isinf function that only * accepts floats, so we need to use _finite instead. */ #ifdef __MINGW64__ #include #define PRISM_ISINF(x) (!_finite(x)) #else #define PRISM_ISINF(x) isinf(x) #endif /** * If you build prism with a custom allocator, configure it with * "-D PRISM_XALLOCATOR" to use your own allocator that defines xmalloc, * xrealloc, xcalloc, and xfree. * * For example, your `prism_xallocator.h` file could look like this: * * ``` * #ifndef PRISM_XALLOCATOR_H * #define PRISM_XALLOCATOR_H * #define xmalloc my_malloc * #define xrealloc my_realloc * #define xcalloc my_calloc * #define xfree my_free * #endif * ``` */ #ifdef PRISM_XALLOCATOR #include "prism_xallocator.h" #else #ifndef xmalloc /** * The malloc function that should be used. This can be overridden with * the PRISM_XALLOCATOR define. */ #define xmalloc malloc #endif #ifndef xrealloc /** * The realloc function that should be used. This can be overridden with * the PRISM_XALLOCATOR define. */ #define xrealloc realloc #endif #ifndef xcalloc /** * The calloc function that should be used. This can be overridden with * the PRISM_XALLOCATOR define. */ #define xcalloc calloc #endif #ifndef xfree /** * The free function that should be used. This can be overridden with the * PRISM_XALLOCATOR define. */ #define xfree free #endif #endif /** * If PRISM_BUILD_MINIMAL is defined, then we're going to define every possible * switch that will turn off certain features of prism. */ #ifdef PRISM_BUILD_MINIMAL /** Exclude the serialization API. */ #define PRISM_EXCLUDE_SERIALIZATION /** Exclude the JSON serialization API. */ #define PRISM_EXCLUDE_JSON /** Exclude the Array#pack parser API. */ #define PRISM_EXCLUDE_PACK /** Exclude the prettyprint API. */ #define PRISM_EXCLUDE_PRETTYPRINT /** Exclude the full set of encodings, using the minimal only. */ #define PRISM_ENCODING_EXCLUDE_FULL #endif /** * Support PRISM_LIKELY and PRISM_UNLIKELY to help the compiler optimize its * branch predication. */ #if defined(__GNUC__) || defined(__clang__) /** The compiler should predicate that this branch will be taken. */ #define PRISM_LIKELY(x) __builtin_expect(!!(x), 1) /** The compiler should predicate that this branch will not be taken. */ #define PRISM_UNLIKELY(x) __builtin_expect(!!(x), 0) #else /** Void because this platform does not support branch prediction hints. */ #define PRISM_LIKELY(x) (x) /** Void because this platform does not support branch prediction hints. */ #define PRISM_UNLIKELY(x) (x) #endif /** * We use -Wimplicit-fallthrough to guard potentially unintended fall-through between cases of a switch. * Use PRISM_FALLTHROUGH to explicitly annotate cases where the fallthrough is intentional. */ #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L // C23 or later #define PRISM_FALLTHROUGH [[fallthrough]]; #elif defined(__GNUC__) || defined(__clang__) #define PRISM_FALLTHROUGH __attribute__((fallthrough)); #elif defined(_MSC_VER) #define PRISM_FALLTHROUGH __fallthrough; #else #define PRISM_FALLTHROUGH #endif #endif prism-1.5.1/include/prism/encoding.h000066400000000000000000000210431506127434000173660ustar00rootroot00000000000000/** * @file encoding.h * * The encoding interface and implementations used by the parser. */ #ifndef PRISM_ENCODING_H #define PRISM_ENCODING_H #include "prism/defines.h" #include "prism/util/pm_strncasecmp.h" #include #include #include #include /** * This struct defines the functions necessary to implement the encoding * interface so we can determine how many bytes the subsequent character takes. * Each callback should return the number of bytes, or 0 if the next bytes are * invalid for the encoding and type. */ typedef struct { /** * Return the number of bytes that the next character takes if it is valid * in the encoding. Does not read more than n bytes. It is assumed that n is * at least 1. */ size_t (*char_width)(const uint8_t *b, ptrdiff_t n); /** * Return the number of bytes that the next character takes if it is valid * in the encoding and is alphabetical. Does not read more than n bytes. It * is assumed that n is at least 1. */ size_t (*alpha_char)(const uint8_t *b, ptrdiff_t n); /** * Return the number of bytes that the next character takes if it is valid * in the encoding and is alphanumeric. Does not read more than n bytes. It * is assumed that n is at least 1. */ size_t (*alnum_char)(const uint8_t *b, ptrdiff_t n); /** * Return true if the next character is valid in the encoding and is an * uppercase character. Does not read more than n bytes. It is assumed that * n is at least 1. */ bool (*isupper_char)(const uint8_t *b, ptrdiff_t n); /** * The name of the encoding. This should correspond to a value that can be * passed to Encoding.find in Ruby. */ const char *name; /** * Return true if the encoding is a multibyte encoding. */ bool multibyte; } pm_encoding_t; /** * All of the lookup tables use the first bit of each embedded byte to indicate * whether the codepoint is alphabetical. */ #define PRISM_ENCODING_ALPHABETIC_BIT 1 << 0 /** * All of the lookup tables use the second bit of each embedded byte to indicate * whether the codepoint is alphanumeric. */ #define PRISM_ENCODING_ALPHANUMERIC_BIT 1 << 1 /** * All of the lookup tables use the third bit of each embedded byte to indicate * whether the codepoint is uppercase. */ #define PRISM_ENCODING_UPPERCASE_BIT 1 << 2 /** * Return the size of the next character in the UTF-8 encoding. * * @param b The bytes to read. * @param n The number of bytes that can be read. * @returns The number of bytes that the next character takes if it is valid in * the encoding, or 0 if it is not. */ size_t pm_encoding_utf_8_char_width(const uint8_t *b, ptrdiff_t n); /** * Return the size of the next character in the UTF-8 encoding if it is an * alphabetical character. * * @param b The bytes to read. * @param n The number of bytes that can be read. * @returns The number of bytes that the next character takes if it is valid in * the encoding, or 0 if it is not. */ size_t pm_encoding_utf_8_alpha_char(const uint8_t *b, ptrdiff_t n); /** * Return the size of the next character in the UTF-8 encoding if it is an * alphanumeric character. * * @param b The bytes to read. * @param n The number of bytes that can be read. * @returns The number of bytes that the next character takes if it is valid in * the encoding, or 0 if it is not. */ size_t pm_encoding_utf_8_alnum_char(const uint8_t *b, ptrdiff_t n); /** * Return true if the next character in the UTF-8 encoding if it is an uppercase * character. * * @param b The bytes to read. * @param n The number of bytes that can be read. * @returns True if the next character is valid in the encoding and is an * uppercase character, or false if it is not. */ bool pm_encoding_utf_8_isupper_char(const uint8_t *b, ptrdiff_t n); /** * This lookup table is referenced in both the UTF-8 encoding file and the * parser directly in order to speed up the default encoding processing. It is * used to indicate whether a character is alphabetical, alphanumeric, or * uppercase in unicode mappings. */ extern const uint8_t pm_encoding_unicode_table[256]; /** * These are all of the encodings that prism supports. */ typedef enum { PM_ENCODING_UTF_8 = 0, PM_ENCODING_US_ASCII, PM_ENCODING_ASCII_8BIT, PM_ENCODING_EUC_JP, PM_ENCODING_WINDOWS_31J, // We optionally support excluding the full set of encodings to only support the // minimum necessary to process Ruby code without encoding comments. #ifndef PRISM_ENCODING_EXCLUDE_FULL PM_ENCODING_BIG5, PM_ENCODING_BIG5_HKSCS, PM_ENCODING_BIG5_UAO, PM_ENCODING_CESU_8, PM_ENCODING_CP51932, PM_ENCODING_CP850, PM_ENCODING_CP852, PM_ENCODING_CP855, PM_ENCODING_CP949, PM_ENCODING_CP950, PM_ENCODING_CP951, PM_ENCODING_EMACS_MULE, PM_ENCODING_EUC_JP_MS, PM_ENCODING_EUC_JIS_2004, PM_ENCODING_EUC_KR, PM_ENCODING_EUC_TW, PM_ENCODING_GB12345, PM_ENCODING_GB18030, PM_ENCODING_GB1988, PM_ENCODING_GB2312, PM_ENCODING_GBK, PM_ENCODING_IBM437, PM_ENCODING_IBM720, PM_ENCODING_IBM737, PM_ENCODING_IBM775, PM_ENCODING_IBM852, PM_ENCODING_IBM855, PM_ENCODING_IBM857, PM_ENCODING_IBM860, PM_ENCODING_IBM861, PM_ENCODING_IBM862, PM_ENCODING_IBM863, PM_ENCODING_IBM864, PM_ENCODING_IBM865, PM_ENCODING_IBM866, PM_ENCODING_IBM869, PM_ENCODING_ISO_8859_1, PM_ENCODING_ISO_8859_2, PM_ENCODING_ISO_8859_3, PM_ENCODING_ISO_8859_4, PM_ENCODING_ISO_8859_5, PM_ENCODING_ISO_8859_6, PM_ENCODING_ISO_8859_7, PM_ENCODING_ISO_8859_8, PM_ENCODING_ISO_8859_9, PM_ENCODING_ISO_8859_10, PM_ENCODING_ISO_8859_11, PM_ENCODING_ISO_8859_13, PM_ENCODING_ISO_8859_14, PM_ENCODING_ISO_8859_15, PM_ENCODING_ISO_8859_16, PM_ENCODING_KOI8_R, PM_ENCODING_KOI8_U, PM_ENCODING_MAC_CENT_EURO, PM_ENCODING_MAC_CROATIAN, PM_ENCODING_MAC_CYRILLIC, PM_ENCODING_MAC_GREEK, PM_ENCODING_MAC_ICELAND, PM_ENCODING_MAC_JAPANESE, PM_ENCODING_MAC_ROMAN, PM_ENCODING_MAC_ROMANIA, PM_ENCODING_MAC_THAI, PM_ENCODING_MAC_TURKISH, PM_ENCODING_MAC_UKRAINE, PM_ENCODING_SHIFT_JIS, PM_ENCODING_SJIS_DOCOMO, PM_ENCODING_SJIS_KDDI, PM_ENCODING_SJIS_SOFTBANK, PM_ENCODING_STATELESS_ISO_2022_JP, PM_ENCODING_STATELESS_ISO_2022_JP_KDDI, PM_ENCODING_TIS_620, PM_ENCODING_UTF8_MAC, PM_ENCODING_UTF8_DOCOMO, PM_ENCODING_UTF8_KDDI, PM_ENCODING_UTF8_SOFTBANK, PM_ENCODING_WINDOWS_1250, PM_ENCODING_WINDOWS_1251, PM_ENCODING_WINDOWS_1252, PM_ENCODING_WINDOWS_1253, PM_ENCODING_WINDOWS_1254, PM_ENCODING_WINDOWS_1255, PM_ENCODING_WINDOWS_1256, PM_ENCODING_WINDOWS_1257, PM_ENCODING_WINDOWS_1258, PM_ENCODING_WINDOWS_874, #endif PM_ENCODING_MAXIMUM } pm_encoding_type_t; /** * This is the table of all of the encodings that prism supports. */ extern const pm_encoding_t pm_encodings[PM_ENCODING_MAXIMUM]; /** * This is the default UTF-8 encoding. We need a reference to it to quickly * create parsers. */ #define PM_ENCODING_UTF_8_ENTRY (&pm_encodings[PM_ENCODING_UTF_8]) /** * This is the US-ASCII encoding. We need a reference to it to be able to * compare against it when a string is being created because it could possibly * need to fall back to ASCII-8BIT. */ #define PM_ENCODING_US_ASCII_ENTRY (&pm_encodings[PM_ENCODING_US_ASCII]) /** * This is the ASCII-8BIT encoding. We need a reference to it so that pm_strpbrk * can compare against it because invalid multibyte characters are not a thing * in this encoding. It is also needed for handling Regexp encoding flags. */ #define PM_ENCODING_ASCII_8BIT_ENTRY (&pm_encodings[PM_ENCODING_ASCII_8BIT]) /** * This is the EUC-JP encoding. We need a reference to it to quickly process * regular expression modifiers. */ #define PM_ENCODING_EUC_JP_ENTRY (&pm_encodings[PM_ENCODING_EUC_JP]) /** * This is the Windows-31J encoding. We need a reference to it to quickly * process regular expression modifiers. */ #define PM_ENCODING_WINDOWS_31J_ENTRY (&pm_encodings[PM_ENCODING_WINDOWS_31J]) /** * Parse the given name of an encoding and return a pointer to the corresponding * encoding struct if one can be found, otherwise return NULL. * * @param start A pointer to the first byte of the name. * @param end A pointer to the last byte of the name. * @returns A pointer to the encoding struct if one is found, otherwise NULL. */ const pm_encoding_t * pm_encoding_find(const uint8_t *start, const uint8_t *end); #endif prism-1.5.1/include/prism/node.h000066400000000000000000000076201506127434000165320ustar00rootroot00000000000000/** * @file node.h * * Functions related to nodes in the AST. */ #ifndef PRISM_NODE_H #define PRISM_NODE_H #include "prism/defines.h" #include "prism/parser.h" #include "prism/util/pm_buffer.h" /** * Loop through each node in the node list, writing each node to the given * pm_node_t pointer. */ #define PM_NODE_LIST_FOREACH(list, index, node) \ for (size_t index = 0; index < (list)->size && ((node) = (list)->nodes[index]); index++) /** * Append a new node onto the end of the node list. * * @param list The list to append to. * @param node The node to append. */ void pm_node_list_append(pm_node_list_t *list, pm_node_t *node); /** * Prepend a new node onto the beginning of the node list. * * @param list The list to prepend to. * @param node The node to prepend. */ void pm_node_list_prepend(pm_node_list_t *list, pm_node_t *node); /** * Concatenate the given node list onto the end of the other node list. * * @param list The list to concatenate onto. * @param other The list to concatenate. */ void pm_node_list_concat(pm_node_list_t *list, pm_node_list_t *other); /** * Free the internal memory associated with the given node list. * * @param list The list to free. */ void pm_node_list_free(pm_node_list_t *list); /** * Deallocate a node and all of its children. * * @param parser The parser that owns the node. * @param node The node to deallocate. */ PRISM_EXPORTED_FUNCTION void pm_node_destroy(pm_parser_t *parser, struct pm_node *node); /** * Returns a string representation of the given node type. * * @param node_type The node type to convert to a string. * @return A string representation of the given node type. */ PRISM_EXPORTED_FUNCTION const char * pm_node_type_to_str(pm_node_type_t node_type); /** * Visit each of the nodes in this subtree using the given visitor callback. The * callback function will be called for each node in the subtree. If it returns * false, then that node's children will not be visited. If it returns true, * then the children will be visited. The data parameter is treated as an opaque * pointer and is passed to the visitor callback for consumers to use as they * see fit. * * As an example: * * ```c * #include "prism.h" * * bool visit(const pm_node_t *node, void *data) { * size_t *indent = (size_t *) data; * for (size_t i = 0; i < *indent * 2; i++) putc(' ', stdout); * printf("%s\n", pm_node_type_to_str(node->type)); * * size_t next_indent = *indent + 1; * size_t *next_data = &next_indent; * pm_visit_child_nodes(node, visit, next_data); * * return false; * } * * int main(void) { * const char *source = "1 + 2; 3 + 4"; * size_t size = strlen(source); * * pm_parser_t parser; * pm_options_t options = { 0 }; * pm_parser_init(&parser, (const uint8_t *) source, size, &options); * * size_t indent = 0; * pm_node_t *node = pm_parse(&parser); * * size_t *data = &indent; * pm_visit_node(node, visit, data); * * pm_node_destroy(&parser, node); * pm_parser_free(&parser); * return EXIT_SUCCESS; * } * ``` * * @param node The root node to start visiting from. * @param visitor The callback to call for each node in the subtree. * @param data An opaque pointer that is passed to the visitor callback. */ PRISM_EXPORTED_FUNCTION void pm_visit_node(const pm_node_t *node, bool (*visitor)(const pm_node_t *node, void *data), void *data); /** * Visit the children of the given node with the given callback. This is the * default behavior for walking the tree that is called from pm_visit_node if * the callback returns true. * * @param node The node to visit the children of. * @param visitor The callback to call for each child node. * @param data An opaque pointer that is passed to the visitor callback. */ PRISM_EXPORTED_FUNCTION void pm_visit_child_nodes(const pm_node_t *node, bool (*visitor)(const pm_node_t *node, void *data), void *data); #endif prism-1.5.1/include/prism/options.h000066400000000000000000000404421506127434000172770ustar00rootroot00000000000000/** * @file options.h * * The options that can be passed to parsing. */ #ifndef PRISM_OPTIONS_H #define PRISM_OPTIONS_H #include "prism/defines.h" #include "prism/util/pm_char.h" #include "prism/util/pm_string.h" #include #include #include /** * String literals should be made frozen. */ #define PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED ((int8_t) -1) /** * String literals may be frozen or mutable depending on the implementation * default. */ #define PM_OPTIONS_FROZEN_STRING_LITERAL_UNSET ((int8_t) 0) /** * String literals should be made mutable. */ #define PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED ((int8_t) 1) /** * A scope of locals surrounding the code that is being parsed. */ typedef struct pm_options_scope { /** The number of locals in the scope. */ size_t locals_count; /** The names of the locals in the scope. */ pm_string_t *locals; /** Flags for the set of forwarding parameters in this scope. */ uint8_t forwarding; } pm_options_scope_t; /** The default value for parameters. */ static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_NONE = 0x0; /** When the scope is fowarding with the * parameter. */ static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_POSITIONALS = 0x1; /** When the scope is fowarding with the ** parameter. */ static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_KEYWORDS = 0x2; /** When the scope is fowarding with the & parameter. */ static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_BLOCK = 0x4; /** When the scope is fowarding with the ... parameter. */ static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_ALL = 0x8; // Forward declaration needed by the callback typedef. struct pm_options; /** * The callback called when additional switches are found in a shebang comment * that need to be processed by the runtime. * * @param options The options struct that may be updated by this callback. * Certain fields will be checked for changes, specifically encoding, * command_line, and frozen_string_literal. * @param source The source of the shebang comment. * @param length The length of the source. * @param shebang_callback_data Any additional data that should be passed along * to the callback. */ typedef void (*pm_options_shebang_callback_t)(struct pm_options *options, const uint8_t *source, size_t length, void *shebang_callback_data); /** * The version of Ruby syntax that we should be parsing with. This is used to * allow consumers to specify which behavior they want in case they need to * parse in the same way as a specific version of CRuby would have. */ typedef enum { /** If an explicit version is not provided, the current version of prism will be used. */ PM_OPTIONS_VERSION_UNSET = 0, /** The vendored version of prism in CRuby 3.3.x. */ PM_OPTIONS_VERSION_CRUBY_3_3 = 1, /** The vendored version of prism in CRuby 3.4.x. */ PM_OPTIONS_VERSION_CRUBY_3_4 = 2, /** The vendored version of prism in CRuby 3.5.x. */ PM_OPTIONS_VERSION_CRUBY_3_5 = 3, /** The current version of prism. */ PM_OPTIONS_VERSION_LATEST = PM_OPTIONS_VERSION_CRUBY_3_5 } pm_options_version_t; /** * The options that can be passed to the parser. */ typedef struct pm_options { /** * The callback to call when additional switches are found in a shebang * comment. */ pm_options_shebang_callback_t shebang_callback; /** * Any additional data that should be passed along to the shebang callback * if one was set. */ void *shebang_callback_data; /** The name of the file that is currently being parsed. */ pm_string_t filepath; /** * The line within the file that the parse starts on. This value is * 1-indexed. */ int32_t line; /** * The name of the encoding that the source file is in. Note that this must * correspond to a name that can be found with Encoding.find in Ruby. */ pm_string_t encoding; /** * The number of scopes surrounding the code that is being parsed. */ size_t scopes_count; /** * The scopes surrounding the code that is being parsed. For most parses * this will be NULL, but for evals it will be the locals that are in scope * surrounding the eval. Scopes are ordered from the outermost scope to the * innermost one. */ pm_options_scope_t *scopes; /** * The version of prism that we should be parsing with. This is used to * allow consumers to specify which behavior they want in case they need to * parse exactly as a specific version of CRuby. */ pm_options_version_t version; /** A bitset of the various options that were set on the command line. */ uint8_t command_line; /** * Whether or not the frozen string literal option has been set. * May be: * - PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED * - PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED * - PM_OPTIONS_FROZEN_STRING_LITERAL_UNSET */ int8_t frozen_string_literal; /** * Whether or not the encoding magic comments should be respected. This is a * niche use-case where you want to parse a file with a specific encoding * but ignore any encoding magic comments at the top of the file. */ bool encoding_locked; /** * When the file being parsed is the main script, the shebang will be * considered for command-line flags (or for implicit -x). The caller needs * to pass this information to the parser so that it can behave correctly. */ bool main_script; /** * When the file being parsed is considered a "partial" script, jumps will * not be marked as errors if they are not contained within loops/blocks. * This is used in the case that you're parsing a script that you know will * be embedded inside another script later, but you do not have that context * yet. For example, when parsing an ERB template that will be evaluated * inside another script. */ bool partial_script; /** * Whether or not the parser should freeze the nodes that it creates. This * makes it possible to have a deeply frozen AST that is safe to share * between concurrency primitives. */ bool freeze; } pm_options_t; /** * A bit representing whether or not the command line -a option was set. -a * splits the input line $_ into $F. */ static const uint8_t PM_OPTIONS_COMMAND_LINE_A = 0x1; /** * A bit representing whether or not the command line -e option was set. -e * allow the user to specify a script to be executed. This is necessary for * prism to know because certain warnings are not generated when -e is used. */ static const uint8_t PM_OPTIONS_COMMAND_LINE_E = 0x2; /** * A bit representing whether or not the command line -l option was set. -l * chomps the input line by default. */ static const uint8_t PM_OPTIONS_COMMAND_LINE_L = 0x4; /** * A bit representing whether or not the command line -n option was set. -n * wraps the script in a while gets loop. */ static const uint8_t PM_OPTIONS_COMMAND_LINE_N = 0x8; /** * A bit representing whether or not the command line -p option was set. -p * prints the value of $_ at the end of each loop. */ static const uint8_t PM_OPTIONS_COMMAND_LINE_P = 0x10; /** * A bit representing whether or not the command line -x option was set. -x * searches the input file for a shebang that matches the current Ruby engine. */ static const uint8_t PM_OPTIONS_COMMAND_LINE_X = 0x20; /** * Set the shebang callback option on the given options struct. * * @param options The options struct to set the shebang callback on. * @param shebang_callback The shebang callback to set. * @param shebang_callback_data Any additional data that should be passed along * to the callback. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION void pm_options_shebang_callback_set(pm_options_t *options, pm_options_shebang_callback_t shebang_callback, void *shebang_callback_data); /** * Set the filepath option on the given options struct. * * @param options The options struct to set the filepath on. * @param filepath The filepath to set. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION void pm_options_filepath_set(pm_options_t *options, const char *filepath); /** * Set the line option on the given options struct. * * @param options The options struct to set the line on. * @param line The line to set. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION void pm_options_line_set(pm_options_t *options, int32_t line); /** * Set the encoding option on the given options struct. * * @param options The options struct to set the encoding on. * @param encoding The encoding to set. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION void pm_options_encoding_set(pm_options_t *options, const char *encoding); /** * Set the encoding_locked option on the given options struct. * * @param options The options struct to set the encoding_locked value on. * @param encoding_locked The encoding_locked value to set. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION void pm_options_encoding_locked_set(pm_options_t *options, bool encoding_locked); /** * Set the frozen string literal option on the given options struct. * * @param options The options struct to set the frozen string literal value on. * @param frozen_string_literal The frozen string literal value to set. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION void pm_options_frozen_string_literal_set(pm_options_t *options, bool frozen_string_literal); /** * Sets the command line option on the given options struct. * * @param options The options struct to set the command line option on. * @param command_line The command_line value to set. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION void pm_options_command_line_set(pm_options_t *options, uint8_t command_line); /** * Set the version option on the given options struct by parsing the given * string. If the string contains an invalid option, this returns false. * Otherwise, it returns true. * * @param options The options struct to set the version on. * @param version The version to set. * @param length The length of the version string. * @return Whether or not the version was parsed successfully. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION bool pm_options_version_set(pm_options_t *options, const char *version, size_t length); /** * Set the main script option on the given options struct. * * @param options The options struct to set the main script value on. * @param main_script The main script value to set. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION void pm_options_main_script_set(pm_options_t *options, bool main_script); /** * Set the partial script option on the given options struct. * * @param options The options struct to set the partial script value on. * @param partial_script The partial script value to set. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION void pm_options_partial_script_set(pm_options_t *options, bool partial_script); /** * Set the freeze option on the given options struct. * * @param options The options struct to set the freeze value on. * @param freeze The freeze value to set. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION void pm_options_freeze_set(pm_options_t *options, bool freeze); /** * Allocate and zero out the scopes array on the given options struct. * * @param options The options struct to initialize the scopes array on. * @param scopes_count The number of scopes to allocate. * @return Whether or not the scopes array was initialized successfully. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION bool pm_options_scopes_init(pm_options_t *options, size_t scopes_count); /** * Return a pointer to the scope at the given index within the given options. * * @param options The options struct to get the scope from. * @param index The index of the scope to get. * @return A pointer to the scope at the given index. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION const pm_options_scope_t * pm_options_scope_get(const pm_options_t *options, size_t index); /** * Create a new options scope struct. This will hold a set of locals that are in * scope surrounding the code that is being parsed. * * @param scope The scope struct to initialize. * @param locals_count The number of locals to allocate. * @return Whether or not the scope was initialized successfully. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION bool pm_options_scope_init(pm_options_scope_t *scope, size_t locals_count); /** * Return a pointer to the local at the given index within the given scope. * * @param scope The scope struct to get the local from. * @param index The index of the local to get. * @return A pointer to the local at the given index. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION const pm_string_t * pm_options_scope_local_get(const pm_options_scope_t *scope, size_t index); /** * Set the forwarding option on the given scope struct. * * @param scope The scope struct to set the forwarding on. * @param forwarding The forwarding value to set. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION void pm_options_scope_forwarding_set(pm_options_scope_t *scope, uint8_t forwarding); /** * Free the internal memory associated with the options. * * @param options The options struct whose internal memory should be freed. * * \public \memberof pm_options */ PRISM_EXPORTED_FUNCTION void pm_options_free(pm_options_t *options); /** * Deserialize an options struct from the given binary string. This is used to * pass options to the parser from an FFI call so that consumers of the library * from an FFI perspective don't have to worry about the structure of our * options structs. Since the source of these calls will be from Ruby * implementation internals we assume it is from a trusted source. * * `data` is assumed to be a valid pointer pointing to well-formed data. The * layout of this data should be the same every time, and is described below: * * | # bytes | field | * | ------- | -------------------------- | * | `4` | the length of the filepath | * | ... | the filepath bytes | * | `4` | the line number | * | `4` | the length the encoding | * | ... | the encoding bytes | * | `1` | frozen string literal | * | `1` | -p command line option | * | `1` | -n command line option | * | `1` | -l command line option | * | `1` | -a command line option | * | `1` | the version | * | `1` | encoding locked | * | `1` | main script | * | `1` | partial script | * | `1` | freeze | * | `4` | the number of scopes | * | ... | the scopes | * * The version field is an enum, so it should be one of the following values: * * | value | version | * | ----- | ------------------------- | * | `0` | use the latest version of prism | * | `1` | use the version of prism that is vendored in CRuby 3.3.0 | * * Each scope is laid out as follows: * * | # bytes | field | * | ------- | -------------------------- | * | `4` | the number of locals | * | `1` | the forwarding flags | * | ... | the locals | * * Each local is laid out as follows: * * | # bytes | field | * | ------- | -------------------------- | * | `4` | the length of the local | * | ... | the local bytes | * * Some additional things to note about this layout: * * * The filepath can have a length of 0, in which case we'll consider it an * empty string. * * The line number should be 0-indexed. * * The encoding can have a length of 0, in which case we'll use the default * encoding (UTF-8). If it's not 0, it should correspond to a name of an * encoding that can be passed to `Encoding.find` in Ruby. * * The frozen string literal, encoding locked, main script, and partial script * fields are booleans, so their values should be either 0 or 1. * * The number of scopes can be 0. * * @param options The options struct to deserialize into. * @param data The binary string to deserialize from. */ void pm_options_read(pm_options_t *options, const char *data); #endif prism-1.5.1/include/prism/pack.h000066400000000000000000000107331506127434000165220ustar00rootroot00000000000000/** * @file pack.h * * A pack template string parser. */ #ifndef PRISM_PACK_H #define PRISM_PACK_H #include "prism/defines.h" // We optionally support parsing String#pack templates. For systems that don't // want or need this functionality, it can be turned off with the // PRISM_EXCLUDE_PACK define. #ifdef PRISM_EXCLUDE_PACK void pm_pack_parse(void); #else #include #include /** The version of the pack template language that we are parsing. */ typedef enum pm_pack_version { PM_PACK_VERSION_3_2_0 } pm_pack_version; /** The type of pack template we are parsing. */ typedef enum pm_pack_variant { PM_PACK_VARIANT_PACK, PM_PACK_VARIANT_UNPACK } pm_pack_variant; /** A directive within the pack template. */ typedef enum pm_pack_type { PM_PACK_SPACE, PM_PACK_COMMENT, PM_PACK_INTEGER, PM_PACK_UTF8, PM_PACK_BER, PM_PACK_FLOAT, PM_PACK_STRING_SPACE_PADDED, PM_PACK_STRING_NULL_PADDED, PM_PACK_STRING_NULL_TERMINATED, PM_PACK_STRING_MSB, PM_PACK_STRING_LSB, PM_PACK_STRING_HEX_HIGH, PM_PACK_STRING_HEX_LOW, PM_PACK_STRING_UU, PM_PACK_STRING_MIME, PM_PACK_STRING_BASE64, PM_PACK_STRING_FIXED, PM_PACK_STRING_POINTER, PM_PACK_MOVE, PM_PACK_BACK, PM_PACK_NULL, PM_PACK_END } pm_pack_type; /** The signness of a pack directive. */ typedef enum pm_pack_signed { PM_PACK_UNSIGNED, PM_PACK_SIGNED, PM_PACK_SIGNED_NA } pm_pack_signed; /** The endianness of a pack directive. */ typedef enum pm_pack_endian { PM_PACK_AGNOSTIC_ENDIAN, PM_PACK_LITTLE_ENDIAN, // aka 'VAX', or 'V' PM_PACK_BIG_ENDIAN, // aka 'network', or 'N' PM_PACK_NATIVE_ENDIAN, PM_PACK_ENDIAN_NA } pm_pack_endian; /** The size of an integer pack directive. */ typedef enum pm_pack_size { PM_PACK_SIZE_SHORT, PM_PACK_SIZE_INT, PM_PACK_SIZE_LONG, PM_PACK_SIZE_LONG_LONG, PM_PACK_SIZE_8, PM_PACK_SIZE_16, PM_PACK_SIZE_32, PM_PACK_SIZE_64, PM_PACK_SIZE_P, PM_PACK_SIZE_NA } pm_pack_size; /** The type of length of a pack directive. */ typedef enum pm_pack_length_type { PM_PACK_LENGTH_FIXED, PM_PACK_LENGTH_MAX, PM_PACK_LENGTH_RELATIVE, // special case for unpack @* PM_PACK_LENGTH_NA } pm_pack_length_type; /** The type of encoding for a pack template string. */ typedef enum pm_pack_encoding { PM_PACK_ENCODING_START, PM_PACK_ENCODING_ASCII_8BIT, PM_PACK_ENCODING_US_ASCII, PM_PACK_ENCODING_UTF_8 } pm_pack_encoding; /** The result of parsing a pack template. */ typedef enum pm_pack_result { PM_PACK_OK, PM_PACK_ERROR_UNSUPPORTED_DIRECTIVE, PM_PACK_ERROR_UNKNOWN_DIRECTIVE, PM_PACK_ERROR_LENGTH_TOO_BIG, PM_PACK_ERROR_BANG_NOT_ALLOWED, PM_PACK_ERROR_DOUBLE_ENDIAN } pm_pack_result; /** * Parse a single directive from a pack or unpack format string. * * @param variant (in) pack or unpack * @param format (in, out) the start of the next directive to parse on calling, * and advanced beyond the parsed directive on return, or as much of it as * was consumed until an error was encountered * @param format_end (in) the end of the format string * @param type (out) the type of the directive * @param signed_type (out) whether the value is signed * @param endian (out) the endianness of the value * @param size (out) the size of the value * @param length_type (out) what kind of length is specified * @param length (out) the length of the directive * @param encoding (in, out) takes the current encoding of the string which * would result from parsing the whole format string, and returns a possibly * changed directive - the encoding should be `PM_PACK_ENCODING_START` when * pm_pack_parse is called for the first directive in a format string * * @return `PM_PACK_OK` on success or `PM_PACK_ERROR_*` on error * @note Consult Ruby documentation for the meaning of directives. */ PRISM_EXPORTED_FUNCTION pm_pack_result pm_pack_parse( pm_pack_variant variant, const char **format, const char *format_end, pm_pack_type *type, pm_pack_signed *signed_type, pm_pack_endian *endian, pm_pack_size *size, pm_pack_length_type *length_type, uint64_t *length, pm_pack_encoding *encoding ); /** * Prism abstracts sizes away from the native system - this converts an abstract * size to a native size. * * @param size The abstract size to convert. * @return The native size. */ PRISM_EXPORTED_FUNCTION size_t pm_size_to_native(pm_pack_size size); #endif #endif prism-1.5.1/include/prism/parser.h000066400000000000000000000726631506127434000171120ustar00rootroot00000000000000/** * @file parser.h * * The parser used to parse Ruby source. */ #ifndef PRISM_PARSER_H #define PRISM_PARSER_H #include "prism/defines.h" #include "prism/ast.h" #include "prism/encoding.h" #include "prism/options.h" #include "prism/static_literals.h" #include "prism/util/pm_constant_pool.h" #include "prism/util/pm_list.h" #include "prism/util/pm_newline_list.h" #include "prism/util/pm_string.h" #include /** * This enum provides various bits that represent different kinds of states that * the lexer can track. This is used to determine which kind of token to return * based on the context of the parser. */ typedef enum { PM_LEX_STATE_BIT_BEG, PM_LEX_STATE_BIT_END, PM_LEX_STATE_BIT_ENDARG, PM_LEX_STATE_BIT_ENDFN, PM_LEX_STATE_BIT_ARG, PM_LEX_STATE_BIT_CMDARG, PM_LEX_STATE_BIT_MID, PM_LEX_STATE_BIT_FNAME, PM_LEX_STATE_BIT_DOT, PM_LEX_STATE_BIT_CLASS, PM_LEX_STATE_BIT_LABEL, PM_LEX_STATE_BIT_LABELED, PM_LEX_STATE_BIT_FITEM } pm_lex_state_bit_t; /** * This enum combines the various bits from the above enum into individual * values that represent the various states of the lexer. */ typedef enum { PM_LEX_STATE_NONE = 0, PM_LEX_STATE_BEG = (1 << PM_LEX_STATE_BIT_BEG), PM_LEX_STATE_END = (1 << PM_LEX_STATE_BIT_END), PM_LEX_STATE_ENDARG = (1 << PM_LEX_STATE_BIT_ENDARG), PM_LEX_STATE_ENDFN = (1 << PM_LEX_STATE_BIT_ENDFN), PM_LEX_STATE_ARG = (1 << PM_LEX_STATE_BIT_ARG), PM_LEX_STATE_CMDARG = (1 << PM_LEX_STATE_BIT_CMDARG), PM_LEX_STATE_MID = (1 << PM_LEX_STATE_BIT_MID), PM_LEX_STATE_FNAME = (1 << PM_LEX_STATE_BIT_FNAME), PM_LEX_STATE_DOT = (1 << PM_LEX_STATE_BIT_DOT), PM_LEX_STATE_CLASS = (1 << PM_LEX_STATE_BIT_CLASS), PM_LEX_STATE_LABEL = (1 << PM_LEX_STATE_BIT_LABEL), PM_LEX_STATE_LABELED = (1 << PM_LEX_STATE_BIT_LABELED), PM_LEX_STATE_FITEM = (1 << PM_LEX_STATE_BIT_FITEM), PM_LEX_STATE_BEG_ANY = PM_LEX_STATE_BEG | PM_LEX_STATE_MID | PM_LEX_STATE_CLASS, PM_LEX_STATE_ARG_ANY = PM_LEX_STATE_ARG | PM_LEX_STATE_CMDARG, PM_LEX_STATE_END_ANY = PM_LEX_STATE_END | PM_LEX_STATE_ENDARG | PM_LEX_STATE_ENDFN } pm_lex_state_t; /** * The type of quote that a heredoc uses. */ typedef enum { PM_HEREDOC_QUOTE_NONE, PM_HEREDOC_QUOTE_SINGLE = '\'', PM_HEREDOC_QUOTE_DOUBLE = '"', PM_HEREDOC_QUOTE_BACKTICK = '`', } pm_heredoc_quote_t; /** * The type of indentation that a heredoc uses. */ typedef enum { PM_HEREDOC_INDENT_NONE, PM_HEREDOC_INDENT_DASH, PM_HEREDOC_INDENT_TILDE, } pm_heredoc_indent_t; /** * All of the information necessary to store to lexing a heredoc. */ typedef struct { /** A pointer to the start of the heredoc identifier. */ const uint8_t *ident_start; /** The length of the heredoc identifier. */ size_t ident_length; /** The type of quote that the heredoc uses. */ pm_heredoc_quote_t quote; /** The type of indentation that the heredoc uses. */ pm_heredoc_indent_t indent; } pm_heredoc_lex_mode_t; /** * When lexing Ruby source, the lexer has a small amount of state to tell which * kind of token it is currently lexing. For example, when we find the start of * a string, the first token that we return is a TOKEN_STRING_BEGIN token. After * that the lexer is now in the PM_LEX_STRING mode, and will return tokens that * are found as part of a string. */ typedef struct pm_lex_mode { /** The type of this lex mode. */ enum { /** This state is used when any given token is being lexed. */ PM_LEX_DEFAULT, /** * This state is used when we're lexing as normal but inside an embedded * expression of a string. */ PM_LEX_EMBEXPR, /** * This state is used when we're lexing a variable that is embedded * directly inside of a string with the # shorthand. */ PM_LEX_EMBVAR, /** This state is used when you are inside the content of a heredoc. */ PM_LEX_HEREDOC, /** * This state is used when we are lexing a list of tokens, as in a %w * word list literal or a %i symbol list literal. */ PM_LEX_LIST, /** * This state is used when a regular expression has been begun and we * are looking for the terminator. */ PM_LEX_REGEXP, /** * This state is used when we are lexing a string or a string-like * token, as in string content with either quote or an xstring. */ PM_LEX_STRING } mode; /** The data associated with this type of lex mode. */ union { struct { /** This keeps track of the nesting level of the list. */ size_t nesting; /** Whether or not interpolation is allowed in this list. */ bool interpolation; /** * When lexing a list, it takes into account balancing the * terminator if the terminator is one of (), [], {}, or <>. */ uint8_t incrementor; /** This is the terminator of the list literal. */ uint8_t terminator; /** * This is the character set that should be used to delimit the * tokens within the list. */ uint8_t breakpoints[11]; } list; struct { /** * This keeps track of the nesting level of the regular expression. */ size_t nesting; /** * When lexing a regular expression, it takes into account balancing * the terminator if the terminator is one of (), [], {}, or <>. */ uint8_t incrementor; /** This is the terminator of the regular expression. */ uint8_t terminator; /** * This is the character set that should be used to delimit the * tokens within the regular expression. */ uint8_t breakpoints[7]; } regexp; struct { /** This keeps track of the nesting level of the string. */ size_t nesting; /** Whether or not interpolation is allowed in this string. */ bool interpolation; /** * Whether or not at the end of the string we should allow a :, * which would indicate this was a dynamic symbol instead of a * string. */ bool label_allowed; /** * When lexing a string, it takes into account balancing the * terminator if the terminator is one of (), [], {}, or <>. */ uint8_t incrementor; /** * This is the terminator of the string. It is typically either a * single or double quote. */ uint8_t terminator; /** * This is the character set that should be used to delimit the * tokens within the string. */ uint8_t breakpoints[7]; } string; struct { /** * All of the data necessary to lex a heredoc. */ pm_heredoc_lex_mode_t base; /** * This is the pointer to the character where lexing should resume * once the heredoc has been completely processed. */ const uint8_t *next_start; /** * This is used to track the amount of common whitespace on each * line so that we know how much to dedent each line in the case of * a tilde heredoc. */ size_t *common_whitespace; /** True if the previous token ended with a line continuation. */ bool line_continuation; } heredoc; } as; /** The previous lex state so that it knows how to pop. */ struct pm_lex_mode *prev; } pm_lex_mode_t; /** * We pre-allocate a certain number of lex states in order to avoid having to * call malloc too many times while parsing. You really shouldn't need more than * this because you only really nest deeply when doing string interpolation. */ #define PM_LEX_STACK_SIZE 4 /** * The parser used to parse Ruby source. */ typedef struct pm_parser pm_parser_t; /** * While parsing, we keep track of a stack of contexts. This is helpful for * error recovery so that we can pop back to a previous context when we hit a * token that is understood by a parent context but not by the current context. */ typedef enum { /** a null context, used for returning a value from a function */ PM_CONTEXT_NONE = 0, /** a begin statement */ PM_CONTEXT_BEGIN, /** an ensure statement with an explicit begin */ PM_CONTEXT_BEGIN_ENSURE, /** a rescue else statement with an explicit begin */ PM_CONTEXT_BEGIN_ELSE, /** a rescue statement with an explicit begin */ PM_CONTEXT_BEGIN_RESCUE, /** expressions in block arguments using braces */ PM_CONTEXT_BLOCK_BRACES, /** expressions in block arguments using do..end */ PM_CONTEXT_BLOCK_KEYWORDS, /** an ensure statement within a do..end block */ PM_CONTEXT_BLOCK_ENSURE, /** a rescue else statement within a do..end block */ PM_CONTEXT_BLOCK_ELSE, /** a rescue statement within a do..end block */ PM_CONTEXT_BLOCK_RESCUE, /** a case when statements */ PM_CONTEXT_CASE_WHEN, /** a case in statements */ PM_CONTEXT_CASE_IN, /** a class declaration */ PM_CONTEXT_CLASS, /** an ensure statement within a class statement */ PM_CONTEXT_CLASS_ENSURE, /** a rescue else statement within a class statement */ PM_CONTEXT_CLASS_ELSE, /** a rescue statement within a class statement */ PM_CONTEXT_CLASS_RESCUE, /** a method definition */ PM_CONTEXT_DEF, /** an ensure statement within a method definition */ PM_CONTEXT_DEF_ENSURE, /** a rescue else statement within a method definition */ PM_CONTEXT_DEF_ELSE, /** a rescue statement within a method definition */ PM_CONTEXT_DEF_RESCUE, /** a method definition's parameters */ PM_CONTEXT_DEF_PARAMS, /** a defined? expression */ PM_CONTEXT_DEFINED, /** a method definition's default parameter */ PM_CONTEXT_DEFAULT_PARAMS, /** an else clause */ PM_CONTEXT_ELSE, /** an elsif clause */ PM_CONTEXT_ELSIF, /** an interpolated expression */ PM_CONTEXT_EMBEXPR, /** a for loop */ PM_CONTEXT_FOR, /** a for loop's index */ PM_CONTEXT_FOR_INDEX, /** an if statement */ PM_CONTEXT_IF, /** a lambda expression with braces */ PM_CONTEXT_LAMBDA_BRACES, /** a lambda expression with do..end */ PM_CONTEXT_LAMBDA_DO_END, /** an ensure statement within a lambda expression */ PM_CONTEXT_LAMBDA_ENSURE, /** a rescue else statement within a lambda expression */ PM_CONTEXT_LAMBDA_ELSE, /** a rescue statement within a lambda expression */ PM_CONTEXT_LAMBDA_RESCUE, /** the predicate clause of a loop statement */ PM_CONTEXT_LOOP_PREDICATE, /** the top level context */ PM_CONTEXT_MAIN, /** a module declaration */ PM_CONTEXT_MODULE, /** an ensure statement within a module statement */ PM_CONTEXT_MODULE_ENSURE, /** a rescue else statement within a module statement */ PM_CONTEXT_MODULE_ELSE, /** a rescue statement within a module statement */ PM_CONTEXT_MODULE_RESCUE, /** a multiple target expression */ PM_CONTEXT_MULTI_TARGET, /** a parenthesized expression */ PM_CONTEXT_PARENS, /** an END block */ PM_CONTEXT_POSTEXE, /** a predicate inside an if/elsif/unless statement */ PM_CONTEXT_PREDICATE, /** a BEGIN block */ PM_CONTEXT_PREEXE, /** a modifier rescue clause */ PM_CONTEXT_RESCUE_MODIFIER, /** a singleton class definition */ PM_CONTEXT_SCLASS, /** an ensure statement with a singleton class */ PM_CONTEXT_SCLASS_ENSURE, /** a rescue else statement with a singleton class */ PM_CONTEXT_SCLASS_ELSE, /** a rescue statement with a singleton class */ PM_CONTEXT_SCLASS_RESCUE, /** a ternary expression */ PM_CONTEXT_TERNARY, /** an unless statement */ PM_CONTEXT_UNLESS, /** an until statement */ PM_CONTEXT_UNTIL, /** a while statement */ PM_CONTEXT_WHILE, } pm_context_t; /** This is a node in a linked list of contexts. */ typedef struct pm_context_node { /** The context that this node represents. */ pm_context_t context; /** A pointer to the previous context in the linked list. */ struct pm_context_node *prev; } pm_context_node_t; /** This is the type of a comment that we've found while parsing. */ typedef enum { PM_COMMENT_INLINE, PM_COMMENT_EMBDOC } pm_comment_type_t; /** * This is a node in the linked list of comments that we've found while parsing. * * @extends pm_list_node_t */ typedef struct pm_comment { /** The embedded base node. */ pm_list_node_t node; /** The location of the comment in the source. */ pm_location_t location; /** The type of comment that we've found. */ pm_comment_type_t type; } pm_comment_t; /** * This is a node in the linked list of magic comments that we've found while * parsing. * * @extends pm_list_node_t */ typedef struct { /** The embedded base node. */ pm_list_node_t node; /** A pointer to the start of the key in the source. */ const uint8_t *key_start; /** A pointer to the start of the value in the source. */ const uint8_t *value_start; /** The length of the key in the source. */ uint32_t key_length; /** The length of the value in the source. */ uint32_t value_length; } pm_magic_comment_t; /** * When the encoding that is being used to parse the source is changed by prism, * we provide the ability here to call out to a user-defined function. */ typedef void (*pm_encoding_changed_callback_t)(pm_parser_t *parser); /** * When you are lexing through a file, the lexer needs all of the information * that the parser additionally provides (for example, the local table). So if * you want to properly lex Ruby, you need to actually lex it in the context of * the parser. In order to provide this functionality, we optionally allow a * struct to be attached to the parser that calls back out to a user-provided * callback when each token is lexed. */ typedef struct { /** * This opaque pointer is used to provide whatever information the user * deemed necessary to the callback. In our case we use it to pass the array * that the tokens get appended into. */ void *data; /** * This is the callback that is called when a token is lexed. It is passed * the opaque data pointer, the parser, and the token that was lexed. */ void (*callback)(void *data, pm_parser_t *parser, pm_token_t *token); } pm_lex_callback_t; /** The type of shareable constant value that can be set. */ typedef uint8_t pm_shareable_constant_value_t; static const pm_shareable_constant_value_t PM_SCOPE_SHAREABLE_CONSTANT_NONE = 0x0; static const pm_shareable_constant_value_t PM_SCOPE_SHAREABLE_CONSTANT_LITERAL = PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL; static const pm_shareable_constant_value_t PM_SCOPE_SHAREABLE_CONSTANT_EXPERIMENTAL_EVERYTHING = PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING; static const pm_shareable_constant_value_t PM_SCOPE_SHAREABLE_CONSTANT_EXPERIMENTAL_COPY = PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY; /** * This tracks an individual local variable in a certain lexical context, as * well as the number of times is it read. */ typedef struct { /** The name of the local variable. */ pm_constant_id_t name; /** The location of the local variable in the source. */ pm_location_t location; /** The index of the local variable in the local table. */ uint32_t index; /** The number of times the local variable is read. */ uint32_t reads; /** The hash of the local variable. */ uint32_t hash; } pm_local_t; /** * This is a set of local variables in a certain lexical context (method, class, * module, etc.). We need to track how many times these variables are read in * order to warn if they only get written. */ typedef struct pm_locals { /** The number of local variables in the set. */ uint32_t size; /** The capacity of the local variables set. */ uint32_t capacity; /** The nullable allocated memory for the local variables in the set. */ pm_local_t *locals; } pm_locals_t; /** The flags about scope parameters that can be set. */ typedef uint8_t pm_scope_parameters_t; static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_NONE = 0x0; static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_FORWARDING_POSITIONALS = 0x1; static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_FORWARDING_KEYWORDS = 0x2; static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_FORWARDING_BLOCK = 0x4; static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_FORWARDING_ALL = 0x8; static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_IMPLICIT_DISALLOWED = 0x10; static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_NUMBERED_INNER = 0x20; static const pm_scope_parameters_t PM_SCOPE_PARAMETERS_NUMBERED_FOUND = 0x40; /** * This struct represents a node in a linked list of scopes. Some scopes can see * into their parent scopes, while others cannot. */ typedef struct pm_scope { /** A pointer to the previous scope in the linked list. */ struct pm_scope *previous; /** The IDs of the locals in the given scope. */ pm_locals_t locals; /** * This is a list of the implicit parameters contained within the block. * These will be processed after the block is parsed to determine the kind * of parameters node that should be used and to check if any errors need to * be added. */ pm_node_list_t implicit_parameters; /** * This is a bitfield that indicates the parameters that are being used in * this scope. It is a combination of the PM_SCOPE_PARAMETERS_* constants. * There are three different kinds of parameters that can be used in a * scope: * * - Ordinary parameters (e.g., def foo(bar); end) * - Numbered parameters (e.g., def foo; _1; end) * - The it parameter (e.g., def foo; it; end) * * If ordinary parameters are being used, then certain parameters can be * forwarded to another method/structure. Those are indicated by four * additional bits in the params field. For example, some combinations of: * * - def foo(*); end * - def foo(**); end * - def foo(&); end * - def foo(...); end */ pm_scope_parameters_t parameters; /** * The current state of constant shareability for this scope. This is * changed by magic shareable_constant_value comments. */ pm_shareable_constant_value_t shareable_constant; /** * A boolean indicating whether or not this scope can see into its parent. * If closed is true, then the scope cannot see into its parent. */ bool closed; } pm_scope_t; /** * A struct that represents a stack of boolean values. */ typedef uint32_t pm_state_stack_t; /** * This struct represents the overall parser. It contains a reference to the * source file, as well as pointers that indicate where in the source it's * currently parsing. It also contains the most recent and current token that * it's considering. */ struct pm_parser { /** * The next node identifier that will be assigned. This is a unique * identifier used to track nodes such that the syntax tree can be dropped * but the node can be found through another parse. */ uint32_t node_id; /** The current state of the lexer. */ pm_lex_state_t lex_state; /** Tracks the current nesting of (), [], and {}. */ int enclosure_nesting; /** * Used to temporarily track the nesting of enclosures to determine if a { * is the beginning of a lambda following the parameters of a lambda. */ int lambda_enclosure_nesting; /** * Used to track the nesting of braces to ensure we get the correct value * when we are interpolating blocks with braces. */ int brace_nesting; /** * The stack used to determine if a do keyword belongs to the predicate of a * while, until, or for loop. */ pm_state_stack_t do_loop_stack; /** * The stack used to determine if a do keyword belongs to the beginning of a * block. */ pm_state_stack_t accepts_block_stack; /** A stack of lex modes. */ struct { /** The current mode of the lexer. */ pm_lex_mode_t *current; /** The stack of lexer modes. */ pm_lex_mode_t stack[PM_LEX_STACK_SIZE]; /** The current index into the lexer mode stack. */ size_t index; } lex_modes; /** The pointer to the start of the source. */ const uint8_t *start; /** The pointer to the end of the source. */ const uint8_t *end; /** The previous token we were considering. */ pm_token_t previous; /** The current token we're considering. */ pm_token_t current; /** * This is a special field set on the parser when we need the parser to jump * to a specific location when lexing the next token, as opposed to just * using the end of the previous token. Normally this is NULL. */ const uint8_t *next_start; /** * This field indicates the end of a heredoc whose identifier was found on * the current line. If another heredoc is found on the same line, then this * will be moved forward to the end of that heredoc. If no heredocs are * found on a line then this is NULL. */ const uint8_t *heredoc_end; /** The list of comments that have been found while parsing. */ pm_list_t comment_list; /** The list of magic comments that have been found while parsing. */ pm_list_t magic_comment_list; /** * An optional location that represents the location of the __END__ marker * and the rest of the content of the file. This content is loaded into the * DATA constant when the file being parsed is the main file being executed. */ pm_location_t data_loc; /** The list of warnings that have been found while parsing. */ pm_list_t warning_list; /** The list of errors that have been found while parsing. */ pm_list_t error_list; /** The current local scope. */ pm_scope_t *current_scope; /** The current parsing context. */ pm_context_node_t *current_context; /** * The hash keys for the hash that is currently being parsed. This is not * usually necessary because it can pass it down the various call chains, * but in the event that you're parsing a hash that is being directly * pushed into another hash with **, we need to share the hash keys so that * we can warn for the nested hash as well. */ pm_static_literals_t *current_hash_keys; /** * The encoding functions for the current file is attached to the parser as * it's parsing so that it can change with a magic comment. */ const pm_encoding_t *encoding; /** * When the encoding that is being used to parse the source is changed by * prism, we provide the ability here to call out to a user-defined * function. */ pm_encoding_changed_callback_t encoding_changed_callback; /** * This pointer indicates where a comment must start if it is to be * considered an encoding comment. */ const uint8_t *encoding_comment_start; /** * This is an optional callback that can be attached to the parser that will * be called whenever a new token is lexed by the parser. */ pm_lex_callback_t *lex_callback; /** * This is the path of the file being parsed. We use the filepath when * constructing SourceFileNodes. */ pm_string_t filepath; /** * This constant pool keeps all of the constants defined throughout the file * so that we can reference them later. */ pm_constant_pool_t constant_pool; /** This is the list of newline offsets in the source file. */ pm_newline_list_t newline_list; /** * We want to add a flag to integer nodes that indicates their base. We only * want to parse these once, but we don't have space on the token itself to * communicate this information. So we store it here and pass it through * when we find tokens that we need it for. */ pm_node_flags_t integer_base; /** * This string is used to pass information from the lexer to the parser. It * is particularly necessary because of escape sequences. */ pm_string_t current_string; /** * The line number at the start of the parse. This will be used to offset * the line numbers of all of the locations. */ int32_t start_line; /** * When a string-like expression is being lexed, any byte or escape sequence * that resolves to a value whose top bit is set (i.e., >= 0x80) will * explicitly set the encoding to the same encoding as the source. * Alternatively, if a unicode escape sequence is used (e.g., \\u{80}) that * resolves to a value whose top bit is set, then the encoding will be * explicitly set to UTF-8. * * The _next_ time this happens, if the encoding that is about to become the * explicitly set encoding does not match the previously set explicit * encoding, a mixed encoding error will be emitted. * * When the expression is finished being lexed, the explicit encoding * controls the encoding of the expression. For the most part this means * that the expression will either be encoded in the source encoding or * UTF-8. This holds for all encodings except US-ASCII. If the source is * US-ASCII and an explicit encoding was set that was _not_ UTF-8, then the * expression will be encoded as ASCII-8BIT. * * Note that if the expression is a list, different elements within the same * list can have different encodings, so this will get reset between each * element. Furthermore all of this only applies to lists that support * interpolation, because otherwise escapes that could change the encoding * are ignored. * * At first glance, it may make more sense for this to live on the lexer * mode, but we need it here to communicate back to the parser for character * literals that do not push a new lexer mode. */ const pm_encoding_t *explicit_encoding; /** * When parsing block exits (e.g., break, next, redo), we need to validate * that they are in correct contexts. For the most part we can do this by * looking at our parent contexts. However, modifier while and until * expressions can change that context to make block exits valid. In these * cases, we need to keep track of the block exits and then validate them * after the expression has been parsed. * * We use a pointer here because we don't want to keep a whole list attached * since this will only be used in the context of begin/end expressions. */ pm_node_list_t *current_block_exits; /** The version of prism that we should use to parse. */ pm_options_version_t version; /** The command line flags given from the options. */ uint8_t command_line; /** * Whether or not we have found a frozen_string_literal magic comment with * a true or false value. * May be: * - PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED * - PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED * - PM_OPTIONS_FROZEN_STRING_LITERAL_UNSET */ int8_t frozen_string_literal; /** * Whether or not we are parsing an eval string. This impacts whether or not * we should evaluate if block exits/yields are valid. */ bool parsing_eval; /** * Whether or not we are parsing a "partial" script, which is a script that * will be evaluated in the context of another script, so we should not * check jumps (next/break/etc.) for validity. */ bool partial_script; /** Whether or not we're at the beginning of a command. */ bool command_start; /** Whether or not we're currently recovering from a syntax error. */ bool recovering; /** * This is very specialized behavior for when you want to parse in a context * that does not respect encoding comments. Its main use case is translating * into the whitequark/parser AST which re-encodes source files in UTF-8 * before they are parsed and ignores encoding comments. */ bool encoding_locked; /** * Whether or not the encoding has been changed by a magic comment. We use * this to provide a fast path for the lexer instead of going through the * function pointer. */ bool encoding_changed; /** * This flag indicates that we are currently parsing a pattern matching * expression and impacts that calculation of newlines. */ bool pattern_matching_newlines; /** This flag indicates that we are currently parsing a keyword argument. */ bool in_keyword_arg; /** * Whether or not the parser has seen a token that has semantic meaning * (i.e., a token that is not a comment or whitespace). */ bool semantic_token_seen; /** * True if the current regular expression being lexed contains only ASCII * characters. */ bool current_regular_expression_ascii_only; /** * By default, Ruby always warns about mismatched indentation. This can be * toggled with a magic comment. */ bool warn_mismatched_indentation; }; #endif prism-1.5.1/include/prism/prettyprint.h000066400000000000000000000013261506127434000202060ustar00rootroot00000000000000/** * @file prettyprint.h * * An AST node pretty-printer. */ #ifndef PRISM_PRETTYPRINT_H #define PRISM_PRETTYPRINT_H #include "prism/defines.h" #ifdef PRISM_EXCLUDE_PRETTYPRINT void pm_prettyprint(void); #else #include #include "prism/ast.h" #include "prism/parser.h" #include "prism/util/pm_buffer.h" /** * Pretty-prints the AST represented by the given node to the given buffer. * * @param output_buffer The buffer to write the pretty-printed AST to. * @param parser The parser that parsed the AST. * @param node The root node of the AST to pretty-print. */ PRISM_EXPORTED_FUNCTION void pm_prettyprint(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm_node_t *node); #endif #endif prism-1.5.1/include/prism/regexp.h000066400000000000000000000027511506127434000170770ustar00rootroot00000000000000/** * @file regexp.h * * A regular expression parser. */ #ifndef PRISM_REGEXP_H #define PRISM_REGEXP_H #include "prism/defines.h" #include "prism/parser.h" #include "prism/encoding.h" #include "prism/util/pm_memchr.h" #include "prism/util/pm_string.h" #include #include #include /** * This callback is called by pm_regexp_parse() when a named capture group is found. */ typedef void (*pm_regexp_name_callback_t)(const pm_string_t *name, void *data); /** * This callback is called by pm_regexp_parse() when a parse error is found. */ typedef void (*pm_regexp_error_callback_t)(const uint8_t *start, const uint8_t *end, const char *message, void *data); /** * Parse a regular expression. * * @param parser The parser that is currently being used. * @param source The source code to parse. * @param size The size of the source code. * @param extended_mode Whether to parse the regular expression in extended mode. * @param name_callback The optional callback to call when a named capture group is found. * @param name_data The optional data to pass to the name callback. * @param error_callback The callback to call when a parse error is found. * @param error_data The data to pass to the error callback. */ PRISM_EXPORTED_FUNCTION void pm_regexp_parse(pm_parser_t *parser, const uint8_t *source, size_t size, bool extended_mode, pm_regexp_name_callback_t name_callback, void *name_data, pm_regexp_error_callback_t error_callback, void *error_data); #endif prism-1.5.1/include/prism/static_literals.h000066400000000000000000000067671506127434000210060ustar00rootroot00000000000000/** * @file static_literals.h * * A set of static literal nodes that can be checked for duplicates. */ #ifndef PRISM_STATIC_LITERALS_H #define PRISM_STATIC_LITERALS_H #include "prism/defines.h" #include "prism/ast.h" #include "prism/util/pm_newline_list.h" #include #include /** * An internal hash table for a set of nodes. */ typedef struct { /** The array of nodes in the hash table. */ pm_node_t **nodes; /** The size of the hash table. */ uint32_t size; /** The space that has been allocated in the hash table. */ uint32_t capacity; } pm_node_hash_t; /** * Certain sets of nodes (hash keys and when clauses) check for duplicate nodes * to alert the user of potential issues. To do this, we keep a set of the nodes * that have been seen so far, and compare whenever we find a new node. * * We bucket the nodes based on their type to minimize the number of comparisons * that need to be performed. */ typedef struct { /** * This is the set of IntegerNode and SourceLineNode instances. */ pm_node_hash_t integer_nodes; /** * This is the set of FloatNode instances. */ pm_node_hash_t float_nodes; /** * This is the set of RationalNode and ImaginaryNode instances. */ pm_node_hash_t number_nodes; /** * This is the set of StringNode and SourceFileNode instances. */ pm_node_hash_t string_nodes; /** * This is the set of RegularExpressionNode instances. */ pm_node_hash_t regexp_nodes; /** * This is the set of SymbolNode instances. */ pm_node_hash_t symbol_nodes; /** * A pointer to the last TrueNode instance that was inserted, or NULL. */ pm_node_t *true_node; /** * A pointer to the last FalseNode instance that was inserted, or NULL. */ pm_node_t *false_node; /** * A pointer to the last NilNode instance that was inserted, or NULL. */ pm_node_t *nil_node; /** * A pointer to the last SourceEncodingNode instance that was inserted, or * NULL. */ pm_node_t *source_encoding_node; } pm_static_literals_t; /** * Add a node to the set of static literals. * * @param newline_list The list of newline offsets to use to calculate lines. * @param start_line The line number that the parser starts on. * @param literals The set of static literals to add the node to. * @param node The node to add to the set. * @param replace Whether to replace the previous node if one already exists. * @return A pointer to the node that is being overwritten, if there is one. */ pm_node_t * pm_static_literals_add(const pm_newline_list_t *newline_list, int32_t start_line, pm_static_literals_t *literals, pm_node_t *node, bool replace); /** * Free the internal memory associated with the given static literals set. * * @param literals The set of static literals to free. */ void pm_static_literals_free(pm_static_literals_t *literals); /** * Create a string-based representation of the given static literal. * * @param buffer The buffer to write the string to. * @param newline_list The list of newline offsets to use to calculate lines. * @param start_line The line number that the parser starts on. * @param encoding_name The name of the encoding of the source being parsed. * @param node The node to create a string representation of. */ void pm_static_literal_inspect(pm_buffer_t *buffer, const pm_newline_list_t *newline_list, int32_t start_line, const char *encoding_name, const pm_node_t *node); #endif prism-1.5.1/include/prism/util/000077500000000000000000000000001506127434000164045ustar00rootroot00000000000000prism-1.5.1/include/prism/util/pm_buffer.h000066400000000000000000000145371506127434000205340ustar00rootroot00000000000000/** * @file pm_buffer.h * * A wrapper around a contiguous block of allocated memory. */ #ifndef PRISM_BUFFER_H #define PRISM_BUFFER_H #include "prism/defines.h" #include "prism/util/pm_char.h" #include #include #include #include #include /** * A pm_buffer_t is a simple memory buffer that stores data in a contiguous * block of memory. */ typedef struct { /** The length of the buffer in bytes. */ size_t length; /** The capacity of the buffer in bytes that has been allocated. */ size_t capacity; /** A pointer to the start of the buffer. */ char *value; } pm_buffer_t; /** * Return the size of the pm_buffer_t struct. * * @returns The size of the pm_buffer_t struct. */ PRISM_EXPORTED_FUNCTION size_t pm_buffer_sizeof(void); /** * Initialize a pm_buffer_t with the given capacity. * * @param buffer The buffer to initialize. * @param capacity The capacity of the buffer. * @returns True if the buffer was initialized successfully, false otherwise. */ bool pm_buffer_init_capacity(pm_buffer_t *buffer, size_t capacity); /** * Initialize a pm_buffer_t with its default values. * * @param buffer The buffer to initialize. * @returns True if the buffer was initialized successfully, false otherwise. * * \public \memberof pm_buffer_t */ PRISM_EXPORTED_FUNCTION bool pm_buffer_init(pm_buffer_t *buffer); /** * Return the value of the buffer. * * @param buffer The buffer to get the value of. * @returns The value of the buffer. * * \public \memberof pm_buffer_t */ PRISM_EXPORTED_FUNCTION char * pm_buffer_value(const pm_buffer_t *buffer); /** * Return the length of the buffer. * * @param buffer The buffer to get the length of. * @returns The length of the buffer. * * \public \memberof pm_buffer_t */ PRISM_EXPORTED_FUNCTION size_t pm_buffer_length(const pm_buffer_t *buffer); /** * Append the given amount of space as zeroes to the buffer. * * @param buffer The buffer to append to. * @param length The amount of space to append and zero. */ void pm_buffer_append_zeroes(pm_buffer_t *buffer, size_t length); /** * Append a formatted string to the buffer. * * @param buffer The buffer to append to. * @param format The format string to append. * @param ... The arguments to the format string. */ void pm_buffer_append_format(pm_buffer_t *buffer, const char *format, ...) PRISM_ATTRIBUTE_FORMAT(2, 3); /** * Append a string to the buffer. * * @param buffer The buffer to append to. * @param value The string to append. * @param length The length of the string to append. */ void pm_buffer_append_string(pm_buffer_t *buffer, const char *value, size_t length); /** * Append a list of bytes to the buffer. * * @param buffer The buffer to append to. * @param value The bytes to append. * @param length The length of the bytes to append. */ void pm_buffer_append_bytes(pm_buffer_t *buffer, const uint8_t *value, size_t length); /** * Append a single byte to the buffer. * * @param buffer The buffer to append to. * @param value The byte to append. */ void pm_buffer_append_byte(pm_buffer_t *buffer, uint8_t value); /** * Append a 32-bit unsigned integer to the buffer as a variable-length integer. * * @param buffer The buffer to append to. * @param value The integer to append. */ void pm_buffer_append_varuint(pm_buffer_t *buffer, uint32_t value); /** * Append a 32-bit signed integer to the buffer as a variable-length integer. * * @param buffer The buffer to append to. * @param value The integer to append. */ void pm_buffer_append_varsint(pm_buffer_t *buffer, int32_t value); /** * Append a double to the buffer. * * @param buffer The buffer to append to. * @param value The double to append. */ void pm_buffer_append_double(pm_buffer_t *buffer, double value); /** * Append a unicode codepoint to the buffer. * * @param buffer The buffer to append to. * @param value The character to append. * @returns True if the codepoint was valid and appended successfully, false * otherwise. */ bool pm_buffer_append_unicode_codepoint(pm_buffer_t *buffer, uint32_t value); /** * The different types of escaping that can be performed by the buffer when * appending a slice of Ruby source code. */ typedef enum { PM_BUFFER_ESCAPING_RUBY, PM_BUFFER_ESCAPING_JSON } pm_buffer_escaping_t; /** * Append a slice of source code to the buffer. * * @param buffer The buffer to append to. * @param source The source code to append. * @param length The length of the source code to append. * @param escaping The type of escaping to perform. */ void pm_buffer_append_source(pm_buffer_t *buffer, const uint8_t *source, size_t length, pm_buffer_escaping_t escaping); /** * Prepend the given string to the buffer. * * @param buffer The buffer to prepend to. * @param value The string to prepend. * @param length The length of the string to prepend. */ void pm_buffer_prepend_string(pm_buffer_t *buffer, const char *value, size_t length); /** * Concatenate one buffer onto another. * * @param destination The buffer to concatenate onto. * @param source The buffer to concatenate. */ void pm_buffer_concat(pm_buffer_t *destination, const pm_buffer_t *source); /** * Clear the buffer by reducing its size to 0. This does not free the allocated * memory, but it does allow the buffer to be reused. * * @param buffer The buffer to clear. */ void pm_buffer_clear(pm_buffer_t *buffer); /** * Strip the whitespace from the end of the buffer. * * @param buffer The buffer to strip. */ void pm_buffer_rstrip(pm_buffer_t *buffer); /** * Checks if the buffer includes the given value. * * @param buffer The buffer to check. * @param value The value to check for. * @returns The index of the first occurrence of the value in the buffer, or * SIZE_MAX if the value is not found. */ size_t pm_buffer_index(const pm_buffer_t *buffer, char value); /** * Insert the given string into the buffer at the given index. * * @param buffer The buffer to insert into. * @param index The index to insert at. * @param value The string to insert. * @param length The length of the string to insert. */ void pm_buffer_insert(pm_buffer_t *buffer, size_t index, const char *value, size_t length); /** * Free the memory associated with the buffer. * * @param buffer The buffer to free. * * \public \memberof pm_buffer_t */ PRISM_EXPORTED_FUNCTION void pm_buffer_free(pm_buffer_t *buffer); #endif prism-1.5.1/include/prism/util/pm_char.h000066400000000000000000000164231506127434000201740ustar00rootroot00000000000000/** * @file pm_char.h * * Functions for working with characters and strings. */ #ifndef PRISM_CHAR_H #define PRISM_CHAR_H #include "prism/defines.h" #include "prism/util/pm_newline_list.h" #include #include /** * Returns the number of characters at the start of the string that are * whitespace. Disallows searching past the given maximum number of characters. * * @param string The string to search. * @param length The maximum number of characters to search. * @return The number of characters at the start of the string that are * whitespace. */ size_t pm_strspn_whitespace(const uint8_t *string, ptrdiff_t length); /** * Returns the number of characters at the start of the string that are * whitespace while also tracking the location of each newline. Disallows * searching past the given maximum number of characters. * * @param string The string to search. * @param length The maximum number of characters to search. * @param newline_list The list of newlines to populate. * @return The number of characters at the start of the string that are * whitespace. */ size_t pm_strspn_whitespace_newlines(const uint8_t *string, ptrdiff_t length, pm_newline_list_t *newline_list); /** * Returns the number of characters at the start of the string that are inline * whitespace. Disallows searching past the given maximum number of characters. * * @param string The string to search. * @param length The maximum number of characters to search. * @return The number of characters at the start of the string that are inline * whitespace. */ size_t pm_strspn_inline_whitespace(const uint8_t *string, ptrdiff_t length); /** * Returns the number of characters at the start of the string that are decimal * digits. Disallows searching past the given maximum number of characters. * * @param string The string to search. * @param length The maximum number of characters to search. * @return The number of characters at the start of the string that are decimal * digits. */ size_t pm_strspn_decimal_digit(const uint8_t *string, ptrdiff_t length); /** * Returns the number of characters at the start of the string that are * hexadecimal digits. Disallows searching past the given maximum number of * characters. * * @param string The string to search. * @param length The maximum number of characters to search. * @return The number of characters at the start of the string that are * hexadecimal digits. */ size_t pm_strspn_hexadecimal_digit(const uint8_t *string, ptrdiff_t length); /** * Returns the number of characters at the start of the string that are octal * digits or underscores. Disallows searching past the given maximum number of * characters. * * If multiple underscores are found in a row or if an underscore is * found at the end of the number, then the invalid pointer is set to the index * of the first invalid underscore. * * @param string The string to search. * @param length The maximum number of characters to search. * @param invalid The pointer to set to the index of the first invalid * underscore. * @return The number of characters at the start of the string that are octal * digits or underscores. */ size_t pm_strspn_octal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid); /** * Returns the number of characters at the start of the string that are decimal * digits or underscores. Disallows searching past the given maximum number of * characters. * * If multiple underscores are found in a row or if an underscore is * found at the end of the number, then the invalid pointer is set to the index * of the first invalid underscore. * * @param string The string to search. * @param length The maximum number of characters to search. * @param invalid The pointer to set to the index of the first invalid * underscore. * @return The number of characters at the start of the string that are decimal * digits or underscores. */ size_t pm_strspn_decimal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid); /** * Returns the number of characters at the start of the string that are * hexadecimal digits or underscores. Disallows searching past the given maximum * number of characters. * * If multiple underscores are found in a row or if an underscore is * found at the end of the number, then the invalid pointer is set to the index * of the first invalid underscore. * * @param string The string to search. * @param length The maximum number of characters to search. * @param invalid The pointer to set to the index of the first invalid * underscore. * @return The number of characters at the start of the string that are * hexadecimal digits or underscores. */ size_t pm_strspn_hexadecimal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid); /** * Returns the number of characters at the start of the string that are regexp * options. Disallows searching past the given maximum number of characters. * * @param string The string to search. * @param length The maximum number of characters to search. * @return The number of characters at the start of the string that are regexp * options. */ size_t pm_strspn_regexp_option(const uint8_t *string, ptrdiff_t length); /** * Returns the number of characters at the start of the string that are binary * digits or underscores. Disallows searching past the given maximum number of * characters. * * If multiple underscores are found in a row or if an underscore is * found at the end of the number, then the invalid pointer is set to the index * of the first invalid underscore. * * @param string The string to search. * @param length The maximum number of characters to search. * @param invalid The pointer to set to the index of the first invalid * underscore. * @return The number of characters at the start of the string that are binary * digits or underscores. */ size_t pm_strspn_binary_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid); /** * Returns true if the given character is a whitespace character. * * @param b The character to check. * @return True if the given character is a whitespace character. */ bool pm_char_is_whitespace(const uint8_t b); /** * Returns true if the given character is an inline whitespace character. * * @param b The character to check. * @return True if the given character is an inline whitespace character. */ bool pm_char_is_inline_whitespace(const uint8_t b); /** * Returns true if the given character is a binary digit. * * @param b The character to check. * @return True if the given character is a binary digit. */ bool pm_char_is_binary_digit(const uint8_t b); /** * Returns true if the given character is an octal digit. * * @param b The character to check. * @return True if the given character is an octal digit. */ bool pm_char_is_octal_digit(const uint8_t b); /** * Returns true if the given character is a decimal digit. * * @param b The character to check. * @return True if the given character is a decimal digit. */ bool pm_char_is_decimal_digit(const uint8_t b); /** * Returns true if the given character is a hexadecimal digit. * * @param b The character to check. * @return True if the given character is a hexadecimal digit. */ bool pm_char_is_hexadecimal_digit(const uint8_t b); #endif prism-1.5.1/include/prism/util/pm_constant_pool.h000066400000000000000000000153431506127434000221410ustar00rootroot00000000000000/** * @file pm_constant_pool.h * * A data structure that stores a set of strings. * * Each string is assigned a unique id, which can be used to compare strings for * equality. This comparison ends up being much faster than strcmp, since it * only requires a single integer comparison. */ #ifndef PRISM_CONSTANT_POOL_H #define PRISM_CONSTANT_POOL_H #include "prism/defines.h" #include #include #include #include #include /** * When we allocate constants into the pool, we reserve 0 to mean that the slot * is not yet filled. This constant is reused in other places to indicate the * lack of a constant id. */ #define PM_CONSTANT_ID_UNSET 0 /** * A constant id is a unique identifier for a constant in the constant pool. */ typedef uint32_t pm_constant_id_t; /** * A list of constant IDs. Usually used to represent a set of locals. */ typedef struct { /** The number of constant ids in the list. */ size_t size; /** The number of constant ids that have been allocated in the list. */ size_t capacity; /** The constant ids in the list. */ pm_constant_id_t *ids; } pm_constant_id_list_t; /** * Initialize a list of constant ids. * * @param list The list to initialize. */ void pm_constant_id_list_init(pm_constant_id_list_t *list); /** * Initialize a list of constant ids with a given capacity. * * @param list The list to initialize. * @param capacity The initial capacity of the list. */ void pm_constant_id_list_init_capacity(pm_constant_id_list_t *list, size_t capacity); /** * Append a constant id to a list of constant ids. Returns false if any * potential reallocations fail. * * @param list The list to append to. * @param id The id to append. * @return Whether the append succeeded. */ bool pm_constant_id_list_append(pm_constant_id_list_t *list, pm_constant_id_t id); /** * Insert a constant id into a list of constant ids at the specified index. * * @param list The list to insert into. * @param index The index at which to insert. * @param id The id to insert. */ void pm_constant_id_list_insert(pm_constant_id_list_t *list, size_t index, pm_constant_id_t id); /** * Checks if the current constant id list includes the given constant id. * * @param list The list to check. * @param id The id to check for. * @return Whether the list includes the given id. */ bool pm_constant_id_list_includes(pm_constant_id_list_t *list, pm_constant_id_t id); /** * Free the memory associated with a list of constant ids. * * @param list The list to free. */ void pm_constant_id_list_free(pm_constant_id_list_t *list); /** * The type of bucket in the constant pool hash map. This determines how the * bucket should be freed. */ typedef unsigned int pm_constant_pool_bucket_type_t; /** By default, each constant is a slice of the source. */ static const pm_constant_pool_bucket_type_t PM_CONSTANT_POOL_BUCKET_DEFAULT = 0; /** An owned constant is one for which memory has been allocated. */ static const pm_constant_pool_bucket_type_t PM_CONSTANT_POOL_BUCKET_OWNED = 1; /** A constant constant is known at compile time. */ static const pm_constant_pool_bucket_type_t PM_CONSTANT_POOL_BUCKET_CONSTANT = 2; /** A bucket in the hash map. */ typedef struct { /** The incremental ID used for indexing back into the pool. */ unsigned int id: 30; /** The type of the bucket, which determines how to free it. */ pm_constant_pool_bucket_type_t type: 2; /** The hash of the bucket. */ uint32_t hash; } pm_constant_pool_bucket_t; /** A constant in the pool which effectively stores a string. */ typedef struct { /** A pointer to the start of the string. */ const uint8_t *start; /** The length of the string. */ size_t length; } pm_constant_t; /** The overall constant pool, which stores constants found while parsing. */ typedef struct { /** The buckets in the hash map. */ pm_constant_pool_bucket_t *buckets; /** The constants that are stored in the buckets. */ pm_constant_t *constants; /** The number of buckets in the hash map. */ uint32_t size; /** The number of buckets that have been allocated in the hash map. */ uint32_t capacity; } pm_constant_pool_t; /** * Initialize a new constant pool with a given capacity. * * @param pool The pool to initialize. * @param capacity The initial capacity of the pool. * @return Whether the initialization succeeded. */ bool pm_constant_pool_init(pm_constant_pool_t *pool, uint32_t capacity); /** * Return a pointer to the constant indicated by the given constant id. * * @param pool The pool to get the constant from. * @param constant_id The id of the constant to get. * @return A pointer to the constant. */ pm_constant_t * pm_constant_pool_id_to_constant(const pm_constant_pool_t *pool, pm_constant_id_t constant_id); /** * Find a constant in a constant pool. Returns the id of the constant, or 0 if * the constant is not found. * * @param pool The pool to find the constant in. * @param start A pointer to the start of the constant. * @param length The length of the constant. * @return The id of the constant. */ pm_constant_id_t pm_constant_pool_find(const pm_constant_pool_t *pool, const uint8_t *start, size_t length); /** * Insert a constant into a constant pool that is a slice of a source string. * Returns the id of the constant, or 0 if any potential calls to resize fail. * * @param pool The pool to insert the constant into. * @param start A pointer to the start of the constant. * @param length The length of the constant. * @return The id of the constant. */ pm_constant_id_t pm_constant_pool_insert_shared(pm_constant_pool_t *pool, const uint8_t *start, size_t length); /** * Insert a constant into a constant pool from memory that is now owned by the * constant pool. Returns the id of the constant, or 0 if any potential calls to * resize fail. * * @param pool The pool to insert the constant into. * @param start A pointer to the start of the constant. * @param length The length of the constant. * @return The id of the constant. */ pm_constant_id_t pm_constant_pool_insert_owned(pm_constant_pool_t *pool, uint8_t *start, size_t length); /** * Insert a constant into a constant pool from memory that is constant. Returns * the id of the constant, or 0 if any potential calls to resize fail. * * @param pool The pool to insert the constant into. * @param start A pointer to the start of the constant. * @param length The length of the constant. * @return The id of the constant. */ pm_constant_id_t pm_constant_pool_insert_constant(pm_constant_pool_t *pool, const uint8_t *start, size_t length); /** * Free the memory associated with a constant pool. * * @param pool The pool to free. */ void pm_constant_pool_free(pm_constant_pool_t *pool); #endif prism-1.5.1/include/prism/util/pm_integer.h000066400000000000000000000075151506127434000207160ustar00rootroot00000000000000/** * @file pm_integer.h * * This module provides functions for working with arbitrary-sized integers. */ #ifndef PRISM_NUMBER_H #define PRISM_NUMBER_H #include "prism/defines.h" #include "prism/util/pm_buffer.h" #include #include #include #include /** * A structure represents an arbitrary-sized integer. */ typedef struct { /** * The number of allocated values. length is set to 0 if the integer fits * into uint32_t. */ size_t length; /** * List of 32-bit integers. Set to NULL if the integer fits into uint32_t. */ uint32_t *values; /** * Embedded value for small integer. This value is set to 0 if the value * does not fit into uint32_t. */ uint32_t value; /** * Whether or not the integer is negative. It is stored this way so that a * zeroed pm_integer_t is always positive zero. */ bool negative; } pm_integer_t; /** * An enum controlling the base of an integer. It is expected that the base is * already known before parsing the integer, even though it could be derived * from the string itself. */ typedef enum { /** The default decimal base, with no prefix. Leading 0s will be ignored. */ PM_INTEGER_BASE_DEFAULT, /** The binary base, indicated by a 0b or 0B prefix. */ PM_INTEGER_BASE_BINARY, /** The octal base, indicated by a 0, 0o, or 0O prefix. */ PM_INTEGER_BASE_OCTAL, /** The decimal base, indicated by a 0d, 0D, or empty prefix. */ PM_INTEGER_BASE_DECIMAL, /** The hexadecimal base, indicated by a 0x or 0X prefix. */ PM_INTEGER_BASE_HEXADECIMAL, /** * An unknown base, in which case pm_integer_parse will derive it based on * the content of the string. This is less efficient and does more * comparisons, so if callers know the base ahead of time, they should use * that instead. */ PM_INTEGER_BASE_UNKNOWN } pm_integer_base_t; /** * Parse an integer from a string. This assumes that the format of the integer * has already been validated, as internal validation checks are not performed * here. * * @param integer The integer to parse into. * @param base The base of the integer. * @param start The start of the string. * @param end The end of the string. */ void pm_integer_parse(pm_integer_t *integer, pm_integer_base_t base, const uint8_t *start, const uint8_t *end); /** * Compare two integers. This function returns -1 if the left integer is less * than the right integer, 0 if they are equal, and 1 if the left integer is * greater than the right integer. * * @param left The left integer to compare. * @param right The right integer to compare. * @return The result of the comparison. */ int pm_integer_compare(const pm_integer_t *left, const pm_integer_t *right); /** * Reduce a ratio of integers to its simplest form. * * If either the numerator or denominator do not fit into a 32-bit integer, then * this function is a no-op. In the future, we may consider reducing even the * larger numbers, but for now we're going to keep it simple. * * @param numerator The numerator of the ratio. * @param denominator The denominator of the ratio. */ void pm_integers_reduce(pm_integer_t *numerator, pm_integer_t *denominator); /** * Convert an integer to a decimal string. * * @param buffer The buffer to append the string to. * @param integer The integer to convert to a string. * * \public \memberof pm_integer_t */ PRISM_EXPORTED_FUNCTION void pm_integer_string(pm_buffer_t *buffer, const pm_integer_t *integer); /** * Free the internal memory of an integer. This memory will only be allocated if * the integer exceeds the size of a single node in the linked list. * * @param integer The integer to free. * * \public \memberof pm_integer_t */ PRISM_EXPORTED_FUNCTION void pm_integer_free(pm_integer_t *integer); #endif prism-1.5.1/include/prism/util/pm_list.h000066400000000000000000000050541506127434000202300ustar00rootroot00000000000000/** * @file pm_list.h * * An abstract linked list. */ #ifndef PRISM_LIST_H #define PRISM_LIST_H #include "prism/defines.h" #include #include #include #include /** * This struct represents an abstract linked list that provides common * functionality. It is meant to be used any time a linked list is necessary to * store data. * * The linked list itself operates off a set of pointers. Because the pointers * are not necessarily sequential, they can be of any size. We use this fact to * allow the consumer of this linked list to extend the node struct to include * any data they want. This is done by using the pm_list_node_t as the first * member of the struct. * * For example, if we want to store a list of integers, we can do the following: * * ```c * typedef struct { * pm_list_node_t node; * int value; * } pm_int_node_t; * * pm_list_t list = { 0 }; * pm_int_node_t *node = xmalloc(sizeof(pm_int_node_t)); * node->value = 5; * * pm_list_append(&list, &node->node); * ``` * * The pm_list_t struct is used to represent the overall linked list. It * contains a pointer to the head and tail of the list. This allows for easy * iteration and appending of new nodes. */ typedef struct pm_list_node { /** A pointer to the next node in the list. */ struct pm_list_node *next; } pm_list_node_t; /** * This represents the overall linked list. It keeps a pointer to the head and * tail so that iteration is easy and pushing new nodes is easy. */ typedef struct { /** The size of the list. */ size_t size; /** A pointer to the head of the list. */ pm_list_node_t *head; /** A pointer to the tail of the list. */ pm_list_node_t *tail; } pm_list_t; /** * Returns true if the given list is empty. * * @param list The list to check. * @return True if the given list is empty, otherwise false. * * \public \memberof pm_list_t */ PRISM_EXPORTED_FUNCTION bool pm_list_empty_p(pm_list_t *list); /** * Returns the size of the list. * * @param list The list to check. * @return The size of the list. * * \public \memberof pm_list_t */ PRISM_EXPORTED_FUNCTION size_t pm_list_size(pm_list_t *list); /** * Append a node to the given list. * * @param list The list to append to. * @param node The node to append. */ void pm_list_append(pm_list_t *list, pm_list_node_t *node); /** * Deallocate the internal state of the given list. * * @param list The list to free. * * \public \memberof pm_list_t */ PRISM_EXPORTED_FUNCTION void pm_list_free(pm_list_t *list); #endif prism-1.5.1/include/prism/util/pm_memchr.h000066400000000000000000000015771506127434000205360ustar00rootroot00000000000000/** * @file pm_memchr.h * * A custom memchr implementation. */ #ifndef PRISM_MEMCHR_H #define PRISM_MEMCHR_H #include "prism/defines.h" #include "prism/encoding.h" #include /** * We need to roll our own memchr to handle cases where the encoding changes and * we need to search for a character in a buffer that could be the trailing byte * of a multibyte character. * * @param source The source string. * @param character The character to search for. * @param number The maximum number of bytes to search. * @param encoding_changed Whether the encoding changed. * @param encoding A pointer to the encoding. * @return A pointer to the first occurrence of the character in the source * string, or NULL if no such character exists. */ void * pm_memchr(const void *source, int character, size_t number, bool encoding_changed, const pm_encoding_t *encoding); #endif prism-1.5.1/include/prism/util/pm_newline_list.h000066400000000000000000000066141506127434000217540ustar00rootroot00000000000000/** * @file pm_newline_list.h * * A list of byte offsets of newlines in a string. * * When compiling the syntax tree, it's necessary to know the line and column * of many nodes. This is necessary to support things like error messages, * tracepoints, etc. * * It's possible that we could store the start line, start column, end line, and * end column on every node in addition to the offsets that we already store, * but that would be quite a lot of memory overhead. */ #ifndef PRISM_NEWLINE_LIST_H #define PRISM_NEWLINE_LIST_H #include "prism/defines.h" #include #include #include #include /** * A list of offsets of newlines in a string. The offsets are assumed to be * sorted/inserted in ascending order. */ typedef struct { /** A pointer to the start of the source string. */ const uint8_t *start; /** The number of offsets in the list. */ size_t size; /** The capacity of the list that has been allocated. */ size_t capacity; /** The list of offsets. */ size_t *offsets; } pm_newline_list_t; /** * A line and column in a string. */ typedef struct { /** The line number. */ int32_t line; /** The column number. */ uint32_t column; } pm_line_column_t; /** * Initialize a new newline list with the given capacity. Returns true if the * allocation of the offsets succeeds, otherwise returns false. * * @param list The list to initialize. * @param start A pointer to the start of the source string. * @param capacity The initial capacity of the list. * @return True if the allocation of the offsets succeeds, otherwise false. */ bool pm_newline_list_init(pm_newline_list_t *list, const uint8_t *start, size_t capacity); /** * Clear out the newlines that have been appended to the list. * * @param list The list to clear. */ void pm_newline_list_clear(pm_newline_list_t *list); /** * Append a new offset to the newline list. Returns true if the reallocation of * the offsets succeeds (if one was necessary), otherwise returns false. * * @param list The list to append to. * @param cursor A pointer to the offset to append. * @return True if the reallocation of the offsets succeeds (if one was * necessary), otherwise false. */ bool pm_newline_list_append(pm_newline_list_t *list, const uint8_t *cursor); /** * Returns the line of the given offset. If the offset is not in the list, the * line of the closest offset less than the given offset is returned. * * @param list The list to search. * @param cursor A pointer to the offset to search for. * @param start_line The line to start counting from. * @return The line of the given offset. */ int32_t pm_newline_list_line(const pm_newline_list_t *list, const uint8_t *cursor, int32_t start_line); /** * Returns the line and column of the given offset. If the offset is not in the * list, the line and column of the closest offset less than the given offset * are returned. * * @param list The list to search. * @param cursor A pointer to the offset to search for. * @param start_line The line to start counting from. * @return The line and column of the given offset. */ pm_line_column_t pm_newline_list_line_column(const pm_newline_list_t *list, const uint8_t *cursor, int32_t start_line); /** * Free the internal memory allocated for the newline list. * * @param list The list to free. */ void pm_newline_list_free(pm_newline_list_t *list); #endif prism-1.5.1/include/prism/util/pm_string.h000066400000000000000000000143521506127434000205640ustar00rootroot00000000000000/** * @file pm_string.h * * A generic string type that can have various ownership semantics. */ #ifndef PRISM_STRING_H #define PRISM_STRING_H #include "prism/defines.h" #include #include #include #include #include #include // The following headers are necessary to read files using demand paging. #ifdef _WIN32 #include #elif defined(_POSIX_MAPPED_FILES) #include #include #include #elif defined(PRISM_HAS_FILESYSTEM) #include #include #endif /** * A generic string type that can have various ownership semantics. */ typedef struct { /** A pointer to the start of the string. */ const uint8_t *source; /** The length of the string in bytes of memory. */ size_t length; /** The type of the string. This field determines how the string should be freed. */ enum { /** This string is a constant string, and should not be freed. */ PM_STRING_CONSTANT, /** This is a slice of another string, and should not be freed. */ PM_STRING_SHARED, /** This string owns its memory, and should be freed using `pm_string_free()`. */ PM_STRING_OWNED, #ifdef PRISM_HAS_MMAP /** This string is a memory-mapped file, and should be freed using `pm_string_free()`. */ PM_STRING_MAPPED #endif } type; } pm_string_t; /** * Returns the size of the pm_string_t struct. This is necessary to allocate the * correct amount of memory in the FFI backend. * * @return The size of the pm_string_t struct. */ PRISM_EXPORTED_FUNCTION size_t pm_string_sizeof(void); /** * Defines an empty string. This is useful for initializing a string that will * be filled in later. */ #define PM_STRING_EMPTY ((pm_string_t) { .type = PM_STRING_CONSTANT, .source = NULL, .length = 0 }) /** * Initialize a shared string that is based on initial input. * * @param string The string to initialize. * @param start The start of the string. * @param end The end of the string. */ void pm_string_shared_init(pm_string_t *string, const uint8_t *start, const uint8_t *end); /** * Initialize an owned string that is responsible for freeing allocated memory. * * @param string The string to initialize. * @param source The source of the string. * @param length The length of the string. */ void pm_string_owned_init(pm_string_t *string, uint8_t *source, size_t length); /** * Initialize a constant string that doesn't own its memory source. * * @param string The string to initialize. * @param source The source of the string. * @param length The length of the string. */ void pm_string_constant_init(pm_string_t *string, const char *source, size_t length); /** * Represents the result of calling pm_string_mapped_init or * pm_string_file_init. We need this additional information because there is * not a platform-agnostic way to indicate that the file that was attempted to * be opened was a directory. */ typedef enum { /** Indicates that the string was successfully initialized. */ PM_STRING_INIT_SUCCESS = 0, /** * Indicates a generic error from a string_*_init function, where the type * of error should be read from `errno` or `GetLastError()`. */ PM_STRING_INIT_ERROR_GENERIC = 1, /** * Indicates that the file that was attempted to be opened was a directory. */ PM_STRING_INIT_ERROR_DIRECTORY = 2 } pm_string_init_result_t; /** * Read the file indicated by the filepath parameter into source and load its * contents and size into the given `pm_string_t`. The given `pm_string_t` * should be freed using `pm_string_free` when it is no longer used. * * We want to use demand paging as much as possible in order to avoid having to * read the entire file into memory (which could be detrimental to performance * for large files). This means that if we're on windows we'll use * `MapViewOfFile`, on POSIX systems that have access to `mmap` we'll use * `mmap`, and on other POSIX systems we'll use `read`. * * @param string The string to initialize. * @param filepath The filepath to read. * @return The success of the read, indicated by the value of the enum. * * \public \memberof pm_string_t */ PRISM_EXPORTED_FUNCTION pm_string_init_result_t pm_string_mapped_init(pm_string_t *string, const char *filepath); /** * Read the file indicated by the filepath parameter into source and load its * contents and size into the given `pm_string_t`. The given `pm_string_t` * should be freed using `pm_string_free` when it is no longer used. * * @param string The string to initialize. * @param filepath The filepath to read. * @return The success of the read, indicated by the value of the enum. * * \public \memberof pm_string_t */ PRISM_EXPORTED_FUNCTION pm_string_init_result_t pm_string_file_init(pm_string_t *string, const char *filepath); /** * Ensure the string is owned. If it is not, then reinitialize it as owned and * copy over the previous source. * * @param string The string to ensure is owned. */ void pm_string_ensure_owned(pm_string_t *string); /** * Compare the underlying lengths and bytes of two strings. Returns 0 if the * strings are equal, a negative number if the left string is less than the * right string, and a positive number if the left string is greater than the * right string. * * @param left The left string to compare. * @param right The right string to compare. * @return The comparison result. */ int pm_string_compare(const pm_string_t *left, const pm_string_t *right); /** * Returns the length associated with the string. * * @param string The string to get the length of. * @return The length of the string. * * \public \memberof pm_string_t */ PRISM_EXPORTED_FUNCTION size_t pm_string_length(const pm_string_t *string); /** * Returns the start pointer associated with the string. * * @param string The string to get the start pointer of. * @return The start pointer of the string. * * \public \memberof pm_string_t */ PRISM_EXPORTED_FUNCTION const uint8_t * pm_string_source(const pm_string_t *string); /** * Free the associated memory of the given string. * * @param string The string to free. * * \public \memberof pm_string_t */ PRISM_EXPORTED_FUNCTION void pm_string_free(pm_string_t *string); #endif prism-1.5.1/include/prism/util/pm_strncasecmp.h000066400000000000000000000017741506127434000216040ustar00rootroot00000000000000/** * @file pm_strncasecmp.h * * A custom strncasecmp implementation. */ #ifndef PRISM_STRNCASECMP_H #define PRISM_STRNCASECMP_H #include "prism/defines.h" #include #include #include /** * Compare two strings, ignoring case, up to the given length. Returns 0 if the * strings are equal, a negative number if string1 is less than string2, or a * positive number if string1 is greater than string2. * * Note that this is effectively our own implementation of strncasecmp, but it's * not available on all of the platforms we want to support so we're rolling it * here. * * @param string1 The first string to compare. * @param string2 The second string to compare * @param length The maximum number of characters to compare. * @return 0 if the strings are equal, a negative number if string1 is less than * string2, or a positive number if string1 is greater than string2. */ int pm_strncasecmp(const uint8_t *string1, const uint8_t *string2, size_t length); #endif prism-1.5.1/include/prism/util/pm_strpbrk.h000066400000000000000000000035101506127434000207370ustar00rootroot00000000000000/** * @file pm_strpbrk.h * * A custom strpbrk implementation. */ #ifndef PRISM_STRPBRK_H #define PRISM_STRPBRK_H #include "prism/defines.h" #include "prism/diagnostic.h" #include "prism/parser.h" #include #include /** * Here we have rolled our own version of strpbrk. The standard library strpbrk * has undefined behavior when the source string is not null-terminated. We want * to support strings that are not null-terminated because pm_parse does not * have the contract that the string is null-terminated. (This is desirable * because it means the extension can call pm_parse with the result of a call to * mmap). * * The standard library strpbrk also does not support passing a maximum length * to search. We want to support this for the reason mentioned above, but we * also don't want it to stop on null bytes. Ruby actually allows null bytes * within strings, comments, regular expressions, etc. So we need to be able to * skip past them. * * Finally, we want to support encodings wherein the charset could contain * characters that are trailing bytes of multi-byte characters. For example, in * Shift-JIS, the backslash character can be a trailing byte. In that case we * need to take a slower path and iterate one multi-byte character at a time. * * @param parser The parser. * @param source The source to search. * @param charset The charset to search for. * @param length The maximum number of bytes to search. * @param validate Whether to validate that the source string is valid in the * current encoding of the parser. * @return A pointer to the first character in the source string that is in the * charset, or NULL if no such character exists. */ const uint8_t * pm_strpbrk(pm_parser_t *parser, const uint8_t *source, const uint8_t *charset, ptrdiff_t length, bool validate); #endif prism-1.5.1/include/prism/version.h000066400000000000000000000007601506127434000172700ustar00rootroot00000000000000/** * @file version.h * * The version of the Prism library. */ #ifndef PRISM_VERSION_H #define PRISM_VERSION_H /** * The major version of the Prism library as an int. */ #define PRISM_VERSION_MAJOR 1 /** * The minor version of the Prism library as an int. */ #define PRISM_VERSION_MINOR 5 /** * The patch version of the Prism library as an int. */ #define PRISM_VERSION_PATCH 1 /** * The version of the Prism library as a constant string. */ #define PRISM_VERSION "1.5.1" #endif prism-1.5.1/java-wasm/000077500000000000000000000000001506127434000145405ustar00rootroot00000000000000prism-1.5.1/java-wasm/.gitignore000066400000000000000000000000151506127434000165240ustar00rootroot00000000000000target .idea prism-1.5.1/java-wasm/pom.xml000066400000000000000000000104331506127434000160560ustar00rootroot00000000000000 4.0.0 com.prism java-prism 999-SNAPSHOT Java Prism Pure Java Prism interpreting WASM UTF-8 UTF-8 11 11 1.3.0 5.13.4 com.dylibso.chicory bom ${chicory.version} pom import com.dylibso.chicory runtime com.dylibso.chicory log com.dylibso.chicory wasi com.dylibso.chicory wasm org.junit.jupiter junit-jupiter-engine ${junit.version} test com.dylibso.chicory host-module-annotations-experimental provided org.codehaus.mojo templating-maven-plugin 3.0.0 filtering-java-templates filter-sources org.apache.maven.plugins maven-compiler-plugin 3.14.0 11 com.dylibso.chicory host-module-processor-experimental ${chicory.version} org.apache.maven.plugins maven-surefire-plugin 3.5.3 org.codehaus.mojo build-helper-maven-plugin 3.6.1 generate-sources add-source ../java com.dylibso.chicory aot-maven-plugin-experimental ${chicory.version} prism wasm-aot-gen org.prism.Prism src/test/resources/prism.wasm prism-1.5.1/java-wasm/src/000077500000000000000000000000001506127434000153275ustar00rootroot00000000000000prism-1.5.1/java-wasm/src/main/000077500000000000000000000000001506127434000162535ustar00rootroot00000000000000prism-1.5.1/java-wasm/src/main/java-templates/000077500000000000000000000000001506127434000211705ustar00rootroot00000000000000prism-1.5.1/java-wasm/src/main/java-templates/org/000077500000000000000000000000001506127434000217575ustar00rootroot00000000000000prism-1.5.1/java-wasm/src/main/java-templates/org/prism/000077500000000000000000000000001506127434000231115ustar00rootroot00000000000000prism-1.5.1/java-wasm/src/main/java-templates/org/prism/WasmResource.java000066400000000000000000000003001506127434000263640ustar00rootroot00000000000000package org.prism; public final class WasmResource { public static final String absoluteFile = "file://${project.basedir}/src/test/resources/prism.wasm"; private WasmResource() {} } prism-1.5.1/java-wasm/src/main/java/000077500000000000000000000000001506127434000171745ustar00rootroot00000000000000prism-1.5.1/java-wasm/src/main/java/org/000077500000000000000000000000001506127434000177635ustar00rootroot00000000000000prism-1.5.1/java-wasm/src/main/java/org/prism/000077500000000000000000000000001506127434000211155ustar00rootroot00000000000000prism-1.5.1/java-wasm/src/main/java/org/prism/Prism.java000066400000000000000000000060211506127434000230510ustar00rootroot00000000000000package org.prism; import com.dylibso.chicory.runtime.ByteArrayMemory; import com.dylibso.chicory.experimental.hostmodule.annotations.WasmModuleInterface; import com.dylibso.chicory.runtime.ImportValues; import com.dylibso.chicory.runtime.Instance; import com.dylibso.chicory.wasi.WasiOptions; import com.dylibso.chicory.wasi.WasiPreview1; import com.dylibso.chicory.wasm.types.MemoryLimits; import java.nio.charset.StandardCharsets; @WasmModuleInterface(WasmResource.absoluteFile) public class Prism implements AutoCloseable { private final WasiPreview1 wasi; private final Instance instance; private final Prism_ModuleExports exports; public Prism() { this(WasiOptions.builder().build()); } public Prism(WasiOptions wasiOpts) { wasi = WasiPreview1.builder().withOptions(wasiOpts).build(); instance = Instance.builder(PrismModule.load()) .withMemoryFactory(limits -> new ByteArrayMemory(new MemoryLimits(10, MemoryLimits.MAX_PAGES))) .withMachineFactory(PrismModule::create) .withImportValues(ImportValues.builder().addFunction(wasi.toHostFunctions()).build()) .build(); exports = new Prism_ModuleExports(instance); } public Prism_ModuleExports exports() { return exports; } public byte[] serialize(byte[] packedOptions, byte[] source, int sourceLength) { int sourcePointer = 0; int optionsPointer = 0; int bufferPointer = 0; int resultPointer = 0; byte[] result; try { sourcePointer = exports.calloc(1, sourceLength); exports.memory().write(sourcePointer, source); optionsPointer = exports.calloc(1, packedOptions.length); exports.memory().write(optionsPointer, packedOptions); bufferPointer = exports.calloc(exports.pmBufferSizeof(), 1); exports.pmBufferInit(bufferPointer); exports.pmSerializeParse(bufferPointer, sourcePointer, sourceLength, optionsPointer); resultPointer = exports.pmBufferValue(bufferPointer); result = instance.memory().readBytes( resultPointer, exports.pmBufferLength(bufferPointer)); } finally { if (sourcePointer != 0) { exports.free(sourcePointer); } if (optionsPointer != 0) { exports.free(optionsPointer); } if (bufferPointer != 0) { exports.free(bufferPointer); } if (resultPointer != 0) { exports.free(resultPointer); } } return result; } public ParseResult serializeParse(byte[] packedOptions, String source) { var sourceBytes = source.getBytes(StandardCharsets.US_ASCII); byte[] result = serialize(packedOptions, sourceBytes, sourceBytes.length); return Loader.load(result, sourceBytes); } @Override public void close() { if (wasi != null) { wasi.close(); } } } prism-1.5.1/java-wasm/src/test/000077500000000000000000000000001506127434000163065ustar00rootroot00000000000000prism-1.5.1/java-wasm/src/test/java/000077500000000000000000000000001506127434000172275ustar00rootroot00000000000000prism-1.5.1/java-wasm/src/test/java/org/000077500000000000000000000000001506127434000200165ustar00rootroot00000000000000prism-1.5.1/java-wasm/src/test/java/org/prism/000077500000000000000000000000001506127434000211505ustar00rootroot00000000000000prism-1.5.1/java-wasm/src/test/java/org/prism/DummyTest.java000066400000000000000000000133741506127434000237560ustar00rootroot00000000000000package org.prism; import com.dylibso.chicory.runtime.ImportValues; import com.dylibso.chicory.runtime.Instance; import com.dylibso.chicory.wasi.WasiOptions; import com.dylibso.chicory.wasi.WasiPreview1; import com.dylibso.chicory.wasm.Parser; import com.dylibso.chicory.wasm.types.Value; import org.junit.jupiter.api.Test; import java.nio.charset.StandardCharsets; import java.util.EnumSet; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; public class DummyTest { private static final byte[] packedOptions = ParsingOptions.serialize( new byte[] {}, 1, new byte[] {}, false, EnumSet.noneOf(ParsingOptions.CommandLine.class), ParsingOptions.SyntaxVersion.LATEST, false, false, false, new byte[][][] {} ); @Test public void test1() { WasiOptions wasiOpts = WasiOptions.builder().build(); WasiPreview1 wasi = WasiPreview1.builder().withOptions(wasiOpts).build(); var wasmPrism = Instance.builder(Parser.parse(DummyTest.class.getResourceAsStream("/prism.wasm"))) .withImportValues(ImportValues.builder().addFunction(wasi.toHostFunctions()).build()) .build(); var memory = wasmPrism.memory(); var calloc = wasmPrism.export("calloc"); var pmSerializeParse = wasmPrism.export("pm_serialize_parse"); var pmBufferInit = wasmPrism.export("pm_buffer_init"); var pmBufferSizeof = wasmPrism.export("pm_buffer_sizeof"); var pmBufferValue = wasmPrism.export("pm_buffer_value"); var pmBufferLength = wasmPrism.export("pm_buffer_length"); // The Ruby source code to be processed var source = "1 + 1"; var sourceBytes = source.getBytes(StandardCharsets.US_ASCII); var sourcePointer = calloc.apply(1, source.length()); memory.writeString((int) sourcePointer[0], source); var optionsPointer = calloc.apply(1, packedOptions.length); memory.write((int) optionsPointer[0], packedOptions); var bufferPointer = calloc.apply(pmBufferSizeof.apply()[0], 1); pmBufferInit.apply(bufferPointer); pmSerializeParse.apply( bufferPointer[0], sourcePointer[0], source.length(), optionsPointer[0]); var result = memory.readBytes( (int) pmBufferValue.apply(bufferPointer[0])[0], (int) pmBufferLength.apply(bufferPointer[0])[0]); System.out.println("RESULT: " + new String(result)); ParseResult pr = Loader.load(result, sourceBytes); assertEquals(1, pr.value.childNodes().length); System.out.println("Nodes:"); System.out.println(pr.value.childNodes()[0]); assertTrue(pr.value.childNodes()[0].toString().contains("IntegerNode")); } @Test public void test1Aot() { // The Ruby source code to be processed var source = "1 + 1"; ParseResult pr = null; try (Prism prism = new Prism()) { pr = prism.serializeParse(packedOptions, source); } assertEquals(1, pr.value.childNodes().length); System.out.println("Nodes:"); System.out.println(pr.value.childNodes()[0]); assertTrue(pr.value.childNodes()[0].toString().contains("IntegerNode")); } @Test public void test2() { WasiOptions wasiOpts = WasiOptions.builder().build(); WasiPreview1 wasi = WasiPreview1.builder().withOptions(wasiOpts).build(); var wasmPrism = Instance.builder(Parser.parse(DummyTest.class.getResourceAsStream("/prism.wasm"))) .withImportValues(ImportValues.builder().addFunction(wasi.toHostFunctions()).build()) .build(); var memory = wasmPrism.memory(); var calloc = wasmPrism.export("calloc"); var pmSerializeParse = wasmPrism.export("pm_serialize_parse"); var pmBufferInit = wasmPrism.export("pm_buffer_init"); var pmBufferSizeof = wasmPrism.export("pm_buffer_sizeof"); var pmBufferValue = wasmPrism.export("pm_buffer_value"); var pmBufferLength = wasmPrism.export("pm_buffer_length"); // The Ruby source code to be processed var source = "puts \"h\ne\nl\nl\no\n\""; var sourceBytes = source.getBytes(StandardCharsets.US_ASCII); var sourcePointer = calloc.apply(1, source.length()); memory.writeString((int) sourcePointer[0], source); var optionsPointer = calloc.apply(1, packedOptions.length); memory.write((int) optionsPointer[0], packedOptions); var bufferPointer = calloc.apply(pmBufferSizeof.apply()[0], 1); pmBufferInit.apply(bufferPointer); pmSerializeParse.apply( bufferPointer[0], sourcePointer[0], source.length(), optionsPointer[0]); var result = memory.readBytes( (int) pmBufferValue.apply(bufferPointer[0])[0], (int) pmBufferLength.apply(bufferPointer[0])[0]); System.out.println("RESULT: " + new String(result)); ParseResult pr = Loader.load(result, sourceBytes); assertEquals(1, pr.value.childNodes().length); System.out.println("Nodes:"); System.out.println(pr.value.childNodes()[0]); assertTrue(pr.value.childNodes()[0].toString().contains("CallNode")); } @Test public void test2Aot() { // The Ruby source code to be processed var source = "puts \"h\ne\nl\nl\no\n\""; ParseResult pr = null; try (Prism prism = new Prism()) { pr = prism.serializeParse(packedOptions, source); } assertEquals(1, pr.value.childNodes().length); System.out.println("Nodes:"); System.out.println(pr.value.childNodes()[0]); assertTrue(pr.value.childNodes()[0].toString().contains("CallNode")); } } prism-1.5.1/java-wasm/src/test/resources/000077500000000000000000000000001506127434000203205ustar00rootroot00000000000000prism-1.5.1/java-wasm/src/test/resources/.gitignore000066400000000000000000000000131506127434000223020ustar00rootroot00000000000000prism.wasm prism-1.5.1/java/000077500000000000000000000000001506127434000135735ustar00rootroot00000000000000prism-1.5.1/java/org/000077500000000000000000000000001506127434000143625ustar00rootroot00000000000000prism-1.5.1/java/org/prism/000077500000000000000000000000001506127434000155145ustar00rootroot00000000000000prism-1.5.1/java/org/prism/MarkNewlinesVisitor.java000066400000000000000000000034031506127434000223360ustar00rootroot00000000000000package org.prism; // Keep in sync with Ruby MarkNewlinesVisitor final class MarkNewlinesVisitor extends AbstractNodeVisitor { private final Nodes.Source source; private boolean[] newlineMarked; MarkNewlinesVisitor(Nodes.Source source, boolean[] newlineMarked) { this.source = source; this.newlineMarked = newlineMarked; } @Override public Void visitBlockNode(Nodes.BlockNode node) { boolean[] oldNewlineMarked = this.newlineMarked; this.newlineMarked = new boolean[oldNewlineMarked.length]; try { return super.visitBlockNode(node); } finally { this.newlineMarked = oldNewlineMarked; } } @Override public Void visitLambdaNode(Nodes.LambdaNode node) { boolean[] oldNewlineMarked = this.newlineMarked; this.newlineMarked = new boolean[oldNewlineMarked.length]; try { return super.visitLambdaNode(node); } finally { this.newlineMarked = oldNewlineMarked; } } @Override public Void visitIfNode(Nodes.IfNode node) { node.setNewLineFlag(this.source, this.newlineMarked); return super.visitIfNode(node); } @Override public Void visitUnlessNode(Nodes.UnlessNode node) { node.setNewLineFlag(this.source, this.newlineMarked); return super.visitUnlessNode(node); } @Override public Void visitStatementsNode(Nodes.StatementsNode node) { for (Nodes.Node child : node.body) { child.setNewLineFlag(this.source, this.newlineMarked); } return super.visitStatementsNode(node); } @Override protected Void defaultVisit(Nodes.Node node) { node.visitChildNodes(this); return null; } } prism-1.5.1/java/org/prism/ParseResult.java000066400000000000000000000051041506127434000206300ustar00rootroot00000000000000package org.prism; // @formatter:off public final class ParseResult { public static final class MagicComment { public final Nodes.Location keyLocation; public final Nodes.Location valueLocation; public MagicComment(Nodes.Location keyLocation, Nodes.Location valueLocation) { this.keyLocation = keyLocation; this.valueLocation = valueLocation; } } public enum ErrorLevel { /** For errors that should raise SyntaxError. */ ERROR_SYNTAX, /** For errors that should raise ArgumentError. */ ERROR_ARGUMENT, /** For errors that should raise LoadError. */ ERROR_LOAD, } public static ErrorLevel[] ERROR_LEVELS = ErrorLevel.values(); public static final class Error { public final Nodes.ErrorType type; public final String message; public final Nodes.Location location; public final ErrorLevel level; public Error(Nodes.ErrorType type, String message, Nodes.Location location, ErrorLevel level) { this.type = type; this.message = message; this.location = location; this.level = level; } } public enum WarningLevel { /** For warnings which should be emitted if $VERBOSE != nil. */ WARNING_DEFAULT, /** For warnings which should be emitted if $VERBOSE == true. */ WARNING_VERBOSE } public static WarningLevel[] WARNING_LEVELS = WarningLevel.values(); public static final class Warning { public final Nodes.WarningType type; public final String message; public final Nodes.Location location; public final WarningLevel level; public Warning(Nodes.WarningType type, String message, Nodes.Location location, WarningLevel level) { this.type = type; this.message = message; this.location = location; this.level = level; } } public final Nodes.Node value; public final MagicComment[] magicComments; public final Nodes.Location dataLocation; public final Error[] errors; public final Warning[] warnings; public final Nodes.Source source; public ParseResult(Nodes.Node value, MagicComment[] magicComments, Nodes.Location dataLocation, Error[] errors, Warning[] warnings, Nodes.Source source) { this.value = value; this.magicComments = magicComments; this.dataLocation = dataLocation; this.errors = errors; this.warnings = warnings; this.source = source; } } // @formatter:on prism-1.5.1/java/org/prism/Parser.java000066400000000000000000000005641506127434000176200ustar00rootroot00000000000000package org.prism; public abstract class Parser { @SuppressWarnings("restricted") public static void loadLibrary(String path) { System.load(path); } public static native byte[] parseAndSerialize(byte[] source, byte[] options); public static byte[] parseAndSerialize(byte[] source) { return parseAndSerialize(source, null); } } prism-1.5.1/java/org/prism/ParsingOptions.java000066400000000000000000000137531506127434000213470ustar00rootroot00000000000000package org.prism; import java.io.ByteArrayOutputStream; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.EnumSet; // @formatter:off public abstract class ParsingOptions { /** * The version of Ruby syntax that we should be parsing with. * See pm_options_version_t in include/prism/options.h. */ public enum SyntaxVersion { LATEST(0), // Handled in pm_parser_init V3_3(1), V3_4(2), V3_5(3); private final int value; SyntaxVersion(int value) { this.value = value; } public byte getValue() { return (byte) value; } } /** * The command line options that can be passed to the parser. * See PM_OPTIONS_COMMAND_LINE_* in include/prism/options.h. * * NOTE: positions should match PM_OPTIONS_COMMAND_LINE_* constants values */ public enum CommandLine { A, E, L, N, P, X }; /** * The forwarding options for a given scope in the parser. */ public enum Forwarding { NONE(0), POSITIONAL(1), KEYWORD(2), BLOCK(4), ALL(8); private final int value; Forwarding(int value) { this.value = value; } public byte getValue() { return (byte) value; } }; /** * Represents a scope in the parser. */ public static class Scope { private byte[][] locals; private Forwarding[] forwarding; public Scope(byte[][] locals) { this(locals, new Forwarding[0]); } public Scope(Forwarding[] forwarding) { this(new byte[0][], forwarding); } public Scope(byte[][] locals, Forwarding[] forwarding) { this.locals = locals; this.forwarding = forwarding; } public byte[][] getLocals() { return locals; } public int getForwarding() { int value = 0; for (Forwarding f : forwarding) { value |= f.getValue(); } return value; } } public static byte[] serialize(byte[] filepath, int line, byte[] encoding, boolean frozenStringLiteral, EnumSet commandLine, SyntaxVersion version, boolean encodingLocked, boolean mainScript, boolean partialScript, byte[][][] scopes) { Scope[] normalizedScopes = new Scope[scopes.length]; for (int i = 0; i < scopes.length; i++) { normalizedScopes[i] = new Scope(scopes[i]); } return serialize(filepath, line, encoding, frozenStringLiteral, commandLine, version, encodingLocked, mainScript, partialScript, normalizedScopes); } /** * Serialize parsing options into byte array. * * @param filepath the name of the file that is currently being parsed * @param line the line within the file that the parser starts on. This value is 1-indexed * @param encoding the name of the encoding that the source file is in * @param frozenStringLiteral whether the frozen string literal option has been set * @param commandLine the set of flags that were set on the command line * @param version code of Ruby version which syntax will be used to parse * @param encodingLocked whether the encoding is locked (should almost always be false) * @param mainScript whether the file is the main script * @param partialScript whether the file is a partial script * @param scopes scopes surrounding the code that is being parsed with local variable names defined in every scope * ordered from the outermost scope to the innermost one */ public static byte[] serialize(byte[] filepath, int line, byte[] encoding, boolean frozenStringLiteral, EnumSet commandLine, SyntaxVersion version, boolean encodingLocked, boolean mainScript, boolean partialScript, Scope[] scopes) { final ByteArrayOutputStream output = new ByteArrayOutputStream(); // filepath write(output, serializeInt(filepath.length)); write(output, filepath); // line write(output, serializeInt(line)); // encoding write(output, serializeInt(encoding.length)); write(output, encoding); // frozenStringLiteral output.write(frozenStringLiteral ? 1 : 0); // command line output.write(serializeEnumSet(commandLine)); // version output.write(version.getValue()); // encodingLocked output.write(encodingLocked ? 1 : 0); // mainScript output.write(mainScript ? 1 : 0); // partialScript output.write(partialScript ? 1 : 0); // freeze output.write(0); // scopes // number of scopes write(output, serializeInt(scopes.length)); // local variables in each scope for (Scope scope : scopes) { byte[][] locals = scope.getLocals(); // number of locals write(output, serializeInt(locals.length)); // forwarding flags output.write(scope.getForwarding()); // locals for (byte[] local : locals) { write(output, serializeInt(local.length)); write(output, local); } } return output.toByteArray(); } private static void write(ByteArrayOutputStream output, byte[] bytes) { // Note: we cannot use output.writeBytes(local) because that's Java 11 output.write(bytes, 0, bytes.length); } private static > byte serializeEnumSet(EnumSet set) { byte result = 0; for (T value : set) { assert (1 << value.ordinal()) <= Byte.MAX_VALUE; result |= (byte) (1 << value.ordinal()); } return result; } private static byte[] serializeInt(int n) { ByteBuffer buffer = ByteBuffer.allocate(4).order(ByteOrder.nativeOrder()); buffer.putInt(n); return buffer.array(); } } // @formatter:on prism-1.5.1/javascript/000077500000000000000000000000001506127434000150205ustar00rootroot00000000000000prism-1.5.1/javascript/README.md000066400000000000000000000003101506127434000162710ustar00rootroot00000000000000# @ruby/prism JavaScript bindings for Ruby's [prism](https://github.com/ruby/prism) parser. See the [JavaScript documentation](https://github.com/ruby/prism/blob/main/docs/javascript.md) for Prism. prism-1.5.1/javascript/example.html000066400000000000000000000025461506127434000173500ustar00rootroot00000000000000 @ruby/prism 
  
      

    

    
  

prism-1.5.1/javascript/package.json000066400000000000000000000006261506127434000173120ustar00rootroot00000000000000{
  "name": "@ruby/prism",
  "version": "1.5.1",
  "description": "Prism Ruby parser",
  "type": "module",
  "main": "src/index.js",
  "types": "src/index.d.ts",
  "scripts": {
    "prepublishOnly": "npm run type",
    "test": "node test.js",
    "type": "tsc --allowJs -d --target ES2015 --emitDeclarationOnly --outDir src src/index.js"
  },
  "author": "Shopify ",
  "license": "MIT"
}
prism-1.5.1/javascript/src/000077500000000000000000000000001506127434000156075ustar00rootroot00000000000000prism-1.5.1/javascript/src/index.js000066400000000000000000000015731506127434000172620ustar00rootroot00000000000000import { WASI } from "wasi";
import { readFile } from "node:fs/promises";
import { fileURLToPath } from "node:url";

import { ParseResult } from "./deserialize.js";
import { parsePrism } from "./parsePrism.js";

export * from "./visitor.js";
export * from "./nodes.js";

/**
 * Load the prism wasm module and return a parse function.
 *
 * @typedef {import("./parsePrism.js").Options} Options
 *
 * @returns {Promise<(source: string, options?: Options) => ParseResult>}
 */
export async function loadPrism() {
  const wasm = await WebAssembly.compile(await readFile(fileURLToPath(new URL("prism.wasm", import.meta.url))));
  const wasi = new WASI({ version: "preview1" });

  const instance = await WebAssembly.instantiate(wasm, wasi.getImportObject());
  wasi.initialize(instance);

  return function (source, options = {}) {
    return parsePrism(instance.exports, source, options);
  }
}
prism-1.5.1/javascript/src/parsePrism.js000066400000000000000000000171241506127434000202770ustar00rootroot00000000000000import { ParseResult, deserialize } from "./deserialize.js";

/**
 * Parse the given source code.
 *
 * @typedef {{
 *   locals?: string[],
 *   forwarding?: string[]
 * }} Scope
 *
 * @typedef {{
 *   filepath?: string,
 *   line?: number,
 *   encoding?: string | false,
 *   frozen_string_literal?: boolean,
 *   command_line?: string,
 *   version?: string,
 *   main_script?: boolean,
 *   partial_script?: boolean,
 *   scopes?: (string[] | Scope)[]
 * }} Options
 *
 * @param {WebAssembly.Exports} prism
 * @param {string} source
 * @param {Options} options
 * @returns {ParseResult}
 */
export function parsePrism(prism, source, options = {}) {
  const sourceArray = new TextEncoder().encode(source);
  const sourcePointer = prism.calloc(1, sourceArray.length);

  const packedOptions = dumpOptions(options);
  const optionsPointer = prism.calloc(1, packedOptions.length);

  const bufferPointer = prism.calloc(prism.pm_buffer_sizeof(), 1);
  prism.pm_buffer_init(bufferPointer);

  const sourceView = new Uint8Array(prism.memory.buffer, sourcePointer, sourceArray.length);
  sourceView.set(sourceArray);

  const optionsView = new Uint8Array(prism.memory.buffer, optionsPointer, packedOptions.length);
  optionsView.set(packedOptions);

  prism.pm_serialize_parse(bufferPointer, sourcePointer, sourceArray.length, optionsPointer);
  const serializedView = new Uint8Array(prism.memory.buffer, prism.pm_buffer_value(bufferPointer), prism.pm_buffer_length(bufferPointer));
  const result = deserialize(sourceArray, serializedView);

  prism.pm_buffer_free(bufferPointer);
  prism.free(sourcePointer);
  prism.free(bufferPointer);
  prism.free(optionsPointer);
  return result;
}

/**
 * Dump the command line options into a serialized format.
 *
 * @param {Options} options
 * @returns {number}
 */
function dumpCommandLineOptions(options) {
  if (options.command_line === undefined) {
    return 0;
  }

  const commandLine = options.command_line;
  if (typeof commandLine !== "string") {
    throw new Error("command_line must be a string");
  }

  let value = 0;
  for (let index = 0; index < commandLine.length; index++) {
    switch (commandLine[index]) {
      case "a": value |= 1; break;
      case "e": value |= 2; break;
      case "l": value |= 4; break;
      case "n": value |= 8; break;
      case "p": value |= 16; break;
      case "x": value |= 32; break;
      default: throw new Error(`Unsupported command line flag '${commandLine[index]}'`);
    }
  }

  return value;
}

/**
 * Convert a boolean value into a serialized byte.
 *
 * @param {boolean} value
 * @returns {number}
 */
function dumpBooleanOption(value) {
  return (value === undefined || value === false || value === null) ? 0 : 1;
}

/** 
 * Converts the given options into a serialized options string.
 *
 * @param {Options} options
 * @returns {Uint8Array}
 */
function dumpOptions(options) {
  /** @type {PackTemplate} */
  const template = [];

  /** @type {PackValues} */
  const values = [];

  /** @type {TextEncoder} */
  const encoder = new TextEncoder();

  template.push("L")
  if (options.filepath) {
    const filepath = encoder.encode(options.filepath);
    values.push(filepath.length);
    values.push(filepath);
    template.push("A");
  } else {
    values.push(0);
  }

  template.push("l");
  values.push(options.line || 1);

  template.push("L");
  if (options.encoding) {
    const encoding = encoder.encode(options.encoding);
    values.push(encoding.length);
    values.push(encoding);
    template.push("A");
  } else {
    values.push(0);
  }

  template.push("C");
  values.push(dumpBooleanOption(options.frozen_string_literal));

  template.push("C");
  values.push(dumpCommandLineOptions(options));

  template.push("C");
  if (!options.version || options.version === "latest") {
    values.push(0); // Handled in pm_parser_init
  } else if (options.version.match(/^3\.3(\.\d+)?$/)) {
    values.push(1);
  } else if (options.version.match(/^3\.4(\.\d+)?$/)) {
    values.push(2);
  } else if (options.version.match(/^3\.5(\.\d+)?$/)) {
    values.push(3);
  } else {
    throw new Error(`Unsupported version '${options.version}' in compiler options`);
  }

  template.push("C");
  values.push(options.encoding === false ? 1 : 0);

  template.push("C");
  values.push(dumpBooleanOption(options.main_script));

  template.push("C");
  values.push(dumpBooleanOption(options.partial_script));

  template.push("C");
  values.push(0);

  template.push("L");
  if (options.scopes) {
    const scopes = options.scopes;
    values.push(scopes.length);

    for (const scope of scopes) {
      let locals;
      let forwarding = 0;

      if (Array.isArray(scope)) {
        locals = scope;
      } else {
        locals = scope.locals || [];

        for (const forward of (scope.forwarding || [])) {
          switch (forward) {
            case "*": forwarding |= 0x1; break;
            case "**": forwarding |= 0x2; break;
            case "&": forwarding |= 0x4; break;
            case "...": forwarding |= 0x8; break;
            default: throw new Error(`invalid forwarding value: ${forward}`);
          }
        }
      }

      template.push("L");
      values.push(locals.length);

      template.push("C");
      values.push(forwarding);

      for (const local of locals) {
        template.push("L");
        values.push(local.length);

        template.push("A")
        values.push(encoder.encode(local));
      }
    }
  } else {
    values.push(0);
  }

  return pack(values, template);
}

/**
 * Pack the given values using the given template. This function matches a
 * subset of the functionality from Ruby's Array#pack method.
 *
 * @typedef {(number | string)[]} PackValues
 * @typedef {string[]} PackTemplate
 *
 * @param {PackValues} values 
 * @param {PackTemplate} template 
 * @returns {Uint8Array}
 */
function pack(values, template) {
  const littleEndian = endianness() === "LE";
  const buffer = new ArrayBuffer(totalSizeOf(values, template));
  const data_view = new DataView(buffer);
  let offset = 0;

  for (let i = 0; i < values.length; i ++) {
    switch (template[i]) {
      case "A":
        for (let c = 0; c < values[i].length; c ++) {
          data_view.setUint8(offset + c, values[i][c]);
        }

        break;

      case "l":
        data_view.setInt32(offset, values[i], littleEndian);
        break;

      case "L":
        data_view.setUint32(offset, values[i], littleEndian);
        break;

      case "C":
        data_view.setUint8(offset, values[i], littleEndian);
        break;
    }

    offset += sizeOf(values, template, i);
  }

  return new Uint8Array(buffer);
}

/**
 * Returns the total size of the given values in bytes.
 *
 * @param {PackValues} values
 * @param {PackTemplate} template
 * @returns {number}
 */
function totalSizeOf(values, template) {
  let size = 0;

  for (let i = 0; i < values.length; i ++) {
    size += sizeOf(values, template, i);
  }

  return size;
}

/**
 * Returns the size of the given value inside the list of values at the
 * specified index in bytes.
 * 
 * @param {PackValues} values 
 * @param {PackTemplate} template 
 * @param {number} index 
 * @returns {number}
 */
function sizeOf(values, template, index) {
  switch (template[index]) {
    // arbitrary binary string
    case "A":
      return values[index].length;

    // l: signed 32-bit integer, L: unsigned 32-bit integer
    case "l":
    case "L":
      return 4;

    // 8-bit unsigned integer
    case "C":
      return 1;
  }
}

/**
 * Platform-agnostic implementation of Node's os.endianness().
 *
 * @returns {"BE" | "LE"}
 */
function endianness() {
  const arr = new Uint8Array(4);
  new Uint32Array(arr.buffer)[0] = 0xffcc0011;
  return arr[0] === 0xff ? "BE" : "LE";
}
prism-1.5.1/javascript/test.js000066400000000000000000000131131506127434000163340ustar00rootroot00000000000000import test from "node:test";
import assert from "node:assert";
import { loadPrism } from "./src/index.js";
import * as nodes from "./src/nodes.js";

const parse = await loadPrism();

function statement(result) {
  return result.value.statements.body[0];
}

test("node", () => {
  const result = parse("foo");
  assert(result.value instanceof nodes.ProgramNode);
});

test("node? present", () => {
  const result = parse("foo.bar");
  assert(statement(result).receiver instanceof nodes.CallNode);
});

test("node? absent", () => {
  const result = parse("foo");
  assert(statement(result).receiver === null);
});

test("node[]", () => {
  const result = parse("foo.bar");
  assert(result.value.statements.body instanceof Array);
});

test("string", () => {
  const result = parse('"foo"');
  const node = statement(result);

  assert(!node.isForcedUtf8Encoding())
  assert(!node.isForcedBinaryEncoding())

  assert(node.unescaped.value === "foo");
  assert(node.unescaped.encoding === "utf-8");
  assert(node.unescaped.validEncoding);
});

test("forced utf-8 string using \\u syntax", () => {
  const result = parse('# encoding: utf-8\n"\\u{9E7F}"');
  const node = statement(result);
  const str = node.unescaped;

  assert(node.isForcedUtf8Encoding());
  assert(!node.isForcedBinaryEncoding());

  assert(str.value === "鹿");
  assert(str.encoding === "utf-8");
  assert(str.validEncoding);
});

test("forced utf-8 string with invalid byte sequence", () => {
  const result = parse('# encoding: utf-8\n"\\xFF\\xFF\\xFF"');
  const node = statement(result);
  const str = node.unescaped;

  assert(node.isForcedUtf8Encoding());
  assert(!node.isForcedBinaryEncoding());

  assert(str.value === "ÿÿÿ");
  assert(str.encoding === "utf-8");
  assert(!str.validEncoding);
});

test("ascii string with embedded utf-8 character", () => {
  // # encoding: ascii\n"鹿"'
  // # encoding: ascii\n"鹿"'
  const ascii_str = new Buffer.from([35, 32, 101, 110, 99, 111, 100, 105, 110, 103, 58, 32, 97, 115, 99, 105, 105, 10, 34, 233, 185, 191, 34]);
  const result = parse(ascii_str);
  const node = statement(result);
  const str = node.unescaped;

  assert(!node.isForcedUtf8Encoding());
  assert(node.isForcedBinaryEncoding());

  assert(str.value === "鹿");
  assert(str.encoding === "ascii");
  assert(str.validEncoding);
});

test("forced binary string", () => {
  const result = parse('# encoding: ascii\n"\\xFF\\xFF\\xFF"');
  const node = statement(result);
  const str = node.unescaped;

  assert(!node.isForcedUtf8Encoding());
  assert(node.isForcedBinaryEncoding());

  assert(str.value === "ÿÿÿ");
  assert(str.encoding === "ascii");
  assert(str.validEncoding);
});

test("forced binary string with Unicode character", () => {
  // # encoding: us-ascii\n"\\xFF鹿\\xFF"
  const ascii_str = Buffer.from([35, 32, 101, 110, 99, 111, 100, 105, 110, 103, 58, 32, 97, 115, 99, 105, 105, 10, 34, 92, 120, 70, 70, 233, 185, 191, 92, 120, 70, 70, 34]);
  const result = parse(ascii_str);
  const node = statement(result);
  const str = node.unescaped;

  assert(!node.isForcedUtf8Encoding());
  assert(node.isForcedBinaryEncoding());

  assert(str.value === "ÿ鹿ÿ");
  assert(str.encoding === "ascii");
  assert(str.validEncoding);
});

test("constant", () => {
  const result = parse("foo = 1");
  assert(result.value.locals[0] === "foo");
});

test("constant? present", () => {
  const result = parse("def foo(*bar); end");
  assert(statement(result).parameters.rest.name === "bar");
});

test("constant? absent", () => {
  const result = parse("def foo(*); end");
  assert(statement(result).parameters.rest.name === null);
});

test("constant[]", async() => {
  const result = parse("foo = 1");
  assert(result.value.locals instanceof Array);
});

test("location", () => {
  const result = parse("foo = 1");
  assert(typeof result.value.location.startOffset === "number");
});

test("location? present", () => {
  const result = parse("def foo = bar");
  assert(statement(result).equalLoc !== null);
});

test("location? absent", () => {
  const result = parse("def foo; bar; end");
  assert(statement(result).equalLoc === null);
});

test("uint8", () => {
  const result = parse("-> { _3 }");
  assert(statement(result).parameters.maximum === 3);
});

test("uint32", () => {
  const result = parse("foo = 1");
  assert(statement(result).depth === 0);
});

test("flags", () => {
  const result = parse("/foo/mi");
  const regexp = statement(result);

  assert(regexp.isIgnoreCase());
  assert(regexp.isMultiLine());
  assert(!regexp.isExtended());
});

test("integer (decimal)", () => {
  const result = parse("10");
  assert(statement(result).value === 10);
});

test("integer (hex)", () => {
  const result = parse("0xA");
  assert(statement(result).value === 10);
});

test("integer (2 nodes)", () => {
  const result = parse("4294967296");
  assert(statement(result).value === 4294967296n);
});

test("integer (3 nodes)", () => {
  const result = parse("18446744073709552000");
  assert(statement(result).value === 18446744073709552000n);
});

test("double", () => {
  const result = parse("1.0");
  assert(statement(result).value === 1.0);
});

test("scopes", () => {
  let result;

  result = parse("foo");
  assert(statement(result) instanceof nodes.CallNode);

  result = parse("foo", { scopes: [["foo"]] });
  assert(statement(result) instanceof nodes.LocalVariableReadNode);

  result = parse("foo", { scopes: [{ locals: ["foo"] }] });
  assert(statement(result) instanceof nodes.LocalVariableReadNode);

  result = parse("foo(*)");
  assert(result.errors.length > 0);

  result = parse("foo(*)", { scopes: [{ forwarding: ["*"] }] });
  assert(result.errors.length === 0);
});
prism-1.5.1/lib/000077500000000000000000000000001506127434000134205ustar00rootroot00000000000000prism-1.5.1/lib/prism.rb000066400000000000000000000060361506127434000151040ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

# The Prism Ruby parser.
#
# "Parsing Ruby is suddenly manageable!"
#   - You, hopefully
#
module Prism
  # There are many files in prism that are templated to handle every node type,
  # which means the files can end up being quite large. We autoload them to make
  # our require speed faster since consuming libraries are unlikely to use all
  # of these features.

  autoload :BasicVisitor, "prism/visitor"
  autoload :Compiler, "prism/compiler"
  autoload :DesugarCompiler, "prism/desugar_compiler"
  autoload :Dispatcher, "prism/dispatcher"
  autoload :DotVisitor, "prism/dot_visitor"
  autoload :DSL, "prism/dsl"
  autoload :InspectVisitor, "prism/inspect_visitor"
  autoload :LexCompat, "prism/lex_compat"
  autoload :LexRipper, "prism/lex_compat"
  autoload :MutationCompiler, "prism/mutation_compiler"
  autoload :Pack, "prism/pack"
  autoload :Pattern, "prism/pattern"
  autoload :Reflection, "prism/reflection"
  autoload :Relocation, "prism/relocation"
  autoload :Serialize, "prism/serialize"
  autoload :StringQuery, "prism/string_query"
  autoload :Translation, "prism/translation"
  autoload :Visitor, "prism/visitor"

  # Some of these constants are not meant to be exposed, so marking them as
  # private here.

  private_constant :LexCompat
  private_constant :LexRipper

  # :call-seq:
  #   Prism::lex_compat(source, **options) -> LexCompat::Result
  #
  # Returns a parse result whose value is an array of tokens that closely
  # resembles the return value of Ripper::lex. The main difference is that the
  # `:on_sp` token is not emitted.
  #
  # For supported options, see Prism::parse.
  def self.lex_compat(source, **options)
    LexCompat.new(source, **options).result # steep:ignore
  end

  # :call-seq:
  #   Prism::lex_ripper(source) -> Array
  #
  # This lexes with the Ripper lex. It drops any space events but otherwise
  # returns the same tokens. Raises SyntaxError if the syntax in source is
  # invalid.
  def self.lex_ripper(source)
    LexRipper.new(source).result # steep:ignore
  end

  # :call-seq:
  #   Prism::load(source, serialized, freeze) -> ParseResult
  #
  # Load the serialized AST using the source as a reference into a tree.
  def self.load(source, serialized, freeze = false)
    Serialize.load_parse(source, serialized, freeze)
  end
end

require_relative "prism/polyfill/byteindex"
require_relative "prism/polyfill/warn"
require_relative "prism/node"
require_relative "prism/node_ext"
require_relative "prism/parse_result"

# This is a Ruby implementation of the prism parser. If we're running on CRuby
# and we haven't explicitly set the PRISM_FFI_BACKEND environment variable, then
# it's going to require the built library. Otherwise, it's going to require a
# module that uses FFI to call into the library.
if RUBY_ENGINE == "ruby" and !ENV["PRISM_FFI_BACKEND"]
  # The C extension is the default backend on CRuby.
  Prism::BACKEND = :CEXT

  require "prism/prism"
else
  # The FFI backend is used on other Ruby implementations.
  Prism::BACKEND = :FFI

  require_relative "prism/ffi"
end
prism-1.5.1/lib/prism/000077500000000000000000000000001506127434000145525ustar00rootroot00000000000000prism-1.5.1/lib/prism/desugar_compiler.rb000066400000000000000000000236151506127434000204320ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

module Prism
  class DesugarAndWriteNode # :nodoc:
    include DSL

    attr_reader :node, :default_source, :read_class, :write_class, :arguments

    def initialize(node, default_source, read_class, write_class, **arguments)
      @node = node
      @default_source = default_source
      @read_class = read_class
      @write_class = write_class
      @arguments = arguments
    end

    # Desugar `x &&= y` to `x && x = y`
    def compile
      and_node(
        location: node.location,
        left: public_send(read_class, location: node.name_loc, **arguments),
        right: public_send(
          write_class,
          location: node.location,
          **arguments,
          name_loc: node.name_loc,
          value: node.value,
          operator_loc: node.operator_loc
        ),
        operator_loc: node.operator_loc
      )
    end
  end

  class DesugarOrWriteDefinedNode # :nodoc:
    include DSL

    attr_reader :node, :default_source, :read_class, :write_class, :arguments

    def initialize(node, default_source, read_class, write_class, **arguments)
      @node = node
      @default_source = default_source
      @read_class = read_class
      @write_class = write_class
      @arguments = arguments
    end

    # Desugar `x ||= y` to `defined?(x) ? x : x = y`
    def compile
      if_node(
        location: node.location,
        if_keyword_loc: node.operator_loc,
        predicate: defined_node(
          location: node.name_loc,
          value: public_send(read_class, location: node.name_loc, **arguments),
          keyword_loc: node.operator_loc
        ),
        then_keyword_loc: node.operator_loc,
        statements: statements_node(
          location: node.location,
          body: [public_send(read_class, location: node.name_loc, **arguments)]
        ),
        subsequent: else_node(
          location: node.location,
          else_keyword_loc: node.operator_loc,
          statements: statements_node(
            location: node.location,
            body: [
              public_send(
                write_class,
                location: node.location,
                **arguments,
                name_loc: node.name_loc,
                value: node.value,
                operator_loc: node.operator_loc
              )
            ]
          ),
          end_keyword_loc: node.operator_loc
        ),
        end_keyword_loc: node.operator_loc
      )
    end
  end

  class DesugarOperatorWriteNode # :nodoc:
    include DSL

    attr_reader :node, :default_source, :read_class, :write_class, :arguments

    def initialize(node, default_source, read_class, write_class, **arguments)
      @node = node
      @default_source = default_source
      @read_class = read_class
      @write_class = write_class
      @arguments = arguments
    end

    # Desugar `x += y` to `x = x + y`
    def compile
      binary_operator_loc = node.binary_operator_loc.chop

      public_send(
        write_class,
        location: node.location,
        **arguments,
        name_loc: node.name_loc,
        value: call_node(
          location: node.location,
          receiver: public_send(
            read_class,
            location: node.name_loc,
            **arguments
          ),
          name: binary_operator_loc.slice.to_sym,
          message_loc: binary_operator_loc,
          arguments: arguments_node(
            location: node.value.location,
            arguments: [node.value]
          )
        ),
        operator_loc: node.binary_operator_loc.copy(
          start_offset: node.binary_operator_loc.end_offset - 1,
          length: 1
        )
      )
    end
  end

  class DesugarOrWriteNode # :nodoc:
    include DSL

    attr_reader :node, :default_source, :read_class, :write_class, :arguments

    def initialize(node, default_source, read_class, write_class, **arguments)
      @node = node
      @default_source = default_source
      @read_class = read_class
      @write_class = write_class
      @arguments = arguments
    end

    # Desugar `x ||= y` to `x || x = y`
    def compile
      or_node(
        location: node.location,
        left: public_send(read_class, location: node.name_loc, **arguments),
        right: public_send(
          write_class,
          location: node.location,
          **arguments,
          name_loc: node.name_loc,
          value: node.value,
          operator_loc: node.operator_loc
        ),
        operator_loc: node.operator_loc
      )
    end
  end

  private_constant :DesugarAndWriteNode, :DesugarOrWriteNode, :DesugarOrWriteDefinedNode, :DesugarOperatorWriteNode

  class ClassVariableAndWriteNode
    def desugar # :nodoc:
      DesugarAndWriteNode.new(self, source, :class_variable_read_node, :class_variable_write_node, name: name).compile
    end
  end

  class ClassVariableOrWriteNode
    def desugar # :nodoc:
      DesugarOrWriteDefinedNode.new(self, source, :class_variable_read_node, :class_variable_write_node, name: name).compile
    end
  end

  class ClassVariableOperatorWriteNode
    def desugar # :nodoc:
      DesugarOperatorWriteNode.new(self, source, :class_variable_read_node, :class_variable_write_node, name: name).compile
    end
  end

  class ConstantAndWriteNode
    def desugar # :nodoc:
      DesugarAndWriteNode.new(self, source, :constant_read_node, :constant_write_node, name: name).compile
    end
  end

  class ConstantOrWriteNode
    def desugar # :nodoc:
      DesugarOrWriteDefinedNode.new(self, source, :constant_read_node, :constant_write_node, name: name).compile
    end
  end

  class ConstantOperatorWriteNode
    def desugar # :nodoc:
      DesugarOperatorWriteNode.new(self, source, :constant_read_node, :constant_write_node, name: name).compile
    end
  end

  class GlobalVariableAndWriteNode
    def desugar # :nodoc:
      DesugarAndWriteNode.new(self, source, :global_variable_read_node, :global_variable_write_node, name: name).compile
    end
  end

  class GlobalVariableOrWriteNode
    def desugar # :nodoc:
      DesugarOrWriteDefinedNode.new(self, source, :global_variable_read_node, :global_variable_write_node, name: name).compile
    end
  end

  class GlobalVariableOperatorWriteNode
    def desugar # :nodoc:
      DesugarOperatorWriteNode.new(self, source, :global_variable_read_node, :global_variable_write_node, name: name).compile
    end
  end

  class InstanceVariableAndWriteNode
    def desugar # :nodoc:
      DesugarAndWriteNode.new(self, source, :instance_variable_read_node, :instance_variable_write_node, name: name).compile
    end
  end

  class InstanceVariableOrWriteNode
    def desugar # :nodoc:
      DesugarOrWriteNode.new(self, source, :instance_variable_read_node, :instance_variable_write_node, name: name).compile
    end
  end

  class InstanceVariableOperatorWriteNode
    def desugar # :nodoc:
      DesugarOperatorWriteNode.new(self, source, :instance_variable_read_node, :instance_variable_write_node, name: name).compile
    end
  end

  class LocalVariableAndWriteNode
    def desugar # :nodoc:
      DesugarAndWriteNode.new(self, source, :local_variable_read_node, :local_variable_write_node, name: name, depth: depth).compile
    end
  end

  class LocalVariableOrWriteNode
    def desugar # :nodoc:
      DesugarOrWriteNode.new(self, source, :local_variable_read_node, :local_variable_write_node, name: name, depth: depth).compile
    end
  end

  class LocalVariableOperatorWriteNode
    def desugar # :nodoc:
      DesugarOperatorWriteNode.new(self, source, :local_variable_read_node, :local_variable_write_node, name: name, depth: depth).compile
    end
  end

  # DesugarCompiler is a compiler that desugars Ruby code into a more primitive
  # form. This is useful for consumers that want to deal with fewer node types.
  class DesugarCompiler < MutationCompiler
    # @@foo &&= bar
    #
    # becomes
    #
    # @@foo && @@foo = bar
    def visit_class_variable_and_write_node(node)
      node.desugar
    end

    # @@foo ||= bar
    #
    # becomes
    #
    # defined?(@@foo) ? @@foo : @@foo = bar
    def visit_class_variable_or_write_node(node)
      node.desugar
    end

    # @@foo += bar
    #
    # becomes
    #
    # @@foo = @@foo + bar
    def visit_class_variable_operator_write_node(node)
      node.desugar
    end

    # Foo &&= bar
    #
    # becomes
    #
    # Foo && Foo = bar
    def visit_constant_and_write_node(node)
      node.desugar
    end

    # Foo ||= bar
    #
    # becomes
    #
    # defined?(Foo) ? Foo : Foo = bar
    def visit_constant_or_write_node(node)
      node.desugar
    end

    # Foo += bar
    #
    # becomes
    #
    # Foo = Foo + bar
    def visit_constant_operator_write_node(node)
      node.desugar
    end

    # $foo &&= bar
    #
    # becomes
    #
    # $foo && $foo = bar
    def visit_global_variable_and_write_node(node)
      node.desugar
    end

    # $foo ||= bar
    #
    # becomes
    #
    # defined?($foo) ? $foo : $foo = bar
    def visit_global_variable_or_write_node(node)
      node.desugar
    end

    # $foo += bar
    #
    # becomes
    #
    # $foo = $foo + bar
    def visit_global_variable_operator_write_node(node)
      node.desugar
    end

    # @foo &&= bar
    #
    # becomes
    #
    # @foo && @foo = bar
    def visit_instance_variable_and_write_node(node)
      node.desugar
    end

    # @foo ||= bar
    #
    # becomes
    #
    # @foo || @foo = bar
    def visit_instance_variable_or_write_node(node)
      node.desugar
    end

    # @foo += bar
    #
    # becomes
    #
    # @foo = @foo + bar
    def visit_instance_variable_operator_write_node(node)
      node.desugar
    end

    # foo &&= bar
    #
    # becomes
    #
    # foo && foo = bar
    def visit_local_variable_and_write_node(node)
      node.desugar
    end

    # foo ||= bar
    #
    # becomes
    #
    # foo || foo = bar
    def visit_local_variable_or_write_node(node)
      node.desugar
    end

    # foo += bar
    #
    # becomes
    #
    # foo = foo + bar
    def visit_local_variable_operator_write_node(node)
      node.desugar
    end
  end
end
prism-1.5.1/lib/prism/ffi.rb000066400000000000000000000466531506127434000156610ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown
# typed: ignore

# This file is responsible for mirroring the API provided by the C extension by
# using FFI to call into the shared library.

require "rbconfig"
require "ffi"

# We want to eagerly load this file if there are Ractors so that it does not get
# autoloaded from within a non-main Ractor.
require "prism/serialize" if defined?(Ractor)

module Prism
  module LibRubyParser # :nodoc:
    extend FFI::Library

    # Define the library that we will be pulling functions from. Note that this
    # must align with the build shared library from make/rake.
    libprism_in_build = File.expand_path("../../build/libprism.#{RbConfig::CONFIG["SOEXT"]}", __dir__)
    libprism_in_libdir = "#{RbConfig::CONFIG["libdir"]}/prism/libprism.#{RbConfig::CONFIG["SOEXT"]}"

    if File.exist?(libprism_in_build)
      INCLUDE_DIR = File.expand_path("../../include", __dir__)
      ffi_lib libprism_in_build
    else
      INCLUDE_DIR = "#{RbConfig::CONFIG["libdir"]}/prism/include"
      ffi_lib libprism_in_libdir
    end

    # Convert a native C type declaration into a symbol that FFI understands.
    # For example:
    #
    #     const char * -> :pointer
    #     bool         -> :bool
    #     size_t       -> :size_t
    #     void         -> :void
    #
    def self.resolve_type(type, callbacks)
      type = type.strip

      if !type.end_with?("*")
        type.delete_prefix("const ").to_sym
      else
        type = type.delete_suffix("*").rstrip
        callbacks.include?(type.to_sym) ? type.to_sym : :pointer
      end
    end

    # Read through the given header file and find the declaration of each of the
    # given functions. For each one, define a function with the same name and
    # signature as the C function.
    def self.load_exported_functions_from(header, *functions, callbacks)
      File.foreach("#{INCLUDE_DIR}/#{header}") do |line|
        # We only want to attempt to load exported functions.
        next unless line.start_with?("PRISM_EXPORTED_FUNCTION ")

        # We only want to load the functions that we are interested in.
        next unless functions.any? { |function| line.include?(function) }

        # Parse the function declaration.
        unless /^PRISM_EXPORTED_FUNCTION (?.+) (?\w+)\((?.+)\);$/ =~ line
          raise "Could not parse #{line}"
        end

        # Delete the function from the list of functions we are looking for to
        # mark it as having been found.
        functions.delete(name)

        # Split up the argument types into an array, ensure we handle the case
        # where there are no arguments (by explicit void).
        arg_types = arg_types.split(",").map(&:strip)
        arg_types = [] if arg_types == %w[void]

        # Resolve the type of the argument by dropping the name of the argument
        # first if it is present.
        arg_types.map! { |type| resolve_type(type.sub(/\w+$/, ""), callbacks) }

        # Attach the function using the FFI library.
        attach_function name, arg_types, resolve_type(return_type, [])
      end

      # If we didn't find all of the functions, raise an error.
      raise "Could not find functions #{functions.inspect}" unless functions.empty?
    end

    callback :pm_parse_stream_fgets_t, [:pointer, :int, :pointer], :pointer
    callback :pm_parse_stream_feof_t, [:pointer], :int
    enum :pm_string_init_result_t, %i[PM_STRING_INIT_SUCCESS PM_STRING_INIT_ERROR_GENERIC PM_STRING_INIT_ERROR_DIRECTORY]
    enum :pm_string_query_t, [:PM_STRING_QUERY_ERROR, -1, :PM_STRING_QUERY_FALSE, :PM_STRING_QUERY_TRUE]

    load_exported_functions_from(
      "prism.h",
      "pm_version",
      "pm_serialize_parse",
      "pm_serialize_parse_stream",
      "pm_serialize_parse_comments",
      "pm_serialize_lex",
      "pm_serialize_parse_lex",
      "pm_parse_success_p",
      "pm_string_query_local",
      "pm_string_query_constant",
      "pm_string_query_method_name",
      [:pm_parse_stream_fgets_t, :pm_parse_stream_feof_t]
    )

    load_exported_functions_from(
      "prism/util/pm_buffer.h",
      "pm_buffer_sizeof",
      "pm_buffer_init",
      "pm_buffer_value",
      "pm_buffer_length",
      "pm_buffer_free",
      []
    )

    load_exported_functions_from(
      "prism/util/pm_string.h",
      "pm_string_mapped_init",
      "pm_string_free",
      "pm_string_source",
      "pm_string_length",
      "pm_string_sizeof",
      []
    )

    # This object represents a pm_buffer_t. We only use it as an opaque pointer,
    # so it doesn't need to know the fields of pm_buffer_t.
    class PrismBuffer # :nodoc:
      SIZEOF = LibRubyParser.pm_buffer_sizeof

      attr_reader :pointer

      def initialize(pointer)
        @pointer = pointer
      end

      def value
        LibRubyParser.pm_buffer_value(pointer)
      end

      def length
        LibRubyParser.pm_buffer_length(pointer)
      end

      def read
        value.read_string(length)
      end

      # Initialize a new buffer and yield it to the block. The buffer will be
      # automatically freed when the block returns.
      def self.with
        FFI::MemoryPointer.new(SIZEOF) do |pointer|
          raise unless LibRubyParser.pm_buffer_init(pointer)
          return yield new(pointer)
        ensure
          LibRubyParser.pm_buffer_free(pointer)
        end
      end
    end

    # This object represents a pm_string_t. We only use it as an opaque pointer,
    # so it doesn't have to be an FFI::Struct.
    class PrismString # :nodoc:
      SIZEOF = LibRubyParser.pm_string_sizeof

      PLATFORM_EXPECTS_UTF8 =
        RbConfig::CONFIG["host_os"].match?(/bccwin|cygwin|djgpp|mingw|mswin|wince|darwin/i)

      attr_reader :pointer, :length

      def initialize(pointer, length, from_string)
        @pointer = pointer
        @length = length
        @from_string = from_string
      end

      def read
        raise "should use the original String instead" if @from_string
        @pointer.read_string(@length)
      end

      # Yields a pm_string_t pointer to the given block.
      def self.with_string(string)
        raise TypeError unless string.is_a?(String)

        length = string.bytesize
        # + 1 to never get an address of 0, which pm_parser_init() asserts
        FFI::MemoryPointer.new(:char, length + 1, false) do |pointer|
          pointer.write_string(string)
          # since we have the extra byte we might as well \0-terminate
          pointer.put_char(length, 0)
          return yield new(pointer, length, true)
        end
      end

      # Yields a pm_string_t pointer to the given block.
      def self.with_file(filepath)
        raise TypeError unless filepath.is_a?(String)

        # On Windows and Mac, it's expected that filepaths will be encoded in
        # UTF-8. If they are not, we need to convert them to UTF-8 before
        # passing them into pm_string_mapped_init.
        if PLATFORM_EXPECTS_UTF8 && (encoding = filepath.encoding) != Encoding::ASCII_8BIT && encoding != Encoding::UTF_8
          filepath = filepath.encode(Encoding::UTF_8)
        end

        FFI::MemoryPointer.new(SIZEOF) do |pm_string|
          case (result = LibRubyParser.pm_string_mapped_init(pm_string, filepath))
          when :PM_STRING_INIT_SUCCESS
            pointer = LibRubyParser.pm_string_source(pm_string)
            length = LibRubyParser.pm_string_length(pm_string)
            return yield new(pointer, length, false)
          when :PM_STRING_INIT_ERROR_GENERIC
            raise SystemCallError.new(filepath, FFI.errno)
          when :PM_STRING_INIT_ERROR_DIRECTORY
            raise Errno::EISDIR.new(filepath)
          else
            raise "Unknown error initializing pm_string_t: #{result.inspect}"
          end
        ensure
          LibRubyParser.pm_string_free(pm_string)
        end
      end
    end
  end

  # Mark the LibRubyParser module as private as it should only be called through
  # the prism module.
  private_constant :LibRubyParser

  # The version constant is set by reading the result of calling pm_version.
  VERSION = LibRubyParser.pm_version.read_string.freeze

  class << self
    # Mirror the Prism.dump API by using the serialization API.
    def dump(source, **options)
      LibRubyParser::PrismString.with_string(source) { |string| dump_common(string, options) }
    end

    # Mirror the Prism.dump_file API by using the serialization API.
    def dump_file(filepath, **options)
      options[:filepath] = filepath
      LibRubyParser::PrismString.with_file(filepath) { |string| dump_common(string, options) }
    end

    # Mirror the Prism.lex API by using the serialization API.
    def lex(code, **options)
      LibRubyParser::PrismString.with_string(code) { |string| lex_common(string, code, options) }
    end

    # Mirror the Prism.lex_file API by using the serialization API.
    def lex_file(filepath, **options)
      options[:filepath] = filepath
      LibRubyParser::PrismString.with_file(filepath) { |string| lex_common(string, string.read, options) }
    end

    # Mirror the Prism.parse API by using the serialization API.
    def parse(code, **options)
      LibRubyParser::PrismString.with_string(code) { |string| parse_common(string, code, options) }
    end

    # Mirror the Prism.parse_file API by using the serialization API. This uses
    # native strings instead of Ruby strings because it allows us to use mmap
    # when it is available.
    def parse_file(filepath, **options)
      options[:filepath] = filepath
      LibRubyParser::PrismString.with_file(filepath) { |string| parse_common(string, string.read, options) }
    end

    # Mirror the Prism.parse_stream API by using the serialization API.
    def parse_stream(stream, **options)
      LibRubyParser::PrismBuffer.with do |buffer|
        source = +""
        callback = -> (string, size, _) {
          raise "Expected size to be >= 0, got: #{size}" if size <= 0

          if !(line = stream.gets(size - 1)).nil?
            source << line
            string.write_string("#{line}\x00", line.bytesize + 1)
          end
        }

        eof_callback = -> (_) { stream.eof?  }

        # In the pm_serialize_parse_stream function it accepts a pointer to the
        # IO object as a void* and then passes it through to the callback as the
        # third argument, but it never touches it itself. As such, since we have
        # access to the IO object already through the closure of the lambda, we
        # can pass a null pointer here and not worry.
        LibRubyParser.pm_serialize_parse_stream(buffer.pointer, nil, callback, eof_callback, dump_options(options))
        Prism.load(source, buffer.read, options.fetch(:freeze, false))
      end
    end

    # Mirror the Prism.parse_comments API by using the serialization API.
    def parse_comments(code, **options)
      LibRubyParser::PrismString.with_string(code) { |string| parse_comments_common(string, code, options) }
    end

    # Mirror the Prism.parse_file_comments API by using the serialization
    # API. This uses native strings instead of Ruby strings because it allows us
    # to use mmap when it is available.
    def parse_file_comments(filepath, **options)
      options[:filepath] = filepath
      LibRubyParser::PrismString.with_file(filepath) { |string| parse_comments_common(string, string.read, options) }
    end

    # Mirror the Prism.parse_lex API by using the serialization API.
    def parse_lex(code, **options)
      LibRubyParser::PrismString.with_string(code) { |string| parse_lex_common(string, code, options) }
    end

    # Mirror the Prism.parse_lex_file API by using the serialization API.
    def parse_lex_file(filepath, **options)
      options[:filepath] = filepath
      LibRubyParser::PrismString.with_file(filepath) { |string| parse_lex_common(string, string.read, options) }
    end

    # Mirror the Prism.parse_success? API by using the serialization API.
    def parse_success?(code, **options)
      LibRubyParser::PrismString.with_string(code) { |string| parse_file_success_common(string, options) }
    end

    # Mirror the Prism.parse_failure? API by using the serialization API.
    def parse_failure?(code, **options)
      !parse_success?(code, **options)
    end

    # Mirror the Prism.parse_file_success? API by using the serialization API.
    def parse_file_success?(filepath, **options)
      options[:filepath] = filepath
      LibRubyParser::PrismString.with_file(filepath) { |string| parse_file_success_common(string, options) }
    end

    # Mirror the Prism.parse_file_failure? API by using the serialization API.
    def parse_file_failure?(filepath, **options)
      !parse_file_success?(filepath, **options)
    end

    # Mirror the Prism.profile API by using the serialization API.
    def profile(source, **options)
      LibRubyParser::PrismString.with_string(source) do |string|
        LibRubyParser::PrismBuffer.with do |buffer|
          LibRubyParser.pm_serialize_parse(buffer.pointer, string.pointer, string.length, dump_options(options))
          nil
        end
      end
    end

    # Mirror the Prism.profile_file API by using the serialization API.
    def profile_file(filepath, **options)
      LibRubyParser::PrismString.with_file(filepath) do |string|
        LibRubyParser::PrismBuffer.with do |buffer|
          options[:filepath] = filepath
          LibRubyParser.pm_serialize_parse(buffer.pointer, string.pointer, string.length, dump_options(options))
          nil
        end
      end
    end

    private

    def dump_common(string, options) # :nodoc:
      LibRubyParser::PrismBuffer.with do |buffer|
        LibRubyParser.pm_serialize_parse(buffer.pointer, string.pointer, string.length, dump_options(options))

        dumped = buffer.read
        dumped.freeze if options.fetch(:freeze, false)

        dumped
      end
    end

    def lex_common(string, code, options) # :nodoc:
      LibRubyParser::PrismBuffer.with do |buffer|
        LibRubyParser.pm_serialize_lex(buffer.pointer, string.pointer, string.length, dump_options(options))
        Serialize.load_lex(code, buffer.read, options.fetch(:freeze, false))
      end
    end

    def parse_common(string, code, options) # :nodoc:
      serialized = dump_common(string, options)
      Serialize.load_parse(code, serialized, options.fetch(:freeze, false))
    end

    def parse_comments_common(string, code, options) # :nodoc:
      LibRubyParser::PrismBuffer.with do |buffer|
        LibRubyParser.pm_serialize_parse_comments(buffer.pointer, string.pointer, string.length, dump_options(options))
        Serialize.load_parse_comments(code, buffer.read, options.fetch(:freeze, false))
      end
    end

    def parse_lex_common(string, code, options) # :nodoc:
      LibRubyParser::PrismBuffer.with do |buffer|
        LibRubyParser.pm_serialize_parse_lex(buffer.pointer, string.pointer, string.length, dump_options(options))
        Serialize.load_parse_lex(code, buffer.read, options.fetch(:freeze, false))
      end
    end

    def parse_file_success_common(string, options) # :nodoc:
      LibRubyParser.pm_parse_success_p(string.pointer, string.length, dump_options(options))
    end

    # Return the value that should be dumped for the command_line option.
    def dump_options_command_line(options)
      command_line = options.fetch(:command_line, "")
      raise ArgumentError, "command_line must be a string" unless command_line.is_a?(String)

      command_line.each_char.inject(0) do |value, char|
        case char
        when "a" then value | 0b000001
        when "e" then value | 0b000010
        when "l" then value | 0b000100
        when "n" then value | 0b001000
        when "p" then value | 0b010000
        when "x" then value | 0b100000
        else raise ArgumentError, "invalid command_line option: #{char}"
        end
      end
    end

    # Return the value that should be dumped for the version option.
    def dump_options_version(version)
      case version
      when nil, "latest"
        0 # Handled in pm_parser_init
      when /\A3\.3(\.\d+)?\z/
        1
      when /\A3\.4(\.\d+)?\z/
        2
      when /\A3\.5(\.\d+)?\z/
        3
      else
        raise ArgumentError, "invalid version: #{version}"
      end
    end

    # Convert the given options into a serialized options string.
    def dump_options(options)
      template = +""
      values = []

      template << "L"
      if (filepath = options[:filepath])
        values.push(filepath.bytesize, filepath.b)
        template << "A*"
      else
        values << 0
      end

      template << "l"
      values << options.fetch(:line, 1)

      template << "L"
      if (encoding = options[:encoding])
        name = encoding.is_a?(Encoding) ? encoding.name : encoding
        values.push(name.bytesize, name.b)
        template << "A*"
      else
        values << 0
      end

      template << "C"
      values << (options.fetch(:frozen_string_literal, false) ? 1 : 0)

      template << "C"
      values << dump_options_command_line(options)

      template << "C"
      values << dump_options_version(options[:version])

      template << "C"
      values << (options[:encoding] == false ? 1 : 0)

      template << "C"
      values << (options.fetch(:main_script, false) ? 1 : 0)

      template << "C"
      values << (options.fetch(:partial_script, false) ? 1 : 0)

      template << "C"
      values << (options.fetch(:freeze, false) ? 1 : 0)

      template << "L"
      if (scopes = options[:scopes])
        values << scopes.length

        scopes.each do |scope|
          locals = nil
          forwarding = 0

          case scope
          when Array
            locals = scope
          when Scope
            locals = scope.locals

            scope.forwarding.each do |forward|
              case forward
              when :*     then forwarding |= 0x1
              when :**    then forwarding |= 0x2
              when :&     then forwarding |= 0x4
              when :"..." then forwarding |= 0x8
              else raise ArgumentError, "invalid forwarding value: #{forward}"
              end
            end
          else
            raise TypeError, "wrong argument type #{scope.class.inspect} (expected Array or Prism::Scope)"
          end

          template << "L"
          values << locals.length

          template << "C"
          values << forwarding

          locals.each do |local|
            name = local.name
            template << "L"
            values << name.bytesize

            template << "A*"
            values << name.b
          end
        end
      else
        values << 0
      end

      values.pack(template)
    end
  end

  # Here we are going to patch StringQuery to put in the class-level methods so
  # that it can maintain a consistent interface
  class StringQuery
    class << self
      # Mirrors the C extension's StringQuery::local? method.
      def local?(string)
        query(LibRubyParser.pm_string_query_local(string, string.bytesize, string.encoding.name))
      end

      # Mirrors the C extension's StringQuery::constant? method.
      def constant?(string)
        query(LibRubyParser.pm_string_query_constant(string, string.bytesize, string.encoding.name))
      end

      # Mirrors the C extension's StringQuery::method_name? method.
      def method_name?(string)
        query(LibRubyParser.pm_string_query_method_name(string, string.bytesize, string.encoding.name))
      end

      private

      # Parse the enum result and return an appropriate boolean.
      def query(result)
        case result
        when :PM_STRING_QUERY_ERROR
          raise ArgumentError, "Invalid or non ascii-compatible encoding"
        when :PM_STRING_QUERY_FALSE
          false
        when :PM_STRING_QUERY_TRUE
          true
        end
      end
    end
  end
end
prism-1.5.1/lib/prism/lex_compat.rb000066400000000000000000001007021506127434000172320ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

require "delegate"
require "ripper"

module Prism
  # This class is responsible for lexing the source using prism and then
  # converting those tokens to be compatible with Ripper. In the vast majority
  # of cases, this is a one-to-one mapping of the token type. Everything else
  # generally lines up. However, there are a few cases that require special
  # handling.
  class LexCompat # :nodoc:
    # A result class specialized for holding tokens produced by the lexer.
    class Result < Prism::Result
      # The list of tokens that were produced by the lexer.
      attr_reader :value

      # Create a new lex compat result object with the given values.
      def initialize(value, comments, magic_comments, data_loc, errors, warnings, source)
        @value = value
        super(comments, magic_comments, data_loc, errors, warnings, source)
      end

      # Implement the hash pattern matching interface for Result.
      def deconstruct_keys(keys)
        super.merge!(value: value)
      end
    end

    # This is a mapping of prism token types to Ripper token types. This is a
    # many-to-one mapping because we split up our token types, whereas Ripper
    # tends to group them.
    RIPPER = {
      AMPERSAND: :on_op,
      AMPERSAND_AMPERSAND: :on_op,
      AMPERSAND_AMPERSAND_EQUAL: :on_op,
      AMPERSAND_DOT: :on_op,
      AMPERSAND_EQUAL: :on_op,
      BACK_REFERENCE: :on_backref,
      BACKTICK: :on_backtick,
      BANG: :on_op,
      BANG_EQUAL: :on_op,
      BANG_TILDE: :on_op,
      BRACE_LEFT: :on_lbrace,
      BRACE_RIGHT: :on_rbrace,
      BRACKET_LEFT: :on_lbracket,
      BRACKET_LEFT_ARRAY: :on_lbracket,
      BRACKET_LEFT_RIGHT: :on_op,
      BRACKET_LEFT_RIGHT_EQUAL: :on_op,
      BRACKET_RIGHT: :on_rbracket,
      CARET: :on_op,
      CARET_EQUAL: :on_op,
      CHARACTER_LITERAL: :on_CHAR,
      CLASS_VARIABLE: :on_cvar,
      COLON: :on_op,
      COLON_COLON: :on_op,
      COMMA: :on_comma,
      COMMENT: :on_comment,
      CONSTANT: :on_const,
      DOT: :on_period,
      DOT_DOT: :on_op,
      DOT_DOT_DOT: :on_op,
      EMBDOC_BEGIN: :on_embdoc_beg,
      EMBDOC_END: :on_embdoc_end,
      EMBDOC_LINE: :on_embdoc,
      EMBEXPR_BEGIN: :on_embexpr_beg,
      EMBEXPR_END: :on_embexpr_end,
      EMBVAR: :on_embvar,
      EOF: :on_eof,
      EQUAL: :on_op,
      EQUAL_EQUAL: :on_op,
      EQUAL_EQUAL_EQUAL: :on_op,
      EQUAL_GREATER: :on_op,
      EQUAL_TILDE: :on_op,
      FLOAT: :on_float,
      FLOAT_IMAGINARY: :on_imaginary,
      FLOAT_RATIONAL: :on_rational,
      FLOAT_RATIONAL_IMAGINARY: :on_imaginary,
      GREATER: :on_op,
      GREATER_EQUAL: :on_op,
      GREATER_GREATER: :on_op,
      GREATER_GREATER_EQUAL: :on_op,
      GLOBAL_VARIABLE: :on_gvar,
      HEREDOC_END: :on_heredoc_end,
      HEREDOC_START: :on_heredoc_beg,
      IDENTIFIER: :on_ident,
      IGNORED_NEWLINE: :on_ignored_nl,
      INTEGER: :on_int,
      INTEGER_IMAGINARY: :on_imaginary,
      INTEGER_RATIONAL: :on_rational,
      INTEGER_RATIONAL_IMAGINARY: :on_imaginary,
      INSTANCE_VARIABLE: :on_ivar,
      INVALID: :INVALID,
      KEYWORD___ENCODING__: :on_kw,
      KEYWORD___LINE__: :on_kw,
      KEYWORD___FILE__: :on_kw,
      KEYWORD_ALIAS: :on_kw,
      KEYWORD_AND: :on_kw,
      KEYWORD_BEGIN: :on_kw,
      KEYWORD_BEGIN_UPCASE: :on_kw,
      KEYWORD_BREAK: :on_kw,
      KEYWORD_CASE: :on_kw,
      KEYWORD_CLASS: :on_kw,
      KEYWORD_DEF: :on_kw,
      KEYWORD_DEFINED: :on_kw,
      KEYWORD_DO: :on_kw,
      KEYWORD_DO_LOOP: :on_kw,
      KEYWORD_ELSE: :on_kw,
      KEYWORD_ELSIF: :on_kw,
      KEYWORD_END: :on_kw,
      KEYWORD_END_UPCASE: :on_kw,
      KEYWORD_ENSURE: :on_kw,
      KEYWORD_FALSE: :on_kw,
      KEYWORD_FOR: :on_kw,
      KEYWORD_IF: :on_kw,
      KEYWORD_IF_MODIFIER: :on_kw,
      KEYWORD_IN: :on_kw,
      KEYWORD_MODULE: :on_kw,
      KEYWORD_NEXT: :on_kw,
      KEYWORD_NIL: :on_kw,
      KEYWORD_NOT: :on_kw,
      KEYWORD_OR: :on_kw,
      KEYWORD_REDO: :on_kw,
      KEYWORD_RESCUE: :on_kw,
      KEYWORD_RESCUE_MODIFIER: :on_kw,
      KEYWORD_RETRY: :on_kw,
      KEYWORD_RETURN: :on_kw,
      KEYWORD_SELF: :on_kw,
      KEYWORD_SUPER: :on_kw,
      KEYWORD_THEN: :on_kw,
      KEYWORD_TRUE: :on_kw,
      KEYWORD_UNDEF: :on_kw,
      KEYWORD_UNLESS: :on_kw,
      KEYWORD_UNLESS_MODIFIER: :on_kw,
      KEYWORD_UNTIL: :on_kw,
      KEYWORD_UNTIL_MODIFIER: :on_kw,
      KEYWORD_WHEN: :on_kw,
      KEYWORD_WHILE: :on_kw,
      KEYWORD_WHILE_MODIFIER: :on_kw,
      KEYWORD_YIELD: :on_kw,
      LABEL: :on_label,
      LABEL_END: :on_label_end,
      LAMBDA_BEGIN: :on_tlambeg,
      LESS: :on_op,
      LESS_EQUAL: :on_op,
      LESS_EQUAL_GREATER: :on_op,
      LESS_LESS: :on_op,
      LESS_LESS_EQUAL: :on_op,
      METHOD_NAME: :on_ident,
      MINUS: :on_op,
      MINUS_EQUAL: :on_op,
      MINUS_GREATER: :on_tlambda,
      NEWLINE: :on_nl,
      NUMBERED_REFERENCE: :on_backref,
      PARENTHESIS_LEFT: :on_lparen,
      PARENTHESIS_LEFT_PARENTHESES: :on_lparen,
      PARENTHESIS_RIGHT: :on_rparen,
      PERCENT: :on_op,
      PERCENT_EQUAL: :on_op,
      PERCENT_LOWER_I: :on_qsymbols_beg,
      PERCENT_LOWER_W: :on_qwords_beg,
      PERCENT_LOWER_X: :on_backtick,
      PERCENT_UPPER_I: :on_symbols_beg,
      PERCENT_UPPER_W: :on_words_beg,
      PIPE: :on_op,
      PIPE_EQUAL: :on_op,
      PIPE_PIPE: :on_op,
      PIPE_PIPE_EQUAL: :on_op,
      PLUS: :on_op,
      PLUS_EQUAL: :on_op,
      QUESTION_MARK: :on_op,
      RATIONAL_FLOAT: :on_rational,
      RATIONAL_INTEGER: :on_rational,
      REGEXP_BEGIN: :on_regexp_beg,
      REGEXP_END: :on_regexp_end,
      SEMICOLON: :on_semicolon,
      SLASH: :on_op,
      SLASH_EQUAL: :on_op,
      STAR: :on_op,
      STAR_EQUAL: :on_op,
      STAR_STAR: :on_op,
      STAR_STAR_EQUAL: :on_op,
      STRING_BEGIN: :on_tstring_beg,
      STRING_CONTENT: :on_tstring_content,
      STRING_END: :on_tstring_end,
      SYMBOL_BEGIN: :on_symbeg,
      TILDE: :on_op,
      UAMPERSAND: :on_op,
      UCOLON_COLON: :on_op,
      UDOT_DOT: :on_op,
      UDOT_DOT_DOT: :on_op,
      UMINUS: :on_op,
      UMINUS_NUM: :on_op,
      UPLUS: :on_op,
      USTAR: :on_op,
      USTAR_STAR: :on_op,
      WORDS_SEP: :on_words_sep,
      "__END__": :on___end__
    }.freeze

    # When we produce tokens, we produce the same arrays that Ripper does.
    # However, we add a couple of convenience methods onto them to make them a
    # little easier to work with. We delegate all other methods to the array.
    class Token < SimpleDelegator
      # @dynamic initialize, each, []

      # The location of the token in the source.
      def location
        self[0]
      end

      # The type of the token.
      def event
        self[1]
      end

      # The slice of the source that this token represents.
      def value
        self[2]
      end

      # The state of the lexer when this token was produced.
      def state
        self[3]
      end
    end

    # Ripper doesn't include the rest of the token in the event, so we need to
    # trim it down to just the content on the first line when comparing.
    class EndContentToken < Token
      def ==(other) # :nodoc:
        [self[0], self[1], self[2][0..self[2].index("\n")], self[3]] == other
      end
    end

    # Tokens where state should be ignored
    # used for :on_comment, :on_heredoc_end, :on_embexpr_end
    class IgnoreStateToken < Token
      def ==(other) # :nodoc:
        self[0...-1] == other[0...-1]
      end
    end

    # Ident tokens for the most part are exactly the same, except sometimes we
    # know an ident is a local when ripper doesn't (when they are introduced
    # through named captures in regular expressions). In that case we don't
    # compare the state.
    class IdentToken < Token
      def ==(other) # :nodoc:
        (self[0...-1] == other[0...-1]) && (
          (other[3] == Ripper::EXPR_LABEL | Ripper::EXPR_END) ||
          (other[3] & Ripper::EXPR_ARG_ANY != 0)
        )
      end
    end

    # Ignored newlines can occasionally have a LABEL state attached to them, so
    # we compare the state differently here.
    class IgnoredNewlineToken < Token
      def ==(other) # :nodoc:
        return false unless self[0...-1] == other[0...-1]

        if self[3] == Ripper::EXPR_ARG | Ripper::EXPR_LABELED
          other[3] & Ripper::EXPR_ARG | Ripper::EXPR_LABELED != 0
        else
          self[3] == other[3]
        end
      end
    end

    # If we have an identifier that follows a method name like:
    #
    #     def foo bar
    #
    # then Ripper will mark bar as END|LABEL if there is a local in a parent
    # scope named bar because it hasn't pushed the local table yet. We do this
    # more accurately, so we need to allow comparing against both END and
    # END|LABEL.
    class ParamToken < Token
      def ==(other) # :nodoc:
        (self[0...-1] == other[0...-1]) && (
          (other[3] == Ripper::EXPR_END) ||
          (other[3] == Ripper::EXPR_END | Ripper::EXPR_LABEL)
        )
      end
    end

    # A heredoc in this case is a list of tokens that belong to the body of the
    # heredoc that should be appended onto the list of tokens when the heredoc
    # closes.
    module Heredoc # :nodoc:
      # Heredocs that are no dash or tilde heredocs are just a list of tokens.
      # We need to keep them around so that we can insert them in the correct
      # order back into the token stream and set the state of the last token to
      # the state that the heredoc was opened in.
      class PlainHeredoc # :nodoc:
        attr_reader :tokens

        def initialize
          @tokens = []
        end

        def <<(token)
          tokens << token
        end

        def to_a
          tokens
        end
      end

      # Dash heredocs are a little more complicated. They are a list of tokens
      # that need to be split on "\\\n" to mimic Ripper's behavior. We also need
      # to keep track of the state that the heredoc was opened in.
      class DashHeredoc # :nodoc:
        attr_reader :split, :tokens

        def initialize(split)
          @split = split
          @tokens = []
        end

        def <<(token)
          tokens << token
        end

        def to_a
          embexpr_balance = 0

          tokens.each_with_object([]) do |token, results| #$ Array[Token]
            case token.event
            when :on_embexpr_beg
              embexpr_balance += 1
              results << token
            when :on_embexpr_end
              embexpr_balance -= 1
              results << token
            when :on_tstring_content
              if embexpr_balance == 0
                lineno = token[0][0]
                column = token[0][1]

                if split
                  # Split on "\\\n" to mimic Ripper's behavior. Use a lookbehind
                  # to keep the delimiter in the result.
                  token.value.split(/(?<=[^\\]\\\n)|(?<=[^\\]\\\r\n)/).each_with_index do |value, index|
                    column = 0 if index > 0
                    results << Token.new([[lineno, column], :on_tstring_content, value, token.state])
                    lineno += value.count("\n")
                  end
                else
                  results << token
                end
              else
                results << token
              end
            else
              results << token
            end
          end
        end
      end

      # Heredocs that are dedenting heredocs are a little more complicated.
      # Ripper outputs on_ignored_sp tokens for the whitespace that is being
      # removed from the output. prism only modifies the node itself and keeps
      # the token the same. This simplifies prism, but makes comparing against
      # Ripper much harder because there is a length mismatch.
      #
      # Fortunately, we already have to pull out the heredoc tokens in order to
      # insert them into the stream in the correct order. As such, we can do
      # some extra manipulation on the tokens to make them match Ripper's
      # output by mirroring the dedent logic that Ripper uses.
      class DedentingHeredoc # :nodoc:
        TAB_WIDTH = 8

        attr_reader :tokens, :dedent_next, :dedent, :embexpr_balance

        def initialize
          @tokens = []
          @dedent_next = true
          @dedent = nil
          @embexpr_balance = 0
          @ended_on_newline = false
        end

        # As tokens are coming in, we track the minimum amount of common leading
        # whitespace on plain string content tokens. This allows us to later
        # remove that amount of whitespace from the beginning of each line.
        def <<(token)
          case token.event
          when :on_embexpr_beg, :on_heredoc_beg
            @embexpr_balance += 1
            @dedent = 0 if @dedent_next && @ended_on_newline
          when :on_embexpr_end, :on_heredoc_end
            @embexpr_balance -= 1
          when :on_tstring_content
            if embexpr_balance == 0
              line = token.value

              if dedent_next && !(line.strip.empty? && line.end_with?("\n"))
                leading = line[/\A(\s*)\n?/, 1]
                next_dedent = 0

                leading.each_char do |char|
                  if char == "\t"
                    next_dedent = next_dedent - (next_dedent % TAB_WIDTH) + TAB_WIDTH
                  else
                    next_dedent += 1
                  end
                end

                @dedent = [dedent, next_dedent].compact.min
                @dedent_next = true
                @ended_on_newline = line.end_with?("\n")
                tokens << token
                return
              end
            end
          end

          @dedent_next = token.event == :on_tstring_content && embexpr_balance == 0
          @ended_on_newline = false
          tokens << token
        end

        def to_a
          # If every line in the heredoc is blank, we still need to split up the
          # string content token into multiple tokens.
          if dedent.nil?
            results = [] #: Array[Token]
            embexpr_balance = 0

            tokens.each do |token|
              case token.event
              when :on_embexpr_beg, :on_heredoc_beg
                embexpr_balance += 1
                results << token
              when :on_embexpr_end, :on_heredoc_end
                embexpr_balance -= 1
                results << token
              when :on_tstring_content
                if embexpr_balance == 0
                  lineno = token[0][0]
                  column = token[0][1]

                  token.value.split(/(?<=\n)/).each_with_index do |value, index|
                    column = 0 if index > 0
                    results << Token.new([[lineno, column], :on_tstring_content, value, token.state])
                    lineno += 1
                  end
                else
                  results << token
                end
              else
                results << token
              end
            end

            return results
          end

          # If the minimum common whitespace is 0, then we need to concatenate
          # string nodes together that are immediately adjacent.
          if dedent == 0
            results = [] #: Array[Token]
            embexpr_balance = 0

            index = 0
            max_index = tokens.length

            while index < max_index
              token = tokens[index]
              results << token
              index += 1

              case token.event
              when :on_embexpr_beg, :on_heredoc_beg
                embexpr_balance += 1
              when :on_embexpr_end, :on_heredoc_end
                embexpr_balance -= 1
              when :on_tstring_content
                if embexpr_balance == 0
                  while index < max_index && tokens[index].event == :on_tstring_content && !token.value.match?(/\\\r?\n\z/)
                    token.value << tokens[index].value
                    index += 1
                  end
                end
              end
            end

            return results
          end

          # Otherwise, we're going to run through each token in the list and
          # insert on_ignored_sp tokens for the amount of dedent that we need to
          # perform. We also need to remove the dedent from the beginning of
          # each line of plain string content tokens.
          results = [] #: Array[Token]
          dedent_next = true
          embexpr_balance = 0

          tokens.each do |token|
            # Notice that the structure of this conditional largely matches the
            # whitespace calculation we performed above. This is because
            # checking if the subsequent token needs to be dedented is common to
            # both the dedent calculation and the ignored_sp insertion.
            case token.event
            when :on_embexpr_beg
              embexpr_balance += 1
              results << token
            when :on_embexpr_end
              embexpr_balance -= 1
              results << token
            when :on_tstring_content
              if embexpr_balance == 0
                # Here we're going to split the string on newlines, but maintain
                # the newlines in the resulting array. We'll do that with a look
                # behind assertion.
                splits = token.value.split(/(?<=\n)/)
                index = 0

                while index < splits.length
                  line = splits[index]
                  lineno = token[0][0] + index
                  column = token[0][1]

                  # Blank lines do not count toward common leading whitespace
                  # calculation and do not need to be dedented.
                  if dedent_next || index > 0
                    column = 0
                  end

                  # If the dedent is 0 and we're not supposed to dedent the next
                  # line or this line doesn't start with whitespace, then we
                  # should concatenate the rest of the string to match ripper.
                  if dedent == 0 && (!dedent_next || !line.start_with?(/\s/))
                    line = splits[index..].join
                    index = splits.length
                  end

                  # If we are supposed to dedent this line or if this is not the
                  # first line of the string and this line isn't entirely blank,
                  # then we need to insert an on_ignored_sp token and remove the
                  # dedent from the beginning of the line.
                  if (dedent > 0) && (dedent_next || index > 0)
                    deleting = 0
                    deleted_chars = [] #: Array[String]

                    # Gather up all of the characters that we're going to
                    # delete, stopping when you hit a character that would put
                    # you over the dedent amount.
                    line.each_char.with_index do |char, i|
                      case char
                      when "\r"
                        if line[i + 1] == "\n"
                          break
                        end
                      when "\n"
                        break
                      when "\t"
                        deleting = deleting - (deleting % TAB_WIDTH) + TAB_WIDTH
                      else
                        deleting += 1
                      end

                      break if deleting > dedent
                      deleted_chars << char
                    end

                    # If we have something to delete, then delete it from the
                    # string and insert an on_ignored_sp token.
                    if deleted_chars.any?
                      ignored = deleted_chars.join
                      line.delete_prefix!(ignored)

                      results << Token.new([[lineno, 0], :on_ignored_sp, ignored, token[3]])
                      column = ignored.length
                    end
                  end

                  results << Token.new([[lineno, column], token[1], line, token[3]]) unless line.empty?
                  index += 1
                end
              else
                results << token
              end
            else
              results << token
            end

            dedent_next =
              ((token.event == :on_tstring_content) || (token.event == :on_heredoc_end)) &&
              embexpr_balance == 0
          end

          results
        end
      end

      # Here we will split between the two types of heredocs and return the
      # object that will store their tokens.
      def self.build(opening)
        case opening.value[2]
        when "~"
          DedentingHeredoc.new
        when "-"
          DashHeredoc.new(opening.value[3] != "'")
        else
          PlainHeredoc.new
        end
      end
    end

    private_constant :Heredoc

    attr_reader :source, :options

    def initialize(source, **options)
      @source = source
      @options = options
    end

    def result
      tokens = [] #: Array[LexCompat::Token]

      state = :default
      heredoc_stack = [[]] #: Array[Array[Heredoc::PlainHeredoc | Heredoc::DashHeredoc | Heredoc::DedentingHeredoc]]

      result = Prism.lex(source, **options)
      result_value = result.value
      previous_state = nil #: Ripper::Lexer::State?
      last_heredoc_end = nil #: Integer?

      # In previous versions of Ruby, Ripper wouldn't flush the bom before the
      # first token, so we had to have a hack in place to account for that. This
      # checks for that behavior.
      bom_flushed = Ripper.lex("\xEF\xBB\xBF# test")[0][0][1] == 0
      bom = source.byteslice(0..2) == "\xEF\xBB\xBF"

      result_value.each_with_index do |(token, lex_state), index|
        lineno = token.location.start_line
        column = token.location.start_column

        # If there's a UTF-8 byte-order mark as the start of the file, then for
        # certain tokens ripper sets the first token back by 3 bytes. It also
        # keeps the byte order mark in the first token's value. This is weird,
        # and I don't want to mirror that in our parser. So instead, we'll match
        # up the columns and values here.
        if bom && lineno == 1
          column -= 3

          if index == 0 && column == 0 && !bom_flushed
            flushed =
              case token.type
              when :BACK_REFERENCE, :INSTANCE_VARIABLE, :CLASS_VARIABLE,
                  :GLOBAL_VARIABLE, :NUMBERED_REFERENCE, :PERCENT_LOWER_I,
                  :PERCENT_LOWER_X, :PERCENT_LOWER_W, :PERCENT_UPPER_I,
                  :PERCENT_UPPER_W, :STRING_BEGIN
                true
              when :REGEXP_BEGIN, :SYMBOL_BEGIN
                token.value.start_with?("%")
              else
                false
              end

            unless flushed
              column -= 3
              value = token.value
              value.prepend(String.new("\xEF\xBB\xBF", encoding: value.encoding))
            end
          end
        end

        event = RIPPER.fetch(token.type)
        value = token.value
        lex_state = Ripper::Lexer::State.new(lex_state)

        token =
          case event
          when :on___end__
            EndContentToken.new([[lineno, column], event, value, lex_state])
          when :on_comment
            IgnoreStateToken.new([[lineno, column], event, value, lex_state])
          when :on_heredoc_end
            # Heredoc end tokens can be emitted in an odd order, so we don't
            # want to bother comparing the state on them.
            last_heredoc_end = token.location.end_offset
            IgnoreStateToken.new([[lineno, column], event, value, lex_state])
          when :on_ident
            if lex_state == Ripper::EXPR_END
              # If we have an identifier that follows a method name like:
              #
              #     def foo bar
              #
              # then Ripper will mark bar as END|LABEL if there is a local in a
              # parent scope named bar because it hasn't pushed the local table
              # yet. We do this more accurately, so we need to allow comparing
              # against both END and END|LABEL.
              ParamToken.new([[lineno, column], event, value, lex_state])
            elsif lex_state == Ripper::EXPR_END | Ripper::EXPR_LABEL
              # In the event that we're comparing identifiers, we're going to
              # allow a little divergence. Ripper doesn't account for local
              # variables introduced through named captures in regexes, and we
              # do, which accounts for this difference.
              IdentToken.new([[lineno, column], event, value, lex_state])
            else
              Token.new([[lineno, column], event, value, lex_state])
            end
          when :on_embexpr_end
            IgnoreStateToken.new([[lineno, column], event, value, lex_state])
          when :on_ignored_nl
            # Ignored newlines can occasionally have a LABEL state attached to
            # them which doesn't actually impact anything. We don't mirror that
            # state so we ignored it.
            IgnoredNewlineToken.new([[lineno, column], event, value, lex_state])
          when :on_regexp_end
            # On regex end, Ripper scans and then sets end state, so the ripper
            # lexed output is begin, when it should be end. prism sets lex state
            # correctly to end state, but we want to be able to compare against
            # Ripper's lexed state. So here, if it's a regexp end token, we
            # output the state as the previous state, solely for the sake of
            # comparison.
            previous_token = result_value[index - 1][0]
            lex_state =
              if RIPPER.fetch(previous_token.type) == :on_embexpr_end
                # If the previous token is embexpr_end, then we have to do even
                # more processing. The end of an embedded expression sets the
                # state to the state that it had at the beginning of the
                # embedded expression. So we have to go and find that state and
                # set it here.
                counter = 1
                current_index = index - 1

                until counter == 0
                  current_index -= 1
                  current_event = RIPPER.fetch(result_value[current_index][0].type)
                  counter += { on_embexpr_beg: -1, on_embexpr_end: 1 }[current_event] || 0
                end

                Ripper::Lexer::State.new(result_value[current_index][1])
              else
                previous_state
              end

            Token.new([[lineno, column], event, value, lex_state])
          when :on_eof
            previous_token = result_value[index - 1][0]

            # If we're at the end of the file and the previous token was a
            # comment and there is still whitespace after the comment, then
            # Ripper will append a on_nl token (even though there isn't
            # necessarily a newline). We mirror that here.
            if previous_token.type == :COMMENT
              # If the comment is at the start of a heredoc: < 1
              flushing = heredoc_stack.pop
              heredoc_stack.last.last << token

              flushing.each do |heredoc|
                heredoc.to_a.each do |flushed_token|
                  heredoc_stack.last.last << flushed_token
                end
              end

              state = :heredoc_opened
              next
            end
          elsif event == :on_heredoc_beg
            tokens << token
            state = :heredoc_opened
            heredoc_stack.last << Heredoc.build(token)
            next
          elsif heredoc_stack.size > 1
            heredoc_stack[-2].last << token
            next
          end

          heredoc_stack.last.each do |heredoc|
            tokens.concat(heredoc.to_a)
          end

          heredoc_stack.last.clear
          state = :default

          tokens << token
        end
      end

      # Drop the EOF token from the list
      tokens = tokens[0...-1]

      # We sort by location to compare against Ripper's output
      tokens.sort_by!(&:location)

      Result.new(tokens, result.comments, result.magic_comments, result.data_loc, result.errors, result.warnings, Source.for(source))
    end
  end

  private_constant :LexCompat

  # This is a class that wraps the Ripper lexer to produce almost exactly the
  # same tokens.
  class LexRipper # :nodoc:
    attr_reader :source

    def initialize(source)
      @source = source
    end

    def result
      previous = [] #: [[Integer, Integer], Symbol, String, untyped] | []
      results = [] #: Array[[[Integer, Integer], Symbol, String, untyped]]

      lex(source).each do |token|
        case token[1]
        when :on_sp
          # skip
        when :on_tstring_content
          if previous[1] == :on_tstring_content && (token[2].start_with?("\#$") || token[2].start_with?("\#@"))
            previous[2] << token[2]
          else
            results << token
            previous = token
          end
        when :on_words_sep
          if previous[1] == :on_words_sep
            previous[2] << token[2]
          else
            results << token
            previous = token
          end
        else
          results << token
          previous = token
        end
      end

      results
    end

    private

    if Ripper.method(:lex).parameters.assoc(:keyrest)
      def lex(source)
        Ripper.lex(source, raise_errors: true)
      end
    else
      def lex(source)
        ripper = Ripper::Lexer.new(source)
        ripper.lex.tap do |result|
          raise SyntaxError, ripper.errors.map(&:message).join(' ;') if ripper.errors.any?
        end
      end
    end
  end

  private_constant :LexRipper
end
prism-1.5.1/lib/prism/node_ext.rb000066400000000000000000000357461506127434000167230ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

#--
# Here we are reopening the prism module to provide methods on nodes that aren't
# templated and are meant as convenience methods.
#++
module Prism
  class Node
    def deprecated(*replacements) # :nodoc:
      location = caller_locations(1, 1)
      location = location[0].label if location
      suggest = replacements.map { |replacement| "#{self.class}##{replacement}" }

      warn(<<~MSG, uplevel: 1, category: :deprecated)
        [deprecation]: #{self.class}##{location} is deprecated and will be \
        removed in the next major version. Use #{suggest.join("/")} instead.
        #{(caller(1, 3) || []).join("\n")}
      MSG
    end
  end

  module RegularExpressionOptions # :nodoc:
    # Returns a numeric value that represents the flags that were used to create
    # the regular expression.
    def options
      o = 0
      o |= Regexp::IGNORECASE if flags.anybits?(RegularExpressionFlags::IGNORE_CASE)
      o |= Regexp::EXTENDED if flags.anybits?(RegularExpressionFlags::EXTENDED)
      o |= Regexp::MULTILINE if flags.anybits?(RegularExpressionFlags::MULTI_LINE)
      o |= Regexp::FIXEDENCODING if flags.anybits?(RegularExpressionFlags::EUC_JP | RegularExpressionFlags::WINDOWS_31J | RegularExpressionFlags::UTF_8)
      o |= Regexp::NOENCODING if flags.anybits?(RegularExpressionFlags::ASCII_8BIT)
      o
    end
  end

  class InterpolatedMatchLastLineNode < Node
    include RegularExpressionOptions
  end

  class InterpolatedRegularExpressionNode < Node
    include RegularExpressionOptions
  end

  class MatchLastLineNode < Node
    include RegularExpressionOptions
  end

  class RegularExpressionNode < Node
    include RegularExpressionOptions
  end

  private_constant :RegularExpressionOptions

  module HeredocQuery # :nodoc:
    # Returns true if this node was represented as a heredoc in the source code.
    def heredoc?
      opening&.start_with?("<<")
    end
  end

  class InterpolatedStringNode < Node
    include HeredocQuery
  end

  class InterpolatedXStringNode < Node
    include HeredocQuery
  end

  class StringNode < Node
    include HeredocQuery

    # Occasionally it's helpful to treat a string as if it were interpolated so
    # that there's a consistent interface for working with strings.
    def to_interpolated
      InterpolatedStringNode.new(
        source,
        -1,
        location,
        frozen? ? InterpolatedStringNodeFlags::FROZEN : 0,
        opening_loc,
        [copy(location: content_loc, opening_loc: nil, closing_loc: nil)],
        closing_loc
      )
    end
  end

  class XStringNode < Node
    include HeredocQuery

    # Occasionally it's helpful to treat a string as if it were interpolated so
    # that there's a consistent interface for working with strings.
    def to_interpolated
      InterpolatedXStringNode.new(
        source,
        -1,
        location,
        flags,
        opening_loc,
        [StringNode.new(source, node_id, content_loc, 0, nil, content_loc, nil, unescaped)],
        closing_loc
      )
    end
  end

  private_constant :HeredocQuery

  class ImaginaryNode < Node
    # Returns the value of the node as a Ruby Complex.
    def value
      Complex(0, numeric.value)
    end
  end

  class RationalNode < Node
    # Returns the value of the node as a Ruby Rational.
    def value
      Rational(numerator, denominator)
    end

    # Returns the value of the node as an IntegerNode or a FloatNode. This
    # method is deprecated in favor of #value or #numerator/#denominator.
    def numeric
      deprecated("value", "numerator", "denominator")

      if denominator == 1
        IntegerNode.new(source, -1, location.chop, flags, numerator)
      else
        FloatNode.new(source, -1, location.chop, 0, numerator.to_f / denominator)
      end
    end
  end

  class ConstantReadNode < Node
    # Returns the list of parts for the full name of this constant.
    # For example: [:Foo]
    def full_name_parts
      [name]
    end

    # Returns the full name of this constant. For example: "Foo"
    def full_name
      name.to_s
    end
  end

  class ConstantWriteNode < Node
    # Returns the list of parts for the full name of this constant.
    # For example: [:Foo]
    def full_name_parts
      [name]
    end

    # Returns the full name of this constant. For example: "Foo"
    def full_name
      name.to_s
    end
  end

  class ConstantPathNode < Node
    # An error class raised when dynamic parts are found while computing a
    # constant path's full name. For example:
    # Foo::Bar::Baz -> does not raise because all parts of the constant path are
    # simple constants
    # var::Bar::Baz -> raises because the first part of the constant path is a
    # local variable
    class DynamicPartsInConstantPathError < StandardError; end

    # An error class raised when missing nodes are found while computing a
    # constant path's full name. For example:
    # Foo:: -> raises because the constant path is missing the last part
    class MissingNodesInConstantPathError < StandardError; end

    # Returns the list of parts for the full name of this constant path.
    # For example: [:Foo, :Bar]
    def full_name_parts
      parts = [] #: Array[Symbol]
      current = self #: node?

      while current.is_a?(ConstantPathNode)
        name = current.name
        if name.nil?
          raise MissingNodesInConstantPathError, "Constant path contains missing nodes. Cannot compute full name"
        end

        parts.unshift(name)
        current = current.parent
      end

      if !current.is_a?(ConstantReadNode) && !current.nil?
        raise DynamicPartsInConstantPathError, "Constant path contains dynamic parts. Cannot compute full name"
      end

      parts.unshift(current&.name || :"")
    end

    # Returns the full name of this constant path. For example: "Foo::Bar"
    def full_name
      full_name_parts.join("::")
    end

    # Previously, we had a child node on this class that contained either a
    # constant read or a missing node. To not cause a breaking change, we
    # continue to supply that API.
    def child
      deprecated("name", "name_loc")

      if name
        ConstantReadNode.new(source, -1, name_loc, 0, name)
      else
        MissingNode.new(source, -1, location, 0)
      end
    end
  end

  class ConstantPathTargetNode < Node
    # Returns the list of parts for the full name of this constant path.
    # For example: [:Foo, :Bar]
    def full_name_parts
      parts =
        case parent
        when ConstantPathNode, ConstantReadNode
          parent.full_name_parts
        when nil
          [:""]
        else
          # e.g. self::Foo, (var)::Bar = baz
          raise ConstantPathNode::DynamicPartsInConstantPathError, "Constant target path contains dynamic parts. Cannot compute full name"
        end

      if name.nil?
        raise ConstantPathNode::MissingNodesInConstantPathError, "Constant target path contains missing nodes. Cannot compute full name"
      end

      parts.push(name)
    end

    # Returns the full name of this constant path. For example: "Foo::Bar"
    def full_name
      full_name_parts.join("::")
    end

    # Previously, we had a child node on this class that contained either a
    # constant read or a missing node. To not cause a breaking change, we
    # continue to supply that API.
    def child
      deprecated("name", "name_loc")

      if name
        ConstantReadNode.new(source, -1, name_loc, 0, name)
      else
        MissingNode.new(source, -1, location, 0)
      end
    end
  end

  class ConstantTargetNode < Node
    # Returns the list of parts for the full name of this constant.
    # For example: [:Foo]
    def full_name_parts
      [name]
    end

    # Returns the full name of this constant. For example: "Foo"
    def full_name
      name.to_s
    end
  end

  class ParametersNode < Node
    # Mirrors the Method#parameters method.
    def signature
      names = [] #: Array[[Symbol, Symbol] | [Symbol]]

      requireds.each do |param|
        names << (param.is_a?(MultiTargetNode) ? [:req] : [:req, param.name])
      end

      optionals.each { |param| names << [:opt, param.name] }

      if rest && rest.is_a?(RestParameterNode)
        names << [:rest, rest.name || :*]
      end

      posts.each do |param|
        case param
        when MultiTargetNode
          names << [:req]
        when NoKeywordsParameterNode, KeywordRestParameterNode, ForwardingParameterNode
          # Invalid syntax, e.g. "def f(**nil, ...)" moves the NoKeywordsParameterNode to posts
          raise "Invalid syntax"
        else
          names << [:req, param.name]
        end
      end

      # Regardless of the order in which the keywords were defined, the required
      # keywords always come first followed by the optional keywords.
      keyopt = [] #: Array[OptionalKeywordParameterNode]
      keywords.each do |param|
        if param.is_a?(OptionalKeywordParameterNode)
          keyopt << param
        else
          names << [:keyreq, param.name]
        end
      end

      keyopt.each { |param| names << [:key, param.name] }

      case keyword_rest
      when ForwardingParameterNode
        names.concat([[:rest, :*], [:keyrest, :**], [:block, :&]])
      when KeywordRestParameterNode
        names << [:keyrest, keyword_rest.name || :**]
      when NoKeywordsParameterNode
        names << [:nokey]
      end

      names << [:block, block.name || :&] if block
      names
    end
  end

  class CallNode < Node
    # When a call node has the attribute_write flag set, it means that the call
    # is using the attribute write syntax. This is either a method call to []=
    # or a method call to a method that ends with =. Either way, the = sign is
    # present in the source.
    #
    # Prism returns the message_loc _without_ the = sign attached, because there
    # can be any amount of space between the message and the = sign. However,
    # sometimes you want the location of the full message including the inner
    # space and the = sign. This method provides that.
    def full_message_loc
      attribute_write? ? message_loc&.adjoin("=") : message_loc
    end
  end

  class CallOperatorWriteNode < Node
    # Returns the binary operator used to modify the receiver. This method is
    # deprecated in favor of #binary_operator.
    def operator
      deprecated("binary_operator")
      binary_operator
    end

    # Returns the location of the binary operator used to modify the receiver.
    # This method is deprecated in favor of #binary_operator_loc.
    def operator_loc
      deprecated("binary_operator_loc")
      binary_operator_loc
    end
  end

  class ClassVariableOperatorWriteNode < Node
    # Returns the binary operator used to modify the receiver. This method is
    # deprecated in favor of #binary_operator.
    def operator
      deprecated("binary_operator")
      binary_operator
    end

    # Returns the location of the binary operator used to modify the receiver.
    # This method is deprecated in favor of #binary_operator_loc.
    def operator_loc
      deprecated("binary_operator_loc")
      binary_operator_loc
    end
  end

  class ConstantOperatorWriteNode < Node
    # Returns the binary operator used to modify the receiver. This method is
    # deprecated in favor of #binary_operator.
    def operator
      deprecated("binary_operator")
      binary_operator
    end

    # Returns the location of the binary operator used to modify the receiver.
    # This method is deprecated in favor of #binary_operator_loc.
    def operator_loc
      deprecated("binary_operator_loc")
      binary_operator_loc
    end
  end

  class ConstantPathOperatorWriteNode < Node
    # Returns the binary operator used to modify the receiver. This method is
    # deprecated in favor of #binary_operator.
    def operator
      deprecated("binary_operator")
      binary_operator
    end

    # Returns the location of the binary operator used to modify the receiver.
    # This method is deprecated in favor of #binary_operator_loc.
    def operator_loc
      deprecated("binary_operator_loc")
      binary_operator_loc
    end
  end

  class GlobalVariableOperatorWriteNode < Node
    # Returns the binary operator used to modify the receiver. This method is
    # deprecated in favor of #binary_operator.
    def operator
      deprecated("binary_operator")
      binary_operator
    end

    # Returns the location of the binary operator used to modify the receiver.
    # This method is deprecated in favor of #binary_operator_loc.
    def operator_loc
      deprecated("binary_operator_loc")
      binary_operator_loc
    end
  end

  class IndexOperatorWriteNode < Node
    # Returns the binary operator used to modify the receiver. This method is
    # deprecated in favor of #binary_operator.
    def operator
      deprecated("binary_operator")
      binary_operator
    end

    # Returns the location of the binary operator used to modify the receiver.
    # This method is deprecated in favor of #binary_operator_loc.
    def operator_loc
      deprecated("binary_operator_loc")
      binary_operator_loc
    end
  end

  class InstanceVariableOperatorWriteNode < Node
    # Returns the binary operator used to modify the receiver. This method is
    # deprecated in favor of #binary_operator.
    def operator
      deprecated("binary_operator")
      binary_operator
    end

    # Returns the location of the binary operator used to modify the receiver.
    # This method is deprecated in favor of #binary_operator_loc.
    def operator_loc
      deprecated("binary_operator_loc")
      binary_operator_loc
    end
  end

  class LocalVariableOperatorWriteNode < Node
    # Returns the binary operator used to modify the receiver. This method is
    # deprecated in favor of #binary_operator.
    def operator
      deprecated("binary_operator")
      binary_operator
    end

    # Returns the location of the binary operator used to modify the receiver.
    # This method is deprecated in favor of #binary_operator_loc.
    def operator_loc
      deprecated("binary_operator_loc")
      binary_operator_loc
    end
  end

  class CaseMatchNode < Node
    # Returns the else clause of the case match node. This method is deprecated
    # in favor of #else_clause.
    def consequent
      deprecated("else_clause")
      else_clause
    end
  end

  class CaseNode < Node
    # Returns the else clause of the case node. This method is deprecated in
    # favor of #else_clause.
    def consequent
      deprecated("else_clause")
      else_clause
    end
  end

  class IfNode < Node
    # Returns the subsequent if/elsif/else clause of the if node. This method is
    # deprecated in favor of #subsequent.
    def consequent
      deprecated("subsequent")
      subsequent
    end
  end

  class RescueNode < Node
    # Returns the subsequent rescue clause of the rescue node. This method is
    # deprecated in favor of #subsequent.
    def consequent
      deprecated("subsequent")
      subsequent
    end
  end

  class UnlessNode < Node
    # Returns the else clause of the unless node. This method is deprecated in
    # favor of #else_clause.
    def consequent
      deprecated("else_clause")
      else_clause
    end
  end
end
prism-1.5.1/lib/prism/pack.rb000066400000000000000000000136031506127434000160200ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown
# typed: ignore

#
module Prism
  # A parser for the pack template language.
  module Pack
    %i[
      SPACE
      COMMENT
      INTEGER
      UTF8
      BER
      FLOAT
      STRING_SPACE_PADDED
      STRING_NULL_PADDED
      STRING_NULL_TERMINATED
      STRING_MSB
      STRING_LSB
      STRING_HEX_HIGH
      STRING_HEX_LOW
      STRING_UU
      STRING_MIME
      STRING_BASE64
      STRING_FIXED
      STRING_POINTER
      MOVE
      BACK
      NULL

      UNSIGNED
      SIGNED
      SIGNED_NA

      AGNOSTIC_ENDIAN
      LITTLE_ENDIAN
      BIG_ENDIAN
      NATIVE_ENDIAN
      ENDIAN_NA

      SIZE_SHORT
      SIZE_INT
      SIZE_LONG
      SIZE_LONG_LONG
      SIZE_8
      SIZE_16
      SIZE_32
      SIZE_64
      SIZE_P
      SIZE_NA

      LENGTH_FIXED
      LENGTH_MAX
      LENGTH_RELATIVE
      LENGTH_NA
    ].each do |const|
      const_set(const, const)
    end

    # A directive in the pack template language.
    class Directive
      # A symbol representing the version of Ruby.
      attr_reader :version

      # A symbol representing whether or not we are packing or unpacking.
      attr_reader :variant

      # A byteslice of the source string that this directive represents.
      attr_reader :source

      # The type of the directive.
      attr_reader :type

      # The type of signedness of the directive.
      attr_reader :signed

      # The type of endianness of the directive.
      attr_reader :endian

      # The size of the directive.
      attr_reader :size

      # The length type of this directive (used for integers).
      attr_reader :length_type

      # The length of this directive (used for integers).
      attr_reader :length

      # Initialize a new directive with the given values.
      def initialize(version, variant, source, type, signed, endian, size, length_type, length)
        @version = version
        @variant = variant
        @source = source
        @type = type
        @signed = signed
        @endian = endian
        @size = size
        @length_type = length_type
        @length = length
      end

      # The descriptions of the various types of endianness.
      ENDIAN_DESCRIPTIONS = {
        AGNOSTIC_ENDIAN: "agnostic",
        LITTLE_ENDIAN: "little-endian (VAX)",
        BIG_ENDIAN: "big-endian (network)",
        NATIVE_ENDIAN: "native-endian",
        ENDIAN_NA: "n/a"
      }

      # The descriptions of the various types of signedness.
      SIGNED_DESCRIPTIONS = {
        UNSIGNED: "unsigned",
        SIGNED: "signed",
        SIGNED_NA: "n/a"
      }

      # The descriptions of the various types of sizes.
      SIZE_DESCRIPTIONS = {
        SIZE_SHORT: "short",
        SIZE_INT: "int-width",
        SIZE_LONG: "long",
        SIZE_LONG_LONG: "long long",
        SIZE_8: "8-bit",
        SIZE_16: "16-bit",
        SIZE_32: "32-bit",
        SIZE_64: "64-bit",
        SIZE_P: "pointer-width"
      }

      # Provide a human-readable description of the directive.
      def describe
        case type
        when SPACE
          "whitespace"
        when COMMENT
          "comment"
        when INTEGER
          if size == SIZE_8
            base = "#{SIGNED_DESCRIPTIONS[signed]} #{SIZE_DESCRIPTIONS[size]} integer"
          else
            base = "#{SIGNED_DESCRIPTIONS[signed]} #{SIZE_DESCRIPTIONS[size]} #{ENDIAN_DESCRIPTIONS[endian]} integer"
          end
          case length_type
          when LENGTH_FIXED
            if length > 1
              base + ", x#{length}"
            else
              base
            end
          when LENGTH_MAX
            base + ", as many as possible"
          else
            raise
          end
        when UTF8
          "UTF-8 character"
        when BER
          "BER-compressed integer"
        when FLOAT
          "#{SIZE_DESCRIPTIONS[size]} #{ENDIAN_DESCRIPTIONS[endian]} float"
        when STRING_SPACE_PADDED
          "arbitrary binary string (space padded)"
        when STRING_NULL_PADDED
          "arbitrary binary string (null padded, count is width)"
        when STRING_NULL_TERMINATED
          "arbitrary binary string (null padded, count is width), except that null is added with *"
        when STRING_MSB
          "bit string (MSB first)"
        when STRING_LSB
          "bit string (LSB first)"
        when STRING_HEX_HIGH
          "hex string (high nibble first)"
        when STRING_HEX_LOW
          "hex string (low nibble first)"
        when STRING_UU
          "UU-encoded string"
        when STRING_MIME
          "quoted printable, MIME encoding"
        when STRING_BASE64
          "base64 encoded string"
        when STRING_FIXED
          "pointer to a structure (fixed-length string)"
        when STRING_POINTER
          "pointer to a null-terminated string"
        when MOVE
          "move to absolute position"
        when BACK
          "back up a byte"
        when NULL
          "null byte"
        else
          raise
        end
      end
    end

    # The result of parsing a pack template.
    class Format
      # A list of the directives in the template.
      attr_reader :directives

      # The encoding of the template.
      attr_reader :encoding

      # Create a new Format with the given directives and encoding.
      def initialize(directives, encoding)
        @directives = directives
        @encoding = encoding
      end

      # Provide a human-readable description of the format.
      def describe
        source_width = directives.map { |d| d.source.inspect.length }.max
        directive_lines = directives.map do |directive|
          if directive.type == SPACE
            source = directive.source.inspect
          else
            source = directive.source
          end
          # @type var source_width: Integer
          "  #{source.ljust(source_width)}  #{directive.describe}"
        end

        (["Directives:"] + directive_lines + ["Encoding:", "  #{encoding}"]).join("\n")
      end
    end
  end
end
prism-1.5.1/lib/prism/parse_result.rb000066400000000000000000000726011506127434000176150ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

module Prism
  # This represents a source of Ruby code that has been parsed. It is used in
  # conjunction with locations to allow them to resolve line numbers and source
  # ranges.
  class Source
    # Create a new source object with the given source code. This method should
    # be used instead of `new` and it will return either a `Source` or a
    # specialized and more performant `ASCIISource` if no multibyte characters
    # are present in the source code.
    def self.for(source, start_line = 1, offsets = [])
      if source.ascii_only?
        ASCIISource.new(source, start_line, offsets)
      elsif source.encoding == Encoding::BINARY
        source.force_encoding(Encoding::UTF_8)

        if source.valid_encoding?
          new(source, start_line, offsets)
        else
          # This is an extremely niche use case where the file is marked as
          # binary, contains multi-byte characters, and those characters are not
          # valid UTF-8. In this case we'll mark it as binary and fall back to
          # treating everything as a single-byte character. This _may_ cause
          # problems when asking for code units, but it appears to be the
          # cleanest solution at the moment.
          source.force_encoding(Encoding::BINARY)
          ASCIISource.new(source, start_line, offsets)
        end
      else
        new(source, start_line, offsets)
      end
    end

    # The source code that this source object represents.
    attr_reader :source

    # The line number where this source starts.
    attr_reader :start_line

    # The list of newline byte offsets in the source code.
    attr_reader :offsets

    # Create a new source object with the given source code.
    def initialize(source, start_line = 1, offsets = [])
      @source = source
      @start_line = start_line # set after parsing is done
      @offsets = offsets # set after parsing is done
    end

    # Replace the value of start_line with the given value.
    def replace_start_line(start_line)
      @start_line = start_line
    end

    # Replace the value of offsets with the given value.
    def replace_offsets(offsets)
      @offsets.replace(offsets)
    end

    # Returns the encoding of the source code, which is set by parameters to the
    # parser or by the encoding magic comment.
    def encoding
      source.encoding
    end

    # Returns the lines of the source code as an array of strings.
    def lines
      source.lines
    end

    # Perform a byteslice on the source code using the given byte offset and
    # byte length.
    def slice(byte_offset, length)
      source.byteslice(byte_offset, length) or raise
    end

    # Binary search through the offsets to find the line number for the given
    # byte offset.
    def line(byte_offset)
      start_line + find_line(byte_offset)
    end

    # Return the byte offset of the start of the line corresponding to the given
    # byte offset.
    def line_start(byte_offset)
      offsets[find_line(byte_offset)]
    end

    # Returns the byte offset of the end of the line corresponding to the given
    # byte offset.
    def line_end(byte_offset)
      offsets[find_line(byte_offset) + 1] || source.bytesize
    end

    # Return the column number for the given byte offset.
    def column(byte_offset)
      byte_offset - line_start(byte_offset)
    end

    # Return the character offset for the given byte offset.
    def character_offset(byte_offset)
      (source.byteslice(0, byte_offset) or raise).length
    end

    # Return the column number in characters for the given byte offset.
    def character_column(byte_offset)
      character_offset(byte_offset) - character_offset(line_start(byte_offset))
    end

    # Returns the offset from the start of the file for the given byte offset
    # counting in code units for the given encoding.
    #
    # This method is tested with UTF-8, UTF-16, and UTF-32. If there is the
    # concept of code units that differs from the number of characters in other
    # encodings, it is not captured here.
    #
    # We purposefully replace invalid and undefined characters with replacement
    # characters in this conversion. This happens for two reasons. First, it's
    # possible that the given byte offset will not occur on a character
    # boundary. Second, it's possible that the source code will contain a
    # character that has no equivalent in the given encoding.
    def code_units_offset(byte_offset, encoding)
      byteslice = (source.byteslice(0, byte_offset) or raise).encode(encoding, invalid: :replace, undef: :replace)

      if encoding == Encoding::UTF_16LE || encoding == Encoding::UTF_16BE
        byteslice.bytesize / 2
      else
        byteslice.length
      end
    end

    # Generate a cache that targets a specific encoding for calculating code
    # unit offsets.
    def code_units_cache(encoding)
      CodeUnitsCache.new(source, encoding)
    end

    # Returns the column number in code units for the given encoding for the
    # given byte offset.
    def code_units_column(byte_offset, encoding)
      code_units_offset(byte_offset, encoding) - code_units_offset(line_start(byte_offset), encoding)
    end

    # Freeze this object and the objects it contains.
    def deep_freeze
      source.freeze
      offsets.freeze
      freeze
    end

    private

    # Binary search through the offsets to find the line number for the given
    # byte offset.
    def find_line(byte_offset)
      left = 0
      right = offsets.length - 1

      while left <= right
        mid = left + (right - left) / 2
        return mid if (offset = offsets[mid]) == byte_offset

        if offset < byte_offset
          left = mid + 1
        else
          right = mid - 1
        end
      end

      left - 1
    end
  end

  # A cache that can be used to quickly compute code unit offsets from byte
  # offsets. It purposefully provides only a single #[] method to access the
  # cache in order to minimize surface area.
  #
  # Note that there are some known issues here that may or may not be addressed
  # in the future:
  #
  # * The first is that there are issues when the cache computes values that are
  #   not on character boundaries. This can result in subsequent computations
  #   being off by one or more code units.
  # * The second is that this cache is currently unbounded. In theory we could
  #   introduce some kind of LRU cache to limit the number of entries, but this
  #   has not yet been implemented.
  #
  class CodeUnitsCache
    class UTF16Counter # :nodoc:
      def initialize(source, encoding)
        @source = source
        @encoding = encoding
      end

      def count(byte_offset, byte_length)
        @source.byteslice(byte_offset, byte_length).encode(@encoding, invalid: :replace, undef: :replace).bytesize / 2
      end
    end

    class LengthCounter # :nodoc:
      def initialize(source, encoding)
        @source = source
        @encoding = encoding
      end

      def count(byte_offset, byte_length)
        @source.byteslice(byte_offset, byte_length).encode(@encoding, invalid: :replace, undef: :replace).length
      end
    end

    private_constant :UTF16Counter, :LengthCounter

    # Initialize a new cache with the given source and encoding.
    def initialize(source, encoding)
      @source = source
      @counter =
        if encoding == Encoding::UTF_16LE || encoding == Encoding::UTF_16BE
          UTF16Counter.new(source, encoding)
        else
          LengthCounter.new(source, encoding)
        end

      @cache = {} #: Hash[Integer, Integer]
      @offsets = [] #: Array[Integer]
    end

    # Retrieve the code units offset from the given byte offset.
    def [](byte_offset)
      @cache[byte_offset] ||=
        if (index = @offsets.bsearch_index { |offset| offset > byte_offset }).nil?
          @offsets << byte_offset
          @counter.count(0, byte_offset)
        elsif index == 0
          @offsets.unshift(byte_offset)
          @counter.count(0, byte_offset)
        else
          @offsets.insert(index, byte_offset)
          offset = @offsets[index - 1]
          @cache[offset] + @counter.count(offset, byte_offset - offset)
        end
    end
  end

  # Specialized version of Prism::Source for source code that includes ASCII
  # characters only. This class is used to apply performance optimizations that
  # cannot be applied to sources that include multibyte characters.
  #
  # In the extremely rare case that a source includes multi-byte characters but
  # is marked as binary because of a magic encoding comment and it cannot be
  # eagerly converted to UTF-8, this class will be used as well. This is because
  # at that point we will treat everything as single-byte characters.
  class ASCIISource < Source
    # Return the character offset for the given byte offset.
    def character_offset(byte_offset)
      byte_offset
    end

    # Return the column number in characters for the given byte offset.
    def character_column(byte_offset)
      byte_offset - line_start(byte_offset)
    end

    # Returns the offset from the start of the file for the given byte offset
    # counting in code units for the given encoding.
    #
    # This method is tested with UTF-8, UTF-16, and UTF-32. If there is the
    # concept of code units that differs from the number of characters in other
    # encodings, it is not captured here.
    def code_units_offset(byte_offset, encoding)
      byte_offset
    end

    # Returns a cache that is the identity function in order to maintain the
    # same interface. We can do this because code units are always equivalent to
    # byte offsets for ASCII-only sources.
    def code_units_cache(encoding)
      ->(byte_offset) { byte_offset }
    end

    # Specialized version of `code_units_column` that does not depend on
    # `code_units_offset`, which is a more expensive operation. This is
    # essentially the same as `Prism::Source#column`.
    def code_units_column(byte_offset, encoding)
      byte_offset - line_start(byte_offset)
    end
  end

  # This represents a location in the source.
  class Location
    # A Source object that is used to determine more information from the given
    # offset and length.
    attr_reader :source
    protected :source

    # The byte offset from the beginning of the source where this location
    # starts.
    attr_reader :start_offset

    # The length of this location in bytes.
    attr_reader :length

    # Create a new location object with the given source, start byte offset, and
    # byte length.
    def initialize(source, start_offset, length)
      @source = source
      @start_offset = start_offset
      @length = length

      # These are used to store comments that are associated with this location.
      # They are initialized to `nil` to save on memory when there are no
      # comments to be attached and/or the comment-related APIs are not used.
      @leading_comments = nil
      @trailing_comments = nil
    end

    # These are the comments that are associated with this location that exist
    # before the start of this location.
    def leading_comments
      @leading_comments ||= []
    end

    # Attach a comment to the leading comments of this location.
    def leading_comment(comment)
      leading_comments << comment
    end

    # These are the comments that are associated with this location that exist
    # after the end of this location.
    def trailing_comments
      @trailing_comments ||= []
    end

    # Attach a comment to the trailing comments of this location.
    def trailing_comment(comment)
      trailing_comments << comment
    end

    # Returns all comments that are associated with this location (both leading
    # and trailing comments).
    def comments
      [*@leading_comments, *@trailing_comments]
    end

    # Create a new location object with the given options.
    def copy(source: self.source, start_offset: self.start_offset, length: self.length)
      Location.new(source, start_offset, length)
    end

    # Returns a new location that is the result of chopping off the last byte.
    def chop
      copy(length: length == 0 ? length : length - 1)
    end

    # Returns a string representation of this location.
    def inspect
      "#"
    end

    # Returns all of the lines of the source code associated with this location.
    def source_lines
      source.lines
    end

    # The source code that this location represents.
    def slice
      source.slice(start_offset, length)
    end

    # The source code that this location represents starting from the beginning
    # of the line that this location starts on to the end of the line that this
    # location ends on.
    def slice_lines
      line_start = source.line_start(start_offset)
      line_end = source.line_end(end_offset)
      source.slice(line_start, line_end - line_start)
    end

    # The character offset from the beginning of the source where this location
    # starts.
    def start_character_offset
      source.character_offset(start_offset)
    end

    # The offset from the start of the file in code units of the given encoding.
    def start_code_units_offset(encoding = Encoding::UTF_16LE)
      source.code_units_offset(start_offset, encoding)
    end

    # The start offset from the start of the file in code units using the given
    # cache to fetch or calculate the value.
    def cached_start_code_units_offset(cache)
      cache[start_offset]
    end

    # The byte offset from the beginning of the source where this location ends.
    def end_offset
      start_offset + length
    end

    # The character offset from the beginning of the source where this location
    # ends.
    def end_character_offset
      source.character_offset(end_offset)
    end

    # The offset from the start of the file in code units of the given encoding.
    def end_code_units_offset(encoding = Encoding::UTF_16LE)
      source.code_units_offset(end_offset, encoding)
    end

    # The end offset from the start of the file in code units using the given
    # cache to fetch or calculate the value.
    def cached_end_code_units_offset(cache)
      cache[end_offset]
    end

    # The line number where this location starts.
    def start_line
      source.line(start_offset)
    end

    # The content of the line where this location starts before this location.
    def start_line_slice
      offset = source.line_start(start_offset)
      source.slice(offset, start_offset - offset)
    end

    # The line number where this location ends.
    def end_line
      source.line(end_offset)
    end

    # The column number in bytes where this location starts from the start of
    # the line.
    def start_column
      source.column(start_offset)
    end

    # The column number in characters where this location ends from the start of
    # the line.
    def start_character_column
      source.character_column(start_offset)
    end

    # The column number in code units of the given encoding where this location
    # starts from the start of the line.
    def start_code_units_column(encoding = Encoding::UTF_16LE)
      source.code_units_column(start_offset, encoding)
    end

    # The start column in code units using the given cache to fetch or calculate
    # the value.
    def cached_start_code_units_column(cache)
      cache[start_offset] - cache[source.line_start(start_offset)]
    end

    # The column number in bytes where this location ends from the start of the
    # line.
    def end_column
      source.column(end_offset)
    end

    # The column number in characters where this location ends from the start of
    # the line.
    def end_character_column
      source.character_column(end_offset)
    end

    # The column number in code units of the given encoding where this location
    # ends from the start of the line.
    def end_code_units_column(encoding = Encoding::UTF_16LE)
      source.code_units_column(end_offset, encoding)
    end

    # The end column in code units using the given cache to fetch or calculate
    # the value.
    def cached_end_code_units_column(cache)
      cache[end_offset] - cache[source.line_start(end_offset)]
    end

    # Implement the hash pattern matching interface for Location.
    def deconstruct_keys(keys)
      { start_offset: start_offset, end_offset: end_offset }
    end

    # Implement the pretty print interface for Location.
    def pretty_print(q)
      q.text("(#{start_line},#{start_column})-(#{end_line},#{end_column})")
    end

    # Returns true if the given other location is equal to this location.
    def ==(other)
      Location === other &&
        other.start_offset == start_offset &&
        other.end_offset == end_offset
    end

    # Returns a new location that stretches from this location to the given
    # other location. Raises an error if this location is not before the other
    # location or if they don't share the same source.
    def join(other)
      raise "Incompatible sources" if source != other.source
      raise "Incompatible locations" if start_offset > other.start_offset

      Location.new(source, start_offset, other.end_offset - start_offset)
    end

    # Join this location with the first occurrence of the string in the source
    # that occurs after this location on the same line, and return the new
    # location. This will raise an error if the string does not exist.
    def adjoin(string)
      line_suffix = source.slice(end_offset, source.line_end(end_offset) - end_offset)

      line_suffix_index = line_suffix.byteindex(string)
      raise "Could not find #{string}" if line_suffix_index.nil?

      Location.new(source, start_offset, length + line_suffix_index + string.bytesize)
    end
  end

  # This represents a comment that was encountered during parsing. It is the
  # base class for all comment types.
  class Comment
    # The location of this comment in the source.
    attr_reader :location

    # Create a new comment object with the given location.
    def initialize(location)
      @location = location
    end

    # Implement the hash pattern matching interface for Comment.
    def deconstruct_keys(keys)
      { location: location }
    end

    # Returns the content of the comment by slicing it from the source code.
    def slice
      location.slice
    end
  end

  # InlineComment objects are the most common. They correspond to comments in
  # the source file like this one that start with #.
  class InlineComment < Comment
    # Returns true if this comment happens on the same line as other code and
    # false if the comment is by itself.
    def trailing?
      !location.start_line_slice.strip.empty?
    end

    # Returns a string representation of this comment.
    def inspect
      "#"
    end
  end

  # EmbDocComment objects correspond to comments that are surrounded by =begin
  # and =end.
  class EmbDocComment < Comment
    # This can only be true for inline comments.
    def trailing?
      false
    end

    # Returns a string representation of this comment.
    def inspect
      "#"
    end
  end

  # This represents a magic comment that was encountered during parsing.
  class MagicComment
    # A Location object representing the location of the key in the source.
    attr_reader :key_loc

    # A Location object representing the location of the value in the source.
    attr_reader :value_loc

    # Create a new magic comment object with the given key and value locations.
    def initialize(key_loc, value_loc)
      @key_loc = key_loc
      @value_loc = value_loc
    end

    # Returns the key of the magic comment by slicing it from the source code.
    def key
      key_loc.slice
    end

    # Returns the value of the magic comment by slicing it from the source code.
    def value
      value_loc.slice
    end

    # Implement the hash pattern matching interface for MagicComment.
    def deconstruct_keys(keys)
      { key_loc: key_loc, value_loc: value_loc }
    end

    # Returns a string representation of this magic comment.
    def inspect
      "#"
    end
  end

  # This represents an error that was encountered during parsing.
  class ParseError
    # The type of error. This is an _internal_ symbol that is used for
    # communicating with translation layers. It is not meant to be public API.
    attr_reader :type

    # The message associated with this error.
    attr_reader :message

    # A Location object representing the location of this error in the source.
    attr_reader :location

    # The level of this error.
    attr_reader :level

    # Create a new error object with the given message and location.
    def initialize(type, message, location, level)
      @type = type
      @message = message
      @location = location
      @level = level
    end

    # Implement the hash pattern matching interface for ParseError.
    def deconstruct_keys(keys)
      { type: type, message: message, location: location, level: level }
    end

    # Returns a string representation of this error.
    def inspect
      "#"
    end
  end

  # This represents a warning that was encountered during parsing.
  class ParseWarning
    # The type of warning. This is an _internal_ symbol that is used for
    # communicating with translation layers. It is not meant to be public API.
    attr_reader :type

    # The message associated with this warning.
    attr_reader :message

    # A Location object representing the location of this warning in the source.
    attr_reader :location

    # The level of this warning.
    attr_reader :level

    # Create a new warning object with the given message and location.
    def initialize(type, message, location, level)
      @type = type
      @message = message
      @location = location
      @level = level
    end

    # Implement the hash pattern matching interface for ParseWarning.
    def deconstruct_keys(keys)
      { type: type, message: message, location: location, level: level }
    end

    # Returns a string representation of this warning.
    def inspect
      "#"
    end
  end

  # This represents the result of a call to ::parse or ::parse_file. It contains
  # the requested structure, any comments that were encounters, and any errors
  # that were encountered.
  class Result
    # The list of comments that were encountered during parsing.
    attr_reader :comments

    # The list of magic comments that were encountered during parsing.
    attr_reader :magic_comments

    # An optional location that represents the location of the __END__ marker
    # and the rest of the content of the file. This content is loaded into the
    # DATA constant when the file being parsed is the main file being executed.
    attr_reader :data_loc

    # The list of errors that were generated during parsing.
    attr_reader :errors

    # The list of warnings that were generated during parsing.
    attr_reader :warnings

    # A Source instance that represents the source code that was parsed.
    attr_reader :source

    # Create a new result object with the given values.
    def initialize(comments, magic_comments, data_loc, errors, warnings, source)
      @comments = comments
      @magic_comments = magic_comments
      @data_loc = data_loc
      @errors = errors
      @warnings = warnings
      @source = source
    end

    # Implement the hash pattern matching interface for Result.
    def deconstruct_keys(keys)
      { comments: comments, magic_comments: magic_comments, data_loc: data_loc, errors: errors, warnings: warnings }
    end

    # Returns the encoding of the source code that was parsed.
    def encoding
      source.encoding
    end

    # Returns true if there were no errors during parsing and false if there
    # were.
    def success?
      errors.empty?
    end

    # Returns true if there were errors during parsing and false if there were
    # not.
    def failure?
      !success?
    end

    # Create a code units cache for the given encoding.
    def code_units_cache(encoding)
      source.code_units_cache(encoding)
    end
  end

  # This is a result specific to the `parse` and `parse_file` methods.
  class ParseResult < Result
    autoload :Comments, "prism/parse_result/comments"
    autoload :Errors, "prism/parse_result/errors"
    autoload :Newlines, "prism/parse_result/newlines"

    private_constant :Comments
    private_constant :Errors
    private_constant :Newlines

    # The syntax tree that was parsed from the source code.
    attr_reader :value

    # Create a new parse result object with the given values.
    def initialize(value, comments, magic_comments, data_loc, errors, warnings, source)
      @value = value
      super(comments, magic_comments, data_loc, errors, warnings, source)
    end

    # Implement the hash pattern matching interface for ParseResult.
    def deconstruct_keys(keys)
      super.merge!(value: value)
    end

    # Attach the list of comments to their respective locations in the tree.
    def attach_comments!
      Comments.new(self).attach! # steep:ignore
    end

    # Walk the tree and mark nodes that are on a new line, loosely emulating
    # the behavior of CRuby's `:line` tracepoint event.
    def mark_newlines!
      value.accept(Newlines.new(source.offsets.size)) # steep:ignore
    end

    # Returns a string representation of the syntax tree with the errors
    # displayed inline.
    def errors_format
      Errors.new(self).format
    end
  end

  # This is a result specific to the `lex` and `lex_file` methods.
  class LexResult < Result
    # The list of tokens that were parsed from the source code.
    attr_reader :value

    # Create a new lex result object with the given values.
    def initialize(value, comments, magic_comments, data_loc, errors, warnings, source)
      @value = value
      super(comments, magic_comments, data_loc, errors, warnings, source)
    end

    # Implement the hash pattern matching interface for LexResult.
    def deconstruct_keys(keys)
      super.merge!(value: value)
    end
  end

  # This is a result specific to the `parse_lex` and `parse_lex_file` methods.
  class ParseLexResult < Result
    # A tuple of the syntax tree and the list of tokens that were parsed from
    # the source code.
    attr_reader :value

    # Create a new parse lex result object with the given values.
    def initialize(value, comments, magic_comments, data_loc, errors, warnings, source)
      @value = value
      super(comments, magic_comments, data_loc, errors, warnings, source)
    end

    # Implement the hash pattern matching interface for ParseLexResult.
    def deconstruct_keys(keys)
      super.merge!(value: value)
    end
  end

  # This represents a token from the Ruby source.
  class Token
    # The Source object that represents the source this token came from.
    attr_reader :source
    private :source

    # The type of token that this token is.
    attr_reader :type

    # A byteslice of the source that this token represents.
    attr_reader :value

    # Create a new token object with the given type, value, and location.
    def initialize(source, type, value, location)
      @source = source
      @type = type
      @value = value
      @location = location
    end

    # Implement the hash pattern matching interface for Token.
    def deconstruct_keys(keys)
      { type: type, value: value, location: location }
    end

    # A Location object representing the location of this token in the source.
    def location
      location = @location
      return location if location.is_a?(Location)
      @location = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

    # Implement the pretty print interface for Token.
    def pretty_print(q)
      q.group do
        q.text(type.to_s)
        self.location.pretty_print(q)
        q.text("(")
        q.nest(2) do
          q.breakable("")
          q.pp(value)
        end
        q.breakable("")
        q.text(")")
      end
    end

    # Returns true if the given other token is equal to this token.
    def ==(other)
      Token === other &&
        other.type == type &&
        other.value == value
    end

    # Returns a string representation of this token.
    def inspect
      location
      super
    end

    # Freeze this object and the objects it contains.
    def deep_freeze
      value.freeze
      location.freeze
      freeze
    end
  end

  # This object is passed to the various Prism.* methods that accept the
  # `scopes` option as an element of the list. It defines both the local
  # variables visible at that scope as well as the forwarding parameters
  # available at that scope.
  class Scope
    # The list of local variables that are defined in this scope. This should be
    # defined as an array of symbols.
    attr_reader :locals

    # The list of local variables that are forwarded to the next scope. This
    # should by defined as an array of symbols containing the specific values of
    # :*, :**, :&, or :"...".
    attr_reader :forwarding

    # Create a new scope object with the given locals and forwarding.
    def initialize(locals, forwarding)
      @locals = locals
      @forwarding = forwarding
    end
  end

  # Create a new scope with the given locals and forwarding options that is
  # suitable for passing into one of the Prism.* methods that accepts the
  # `scopes` option.
  def self.scope(locals: [], forwarding: [])
    Scope.new(locals, forwarding)
  end
end
prism-1.5.1/lib/prism/parse_result/000077500000000000000000000000001506127434000172625ustar00rootroot00000000000000prism-1.5.1/lib/prism/parse_result/comments.rb000066400000000000000000000137261506127434000214450ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

module Prism
  class ParseResult < Result
    # When we've parsed the source, we have both the syntax tree and the list of
    # comments that we found in the source. This class is responsible for
    # walking the tree and finding the nearest location to attach each comment.
    #
    # It does this by first finding the nearest locations to each comment.
    # Locations can either come from nodes directly or from location fields on
    # nodes. For example, a `ClassNode` has an overall location encompassing the
    # entire class, but it also has a location for the `class` keyword.
    #
    # Once the nearest locations are found, it determines which one to attach
    # to. If it's a trailing comment (a comment on the same line as other source
    # code), it will favor attaching to the nearest location that occurs before
    # the comment. Otherwise it will favor attaching to the nearest location
    # that is after the comment.
    class Comments
      # A target for attaching comments that is based on a specific node's
      # location.
      class NodeTarget # :nodoc:
        attr_reader :node

        def initialize(node)
          @node = node
        end

        def start_offset
          node.start_offset
        end

        def end_offset
          node.end_offset
        end

        def encloses?(comment)
          start_offset <= comment.location.start_offset &&
            comment.location.end_offset <= end_offset
        end

        def leading_comment(comment)
          node.location.leading_comment(comment)
        end

        def trailing_comment(comment)
          node.location.trailing_comment(comment)
        end
      end

      # A target for attaching comments that is based on a location field on a
      # node. For example, the `end` token of a ClassNode.
      class LocationTarget # :nodoc:
        attr_reader :location

        def initialize(location)
          @location = location
        end

        def start_offset
          location.start_offset
        end

        def end_offset
          location.end_offset
        end

        def encloses?(comment)
          false
        end

        def leading_comment(comment)
          location.leading_comment(comment)
        end

        def trailing_comment(comment)
          location.trailing_comment(comment)
        end
      end

      # The parse result that we are attaching comments to.
      attr_reader :parse_result

      # Create a new Comments object that will attach comments to the given
      # parse result.
      def initialize(parse_result)
        @parse_result = parse_result
      end

      # Attach the comments to their respective locations in the tree by
      # mutating the parse result.
      def attach!
        parse_result.comments.each do |comment|
          preceding, enclosing, following = nearest_targets(parse_result.value, comment)

          if comment.trailing?
            if preceding
              preceding.trailing_comment(comment)
            else
              (following || enclosing || NodeTarget.new(parse_result.value)).leading_comment(comment)
            end
          else
            # If a comment exists on its own line, prefer a leading comment.
            if following
              following.leading_comment(comment)
            elsif preceding
              preceding.trailing_comment(comment)
            else
              (enclosing || NodeTarget.new(parse_result.value)).leading_comment(comment)
            end
          end
        end
      end

      private

      # Responsible for finding the nearest targets to the given comment within
      # the context of the given encapsulating node.
      def nearest_targets(node, comment)
        comment_start = comment.location.start_offset
        comment_end = comment.location.end_offset

        targets = [] #: Array[_Target]
        node.comment_targets.map do |value|
          case value
          when StatementsNode
            targets.concat(value.body.map { |node| NodeTarget.new(node) })
          when Node
            targets << NodeTarget.new(value)
          when Location
            targets << LocationTarget.new(value)
          end
        end

        targets.sort_by!(&:start_offset)
        preceding = nil #: _Target?
        following = nil #: _Target?

        left = 0
        right = targets.length

        # This is a custom binary search that finds the nearest nodes to the
        # given comment. When it finds a node that completely encapsulates the
        # comment, it recurses downward into the tree.
        while left < right
          middle = (left + right) / 2
          target = targets[middle]

          target_start = target.start_offset
          target_end = target.end_offset

          if target.encloses?(comment)
            # @type var target: NodeTarget
            # The comment is completely contained by this target. Abandon the
            # binary search at this level.
            return nearest_targets(target.node, comment)
          end

          if target_end <= comment_start
            # This target falls completely before the comment. Because we will
            # never consider this target or any targets before it again, this
            # target must be the closest preceding target we have encountered so
            # far.
            preceding = target
            left = middle + 1
            next
          end

          if comment_end <= target_start
            # This target falls completely after the comment. Because we will
            # never consider this target or any targets after it again, this
            # target must be the closest following target we have encountered so
            # far.
            following = target
            right = middle
            next
          end

          # This should only happen if there is a bug in this parser.
          raise "Comment location overlaps with a target location"
        end

        [preceding, NodeTarget.new(node), following]
      end
    end
  end
end
prism-1.5.1/lib/prism/parse_result/errors.rb000066400000000000000000000037641506127434000211350ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

require "stringio"

module Prism
  class ParseResult < Result
    # An object to represent the set of errors on a parse result. This object
    # can be used to format the errors in a human-readable way.
    class Errors
      # The parse result that contains the errors.
      attr_reader :parse_result

      # Initialize a new set of errors from the given parse result.
      def initialize(parse_result)
        @parse_result = parse_result
      end

      # Formats the errors in a human-readable way and return them as a string.
      def format
        error_lines = {} #: Hash[Integer, Array[ParseError]]
        parse_result.errors.each do |error|
          location = error.location
          (location.start_line..location.end_line).each do |line|
            error_lines[line] ||= []
            error_lines[line] << error
          end
        end

        source_lines = parse_result.source.source.lines
        source_lines << "" if error_lines.key?(source_lines.size + 1)

        io = StringIO.new
        source_lines.each.with_index(1) do |line, line_number|
          io.puts(line)

          (error_lines.delete(line_number) || []).each do |error|
            location = error.location

            case line_number
            when location.start_line
              io.print(" " * location.start_column + "^")

              if location.start_line == location.end_line
                if location.start_column != location.end_column
                  io.print("~" * (location.end_column - location.start_column - 1))
                end

                io.puts(" " + error.message)
              else
                io.puts("~" * (line.bytesize - location.start_column))
              end
            when location.end_line
              io.puts("~" * location.end_column + " " + error.message)
            else
              io.puts("~" * line.bytesize)
            end
          end
        end

        io.puts
        io.string
      end
    end
  end
end
prism-1.5.1/lib/prism/parse_result/newlines.rb000066400000000000000000000077171506127434000214470ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

module Prism
  class ParseResult < Result
    # The :line tracepoint event gets fired whenever the Ruby VM encounters an
    # expression on a new line. The types of expressions that can trigger this
    # event are:
    #
    # * if statements
    # * unless statements
    # * nodes that are children of statements lists
    #
    # In order to keep track of the newlines, we have a list of offsets that
    # come back from the parser. We assign these offsets to the first nodes that
    # we find in the tree that are on those lines.
    #
    # Note that the logic in this file should be kept in sync with the Java
    # MarkNewlinesVisitor, since that visitor is responsible for marking the
    # newlines for JRuby/TruffleRuby.
    #
    # This file is autoloaded only when `mark_newlines!` is called, so the
    # re-opening of the various nodes in this file will only be performed in
    # that case. We do that to avoid storing the extra `@newline` instance
    # variable on every node if we don't need it.
    class Newlines < Visitor
      # Create a new Newlines visitor with the given newline offsets.
      def initialize(lines)
        # @type var lines: Integer
        @lines = Array.new(1 + lines, false)
      end

      # Permit block/lambda nodes to mark newlines within themselves.
      def visit_block_node(node)
        old_lines = @lines
        @lines = Array.new(old_lines.size, false)

        begin
          super(node)
        ensure
          @lines = old_lines
        end
      end

      alias_method :visit_lambda_node, :visit_block_node

      # Mark if/unless nodes as newlines.
      def visit_if_node(node)
        node.newline_flag!(@lines)
        super(node)
      end

      alias_method :visit_unless_node, :visit_if_node

      # Permit statements lists to mark newlines within themselves.
      def visit_statements_node(node)
        node.body.each do |child|
          child.newline_flag!(@lines)
        end
        super(node)
      end
    end
  end

  class Node
    def newline_flag? # :nodoc:
      !!defined?(@newline_flag)
    end

    def newline_flag!(lines) # :nodoc:
      line = location.start_line
      unless lines[line]
        lines[line] = true
        @newline_flag = true
      end
    end
  end

  class BeginNode < Node
    def newline_flag!(lines) # :nodoc:
      # Never mark BeginNode with a newline flag, mark children instead.
    end
  end

  class ParenthesesNode < Node
    def newline_flag!(lines) # :nodoc:
      # Never mark ParenthesesNode with a newline flag, mark children instead.
    end
  end

  class IfNode < Node
    def newline_flag!(lines) # :nodoc:
      predicate.newline_flag!(lines)
    end
  end

  class UnlessNode < Node
    def newline_flag!(lines) # :nodoc:
      predicate.newline_flag!(lines)
    end
  end

  class UntilNode < Node
    def newline_flag!(lines) # :nodoc:
      predicate.newline_flag!(lines)
    end
  end

  class WhileNode < Node
    def newline_flag!(lines) # :nodoc:
      predicate.newline_flag!(lines)
    end
  end

  class RescueModifierNode < Node
    def newline_flag!(lines) # :nodoc:
      expression.newline_flag!(lines)
    end
  end

  class InterpolatedMatchLastLineNode < Node
    def newline_flag!(lines) # :nodoc:
      first = parts.first
      first.newline_flag!(lines) if first
    end
  end

  class InterpolatedRegularExpressionNode < Node
    def newline_flag!(lines) # :nodoc:
      first = parts.first
      first.newline_flag!(lines) if first
    end
  end

  class InterpolatedStringNode < Node
    def newline_flag!(lines) # :nodoc:
      first = parts.first
      first.newline_flag!(lines) if first
    end
  end

  class InterpolatedSymbolNode < Node
    def newline_flag!(lines) # :nodoc:
      first = parts.first
      first.newline_flag!(lines) if first
    end
  end

  class InterpolatedXStringNode < Node
    def newline_flag!(lines) # :nodoc:
      first = parts.first
      first.newline_flag!(lines) if first
    end
  end
end
prism-1.5.1/lib/prism/pattern.rb000066400000000000000000000202431506127434000165550ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

module Prism
  # A pattern is an object that wraps a Ruby pattern matching expression. The
  # expression would normally be passed to an `in` clause within a `case`
  # expression or a rightward assignment expression. For example, in the
  # following snippet:
  #
  #     case node
  #     in ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]
  #     end
  #
  # the pattern is the ConstantPathNode[...] expression.
  #
  # The pattern gets compiled into an object that responds to #call by running
  # the #compile method. This method itself will run back through Prism to
  # parse the expression into a tree, then walk the tree to generate the
  # necessary callable objects. For example, if you wanted to compile the
  # expression above into a callable, you would:
  #
  #     callable = Prism::Pattern.new("ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]").compile
  #     callable.call(node)
  #
  # The callable object returned by #compile is guaranteed to respond to #call
  # with a single argument, which is the node to match against. It also is
  # guaranteed to respond to #===, which means it itself can be used in a `case`
  # expression, as in:
  #
  #     case node
  #     when callable
  #     end
  #
  # If the query given to the initializer cannot be compiled into a valid
  # matcher (either because of a syntax error or because it is using syntax we
  # do not yet support) then a Prism::Pattern::CompilationError will be
  # raised.
  class Pattern
    # Raised when the query given to a pattern is either invalid Ruby syntax or
    # is using syntax that we don't yet support.
    class CompilationError < StandardError
      # Create a new CompilationError with the given representation of the node
      # that caused the error.
      def initialize(repr)
        super(<<~ERROR)
          prism was unable to compile the pattern you provided into a usable
          expression. It failed on to understand the node represented by:

          #{repr}

          Note that not all syntax supported by Ruby's pattern matching syntax
          is also supported by prism's patterns. If you're using some syntax
          that you believe should be supported, please open an issue on
          GitHub at https://github.com/ruby/prism/issues/new.
        ERROR
      end
    end

    # The query that this pattern was initialized with.
    attr_reader :query

    # Create a new pattern with the given query. The query should be a string
    # containing a Ruby pattern matching expression.
    def initialize(query)
      @query = query
      @compiled = nil
    end

    # Compile the query into a callable object that can be used to match against
    # nodes.
    def compile
      result = Prism.parse("case nil\nin #{query}\nend")

      case_match_node = result.value.statements.body.last
      raise CompilationError, case_match_node.inspect unless case_match_node.is_a?(CaseMatchNode)

      in_node = case_match_node.conditions.last
      raise CompilationError, in_node.inspect unless in_node.is_a?(InNode)

      compile_node(in_node.pattern)
    end

    # Scan the given node and all of its children for nodes that match the
    # pattern. If a block is given, it will be called with each node that
    # matches the pattern. If no block is given, an enumerator will be returned
    # that will yield each node that matches the pattern.
    def scan(root)
      return to_enum(:scan, root) unless block_given?

      @compiled ||= compile
      queue = [root]

      while (node = queue.shift)
        yield node if @compiled.call(node) # steep:ignore
        queue.concat(node.compact_child_nodes)
      end
    end

    private

    # Shortcut for combining two procs into one that returns true if both return
    # true.
    def combine_and(left, right)
      ->(other) { left.call(other) && right.call(other) }
    end

    # Shortcut for combining two procs into one that returns true if either
    # returns true.
    def combine_or(left, right)
      ->(other) { left.call(other) || right.call(other) }
    end

    # Raise an error because the given node is not supported.
    def compile_error(node)
      raise CompilationError, node.inspect
    end

    # in [foo, bar, baz]
    def compile_array_pattern_node(node)
      compile_error(node) if !node.rest.nil? || node.posts.any?

      constant = node.constant
      compiled_constant = compile_node(constant) if constant

      preprocessed = node.requireds.map { |required| compile_node(required) }

      compiled_requireds = ->(other) do
        deconstructed = other.deconstruct

        deconstructed.length == preprocessed.length &&
          preprocessed
            .zip(deconstructed)
            .all? { |(matcher, value)| matcher.call(value) }
      end

      if compiled_constant
        combine_and(compiled_constant, compiled_requireds)
      else
        compiled_requireds
      end
    end

    # in foo | bar
    def compile_alternation_pattern_node(node)
      combine_or(compile_node(node.left), compile_node(node.right))
    end

    # in Prism::ConstantReadNode
    def compile_constant_path_node(node)
      parent = node.parent

      if parent.is_a?(ConstantReadNode) && parent.slice == "Prism"
        name = node.name
        raise CompilationError, node.inspect if name.nil?

        compile_constant_name(node, name)
      else
        compile_error(node)
      end
    end

    # in ConstantReadNode
    # in String
    def compile_constant_read_node(node)
      compile_constant_name(node, node.name)
    end

    # Compile a name associated with a constant.
    def compile_constant_name(node, name)
      if Prism.const_defined?(name, false)
        clazz = Prism.const_get(name)

        ->(other) { clazz === other }
      elsif Object.const_defined?(name, false)
        clazz = Object.const_get(name)

        ->(other) { clazz === other }
      else
        compile_error(node)
      end
    end

    # in InstanceVariableReadNode[name: Symbol]
    # in { name: Symbol }
    def compile_hash_pattern_node(node)
      compile_error(node) if node.rest
      compiled_constant = compile_node(node.constant) if node.constant

      preprocessed =
        node.elements.to_h do |element|
          key = element.key
          if key.is_a?(SymbolNode)
            [key.unescaped.to_sym, compile_node(element.value)]
          else
            raise CompilationError, element.inspect
          end
        end

      compiled_keywords = ->(other) do
        deconstructed = other.deconstruct_keys(preprocessed.keys)

        preprocessed.all? do |keyword, matcher|
          deconstructed.key?(keyword) && matcher.call(deconstructed[keyword])
        end
      end

      if compiled_constant
        combine_and(compiled_constant, compiled_keywords)
      else
        compiled_keywords
      end
    end

    # in nil
    def compile_nil_node(node)
      ->(attribute) { attribute.nil? }
    end

    # in /foo/
    def compile_regular_expression_node(node)
      regexp = Regexp.new(node.unescaped, node.closing[1..])

      ->(attribute) { regexp === attribute }
    end

    # in ""
    # in "foo"
    def compile_string_node(node)
      string = node.unescaped

      ->(attribute) { string === attribute }
    end

    # in :+
    # in :foo
    def compile_symbol_node(node)
      symbol = node.unescaped.to_sym

      ->(attribute) { symbol === attribute }
    end

    # Compile any kind of node. Dispatch out to the individual compilation
    # methods based on the type of node.
    def compile_node(node)
      case node
      when AlternationPatternNode
        compile_alternation_pattern_node(node)
      when ArrayPatternNode
        compile_array_pattern_node(node)
      when ConstantPathNode
        compile_constant_path_node(node)
      when ConstantReadNode
        compile_constant_read_node(node)
      when HashPatternNode
        compile_hash_pattern_node(node)
      when NilNode
        compile_nil_node(node)
      when RegularExpressionNode
        compile_regular_expression_node(node)
      when StringNode
        compile_string_node(node)
      when SymbolNode
        compile_symbol_node(node)
      else
        compile_error(node)
      end
    end
  end
end
prism-1.5.1/lib/prism/polyfill/000077500000000000000000000000001506127434000164045ustar00rootroot00000000000000prism-1.5.1/lib/prism/polyfill/append_as_bytes.rb000066400000000000000000000005631506127434000220750ustar00rootroot00000000000000# frozen_string_literal: true

# Polyfill for String#append_as_bytes, which didn't exist until Ruby 3.4.
if !("".respond_to?(:append_as_bytes))
  String.include(
    Module.new {
      def append_as_bytes(*args)
        args.each do |arg|
          arg = Integer === arg ? [arg].pack("C") : arg.b
          self.<<(arg) # steep:ignore
        end
      end
    }
  )
end
prism-1.5.1/lib/prism/polyfill/byteindex.rb000066400000000000000000000005041506127434000207230ustar00rootroot00000000000000# frozen_string_literal: true

# Polyfill for String#byteindex, which didn't exist until Ruby 3.2.
if !("".respond_to?(:byteindex))
  String.include(
    Module.new {
      def byteindex(needle, offset = 0)
        charindex = index(needle, offset)
        slice(0...charindex).bytesize if charindex
      end
    }
  )
end
prism-1.5.1/lib/prism/polyfill/scan_byte.rb000066400000000000000000000004601506127434000207000ustar00rootroot00000000000000# frozen_string_literal: true

require "strscan"

# Polyfill for StringScanner#scan_byte, which didn't exist until Ruby 3.4.
if !(StringScanner.instance_methods.include?(:scan_byte))
  StringScanner.include(
    Module.new {
      def scan_byte # :nodoc:
        get_byte&.b&.ord
      end
    }
  )
end
prism-1.5.1/lib/prism/polyfill/unpack1.rb000066400000000000000000000010301506127434000202650ustar00rootroot00000000000000# frozen_string_literal: true

# Polyfill for String#unpack1 with the offset parameter. Not all Ruby engines
# have Method#parameters implemented, so we check the arity instead if
# necessary.
if (unpack1 = String.instance_method(:unpack1)).respond_to?(:parameters) ? unpack1.parameters.none? { |_, name| name == :offset } : (unpack1.arity == 1)
  String.prepend(
    Module.new {
      def unpack1(format, offset: 0) # :nodoc:
        offset == 0 ? super(format) : self[offset..].unpack1(format) # steep:ignore
      end
    }
  )
end
prism-1.5.1/lib/prism/polyfill/warn.rb000066400000000000000000000017751506127434000177120ustar00rootroot00000000000000# frozen_string_literal: true

# Polyfill for Kernel#warn with the category parameter. Not all Ruby engines
# have Method#parameters implemented, so we check the arity instead if
# necessary.
if (method = Kernel.instance_method(:warn)).respond_to?(:parameters) ? method.parameters.none? { |_, name| name == :category } : (method.arity == -1)
  Kernel.prepend(
    Module.new {
      def warn(*msgs, uplevel: nil, category: nil) # :nodoc:
        uplevel =
          case uplevel
          when nil
            1
          when Integer
            uplevel + 1
          else
            uplevel.to_int + 1
          end

        super(*msgs, uplevel: uplevel)
      end
    }
  )

  Object.prepend(
    Module.new {
      def warn(*msgs, uplevel: nil, category: nil) # :nodoc:
        uplevel =
          case uplevel
          when nil
            1
          when Integer
            uplevel + 1
          else
            uplevel.to_int + 1
          end

        super(*msgs, uplevel: uplevel)
      end
    }
  )
end
prism-1.5.1/lib/prism/relocation.rb000066400000000000000000000361721506127434000172470ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

module Prism
  # Prism parses deterministically for the same input. This provides a nice
  # property that is exposed through the #node_id API on nodes. Effectively this
  # means that for the same input, these values will remain consistent every
  # time the source is parsed. This means we can reparse the source same with a
  # #node_id value and find the exact same node again.
  #
  # The Relocation module provides an API around this property. It allows you to
  # "save" nodes and locations using a minimal amount of memory (just the
  # node_id and a field identifier) and then reify them later.
  module Relocation
    # An entry in a repository that will lazily reify its values when they are
    # first accessed.
    class Entry
      # Raised if a value that could potentially be on an entry is missing
      # because it was either not configured on the repository or it has not yet
      # been fetched.
      class MissingValueError < StandardError
      end

      # Initialize a new entry with the given repository.
      def initialize(repository)
        @repository = repository
        @values = nil
      end

      # Fetch the filepath of the value.
      def filepath
        fetch_value(:filepath)
      end

      # Fetch the start line of the value.
      def start_line
        fetch_value(:start_line)
      end

      # Fetch the end line of the value.
      def end_line
        fetch_value(:end_line)
      end

      # Fetch the start byte offset of the value.
      def start_offset
        fetch_value(:start_offset)
      end

      # Fetch the end byte offset of the value.
      def end_offset
        fetch_value(:end_offset)
      end

      # Fetch the start character offset of the value.
      def start_character_offset
        fetch_value(:start_character_offset)
      end

      # Fetch the end character offset of the value.
      def end_character_offset
        fetch_value(:end_character_offset)
      end

      # Fetch the start code units offset of the value, for the encoding that
      # was configured on the repository.
      def start_code_units_offset
        fetch_value(:start_code_units_offset)
      end

      # Fetch the end code units offset of the value, for the encoding that was
      # configured on the repository.
      def end_code_units_offset
        fetch_value(:end_code_units_offset)
      end

      # Fetch the start byte column of the value.
      def start_column
        fetch_value(:start_column)
      end

      # Fetch the end byte column of the value.
      def end_column
        fetch_value(:end_column)
      end

      # Fetch the start character column of the value.
      def start_character_column
        fetch_value(:start_character_column)
      end

      # Fetch the end character column of the value.
      def end_character_column
        fetch_value(:end_character_column)
      end

      # Fetch the start code units column of the value, for the encoding that
      # was configured on the repository.
      def start_code_units_column
        fetch_value(:start_code_units_column)
      end

      # Fetch the end code units column of the value, for the encoding that was
      # configured on the repository.
      def end_code_units_column
        fetch_value(:end_code_units_column)
      end

      # Fetch the leading comments of the value.
      def leading_comments
        fetch_value(:leading_comments)
      end

      # Fetch the trailing comments of the value.
      def trailing_comments
        fetch_value(:trailing_comments)
      end

      # Fetch the leading and trailing comments of the value.
      def comments
        leading_comments.concat(trailing_comments)
      end

      # Reify the values on this entry with the given values. This is an
      # internal-only API that is called from the repository when it is time to
      # reify the values.
      def reify!(values) # :nodoc:
        @repository = nil
        @values = values
      end

      private

      # Fetch a value from the entry, raising an error if it is missing.
      def fetch_value(name)
        values.fetch(name) do
          raise MissingValueError, "No value for #{name}, make sure the " \
            "repository has been properly configured"
        end
      end

      # Return the values from the repository, reifying them if necessary.
      def values
        @values || (@repository.reify!; @values)
      end
    end

    # Represents the source of a repository that will be reparsed.
    class Source
      # The value that will need to be reparsed.
      attr_reader :value

      # Initialize the source with the given value.
      def initialize(value)
        @value = value
      end

      # Reparse the value and return the parse result.
      def result
        raise NotImplementedError, "Subclasses must implement #result"
      end

      # Create a code units cache for the given encoding.
      def code_units_cache(encoding)
        result.code_units_cache(encoding)
      end
    end

    # A source that is represented by a file path.
    class SourceFilepath < Source
      # Reparse the file and return the parse result.
      def result
        Prism.parse_file(value)
      end
    end

    # A source that is represented by a string.
    class SourceString < Source
      # Reparse the string and return the parse result.
      def result
        Prism.parse(value)
      end
    end

    # A field that represents the file path.
    class FilepathField
      # The file path that this field represents.
      attr_reader :value

      # Initialize a new field with the given file path.
      def initialize(value)
        @value = value
      end

      # Fetch the file path.
      def fields(_value)
        { filepath: value }
      end
    end

    # A field representing the start and end lines.
    class LinesField
      # Fetches the start and end line of a value.
      def fields(value)
        { start_line: value.start_line, end_line: value.end_line }
      end
    end

    # A field representing the start and end byte offsets.
    class OffsetsField
      # Fetches the start and end byte offset of a value.
      def fields(value)
        { start_offset: value.start_offset, end_offset: value.end_offset }
      end
    end

    # A field representing the start and end character offsets.
    class CharacterOffsetsField
      # Fetches the start and end character offset of a value.
      def fields(value)
        {
          start_character_offset: value.start_character_offset,
          end_character_offset: value.end_character_offset
        }
      end
    end

    # A field representing the start and end code unit offsets.
    class CodeUnitOffsetsField
      # A pointer to the repository object that is used for lazily creating a
      # code units cache.
      attr_reader :repository

      # The associated encoding for the code units.
      attr_reader :encoding

      # Initialize a new field with the associated repository and encoding.
      def initialize(repository, encoding)
        @repository = repository
        @encoding = encoding
        @cache = nil
      end

      # Fetches the start and end code units offset of a value for a particular
      # encoding.
      def fields(value)
        {
          start_code_units_offset: value.cached_start_code_units_offset(cache),
          end_code_units_offset: value.cached_end_code_units_offset(cache)
        }
      end

      private

      # Lazily create a code units cache for the associated encoding.
      def cache
        @cache ||= repository.code_units_cache(encoding)
      end
    end

    # A field representing the start and end byte columns.
    class ColumnsField
      # Fetches the start and end byte column of a value.
      def fields(value)
        { start_column: value.start_column, end_column: value.end_column }
      end
    end

    # A field representing the start and end character columns.
    class CharacterColumnsField
      # Fetches the start and end character column of a value.
      def fields(value)
        {
          start_character_column: value.start_character_column,
          end_character_column: value.end_character_column
        }
      end
    end

    # A field representing the start and end code unit columns for a specific
    # encoding.
    class CodeUnitColumnsField
      # The repository object that is used for lazily creating a code units
      # cache.
      attr_reader :repository

      # The associated encoding for the code units.
      attr_reader :encoding

      # Initialize a new field with the associated repository and encoding.
      def initialize(repository, encoding)
        @repository = repository
        @encoding = encoding
        @cache = nil
      end

      # Fetches the start and end code units column of a value for a particular
      # encoding.
      def fields(value)
        {
          start_code_units_column: value.cached_start_code_units_column(cache),
          end_code_units_column: value.cached_end_code_units_column(cache)
        }
      end

      private

      # Lazily create a code units cache for the associated encoding.
      def cache
        @cache ||= repository.code_units_cache(encoding)
      end
    end

    # An abstract field used as the parent class of the two comments fields.
    class CommentsField
      # An object that represents a slice of a comment.
      class Comment
        # The slice of the comment.
        attr_reader :slice

        # Initialize a new comment with the given slice.
        def initialize(slice)
          @slice = slice
        end
      end

      private

      # Create comment objects from the given values.
      def comments(values)
        values.map { |value| Comment.new(value.slice) }
      end
    end

    # A field representing the leading comments.
    class LeadingCommentsField < CommentsField
      # Fetches the leading comments of a value.
      def fields(value)
        { leading_comments: comments(value.leading_comments) }
      end
    end

    # A field representing the trailing comments.
    class TrailingCommentsField < CommentsField
      # Fetches the trailing comments of a value.
      def fields(value)
        { trailing_comments: comments(value.trailing_comments) }
      end
    end

    # A repository is a configured collection of fields and a set of entries
    # that knows how to reparse a source and reify the values.
    class Repository
      # Raised when multiple fields of the same type are configured on the same
      # repository.
      class ConfigurationError < StandardError
      end

      # The source associated with this repository. This will be either a
      # SourceFilepath (the most common use case) or a SourceString.
      attr_reader :source

      # The fields that have been configured on this repository.
      attr_reader :fields

      # The entries that have been saved on this repository.
      attr_reader :entries

      # Initialize a new repository with the given source.
      def initialize(source)
        @source = source
        @fields = {}
        @entries = Hash.new { |hash, node_id| hash[node_id] = {} }
      end

      # Create a code units cache for the given encoding from the source.
      def code_units_cache(encoding)
        source.code_units_cache(encoding)
      end

      # Configure the filepath field for this repository and return self.
      def filepath
        raise ConfigurationError, "Can only specify filepath for a filepath source" unless source.is_a?(SourceFilepath)
        field(:filepath, FilepathField.new(source.value))
      end

      # Configure the lines field for this repository and return self.
      def lines
        field(:lines, LinesField.new)
      end

      # Configure the offsets field for this repository and return self.
      def offsets
        field(:offsets, OffsetsField.new)
      end

      # Configure the character offsets field for this repository and return
      # self.
      def character_offsets
        field(:character_offsets, CharacterOffsetsField.new)
      end

      # Configure the code unit offsets field for this repository for a specific
      # encoding and return self.
      def code_unit_offsets(encoding)
        field(:code_unit_offsets, CodeUnitOffsetsField.new(self, encoding))
      end

      # Configure the columns field for this repository and return self.
      def columns
        field(:columns, ColumnsField.new)
      end

      # Configure the character columns field for this repository and return
      # self.
      def character_columns
        field(:character_columns, CharacterColumnsField.new)
      end

      # Configure the code unit columns field for this repository for a specific
      # encoding and return self.
      def code_unit_columns(encoding)
        field(:code_unit_columns, CodeUnitColumnsField.new(self, encoding))
      end

      # Configure the leading comments field for this repository and return
      # self.
      def leading_comments
        field(:leading_comments, LeadingCommentsField.new)
      end

      # Configure the trailing comments field for this repository and return
      # self.
      def trailing_comments
        field(:trailing_comments, TrailingCommentsField.new)
      end

      # Configure both the leading and trailing comment fields for this
      # repository and return self.
      def comments
        leading_comments.trailing_comments
      end

      # This method is called from nodes and locations when they want to enter
      # themselves into the repository. It it internal-only and meant to be
      # called from the #save* APIs.
      def enter(node_id, field_name) # :nodoc:
        entry = Entry.new(self)
        @entries[node_id][field_name] = entry
        entry
      end

      # This method is called from the entries in the repository when they need
      # to reify their values. It is internal-only and meant to be called from
      # the various value APIs.
      def reify! # :nodoc:
        result = source.result

        # Attach the comments if they have been requested as part of the
        # configuration of this repository.
        if fields.key?(:leading_comments) || fields.key?(:trailing_comments)
          result.attach_comments!
        end

        queue = [result.value] #: Array[Prism::node]
        while (node = queue.shift)
          @entries[node.node_id].each do |field_name, entry|
            value = node.public_send(field_name)
            values = {} #: Hash[Symbol, untyped]

            fields.each_value do |field|
              values.merge!(field.fields(value))
            end

            entry.reify!(values)
          end

          queue.concat(node.compact_child_nodes)
        end

        @entries.clear
      end

      private

      # Append the given field to the repository and return the repository so
      # that these calls can be chained.
      def field(name, value)
        raise ConfigurationError, "Cannot specify multiple #{name} fields" if @fields.key?(name)
        @fields[name] = value
        self
      end
    end

    # Create a new repository for the given filepath.
    def self.filepath(value)
      Repository.new(SourceFilepath.new(value))
    end

    # Create a new repository for the given string.
    def self.string(value)
      Repository.new(SourceString.new(value))
    end
  end
end
prism-1.5.1/lib/prism/string_query.rb000066400000000000000000000014071506127434000176340ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

module Prism
  # Query methods that allow categorizing strings based on their context for
  # where they could be valid in a Ruby syntax tree.
  class StringQuery
    # The string that this query is wrapping.
    attr_reader :string

    # Initialize a new query with the given string.
    def initialize(string)
      @string = string
    end

    # Whether or not this string is a valid local variable name.
    def local?
      StringQuery.local?(string)
    end

    # Whether or not this string is a valid constant name.
    def constant?
      StringQuery.constant?(string)
    end

    # Whether or not this string is a valid method name.
    def method_name?
      StringQuery.method_name?(string)
    end
  end
end
prism-1.5.1/lib/prism/translation.rb000066400000000000000000000011121506127434000174300ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

module Prism
  # This module is responsible for converting the prism syntax tree into other
  # syntax trees.
  module Translation # steep:ignore
    autoload :Parser, "prism/translation/parser"
    autoload :ParserCurrent, "prism/translation/parser_current"
    autoload :Parser33, "prism/translation/parser33"
    autoload :Parser34, "prism/translation/parser34"
    autoload :Parser35, "prism/translation/parser35"
    autoload :Ripper, "prism/translation/ripper"
    autoload :RubyParser, "prism/translation/ruby_parser"
  end
end
prism-1.5.1/lib/prism/translation/000077500000000000000000000000001506127434000171105ustar00rootroot00000000000000prism-1.5.1/lib/prism/translation/parser.rb000066400000000000000000000333541506127434000207410ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

begin
  required_version = ">= 3.3.7.2"
  gem "parser", required_version
  require "parser"
rescue LoadError
  warn(<<~MSG)
    Error: Unable to load parser #{required_version}. \
    Add `gem "parser"` to your Gemfile or run `bundle update parser`.
  MSG
  exit(1)
end

module Prism
  module Translation
    # This class is the entry-point for converting a prism syntax tree into the
    # whitequark/parser gem's syntax tree. It inherits from the base parser for
    # the parser gem, and overrides the parse* methods to parse with prism and
    # then translate.
    class Parser < ::Parser::Base
      Diagnostic = ::Parser::Diagnostic # :nodoc:
      private_constant :Diagnostic

      # The parser gem has a list of diagnostics with a hard-coded set of error
      # messages. We create our own diagnostic class in order to set our own
      # error messages.
      class PrismDiagnostic < Diagnostic
        # This is the cached message coming from prism.
        attr_reader :message

        # Initialize a new diagnostic with the given message and location.
        def initialize(message, level, reason, location)
          @message = message
          super(level, reason, {}, location, [])
        end
      end

      Racc_debug_parser = false # :nodoc:

      # The `builder` argument is used to create the parser using our custom builder class by default.
      #
      # By using the `:parser` keyword argument, you can translate in a way that is compatible with
      # the Parser gem using any parser.
      #
      # For example, in RuboCop for Ruby LSP, the following approach can be used to improve performance
      # by reusing a pre-parsed `Prism::ParseLexResult`:
      #
      #   class PrismPreparsed
      #     def initialize(prism_result)
      #       @prism_result = prism_result
      #     end
      #
      #     def parse_lex(source, **options)
      #       @prism_result
      #     end
      #   end
      #
      #   prism_preparsed = PrismPreparsed.new(prism_result)
      #
      #   Prism::Translation::Ruby34.new(builder, parser: prism_preparsed)
      #
      # In an object passed to the `:parser` keyword argument, the `parse` and `parse_lex` methods
      # should be implemented as needed.
      #
      def initialize(builder = Prism::Translation::Parser::Builder.new, parser: Prism)
        if !builder.is_a?(Prism::Translation::Parser::Builder)
          warn(<<~MSG, uplevel: 1, category: :deprecated)
            [deprecation]: The builder passed to `Prism::Translation::Parser.new` is not a \
            `Prism::Translation::Parser::Builder` subclass. This will raise in the next major version.
          MSG
        end
        @parser = parser

        super(builder)
      end

      def version # :nodoc:
        34
      end

      # The default encoding for Ruby files is UTF-8.
      def default_encoding
        Encoding::UTF_8
      end

      def yyerror # :nodoc:
      end

      # Parses a source buffer and returns the AST.
      def parse(source_buffer)
        @source_buffer = source_buffer
        source = source_buffer.source

        offset_cache = build_offset_cache(source)
        result = unwrap(@parser.parse(source, **prism_options), offset_cache)

        build_ast(result.value, offset_cache)
      ensure
        @source_buffer = nil
      end

      # Parses a source buffer and returns the AST and the source code comments.
      def parse_with_comments(source_buffer)
        @source_buffer = source_buffer
        source = source_buffer.source

        offset_cache = build_offset_cache(source)
        result = unwrap(@parser.parse(source, **prism_options), offset_cache)

        [
          build_ast(result.value, offset_cache),
          build_comments(result.comments, offset_cache)
        ]
      ensure
        @source_buffer = nil
      end

      # Parses a source buffer and returns the AST, the source code comments,
      # and the tokens emitted by the lexer.
      def tokenize(source_buffer, recover = false)
        @source_buffer = source_buffer
        source = source_buffer.source

        offset_cache = build_offset_cache(source)
        result =
          begin
            unwrap(@parser.parse_lex(source, **prism_options), offset_cache)
          rescue ::Parser::SyntaxError
            raise if !recover
          end

        program, tokens = result.value
        ast = build_ast(program, offset_cache) if result.success?

        [
          ast,
          build_comments(result.comments, offset_cache),
          build_tokens(tokens, offset_cache)
        ]
      ensure
        @source_buffer = nil
      end

      # Since prism resolves num params for us, we don't need to support this
      # kind of logic here.
      def try_declare_numparam(node)
        node.children[0].match?(/\A_[1-9]\z/)
      end

      private

      # This is a hook to allow consumers to disable some errors if they don't
      # want them to block creating the syntax tree.
      def valid_error?(error)
        true
      end

      # This is a hook to allow consumers to disable some warnings if they don't
      # want them to block creating the syntax tree.
      def valid_warning?(warning)
        true
      end

      # Build a diagnostic from the given prism parse error.
      def error_diagnostic(error, offset_cache)
        location = error.location
        diagnostic_location = build_range(location, offset_cache)

        case error.type
        when :argument_block_multi
          Diagnostic.new(:error, :block_and_blockarg, {}, diagnostic_location, [])
        when :argument_formal_constant
          Diagnostic.new(:error, :argument_const, {}, diagnostic_location, [])
        when :argument_formal_class
          Diagnostic.new(:error, :argument_cvar, {}, diagnostic_location, [])
        when :argument_formal_global
          Diagnostic.new(:error, :argument_gvar, {}, diagnostic_location, [])
        when :argument_formal_ivar
          Diagnostic.new(:error, :argument_ivar, {}, diagnostic_location, [])
        when :argument_no_forwarding_amp
          Diagnostic.new(:error, :no_anonymous_blockarg, {}, diagnostic_location, [])
        when :argument_no_forwarding_star
          Diagnostic.new(:error, :no_anonymous_restarg, {}, diagnostic_location, [])
        when :argument_no_forwarding_star_star
          Diagnostic.new(:error, :no_anonymous_kwrestarg, {}, diagnostic_location, [])
        when :begin_lonely_else
          location = location.copy(length: 4)
          diagnostic_location = build_range(location, offset_cache)
          Diagnostic.new(:error, :useless_else, {}, diagnostic_location, [])
        when :class_name, :module_name
          Diagnostic.new(:error, :module_name_const, {}, diagnostic_location, [])
        when :class_in_method
          Diagnostic.new(:error, :class_in_def, {}, diagnostic_location, [])
        when :def_endless_setter
          Diagnostic.new(:error, :endless_setter, {}, diagnostic_location, [])
        when :embdoc_term
          Diagnostic.new(:error, :embedded_document, {}, diagnostic_location, [])
        when :incomplete_variable_class, :incomplete_variable_class_3_3
          location = location.copy(length: location.length + 1)
          diagnostic_location = build_range(location, offset_cache)

          Diagnostic.new(:error, :cvar_name, { name: location.slice }, diagnostic_location, [])
        when :incomplete_variable_instance, :incomplete_variable_instance_3_3
          location = location.copy(length: location.length + 1)
          diagnostic_location = build_range(location, offset_cache)

          Diagnostic.new(:error, :ivar_name, { name: location.slice }, diagnostic_location, [])
        when :invalid_variable_global, :invalid_variable_global_3_3
          Diagnostic.new(:error, :gvar_name, { name: location.slice }, diagnostic_location, [])
        when :module_in_method
          Diagnostic.new(:error, :module_in_def, {}, diagnostic_location, [])
        when :numbered_parameter_ordinary
          Diagnostic.new(:error, :ordinary_param_defined, {}, diagnostic_location, [])
        when :numbered_parameter_outer_scope
          Diagnostic.new(:error, :numparam_used_in_outer_scope, {}, diagnostic_location, [])
        when :parameter_circular
          Diagnostic.new(:error, :circular_argument_reference, { var_name: location.slice }, diagnostic_location, [])
        when :parameter_name_repeat
          Diagnostic.new(:error, :duplicate_argument, {}, diagnostic_location, [])
        when :parameter_numbered_reserved
          Diagnostic.new(:error, :reserved_for_numparam, { name: location.slice }, diagnostic_location, [])
        when :regexp_unknown_options
          Diagnostic.new(:error, :regexp_options, { options: location.slice[1..] }, diagnostic_location, [])
        when :singleton_for_literals
          Diagnostic.new(:error, :singleton_literal, {}, diagnostic_location, [])
        when :string_literal_eof
          Diagnostic.new(:error, :string_eof, {}, diagnostic_location, [])
        when :unexpected_token_ignore
          Diagnostic.new(:error, :unexpected_token, { token: location.slice }, diagnostic_location, [])
        when :write_target_in_method
          Diagnostic.new(:error, :dynamic_const, {}, diagnostic_location, [])
        else
          PrismDiagnostic.new(error.message, :error, error.type, diagnostic_location)
        end
      end

      # Build a diagnostic from the given prism parse warning.
      def warning_diagnostic(warning, offset_cache)
        diagnostic_location = build_range(warning.location, offset_cache)

        case warning.type
        when :ambiguous_first_argument_plus
          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "+" }, diagnostic_location, [])
        when :ambiguous_first_argument_minus
          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "-" }, diagnostic_location, [])
        when :ambiguous_prefix_ampersand
          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "&" }, diagnostic_location, [])
        when :ambiguous_prefix_star
          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "*" }, diagnostic_location, [])
        when :ambiguous_prefix_star_star
          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "**" }, diagnostic_location, [])
        when :ambiguous_slash
          Diagnostic.new(:warning, :ambiguous_regexp, {}, diagnostic_location, [])
        when :dot_dot_dot_eol
          Diagnostic.new(:warning, :triple_dot_at_eol, {}, diagnostic_location, [])
        when :duplicated_hash_key
          # skip, parser does this on its own
        else
          PrismDiagnostic.new(warning.message, :warning, warning.type, diagnostic_location)
        end
      end

      # If there was a error generated during the parse, then raise an
      # appropriate syntax error. Otherwise return the result.
      def unwrap(result, offset_cache)
        result.errors.each do |error|
          next unless valid_error?(error)
          diagnostics.process(error_diagnostic(error, offset_cache))
        end

        result.warnings.each do |warning|
          next unless valid_warning?(warning)
          diagnostic = warning_diagnostic(warning, offset_cache)
          diagnostics.process(diagnostic) if diagnostic
        end

        result
      end

      # Prism deals with offsets in bytes, while the parser gem deals with
      # offsets in characters. We need to handle this conversion in order to
      # build the parser gem AST.
      #
      # If the bytesize of the source is the same as the length, then we can
      # just use the offset directly. Otherwise, we build an array where the
      # index is the byte offset and the value is the character offset.
      def build_offset_cache(source)
        if source.bytesize == source.length
          -> (offset) { offset }
        else
          offset_cache = []
          offset = 0

          source.each_char do |char|
            char.bytesize.times { offset_cache << offset }
            offset += 1
          end

          offset_cache << offset
        end
      end

      # Build the parser gem AST from the prism AST.
      def build_ast(program, offset_cache)
        program.accept(Compiler.new(self, offset_cache))
      end

      # Build the parser gem comments from the prism comments.
      def build_comments(comments, offset_cache)
        comments.map do |comment|
          ::Parser::Source::Comment.new(build_range(comment.location, offset_cache))
        end
      end

      # Build the parser gem tokens from the prism tokens.
      def build_tokens(tokens, offset_cache)
        Lexer.new(source_buffer, tokens, offset_cache).to_a
      end

      # Build a range from a prism location.
      def build_range(location, offset_cache)
        ::Parser::Source::Range.new(
          source_buffer,
          offset_cache[location.start_offset],
          offset_cache[location.end_offset]
        )
      end

      # Options for how prism should parse/lex the source.
      def prism_options
        options = {
          filepath: @source_buffer.name,
          version: convert_for_prism(version),
          partial_script: true,
        }
        # The parser gem always encodes to UTF-8, unless it is binary.
        # https://github.com/whitequark/parser/blob/v3.3.6.0/lib/parser/source/buffer.rb#L80-L107
        options[:encoding] = false if @source_buffer.source.encoding != Encoding::BINARY

        options
      end

      # Converts the version format handled by Parser to the format handled by Prism.
      def convert_for_prism(version)
        case version
        when 33
          "3.3.1"
        when 34
          "3.4.0"
        when 35
          "3.5.0"
        else
          "latest"
        end
      end

      require_relative "parser/builder"
      require_relative "parser/compiler"
      require_relative "parser/lexer"

      private_constant :Compiler
      private_constant :Lexer
    end
  end
end
prism-1.5.1/lib/prism/translation/parser/000077500000000000000000000000001506127434000204045ustar00rootroot00000000000000prism-1.5.1/lib/prism/translation/parser/builder.rb000066400000000000000000000043361506127434000223650ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

module Prism
  module Translation
    class Parser
      # A builder that knows how to convert more modern Ruby syntax
      # into whitequark/parser gem's syntax tree.
      class Builder < ::Parser::Builders::Default
        # It represents the `it` block argument, which is not yet implemented in the Parser gem.
        def itarg
          n(:itarg, [:it], nil)
        end

        # The following three lines have been added to support the `it` block parameter syntax in the source code below.
        #
        #   if args.type == :itarg
        #     block_type = :itblock
        #     args = :it
        #
        # https://github.com/whitequark/parser/blob/v3.3.7.1/lib/parser/builders/default.rb#L1122-L1155
        def block(method_call, begin_t, args, body, end_t)
          _receiver, _selector, *call_args = *method_call

          if method_call.type == :yield
            diagnostic :error, :block_given_to_yield, nil, method_call.loc.keyword, [loc(begin_t)]
          end

          last_arg = call_args.last
          if last_arg && (last_arg.type == :block_pass || last_arg.type == :forwarded_args)
            diagnostic :error, :block_and_blockarg, nil, last_arg.loc.expression, [loc(begin_t)]
          end

          if args.type == :itarg
            block_type = :itblock
            args = :it
          elsif args.type == :numargs
            block_type = :numblock
            args = args.children[0]
          else
            block_type = :block
          end

          if [:send, :csend, :index, :super, :zsuper, :lambda].include?(method_call.type)
            n(block_type, [ method_call, args, body ],
              block_map(method_call.loc.expression, begin_t, end_t))
          else
            # Code like "return foo 1 do end" is reduced in a weird sequence.
            # Here, method_call is actually (return).
            actual_send, = *method_call
            block =
              n(block_type, [ actual_send, args, body ],
                block_map(actual_send.loc.expression, begin_t, end_t))

            n(method_call.type, [ block ],
              method_call.loc.with_expression(join_exprs(method_call, block)))
          end
        end
      end
    end
  end
end
prism-1.5.1/lib/prism/translation/parser/compiler.rb000066400000000000000000002240461506127434000225530ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

module Prism
  module Translation
    class Parser
      # A visitor that knows how to convert a prism syntax tree into the
      # whitequark/parser gem's syntax tree.
      class Compiler < ::Prism::Compiler
        # Raised when the tree is malformed or there is a bug in the compiler.
        class CompilationError < StandardError
        end

        # The Parser::Base instance that is being used to build the AST.
        attr_reader :parser

        # The Parser::Builders::Default instance that is being used to build the
        # AST.
        attr_reader :builder

        # The Parser::Source::Buffer instance that is holding a reference to the
        # source code.
        attr_reader :source_buffer

        # The offset cache that is used to map between byte and character
        # offsets in the file.
        attr_reader :offset_cache

        # The types of values that can be forwarded in the current scope.
        attr_reader :forwarding

        # Whether or not the current node is in a destructure.
        attr_reader :in_destructure

        # Whether or not the current node is in a pattern.
        attr_reader :in_pattern

        # Initialize a new compiler with the given parser, offset cache, and
        # options.
        def initialize(parser, offset_cache, forwarding: [], in_destructure: false, in_pattern: false)
          @parser = parser
          @builder = parser.builder
          @source_buffer = parser.source_buffer
          @offset_cache = offset_cache

          @forwarding = forwarding
          @in_destructure = in_destructure
          @in_pattern = in_pattern
        end

        # alias foo bar
        # ^^^^^^^^^^^^^
        def visit_alias_method_node(node)
          builder.alias(token(node.keyword_loc), visit(node.new_name), visit(node.old_name))
        end

        # alias $foo $bar
        # ^^^^^^^^^^^^^^^
        def visit_alias_global_variable_node(node)
          builder.alias(token(node.keyword_loc), visit(node.new_name), visit(node.old_name))
        end

        # foo => bar | baz
        #        ^^^^^^^^^
        def visit_alternation_pattern_node(node)
          builder.match_alt(visit(node.left), token(node.operator_loc), visit(node.right))
        end

        # a and b
        # ^^^^^^^
        def visit_and_node(node)
          builder.logical_op(:and, visit(node.left), token(node.operator_loc), visit(node.right))
        end

        # []
        # ^^
        def visit_array_node(node)
          if node.opening&.start_with?("%w", "%W", "%i", "%I")
            elements = node.elements.flat_map do |element|
              if element.is_a?(StringNode)
                if element.content.include?("\n")
                  string_nodes_from_line_continuations(element.unescaped, element.content, element.content_loc.start_offset, node.opening)
                else
                  [builder.string_internal([element.unescaped, srange(element.content_loc)])]
                end
              elsif element.is_a?(InterpolatedStringNode)
                builder.string_compose(
                  token(element.opening_loc),
                  string_nodes_from_interpolation(element, node.opening),
                  token(element.closing_loc)
                )
              else
                [visit(element)]
              end
            end
          else
            elements = visit_all(node.elements)
          end

          builder.array(token(node.opening_loc), elements, token(node.closing_loc))
        end

        # foo => [bar]
        #        ^^^^^
        def visit_array_pattern_node(node)
          elements = [*node.requireds]
          elements << node.rest if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode)
          elements.concat(node.posts)
          visited = visit_all(elements)

          if node.rest.is_a?(ImplicitRestNode)
            visited[-1] = builder.match_with_trailing_comma(visited[-1], token(node.rest.location))
          end

          if node.constant
            if visited.empty?
              builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.array_pattern(token(node.opening_loc), visited, token(node.closing_loc)), token(node.closing_loc))
            else
              builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.array_pattern(nil, visited, nil), token(node.closing_loc))
            end
          else
            builder.array_pattern(token(node.opening_loc), visited, token(node.closing_loc))
          end
        end

        # foo(bar)
        #     ^^^
        def visit_arguments_node(node)
          visit_all(node.arguments)
        end

        # { a: 1 }
        #   ^^^^
        def visit_assoc_node(node)
          key = node.key

          if  node.value.is_a?(ImplicitNode)
            if in_pattern
              if key.is_a?(SymbolNode)
                if key.opening.nil?
                  builder.match_hash_var([key.unescaped, srange(key.location)])
                else
                  builder.match_hash_var_from_str(token(key.opening_loc), [builder.string_internal([key.unescaped, srange(key.value_loc)])], token(key.closing_loc))
                end
              else
                builder.match_hash_var_from_str(token(key.opening_loc), visit_all(key.parts), token(key.closing_loc))
              end
            else
              value = node.value.value

              implicit_value = if value.is_a?(CallNode)
                builder.call_method(nil, nil, [value.name, srange(value.message_loc)])
              elsif value.is_a?(ConstantReadNode)
                builder.const([value.name, srange(key.value_loc)])
              else
                builder.ident([value.name, srange(key.value_loc)]).updated(:lvar)
              end

              builder.pair_keyword([key.unescaped, srange(key)], implicit_value)
            end
          elsif node.operator_loc
            builder.pair(visit(key), token(node.operator_loc), visit(node.value))
          elsif key.is_a?(SymbolNode) && key.opening_loc.nil?
            builder.pair_keyword([key.unescaped, srange(key.location)], visit(node.value))
          else
            parts =
              if key.is_a?(SymbolNode)
                [builder.string_internal([key.unescaped, srange(key.value_loc)])]
              else
                visit_all(key.parts)
              end

            builder.pair_quoted(token(key.opening_loc), parts, token(key.closing_loc), visit(node.value))
          end
        end

        # def foo(**); bar(**); end
        #                  ^^
        #
        # { **foo }
        #   ^^^^^
        def visit_assoc_splat_node(node)
          if in_pattern
            builder.match_rest(token(node.operator_loc), token(node.value&.location))
          elsif node.value.nil? && forwarding.include?(:**)
            builder.forwarded_kwrestarg(token(node.operator_loc))
          else
            builder.kwsplat(token(node.operator_loc), visit(node.value))
          end
        end

        # $+
        # ^^
        def visit_back_reference_read_node(node)
          builder.back_ref(token(node.location))
        end

        # begin end
        # ^^^^^^^^^
        def visit_begin_node(node)
          rescue_bodies = []

          if (rescue_clause = node.rescue_clause)
            begin
              find_start_offset = (rescue_clause.reference&.location || rescue_clause.exceptions.last&.location || rescue_clause.keyword_loc).end_offset
              find_end_offset = (
                rescue_clause.statements&.location&.start_offset ||
                rescue_clause.subsequent&.location&.start_offset ||
                node.else_clause&.location&.start_offset ||
                node.ensure_clause&.location&.start_offset ||
                node.end_keyword_loc&.start_offset ||
                find_start_offset + 1
              )

              rescue_bodies << builder.rescue_body(
                token(rescue_clause.keyword_loc),
                rescue_clause.exceptions.any? ? builder.array(nil, visit_all(rescue_clause.exceptions), nil) : nil,
                token(rescue_clause.operator_loc),
                visit(rescue_clause.reference),
                srange_find(find_start_offset, find_end_offset, ";"),
                visit(rescue_clause.statements)
              )
            end until (rescue_clause = rescue_clause.subsequent).nil?
          end

          begin_body =
            builder.begin_body(
              visit(node.statements),
              rescue_bodies,
              token(node.else_clause&.else_keyword_loc),
              visit(node.else_clause),
              token(node.ensure_clause&.ensure_keyword_loc),
              visit(node.ensure_clause&.statements)
            )

          if node.begin_keyword_loc
            builder.begin_keyword(token(node.begin_keyword_loc), begin_body, token(node.end_keyword_loc))
          else
            begin_body
          end
        end

        # foo(&bar)
        #     ^^^^
        def visit_block_argument_node(node)
          builder.block_pass(token(node.operator_loc), visit(node.expression))
        end

        # foo { |; bar| }
        #          ^^^
        def visit_block_local_variable_node(node)
          builder.shadowarg(token(node.location))
        end

        # A block on a keyword or method call.
        def visit_block_node(node)
          raise CompilationError, "Cannot directly compile block nodes"
        end

        # def foo(&bar); end
        #         ^^^^
        def visit_block_parameter_node(node)
          builder.blockarg(token(node.operator_loc), token(node.name_loc))
        end

        # A block's parameters.
        def visit_block_parameters_node(node)
          [*visit(node.parameters)].concat(visit_all(node.locals))
        end

        # break
        # ^^^^^
        #
        # break foo
        # ^^^^^^^^^
        def visit_break_node(node)
          builder.keyword_cmd(:break, token(node.keyword_loc), nil, visit(node.arguments) || [], nil)
        end

        # foo
        # ^^^
        #
        # foo.bar
        # ^^^^^^^
        #
        # foo.bar() {}
        # ^^^^^^^^^^^^
        def visit_call_node(node)
          name = node.name
          arguments = node.arguments&.arguments || []
          block = node.block

          if block.is_a?(BlockArgumentNode)
            arguments = [*arguments, block]
            block = nil
          end

          if node.call_operator_loc.nil?
            case name
            when :-@
              case (receiver = node.receiver).type
              when :integer_node, :float_node, :rational_node, :imaginary_node
                return visit(numeric_negate(node.message_loc, receiver))
              end
            when :!
              return visit_block(builder.not_op(token(node.message_loc), token(node.opening_loc), visit(node.receiver), token(node.closing_loc)), block)
            when :=~
              if (receiver = node.receiver).is_a?(RegularExpressionNode)
                return builder.match_op(visit(receiver), token(node.message_loc), visit(node.arguments.arguments.first))
              end
            when :[]
              return visit_block(builder.index(visit(node.receiver), token(node.opening_loc), visit_all(arguments), token(node.closing_loc)), block)
            when :[]=
              if node.message != "[]=" && node.arguments && block.nil? && !node.safe_navigation?
                arguments = node.arguments.arguments[...-1]
                arguments << node.block if node.block

                return visit_block(
                  builder.assign(
                    builder.index_asgn(
                      visit(node.receiver),
                      token(node.opening_loc),
                      visit_all(arguments),
                      token(node.closing_loc),
                    ),
                    srange_find(node.message_loc.end_offset, node.arguments.arguments.last.location.start_offset, "="),
                    visit(node.arguments.arguments.last)
                  ),
                  block
                )
              end
            end
          end

          message_loc = node.message_loc
          call_operator_loc = node.call_operator_loc
          call_operator = [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)] if call_operator_loc

          visit_block(
            if name.end_with?("=") && !message_loc.slice.end_with?("=") && node.arguments && block.nil?
              builder.assign(
                builder.attr_asgn(visit(node.receiver), call_operator, token(message_loc)),
                srange_find(message_loc.end_offset, node.arguments.location.start_offset, "="),
                visit(node.arguments.arguments.last)
              )
            else
              builder.call_method(
                visit(node.receiver),
                call_operator,
                message_loc ? [node.name, srange(message_loc)] : nil,
                token(node.opening_loc),
                visit_all(arguments),
                token(node.closing_loc)
              )
            end,
            block
          )
        end

        # foo.bar += baz
        # ^^^^^^^^^^^^^^^
        def visit_call_operator_write_node(node)
          call_operator_loc = node.call_operator_loc

          builder.op_assign(
            builder.call_method(
              visit(node.receiver),
              call_operator_loc.nil? ? nil : [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)],
              node.message_loc ? [node.read_name, srange(node.message_loc)] : nil,
              nil,
              [],
              nil
            ),
            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
            visit(node.value)
          )
        end

        # foo.bar &&= baz
        # ^^^^^^^^^^^^^^^
        def visit_call_and_write_node(node)
          call_operator_loc = node.call_operator_loc

          builder.op_assign(
            builder.call_method(
              visit(node.receiver),
              call_operator_loc.nil? ? nil : [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)],
              node.message_loc ? [node.read_name, srange(node.message_loc)] : nil,
              nil,
              [],
              nil
            ),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # foo.bar ||= baz
        # ^^^^^^^^^^^^^^^
        def visit_call_or_write_node(node)
          call_operator_loc = node.call_operator_loc

          builder.op_assign(
            builder.call_method(
              visit(node.receiver),
              call_operator_loc.nil? ? nil : [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)],
              node.message_loc ? [node.read_name, srange(node.message_loc)] : nil,
              nil,
              [],
              nil
            ),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # foo.bar, = 1
        # ^^^^^^^
        def visit_call_target_node(node)
          call_operator_loc = node.call_operator_loc

          builder.attr_asgn(
            visit(node.receiver),
            call_operator_loc.nil? ? nil : [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)],
            token(node.message_loc)
          )
        end

        # foo => bar => baz
        #        ^^^^^^^^^^
        def visit_capture_pattern_node(node)
          builder.match_as(visit(node.value), token(node.operator_loc), visit(node.target))
        end

        # case foo; when bar; end
        # ^^^^^^^^^^^^^^^^^^^^^^^
        def visit_case_node(node)
          builder.case(
            token(node.case_keyword_loc),
            visit(node.predicate),
            visit_all(node.conditions),
            token(node.else_clause&.else_keyword_loc),
            visit(node.else_clause),
            token(node.end_keyword_loc)
          )
        end

        # case foo; in bar; end
        # ^^^^^^^^^^^^^^^^^^^^^
        def visit_case_match_node(node)
          builder.case_match(
            token(node.case_keyword_loc),
            visit(node.predicate),
            visit_all(node.conditions),
            token(node.else_clause&.else_keyword_loc),
            visit(node.else_clause),
            token(node.end_keyword_loc)
          )
        end

        # class Foo; end
        # ^^^^^^^^^^^^^^
        def visit_class_node(node)
          builder.def_class(
            token(node.class_keyword_loc),
            visit(node.constant_path),
            token(node.inheritance_operator_loc),
            visit(node.superclass),
            node.body&.accept(copy_compiler(forwarding: [])),
            token(node.end_keyword_loc)
          )
        end

        # @@foo
        # ^^^^^
        def visit_class_variable_read_node(node)
          builder.cvar(token(node.location))
        end

        # @@foo = 1
        # ^^^^^^^^^
        def visit_class_variable_write_node(node)
          builder.assign(
            builder.assignable(builder.cvar(token(node.name_loc))),
            token(node.operator_loc),
            visit(node.value)
          )
        end

        # @@foo += bar
        # ^^^^^^^^^^^^
        def visit_class_variable_operator_write_node(node)
          builder.op_assign(
            builder.assignable(builder.cvar(token(node.name_loc))),
            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
            visit(node.value)
          )
        end

        # @@foo &&= bar
        # ^^^^^^^^^^^^^
        def visit_class_variable_and_write_node(node)
          builder.op_assign(
            builder.assignable(builder.cvar(token(node.name_loc))),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # @@foo ||= bar
        # ^^^^^^^^^^^^^
        def visit_class_variable_or_write_node(node)
          builder.op_assign(
            builder.assignable(builder.cvar(token(node.name_loc))),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # @@foo, = bar
        # ^^^^^
        def visit_class_variable_target_node(node)
          builder.assignable(builder.cvar(token(node.location)))
        end

        # Foo
        # ^^^
        def visit_constant_read_node(node)
          builder.const([node.name, srange(node.location)])
        end

        # Foo = 1
        # ^^^^^^^
        #
        # Foo, Bar = 1
        # ^^^  ^^^
        def visit_constant_write_node(node)
          builder.assign(builder.assignable(builder.const([node.name, srange(node.name_loc)])), token(node.operator_loc), visit(node.value))
        end

        # Foo += bar
        # ^^^^^^^^^^^
        def visit_constant_operator_write_node(node)
          builder.op_assign(
            builder.assignable(builder.const([node.name, srange(node.name_loc)])),
            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
            visit(node.value)
          )
        end

        # Foo &&= bar
        # ^^^^^^^^^^^^
        def visit_constant_and_write_node(node)
          builder.op_assign(
            builder.assignable(builder.const([node.name, srange(node.name_loc)])),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # Foo ||= bar
        # ^^^^^^^^^^^^
        def visit_constant_or_write_node(node)
          builder.op_assign(
            builder.assignable(builder.const([node.name, srange(node.name_loc)])),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # Foo, = bar
        # ^^^
        def visit_constant_target_node(node)
          builder.assignable(builder.const([node.name, srange(node.location)]))
        end

        # Foo::Bar
        # ^^^^^^^^
        def visit_constant_path_node(node)
          if node.parent.nil?
            builder.const_global(
              token(node.delimiter_loc),
              [node.name, srange(node.name_loc)]
            )
          else
            builder.const_fetch(
              visit(node.parent),
              token(node.delimiter_loc),
              [node.name, srange(node.name_loc)]
            )
          end
        end

        # Foo::Bar = 1
        # ^^^^^^^^^^^^
        #
        # Foo::Foo, Bar::Bar = 1
        # ^^^^^^^^  ^^^^^^^^
        def visit_constant_path_write_node(node)
          builder.assign(
            builder.assignable(visit(node.target)),
            token(node.operator_loc),
            visit(node.value)
          )
        end

        # Foo::Bar += baz
        # ^^^^^^^^^^^^^^^
        def visit_constant_path_operator_write_node(node)
          builder.op_assign(
            builder.assignable(visit(node.target)),
            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
            visit(node.value)
          )
        end

        # Foo::Bar &&= baz
        # ^^^^^^^^^^^^^^^^
        def visit_constant_path_and_write_node(node)
          builder.op_assign(
            builder.assignable(visit(node.target)),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # Foo::Bar ||= baz
        # ^^^^^^^^^^^^^^^^
        def visit_constant_path_or_write_node(node)
          builder.op_assign(
            builder.assignable(visit(node.target)),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # Foo::Bar, = baz
        # ^^^^^^^^
        def visit_constant_path_target_node(node)
          builder.assignable(visit_constant_path_node(node))
        end

        # def foo; end
        # ^^^^^^^^^^^^
        #
        # def self.foo; end
        # ^^^^^^^^^^^^^^^^^
        def visit_def_node(node)
          if node.equal_loc
            if node.receiver
              builder.def_endless_singleton(
                token(node.def_keyword_loc),
                visit(node.receiver.is_a?(ParenthesesNode) ? node.receiver.body : node.receiver),
                token(node.operator_loc),
                token(node.name_loc),
                builder.args(token(node.lparen_loc), visit(node.parameters) || [], token(node.rparen_loc), false),
                token(node.equal_loc),
                node.body&.accept(copy_compiler(forwarding: find_forwarding(node.parameters)))
              )
            else
              builder.def_endless_method(
                token(node.def_keyword_loc),
                token(node.name_loc),
                builder.args(token(node.lparen_loc), visit(node.parameters) || [], token(node.rparen_loc), false),
                token(node.equal_loc),
                node.body&.accept(copy_compiler(forwarding: find_forwarding(node.parameters)))
              )
            end
          elsif node.receiver
            builder.def_singleton(
              token(node.def_keyword_loc),
              visit(node.receiver.is_a?(ParenthesesNode) ? node.receiver.body : node.receiver),
              token(node.operator_loc),
              token(node.name_loc),
              builder.args(token(node.lparen_loc), visit(node.parameters) || [], token(node.rparen_loc), false),
              node.body&.accept(copy_compiler(forwarding: find_forwarding(node.parameters))),
              token(node.end_keyword_loc)
            )
          else
            builder.def_method(
              token(node.def_keyword_loc),
              token(node.name_loc),
              builder.args(token(node.lparen_loc), visit(node.parameters) || [], token(node.rparen_loc), false),
              node.body&.accept(copy_compiler(forwarding: find_forwarding(node.parameters))),
              token(node.end_keyword_loc)
            )
          end
        end

        # defined? a
        # ^^^^^^^^^^
        #
        # defined?(a)
        # ^^^^^^^^^^^
        def visit_defined_node(node)
          # Very weird circumstances here where something like:
          #
          #     defined?
          #     (1)
          #
          # gets parsed in Ruby as having only the `1` expression but in parser
          # it gets parsed as having a begin. In this case we need to synthesize
          # that begin to match parser's behavior.
          if node.lparen_loc && node.keyword_loc.join(node.lparen_loc).slice.include?("\n")
            builder.keyword_cmd(
              :defined?,
              token(node.keyword_loc),
              nil,
              [
                builder.begin(
                  token(node.lparen_loc),
                  visit(node.value),
                  token(node.rparen_loc)
                )
              ],
              nil
            )
          else
            builder.keyword_cmd(
              :defined?,
              token(node.keyword_loc),
              token(node.lparen_loc),
              [visit(node.value)],
              token(node.rparen_loc)
            )
          end
        end

        # if foo then bar else baz end
        #                 ^^^^^^^^^^^^
        def visit_else_node(node)
          visit(node.statements)
        end

        # "foo #{bar}"
        #      ^^^^^^
        def visit_embedded_statements_node(node)
          builder.begin(
            token(node.opening_loc),
            visit(node.statements),
            token(node.closing_loc)
          )
        end

        # "foo #@bar"
        #      ^^^^^
        def visit_embedded_variable_node(node)
          visit(node.variable)
        end

        # begin; foo; ensure; bar; end
        #             ^^^^^^^^^^^^
        def visit_ensure_node(node)
          raise CompilationError, "Cannot directly compile ensure nodes"
        end

        # false
        # ^^^^^
        def visit_false_node(node)
          builder.false(token(node.location))
        end

        # foo => [*, bar, *]
        #        ^^^^^^^^^^^
        def visit_find_pattern_node(node)
          elements = [node.left, *node.requireds, node.right]

          if node.constant
            builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.find_pattern(nil, visit_all(elements), nil), token(node.closing_loc))
          else
            builder.find_pattern(token(node.opening_loc), visit_all(elements), token(node.closing_loc))
          end
        end

        # 1.0
        # ^^^
        def visit_float_node(node)
          visit_numeric(node, builder.float([node.value, srange(node.location)]))
        end

        # for foo in bar do end
        # ^^^^^^^^^^^^^^^^^^^^^
        def visit_for_node(node)
          builder.for(
            token(node.for_keyword_loc),
            visit(node.index),
            token(node.in_keyword_loc),
            visit(node.collection),
            if (do_keyword_loc = node.do_keyword_loc)
              token(do_keyword_loc)
            else
              srange_find(node.collection.location.end_offset, (node.statements&.location || node.end_keyword_loc).start_offset, ";")
            end,
            visit(node.statements),
            token(node.end_keyword_loc)
          )
        end

        # def foo(...); bar(...); end
        #                   ^^^
        def visit_forwarding_arguments_node(node)
          builder.forwarded_args(token(node.location))
        end

        # def foo(...); end
        #         ^^^
        def visit_forwarding_parameter_node(node)
          builder.forward_arg(token(node.location))
        end

        # super
        # ^^^^^
        #
        # super {}
        # ^^^^^^^^
        def visit_forwarding_super_node(node)
          visit_block(
            builder.keyword_cmd(
              :zsuper,
              ["super", srange_offsets(node.location.start_offset, node.location.start_offset + 5)]
            ),
            node.block
          )
        end

        # $foo
        # ^^^^
        def visit_global_variable_read_node(node)
          builder.gvar(token(node.location))
        end

        # $foo = 1
        # ^^^^^^^^
        def visit_global_variable_write_node(node)
          builder.assign(
            builder.assignable(builder.gvar(token(node.name_loc))),
            token(node.operator_loc),
            visit(node.value)
          )
        end

        # $foo += bar
        # ^^^^^^^^^^^
        def visit_global_variable_operator_write_node(node)
          builder.op_assign(
            builder.assignable(builder.gvar(token(node.name_loc))),
            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
            visit(node.value)
          )
        end

        # $foo &&= bar
        # ^^^^^^^^^^^^
        def visit_global_variable_and_write_node(node)
          builder.op_assign(
            builder.assignable(builder.gvar(token(node.name_loc))),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # $foo ||= bar
        # ^^^^^^^^^^^^
        def visit_global_variable_or_write_node(node)
          builder.op_assign(
            builder.assignable(builder.gvar(token(node.name_loc))),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # $foo, = bar
        # ^^^^
        def visit_global_variable_target_node(node)
          builder.assignable(builder.gvar([node.slice, srange(node.location)]))
        end

        # {}
        # ^^
        def visit_hash_node(node)
          builder.associate(
            token(node.opening_loc),
            visit_all(node.elements),
            token(node.closing_loc)
          )
        end

        # foo => {}
        #        ^^
        def visit_hash_pattern_node(node)
          elements = [*node.elements, *node.rest]

          if node.constant
            builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.hash_pattern(nil, visit_all(elements), nil), token(node.closing_loc))
          else
            builder.hash_pattern(token(node.opening_loc), visit_all(elements), token(node.closing_loc))
          end
        end

        # if foo then bar end
        # ^^^^^^^^^^^^^^^^^^^
        #
        # bar if foo
        # ^^^^^^^^^^
        #
        # foo ? bar : baz
        # ^^^^^^^^^^^^^^^
        def visit_if_node(node)
          if !node.if_keyword_loc
            builder.ternary(
              visit(node.predicate),
              token(node.then_keyword_loc),
              visit(node.statements),
              token(node.subsequent.else_keyword_loc),
              visit(node.subsequent)
            )
          elsif node.if_keyword_loc.start_offset == node.location.start_offset
            builder.condition(
              token(node.if_keyword_loc),
              visit(node.predicate),
              if (then_keyword_loc = node.then_keyword_loc)
                token(then_keyword_loc)
              else
                srange_find(node.predicate.location.end_offset, (node.statements&.location || node.subsequent&.location || node.end_keyword_loc).start_offset, ";")
              end,
              visit(node.statements),
              case node.subsequent
              when IfNode
                token(node.subsequent.if_keyword_loc)
              when ElseNode
                token(node.subsequent.else_keyword_loc)
              end,
              visit(node.subsequent),
              if node.if_keyword != "elsif"
                token(node.end_keyword_loc)
              end
            )
          else
            builder.condition_mod(
              visit(node.statements),
              visit(node.subsequent),
              token(node.if_keyword_loc),
              visit(node.predicate)
            )
          end
        end

        # 1i
        # ^^
        def visit_imaginary_node(node)
          visit_numeric(node, builder.complex([Complex(0, node.numeric.value), srange(node.location)]))
        end

        # { foo: }
        #   ^^^^
        def visit_implicit_node(node)
          raise CompilationError, "Cannot directly compile implicit nodes"
        end

        # foo { |bar,| }
        #           ^
        def visit_implicit_rest_node(node)
          raise CompilationError, "Cannot compile implicit rest nodes"
        end

        # case foo; in bar; end
        # ^^^^^^^^^^^^^^^^^^^^^
        def visit_in_node(node)
          pattern = nil
          guard = nil

          case node.pattern
          when IfNode
            pattern = within_pattern { |compiler| node.pattern.statements.accept(compiler) }
            guard = builder.if_guard(token(node.pattern.if_keyword_loc), visit(node.pattern.predicate))
          when UnlessNode
            pattern = within_pattern { |compiler| node.pattern.statements.accept(compiler) }
            guard = builder.unless_guard(token(node.pattern.keyword_loc), visit(node.pattern.predicate))
          else
            pattern = within_pattern { |compiler| node.pattern.accept(compiler) }
          end

          builder.in_pattern(
            token(node.in_loc),
            pattern,
            guard,
            if (then_loc = node.then_loc)
              token(then_loc)
            else
              srange_find(node.pattern.location.end_offset, node.statements&.location&.start_offset, ";")
            end,
            visit(node.statements)
          )
        end

        # foo[bar] += baz
        # ^^^^^^^^^^^^^^^
        def visit_index_operator_write_node(node)
          arguments = node.arguments&.arguments || []
          arguments << node.block if node.block

          builder.op_assign(
            builder.index(
              visit(node.receiver),
              token(node.opening_loc),
              visit_all(arguments),
              token(node.closing_loc)
            ),
            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
            visit(node.value)
          )
        end

        # foo[bar] &&= baz
        # ^^^^^^^^^^^^^^^^
        def visit_index_and_write_node(node)
          arguments = node.arguments&.arguments || []
          arguments << node.block if node.block

          builder.op_assign(
            builder.index(
              visit(node.receiver),
              token(node.opening_loc),
              visit_all(arguments),
              token(node.closing_loc)
            ),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # foo[bar] ||= baz
        # ^^^^^^^^^^^^^^^^
        def visit_index_or_write_node(node)
          arguments = node.arguments&.arguments || []
          arguments << node.block if node.block

          builder.op_assign(
            builder.index(
              visit(node.receiver),
              token(node.opening_loc),
              visit_all(arguments),
              token(node.closing_loc)
            ),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # foo[bar], = 1
        # ^^^^^^^^
        def visit_index_target_node(node)
          builder.index_asgn(
            visit(node.receiver),
            token(node.opening_loc),
            visit_all(node.arguments&.arguments || []),
            token(node.closing_loc),
          )
        end

        # @foo
        # ^^^^
        def visit_instance_variable_read_node(node)
          builder.ivar(token(node.location))
        end

        # @foo = 1
        # ^^^^^^^^
        def visit_instance_variable_write_node(node)
          builder.assign(
            builder.assignable(builder.ivar(token(node.name_loc))),
            token(node.operator_loc),
            visit(node.value)
          )
        end

        # @foo += bar
        # ^^^^^^^^^^^
        def visit_instance_variable_operator_write_node(node)
          builder.op_assign(
            builder.assignable(builder.ivar(token(node.name_loc))),
            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
            visit(node.value)
          )
        end

        # @foo &&= bar
        # ^^^^^^^^^^^^
        def visit_instance_variable_and_write_node(node)
          builder.op_assign(
            builder.assignable(builder.ivar(token(node.name_loc))),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # @foo ||= bar
        # ^^^^^^^^^^^^
        def visit_instance_variable_or_write_node(node)
          builder.op_assign(
            builder.assignable(builder.ivar(token(node.name_loc))),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # @foo, = bar
        # ^^^^
        def visit_instance_variable_target_node(node)
          builder.assignable(builder.ivar(token(node.location)))
        end

        # 1
        # ^
        def visit_integer_node(node)
          visit_numeric(node, builder.integer([node.value, srange(node.location)]))
        end

        # /foo #{bar}/
        # ^^^^^^^^^^^^
        def visit_interpolated_regular_expression_node(node)
          builder.regexp_compose(
            token(node.opening_loc),
            string_nodes_from_interpolation(node, node.opening),
            [node.closing[0], srange_offsets(node.closing_loc.start_offset, node.closing_loc.start_offset + 1)],
            builder.regexp_options([node.closing[1..], srange_offsets(node.closing_loc.start_offset + 1, node.closing_loc.end_offset)])
          )
        end

        # if /foo #{bar}/ then end
        #    ^^^^^^^^^^^^
        alias visit_interpolated_match_last_line_node visit_interpolated_regular_expression_node

        # "foo #{bar}"
        # ^^^^^^^^^^^^
        def visit_interpolated_string_node(node)
          if node.heredoc?
            return visit_heredoc(node) { |children, closing| builder.string_compose(token(node.opening_loc), children, closing) }
          end

          builder.string_compose(
            token(node.opening_loc),
            string_nodes_from_interpolation(node, node.opening),
            token(node.closing_loc)
          )
        end

        # :"foo #{bar}"
        # ^^^^^^^^^^^^^
        def visit_interpolated_symbol_node(node)
          builder.symbol_compose(
            token(node.opening_loc),
            string_nodes_from_interpolation(node, node.opening),
            token(node.closing_loc)
          )
        end

        # `foo #{bar}`
        # ^^^^^^^^^^^^
        def visit_interpolated_x_string_node(node)
          if node.heredoc?
            return visit_heredoc(node) { |children, closing| builder.xstring_compose(token(node.opening_loc), children, closing) }
          end

          builder.xstring_compose(
            token(node.opening_loc),
            string_nodes_from_interpolation(node, node.opening),
            token(node.closing_loc)
          )
        end

        # -> { it }
        #      ^^
        def visit_it_local_variable_read_node(node)
          builder.ident([:it, srange(node.location)]).updated(:lvar)
        end

        # -> { it }
        # ^^^^^^^^^
        def visit_it_parameters_node(node)
          # FIXME: The builder _should_ always be a subclass of the prism builder.
          # Currently RuboCop passes in its own builder that always inherits from the
          # parser builder (which is lacking the `itarg` method). Once rubocop-ast
          # opts in to use the custom prism builder a warning can be emitted when
          # it is not the expected class, and eventually raise.
          # https://github.com/rubocop/rubocop-ast/pull/354
          if builder.is_a?(Translation::Parser::Builder)
            builder.itarg
          else
            builder.args(nil, [], nil, false)
          end
        end

        # foo(bar: baz)
        #     ^^^^^^^^
        def visit_keyword_hash_node(node)
          builder.associate(nil, visit_all(node.elements), nil)
        end

        # def foo(**bar); end
        #         ^^^^^
        #
        # def foo(**); end
        #         ^^
        def visit_keyword_rest_parameter_node(node)
          builder.kwrestarg(
            token(node.operator_loc),
            node.name ? [node.name, srange(node.name_loc)] : nil
          )
        end

        # -> {}
        # ^^^^^
        def visit_lambda_node(node)
          parameters = node.parameters
          implicit_parameters = parameters.is_a?(NumberedParametersNode) || parameters.is_a?(ItParametersNode)

          builder.block(
            builder.call_lambda(token(node.operator_loc)),
            [node.opening, srange(node.opening_loc)],
            if parameters.nil?
              builder.args(nil, [], nil, false)
            elsif implicit_parameters
              visit(node.parameters)
            else
              builder.args(
                token(node.parameters.opening_loc),
                visit(node.parameters),
                token(node.parameters.closing_loc),
                false
              )
            end,
            visit(node.body),
            [node.closing, srange(node.closing_loc)]
          )
        end

        # foo
        # ^^^
        def visit_local_variable_read_node(node)
          builder.ident([node.name, srange(node.location)]).updated(:lvar)
        end

        # foo = 1
        # ^^^^^^^
        def visit_local_variable_write_node(node)
          builder.assign(
            builder.assignable(builder.ident(token(node.name_loc))),
            token(node.operator_loc),
            visit(node.value)
          )
        end

        # foo += bar
        # ^^^^^^^^^^
        def visit_local_variable_operator_write_node(node)
          builder.op_assign(
            builder.assignable(builder.ident(token(node.name_loc))),
            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
            visit(node.value)
          )
        end

        # foo &&= bar
        # ^^^^^^^^^^^
        def visit_local_variable_and_write_node(node)
          builder.op_assign(
            builder.assignable(builder.ident(token(node.name_loc))),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # foo ||= bar
        # ^^^^^^^^^^^
        def visit_local_variable_or_write_node(node)
          builder.op_assign(
            builder.assignable(builder.ident(token(node.name_loc))),
            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
            visit(node.value)
          )
        end

        # foo, = bar
        # ^^^
        def visit_local_variable_target_node(node)
          if in_pattern
            builder.assignable(builder.match_var([node.name, srange(node.location)]))
          else
            builder.assignable(builder.ident(token(node.location)))
          end
        end

        # foo in bar
        # ^^^^^^^^^^
        def visit_match_predicate_node(node)
          builder.match_pattern_p(
            visit(node.value),
            token(node.operator_loc),
            within_pattern { |compiler| node.pattern.accept(compiler) }
          )
        end

        # foo => bar
        # ^^^^^^^^^^
        def visit_match_required_node(node)
          builder.match_pattern(
            visit(node.value),
            token(node.operator_loc),
            within_pattern { |compiler| node.pattern.accept(compiler) }
          )
        end

        # /(?foo)/ =~ bar
        # ^^^^^^^^^^^^^^^^^^^^
        def visit_match_write_node(node)
          builder.match_op(
            visit(node.call.receiver),
            token(node.call.message_loc),
            visit(node.call.arguments.arguments.first)
          )
        end

        # A node that is missing from the syntax tree. This is only used in the
        # case of a syntax error. The parser gem doesn't have such a concept, so
        # we invent our own here.
        def visit_missing_node(node)
          ::AST::Node.new(:missing, [], location: ::Parser::Source::Map.new(srange(node.location)))
        end

        # module Foo; end
        # ^^^^^^^^^^^^^^^
        def visit_module_node(node)
          builder.def_module(
            token(node.module_keyword_loc),
            visit(node.constant_path),
            node.body&.accept(copy_compiler(forwarding: [])),
            token(node.end_keyword_loc)
          )
        end

        # foo, bar = baz
        # ^^^^^^^^
        def visit_multi_target_node(node)
          builder.multi_lhs(
            token(node.lparen_loc),
            visit_all(multi_target_elements(node)),
            token(node.rparen_loc)
          )
        end

        # foo, bar = baz
        # ^^^^^^^^^^^^^^
        def visit_multi_write_node(node)
          elements = multi_target_elements(node)

          if elements.length == 1 && elements.first.is_a?(MultiTargetNode) && !node.rest
            elements = multi_target_elements(elements.first)
          end

          builder.multi_assign(
            builder.multi_lhs(
              token(node.lparen_loc),
              visit_all(elements),
              token(node.rparen_loc)
            ),
            token(node.operator_loc),
            visit(node.value)
          )
        end

        # next
        # ^^^^
        #
        # next foo
        # ^^^^^^^^
        def visit_next_node(node)
          builder.keyword_cmd(
            :next,
            token(node.keyword_loc),
            nil,
            visit(node.arguments) || [],
            nil
          )
        end

        # nil
        # ^^^
        def visit_nil_node(node)
          builder.nil(token(node.location))
        end

        # def foo(**nil); end
        #         ^^^^^
        def visit_no_keywords_parameter_node(node)
          if in_pattern
            builder.match_nil_pattern(token(node.operator_loc), token(node.keyword_loc))
          else
            builder.kwnilarg(token(node.operator_loc), token(node.keyword_loc))
          end
        end

        # -> { _1 + _2 }
        # ^^^^^^^^^^^^^^
        def visit_numbered_parameters_node(node)
          builder.numargs(node.maximum)
        end

        # $1
        # ^^
        def visit_numbered_reference_read_node(node)
          builder.nth_ref([node.number, srange(node.location)])
        end

        # def foo(bar: baz); end
        #         ^^^^^^^^
        def visit_optional_keyword_parameter_node(node)
          builder.kwoptarg([node.name, srange(node.name_loc)], visit(node.value))
        end

        # def foo(bar = 1); end
        #         ^^^^^^^
        def visit_optional_parameter_node(node)
          builder.optarg(token(node.name_loc), token(node.operator_loc), visit(node.value))
        end

        # a or b
        # ^^^^^^
        def visit_or_node(node)
          builder.logical_op(:or, visit(node.left), token(node.operator_loc), visit(node.right))
        end

        # def foo(bar, *baz); end
        #         ^^^^^^^^^
        def visit_parameters_node(node)
          params = []

          if node.requireds.any?
            node.requireds.each do |required|
              params <<
                if required.is_a?(RequiredParameterNode)
                  visit(required)
                else
                  required.accept(copy_compiler(in_destructure: true))
                end
            end
          end

          params.concat(visit_all(node.optionals)) if node.optionals.any?
          params << visit(node.rest) if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode)

          if node.posts.any?
            node.posts.each do |post|
              params <<
                if post.is_a?(RequiredParameterNode)
                  visit(post)
                else
                  post.accept(copy_compiler(in_destructure: true))
                end
            end
          end

          params.concat(visit_all(node.keywords)) if node.keywords.any?
          params << visit(node.keyword_rest) if !node.keyword_rest.nil?
          params << visit(node.block) if !node.block.nil?
          params
        end

        # ()
        # ^^
        #
        # (1)
        # ^^^
        def visit_parentheses_node(node)
          builder.begin(
            token(node.opening_loc),
            visit(node.body),
            token(node.closing_loc)
          )
        end

        # foo => ^(bar)
        #        ^^^^^^
        def visit_pinned_expression_node(node)
          parts = node.expression.accept(copy_compiler(in_pattern: false)) # Don't treat * and similar as match_rest
          expression = builder.begin(token(node.lparen_loc), parts, token(node.rparen_loc))
          builder.pin(token(node.operator_loc), expression)
        end

        # foo = 1 and bar => ^foo
        #                    ^^^^
        def visit_pinned_variable_node(node)
          builder.pin(token(node.operator_loc), visit(node.variable))
        end

        # END {}
        def visit_post_execution_node(node)
          builder.postexe(
            token(node.keyword_loc),
            token(node.opening_loc),
            visit(node.statements),
            token(node.closing_loc)
          )
        end

        # BEGIN {}
        def visit_pre_execution_node(node)
          builder.preexe(
            token(node.keyword_loc),
            token(node.opening_loc),
            visit(node.statements),
            token(node.closing_loc)
          )
        end

        # The top-level program node.
        def visit_program_node(node)
          visit(node.statements)
        end

        # 0..5
        # ^^^^
        def visit_range_node(node)
          if node.exclude_end?
            builder.range_exclusive(
              visit(node.left),
              token(node.operator_loc),
              visit(node.right)
            )
          else
            builder.range_inclusive(
              visit(node.left),
              token(node.operator_loc),
              visit(node.right)
            )
          end
        end

        # if foo .. bar; end
        #    ^^^^^^^^^^
        alias visit_flip_flop_node visit_range_node

        # 1r
        # ^^
        def visit_rational_node(node)
          visit_numeric(node, builder.rational([node.value, srange(node.location)]))
        end

        # redo
        # ^^^^
        def visit_redo_node(node)
          builder.keyword_cmd(:redo, token(node.location))
        end

        # /foo/
        # ^^^^^
        def visit_regular_expression_node(node)
          parts =
            if node.content == ""
              []
            elsif node.content.include?("\n")
              string_nodes_from_line_continuations(node.unescaped, node.content, node.content_loc.start_offset, node.opening)
            else
              [builder.string_internal([node.unescaped, srange(node.content_loc)])]
            end

          builder.regexp_compose(
            token(node.opening_loc),
            parts,
            [node.closing[0], srange_offsets(node.closing_loc.start_offset, node.closing_loc.start_offset + 1)],
            builder.regexp_options([node.closing[1..], srange_offsets(node.closing_loc.start_offset + 1, node.closing_loc.end_offset)])
          )
        end

        # if /foo/ then end
        #    ^^^^^
        alias visit_match_last_line_node visit_regular_expression_node

        # def foo(bar:); end
        #         ^^^^
        def visit_required_keyword_parameter_node(node)
          builder.kwarg([node.name, srange(node.name_loc)])
        end

        # def foo(bar); end
        #         ^^^
        def visit_required_parameter_node(node)
          builder.arg(token(node.location))
        end

        # foo rescue bar
        # ^^^^^^^^^^^^^^
        def visit_rescue_modifier_node(node)
          builder.begin_body(
            visit(node.expression),
            [
              builder.rescue_body(
                token(node.keyword_loc),
                nil,
                nil,
                nil,
                nil,
                visit(node.rescue_expression)
              )
            ]
          )
        end

        # begin; rescue; end
        #        ^^^^^^^
        def visit_rescue_node(node)
          raise CompilationError, "Cannot directly compile rescue nodes"
        end

        # def foo(*bar); end
        #         ^^^^
        #
        # def foo(*); end
        #         ^
        def visit_rest_parameter_node(node)
          builder.restarg(token(node.operator_loc), token(node.name_loc))
        end

        # retry
        # ^^^^^
        def visit_retry_node(node)
          builder.keyword_cmd(:retry, token(node.location))
        end

        # return
        # ^^^^^^
        #
        # return 1
        # ^^^^^^^^
        def visit_return_node(node)
          builder.keyword_cmd(
            :return,
            token(node.keyword_loc),
            nil,
            visit(node.arguments) || [],
            nil
          )
        end

        # self
        # ^^^^
        def visit_self_node(node)
          builder.self(token(node.location))
        end

        # A shareable constant.
        def visit_shareable_constant_node(node)
          visit(node.write)
        end

        # class << self; end
        # ^^^^^^^^^^^^^^^^^^
        def visit_singleton_class_node(node)
          builder.def_sclass(
            token(node.class_keyword_loc),
            token(node.operator_loc),
            visit(node.expression),
            node.body&.accept(copy_compiler(forwarding: [])),
            token(node.end_keyword_loc)
          )
        end

        # __ENCODING__
        # ^^^^^^^^^^^^
        def visit_source_encoding_node(node)
          builder.accessible(builder.__ENCODING__(token(node.location)))
        end

        # __FILE__
        # ^^^^^^^^
        def visit_source_file_node(node)
          builder.accessible(builder.__FILE__(token(node.location)))
        end

        # __LINE__
        # ^^^^^^^^
        def visit_source_line_node(node)
          builder.accessible(builder.__LINE__(token(node.location)))
        end

        # foo(*bar)
        #     ^^^^
        #
        # def foo((bar, *baz)); end
        #               ^^^^
        #
        # def foo(*); bar(*); end
        #                 ^
        def visit_splat_node(node)
          if node.expression.nil? && forwarding.include?(:*)
            builder.forwarded_restarg(token(node.operator_loc))
          elsif in_destructure
            builder.restarg(token(node.operator_loc), token(node.expression&.location))
          elsif in_pattern
            builder.match_rest(token(node.operator_loc), token(node.expression&.location))
          else
            builder.splat(token(node.operator_loc), visit(node.expression))
          end
        end

        # A list of statements.
        def visit_statements_node(node)
          builder.compstmt(visit_all(node.body))
        end

        # "foo"
        # ^^^^^
        def visit_string_node(node)
          if node.heredoc?
            visit_heredoc(node.to_interpolated) { |children, closing| builder.string_compose(token(node.opening_loc), children, closing) }
          elsif node.opening == "?"
            builder.character([node.unescaped, srange(node.location)])
          elsif node.opening&.start_with?("%") && node.unescaped.empty?
            builder.string_compose(token(node.opening_loc), [], token(node.closing_loc))
          else
            parts =
              if node.content.include?("\n")
                string_nodes_from_line_continuations(node.unescaped, node.content, node.content_loc.start_offset, node.opening)
              else
                [builder.string_internal([node.unescaped, srange(node.content_loc)])]
              end

            builder.string_compose(
              token(node.opening_loc),
              parts,
              token(node.closing_loc)
            )
          end
        end

        # super(foo)
        # ^^^^^^^^^^
        def visit_super_node(node)
          arguments = node.arguments&.arguments || []
          block = node.block

          if block.is_a?(BlockArgumentNode)
            arguments = [*arguments, block]
            block = nil
          end

          visit_block(
            builder.keyword_cmd(
              :super,
              token(node.keyword_loc),
              token(node.lparen_loc),
              visit_all(arguments),
              token(node.rparen_loc)
            ),
            block
          )
        end

        # :foo
        # ^^^^
        def visit_symbol_node(node)
          if node.closing_loc.nil?
            if node.opening_loc.nil?
              builder.symbol_internal([node.unescaped, srange(node.location)])
            else
              builder.symbol([node.unescaped, srange(node.location)])
            end
          else
            parts =
              if node.value == ""
                []
              elsif node.value.include?("\n")
                string_nodes_from_line_continuations(node.unescaped, node.value, node.value_loc.start_offset, node.opening)
              else
                [builder.string_internal([node.unescaped, srange(node.value_loc)])]
              end

            builder.symbol_compose(
              token(node.opening_loc),
              parts,
              token(node.closing_loc)
            )
          end
        end

        # true
        # ^^^^
        def visit_true_node(node)
          builder.true(token(node.location))
        end

        # undef foo
        # ^^^^^^^^^
        def visit_undef_node(node)
          builder.undef_method(token(node.keyword_loc), visit_all(node.names))
        end

        # unless foo; bar end
        # ^^^^^^^^^^^^^^^^^^^
        #
        # bar unless foo
        # ^^^^^^^^^^^^^^
        def visit_unless_node(node)
          if node.keyword_loc.start_offset == node.location.start_offset
            builder.condition(
              token(node.keyword_loc),
              visit(node.predicate),
              if (then_keyword_loc = node.then_keyword_loc)
                token(then_keyword_loc)
              else
                srange_find(node.predicate.location.end_offset, (node.statements&.location || node.else_clause&.location || node.end_keyword_loc).start_offset, ";")
              end,
              visit(node.else_clause),
              token(node.else_clause&.else_keyword_loc),
              visit(node.statements),
              token(node.end_keyword_loc)
            )
          else
            builder.condition_mod(
              visit(node.else_clause),
              visit(node.statements),
              token(node.keyword_loc),
              visit(node.predicate)
            )
          end
        end

        # until foo; bar end
        # ^^^^^^^^^^^^^^^^^^
        #
        # bar until foo
        # ^^^^^^^^^^^^^
        def visit_until_node(node)
          if node.location.start_offset == node.keyword_loc.start_offset
            builder.loop(
              :until,
              token(node.keyword_loc),
              visit(node.predicate),
              if (do_keyword_loc = node.do_keyword_loc)
                token(do_keyword_loc)
              else
                srange_find(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset, ";")
              end,
              visit(node.statements),
              token(node.closing_loc)
            )
          else
            builder.loop_mod(
              :until,
              visit(node.statements),
              token(node.keyword_loc),
              visit(node.predicate)
            )
          end
        end

        # case foo; when bar; end
        #           ^^^^^^^^^^^^^
        def visit_when_node(node)
          builder.when(
            token(node.keyword_loc),
            visit_all(node.conditions),
            if (then_keyword_loc = node.then_keyword_loc)
              token(then_keyword_loc)
            else
              srange_find(node.conditions.last.location.end_offset, node.statements&.location&.start_offset, ";")
            end,
            visit(node.statements)
          )
        end

        # while foo; bar end
        # ^^^^^^^^^^^^^^^^^^
        #
        # bar while foo
        # ^^^^^^^^^^^^^
        def visit_while_node(node)
          if node.location.start_offset == node.keyword_loc.start_offset
            builder.loop(
              :while,
              token(node.keyword_loc),
              visit(node.predicate),
              if (do_keyword_loc = node.do_keyword_loc)
                token(do_keyword_loc)
              else
                srange_find(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset, ";")
              end,
              visit(node.statements),
              token(node.closing_loc)
            )
          else
            builder.loop_mod(
              :while,
              visit(node.statements),
              token(node.keyword_loc),
              visit(node.predicate)
            )
          end
        end

        # `foo`
        # ^^^^^
        def visit_x_string_node(node)
          if node.heredoc?
            return visit_heredoc(node.to_interpolated) { |children, closing| builder.xstring_compose(token(node.opening_loc), children, closing) }
          end

          parts =
            if node.content == ""
              []
            elsif node.content.include?("\n")
              string_nodes_from_line_continuations(node.unescaped, node.content, node.content_loc.start_offset, node.opening)
            else
              [builder.string_internal([node.unescaped, srange(node.content_loc)])]
            end

          builder.xstring_compose(
            token(node.opening_loc),
            parts,
            token(node.closing_loc)
          )
        end

        # yield
        # ^^^^^
        #
        # yield 1
        # ^^^^^^^
        def visit_yield_node(node)
          builder.keyword_cmd(
            :yield,
            token(node.keyword_loc),
            token(node.lparen_loc),
            visit(node.arguments) || [],
            token(node.rparen_loc)
          )
        end

        private

        # Initialize a new compiler with the given option overrides, used to
        # visit a subtree with the given options.
        def copy_compiler(forwarding: self.forwarding, in_destructure: self.in_destructure, in_pattern: self.in_pattern)
          Compiler.new(parser, offset_cache, forwarding: forwarding, in_destructure: in_destructure, in_pattern: in_pattern)
        end

        # When *, **, &, or ... are used as an argument in a method call, we
        # check if they were allowed by the current context. To determine that
        # we build this lookup table.
        def find_forwarding(node)
          return [] if node.nil?

          forwarding = []
          forwarding << :* if node.rest.is_a?(RestParameterNode) && node.rest.name.nil?
          forwarding << :** if node.keyword_rest.is_a?(KeywordRestParameterNode) && node.keyword_rest.name.nil?
          forwarding << :& if !node.block.nil? && node.block.name.nil?
          forwarding |= [:&, :"..."] if node.keyword_rest.is_a?(ForwardingParameterNode)

          forwarding
        end

        # Returns the set of targets for a MultiTargetNode or a MultiWriteNode.
        def multi_target_elements(node)
          elements = [*node.lefts]
          elements << node.rest if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode)
          elements.concat(node.rights)
          elements
        end

        # Negate the value of a numeric node. This is a special case where you
        # have a negative sign on one line and then a number on the next line.
        # In normal Ruby, this will always be a method call. The parser gem,
        # however, marks this as a numeric literal. We have to massage the tree
        # here to get it into the correct form.
        def numeric_negate(message_loc, receiver)
          case receiver.type
          when :integer_node, :float_node
            receiver.copy(value: -receiver.value, location: message_loc.join(receiver.location))
          when :rational_node
            receiver.copy(numerator: -receiver.numerator, location: message_loc.join(receiver.location))
          when :imaginary_node
            receiver.copy(numeric: numeric_negate(message_loc, receiver.numeric), location: message_loc.join(receiver.location))
          end
        end

        # Blocks can have a special set of parameters that automatically expand
        # when given arrays if they have a single required parameter and no
        # other parameters.
        def procarg0?(parameters)
          parameters &&
            parameters.requireds.length == 1 &&
            parameters.optionals.empty? &&
            parameters.rest.nil? &&
            parameters.posts.empty? &&
            parameters.keywords.empty? &&
            parameters.keyword_rest.nil? &&
            parameters.block.nil?
        end

        # Locations in the parser gem AST are generated using this class. We
        # store a reference to its constant to make it slightly faster to look
        # up.
        Range = ::Parser::Source::Range

        # Constructs a new source range from the given start and end offsets.
        def srange(location)
          Range.new(source_buffer, offset_cache[location.start_offset], offset_cache[location.end_offset]) if location
        end

        # Constructs a new source range from the given start and end offsets.
        def srange_offsets(start_offset, end_offset)
          Range.new(source_buffer, offset_cache[start_offset], offset_cache[end_offset])
        end

        # Constructs a new source range by finding the given character between
        # the given start offset and end offset. If the needle is not found, it
        # returns nil. Importantly it does not search past newlines or comments.
        #
        # Note that end_offset is allowed to be nil, in which case this will
        # search until the end of the string.
        def srange_find(start_offset, end_offset, character)
          if (match = source_buffer.source.byteslice(start_offset...end_offset)[/\A\s*#{character}/])
            final_offset = start_offset + match.bytesize
            [character, Range.new(source_buffer, offset_cache[final_offset - character.bytesize], offset_cache[final_offset])]
          end
        end

        # Transform a location into a token that the parser gem expects.
        def token(location)
          [location.slice, Range.new(source_buffer, offset_cache[location.start_offset], offset_cache[location.end_offset])] if location
        end

        # Visit a block node on a call.
        def visit_block(call, block)
          if block
            parameters = block.parameters
            implicit_parameters = parameters.is_a?(NumberedParametersNode) || parameters.is_a?(ItParametersNode)

            builder.block(
              call,
              token(block.opening_loc),
              if parameters.nil?
                builder.args(nil, [], nil, false)
              elsif implicit_parameters
                visit(parameters)
              else
                builder.args(
                  token(parameters.opening_loc),
                  if procarg0?(parameters.parameters)
                    parameter = parameters.parameters.requireds.first
                    visited = parameter.is_a?(RequiredParameterNode) ? visit(parameter) : parameter.accept(copy_compiler(in_destructure: true))
                    [builder.procarg0(visited)].concat(visit_all(parameters.locals))
                  else
                    visit(parameters)
                  end,
                  token(parameters.closing_loc),
                  false
                )
              end,
              visit(block.body),
              token(block.closing_loc)
            )
          else
            call
          end
        end

        # Visit a heredoc that can be either a string or an xstring.
        def visit_heredoc(node)
          children = Array.new
          indented = false

          # If this is a dedenting heredoc, then we need to insert the opening
          # content into the children as well.
          if node.opening.start_with?("<<~") && node.parts.length > 0 && !node.parts.first.is_a?(StringNode)
            location = node.parts.first.location
            location = location.copy(start_offset: location.start_offset - location.start_line_slice.bytesize)
            children << builder.string_internal(token(location))
            indented = true
          end

          node.parts.each do |part|
            pushing =
              if part.is_a?(StringNode) && part.content.include?("\n")
                string_nodes_from_line_continuations(part.unescaped, part.content, part.location.start_offset, node.opening)
              else
                [visit(part)]
              end

            pushing.each do |child|
              if child.type == :str && child.children.last == ""
                # nothing
              elsif child.type == :str && children.last && children.last.type == :str && !children.last.children.first.end_with?("\n")
                appendee = children[-1]

                location = appendee.loc
                location = location.with_expression(location.expression.join(child.loc.expression))

                children[-1] = appendee.updated(:str, ["#{appendee.children.first}#{child.children.first}"], location: location)
              else
                children << child
              end
            end
          end

          closing = node.closing
          closing_t = [closing.chomp, srange_offsets(node.closing_loc.start_offset, node.closing_loc.end_offset - (closing[/\s+$/]&.length || 0))]
          composed = yield children, closing_t

          composed = composed.updated(nil, children[1..-1]) if indented
          composed
        end

        # Visit a numeric node and account for the optional sign.
        def visit_numeric(node, value)
          if (slice = node.slice).match?(/^[+-]/)
            builder.unary_num(
              [slice[0].to_sym, srange_offsets(node.location.start_offset, node.location.start_offset + 1)],
              value
            )
          else
            value
          end
        end

        # Within the given block, track that we're within a pattern.
        def within_pattern
          begin
            parser.pattern_variables.push
            yield copy_compiler(in_pattern: true)
          ensure
            parser.pattern_variables.pop
          end
        end

        # When the content of a string node is split across multiple lines, the
        # parser gem creates individual string nodes for each line the content is part of.
        def string_nodes_from_interpolation(node, opening)
          node.parts.flat_map do |part|
            if part.type == :string_node && part.content.include?("\n") && part.opening_loc.nil?
              string_nodes_from_line_continuations(part.unescaped, part.content, part.content_loc.start_offset, opening)
            else
              visit(part)
            end
          end
        end

        # Create parser string nodes from a single prism node. The parser gem
        # "glues" strings together when a line continuation is encountered.
        def string_nodes_from_line_continuations(unescaped, escaped, start_offset, opening)
          unescaped = unescaped.lines
          escaped = escaped.lines
          percent_array = opening&.start_with?("%w", "%W", "%i", "%I")
          regex = opening == "/" || opening&.start_with?("%r")

          # Non-interpolating strings
          if opening&.end_with?("'") || opening&.start_with?("%q", "%s", "%w", "%i")
            current_length = 0
            current_line = +""

            escaped.filter_map.with_index do |escaped_line, index|
              unescaped_line = unescaped.fetch(index, "")
              current_length += escaped_line.bytesize
              current_line << unescaped_line

              # Glue line continuations together. Only %w and %i arrays can contain these.
              if percent_array && escaped_line[/(\\)*\n$/, 1]&.length&.odd?
                next unless index == escaped.count - 1
              end
              s = builder.string_internal([current_line, srange_offsets(start_offset, start_offset + current_length)])
              start_offset += escaped_line.bytesize
              current_line = +""
              current_length = 0
              s
            end
          else
            escaped_lengths = []
            normalized_lengths = []
            # Keeps track of where an unescaped line should start a new token. An unescaped
            # \n would otherwise be indistinguishable from the actual newline at the end of
            # of the line. The parser gem only emits a new string node at "real" newlines,
            # line continuations don't start a new node as well.
            do_next_tokens = []

            escaped
              .chunk_while { |before, after| before[/(\\*)\r?\n$/, 1]&.length&.odd? || false }
              .each do |lines|
                escaped_lengths << lines.sum(&:bytesize)

                unescaped_lines_count =
                  if regex
                    0 # Will always be preserved as is
                  else
                    lines.sum do |line|
                      count = line.scan(/(\\*)n/).count { |(backslashes)| backslashes&.length&.odd? }
                      count -= 1 if !line.end_with?("\n") && count > 0
                      count
                    end
                  end

                extra = 1
                extra = lines.count if percent_array # Account for line continuations in percent arrays

                normalized_lengths.concat(Array.new(unescaped_lines_count + extra, 0))
                normalized_lengths[-1] = lines.sum { |line| line.bytesize }
                do_next_tokens.concat(Array.new(unescaped_lines_count + extra, false))
                do_next_tokens[-1] = true
              end

            current_line = +""
            current_normalized_length = 0

            emitted_count = 0
            unescaped.filter_map.with_index do |unescaped_line, index|
              current_line << unescaped_line
              current_normalized_length += normalized_lengths.fetch(index, 0)

              if do_next_tokens[index]
                inner_part = builder.string_internal([current_line, srange_offsets(start_offset, start_offset + current_normalized_length)])
                start_offset += escaped_lengths.fetch(emitted_count, 0)
                current_line = +""
                current_normalized_length = 0
                emitted_count += 1
                inner_part
              else
                nil
              end
            end
          end
        end
      end
    end
  end
end
prism-1.5.1/lib/prism/translation/parser/lexer.rb000066400000000000000000001024211506127434000220500ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

require "strscan"
require_relative "../../polyfill/append_as_bytes"
require_relative "../../polyfill/scan_byte"

module Prism
  module Translation
    class Parser
      # Accepts a list of prism tokens and converts them into the expected
      # format for the parser gem.
      class Lexer
        # These tokens are always skipped
        TYPES_ALWAYS_SKIP = Set.new(%i[IGNORED_NEWLINE __END__ EOF])
        private_constant :TYPES_ALWAYS_SKIP

        # The direct translating of types between the two lexers.
        TYPES = {
          # These tokens should never appear in the output of the lexer.
          MISSING: nil,
          NOT_PROVIDED: nil,
          EMBDOC_END: nil,
          EMBDOC_LINE: nil,

          # These tokens have more or less direct mappings.
          AMPERSAND: :tAMPER2,
          AMPERSAND_AMPERSAND: :tANDOP,
          AMPERSAND_AMPERSAND_EQUAL: :tOP_ASGN,
          AMPERSAND_DOT: :tANDDOT,
          AMPERSAND_EQUAL: :tOP_ASGN,
          BACK_REFERENCE: :tBACK_REF,
          BACKTICK: :tXSTRING_BEG,
          BANG: :tBANG,
          BANG_EQUAL: :tNEQ,
          BANG_TILDE: :tNMATCH,
          BRACE_LEFT: :tLCURLY,
          BRACE_RIGHT: :tRCURLY,
          BRACKET_LEFT: :tLBRACK2,
          BRACKET_LEFT_ARRAY: :tLBRACK,
          BRACKET_LEFT_RIGHT: :tAREF,
          BRACKET_LEFT_RIGHT_EQUAL: :tASET,
          BRACKET_RIGHT: :tRBRACK,
          CARET: :tCARET,
          CARET_EQUAL: :tOP_ASGN,
          CHARACTER_LITERAL: :tCHARACTER,
          CLASS_VARIABLE: :tCVAR,
          COLON: :tCOLON,
          COLON_COLON: :tCOLON2,
          COMMA: :tCOMMA,
          COMMENT: :tCOMMENT,
          CONSTANT: :tCONSTANT,
          DOT: :tDOT,
          DOT_DOT: :tDOT2,
          DOT_DOT_DOT: :tDOT3,
          EMBDOC_BEGIN: :tCOMMENT,
          EMBEXPR_BEGIN: :tSTRING_DBEG,
          EMBEXPR_END: :tSTRING_DEND,
          EMBVAR: :tSTRING_DVAR,
          EQUAL: :tEQL,
          EQUAL_EQUAL: :tEQ,
          EQUAL_EQUAL_EQUAL: :tEQQ,
          EQUAL_GREATER: :tASSOC,
          EQUAL_TILDE: :tMATCH,
          FLOAT: :tFLOAT,
          FLOAT_IMAGINARY: :tIMAGINARY,
          FLOAT_RATIONAL: :tRATIONAL,
          FLOAT_RATIONAL_IMAGINARY: :tIMAGINARY,
          GLOBAL_VARIABLE: :tGVAR,
          GREATER: :tGT,
          GREATER_EQUAL: :tGEQ,
          GREATER_GREATER: :tRSHFT,
          GREATER_GREATER_EQUAL: :tOP_ASGN,
          HEREDOC_START: :tSTRING_BEG,
          HEREDOC_END: :tSTRING_END,
          IDENTIFIER: :tIDENTIFIER,
          INSTANCE_VARIABLE: :tIVAR,
          INTEGER: :tINTEGER,
          INTEGER_IMAGINARY: :tIMAGINARY,
          INTEGER_RATIONAL: :tRATIONAL,
          INTEGER_RATIONAL_IMAGINARY: :tIMAGINARY,
          KEYWORD_ALIAS: :kALIAS,
          KEYWORD_AND: :kAND,
          KEYWORD_BEGIN: :kBEGIN,
          KEYWORD_BEGIN_UPCASE: :klBEGIN,
          KEYWORD_BREAK: :kBREAK,
          KEYWORD_CASE: :kCASE,
          KEYWORD_CLASS: :kCLASS,
          KEYWORD_DEF: :kDEF,
          KEYWORD_DEFINED: :kDEFINED,
          KEYWORD_DO: :kDO,
          KEYWORD_DO_LOOP: :kDO_COND,
          KEYWORD_END: :kEND,
          KEYWORD_END_UPCASE: :klEND,
          KEYWORD_ENSURE: :kENSURE,
          KEYWORD_ELSE: :kELSE,
          KEYWORD_ELSIF: :kELSIF,
          KEYWORD_FALSE: :kFALSE,
          KEYWORD_FOR: :kFOR,
          KEYWORD_IF: :kIF,
          KEYWORD_IF_MODIFIER: :kIF_MOD,
          KEYWORD_IN: :kIN,
          KEYWORD_MODULE: :kMODULE,
          KEYWORD_NEXT: :kNEXT,
          KEYWORD_NIL: :kNIL,
          KEYWORD_NOT: :kNOT,
          KEYWORD_OR: :kOR,
          KEYWORD_REDO: :kREDO,
          KEYWORD_RESCUE: :kRESCUE,
          KEYWORD_RESCUE_MODIFIER: :kRESCUE_MOD,
          KEYWORD_RETRY: :kRETRY,
          KEYWORD_RETURN: :kRETURN,
          KEYWORD_SELF: :kSELF,
          KEYWORD_SUPER: :kSUPER,
          KEYWORD_THEN: :kTHEN,
          KEYWORD_TRUE: :kTRUE,
          KEYWORD_UNDEF: :kUNDEF,
          KEYWORD_UNLESS: :kUNLESS,
          KEYWORD_UNLESS_MODIFIER: :kUNLESS_MOD,
          KEYWORD_UNTIL: :kUNTIL,
          KEYWORD_UNTIL_MODIFIER: :kUNTIL_MOD,
          KEYWORD_WHEN: :kWHEN,
          KEYWORD_WHILE: :kWHILE,
          KEYWORD_WHILE_MODIFIER: :kWHILE_MOD,
          KEYWORD_YIELD: :kYIELD,
          KEYWORD___ENCODING__: :k__ENCODING__,
          KEYWORD___FILE__: :k__FILE__,
          KEYWORD___LINE__: :k__LINE__,
          LABEL: :tLABEL,
          LABEL_END: :tLABEL_END,
          LAMBDA_BEGIN: :tLAMBEG,
          LESS: :tLT,
          LESS_EQUAL: :tLEQ,
          LESS_EQUAL_GREATER: :tCMP,
          LESS_LESS: :tLSHFT,
          LESS_LESS_EQUAL: :tOP_ASGN,
          METHOD_NAME: :tFID,
          MINUS: :tMINUS,
          MINUS_EQUAL: :tOP_ASGN,
          MINUS_GREATER: :tLAMBDA,
          NEWLINE: :tNL,
          NUMBERED_REFERENCE: :tNTH_REF,
          PARENTHESIS_LEFT: :tLPAREN2,
          PARENTHESIS_LEFT_PARENTHESES: :tLPAREN_ARG,
          PARENTHESIS_RIGHT: :tRPAREN,
          PERCENT: :tPERCENT,
          PERCENT_EQUAL: :tOP_ASGN,
          PERCENT_LOWER_I: :tQSYMBOLS_BEG,
          PERCENT_LOWER_W: :tQWORDS_BEG,
          PERCENT_UPPER_I: :tSYMBOLS_BEG,
          PERCENT_UPPER_W: :tWORDS_BEG,
          PERCENT_LOWER_X: :tXSTRING_BEG,
          PLUS: :tPLUS,
          PLUS_EQUAL: :tOP_ASGN,
          PIPE_EQUAL: :tOP_ASGN,
          PIPE: :tPIPE,
          PIPE_PIPE: :tOROP,
          PIPE_PIPE_EQUAL: :tOP_ASGN,
          QUESTION_MARK: :tEH,
          REGEXP_BEGIN: :tREGEXP_BEG,
          REGEXP_END: :tSTRING_END,
          SEMICOLON: :tSEMI,
          SLASH: :tDIVIDE,
          SLASH_EQUAL: :tOP_ASGN,
          STAR: :tSTAR2,
          STAR_EQUAL: :tOP_ASGN,
          STAR_STAR: :tPOW,
          STAR_STAR_EQUAL: :tOP_ASGN,
          STRING_BEGIN: :tSTRING_BEG,
          STRING_CONTENT: :tSTRING_CONTENT,
          STRING_END: :tSTRING_END,
          SYMBOL_BEGIN: :tSYMBEG,
          TILDE: :tTILDE,
          UAMPERSAND: :tAMPER,
          UCOLON_COLON: :tCOLON3,
          UDOT_DOT: :tBDOT2,
          UDOT_DOT_DOT: :tBDOT3,
          UMINUS: :tUMINUS,
          UMINUS_NUM: :tUNARY_NUM,
          UPLUS: :tUPLUS,
          USTAR: :tSTAR,
          USTAR_STAR: :tDSTAR,
          WORDS_SEP: :tSPACE
        }

        # These constants represent flags in our lex state. We really, really
        # don't want to be using them and we really, really don't want to be
        # exposing them as part of our public API. Unfortunately, we don't have
        # another way of matching the exact tokens that the parser gem expects
        # without them. We should find another way to do this, but in the
        # meantime we'll hide them from the documentation and mark them as
        # private constants.
        EXPR_BEG = 0x1 # :nodoc:
        EXPR_LABEL = 0x400 # :nodoc:

        # It is used to determine whether `do` is of the token type `kDO` or `kDO_LAMBDA`.
        #
        # NOTE: In edge cases like `-> (foo = -> (bar) {}) do end`, please note that `kDO` is still returned
        # instead of `kDO_LAMBDA`, which is expected: https://github.com/ruby/prism/pull/3046
        LAMBDA_TOKEN_TYPES = Set.new([:kDO_LAMBDA, :tLAMBDA, :tLAMBEG])

        # The `PARENTHESIS_LEFT` token in Prism is classified as either `tLPAREN` or `tLPAREN2` in the Parser gem.
        # The following token types are listed as those classified as `tLPAREN`.
        LPAREN_CONVERSION_TOKEN_TYPES = Set.new([
          :kBREAK, :tCARET, :kCASE, :tDIVIDE, :kFOR, :kIF, :kNEXT, :kRETURN, :kUNTIL, :kWHILE, :tAMPER, :tANDOP, :tBANG, :tCOMMA, :tDOT2, :tDOT3,
          :tEQL, :tLPAREN, :tLPAREN2, :tLPAREN_ARG, :tLSHFT, :tNL, :tOP_ASGN, :tOROP, :tPIPE, :tSEMI, :tSTRING_DBEG, :tUMINUS, :tUPLUS, :tLCURLY
        ])

        # Types of tokens that are allowed to continue a method call with comments in-between.
        # For these, the parser gem doesn't emit a newline token after the last comment.
        COMMENT_CONTINUATION_TYPES = Set.new([:COMMENT, :AMPERSAND_DOT, :DOT])
        private_constant :COMMENT_CONTINUATION_TYPES

        # Heredocs are complex and require us to keep track of a bit of info to refer to later
        HeredocData = Struct.new(:identifier, :common_whitespace, keyword_init: true)

        private_constant :TYPES, :EXPR_BEG, :EXPR_LABEL, :LAMBDA_TOKEN_TYPES, :LPAREN_CONVERSION_TOKEN_TYPES, :HeredocData

        # The Parser::Source::Buffer that the tokens were lexed from.
        attr_reader :source_buffer

        # An array of tuples that contain prism tokens and their associated lex
        # state when they were lexed.
        attr_reader :lexed

        # A hash that maps offsets in bytes to offsets in characters.
        attr_reader :offset_cache

        # Initialize the lexer with the given source buffer, prism tokens, and
        # offset cache.
        def initialize(source_buffer, lexed, offset_cache)
          @source_buffer = source_buffer
          @lexed = lexed
          @offset_cache = offset_cache
        end

        Range = ::Parser::Source::Range # :nodoc:
        private_constant :Range

        # Convert the prism tokens into the expected format for the parser gem.
        def to_a
          tokens = []

          index = 0
          length = lexed.length

          heredoc_stack = []
          quote_stack = []

          # The parser gem emits the newline tokens for comments out of order. This saves
          # that token location to emit at a later time to properly line everything up.
          # https://github.com/whitequark/parser/issues/1025
          comment_newline_location = nil

          while index < length
            token, state = lexed[index]
            index += 1
            next if TYPES_ALWAYS_SKIP.include?(token.type)

            type = TYPES.fetch(token.type)
            value = token.value
            location = range(token.location.start_offset, token.location.end_offset)

            case type
            when :kDO
              nearest_lambda_token = tokens.reverse_each.find do |token|
                LAMBDA_TOKEN_TYPES.include?(token.first)
              end

              if nearest_lambda_token&.first == :tLAMBDA
                type = :kDO_LAMBDA
              end
            when :tCHARACTER
              value.delete_prefix!("?")
              # Character literals behave similar to double-quoted strings. We can use the same escaping mechanism.
              value = unescape_string(value, "?")
            when :tCOMMENT
              if token.type == :EMBDOC_BEGIN

                while !((next_token = lexed[index]&.first) && next_token.type == :EMBDOC_END) && (index < length - 1)
                  value += next_token.value
                  index += 1
                end

                value += next_token.value
                location = range(token.location.start_offset, next_token.location.end_offset)
                index += 1
              else
                is_at_eol = value.chomp!.nil?
                location = range(token.location.start_offset, token.location.end_offset + (is_at_eol ? 0 : -1))

                prev_token, _ = lexed[index - 2] if index - 2 >= 0
                next_token, _ = lexed[index]

                is_inline_comment = prev_token&.location&.start_line == token.location.start_line
                if is_inline_comment && !is_at_eol && !COMMENT_CONTINUATION_TYPES.include?(next_token&.type)
                  tokens << [:tCOMMENT, [value, location]]

                  nl_location = range(token.location.end_offset - 1, token.location.end_offset)
                  tokens << [:tNL, [nil, nl_location]]
                  next
                elsif is_inline_comment && next_token&.type == :COMMENT
                  comment_newline_location = range(token.location.end_offset - 1, token.location.end_offset)
                elsif comment_newline_location && !COMMENT_CONTINUATION_TYPES.include?(next_token&.type)
                  tokens << [:tCOMMENT, [value, location]]
                  tokens << [:tNL, [nil, comment_newline_location]]
                  comment_newline_location = nil
                  next
                end
              end
            when :tNL
              next_token, _ = lexed[index]
              # Newlines after comments are emitted out of order.
              if next_token&.type == :COMMENT
                comment_newline_location = location
                next
              end

              value = nil
            when :tFLOAT
              value = parse_float(value)
            when :tIMAGINARY
              value = parse_complex(value)
            when :tINTEGER
              if value.start_with?("+")
                tokens << [:tUNARY_NUM, ["+", range(token.location.start_offset, token.location.start_offset + 1)]]
                location = range(token.location.start_offset + 1, token.location.end_offset)
              end

              value = parse_integer(value)
            when :tLABEL
              value.chomp!(":")
            when :tLABEL_END
              value.chomp!(":")
            when :tLCURLY
              type = :tLBRACE if state == EXPR_BEG | EXPR_LABEL
            when :tLPAREN2
              type = :tLPAREN if tokens.empty? || LPAREN_CONVERSION_TOKEN_TYPES.include?(tokens.dig(-1, 0))
            when :tNTH_REF
              value = parse_integer(value.delete_prefix("$"))
            when :tOP_ASGN
              value.chomp!("=")
            when :tRATIONAL
              value = parse_rational(value)
            when :tSPACE
              location = range(token.location.start_offset, token.location.start_offset + percent_array_leading_whitespace(value))
              value = nil
            when :tSTRING_BEG
              next_token, _ = lexed[index]
              next_next_token, _ = lexed[index + 1]
              basic_quotes = value == '"' || value == "'"

              if basic_quotes && next_token&.type == :STRING_END
                next_location = token.location.join(next_token.location)
                type = :tSTRING
                value = ""
                location = range(next_location.start_offset, next_location.end_offset)
                index += 1
              elsif value.start_with?("'", '"', "%")
                if next_token&.type == :STRING_CONTENT && next_next_token&.type == :STRING_END
                  string_value = next_token.value
                  if simplify_string?(string_value, value)
                    next_location = token.location.join(next_next_token.location)
                    if percent_array?(value)
                      value = percent_array_unescape(string_value)
                    else
                      value = unescape_string(string_value, value)
                    end
                    type = :tSTRING
                    location = range(next_location.start_offset, next_location.end_offset)
                    index += 2
                    tokens << [type, [value, location]]

                    next
                  end
                end

                quote_stack.push(value)
              elsif token.type == :HEREDOC_START
                quote = value[2] == "-" || value[2] == "~" ? value[3] : value[2]
                heredoc_type = value[2] == "-" || value[2] == "~" ? value[2] : ""
                heredoc = HeredocData.new(
                  identifier: value.match(/<<[-~]?["'`]?(?.*?)["'`]?\z/)[:heredoc_identifier],
                  common_whitespace: 0,
                )

                if quote == "`"
                  type = :tXSTRING_BEG
                end

                # The parser gem trims whitespace from squiggly heredocs. We must record
                # the most common whitespace to later remove.
                if heredoc_type == "~" || heredoc_type == "`"
                  heredoc.common_whitespace = calculate_heredoc_whitespace(index)
                end

                if quote == "'" || quote == '"' || quote == "`"
                  value = "<<#{quote}"
                else
                  value = '<<"'
                end

                heredoc_stack.push(heredoc)
                quote_stack.push(value)
              end
            when :tSTRING_CONTENT
              is_percent_array = percent_array?(quote_stack.last)

              if (lines = token.value.lines).one?
                # Prism usually emits a single token for strings with line continuations.
                # For squiggly heredocs they are not joined so we do that manually here.
                current_string = +""
                current_length = 0
                start_offset = token.location.start_offset
                while token.type == :STRING_CONTENT
                  current_length += token.value.bytesize
                  # Heredoc interpolation can have multiple STRING_CONTENT nodes on the same line.
                  prev_token, _ = lexed[index - 2] if index - 2 >= 0
                  is_first_token_on_line = prev_token && token.location.start_line != prev_token.location.start_line
                  # The parser gem only removes indentation when the heredoc is not nested
                  not_nested = heredoc_stack.size == 1
                  if is_percent_array
                    value = percent_array_unescape(token.value)
                  elsif is_first_token_on_line && not_nested && (current_heredoc = heredoc_stack.last).common_whitespace > 0
                    value = trim_heredoc_whitespace(token.value, current_heredoc)
                  end

                  current_string << unescape_string(value, quote_stack.last)
                  relevant_backslash_count = if quote_stack.last.start_with?("%W", "%I")
                                               0 # the last backslash escapes the newline
                                             else
                                               token.value[/(\\{1,})\n/, 1]&.length || 0
                                             end
                  if relevant_backslash_count.even? || !interpolation?(quote_stack.last)
                    tokens << [:tSTRING_CONTENT, [current_string, range(start_offset, start_offset + current_length)]]
                    break
                  end
                  token, _ = lexed[index]
                  index += 1
                end
              else
                # When the parser gem encounters a line continuation inside of a multiline string,
                # it emits a single string node. The backslash (and remaining newline) is removed.
                current_line = +""
                adjustment = 0
                start_offset = token.location.start_offset
                emit = false

                lines.each.with_index do |line, index|
                  chomped_line = line.chomp
                  backslash_count = chomped_line[/\\{1,}\z/]&.length || 0
                  is_interpolation = interpolation?(quote_stack.last)

                  if backslash_count.odd? && (is_interpolation || is_percent_array)
                    if is_percent_array
                      current_line << percent_array_unescape(line)
                      adjustment += 1
                    else
                      chomped_line.delete_suffix!("\\")
                      current_line << chomped_line
                      adjustment += 2
                    end
                    # If the string ends with a line continuation emit the remainder
                    emit = index == lines.count - 1
                  else
                    current_line << line
                    emit = true
                  end

                  if emit
                    end_offset = start_offset + current_line.bytesize + adjustment
                    tokens << [:tSTRING_CONTENT, [unescape_string(current_line, quote_stack.last), range(start_offset, end_offset)]]
                    start_offset = end_offset
                    current_line = +""
                    adjustment = 0
                  end
                end
              end
              next
            when :tSTRING_DVAR
              value = nil
            when :tSTRING_END
              if token.type == :HEREDOC_END && value.end_with?("\n")
                newline_length = value.end_with?("\r\n") ? 2 : 1
                value = heredoc_stack.pop.identifier
                location = range(token.location.start_offset, token.location.end_offset - newline_length)
              elsif token.type == :REGEXP_END
                value = value[0]
                location = range(token.location.start_offset, token.location.start_offset + 1)
              end

              if percent_array?(quote_stack.pop)
                prev_token, _ = lexed[index - 2] if index - 2 >= 0
                empty = %i[PERCENT_LOWER_I PERCENT_LOWER_W PERCENT_UPPER_I PERCENT_UPPER_W].include?(prev_token&.type)
                ends_with_whitespace = prev_token&.type == :WORDS_SEP
                # parser always emits a space token after content in a percent array, even if no actual whitespace is present.
                if !empty && !ends_with_whitespace
                  tokens << [:tSPACE, [nil, range(token.location.start_offset, token.location.start_offset)]]
                end
              end
            when :tSYMBEG
              if (next_token = lexed[index]&.first) && next_token.type != :STRING_CONTENT && next_token.type != :EMBEXPR_BEGIN && next_token.type != :EMBVAR && next_token.type != :STRING_END
                next_location = token.location.join(next_token.location)
                type = :tSYMBOL
                value = next_token.value
                value = { "~@" => "~", "!@" => "!" }.fetch(value, value)
                location = range(next_location.start_offset, next_location.end_offset)
                index += 1
              else
                quote_stack.push(value)
              end
            when :tFID
              if !tokens.empty? && tokens.dig(-1, 0) == :kDEF
                type = :tIDENTIFIER
              end
            when :tXSTRING_BEG
              if (next_token = lexed[index]&.first) && !%i[STRING_CONTENT STRING_END EMBEXPR_BEGIN].include?(next_token.type)
                # self.`()
                type = :tBACK_REF2
              end
              quote_stack.push(value)
            when :tSYMBOLS_BEG, :tQSYMBOLS_BEG, :tWORDS_BEG, :tQWORDS_BEG
              if (next_token = lexed[index]&.first) && next_token.type == :WORDS_SEP
                index += 1
              end

              quote_stack.push(value)
            when :tREGEXP_BEG
              quote_stack.push(value)
            end

            tokens << [type, [value, location]]

            if token.type == :REGEXP_END
              tokens << [:tREGEXP_OPT, [token.value[1..], range(token.location.start_offset + 1, token.location.end_offset)]]
            end
          end

          tokens
        end

        private

        # Creates a new parser range, taking prisms byte offsets into account
        def range(start_offset, end_offset)
          Range.new(source_buffer, offset_cache[start_offset], offset_cache[end_offset])
        end

        # Parse an integer from the string representation.
        def parse_integer(value)
          Integer(value)
        rescue ArgumentError
          0
        end

        # Parse a float from the string representation.
        def parse_float(value)
          Float(value)
        rescue ArgumentError
          0.0
        end

        # Parse a complex from the string representation.
        def parse_complex(value)
          value.chomp!("i")

          if value.end_with?("r")
            Complex(0, parse_rational(value))
          elsif value.start_with?(/0[BbOoDdXx]/)
            Complex(0, parse_integer(value))
          else
            Complex(0, value)
          end
        rescue ArgumentError
          0i
        end

        # Parse a rational from the string representation.
        def parse_rational(value)
          value.chomp!("r")

          if value.start_with?(/0[BbOoDdXx]/)
            Rational(parse_integer(value))
          else
            Rational(value)
          end
        rescue ArgumentError
          0r
        end

        # Wonky heredoc tab/spaces rules.
        # https://github.com/ruby/prism/blob/v1.3.0/src/prism.c#L10548-L10558
        def calculate_heredoc_whitespace(heredoc_token_index)
          next_token_index = heredoc_token_index
          nesting_level = 0
          previous_line = -1
          result = Float::MAX

          while (next_token = lexed[next_token_index]&.first)
            next_token_index += 1
            next_next_token, _ = lexed[next_token_index]
            first_token_on_line = next_token.location.start_column == 0

            # String content inside nested heredocs and interpolation is ignored
            if next_token.type == :HEREDOC_START || next_token.type == :EMBEXPR_BEGIN
              # When interpolation is the first token of a line there is no string
              # content to check against. There will be no common whitespace.
              if nesting_level == 0 && first_token_on_line
                result = 0
              end
              nesting_level += 1
            elsif next_token.type == :HEREDOC_END || next_token.type == :EMBEXPR_END
              nesting_level -= 1
              # When we encountered the matching heredoc end, we can exit
              break if nesting_level == -1
            elsif next_token.type == :STRING_CONTENT && nesting_level == 0 && first_token_on_line
              common_whitespace = 0
              next_token.value[/^\s*/].each_char do |char|
                if char == "\t"
                  common_whitespace = (common_whitespace / 8 + 1) * 8;
                else
                  common_whitespace += 1
                end
              end

              is_first_token_on_line = next_token.location.start_line != previous_line
              # Whitespace is significant if followed by interpolation
              whitespace_only = common_whitespace == next_token.value.length && next_next_token&.location&.start_line != next_token.location.start_line
              if is_first_token_on_line && !whitespace_only && common_whitespace < result
                result = common_whitespace
                previous_line = next_token.location.start_line
              end
            end
          end
          result
        end

        # Wonky heredoc tab/spaces rules.
        # https://github.com/ruby/prism/blob/v1.3.0/src/prism.c#L16528-L16545
        def trim_heredoc_whitespace(string, heredoc)
          trimmed_whitespace = 0
          trimmed_characters = 0
          while (string[trimmed_characters] == "\t" || string[trimmed_characters] == " ") && trimmed_whitespace < heredoc.common_whitespace
            if string[trimmed_characters] == "\t"
              trimmed_whitespace = (trimmed_whitespace / 8 + 1) * 8;
              break if trimmed_whitespace > heredoc.common_whitespace
            else
              trimmed_whitespace += 1
            end
            trimmed_characters += 1
          end

          string[trimmed_characters..]
        end

        # Escape sequences that have special and should appear unescaped in the resulting string.
        ESCAPES = {
          "a" => "\a", "b" => "\b", "e" => "\e", "f" => "\f",
          "n" => "\n", "r" => "\r", "s" => "\s", "t" => "\t",
          "v" => "\v", "\\" => "\\"
        }.freeze
        private_constant :ESCAPES

        # When one of these delimiters is encountered, then the other
        # one is allowed to be escaped as well.
        DELIMITER_SYMETRY = { "[" => "]", "(" => ")", "{" => "}", "<" => ">" }.freeze
        private_constant :DELIMITER_SYMETRY


        # https://github.com/whitequark/parser/blob/v3.3.6.0/lib/parser/lexer-strings.rl#L14
        REGEXP_META_CHARACTERS = ["\\", "$", "(", ")", "*", "+", ".", "<", ">", "?", "[", "]", "^", "{", "|", "}"]
        private_constant :REGEXP_META_CHARACTERS

        # Apply Ruby string escaping rules
        def unescape_string(string, quote)
          # In single-quoted heredocs, everything is taken literally.
          return string if quote == "<<'"

          # OPTIMIZATION: Assume that few strings need escaping to speed up the common case.
          return string unless string.include?("\\")

          # Enclosing character for the string. `"` for `"foo"`, `{` for `%w{foo}`, etc.
          delimiter = quote[-1]

          if regexp?(quote)
            # Should be escaped handled to single-quoted heredocs. The only character that is
            # allowed to be escaped is the delimiter, except when that also has special meaning
            # in the regexp. Since all the symetry delimiters have special meaning, they don't need
            # to be considered separately.
            if REGEXP_META_CHARACTERS.include?(delimiter)
              string
            else
              # There can never be an even amount of backslashes. It would be a syntax error.
              string.gsub(/\\(#{Regexp.escape(delimiter)})/, '\1')
            end
          elsif interpolation?(quote)
            # Appending individual escape sequences may force the string out of its intended
            # encoding. Start out with binary and force it back later.
            result = "".b

            scanner = StringScanner.new(string)
            while (skipped = scanner.skip_until(/\\/))
              # Append what was just skipped over, excluding the found backslash.
              result.append_as_bytes(string.byteslice(scanner.pos - skipped, skipped - 1))
              escape_read(result, scanner, false, false)
            end

            # Add remaining chars
            result.append_as_bytes(string.byteslice(scanner.pos..))
            result.force_encoding(source_buffer.source.encoding)
          else
            delimiters = Regexp.escape("#{delimiter}#{DELIMITER_SYMETRY[delimiter]}")
            string.gsub(/\\([\\#{delimiters}])/, '\1')
          end
        end

        # Certain strings are merged into a single string token.
        def simplify_string?(value, quote)
          case quote
          when "'"
            # Only simplify 'foo'
            !value.include?("\n")
          when '"'
            # Simplify when every line ends with a line continuation, or it is the last line
            value.lines.all? do |line|
              !line.end_with?("\n") || line[/(\\*)$/, 1]&.length&.odd?
            end
          else
            # %q and similar are never simplified
            false
          end
        end

        # Escape a byte value, given the control and meta flags.
        def escape_build(value, control, meta)
          value &= 0x9f if control
          value |= 0x80 if meta
          value
        end

        # Read an escape out of the string scanner, given the control and meta
        # flags, and push the unescaped value into the result.
        def escape_read(result, scanner, control, meta)
          if scanner.skip("\n")
            # Line continuation
          elsif (value = ESCAPES[scanner.peek(1)])
            # Simple single-character escape sequences like \n
            result.append_as_bytes(value)
            scanner.pos += 1
          elsif (value = scanner.scan(/[0-7]{1,3}/))
            # \nnn
            result.append_as_bytes(escape_build(value.to_i(8), control, meta))
          elsif (value = scanner.scan(/x[0-9a-fA-F]{1,2}/))
            # \xnn
            result.append_as_bytes(escape_build(value[1..].to_i(16), control, meta))
          elsif (value = scanner.scan(/u[0-9a-fA-F]{4}/))
            # \unnnn
            result.append_as_bytes(value[1..].hex.chr(Encoding::UTF_8))
          elsif scanner.skip("u{}")
            # https://github.com/whitequark/parser/issues/856
          elsif (value = scanner.scan(/u{.*?}/))
            # \u{nnnn ...}
            value[2..-2].split.each do |unicode|
              result.append_as_bytes(unicode.hex.chr(Encoding::UTF_8))
            end
          elsif (value = scanner.scan(/c\\?(?=[[:print:]])|C-\\?(?=[[:print:]])/))
            # \cx or \C-x where x is an ASCII printable character
            escape_read(result, scanner, true, meta)
          elsif (value = scanner.scan(/M-\\?(?=[[:print:]])/))
            # \M-x where x is an ASCII printable character
            escape_read(result, scanner, control, true)
          elsif (byte = scanner.scan_byte)
            # Something else after an escape.
            if control && byte == 0x3f # ASCII '?'
              result.append_as_bytes(escape_build(0x7f, false, meta))
            else
              result.append_as_bytes(escape_build(byte, control, meta))
            end
          end
        end

        # In a percent array, certain whitespace can be preceeded with a backslash,
        # causing the following characters to be part of the previous element.
        def percent_array_unescape(string)
          string.gsub(/(\\)+[ \f\n\r\t\v]/) do |full_match|
            full_match.delete_prefix!("\\") if Regexp.last_match[1].length.odd?
            full_match
          end
        end

        # For %-arrays whitespace, the parser gem only considers whitespace before the newline.
        def percent_array_leading_whitespace(string)
          return 1 if string.start_with?("\n")

          leading_whitespace = 0
          string.each_char do |c|
            break if c == "\n"
            leading_whitespace += 1
          end
          leading_whitespace
        end

        # Determine if characters preceeded by a backslash should be escaped or not
        def interpolation?(quote)
          !quote.end_with?("'") && !quote.start_with?("%q", "%w", "%i", "%s")
        end

        # Regexp allow interpolation but are handled differently during unescaping
        def regexp?(quote)
          quote == "/" || quote.start_with?("%r")
        end

        # Determine if the string is part of a %-style array.
        def percent_array?(quote)
          quote.start_with?("%w", "%W", "%i", "%I")
        end
      end
    end
  end
end
prism-1.5.1/lib/prism/translation/parser33.rb000066400000000000000000000004061506127434000210770ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

module Prism
  module Translation
    # This class is the entry-point for Ruby 3.3 of `Prism::Translation::Parser`.
    class Parser33 < Parser
      def version # :nodoc:
        33
      end
    end
  end
end
prism-1.5.1/lib/prism/translation/parser34.rb000066400000000000000000000004061506127434000211000ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

module Prism
  module Translation
    # This class is the entry-point for Ruby 3.4 of `Prism::Translation::Parser`.
    class Parser34 < Parser
      def version # :nodoc:
        34
      end
    end
  end
end
prism-1.5.1/lib/prism/translation/parser35.rb000066400000000000000000000004061506127434000211010ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

module Prism
  module Translation
    # This class is the entry-point for Ruby 3.5 of `Prism::Translation::Parser`.
    class Parser35 < Parser
      def version # :nodoc:
        35
      end
    end
  end
end
prism-1.5.1/lib/prism/translation/parser_current.rb000066400000000000000000000011341506127434000224720ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown
# typed: ignore

#
module Prism
  module Translation
    case RUBY_VERSION
    when /^3\.3\./
      ParserCurrent = Parser33
    when /^3\.4\./
      ParserCurrent = Parser34
    when /^3\.5\./
      ParserCurrent = Parser35
    else
      # Keep this in sync with released Ruby.
      parser = Parser34
      major, minor, _patch = Gem::Version.new(RUBY_VERSION).segments
      warn "warning: `Prism::Translation::Current` is loading #{parser.name}, " \
           "but you are running #{major}.#{minor}."
      ParserCurrent = parser
    end
  end
end
prism-1.5.1/lib/prism/translation/ripper.rb000066400000000000000000002757051506127434000207560ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

require "ripper"

module Prism
  module Translation
    # This class provides a compatibility layer between prism and Ripper. It
    # functions by parsing the entire tree first and then walking it and
    # executing each of the Ripper callbacks as it goes. To use this class, you
    # treat `Prism::Translation::Ripper` effectively as you would treat the
    # `Ripper` class.
    #
    # Note that this class will serve the most common use cases, but Ripper's
    # API is extensive and undocumented. It relies on reporting the state of the
    # parser at any given time. We do our best to replicate that here, but
    # because it is a different architecture it is not possible to perfectly
    # replicate the behavior of Ripper.
    #
    # The main known difference is that we may omit dispatching some events in
    # some cases. This impacts the following events:
    #
    # - on_assign_error
    # - on_comma
    # - on_ignored_nl
    # - on_ignored_sp
    # - on_kw
    # - on_label_end
    # - on_lbrace
    # - on_lbracket
    # - on_lparen
    # - on_nl
    # - on_op
    # - on_operator_ambiguous
    # - on_rbrace
    # - on_rbracket
    # - on_rparen
    # - on_semicolon
    # - on_sp
    # - on_symbeg
    # - on_tstring_beg
    # - on_tstring_end
    #
    class Ripper < Compiler
      # Parses the given Ruby program read from +src+.
      # +src+ must be a String or an IO or a object with a #gets method.
      def self.parse(src, filename = "(ripper)", lineno = 1)
        new(src, filename, lineno).parse
      end

      # Tokenizes the Ruby program and returns an array of an array,
      # which is formatted like
      # [[lineno, column], type, token, state].
      # The +filename+ argument is mostly ignored.
      # By default, this method does not handle syntax errors in +src+,
      # use the +raise_errors+ keyword to raise a SyntaxError for an error in +src+.
      #
      #     require "ripper"
      #     require "pp"
      #
      #     pp Ripper.lex("def m(a) nil end")
      #     #=> [[[1,  0], :on_kw,     "def", FNAME    ],
      #          [[1,  3], :on_sp,     " ",   FNAME    ],
      #          [[1,  4], :on_ident,  "m",   ENDFN    ],
      #          [[1,  5], :on_lparen, "(",   BEG|LABEL],
      #          [[1,  6], :on_ident,  "a",   ARG      ],
      #          [[1,  7], :on_rparen, ")",   ENDFN    ],
      #          [[1,  8], :on_sp,     " ",   BEG      ],
      #          [[1,  9], :on_kw,     "nil", END      ],
      #          [[1, 12], :on_sp,     " ",   END      ],
      #          [[1, 13], :on_kw,     "end", END      ]]
      #
      def self.lex(src, filename = "-", lineno = 1, raise_errors: false)
        result = Prism.lex_compat(src, filepath: filename, line: lineno)

        if result.failure? && raise_errors
          raise SyntaxError, result.errors.first.message
        else
          result.value
        end
      end

      # This contains a table of all of the parser events and their
      # corresponding arity.
      PARSER_EVENT_TABLE = {
        BEGIN: 1,
        END: 1,
        alias: 2,
        alias_error: 2,
        aref: 2,
        aref_field: 2,
        arg_ambiguous: 1,
        arg_paren: 1,
        args_add: 2,
        args_add_block: 2,
        args_add_star: 2,
        args_forward: 0,
        args_new: 0,
        array: 1,
        aryptn: 4,
        assign: 2,
        assign_error: 2,
        assoc_new: 2,
        assoc_splat: 1,
        assoclist_from_args: 1,
        bare_assoc_hash: 1,
        begin: 1,
        binary: 3,
        block_var: 2,
        blockarg: 1,
        bodystmt: 4,
        brace_block: 2,
        break: 1,
        call: 3,
        case: 2,
        class: 3,
        class_name_error: 2,
        command: 2,
        command_call: 4,
        const_path_field: 2,
        const_path_ref: 2,
        const_ref: 1,
        def: 3,
        defined: 1,
        defs: 5,
        do_block: 2,
        dot2: 2,
        dot3: 2,
        dyna_symbol: 1,
        else: 1,
        elsif: 3,
        ensure: 1,
        excessed_comma: 0,
        fcall: 1,
        field: 3,
        fndptn: 4,
        for: 3,
        hash: 1,
        heredoc_dedent: 2,
        hshptn: 3,
        if: 3,
        if_mod: 2,
        ifop: 3,
        in: 3,
        kwrest_param: 1,
        lambda: 2,
        magic_comment: 2,
        massign: 2,
        method_add_arg: 2,
        method_add_block: 2,
        mlhs_add: 2,
        mlhs_add_post: 2,
        mlhs_add_star: 2,
        mlhs_new: 0,
        mlhs_paren: 1,
        module: 2,
        mrhs_add: 2,
        mrhs_add_star: 2,
        mrhs_new: 0,
        mrhs_new_from_args: 1,
        next: 1,
        nokw_param: 1,
        opassign: 3,
        operator_ambiguous: 2,
        param_error: 2,
        params: 7,
        paren: 1,
        parse_error: 1,
        program: 1,
        qsymbols_add: 2,
        qsymbols_new: 0,
        qwords_add: 2,
        qwords_new: 0,
        redo: 0,
        regexp_add: 2,
        regexp_literal: 2,
        regexp_new: 0,
        rescue: 4,
        rescue_mod: 2,
        rest_param: 1,
        retry: 0,
        return: 1,
        return0: 0,
        sclass: 2,
        stmts_add: 2,
        stmts_new: 0,
        string_add: 2,
        string_concat: 2,
        string_content: 0,
        string_dvar: 1,
        string_embexpr: 1,
        string_literal: 1,
        super: 1,
        symbol: 1,
        symbol_literal: 1,
        symbols_add: 2,
        symbols_new: 0,
        top_const_field: 1,
        top_const_ref: 1,
        unary: 2,
        undef: 1,
        unless: 3,
        unless_mod: 2,
        until: 2,
        until_mod: 2,
        var_alias: 2,
        var_field: 1,
        var_ref: 1,
        vcall: 1,
        void_stmt: 0,
        when: 3,
        while: 2,
        while_mod: 2,
        word_add: 2,
        word_new: 0,
        words_add: 2,
        words_new: 0,
        xstring_add: 2,
        xstring_literal: 1,
        xstring_new: 0,
        yield: 1,
        yield0: 0,
        zsuper: 0
      }

      # This contains a table of all of the scanner events and their
      # corresponding arity.
      SCANNER_EVENT_TABLE = {
        CHAR: 1,
        __end__: 1,
        backref: 1,
        backtick: 1,
        comma: 1,
        comment: 1,
        const: 1,
        cvar: 1,
        embdoc: 1,
        embdoc_beg: 1,
        embdoc_end: 1,
        embexpr_beg: 1,
        embexpr_end: 1,
        embvar: 1,
        float: 1,
        gvar: 1,
        heredoc_beg: 1,
        heredoc_end: 1,
        ident: 1,
        ignored_nl: 1,
        imaginary: 1,
        int: 1,
        ivar: 1,
        kw: 1,
        label: 1,
        label_end: 1,
        lbrace: 1,
        lbracket: 1,
        lparen: 1,
        nl: 1,
        op: 1,
        period: 1,
        qsymbols_beg: 1,
        qwords_beg: 1,
        rational: 1,
        rbrace: 1,
        rbracket: 1,
        regexp_beg: 1,
        regexp_end: 1,
        rparen: 1,
        semicolon: 1,
        sp: 1,
        symbeg: 1,
        symbols_beg: 1,
        tlambda: 1,
        tlambeg: 1,
        tstring_beg: 1,
        tstring_content: 1,
        tstring_end: 1,
        words_beg: 1,
        words_sep: 1,
        ignored_sp: 1
      }

      # This array contains name of parser events.
      PARSER_EVENTS = PARSER_EVENT_TABLE.keys

      # This array contains name of scanner events.
      SCANNER_EVENTS = SCANNER_EVENT_TABLE.keys

      # This array contains name of all ripper events.
      EVENTS = PARSER_EVENTS + SCANNER_EVENTS

      # A list of all of the Ruby keywords.
      KEYWORDS = [
        "alias",
        "and",
        "begin",
        "BEGIN",
        "break",
        "case",
        "class",
        "def",
        "defined?",
        "do",
        "else",
        "elsif",
        "end",
        "END",
        "ensure",
        "false",
        "for",
        "if",
        "in",
        "module",
        "next",
        "nil",
        "not",
        "or",
        "redo",
        "rescue",
        "retry",
        "return",
        "self",
        "super",
        "then",
        "true",
        "undef",
        "unless",
        "until",
        "when",
        "while",
        "yield",
        "__ENCODING__",
        "__FILE__",
        "__LINE__"
      ]

      # A list of all of the Ruby binary operators.
      BINARY_OPERATORS = [
        :!=,
        :!~,
        :=~,
        :==,
        :===,
        :<=>,
        :>,
        :>=,
        :<,
        :<=,
        :&,
        :|,
        :^,
        :>>,
        :<<,
        :-,
        :+,
        :%,
        :/,
        :*,
        :**
      ]

      private_constant :KEYWORDS, :BINARY_OPERATORS

      # Parses +src+ and create S-exp tree.
      # Returns more readable tree rather than Ripper.sexp_raw.
      # This method is mainly for developer use.
      # The +filename+ argument is mostly ignored.
      # By default, this method does not handle syntax errors in +src+,
      # returning +nil+ in such cases. Use the +raise_errors+ keyword
      # to raise a SyntaxError for an error in +src+.
      #
      #     require "ripper"
      #     require "pp"
      #
      #     pp Ripper.sexp("def m(a) nil end")
      #       #=> [:program,
      #            [[:def,
      #             [:@ident, "m", [1, 4]],
      #             [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil, nil, nil, nil]],
      #             [:bodystmt, [[:var_ref, [:@kw, "nil", [1, 9]]]], nil, nil, nil]]]]
      #
      def self.sexp(src, filename = "-", lineno = 1, raise_errors: false)
        builder = SexpBuilderPP.new(src, filename, lineno)
        sexp = builder.parse
        if builder.error?
          if raise_errors
            raise SyntaxError, builder.error
          end
        else
          sexp
        end
      end

      # Parses +src+ and create S-exp tree.
      # This method is mainly for developer use.
      # The +filename+ argument is mostly ignored.
      # By default, this method does not handle syntax errors in +src+,
      # returning +nil+ in such cases. Use the +raise_errors+ keyword
      # to raise a SyntaxError for an error in +src+.
      #
      #     require "ripper"
      #     require "pp"
      #
      #     pp Ripper.sexp_raw("def m(a) nil end")
      #       #=> [:program,
      #            [:stmts_add,
      #             [:stmts_new],
      #             [:def,
      #              [:@ident, "m", [1, 4]],
      #              [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil]],
      #              [:bodystmt,
      #               [:stmts_add, [:stmts_new], [:var_ref, [:@kw, "nil", [1, 9]]]],
      #               nil,
      #               nil,
      #               nil]]]]
      #
      def self.sexp_raw(src, filename = "-", lineno = 1, raise_errors: false)
        builder = SexpBuilder.new(src, filename, lineno)
        sexp = builder.parse
        if builder.error?
          if raise_errors
            raise SyntaxError, builder.error
          end
        else
          sexp
        end
      end

      autoload :SexpBuilder, "prism/translation/ripper/sexp"
      autoload :SexpBuilderPP, "prism/translation/ripper/sexp"

      # The source that is being parsed.
      attr_reader :source

      # The filename of the source being parsed.
      attr_reader :filename

      # The current line number of the parser.
      attr_reader :lineno

      # The current column number of the parser.
      attr_reader :column

      # Create a new Translation::Ripper object with the given source.
      def initialize(source, filename = "(ripper)", lineno = 1)
        @source = source
        @filename = filename
        @lineno = lineno
        @column = 0
        @result = nil
      end

      ##########################################################################
      # Public interface
      ##########################################################################

      # True if the parser encountered an error during parsing.
      def error?
        result.failure?
      end

      # Parse the source and return the result.
      def parse
        result.comments.each do |comment|
          location = comment.location
          bounds(location)

          if comment.is_a?(InlineComment)
            on_comment(comment.slice)
          else
            offset = location.start_offset
            lines = comment.slice.lines

            lines.each_with_index do |line, index|
              bounds(location.copy(start_offset: offset))

              if index == 0
                on_embdoc_beg(line)
              elsif index == lines.size - 1
                on_embdoc_end(line)
              else
                on_embdoc(line)
              end

              offset += line.bytesize
            end
          end
        end

        result.magic_comments.each do |magic_comment|
          on_magic_comment(magic_comment.key, magic_comment.value)
        end

        unless result.data_loc.nil?
          on___end__(result.data_loc.slice.each_line.first)
        end

        result.warnings.each do |warning|
          bounds(warning.location)

          if warning.level == :default
            warning(warning.message)
          else
            case warning.type
            when :ambiguous_first_argument_plus
              on_arg_ambiguous("+")
            when :ambiguous_first_argument_minus
              on_arg_ambiguous("-")
            when :ambiguous_slash
              on_arg_ambiguous("/")
            else
              warn(warning.message)
            end
          end
        end

        if error?
          result.errors.each do |error|
            location = error.location
            bounds(location)

            case error.type
            when :alias_argument
              on_alias_error("can't make alias for the number variables", location.slice)
            when :argument_formal_class
              on_param_error("formal argument cannot be a class variable", location.slice)
            when :argument_format_constant
              on_param_error("formal argument cannot be a constant", location.slice)
            when :argument_formal_global
              on_param_error("formal argument cannot be a global variable", location.slice)
            when :argument_formal_ivar
              on_param_error("formal argument cannot be an instance variable", location.slice)
            when :class_name, :module_name
              on_class_name_error("class/module name must be CONSTANT", location.slice)
            else
              on_parse_error(error.message)
            end
          end

          nil
        else
          result.value.accept(self)
        end
      end

      ##########################################################################
      # Visitor methods
      ##########################################################################

      # alias foo bar
      # ^^^^^^^^^^^^^
      def visit_alias_method_node(node)
        new_name = visit(node.new_name)
        old_name = visit(node.old_name)

        bounds(node.location)
        on_alias(new_name, old_name)
      end

      # alias $foo $bar
      # ^^^^^^^^^^^^^^^
      def visit_alias_global_variable_node(node)
        new_name = visit_alias_global_variable_node_value(node.new_name)
        old_name = visit_alias_global_variable_node_value(node.old_name)

        bounds(node.location)
        on_var_alias(new_name, old_name)
      end

      # Visit one side of an alias global variable node.
      private def visit_alias_global_variable_node_value(node)
        bounds(node.location)

        case node
        when BackReferenceReadNode
          on_backref(node.slice)
        when GlobalVariableReadNode
          on_gvar(node.name.to_s)
        else
          raise
        end
      end

      # foo => bar | baz
      #        ^^^^^^^^^
      def visit_alternation_pattern_node(node)
        left = visit_pattern_node(node.left)
        right = visit_pattern_node(node.right)

        bounds(node.location)
        on_binary(left, :|, right)
      end

      # Visit a pattern within a pattern match. This is used to bypass the
      # parenthesis node that can be used to wrap patterns.
      private def visit_pattern_node(node)
        if node.is_a?(ParenthesesNode)
          visit(node.body)
        else
          visit(node)
        end
      end

      # a and b
      # ^^^^^^^
      def visit_and_node(node)
        left = visit(node.left)
        right = visit(node.right)

        bounds(node.location)
        on_binary(left, node.operator.to_sym, right)
      end

      # []
      # ^^
      def visit_array_node(node)
        case (opening = node.opening)
        when /^%w/
          opening_loc = node.opening_loc
          bounds(opening_loc)
          on_qwords_beg(opening)

          elements = on_qwords_new
          previous = nil

          node.elements.each do |element|
            visit_words_sep(opening_loc, previous, element)

            bounds(element.location)
            elements = on_qwords_add(elements, on_tstring_content(element.content))

            previous = element
          end

          bounds(node.closing_loc)
          on_tstring_end(node.closing)
        when /^%i/
          opening_loc = node.opening_loc
          bounds(opening_loc)
          on_qsymbols_beg(opening)

          elements = on_qsymbols_new
          previous = nil

          node.elements.each do |element|
            visit_words_sep(opening_loc, previous, element)

            bounds(element.location)
            elements = on_qsymbols_add(elements, on_tstring_content(element.value))

            previous = element
          end

          bounds(node.closing_loc)
          on_tstring_end(node.closing)
        when /^%W/
          opening_loc = node.opening_loc
          bounds(opening_loc)
          on_words_beg(opening)

          elements = on_words_new
          previous = nil

          node.elements.each do |element|
            visit_words_sep(opening_loc, previous, element)

            bounds(element.location)
            elements =
              on_words_add(
                elements,
                if element.is_a?(StringNode)
                  on_word_add(on_word_new, on_tstring_content(element.content))
                else
                  element.parts.inject(on_word_new) do |word, part|
                    word_part =
                      if part.is_a?(StringNode)
                        bounds(part.location)
                        on_tstring_content(part.content)
                      else
                        visit(part)
                      end

                    on_word_add(word, word_part)
                  end
                end
              )

            previous = element
          end

          bounds(node.closing_loc)
          on_tstring_end(node.closing)
        when /^%I/
          opening_loc = node.opening_loc
          bounds(opening_loc)
          on_symbols_beg(opening)

          elements = on_symbols_new
          previous = nil

          node.elements.each do |element|
            visit_words_sep(opening_loc, previous, element)

            bounds(element.location)
            elements =
              on_symbols_add(
                elements,
                if element.is_a?(SymbolNode)
                  on_word_add(on_word_new, on_tstring_content(element.value))
                else
                  element.parts.inject(on_word_new) do |word, part|
                    word_part =
                      if part.is_a?(StringNode)
                        bounds(part.location)
                        on_tstring_content(part.content)
                      else
                        visit(part)
                      end

                    on_word_add(word, word_part)
                  end
                end
              )

            previous = element
          end

          bounds(node.closing_loc)
          on_tstring_end(node.closing)
        else
          bounds(node.opening_loc)
          on_lbracket(opening)

          elements = visit_arguments(node.elements) unless node.elements.empty?

          bounds(node.closing_loc)
          on_rbracket(node.closing)
        end

        bounds(node.location)
        on_array(elements)
      end

      # Dispatch a words_sep event that contains the space between the elements
      # of list literals.
      private def visit_words_sep(opening_loc, previous, current)
        end_offset = (previous.nil? ? opening_loc : previous.location).end_offset
        start_offset = current.location.start_offset

        if end_offset != start_offset
          bounds(current.location.copy(start_offset: end_offset))
          on_words_sep(source.byteslice(end_offset...start_offset))
        end
      end

      # Visit a list of elements, like the elements of an array or arguments.
      private def visit_arguments(elements)
        bounds(elements.first.location)
        elements.inject(on_args_new) do |args, element|
          arg = visit(element)
          bounds(element.location)

          case element
          when BlockArgumentNode
            on_args_add_block(args, arg)
          when SplatNode
            on_args_add_star(args, arg)
          else
            on_args_add(args, arg)
          end
        end
      end

      # foo => [bar]
      #        ^^^^^
      def visit_array_pattern_node(node)
        constant = visit(node.constant)
        requireds = visit_all(node.requireds) if node.requireds.any?
        rest =
          if (rest_node = node.rest).is_a?(SplatNode)
            if rest_node.expression.nil?
              bounds(rest_node.location)
              on_var_field(nil)
            else
              visit(rest_node.expression)
            end
          end

        posts = visit_all(node.posts) if node.posts.any?

        bounds(node.location)
        on_aryptn(constant, requireds, rest, posts)
      end

      # foo(bar)
      #     ^^^
      def visit_arguments_node(node)
        arguments, _ = visit_call_node_arguments(node, nil, false)
        arguments
      end

      # { a: 1 }
      #   ^^^^
      def visit_assoc_node(node)
        key = visit(node.key)
        value = visit(node.value)

        bounds(node.location)
        on_assoc_new(key, value)
      end

      # def foo(**); bar(**); end
      #                  ^^
      #
      # { **foo }
      #   ^^^^^
      def visit_assoc_splat_node(node)
        value = visit(node.value)

        bounds(node.location)
        on_assoc_splat(value)
      end

      # $+
      # ^^
      def visit_back_reference_read_node(node)
        bounds(node.location)
        on_backref(node.slice)
      end

      # begin end
      # ^^^^^^^^^
      def visit_begin_node(node)
        clauses = visit_begin_node_clauses(node.begin_keyword_loc, node, false)

        bounds(node.location)
        on_begin(clauses)
      end

      # Visit the clauses of a begin node to form an on_bodystmt call.
      private def visit_begin_node_clauses(location, node, allow_newline)
        statements =
          if node.statements.nil?
            on_stmts_add(on_stmts_new, on_void_stmt)
          else
            body = node.statements.body
            body.unshift(nil) if void_stmt?(location, node.statements.body[0].location, allow_newline)

            bounds(node.statements.location)
            visit_statements_node_body(body)
          end

        rescue_clause = visit(node.rescue_clause)
        else_clause =
          unless (else_clause_node = node.else_clause).nil?
            else_statements =
              if else_clause_node.statements.nil?
                [nil]
              else
                body = else_clause_node.statements.body
                body.unshift(nil) if void_stmt?(else_clause_node.else_keyword_loc, else_clause_node.statements.body[0].location, allow_newline)
                body
              end

            bounds(else_clause_node.location)
            visit_statements_node_body(else_statements)
          end
        ensure_clause = visit(node.ensure_clause)

        bounds(node.location)
        on_bodystmt(statements, rescue_clause, else_clause, ensure_clause)
      end

      # Visit the body of a structure that can have either a set of statements
      # or statements wrapped in rescue/else/ensure.
      private def visit_body_node(location, node, allow_newline = false)
        case node
        when nil
          bounds(location)
          on_bodystmt(visit_statements_node_body([nil]), nil, nil, nil)
        when StatementsNode
          body = [*node.body]
          body.unshift(nil) if void_stmt?(location, body[0].location, allow_newline)
          stmts = visit_statements_node_body(body)

          bounds(node.body.first.location)
          on_bodystmt(stmts, nil, nil, nil)
        when BeginNode
          visit_begin_node_clauses(location, node, allow_newline)
        else
          raise
        end
      end

      # foo(&bar)
      #     ^^^^
      def visit_block_argument_node(node)
        visit(node.expression)
      end

      # foo { |; bar| }
      #          ^^^
      def visit_block_local_variable_node(node)
        bounds(node.location)
        on_ident(node.name.to_s)
      end

      # Visit a BlockNode.
      def visit_block_node(node)
        braces = node.opening == "{"
        parameters = visit(node.parameters)

        body =
          case node.body
          when nil
            bounds(node.location)
            stmts = on_stmts_add(on_stmts_new, on_void_stmt)

            bounds(node.location)
            braces ? stmts : on_bodystmt(stmts, nil, nil, nil)
          when StatementsNode
            stmts = node.body.body
            stmts.unshift(nil) if void_stmt?(node.parameters&.location || node.opening_loc, node.body.location, false)
            stmts = visit_statements_node_body(stmts)

            bounds(node.body.location)
            braces ? stmts : on_bodystmt(stmts, nil, nil, nil)
          when BeginNode
            visit_body_node(node.parameters&.location || node.opening_loc, node.body)
          else
            raise
          end

        if braces
          bounds(node.location)
          on_brace_block(parameters, body)
        else
          bounds(node.location)
          on_do_block(parameters, body)
        end
      end

      # def foo(&bar); end
      #         ^^^^
      def visit_block_parameter_node(node)
        if node.name_loc.nil?
          bounds(node.location)
          on_blockarg(nil)
        else
          bounds(node.name_loc)
          name = visit_token(node.name.to_s)

          bounds(node.location)
          on_blockarg(name)
        end
      end

      # A block's parameters.
      def visit_block_parameters_node(node)
        parameters =
          if node.parameters.nil?
            on_params(nil, nil, nil, nil, nil, nil, nil)
          else
            visit(node.parameters)
          end

        locals =
          if node.locals.any?
            visit_all(node.locals)
          else
            false
          end

        bounds(node.location)
        on_block_var(parameters, locals)
      end

      # break
      # ^^^^^
      #
      # break foo
      # ^^^^^^^^^
      def visit_break_node(node)
        if node.arguments.nil?
          bounds(node.location)
          on_break(on_args_new)
        else
          arguments = visit(node.arguments)

          bounds(node.location)
          on_break(arguments)
        end
      end

      # foo
      # ^^^
      #
      # foo.bar
      # ^^^^^^^
      #
      # foo.bar() {}
      # ^^^^^^^^^^^^
      def visit_call_node(node)
        if node.call_operator_loc.nil?
          case node.name
          when :[]
            receiver = visit(node.receiver)
            arguments, block = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))

            bounds(node.location)
            call = on_aref(receiver, arguments)

            if block.nil?
              call
            else
              bounds(node.location)
              on_method_add_block(call, block)
            end
          when :[]=
            receiver = visit(node.receiver)

            *arguments, last_argument = node.arguments.arguments
            arguments << node.block if !node.block.nil?

            arguments =
              if arguments.any?
                args = visit_arguments(arguments)

                if !node.block.nil?
                  args
                else
                  bounds(arguments.first.location)
                  on_args_add_block(args, false)
                end
              end

            bounds(node.location)
            call = on_aref_field(receiver, arguments)
            value = visit_write_value(last_argument)

            bounds(last_argument.location)
            on_assign(call, value)
          when :-@, :+@, :~
            receiver = visit(node.receiver)

            bounds(node.location)
            on_unary(node.name, receiver)
          when :!
            if node.message == "not"
              receiver =
                if !node.receiver.is_a?(ParenthesesNode) || !node.receiver.body.nil?
                  visit(node.receiver)
                end

              bounds(node.location)
              on_unary(:not, receiver)
            else
              receiver = visit(node.receiver)

              bounds(node.location)
              on_unary(:!, receiver)
            end
          when *BINARY_OPERATORS
            receiver = visit(node.receiver)
            value = visit(node.arguments.arguments.first)

            bounds(node.location)
            on_binary(receiver, node.name, value)
          else
            bounds(node.message_loc)
            message = visit_token(node.message, false)

            if node.variable_call?
              on_vcall(message)
            else
              arguments, block = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc || node.location))
              call =
                if node.opening_loc.nil? && arguments&.any?
                  bounds(node.location)
                  on_command(message, arguments)
                elsif !node.opening_loc.nil?
                  bounds(node.location)
                  on_method_add_arg(on_fcall(message), on_arg_paren(arguments))
                else
                  bounds(node.location)
                  on_method_add_arg(on_fcall(message), on_args_new)
                end

              if block.nil?
                call
              else
                bounds(node.block.location)
                on_method_add_block(call, block)
              end
            end
          end
        else
          receiver = visit(node.receiver)

          bounds(node.call_operator_loc)
          call_operator = visit_token(node.call_operator)

          message =
            if node.message_loc.nil?
              :call
            else
              bounds(node.message_loc)
              visit_token(node.message, false)
            end

          if node.name.end_with?("=") && !node.message.end_with?("=") && !node.arguments.nil? && node.block.nil?
            value = visit_write_value(node.arguments.arguments.first)

            bounds(node.location)
            on_assign(on_field(receiver, call_operator, message), value)
          else
            arguments, block = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc || node.location))
            call =
              if node.opening_loc.nil?
                bounds(node.location)

                if node.arguments.nil? && !node.block.is_a?(BlockArgumentNode)
                  on_call(receiver, call_operator, message)
                else
                  on_command_call(receiver, call_operator, message, arguments)
                end
              else
                bounds(node.opening_loc)
                arguments = on_arg_paren(arguments)

                bounds(node.location)
                on_method_add_arg(on_call(receiver, call_operator, message), arguments)
              end

            if block.nil?
              call
            else
              bounds(node.block.location)
              on_method_add_block(call, block)
            end
          end
        end
      end

      # Visit the arguments and block of a call node and return the arguments
      # and block as they should be used.
      private def visit_call_node_arguments(arguments_node, block_node, trailing_comma)
        arguments = arguments_node&.arguments || []
        block = block_node

        if block.is_a?(BlockArgumentNode)
          arguments << block
          block = nil
        end

        [
          if arguments.length == 1 && arguments.first.is_a?(ForwardingArgumentsNode)
            visit(arguments.first)
          elsif arguments.any?
            args = visit_arguments(arguments)

            if block_node.is_a?(BlockArgumentNode) || arguments.last.is_a?(ForwardingArgumentsNode) || command?(arguments.last) || trailing_comma
              args
            else
              bounds(arguments.first.location)
              on_args_add_block(args, false)
            end
          end,
          visit(block)
        ]
      end

      # Returns true if the given node is a command node.
      private def command?(node)
        node.is_a?(CallNode) &&
          node.opening_loc.nil? &&
          (!node.arguments.nil? || node.block.is_a?(BlockArgumentNode)) &&
          !BINARY_OPERATORS.include?(node.name)
      end

      # foo.bar += baz
      # ^^^^^^^^^^^^^^^
      def visit_call_operator_write_node(node)
        receiver = visit(node.receiver)

        bounds(node.call_operator_loc)
        call_operator = visit_token(node.call_operator)

        bounds(node.message_loc)
        message = visit_token(node.message)

        bounds(node.location)
        target = on_field(receiver, call_operator, message)

        bounds(node.binary_operator_loc)
        operator = on_op("#{node.binary_operator}=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # foo.bar &&= baz
      # ^^^^^^^^^^^^^^^
      def visit_call_and_write_node(node)
        receiver = visit(node.receiver)

        bounds(node.call_operator_loc)
        call_operator = visit_token(node.call_operator)

        bounds(node.message_loc)
        message = visit_token(node.message)

        bounds(node.location)
        target = on_field(receiver, call_operator, message)

        bounds(node.operator_loc)
        operator = on_op("&&=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # foo.bar ||= baz
      # ^^^^^^^^^^^^^^^
      def visit_call_or_write_node(node)
        receiver = visit(node.receiver)

        bounds(node.call_operator_loc)
        call_operator = visit_token(node.call_operator)

        bounds(node.message_loc)
        message = visit_token(node.message)

        bounds(node.location)
        target = on_field(receiver, call_operator, message)

        bounds(node.operator_loc)
        operator = on_op("||=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # foo.bar, = 1
      # ^^^^^^^
      def visit_call_target_node(node)
        if node.call_operator == "::"
          receiver = visit(node.receiver)

          bounds(node.message_loc)
          message = visit_token(node.message)

          bounds(node.location)
          on_const_path_field(receiver, message)
        else
          receiver = visit(node.receiver)

          bounds(node.call_operator_loc)
          call_operator = visit_token(node.call_operator)

          bounds(node.message_loc)
          message = visit_token(node.message)

          bounds(node.location)
          on_field(receiver, call_operator, message)
        end
      end

      # foo => bar => baz
      #        ^^^^^^^^^^
      def visit_capture_pattern_node(node)
        value = visit(node.value)
        target = visit(node.target)

        bounds(node.location)
        on_binary(value, :"=>", target)
      end

      # case foo; when bar; end
      # ^^^^^^^^^^^^^^^^^^^^^^^
      def visit_case_node(node)
        predicate = visit(node.predicate)
        clauses =
          node.conditions.reverse_each.inject(visit(node.else_clause)) do |current, condition|
            on_when(*visit(condition), current)
          end

        bounds(node.location)
        on_case(predicate, clauses)
      end

      # case foo; in bar; end
      # ^^^^^^^^^^^^^^^^^^^^^
      def visit_case_match_node(node)
        predicate = visit(node.predicate)
        clauses =
          node.conditions.reverse_each.inject(visit(node.else_clause)) do |current, condition|
            on_in(*visit(condition), current)
          end

        bounds(node.location)
        on_case(predicate, clauses)
      end

      # class Foo; end
      # ^^^^^^^^^^^^^^
      def visit_class_node(node)
        constant_path =
          if node.constant_path.is_a?(ConstantReadNode)
            bounds(node.constant_path.location)
            on_const_ref(on_const(node.constant_path.name.to_s))
          else
            visit(node.constant_path)
          end

        superclass = visit(node.superclass)
        bodystmt = visit_body_node(node.superclass&.location || node.constant_path.location, node.body, node.superclass.nil?)

        bounds(node.location)
        on_class(constant_path, superclass, bodystmt)
      end

      # @@foo
      # ^^^^^
      def visit_class_variable_read_node(node)
        bounds(node.location)
        on_var_ref(on_cvar(node.slice))
      end

      # @@foo = 1
      # ^^^^^^^^^
      #
      # @@foo, @@bar = 1
      # ^^^^^  ^^^^^
      def visit_class_variable_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_cvar(node.name.to_s))
        value = visit_write_value(node.value)

        bounds(node.location)
        on_assign(target, value)
      end

      # @@foo += bar
      # ^^^^^^^^^^^^
      def visit_class_variable_operator_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_cvar(node.name.to_s))

        bounds(node.binary_operator_loc)
        operator = on_op("#{node.binary_operator}=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # @@foo &&= bar
      # ^^^^^^^^^^^^^
      def visit_class_variable_and_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_cvar(node.name.to_s))

        bounds(node.operator_loc)
        operator = on_op("&&=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # @@foo ||= bar
      # ^^^^^^^^^^^^^
      def visit_class_variable_or_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_cvar(node.name.to_s))

        bounds(node.operator_loc)
        operator = on_op("||=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # @@foo, = bar
      # ^^^^^
      def visit_class_variable_target_node(node)
        bounds(node.location)
        on_var_field(on_cvar(node.name.to_s))
      end

      # Foo
      # ^^^
      def visit_constant_read_node(node)
        bounds(node.location)
        on_var_ref(on_const(node.name.to_s))
      end

      # Foo = 1
      # ^^^^^^^
      #
      # Foo, Bar = 1
      # ^^^  ^^^
      def visit_constant_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_const(node.name.to_s))
        value = visit_write_value(node.value)

        bounds(node.location)
        on_assign(target, value)
      end

      # Foo += bar
      # ^^^^^^^^^^^
      def visit_constant_operator_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_const(node.name.to_s))

        bounds(node.binary_operator_loc)
        operator = on_op("#{node.binary_operator}=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # Foo &&= bar
      # ^^^^^^^^^^^^
      def visit_constant_and_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_const(node.name.to_s))

        bounds(node.operator_loc)
        operator = on_op("&&=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # Foo ||= bar
      # ^^^^^^^^^^^^
      def visit_constant_or_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_const(node.name.to_s))

        bounds(node.operator_loc)
        operator = on_op("||=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # Foo, = bar
      # ^^^
      def visit_constant_target_node(node)
        bounds(node.location)
        on_var_field(on_const(node.name.to_s))
      end

      # Foo::Bar
      # ^^^^^^^^
      def visit_constant_path_node(node)
        if node.parent.nil?
          bounds(node.name_loc)
          child = on_const(node.name.to_s)

          bounds(node.location)
          on_top_const_ref(child)
        else
          parent = visit(node.parent)

          bounds(node.name_loc)
          child = on_const(node.name.to_s)

          bounds(node.location)
          on_const_path_ref(parent, child)
        end
      end

      # Foo::Bar = 1
      # ^^^^^^^^^^^^
      #
      # Foo::Foo, Bar::Bar = 1
      # ^^^^^^^^  ^^^^^^^^
      def visit_constant_path_write_node(node)
        target = visit_constant_path_write_node_target(node.target)
        value = visit_write_value(node.value)

        bounds(node.location)
        on_assign(target, value)
      end

      # Visit a constant path that is part of a write node.
      private def visit_constant_path_write_node_target(node)
        if node.parent.nil?
          bounds(node.name_loc)
          child = on_const(node.name.to_s)

          bounds(node.location)
          on_top_const_field(child)
        else
          parent = visit(node.parent)

          bounds(node.name_loc)
          child = on_const(node.name.to_s)

          bounds(node.location)
          on_const_path_field(parent, child)
        end
      end

      # Foo::Bar += baz
      # ^^^^^^^^^^^^^^^
      def visit_constant_path_operator_write_node(node)
        target = visit_constant_path_write_node_target(node.target)
        value = visit(node.value)

        bounds(node.binary_operator_loc)
        operator = on_op("#{node.binary_operator}=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # Foo::Bar &&= baz
      # ^^^^^^^^^^^^^^^^
      def visit_constant_path_and_write_node(node)
        target = visit_constant_path_write_node_target(node.target)
        value = visit(node.value)

        bounds(node.operator_loc)
        operator = on_op("&&=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # Foo::Bar ||= baz
      # ^^^^^^^^^^^^^^^^
      def visit_constant_path_or_write_node(node)
        target = visit_constant_path_write_node_target(node.target)
        value = visit(node.value)

        bounds(node.operator_loc)
        operator = on_op("||=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # Foo::Bar, = baz
      # ^^^^^^^^
      def visit_constant_path_target_node(node)
        visit_constant_path_write_node_target(node)
      end

      # def foo; end
      # ^^^^^^^^^^^^
      #
      # def self.foo; end
      # ^^^^^^^^^^^^^^^^^
      def visit_def_node(node)
        receiver = visit(node.receiver)
        operator =
          if !node.operator_loc.nil?
            bounds(node.operator_loc)
            visit_token(node.operator)
          end

        bounds(node.name_loc)
        name = visit_token(node.name_loc.slice)

        parameters =
          if node.parameters.nil?
            bounds(node.location)
            on_params(nil, nil, nil, nil, nil, nil, nil)
          else
            visit(node.parameters)
          end

        if !node.lparen_loc.nil?
          bounds(node.lparen_loc)
          parameters = on_paren(parameters)
        end

        bodystmt =
          if node.equal_loc.nil?
            visit_body_node(node.rparen_loc || node.end_keyword_loc, node.body)
          else
            body = visit(node.body.body.first)

            bounds(node.body.location)
            on_bodystmt(body, nil, nil, nil)
          end

        bounds(node.location)
        if receiver.nil?
          on_def(name, parameters, bodystmt)
        else
          on_defs(receiver, operator, name, parameters, bodystmt)
        end
      end

      # defined? a
      # ^^^^^^^^^^
      #
      # defined?(a)
      # ^^^^^^^^^^^
      def visit_defined_node(node)
        expression = visit(node.value)

        # Very weird circumstances here where something like:
        #
        #     defined?
        #     (1)
        #
        # gets parsed in Ruby as having only the `1` expression but in Ripper it
        # gets parsed as having a parentheses node. In this case we need to
        # synthesize that node to match Ripper's behavior.
        if node.lparen_loc && node.keyword_loc.join(node.lparen_loc).slice.include?("\n")
          bounds(node.lparen_loc.join(node.rparen_loc))
          expression = on_paren(on_stmts_add(on_stmts_new, expression))
        end

        bounds(node.location)
        on_defined(expression)
      end

      # if foo then bar else baz end
      #                 ^^^^^^^^^^^^
      def visit_else_node(node)
        statements =
          if node.statements.nil?
            [nil]
          else
            body = node.statements.body
            body.unshift(nil) if void_stmt?(node.else_keyword_loc, node.statements.body[0].location, false)
            body
          end

        bounds(node.location)
        on_else(visit_statements_node_body(statements))
      end

      # "foo #{bar}"
      #      ^^^^^^
      def visit_embedded_statements_node(node)
        bounds(node.opening_loc)
        on_embexpr_beg(node.opening)

        statements =
          if node.statements.nil?
            bounds(node.location)
            on_stmts_add(on_stmts_new, on_void_stmt)
          else
            visit(node.statements)
          end

        bounds(node.closing_loc)
        on_embexpr_end(node.closing)

        bounds(node.location)
        on_string_embexpr(statements)
      end

      # "foo #@bar"
      #      ^^^^^
      def visit_embedded_variable_node(node)
        bounds(node.operator_loc)
        on_embvar(node.operator)

        variable = visit(node.variable)

        bounds(node.location)
        on_string_dvar(variable)
      end

      # Visit an EnsureNode node.
      def visit_ensure_node(node)
        statements =
          if node.statements.nil?
            [nil]
          else
            body = node.statements.body
            body.unshift(nil) if void_stmt?(node.ensure_keyword_loc, body[0].location, false)
            body
          end

        statements = visit_statements_node_body(statements)

        bounds(node.location)
        on_ensure(statements)
      end

      # false
      # ^^^^^
      def visit_false_node(node)
        bounds(node.location)
        on_var_ref(on_kw("false"))
      end

      # foo => [*, bar, *]
      #        ^^^^^^^^^^^
      def visit_find_pattern_node(node)
        constant = visit(node.constant)
        left =
          if node.left.expression.nil?
            bounds(node.left.location)
            on_var_field(nil)
          else
            visit(node.left.expression)
          end

        requireds = visit_all(node.requireds) if node.requireds.any?
        right =
          if node.right.expression.nil?
            bounds(node.right.location)
            on_var_field(nil)
          else
            visit(node.right.expression)
          end

        bounds(node.location)
        on_fndptn(constant, left, requireds, right)
      end

      # if foo .. bar; end
      #    ^^^^^^^^^^
      def visit_flip_flop_node(node)
        left = visit(node.left)
        right = visit(node.right)

        bounds(node.location)
        if node.exclude_end?
          on_dot3(left, right)
        else
          on_dot2(left, right)
        end
      end

      # 1.0
      # ^^^
      def visit_float_node(node)
        visit_number_node(node) { |text| on_float(text) }
      end

      # for foo in bar do end
      # ^^^^^^^^^^^^^^^^^^^^^
      def visit_for_node(node)
        index = visit(node.index)
        collection = visit(node.collection)
        statements =
          if node.statements.nil?
            bounds(node.location)
            on_stmts_add(on_stmts_new, on_void_stmt)
          else
            visit(node.statements)
          end

        bounds(node.location)
        on_for(index, collection, statements)
      end

      # def foo(...); bar(...); end
      #                   ^^^
      def visit_forwarding_arguments_node(node)
        bounds(node.location)
        on_args_forward
      end

      # def foo(...); end
      #         ^^^
      def visit_forwarding_parameter_node(node)
        bounds(node.location)
        on_args_forward
      end

      # super
      # ^^^^^
      #
      # super {}
      # ^^^^^^^^
      def visit_forwarding_super_node(node)
        if node.block.nil?
          bounds(node.location)
          on_zsuper
        else
          block = visit(node.block)

          bounds(node.location)
          on_method_add_block(on_zsuper, block)
        end
      end

      # $foo
      # ^^^^
      def visit_global_variable_read_node(node)
        bounds(node.location)
        on_var_ref(on_gvar(node.name.to_s))
      end

      # $foo = 1
      # ^^^^^^^^
      #
      # $foo, $bar = 1
      # ^^^^  ^^^^
      def visit_global_variable_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_gvar(node.name.to_s))
        value = visit_write_value(node.value)

        bounds(node.location)
        on_assign(target, value)
      end

      # $foo += bar
      # ^^^^^^^^^^^
      def visit_global_variable_operator_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_gvar(node.name.to_s))

        bounds(node.binary_operator_loc)
        operator = on_op("#{node.binary_operator}=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # $foo &&= bar
      # ^^^^^^^^^^^^
      def visit_global_variable_and_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_gvar(node.name.to_s))

        bounds(node.operator_loc)
        operator = on_op("&&=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # $foo ||= bar
      # ^^^^^^^^^^^^
      def visit_global_variable_or_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_gvar(node.name.to_s))

        bounds(node.operator_loc)
        operator = on_op("||=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # $foo, = bar
      # ^^^^
      def visit_global_variable_target_node(node)
        bounds(node.location)
        on_var_field(on_gvar(node.name.to_s))
      end

      # {}
      # ^^
      def visit_hash_node(node)
        elements =
          if node.elements.any?
            args = visit_all(node.elements)

            bounds(node.elements.first.location)
            on_assoclist_from_args(args)
          end

        bounds(node.location)
        on_hash(elements)
      end

      # foo => {}
      #        ^^
      def visit_hash_pattern_node(node)
        constant = visit(node.constant)
        elements =
          if node.elements.any? || !node.rest.nil?
            node.elements.map do |element|
              [
                if (key = element.key).opening_loc.nil?
                  visit(key)
                else
                  bounds(key.value_loc)
                  if (value = key.value).empty?
                    on_string_content
                  else
                    on_string_add(on_string_content, on_tstring_content(value))
                  end
                end,
                visit(element.value)
              ]
            end
          end

        rest =
          case node.rest
          when AssocSplatNode
            visit(node.rest.value)
          when NoKeywordsParameterNode
            bounds(node.rest.location)
            on_var_field(visit(node.rest))
          end

        bounds(node.location)
        on_hshptn(constant, elements, rest)
      end

      # if foo then bar end
      # ^^^^^^^^^^^^^^^^^^^
      #
      # bar if foo
      # ^^^^^^^^^^
      #
      # foo ? bar : baz
      # ^^^^^^^^^^^^^^^
      def visit_if_node(node)
        if node.then_keyword == "?"
          predicate = visit(node.predicate)
          truthy = visit(node.statements.body.first)
          falsy = visit(node.subsequent.statements.body.first)

          bounds(node.location)
          on_ifop(predicate, truthy, falsy)
        elsif node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset)
          predicate = visit(node.predicate)
          statements =
            if node.statements.nil?
              bounds(node.location)
              on_stmts_add(on_stmts_new, on_void_stmt)
            else
              visit(node.statements)
            end
          subsequent = visit(node.subsequent)

          bounds(node.location)
          if node.if_keyword == "if"
            on_if(predicate, statements, subsequent)
          else
            on_elsif(predicate, statements, subsequent)
          end
        else
          statements = visit(node.statements.body.first)
          predicate = visit(node.predicate)

          bounds(node.location)
          on_if_mod(predicate, statements)
        end
      end

      # 1i
      # ^^
      def visit_imaginary_node(node)
        visit_number_node(node) { |text| on_imaginary(text) }
      end

      # { foo: }
      #   ^^^^
      def visit_implicit_node(node)
      end

      # foo { |bar,| }
      #           ^
      def visit_implicit_rest_node(node)
        bounds(node.location)
        on_excessed_comma
      end

      # case foo; in bar; end
      # ^^^^^^^^^^^^^^^^^^^^^
      def visit_in_node(node)
        # This is a special case where we're not going to call on_in directly
        # because we don't have access to the subsequent. Instead, we'll return
        # the component parts and let the parent node handle it.
        pattern = visit_pattern_node(node.pattern)
        statements =
          if node.statements.nil?
            bounds(node.location)
            on_stmts_add(on_stmts_new, on_void_stmt)
          else
            visit(node.statements)
          end

        [pattern, statements]
      end

      # foo[bar] += baz
      # ^^^^^^^^^^^^^^^
      def visit_index_operator_write_node(node)
        receiver = visit(node.receiver)
        arguments, _ = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))

        bounds(node.location)
        target = on_aref_field(receiver, arguments)

        bounds(node.binary_operator_loc)
        operator = on_op("#{node.binary_operator}=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # foo[bar] &&= baz
      # ^^^^^^^^^^^^^^^^
      def visit_index_and_write_node(node)
        receiver = visit(node.receiver)
        arguments, _ = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))

        bounds(node.location)
        target = on_aref_field(receiver, arguments)

        bounds(node.operator_loc)
        operator = on_op("&&=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # foo[bar] ||= baz
      # ^^^^^^^^^^^^^^^^
      def visit_index_or_write_node(node)
        receiver = visit(node.receiver)
        arguments, _ = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))

        bounds(node.location)
        target = on_aref_field(receiver, arguments)

        bounds(node.operator_loc)
        operator = on_op("||=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # foo[bar], = 1
      # ^^^^^^^^
      def visit_index_target_node(node)
        receiver = visit(node.receiver)
        arguments, _ = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))

        bounds(node.location)
        on_aref_field(receiver, arguments)
      end

      # @foo
      # ^^^^
      def visit_instance_variable_read_node(node)
        bounds(node.location)
        on_var_ref(on_ivar(node.name.to_s))
      end

      # @foo = 1
      # ^^^^^^^^
      def visit_instance_variable_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_ivar(node.name.to_s))
        value = visit_write_value(node.value)

        bounds(node.location)
        on_assign(target, value)
      end

      # @foo += bar
      # ^^^^^^^^^^^
      def visit_instance_variable_operator_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_ivar(node.name.to_s))

        bounds(node.binary_operator_loc)
        operator = on_op("#{node.binary_operator}=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # @foo &&= bar
      # ^^^^^^^^^^^^
      def visit_instance_variable_and_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_ivar(node.name.to_s))

        bounds(node.operator_loc)
        operator = on_op("&&=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # @foo ||= bar
      # ^^^^^^^^^^^^
      def visit_instance_variable_or_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_ivar(node.name.to_s))

        bounds(node.operator_loc)
        operator = on_op("||=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # @foo, = bar
      # ^^^^
      def visit_instance_variable_target_node(node)
        bounds(node.location)
        on_var_field(on_ivar(node.name.to_s))
      end

      # 1
      # ^
      def visit_integer_node(node)
        visit_number_node(node) { |text| on_int(text) }
      end

      # if /foo #{bar}/ then end
      #    ^^^^^^^^^^^^
      def visit_interpolated_match_last_line_node(node)
        bounds(node.opening_loc)
        on_regexp_beg(node.opening)

        bounds(node.parts.first.location)
        parts =
          node.parts.inject(on_regexp_new) do |content, part|
            on_regexp_add(content, visit_string_content(part))
          end

        bounds(node.closing_loc)
        closing = on_regexp_end(node.closing)

        bounds(node.location)
        on_regexp_literal(parts, closing)
      end

      # /foo #{bar}/
      # ^^^^^^^^^^^^
      def visit_interpolated_regular_expression_node(node)
        bounds(node.opening_loc)
        on_regexp_beg(node.opening)

        bounds(node.parts.first.location)
        parts =
          node.parts.inject(on_regexp_new) do |content, part|
            on_regexp_add(content, visit_string_content(part))
          end

        bounds(node.closing_loc)
        closing = on_regexp_end(node.closing)

        bounds(node.location)
        on_regexp_literal(parts, closing)
      end

      # "foo #{bar}"
      # ^^^^^^^^^^^^
      def visit_interpolated_string_node(node)
        if node.opening&.start_with?("<<~")
          heredoc = visit_heredoc_string_node(node)

          bounds(node.location)
          on_string_literal(heredoc)
        elsif !node.heredoc? && node.parts.length > 1 && node.parts.any? { |part| (part.is_a?(StringNode) || part.is_a?(InterpolatedStringNode)) && !part.opening_loc.nil? }
          first, *rest = node.parts
          rest.inject(visit(first)) do |content, part|
            concat = visit(part)

            bounds(part.location)
            on_string_concat(content, concat)
          end
        else
          bounds(node.parts.first.location)
          parts =
            node.parts.inject(on_string_content) do |content, part|
              on_string_add(content, visit_string_content(part))
            end

          bounds(node.location)
          on_string_literal(parts)
        end
      end

      # :"foo #{bar}"
      # ^^^^^^^^^^^^^
      def visit_interpolated_symbol_node(node)
        bounds(node.parts.first.location)
        parts =
          node.parts.inject(on_string_content) do |content, part|
            on_string_add(content, visit_string_content(part))
          end

        bounds(node.location)
        on_dyna_symbol(parts)
      end

      # `foo #{bar}`
      # ^^^^^^^^^^^^
      def visit_interpolated_x_string_node(node)
        if node.opening.start_with?("<<~")
          heredoc = visit_heredoc_x_string_node(node)

          bounds(node.location)
          on_xstring_literal(heredoc)
        else
          bounds(node.parts.first.location)
          parts =
            node.parts.inject(on_xstring_new) do |content, part|
              on_xstring_add(content, visit_string_content(part))
            end

          bounds(node.location)
          on_xstring_literal(parts)
        end
      end

      # Visit an individual part of a string-like node.
      private def visit_string_content(part)
        if part.is_a?(StringNode)
          bounds(part.content_loc)
          on_tstring_content(part.content)
        else
          visit(part)
        end
      end

      # -> { it }
      #      ^^
      def visit_it_local_variable_read_node(node)
        bounds(node.location)
        on_vcall(on_ident(node.slice))
      end

      # -> { it }
      # ^^^^^^^^^
      def visit_it_parameters_node(node)
      end

      # foo(bar: baz)
      #     ^^^^^^^^
      def visit_keyword_hash_node(node)
        elements = visit_all(node.elements)

        bounds(node.location)
        on_bare_assoc_hash(elements)
      end

      # def foo(**bar); end
      #         ^^^^^
      #
      # def foo(**); end
      #         ^^
      def visit_keyword_rest_parameter_node(node)
        if node.name_loc.nil?
          bounds(node.location)
          on_kwrest_param(nil)
        else
          bounds(node.name_loc)
          name = on_ident(node.name.to_s)

          bounds(node.location)
          on_kwrest_param(name)
        end
      end

      # -> {}
      def visit_lambda_node(node)
        bounds(node.operator_loc)
        on_tlambda(node.operator)

        parameters =
          if node.parameters.is_a?(BlockParametersNode)
            # Ripper does not track block-locals within lambdas, so we skip
            # directly to the parameters here.
            params =
              if node.parameters.parameters.nil?
                bounds(node.location)
                on_params(nil, nil, nil, nil, nil, nil, nil)
              else
                visit(node.parameters.parameters)
              end

            if node.parameters.opening_loc.nil?
              params
            else
              bounds(node.parameters.opening_loc)
              on_paren(params)
            end
          else
            bounds(node.location)
            on_params(nil, nil, nil, nil, nil, nil, nil)
          end

        braces = node.opening == "{"
        if braces
          bounds(node.opening_loc)
          on_tlambeg(node.opening)
        end

        body =
          case node.body
          when nil
            bounds(node.location)
            stmts = on_stmts_add(on_stmts_new, on_void_stmt)

            bounds(node.location)
            braces ? stmts : on_bodystmt(stmts, nil, nil, nil)
          when StatementsNode
            stmts = node.body.body
            stmts.unshift(nil) if void_stmt?(node.parameters&.location || node.opening_loc, node.body.location, false)
            stmts = visit_statements_node_body(stmts)

            bounds(node.body.location)
            braces ? stmts : on_bodystmt(stmts, nil, nil, nil)
          when BeginNode
            visit_body_node(node.opening_loc, node.body)
          else
            raise
          end

        bounds(node.location)
        on_lambda(parameters, body)
      end

      # foo
      # ^^^
      def visit_local_variable_read_node(node)
        bounds(node.location)
        on_var_ref(on_ident(node.slice))
      end

      # foo = 1
      # ^^^^^^^
      def visit_local_variable_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_ident(node.name_loc.slice))
        value = visit_write_value(node.value)

        bounds(node.location)
        on_assign(target, value)
      end

      # foo += bar
      # ^^^^^^^^^^
      def visit_local_variable_operator_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_ident(node.name_loc.slice))

        bounds(node.binary_operator_loc)
        operator = on_op("#{node.binary_operator}=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # foo &&= bar
      # ^^^^^^^^^^^
      def visit_local_variable_and_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_ident(node.name_loc.slice))

        bounds(node.operator_loc)
        operator = on_op("&&=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # foo ||= bar
      # ^^^^^^^^^^^
      def visit_local_variable_or_write_node(node)
        bounds(node.name_loc)
        target = on_var_field(on_ident(node.name_loc.slice))

        bounds(node.operator_loc)
        operator = on_op("||=")
        value = visit_write_value(node.value)

        bounds(node.location)
        on_opassign(target, operator, value)
      end

      # foo, = bar
      # ^^^
      def visit_local_variable_target_node(node)
        bounds(node.location)
        on_var_field(on_ident(node.name.to_s))
      end

      # if /foo/ then end
      #    ^^^^^
      def visit_match_last_line_node(node)
        bounds(node.opening_loc)
        on_regexp_beg(node.opening)

        bounds(node.content_loc)
        tstring_content = on_tstring_content(node.content)

        bounds(node.closing_loc)
        closing = on_regexp_end(node.closing)

        on_regexp_literal(on_regexp_add(on_regexp_new, tstring_content), closing)
      end

      # foo in bar
      # ^^^^^^^^^^
      def visit_match_predicate_node(node)
        value = visit(node.value)
        pattern = on_in(visit_pattern_node(node.pattern), nil, nil)

        on_case(value, pattern)
      end

      # foo => bar
      # ^^^^^^^^^^
      def visit_match_required_node(node)
        value = visit(node.value)
        pattern = on_in(visit_pattern_node(node.pattern), nil, nil)

        on_case(value, pattern)
      end

      # /(?foo)/ =~ bar
      # ^^^^^^^^^^^^^^^^^^^^
      def visit_match_write_node(node)
        visit(node.call)
      end

      # A node that is missing from the syntax tree. This is only used in the
      # case of a syntax error.
      def visit_missing_node(node)
        raise "Cannot visit missing nodes directly."
      end

      # module Foo; end
      # ^^^^^^^^^^^^^^^
      def visit_module_node(node)
        constant_path =
          if node.constant_path.is_a?(ConstantReadNode)
            bounds(node.constant_path.location)
            on_const_ref(on_const(node.constant_path.name.to_s))
          else
            visit(node.constant_path)
          end

        bodystmt = visit_body_node(node.constant_path.location, node.body, true)

        bounds(node.location)
        on_module(constant_path, bodystmt)
      end

      # (foo, bar), bar = qux
      # ^^^^^^^^^^
      def visit_multi_target_node(node)
        bounds(node.location)
        targets = visit_multi_target_node_targets(node.lefts, node.rest, node.rights, true)

        if node.lparen_loc.nil?
          targets
        else
          bounds(node.lparen_loc)
          on_mlhs_paren(targets)
        end
      end

      # Visit the targets of a multi-target node.
      private def visit_multi_target_node_targets(lefts, rest, rights, skippable)
        if skippable && lefts.length == 1 && lefts.first.is_a?(MultiTargetNode) && rest.nil? && rights.empty?
          return visit(lefts.first)
        end

        mlhs = on_mlhs_new

        lefts.each do |left|
          bounds(left.location)
          mlhs = on_mlhs_add(mlhs, visit(left))
        end

        case rest
        when nil
          # do nothing
        when ImplicitRestNode
          # these do not get put into the generated tree
          bounds(rest.location)
          on_excessed_comma
        else
          bounds(rest.location)
          mlhs = on_mlhs_add_star(mlhs, visit(rest))
        end

        if rights.any?
          bounds(rights.first.location)
          post = on_mlhs_new

          rights.each do |right|
            bounds(right.location)
            post = on_mlhs_add(post, visit(right))
          end

          mlhs = on_mlhs_add_post(mlhs, post)
        end

        mlhs
      end

      # foo, bar = baz
      # ^^^^^^^^^^^^^^
      def visit_multi_write_node(node)
        bounds(node.location)
        targets = visit_multi_target_node_targets(node.lefts, node.rest, node.rights, true)

        unless node.lparen_loc.nil?
          bounds(node.lparen_loc)
          targets = on_mlhs_paren(targets)
        end

        value = visit_write_value(node.value)

        bounds(node.location)
        on_massign(targets, value)
      end

      # next
      # ^^^^
      #
      # next foo
      # ^^^^^^^^
      def visit_next_node(node)
        if node.arguments.nil?
          bounds(node.location)
          on_next(on_args_new)
        else
          arguments = visit(node.arguments)

          bounds(node.location)
          on_next(arguments)
        end
      end

      # nil
      # ^^^
      def visit_nil_node(node)
        bounds(node.location)
        on_var_ref(on_kw("nil"))
      end

      # def foo(**nil); end
      #         ^^^^^
      def visit_no_keywords_parameter_node(node)
        bounds(node.location)
        on_nokw_param(nil)

        :nil
      end

      # -> { _1 + _2 }
      # ^^^^^^^^^^^^^^
      def visit_numbered_parameters_node(node)
      end

      # $1
      # ^^
      def visit_numbered_reference_read_node(node)
        bounds(node.location)
        on_backref(node.slice)
      end

      # def foo(bar: baz); end
      #         ^^^^^^^^
      def visit_optional_keyword_parameter_node(node)
        bounds(node.name_loc)
        name = on_label("#{node.name}:")
        value = visit(node.value)

        [name, value]
      end

      # def foo(bar = 1); end
      #         ^^^^^^^
      def visit_optional_parameter_node(node)
        bounds(node.name_loc)
        name = visit_token(node.name.to_s)
        value = visit(node.value)

        [name, value]
      end

      # a or b
      # ^^^^^^
      def visit_or_node(node)
        left = visit(node.left)
        right = visit(node.right)

        bounds(node.location)
        on_binary(left, node.operator.to_sym, right)
      end

      # def foo(bar, *baz); end
      #         ^^^^^^^^^
      def visit_parameters_node(node)
        requireds = node.requireds.map { |required| required.is_a?(MultiTargetNode) ? visit_destructured_parameter_node(required) : visit(required) } if node.requireds.any?
        optionals = visit_all(node.optionals) if node.optionals.any?
        rest = visit(node.rest)
        posts = node.posts.map { |post| post.is_a?(MultiTargetNode) ? visit_destructured_parameter_node(post) : visit(post) } if node.posts.any?
        keywords = visit_all(node.keywords) if node.keywords.any?
        keyword_rest = visit(node.keyword_rest)
        block = visit(node.block)

        bounds(node.location)
        on_params(requireds, optionals, rest, posts, keywords, keyword_rest, block)
      end

      # Visit a destructured positional parameter node.
      private def visit_destructured_parameter_node(node)
        bounds(node.location)
        targets = visit_multi_target_node_targets(node.lefts, node.rest, node.rights, false)

        bounds(node.lparen_loc)
        on_mlhs_paren(targets)
      end

      # ()
      # ^^
      #
      # (1)
      # ^^^
      def visit_parentheses_node(node)
        body =
          if node.body.nil?
            on_stmts_add(on_stmts_new, on_void_stmt)
          else
            visit(node.body)
          end

        bounds(node.location)
        on_paren(body)
      end

      # foo => ^(bar)
      #        ^^^^^^
      def visit_pinned_expression_node(node)
        expression = visit(node.expression)

        bounds(node.location)
        on_begin(expression)
      end

      # foo = 1 and bar => ^foo
      #                    ^^^^
      def visit_pinned_variable_node(node)
        visit(node.variable)
      end

      # END {}
      # ^^^^^^
      def visit_post_execution_node(node)
        statements =
          if node.statements.nil?
            bounds(node.location)
            on_stmts_add(on_stmts_new, on_void_stmt)
          else
            visit(node.statements)
          end

        bounds(node.location)
        on_END(statements)
      end

      # BEGIN {}
      # ^^^^^^^^
      def visit_pre_execution_node(node)
        statements =
          if node.statements.nil?
            bounds(node.location)
            on_stmts_add(on_stmts_new, on_void_stmt)
          else
            visit(node.statements)
          end

        bounds(node.location)
        on_BEGIN(statements)
      end

      # The top-level program node.
      def visit_program_node(node)
        body = node.statements.body
        body << nil if body.empty?
        statements = visit_statements_node_body(body)

        bounds(node.location)
        on_program(statements)
      end

      # 0..5
      # ^^^^
      def visit_range_node(node)
        left = visit(node.left)
        right = visit(node.right)

        bounds(node.location)
        if node.exclude_end?
          on_dot3(left, right)
        else
          on_dot2(left, right)
        end
      end

      # 1r
      # ^^
      def visit_rational_node(node)
        visit_number_node(node) { |text| on_rational(text) }
      end

      # redo
      # ^^^^
      def visit_redo_node(node)
        bounds(node.location)
        on_redo
      end

      # /foo/
      # ^^^^^
      def visit_regular_expression_node(node)
        bounds(node.opening_loc)
        on_regexp_beg(node.opening)

        if node.content.empty?
          bounds(node.closing_loc)
          closing = on_regexp_end(node.closing)

          on_regexp_literal(on_regexp_new, closing)
        else
          bounds(node.content_loc)
          tstring_content = on_tstring_content(node.content)

          bounds(node.closing_loc)
          closing = on_regexp_end(node.closing)

          on_regexp_literal(on_regexp_add(on_regexp_new, tstring_content), closing)
        end
      end

      # def foo(bar:); end
      #         ^^^^
      def visit_required_keyword_parameter_node(node)
        bounds(node.name_loc)
        [on_label("#{node.name}:"), false]
      end

      # def foo(bar); end
      #         ^^^
      def visit_required_parameter_node(node)
        bounds(node.location)
        on_ident(node.name.to_s)
      end

      # foo rescue bar
      # ^^^^^^^^^^^^^^
      def visit_rescue_modifier_node(node)
        expression = visit_write_value(node.expression)
        rescue_expression = visit(node.rescue_expression)

        bounds(node.location)
        on_rescue_mod(expression, rescue_expression)
      end

      # begin; rescue; end
      #        ^^^^^^^
      def visit_rescue_node(node)
        exceptions =
          case node.exceptions.length
          when 0
            nil
          when 1
            if (exception = node.exceptions.first).is_a?(SplatNode)
              bounds(exception.location)
              on_mrhs_add_star(on_mrhs_new, visit(exception))
            else
              [visit(node.exceptions.first)]
            end
          else
            bounds(node.location)
            length = node.exceptions.length

            node.exceptions.each_with_index.inject(on_args_new) do |mrhs, (exception, index)|
              arg = visit(exception)

              bounds(exception.location)
              mrhs = on_mrhs_new_from_args(mrhs) if index == length - 1

              if exception.is_a?(SplatNode)
                if index == length - 1
                  on_mrhs_add_star(mrhs, arg)
                else
                  on_args_add_star(mrhs, arg)
                end
              else
                if index == length - 1
                  on_mrhs_add(mrhs, arg)
                else
                  on_args_add(mrhs, arg)
                end
              end
            end
          end

        reference = visit(node.reference)
        statements =
          if node.statements.nil?
            bounds(node.location)
            on_stmts_add(on_stmts_new, on_void_stmt)
          else
            visit(node.statements)
          end

        subsequent = visit(node.subsequent)

        bounds(node.location)
        on_rescue(exceptions, reference, statements, subsequent)
      end

      # def foo(*bar); end
      #         ^^^^
      #
      # def foo(*); end
      #         ^
      def visit_rest_parameter_node(node)
        if node.name_loc.nil?
          bounds(node.location)
          on_rest_param(nil)
        else
          bounds(node.name_loc)
          on_rest_param(visit_token(node.name.to_s))
        end
      end

      # retry
      # ^^^^^
      def visit_retry_node(node)
        bounds(node.location)
        on_retry
      end

      # return
      # ^^^^^^
      #
      # return 1
      # ^^^^^^^^
      def visit_return_node(node)
        if node.arguments.nil?
          bounds(node.location)
          on_return0
        else
          arguments = visit(node.arguments)

          bounds(node.location)
          on_return(arguments)
        end
      end

      # self
      # ^^^^
      def visit_self_node(node)
        bounds(node.location)
        on_var_ref(on_kw("self"))
      end

      # A shareable constant.
      def visit_shareable_constant_node(node)
        visit(node.write)
      end

      # class << self; end
      # ^^^^^^^^^^^^^^^^^^
      def visit_singleton_class_node(node)
        expression = visit(node.expression)
        bodystmt = visit_body_node(node.body&.location || node.end_keyword_loc, node.body)

        bounds(node.location)
        on_sclass(expression, bodystmt)
      end

      # __ENCODING__
      # ^^^^^^^^^^^^
      def visit_source_encoding_node(node)
        bounds(node.location)
        on_var_ref(on_kw("__ENCODING__"))
      end

      # __FILE__
      # ^^^^^^^^
      def visit_source_file_node(node)
        bounds(node.location)
        on_var_ref(on_kw("__FILE__"))
      end

      # __LINE__
      # ^^^^^^^^
      def visit_source_line_node(node)
        bounds(node.location)
        on_var_ref(on_kw("__LINE__"))
      end

      # foo(*bar)
      #     ^^^^
      #
      # def foo((bar, *baz)); end
      #               ^^^^
      #
      # def foo(*); bar(*); end
      #                 ^
      def visit_splat_node(node)
        visit(node.expression)
      end

      # A list of statements.
      def visit_statements_node(node)
        bounds(node.location)
        visit_statements_node_body(node.body)
      end

      # Visit the list of statements of a statements node. We support nil
      # statements in the list. This would normally not be allowed by the
      # structure of the prism parse tree, but we manually add them here so that
      # we can mirror Ripper's void stmt.
      private def visit_statements_node_body(body)
        body.inject(on_stmts_new) do |stmts, stmt|
          on_stmts_add(stmts, stmt.nil? ? on_void_stmt : visit(stmt))
        end
      end

      # "foo"
      # ^^^^^
      def visit_string_node(node)
        if (content = node.content).empty?
          bounds(node.location)
          on_string_literal(on_string_content)
        elsif (opening = node.opening) == "?"
          bounds(node.location)
          on_CHAR("?#{node.content}")
        elsif opening.start_with?("<<~")
          heredoc = visit_heredoc_string_node(node.to_interpolated)

          bounds(node.location)
          on_string_literal(heredoc)
        else
          bounds(node.content_loc)
          tstring_content = on_tstring_content(content)

          bounds(node.location)
          on_string_literal(on_string_add(on_string_content, tstring_content))
        end
      end

      # Ripper gives back the escaped string content but strips out the common
      # leading whitespace. Prism gives back the unescaped string content and
      # a location for the escaped string content. Unfortunately these don't
      # work well together, so here we need to re-derive the common leading
      # whitespace.
      private def visit_heredoc_node_whitespace(parts)
        common_whitespace = nil
        dedent_next = true

        parts.each do |part|
          if part.is_a?(StringNode)
            if dedent_next && !(content = part.content).chomp.empty?
              common_whitespace = [
                common_whitespace || Float::INFINITY,
                content[/\A\s*/].each_char.inject(0) do |part_whitespace, char|
                  char == "\t" ? ((part_whitespace / 8 + 1) * 8) : (part_whitespace + 1)
                end
              ].min
            end

            dedent_next = true
          else
            dedent_next = false
          end
        end

        common_whitespace || 0
      end

      # Visit a string that is expressed using a <<~ heredoc.
      private def visit_heredoc_node(parts, base)
        common_whitespace = visit_heredoc_node_whitespace(parts)

        if common_whitespace == 0
          bounds(parts.first.location)

          string = []
          result = base

          parts.each do |part|
            if part.is_a?(StringNode)
              if string.empty?
                string = [part]
              else
                string << part
              end
            else
              unless string.empty?
                bounds(string[0].location)
                result = yield result, on_tstring_content(string.map(&:content).join)
                string = []
              end

              result = yield result, visit(part)
            end
          end

          unless string.empty?
            bounds(string[0].location)
            result = yield result, on_tstring_content(string.map(&:content).join)
          end

          result
        else
          bounds(parts.first.location)
          result =
            parts.inject(base) do |string_content, part|
              yield string_content, visit_string_content(part)
            end

          bounds(parts.first.location)
          on_heredoc_dedent(result, common_whitespace)
        end
      end

      # Visit a heredoc node that is representing a string.
      private def visit_heredoc_string_node(node)
        bounds(node.opening_loc)
        on_heredoc_beg(node.opening)

        bounds(node.location)
        result =
          visit_heredoc_node(node.parts, on_string_content) do |parts, part|
            on_string_add(parts, part)
          end

        bounds(node.closing_loc)
        on_heredoc_end(node.closing)

        result
      end

      # Visit a heredoc node that is representing an xstring.
      private def visit_heredoc_x_string_node(node)
        bounds(node.opening_loc)
        on_heredoc_beg(node.opening)

        bounds(node.location)
        result =
          visit_heredoc_node(node.parts, on_xstring_new) do |parts, part|
            on_xstring_add(parts, part)
          end

        bounds(node.closing_loc)
        on_heredoc_end(node.closing)

        result
      end

      # super(foo)
      # ^^^^^^^^^^
      def visit_super_node(node)
        arguments, block = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.rparen_loc || node.location))

        if !node.lparen_loc.nil?
          bounds(node.lparen_loc)
          arguments = on_arg_paren(arguments)
        end

        bounds(node.location)
        call = on_super(arguments)

        if block.nil?
          call
        else
          bounds(node.block.location)
          on_method_add_block(call, block)
        end
      end

      # :foo
      # ^^^^
      def visit_symbol_node(node)
        if (opening = node.opening)&.match?(/^%s|['"]:?$/)
          bounds(node.value_loc)
          content = on_string_content

          if !(value = node.value).empty?
            content = on_string_add(content, on_tstring_content(value))
          end

          on_dyna_symbol(content)
        elsif (closing = node.closing) == ":"
          bounds(node.location)
          on_label("#{node.value}:")
        elsif opening.nil? && node.closing_loc.nil?
          bounds(node.value_loc)
          on_symbol_literal(visit_token(node.value))
        else
          bounds(node.value_loc)
          on_symbol_literal(on_symbol(visit_token(node.value)))
        end
      end

      # true
      # ^^^^
      def visit_true_node(node)
        bounds(node.location)
        on_var_ref(on_kw("true"))
      end

      # undef foo
      # ^^^^^^^^^
      def visit_undef_node(node)
        names = visit_all(node.names)

        bounds(node.location)
        on_undef(names)
      end

      # unless foo; bar end
      # ^^^^^^^^^^^^^^^^^^^
      #
      # bar unless foo
      # ^^^^^^^^^^^^^^
      def visit_unless_node(node)
        if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset)
          predicate = visit(node.predicate)
          statements =
            if node.statements.nil?
              bounds(node.location)
              on_stmts_add(on_stmts_new, on_void_stmt)
            else
              visit(node.statements)
            end
          else_clause = visit(node.else_clause)

          bounds(node.location)
          on_unless(predicate, statements, else_clause)
        else
          statements = visit(node.statements.body.first)
          predicate = visit(node.predicate)

          bounds(node.location)
          on_unless_mod(predicate, statements)
        end
      end

      # until foo; bar end
      # ^^^^^^^^^^^^^^^^^
      #
      # bar until foo
      # ^^^^^^^^^^^^^
      def visit_until_node(node)
        if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset)
          predicate = visit(node.predicate)
          statements =
            if node.statements.nil?
              bounds(node.location)
              on_stmts_add(on_stmts_new, on_void_stmt)
            else
              visit(node.statements)
            end

          bounds(node.location)
          on_until(predicate, statements)
        else
          statements = visit(node.statements.body.first)
          predicate = visit(node.predicate)

          bounds(node.location)
          on_until_mod(predicate, statements)
        end
      end

      # case foo; when bar; end
      #           ^^^^^^^^^^^^^
      def visit_when_node(node)
        # This is a special case where we're not going to call on_when directly
        # because we don't have access to the subsequent. Instead, we'll return
        # the component parts and let the parent node handle it.
        conditions = visit_arguments(node.conditions)
        statements =
          if node.statements.nil?
            bounds(node.location)
            on_stmts_add(on_stmts_new, on_void_stmt)
          else
            visit(node.statements)
          end

        [conditions, statements]
      end

      # while foo; bar end
      # ^^^^^^^^^^^^^^^^^^
      #
      # bar while foo
      # ^^^^^^^^^^^^^
      def visit_while_node(node)
        if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset)
          predicate = visit(node.predicate)
          statements =
            if node.statements.nil?
              bounds(node.location)
              on_stmts_add(on_stmts_new, on_void_stmt)
            else
              visit(node.statements)
            end

          bounds(node.location)
          on_while(predicate, statements)
        else
          statements = visit(node.statements.body.first)
          predicate = visit(node.predicate)

          bounds(node.location)
          on_while_mod(predicate, statements)
        end
      end

      # `foo`
      # ^^^^^
      def visit_x_string_node(node)
        if node.unescaped.empty?
          bounds(node.location)
          on_xstring_literal(on_xstring_new)
        elsif node.opening.start_with?("<<~")
          heredoc = visit_heredoc_x_string_node(node.to_interpolated)

          bounds(node.location)
          on_xstring_literal(heredoc)
        else
          bounds(node.content_loc)
          content = on_tstring_content(node.content)

          bounds(node.location)
          on_xstring_literal(on_xstring_add(on_xstring_new, content))
        end
      end

      # yield
      # ^^^^^
      #
      # yield 1
      # ^^^^^^^
      def visit_yield_node(node)
        if node.arguments.nil? && node.lparen_loc.nil?
          bounds(node.location)
          on_yield0
        else
          arguments =
            if node.arguments.nil?
              bounds(node.location)
              on_args_new
            else
              visit(node.arguments)
            end

          unless node.lparen_loc.nil?
            bounds(node.lparen_loc)
            arguments = on_paren(arguments)
          end

          bounds(node.location)
          on_yield(arguments)
        end
      end

      private

      # Lazily initialize the parse result.
      def result
        @result ||= Prism.parse(source, partial_script: true)
      end

      ##########################################################################
      # Helpers
      ##########################################################################

      # Returns true if there is a comma between the two locations.
      def trailing_comma?(left, right)
        source.byteslice(left.end_offset...right.start_offset).include?(",")
      end

      # Returns true if there is a semicolon between the two locations.
      def void_stmt?(left, right, allow_newline)
        pattern = allow_newline ? /[;\n]/ : /;/
        source.byteslice(left.end_offset...right.start_offset).match?(pattern)
      end

      # Visit the string content of a particular node. This method is used to
      # split into the various token types.
      def visit_token(token, allow_keywords = true)
        case token
        when "."
          on_period(token)
        when "`"
          on_backtick(token)
        when *(allow_keywords ? KEYWORDS : [])
          on_kw(token)
        when /^_/
          on_ident(token)
        when /^[[:upper:]]\w*$/
          on_const(token)
        when /^@@/
          on_cvar(token)
        when /^@/
          on_ivar(token)
        when /^\$/
          on_gvar(token)
        when /^[[:punct:]]/
          on_op(token)
        else
          on_ident(token)
        end
      end

      # Visit a node that represents a number. We need to explicitly handle the
      # unary - operator.
      def visit_number_node(node)
        slice = node.slice
        location = node.location

        if slice[0] == "-"
          bounds(location.copy(start_offset: location.start_offset + 1))
          value = yield slice[1..-1]

          bounds(node.location)
          on_unary(:-@, value)
        else
          bounds(location)
          yield slice
        end
      end

      # Visit a node that represents a write value. This is used to handle the
      # special case of an implicit array that is generated without brackets.
      def visit_write_value(node)
        if node.is_a?(ArrayNode) && node.opening_loc.nil?
          elements = node.elements
          length = elements.length

          bounds(elements.first.location)
          elements.each_with_index.inject((elements.first.is_a?(SplatNode) && length == 1) ? on_mrhs_new : on_args_new) do |args, (element, index)|
            arg = visit(element)
            bounds(element.location)

            if index == length - 1
              if element.is_a?(SplatNode)
                mrhs = index == 0 ? args : on_mrhs_new_from_args(args)
                on_mrhs_add_star(mrhs, arg)
              else
                on_mrhs_add(on_mrhs_new_from_args(args), arg)
              end
            else
              case element
              when BlockArgumentNode
                on_args_add_block(args, arg)
              when SplatNode
                on_args_add_star(args, arg)
              else
                on_args_add(args, arg)
              end
            end
          end
        else
          visit(node)
        end
      end

      # This method is responsible for updating lineno and column information
      # to reflect the current node.
      #
      # This method could be drastically improved with some caching on the start
      # of every line, but for now it's good enough.
      def bounds(location)
        @lineno = location.start_line
        @column = location.start_column
      end

      ##########################################################################
      # Ripper interface
      ##########################################################################

      # :stopdoc:
      def _dispatch_0; end
      def _dispatch_1(_); end
      def _dispatch_2(_, _); end
      def _dispatch_3(_, _, _); end
      def _dispatch_4(_, _, _, _); end
      def _dispatch_5(_, _, _, _, _); end
      def _dispatch_7(_, _, _, _, _, _, _); end
      # :startdoc:

      #
      # Parser Events
      #

      PARSER_EVENT_TABLE.each do |id, arity|
        alias_method "on_#{id}", "_dispatch_#{arity}"
      end

      # This method is called when weak warning is produced by the parser.
      # +fmt+ and +args+ is printf style.
      def warn(fmt, *args)
      end

      # This method is called when strong warning is produced by the parser.
      # +fmt+ and +args+ is printf style.
      def warning(fmt, *args)
      end

      # This method is called when the parser found syntax error.
      def compile_error(msg)
      end

      #
      # Scanner Events
      #

      SCANNER_EVENTS.each do |id|
        alias_method "on_#{id}", :_dispatch_1
      end

      # This method is provided by the Ripper C extension. It is called when a
      # string needs to be dedented because of a tilde heredoc. It is expected
      # that it will modify the string in place and return the number of bytes
      # that were removed.
      def dedent_string(string, width)
        whitespace = 0
        cursor = 0

        while cursor < string.length && string[cursor].match?(/\s/) && whitespace < width
          if string[cursor] == "\t"
            whitespace = ((whitespace / 8 + 1) * 8)
            break if whitespace > width
          else
            whitespace += 1
          end

          cursor += 1
        end

        string.replace(string[cursor..])
        cursor
      end
    end
  end
end
prism-1.5.1/lib/prism/translation/ripper/000077500000000000000000000000001506127434000204115ustar00rootroot00000000000000prism-1.5.1/lib/prism/translation/ripper/sexp.rb000066400000000000000000000061031506127434000217150ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

require_relative "../ripper"

module Prism
  module Translation
    class Ripper
      # This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that
      # returns the arrays of [type, *children].
      class SexpBuilder < Ripper
        # :stopdoc:

        attr_reader :error

        private

        def dedent_element(e, width)
          if (n = dedent_string(e[1], width)) > 0
            e[2][1] += n
          end
          e
        end

        def on_heredoc_dedent(val, width)
          sub = proc do |cont|
            cont.map! do |e|
              if Array === e
                case e[0]
                when :@tstring_content
                  e = dedent_element(e, width)
                when /_add\z/
                  e[1] = sub[e[1]]
                end
              elsif String === e
                dedent_string(e, width)
              end
              e
            end
          end
          sub[val]
          val
        end

        events = private_instance_methods(false).grep(/\Aon_/) {$'.to_sym}
        (PARSER_EVENTS - events).each do |event|
          module_eval(<<-End, __FILE__, __LINE__ + 1)
            def on_#{event}(*args)
              args.unshift :#{event}
            end
          End
        end

        SCANNER_EVENTS.each do |event|
          module_eval(<<-End, __FILE__, __LINE__ + 1)
            def on_#{event}(tok)
              [:@#{event}, tok, [lineno(), column()]]
            end
          End
        end

        def on_error(mesg)
          @error = mesg
        end
        remove_method :on_parse_error
        alias on_parse_error on_error
        alias compile_error on_error

        # :startdoc:
      end

      # This class mirrors the ::Ripper::SexpBuilderPP subclass of ::Ripper that
      # returns the same values as ::Ripper::SexpBuilder except with a couple of
      # niceties that flatten linked lists into arrays.
      class SexpBuilderPP < SexpBuilder
        # :stopdoc:

        private

        def on_heredoc_dedent(val, width)
          val.map! do |e|
            next e if Symbol === e and /_content\z/ =~ e
            if Array === e and e[0] == :@tstring_content
              e = dedent_element(e, width)
            elsif String === e
              dedent_string(e, width)
            end
            e
          end
          val
        end

        def _dispatch_event_new
          []
        end

        def _dispatch_event_push(list, item)
          list.push item
          list
        end

        def on_mlhs_paren(list)
          [:mlhs, *list]
        end

        def on_mlhs_add_star(list, star)
          list.push([:rest_param, star])
        end

        def on_mlhs_add_post(list, post)
          list.concat(post)
        end

        PARSER_EVENT_TABLE.each do |event, arity|
          if /_new\z/ =~ event and arity == 0
            alias_method "on_#{event}", :_dispatch_event_new
          elsif /_add\z/ =~ event
            alias_method "on_#{event}", :_dispatch_event_push
          end
        end

        # :startdoc:
      end
    end
  end
end
prism-1.5.1/lib/prism/translation/ripper/shim.rb000066400000000000000000000003111506127434000216710ustar00rootroot00000000000000# frozen_string_literal: true

# This writes the prism ripper translation into the Ripper constant so that
# users can transparently use Ripper without any changes.
Ripper = Prism::Translation::Ripper
prism-1.5.1/lib/prism/translation/ruby_parser.rb000066400000000000000000001530101506127434000217720ustar00rootroot00000000000000# frozen_string_literal: true
# :markup: markdown

begin
  require "ruby_parser"
rescue LoadError
  warn(%q{Error: Unable to load ruby_parser. Add `gem "ruby_parser"` to your Gemfile.})
  exit(1)
end

module Prism
  module Translation
    # This module is the entry-point for converting a prism syntax tree into the
    # seattlerb/ruby_parser gem's syntax tree.
    class RubyParser
      # A prism visitor that builds Sexp objects.
      class Compiler < ::Prism::Compiler
        # This is the name of the file that we are compiling. We set it on every
        # Sexp object that is generated, and also use it to compile `__FILE__`
        # nodes.
        attr_reader :file

        # Class variables will change their type based on if they are inside of
        # a method definition or not, so we need to track that state.
        attr_reader :in_def

        # Some nodes will change their representation if they are inside of a
        # pattern, so we need to track that state.
        attr_reader :in_pattern

        # Initialize a new compiler with the given file name.
        def initialize(file, in_def: false, in_pattern: false)
          @file = file
          @in_def = in_def
          @in_pattern = in_pattern
        end

        # ```
        # alias foo bar
        # ^^^^^^^^^^^^^
        # ```
        def visit_alias_method_node(node)
          s(node, :alias, visit(node.new_name), visit(node.old_name))
        end

        # ```
        # alias $foo $bar
        # ^^^^^^^^^^^^^^^
        # ```
        def visit_alias_global_variable_node(node)
          s(node, :valias, node.new_name.name, node.old_name.name)
        end

        # ```
        # foo => bar | baz
        #        ^^^^^^^^^
        # ```
        def visit_alternation_pattern_node(node)
          s(node, :or, visit(node.left), visit(node.right))
        end

        # ```
        # a and b
        # ^^^^^^^
        # ```
        def visit_and_node(node)
          left = visit(node.left)

          if left[0] == :and
            # ruby_parser has the and keyword as right-associative as opposed to
            # prism which has it as left-associative. We reverse that
            # associativity here.
            nest = left
            nest = nest[2] while nest[2][0] == :and
            nest[2] = s(node, :and, nest[2], visit(node.right))
            left
          else
            s(node, :and, left, visit(node.right))
          end
        end

        # ```
        # []
        # ^^
        # ```
        def visit_array_node(node)
          if in_pattern
            s(node, :array_pat, nil).concat(visit_all(node.elements))
          else
            s(node, :array).concat(visit_all(node.elements))
          end
        end

        # ```
        # foo => [bar]
        #        ^^^^^
        # ```
        def visit_array_pattern_node(node)
          if node.constant.nil? && node.requireds.empty? && node.rest.nil? && node.posts.empty?
            s(node, :array_pat)
          else
            result = s(node, :array_pat, visit_pattern_constant(node.constant)).concat(visit_all(node.requireds))

            case node.rest
            when SplatNode
              result << :"*#{node.rest.expression&.name}"
            when ImplicitRestNode
              result << :*

              # This doesn't make any sense at all, but since we're trying to
              # replicate the behavior directly, we'll copy it.
              result.line(666)
            end

            result.concat(visit_all(node.posts))
          end
        end

        # ```
        # foo(bar)
        #     ^^^
        # ```
        def visit_arguments_node(node)
          raise "Cannot visit arguments directly"
        end

        # ```
        # { a: 1 }
        #   ^^^^
        # ```
        def visit_assoc_node(node)
          [visit(node.key), visit(node.value)]
        end

        # ```
        # def foo(**); bar(**); end
        #                  ^^
        #
        # { **foo }
        #   ^^^^^
        # ```
        def visit_assoc_splat_node(node)
          if node.value.nil?
            [s(node, :kwsplat)]
          else
            [s(node, :kwsplat, visit(node.value))]
          end
        end

        # ```
        # $+
        # ^^
        # ```
        def visit_back_reference_read_node(node)
          s(node, :back_ref, node.name.name.delete_prefix("$").to_sym)
        end

        # ```
        # begin end
        # ^^^^^^^^^
        # ```
        def visit_begin_node(node)
          result = node.statements.nil? ? s(node, :nil) : visit(node.statements)

          if !node.rescue_clause.nil?
            if !node.statements.nil?
              result = s(node.statements, :rescue, result, visit(node.rescue_clause))
            else
              result = s(node.rescue_clause, :rescue, visit(node.rescue_clause))
            end

            current = node.rescue_clause
            until (current = current.subsequent).nil?
              result << visit(current)
            end
          end

          if !node.else_clause&.statements.nil?
            result << visit(node.else_clause)
          end

          if !node.ensure_clause.nil?
            if !node.statements.nil? || !node.rescue_clause.nil? || !node.else_clause.nil?
              result = s(node.statements || node.rescue_clause || node.else_clause || node.ensure_clause, :ensure, result, visit(node.ensure_clause))
            else
              result = s(node.ensure_clause, :ensure, visit(node.ensure_clause))
            end
          end

          result
        end

        # ```
        # foo(&bar)
        #     ^^^^
        # ```
        def visit_block_argument_node(node)
          s(node, :block_pass).tap do |result|
            result << visit(node.expression) unless node.expression.nil?
          end
        end

        # ```
        # foo { |; bar| }
        #          ^^^
        # ```
        def visit_block_local_variable_node(node)
          node.name
        end

        # A block on a keyword or method call.
        def visit_block_node(node)
          s(node, :block_pass, visit(node.expression))
        end

        # ```
        # def foo(&bar); end
        #         ^^^^
        # ```
        def visit_block_parameter_node(node)
          :"&#{node.name}"
        end

        # A block's parameters.
        def visit_block_parameters_node(node)
          # If this block parameters has no parameters and is using pipes, then
          # it inherits its location from its shadow locals, even if they're not
          # on the same lines as the pipes.
          shadow_loc = true

          result =
            if node.parameters.nil?
              s(node, :args)
            else
              shadow_loc = false
              visit(node.parameters)
            end

          if node.opening == "("
            result.line = node.opening_loc.start_line
            result.line_max = node.closing_loc.end_line
            shadow_loc = false
          end

          if node.locals.any?
            shadow = s(node, :shadow).concat(visit_all(node.locals))
            shadow.line = node.locals.first.location.start_line
            shadow.line_max = node.locals.last.location.end_line
            result << shadow

            if shadow_loc
              result.line = shadow.line
              result.line_max = shadow.line_max
            end
          end

          result
        end

        # ```
        # break
        # ^^^^^
        #
        # break foo
        # ^^^^^^^^^
        # ```
        def visit_break_node(node)
          if node.arguments.nil?
            s(node, :break)
          elsif node.arguments.arguments.length == 1
            s(node, :break, visit(node.arguments.arguments.first))
          else
            s(node, :break, s(node.arguments, :array).concat(visit_all(node.arguments.arguments)))
          end
        end

        # ```
        # foo
        # ^^^
        #
        # foo.bar
        # ^^^^^^^
        #
        # foo.bar() {}
        # ^^^^^^^^^^^^
        # ```
        def visit_call_node(node)
          case node.name
          when :!~
            return s(node, :not, visit(node.copy(name: :"=~")))
          when :=~
            if node.arguments&.arguments&.length == 1 && node.block.nil?
              case node.receiver
              when StringNode
                return s(node, :match3, visit(node.arguments.arguments.first), visit(node.receiver))
              when RegularExpressionNode, InterpolatedRegularExpressionNode
                return s(node, :match2, visit(node.receiver), visit(node.arguments.arguments.first))
              end

              case node.arguments.arguments.first
              when RegularExpressionNode, InterpolatedRegularExpressionNode
                return s(node, :match3, visit(node.arguments.arguments.first), visit(node.receiver))
              end
            end
          end

          type = node.attribute_write? ? :attrasgn : :call
          type = :"safe_#{type}" if node.safe_navigation?

          arguments = node.arguments&.arguments || []
          write_value = arguments.pop if type == :attrasgn
          block = node.block

          if block.is_a?(BlockArgumentNode)
            arguments << block
            block = nil
          end

          result = s(node, type, visit(node.receiver), node.name).concat(visit_all(arguments))
          result << visit_write_value(write_value) unless write_value.nil?

          visit_block(node, result, block)
        end

        # ```
        # foo.bar += baz
        # ^^^^^^^^^^^^^^^
        # ```
        def visit_call_operator_write_node(node)
          if op_asgn?(node)
            s(node, op_asgn_type(node, :op_asgn), visit(node.receiver), visit_write_value(node.value), node.read_name, node.binary_operator)
          else
            s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, node.binary_operator, visit_write_value(node.value))
          end
        end

        # ```
        # foo.bar &&= baz
        # ^^^^^^^^^^^^^^^
        # ```
        def visit_call_and_write_node(node)
          if op_asgn?(node)
            s(node, op_asgn_type(node, :op_asgn), visit(node.receiver), visit_write_value(node.value), node.read_name, :"&&")
          else
            s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, :"&&", visit_write_value(node.value))
          end
        end

        # ```
        # foo.bar ||= baz
        # ^^^^^^^^^^^^^^^
        # ```
        def visit_call_or_write_node(node)
          if op_asgn?(node)
            s(node, op_asgn_type(node, :op_asgn), visit(node.receiver), visit_write_value(node.value), node.read_name, :"||")
          else
            s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, :"||", visit_write_value(node.value))
          end
        end

        # Call nodes with operators following them will either be op_asgn or
        # op_asgn2 nodes. That is determined by their call operator and their
        # right-hand side.
        private def op_asgn?(node)
          node.call_operator == "::" || (node.value.is_a?(CallNode) && node.value.opening_loc.nil? && !node.value.arguments.nil?)
        end

        # Call nodes with operators following them can use &. as an operator,
        # which changes their type by prefixing "safe_".
        private def op_asgn_type(node, type)
          node.safe_navigation? ? :"safe_#{type}" : type
        end

        # ```
        # foo.bar, = 1
        # ^^^^^^^
        # ```
        def visit_call_target_node(node)
          s(node, :attrasgn, visit(node.receiver), node.name)
        end

        # ```
        # foo => bar => baz
        #        ^^^^^^^^^^
        # ```
        def visit_capture_pattern_node(node)
          visit(node.target) << visit(node.value)
        end

        # ```
        # case foo; when bar; end
        # ^^^^^^^^^^^^^^^^^^^^^^^
        # ```
        def visit_case_node(node)
          s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.else_clause)
        end

        # ```
        # case foo; in bar; end
        # ^^^^^^^^^^^^^^^^^^^^^
        # ```
        def visit_case_match_node(node)
          s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.else_clause)
        end

        # ```
        # class Foo; end
        # ^^^^^^^^^^^^^^
        # ```
        def visit_class_node(node)
          name =
            if node.constant_path.is_a?(ConstantReadNode)
              node.name
            else
              visit(node.constant_path)
            end

          if node.body.nil?
            s(node, :class, name, visit(node.superclass))
          elsif node.body.is_a?(StatementsNode)
            compiler = copy_compiler(in_def: false)
            s(node, :class, name, visit(node.superclass)).concat(node.body.body.map { |child| child.accept(compiler) })
          else
            s(node, :class, name, visit(node.superclass), node.body.accept(copy_compiler(in_def: false)))
          end
        end

        # ```
        # @@foo
        # ^^^^^
        # ```
        def visit_class_variable_read_node(node)
          s(node, :cvar, node.name)
        end

        # ```
        # @@foo = 1
        # ^^^^^^^^^
        #
        # @@foo, @@bar = 1
        # ^^^^^  ^^^^^
        # ```
        def visit_class_variable_write_node(node)
          s(node, class_variable_write_type, node.name, visit_write_value(node.value))
        end

        # ```
        # @@foo += bar
        # ^^^^^^^^^^^^
        # ```
        def visit_class_variable_operator_write_node(node)
          s(node, class_variable_write_type, node.name, s(node, :call, s(node, :cvar, node.name), node.binary_operator, visit_write_value(node.value)))
        end

        # ```
        # @@foo &&= bar
        # ^^^^^^^^^^^^^
        # ```
        def visit_class_variable_and_write_node(node)
          s(node, :op_asgn_and, s(node, :cvar, node.name), s(node, class_variable_write_type, node.name, visit_write_value(node.value)))
        end

        # ```
        # @@foo ||= bar
        # ^^^^^^^^^^^^^
        # ```
        def visit_class_variable_or_write_node(node)
          s(node, :op_asgn_or, s(node, :cvar, node.name), s(node, class_variable_write_type, node.name, visit_write_value(node.value)))
        end

        # ```
        # @@foo, = bar
        # ^^^^^
        # ```
        def visit_class_variable_target_node(node)
          s(node, class_variable_write_type, node.name)
        end

        # If a class variable is written within a method definition, it has a
        # different type than everywhere else.
        private def class_variable_write_type
          in_def ? :cvasgn : :cvdecl
        end

        # ```
        # Foo
        # ^^^
        # ```
        def visit_constant_read_node(node)
          s(node, :const, node.name)
        end

        # ```
        # Foo = 1
        # ^^^^^^^
        #
        # Foo, Bar = 1
        # ^^^  ^^^
        # ```
        def visit_constant_write_node(node)
          s(node, :cdecl, node.name, visit_write_value(node.value))
        end

        # ```
        # Foo += bar
        # ^^^^^^^^^^^
        # ```
        def visit_constant_operator_write_node(node)
          s(node, :cdecl, node.name, s(node, :call, s(node, :const, node.name), node.binary_operator, visit_write_value(node.value)))
        end

        # ```
        # Foo &&= bar
        # ^^^^^^^^^^^^
        # ```
        def visit_constant_and_write_node(node)
          s(node, :op_asgn_and, s(node, :const, node.name), s(node, :cdecl, node.name, visit(node.value)))
        end

        # ```
        # Foo ||= bar
        # ^^^^^^^^^^^^
        # ```
        def visit_constant_or_write_node(node)
          s(node, :op_asgn_or, s(node, :const, node.name), s(node, :cdecl, node.name, visit(node.value)))
        end

        # ```
        # Foo, = bar
        # ^^^
        # ```
        def visit_constant_target_node(node)
          s(node, :cdecl, node.name)
        end

        # ```
        # Foo::Bar
        # ^^^^^^^^
        # ```
        def visit_constant_path_node(node)
          if node.parent.nil?
            s(node, :colon3, node.name)
          else
            s(node, :colon2, visit(node.parent), node.name)
          end
        end

        # ```
        # Foo::Bar = 1
        # ^^^^^^^^^^^^
        #
        # Foo::Foo, Bar::Bar = 1
        # ^^^^^^^^  ^^^^^^^^
        # ```
        def visit_constant_path_write_node(node)
          s(node, :cdecl, visit(node.target), visit_write_value(node.value))
        end

        # ```
        # Foo::Bar += baz
        # ^^^^^^^^^^^^^^^
        # ```
        def visit_constant_path_operator_write_node(node)
          s(node, :op_asgn, visit(node.target), node.binary_operator, visit_write_value(node.value))
        end

        # ```
        # Foo::Bar &&= baz
        # ^^^^^^^^^^^^^^^^
        # ```
        def visit_constant_path_and_write_node(node)
          s(node, :op_asgn_and, visit(node.target), visit_write_value(node.value))
        end

        # ```
        # Foo::Bar ||= baz
        # ^^^^^^^^^^^^^^^^
        # ```
        def visit_constant_path_or_write_node(node)
          s(node, :op_asgn_or, visit(node.target), visit_write_value(node.value))
        end

        # ```
        # Foo::Bar, = baz
        # ^^^^^^^^
        # ```
        def visit_constant_path_target_node(node)
          inner =
            if node.parent.nil?
              s(node, :colon3, node.name)
            else
              s(node, :colon2, visit(node.parent), node.name)
            end

          s(node, :const, inner)
        end

        # ```
        # def foo; end
        # ^^^^^^^^^^^^
        #
        # def self.foo; end
        # ^^^^^^^^^^^^^^^^^
        # ```
        def visit_def_node(node)
          name = node.name_loc.slice.to_sym
          result =
            if node.receiver.nil?
              s(node, :defn, name)
            else
              s(node, :defs, visit(node.receiver), name)
            end

          result.line(node.name_loc.start_line)
          if node.parameters.nil?
            result << s(node, :args).line(node.name_loc.start_line)
          else
            result << visit(node.parameters)
          end

          if node.body.nil?
            result << s(node, :nil)
          elsif node.body.is_a?(StatementsNode)
            compiler = copy_compiler(in_def: true)
            result.concat(node.body.body.map { |child| child.accept(compiler) })
          else
            result << node.body.accept(copy_compiler(in_def: true))
          end
        end

        # ```
        # defined? a
        # ^^^^^^^^^^
        #
        # defined?(a)
        # ^^^^^^^^^^^
        # ```
        def visit_defined_node(node)
          s(node, :defined, visit(node.value))
        end

        # ```
        # if foo then bar else baz end
        #                 ^^^^^^^^^^^^
        # ```
        def visit_else_node(node)
          visit(node.statements)
        end

        # ```
        # "foo #{bar}"
        #      ^^^^^^
        # ```
        def visit_embedded_statements_node(node)
          result = s(node, :evstr)
          result << visit(node.statements) unless node.statements.nil?
          result
        end

        # ```
        # "foo #@bar"
        #      ^^^^^
        # ```
        def visit_embedded_variable_node(node)
          s(node, :evstr, visit(node.variable))
        end

        # ```
        # begin; foo; ensure; bar; end
        #             ^^^^^^^^^^^^
        # ```
        def visit_ensure_node(node)
          node.statements.nil? ? s(node, :nil) : visit(node.statements)
        end

        # ```
        # false
        # ^^^^^
        # ```
        def visit_false_node(node)
          s(node, :false)
        end

        # ```
        # foo => [*, bar, *]
        #        ^^^^^^^^^^^
        # ```
        def visit_find_pattern_node(node)
          s(node, :find_pat, visit_pattern_constant(node.constant), :"*#{node.left.expression&.name}", *visit_all(node.requireds), :"*#{node.right.expression&.name}")
        end

        # ```
        # if foo .. bar; end
        #    ^^^^^^^^^^
        # ```
        def visit_flip_flop_node(node)
          if node.left.is_a?(IntegerNode) && node.right.is_a?(IntegerNode)
            s(node, :lit, Range.new(node.left.value, node.right.value, node.exclude_end?))
          else
            s(node, node.exclude_end? ? :flip3 : :flip2, visit(node.left), visit(node.right))
          end
        end

        # ```
        # 1.0
        # ^^^
        # ```
        def visit_float_node(node)
          s(node, :lit, node.value)
        end

        # ```
        # for foo in bar do end
        # ^^^^^^^^^^^^^^^^^^^^^
        # ```
        def visit_for_node(node)
          s(node, :for, visit(node.collection), visit(node.index), visit(node.statements))
        end

        # ```
        # def foo(...); bar(...); end
        #                   ^^^
        # ```
        def visit_forwarding_arguments_node(node)
          s(node, :forward_args)
        end

        # ```
        # def foo(...); end
        #         ^^^
        # ```
        def visit_forwarding_parameter_node(node)
          s(node, :forward_args)
        end

        # ```
        # super
        # ^^^^^
        #
        # super {}
        # ^^^^^^^^
        # ```
        def visit_forwarding_super_node(node)
          visit_block(node, s(node, :zsuper), node.block)
        end

        # ```
        # $foo
        # ^^^^
        # ```
        def visit_global_variable_read_node(node)
          s(node, :gvar, node.name)
        end

        # ```
        # $foo = 1
        # ^^^^^^^^
        #
        # $foo, $bar = 1
        # ^^^^  ^^^^
        # ```
        def visit_global_variable_write_node(node)
          s(node, :gasgn, node.name, visit_write_value(node.value))
        end

        # ```
        # $foo += bar
        # ^^^^^^^^^^^
        # ```
        def visit_global_variable_operator_write_node(node)
          s(node, :gasgn, node.name, s(node, :call, s(node, :gvar, node.name), node.binary_operator, visit(node.value)))
        end

        # ```
        # $foo &&= bar
        # ^^^^^^^^^^^^
        # ```
        def visit_global_variable_and_write_node(node)
          s(node, :op_asgn_and, s(node, :gvar, node.name), s(node, :gasgn, node.name, visit_write_value(node.value)))
        end

        # ```
        # $foo ||= bar
        # ^^^^^^^^^^^^
        # ```
        def visit_global_variable_or_write_node(node)
          s(node, :op_asgn_or, s(node, :gvar, node.name), s(node, :gasgn, node.name, visit_write_value(node.value)))
        end

        # ```
        # $foo, = bar
        # ^^^^
        # ```
        def visit_global_variable_target_node(node)
          s(node, :gasgn, node.name)
        end

        # ```
        # {}
        # ^^
        # ```
        def visit_hash_node(node)
          s(node, :hash).concat(node.elements.flat_map { |element| visit(element) })
        end

        # ```
        # foo => {}
        #        ^^
        # ```
        def visit_hash_pattern_node(node)
          result = s(node, :hash_pat, visit_pattern_constant(node.constant)).concat(node.elements.flat_map { |element| visit(element) })

          case node.rest
          when AssocSplatNode
            result << s(node.rest, :kwrest, :"**#{node.rest.value&.name}")
          when NoKeywordsParameterNode
            result << visit(node.rest)
          end

          result
        end

        # ```
        # if foo then bar end
        # ^^^^^^^^^^^^^^^^^^^
        #
        # bar if foo
        # ^^^^^^^^^^
        #
        # foo ? bar : baz
        # ^^^^^^^^^^^^^^^
        # ```
        def visit_if_node(node)
          s(node, :if, visit(node.predicate), visit(node.statements), visit(node.subsequent))
        end

        # 1i
        def visit_imaginary_node(node)
          s(node, :lit, node.value)
        end

        # ```
        # { foo: }
        #   ^^^^
        # ```
        def visit_implicit_node(node)
        end

        # ```
        # foo { |bar,| }
        #           ^
        # ```
        def visit_implicit_rest_node(node)
        end

        # ```
        # case foo; in bar; end
        # ^^^^^^^^^^^^^^^^^^^^^
        # ```
        def visit_in_node(node)
          pattern =
            if node.pattern.is_a?(ConstantPathNode)
              s(node.pattern, :const, visit(node.pattern))
            else
              node.pattern.accept(copy_compiler(in_pattern: true))
            end

          s(node, :in, pattern).concat(node.statements.nil? ? [nil] : visit_all(node.statements.body))
        end

        # ```
        # foo[bar] += baz
        # ^^^^^^^^^^^^^^^
        # ```
        def visit_index_operator_write_node(node)
          arglist = nil

          if !node.arguments.nil? || !node.block.nil?
            arglist = s(node, :arglist).concat(visit_all(node.arguments&.arguments || []))
            arglist << visit(node.block) if !node.block.nil?
          end

          s(node, :op_asgn1, visit(node.receiver), arglist, node.binary_operator, visit_write_value(node.value))
        end

        # ```
        # foo[bar] &&= baz
        # ^^^^^^^^^^^^^^^^
        # ```
        def visit_index_and_write_node(node)
          arglist = nil

          if !node.arguments.nil? || !node.block.nil?
            arglist = s(node, :arglist).concat(visit_all(node.arguments&.arguments || []))
            arglist << visit(node.block) if !node.block.nil?
          end

          s(node, :op_asgn1, visit(node.receiver), arglist, :"&&", visit_write_value(node.value))
        end

        # ```
        # foo[bar] ||= baz
        # ^^^^^^^^^^^^^^^^
        # ```
        def visit_index_or_write_node(node)
          arglist = nil

          if !node.arguments.nil? || !node.block.nil?
            arglist = s(node, :arglist).concat(visit_all(node.arguments&.arguments || []))
            arglist << visit(node.block) if !node.block.nil?
          end

          s(node, :op_asgn1, visit(node.receiver), arglist, :"||", visit_write_value(node.value))
        end

        # ```
        # foo[bar], = 1
        # ^^^^^^^^
        # ```
        def visit_index_target_node(node)
          arguments = visit_all(node.arguments&.arguments || [])
          arguments << visit(node.block) unless node.block.nil?

          s(node, :attrasgn, visit(node.receiver), :[]=).concat(arguments)
        end

        # ```
        # @foo
        # ^^^^
        # ```
        def visit_instance_variable_read_node(node)
          s(node, :ivar, node.name)
        end

        # ```
        # @foo = 1
        # ^^^^^^^^
        #
        # @foo, @bar = 1
        # ^^^^  ^^^^
        # ```
        def visit_instance_variable_write_node(node)
          s(node, :iasgn, node.name, visit_write_value(node.value))
        end

        # ```
        # @foo += bar
        # ^^^^^^^^^^^
        # ```
        def visit_instance_variable_operator_write_node(node)
          s(node, :iasgn, node.name, s(node, :call, s(node, :ivar, node.name), node.binary_operator, visit_write_value(node.value)))
        end

        # ```
        # @foo &&= bar
        # ^^^^^^^^^^^^
        # ```
        def visit_instance_variable_and_write_node(node)
          s(node, :op_asgn_and, s(node, :ivar, node.name), s(node, :iasgn, node.name, visit(node.value)))
        end

        # ```
        # @foo ||= bar
        # ^^^^^^^^^^^^
        # ```
        def visit_instance_variable_or_write_node(node)
          s(node, :op_asgn_or, s(node, :ivar, node.name), s(node, :iasgn, node.name, visit(node.value)))
        end

        # ```
        # @foo, = bar
        # ^^^^
        # ```
        def visit_instance_variable_target_node(node)
          s(node, :iasgn, node.name)
        end

        # ```
        # 1
        # ^
        # ```
        def visit_integer_node(node)
          s(node, :lit, node.value)
        end

        # ```
        # if /foo #{bar}/ then end
        #    ^^^^^^^^^^^^
        # ```
        def visit_interpolated_match_last_line_node(node)
          parts = visit_interpolated_parts(node.parts)
          regexp =
            if parts.length == 1
              s(node, :lit, Regexp.new(parts.first, node.options))
            else
              s(node, :dregx).concat(parts).tap do |result|
                options = node.options
                result << options if options != 0
              end
            end

          s(node, :match, regexp)
        end

        # ```
        # /foo #{bar}/
        # ^^^^^^^^^^^^
        # ```
        def visit_interpolated_regular_expression_node(node)
          parts = visit_interpolated_parts(node.parts)

          if parts.length == 1
            s(node, :lit, Regexp.new(parts.first, node.options))
          else
            s(node, :dregx).concat(parts).tap do |result|
              options = node.options
              result << options if options != 0
            end
          end
        end

        # ```
        # "foo #{bar}"
        # ^^^^^^^^^^^^
        # ```
        def visit_interpolated_string_node(node)
          parts = visit_interpolated_parts(node.parts)
          parts.length == 1 ? s(node, :str, parts.first) : s(node, :dstr).concat(parts)
        end

        # ```
        # :"foo #{bar}"
        # ^^^^^^^^^^^^^
        # ```
        def visit_interpolated_symbol_node(node)
          parts = visit_interpolated_parts(node.parts)
          parts.length == 1 ? s(node, :lit, parts.first.to_sym) : s(node, :dsym).concat(parts)
        end

        # ```
        # `foo #{bar}`
        # ^^^^^^^^^^^^
        # ```
        def visit_interpolated_x_string_node(node)
          source = node.heredoc? ? node.parts.first : node
          parts = visit_interpolated_parts(node.parts)
          parts.length == 1 ? s(source, :xstr, parts.first) : s(source, :dxstr).concat(parts)
        end

        # Visit the interpolated content of the string-like node.
        private def visit_interpolated_parts(parts)
          visited = []

          parts.each do |part|
            result = visit(part)

            if result[0] == :evstr && result[1]
              if result[1][0] == :str
                visited << result[1]
              elsif result[1][0] == :dstr
                visited.concat(result[1][1..-1])
              else
                visited << result
              end
              visited << :space
            elsif result[0] == :dstr
              if !visited.empty? && part.parts[0].is_a?(StringNode)
                # If we are in the middle of an implicitly concatenated string,
                # we should not have a bare string as the first part. In this
                # case we need to visit just that first part and then we can
                # push the rest of the parts onto the visited array.
                result[1] = visit(part.parts[0])
              end
              visited.concat(result[1..-1])
            else
              visited << result
            end
          end

          state = :beginning #: :beginning | :string_content | :interpolated_content
          results = []

          visited.each_with_index do |result, index|
            case state
            when :beginning
              if result.is_a?(String)
                results << result
                state = :string_content
              elsif result.is_a?(Array) && result[0] == :str
                results << result[1]
                state = :string_content
              else
                results << ""
                results << result
                state = :interpolated_content
              end
            when :string_content
              if result == :space
                # continue
              elsif result.is_a?(String)
                results[0] = "#{results[0]}#{result}"
              elsif result.is_a?(Array) && result[0] == :str
                results[0] = "#{results[0]}#{result[1]}"
              else
                results << result
                state = :interpolated_content
              end
            when :interpolated_content
              if result == :space
                # continue
              elsif visited[index - 1] != :space && result.is_a?(Array) && result[0] == :str && results[-1][0] == :str && (results[-1].line_max == result.line)
                results[-1][1] = "#{results[-1][1]}#{result[1]}"
                results[-1].line_max = result.line_max
              else
                results << result
              end
            end
          end

          results
        end

        # ```
        # -> { it }
        #      ^^
        # ```
        def visit_it_local_variable_read_node(node)
          s(node, :call, nil, :it)
        end

        # ```
        # foo(bar: baz)
        #     ^^^^^^^^
        # ```
        def visit_keyword_hash_node(node)
          s(node, :hash).concat(node.elements.flat_map { |element| visit(element) })
        end

        # ```
        # def foo(**bar); end
        #         ^^^^^
        #
        # def foo(**); end
        #         ^^
        # ```
        def visit_keyword_rest_parameter_node(node)
          :"**#{node.name}"
        end

        # -> {}
        def visit_lambda_node(node)
          parameters =
            case node.parameters
            when nil, ItParametersNode, NumberedParametersNode
              0
            else
              visit(node.parameters)
            end

          if node.body.nil?
            s(node, :iter, s(node, :lambda), parameters)
          else
            s(node, :iter, s(node, :lambda), parameters, visit(node.body))
          end
        end

        # ```
        # foo
        # ^^^
        # ```
        def visit_local_variable_read_node(node)
          if node.name.match?(/^_\d$/)
            s(node, :call, nil, node.name)
          else
            s(node, :lvar, node.name)
          end
        end

        # ```
        # foo = 1
        # ^^^^^^^
        #
        # foo, bar = 1
        # ^^^  ^^^
        # ```
        def visit_local_variable_write_node(node)
          s(node, :lasgn, node.name, visit_write_value(node.value))
        end

        # ```
        # foo += bar
        # ^^^^^^^^^^
        # ```
        def visit_local_variable_operator_write_node(node)
          s(node, :lasgn, node.name, s(node, :call, s(node, :lvar, node.name), node.binary_operator, visit_write_value(node.value)))
        end

        # ```
        # foo &&= bar
        # ^^^^^^^^^^^
        # ```
        def visit_local_variable_and_write_node(node)
          s(node, :op_asgn_and, s(node, :lvar, node.name), s(node, :lasgn, node.name, visit_write_value(node.value)))
        end

        # ```
        # foo ||= bar
        # ^^^^^^^^^^^
        # ```
        def visit_local_variable_or_write_node(node)
          s(node, :op_asgn_or, s(node, :lvar, node.name), s(node, :lasgn, node.name, visit_write_value(node.value)))
        end

        # ```
        # foo, = bar
        # ^^^
        # ```
        def visit_local_variable_target_node(node)
          s(node, :lasgn, node.name)
        end

        # ```
        # if /foo/ then end
        #    ^^^^^
        # ```
        def visit_match_last_line_node(node)
          s(node, :match, s(node, :lit, Regexp.new(node.unescaped, node.options)))
        end

        # ```
        # foo in bar
        # ^^^^^^^^^^
        # ```
        def visit_match_predicate_node(node)
          s(node, :case, visit(node.value), s(node, :in, node.pattern.accept(copy_compiler(in_pattern: true)), nil), nil)
        end

        # ```
        # foo => bar
        # ^^^^^^^^^^
        # ```
        def visit_match_required_node(node)
          s(node, :case, visit(node.value), s(node, :in, node.pattern.accept(copy_compiler(in_pattern: true)), nil), nil)
        end

        # ```
        # /(?foo)/ =~ bar
        # ^^^^^^^^^^^^^^^^^^^^
        # ```
        def visit_match_write_node(node)
          s(node, :match2, visit(node.call.receiver), visit(node.call.arguments.arguments.first))
        end

        # A node that is missing from the syntax tree. This is only used in the
        # case of a syntax error. The parser gem doesn't have such a concept, so
        # we invent our own here.
        def visit_missing_node(node)
          raise "Cannot visit missing node directly"
        end

        # ```
        # module Foo; end
        # ^^^^^^^^^^^^^^^
        # ```
        def visit_module_node(node)
          name =
            if node.constant_path.is_a?(ConstantReadNode)
              node.name
            else
              visit(node.constant_path)
            end

          if node.body.nil?
            s(node, :module, name)
          elsif node.body.is_a?(StatementsNode)
            compiler = copy_compiler(in_def: false)
            s(node, :module, name).concat(node.body.body.map { |child| child.accept(compiler) })
          else
            s(node, :module, name, node.body.accept(copy_compiler(in_def: false)))
          end
        end

        # ```
        # foo, bar = baz
        # ^^^^^^^^
        # ```
        def visit_multi_target_node(node)
          targets = [*node.lefts]
          targets << node.rest if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode)
          targets.concat(node.rights)

          s(node, :masgn, s(node, :array).concat(visit_all(targets)))
        end

        # ```
        # foo, bar = baz
        # ^^^^^^^^^^^^^^
        # ```
        def visit_multi_write_node(node)
          targets = [*node.lefts]
          targets << node.rest if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode)
          targets.concat(node.rights)

          value =
            if node.value.is_a?(ArrayNode) && node.value.opening_loc.nil?
              if node.value.elements.length == 1 && node.value.elements.first.is_a?(SplatNode)
                visit(node.value.elements.first)
              else
                visit(node.value)
              end
            else
              s(node.value, :to_ary, visit(node.value))
            end

          s(node, :masgn, s(node, :array).concat(visit_all(targets)), value)
        end

        # ```
        # next
        # ^^^^
        #
        # next foo
        # ^^^^^^^^
        # ```
        def visit_next_node(node)
          if node.arguments.nil?
            s(node, :next)
          elsif node.arguments.arguments.length == 1
            argument = node.arguments.arguments.first
            s(node, :next, argument.is_a?(SplatNode) ? s(node, :svalue, visit(argument)) : visit(argument))
          else
            s(node, :next, s(node, :array).concat(visit_all(node.arguments.arguments)))
          end
        end

        # ```
        # nil
        # ^^^
        # ```
        def visit_nil_node(node)
          s(node, :nil)
        end

        # ```
        # def foo(**nil); end
        #         ^^^^^
        # ```
        def visit_no_keywords_parameter_node(node)
          in_pattern ? s(node, :kwrest, :"**nil") : :"**nil"
        end

        # ```
        # -> { _1 + _2 }
        # ^^^^^^^^^^^^^^
        # ```
        def visit_numbered_parameters_node(node)
          raise "Cannot visit numbered parameters directly"
        end

        # ```
        # $1
        # ^^
        # ```
        def visit_numbered_reference_read_node(node)
          s(node, :nth_ref, node.number)
        end

        # ```
        # def foo(bar: baz); end
        #         ^^^^^^^^
        # ```
        def visit_optional_keyword_parameter_node(node)
          s(node, :kwarg, node.name, visit(node.value))
        end

        # ```
        # def foo(bar = 1); end
        #         ^^^^^^^
        # ```
        def visit_optional_parameter_node(node)
          s(node, :lasgn, node.name, visit(node.value))
        end

        # ```
        # a or b
        # ^^^^^^
        # ```
        def visit_or_node(node)
          left = visit(node.left)

          if left[0] == :or
            # ruby_parser has the or keyword as right-associative as opposed to
            # prism which has it as left-associative. We reverse that
            # associativity here.
            nest = left
            nest = nest[2] while nest[2][0] == :or
            nest[2] = s(node, :or, nest[2], visit(node.right))
            left
          else
            s(node, :or, left, visit(node.right))
          end
        end

        # ```
        # def foo(bar, *baz); end
        #         ^^^^^^^^^
        # ```
        def visit_parameters_node(node)
          children =
            node.compact_child_nodes.map do |element|
              if element.is_a?(MultiTargetNode)
                visit_destructured_parameter(element)
              else
                visit(element)
              end
            end

          s(node, :args).concat(children)
        end

        # ```
        # def foo((bar, baz)); end
        #         ^^^^^^^^^^
        # ```
        private def visit_destructured_parameter(node)
          children =
            [*node.lefts, *node.rest, *node.rights].map do |child|
              case child
              when RequiredParameterNode
                visit(child)
              when MultiTargetNode
                visit_destructured_parameter(child)
              when SplatNode
                :"*#{child.expression&.name}"
              else
                raise
              end
            end

          s(node, :masgn).concat(children)
        end

        # ```
        # ()
        # ^^
        #
        # (1)
        # ^^^
        # ```
        def visit_parentheses_node(node)
          if node.body.nil?
            s(node, :nil)
          else
            visit(node.body)
          end
        end

        # ```
        # foo => ^(bar)
        #        ^^^^^^
        # ```
        def visit_pinned_expression_node(node)
          node.expression.accept(copy_compiler(in_pattern: false))
        end

        # ```
        # foo = 1 and bar => ^foo
        #                    ^^^^
        # ```
        def visit_pinned_variable_node(node)
          if node.variable.is_a?(LocalVariableReadNode) && node.variable.name.match?(/^_\d$/)
            s(node, :lvar, node.variable.name)
          else
            visit(node.variable)
          end
        end

        # END {}
        def visit_post_execution_node(node)
          s(node, :iter, s(node, :postexe), 0, visit(node.statements))
        end

        # BEGIN {}
        def visit_pre_execution_node(node)
          s(node, :iter, s(node, :preexe), 0, visit(node.statements))
        end

        # The top-level program node.
        def visit_program_node(node)
          visit(node.statements)
        end

        # ```
        # 0..5
        # ^^^^
        # ```
        def visit_range_node(node)
          if !in_pattern && !node.left.nil? && !node.right.nil? && ([node.left.type, node.right.type] - %i[nil_node integer_node]).empty?
            left = node.left.value if node.left.is_a?(IntegerNode)
            right = node.right.value if node.right.is_a?(IntegerNode)
            s(node, :lit, Range.new(left, right, node.exclude_end?))
          else
            s(node, node.exclude_end? ? :dot3 : :dot2, visit_range_bounds_node(node.left), visit_range_bounds_node(node.right))
          end
        end

        # If the bounds of a range node are empty parentheses, then they do not
        # get replaced by their usual s(:nil), but instead are s(:begin).
        private def visit_range_bounds_node(node)
          if node.is_a?(ParenthesesNode) && node.body.nil?
            s(node, :begin)
          else
            visit(node)
          end
        end

        # ```
        # 1r
        # ^^
        # ```
        def visit_rational_node(node)
          s(node, :lit, node.value)
        end

        # ```
        # redo
        # ^^^^
        # ```
        def visit_redo_node(node)
          s(node, :redo)
        end

        # ```
        # /foo/
        # ^^^^^
        # ```
        def visit_regular_expression_node(node)
          s(node, :lit, Regexp.new(node.unescaped, node.options))
        end

        # ```
        # def foo(bar:); end
        #         ^^^^
        # ```
        def visit_required_keyword_parameter_node(node)
          s(node, :kwarg, node.name)
        end

        # ```
        # def foo(bar); end
        #         ^^^
        # ```
        def visit_required_parameter_node(node)
          node.name
        end

        # ```
        # foo rescue bar
        # ^^^^^^^^^^^^^^
        # ```
        def visit_rescue_modifier_node(node)
          s(node, :rescue, visit(node.expression), s(node.rescue_expression, :resbody, s(node.rescue_expression, :array), visit(node.rescue_expression)))
        end

        # ```
        # begin; rescue; end
        #        ^^^^^^^
        # ```
        def visit_rescue_node(node)
          exceptions =
            if node.exceptions.length == 1 && node.exceptions.first.is_a?(SplatNode)
              visit(node.exceptions.first)
            else
              s(node, :array).concat(visit_all(node.exceptions))
            end

          if !node.reference.nil?
            exceptions << (visit(node.reference) << s(node.reference, :gvar, :"$!"))
          end

          s(node, :resbody, exceptions).concat(node.statements.nil? ? [nil] : visit_all(node.statements.body))
        end

        # ```
        # def foo(*bar); end
        #         ^^^^
        #
        # def foo(*); end
        #         ^
        # ```
        def visit_rest_parameter_node(node)
          :"*#{node.name}"
        end

        # ```
        # retry
        # ^^^^^
        # ```
        def visit_retry_node(node)
          s(node, :retry)
        end

        # ```
        # return
        # ^^^^^^
        #
        # return 1
        # ^^^^^^^^
        # ```
        def visit_return_node(node)
          if node.arguments.nil?
            s(node, :return)
          elsif node.arguments.arguments.length == 1
            argument = node.arguments.arguments.first
            s(node, :return, argument.is_a?(SplatNode) ? s(node, :svalue, visit(argument)) : visit(argument))
          else
            s(node, :return, s(node, :array).concat(visit_all(node.arguments.arguments)))
          end
        end

        # ```
        # self
        # ^^^^
        # ```
        def visit_self_node(node)
          s(node, :self)
        end

        # A shareable constant.
        def visit_shareable_constant_node(node)
          visit(node.write)
        end

        # ```
        # class << self; end
        # ^^^^^^^^^^^^^^^^^^
        # ```
        def visit_singleton_class_node(node)
          s(node, :sclass, visit(node.expression)).tap do |sexp|
            sexp << node.body.accept(copy_compiler(in_def: false)) unless node.body.nil?
          end
        end

        # ```
        # __ENCODING__
        # ^^^^^^^^^^^^
        # ```
        def visit_source_encoding_node(node)
          # TODO
          s(node, :colon2, s(node, :const, :Encoding), :UTF_8)
        end

        # ```
        # __FILE__
        # ^^^^^^^^
        # ```
        def visit_source_file_node(node)
          s(node, :str, node.filepath)
        end

        # ```
        # __LINE__
        # ^^^^^^^^
        # ```
        def visit_source_line_node(node)
          s(node, :lit, node.location.start_line)
        end

        # ```
        # foo(*bar)
        #     ^^^^
        #
        # def foo((bar, *baz)); end
        #               ^^^^
        #
        # def foo(*); bar(*); end
        #                 ^
        # ```
        def visit_splat_node(node)
          if node.expression.nil?
            s(node, :splat)
          else
            s(node, :splat, visit(node.expression))
          end
        end

        # A list of statements.
        def visit_statements_node(node)
          first, *rest = node.body

          if rest.empty?
            visit(first)
          else
            s(node, :block).concat(visit_all(node.body))
          end
        end

        # ```
        # "foo"
        # ^^^^^
        # ```
        def visit_string_node(node)
          unescaped = node.unescaped

          if node.forced_binary_encoding?
            unescaped = unescaped.dup
            unescaped.force_encoding(Encoding::BINARY)
          end

          s(node, :str, unescaped)
        end

        # ```
        # super(foo)
        # ^^^^^^^^^^
        # ```
        def visit_super_node(node)
          arguments = node.arguments&.arguments || []
          block = node.block

          if block.is_a?(BlockArgumentNode)
            arguments << block
            block = nil
          end

          visit_block(node, s(node, :super).concat(visit_all(arguments)), block)
        end

        # ```
        # :foo
        # ^^^^
        # ```
        def visit_symbol_node(node)
          node.value == "!@" ? s(node, :lit, :"!@") : s(node, :lit, node.unescaped.to_sym)
        end

        # ```
        # true
        # ^^^^
        # ```
        def visit_true_node(node)
          s(node, :true)
        end

        # ```
        # undef foo
        # ^^^^^^^^^
        # ```
        def visit_undef_node(node)
          names = node.names.map { |name| s(node, :undef, visit(name)) }
          names.length == 1 ? names.first : s(node, :block).concat(names)
        end

        # ```
        # unless foo; bar end
        # ^^^^^^^^^^^^^^^^^^^
        #
        # bar unless foo
        # ^^^^^^^^^^^^^^
        # ```
        def visit_unless_node(node)
          s(node, :if, visit(node.predicate), visit(node.else_clause), visit(node.statements))
        end

        # ```
        # until foo; bar end
        # ^^^^^^^^^^^^^^^^^
        #
        # bar until foo
        # ^^^^^^^^^^^^^
        # ```
        def visit_until_node(node)
          s(node, :until, visit(node.predicate), visit(node.statements), !node.begin_modifier?)
        end

        # ```
        # case foo; when bar; end
        #           ^^^^^^^^^^^^^
        # ```
        def visit_when_node(node)
          s(node, :when, s(node, :array).concat(visit_all(node.conditions))).concat(node.statements.nil? ? [nil] : visit_all(node.statements.body))
        end

        # ```
        # while foo; bar end
        # ^^^^^^^^^^^^^^^^^^
        #
        # bar while foo
        # ^^^^^^^^^^^^^
        # ```
        def visit_while_node(node)
          s(node, :while, visit(node.predicate), visit(node.statements), !node.begin_modifier?)
        end

        # ```
        # `foo`
        # ^^^^^
        # ```
        def visit_x_string_node(node)
          result = s(node, :xstr, node.unescaped)

          if node.heredoc?
            result.line = node.content_loc.start_line
            result.line_max = node.content_loc.end_line
          end

          result
        end

        # ```
        # yield
        # ^^^^^
        #
        # yield 1
        # ^^^^^^^
        # ```
        def visit_yield_node(node)
          s(node, :yield).concat(visit_all(node.arguments&.arguments || []))
        end

        private

        # Create a new compiler with the given options.
        def copy_compiler(in_def: self.in_def, in_pattern: self.in_pattern)
          Compiler.new(file, in_def: in_def, in_pattern: in_pattern)
        end

        # Create a new Sexp object from the given prism node and arguments.
        def s(node, *arguments)
          result = Sexp.new(*arguments)
          result.file = file
          result.line = node.location.start_line
          result.line_max = node.location.end_line
          result
        end

        # Visit a block node, which will modify the AST by wrapping the given
        # visited node in an iter node.
        def visit_block(node, sexp, block)
          if block.nil?
            sexp
          else
            parameters =
              case block.parameters
              when nil, ItParametersNode, NumberedParametersNode
                0
              else
                visit(block.parameters)
              end

            if block.body.nil?
              s(node, :iter, sexp, parameters)
            else
              s(node, :iter, sexp, parameters, visit(block.body))
            end
          end
        end

        # Pattern constants get wrapped in another layer of :const.
        def visit_pattern_constant(node)
          case node
          when nil
            # nothing
          when ConstantReadNode
            visit(node)
          else
            s(node, :const, visit(node))
          end
        end

        # Visit the value of a write, which will be on the right-hand side of
        # a write operator. Because implicit arrays can have splats, those could
        # potentially be wrapped in an svalue node.
        def visit_write_value(node)
          if node.is_a?(ArrayNode) && node.opening_loc.nil?
            if node.elements.length == 1 && node.elements.first.is_a?(SplatNode)
              s(node, :svalue, visit(node.elements.first))
            else
              s(node, :svalue, visit(node))
            end
          else
            visit(node)
          end
        end
      end

      private_constant :Compiler

      # Parse the given source and translate it into the seattlerb/ruby_parser
      # gem's Sexp format.
      def parse(source, filepath = "(string)")
        translate(Prism.parse(source, filepath: filepath, partial_script: true), filepath)
      end

      # Parse the given file and translate it into the seattlerb/ruby_parser
      # gem's Sexp format.
      def parse_file(filepath)
        translate(Prism.parse_file(filepath, partial_script: true), filepath)
      end

      class << self
        # Parse the given source and translate it into the seattlerb/ruby_parser
        # gem's Sexp format.
        def parse(source, filepath = "(string)")
          new.parse(source, filepath)
        end

        # Parse the given file and translate it into the seattlerb/ruby_parser
        # gem's Sexp format.
        def parse_file(filepath)
          new.parse_file(filepath)
        end
      end

      private

      # Translate the given parse result and filepath into the
      # seattlerb/ruby_parser gem's Sexp format.
      def translate(result, filepath)
        if result.failure?
          error = result.errors.first
          raise ::RubyParser::SyntaxError, "#{filepath}:#{error.location.start_line} :: #{error.message}"
        end

        result.value.accept(Compiler.new(filepath))
      end
    end
  end
end
prism-1.5.1/prism.gemspec000066400000000000000000000123761506127434000153620ustar00rootroot00000000000000# frozen_string_literal: true

Gem::Specification.new do |spec|
  spec.name = "prism"
  spec.version = "1.5.1"
  spec.authors = ["Shopify"]
  spec.email = ["ruby@shopify.com"]

  spec.summary = "Prism Ruby parser"
  spec.homepage = "https://github.com/ruby/prism"
  spec.license = "MIT"

  spec.required_ruby_version = ">= 2.7.0"

  spec.require_paths = ["lib"]
  spec.files = [
    "BSDmakefile",
    "CHANGELOG.md",
    "CODE_OF_CONDUCT.md",
    "CONTRIBUTING.md",
    "LICENSE.md",
    "Makefile",
    "README.md",
    "config.yml",
    "docs/build_system.md",
    "docs/configuration.md",
    "docs/cruby_compilation.md",
    "docs/design.md",
    "docs/encoding.md",
    "docs/fuzzing.md",
    "docs/heredocs.md",
    "docs/javascript.md",
    "docs/local_variable_depth.md",
    "docs/mapping.md",
    "docs/parser_translation.md",
    "docs/parsing_rules.md",
    "docs/releasing.md",
    "docs/relocation.md",
    "docs/ripper_translation.md",
    "docs/ruby_api.md",
    "docs/ruby_parser_translation.md",
    "docs/serialization.md",
    "docs/testing.md",
    "ext/prism/api_node.c",
    "ext/prism/api_pack.c",
    "ext/prism/extension.c",
    "ext/prism/extension.h",
    "include/prism.h",
    "include/prism/ast.h",
    "include/prism/defines.h",
    "include/prism/diagnostic.h",
    "include/prism/encoding.h",
    "include/prism/node.h",
    "include/prism/options.h",
    "include/prism/pack.h",
    "include/prism/parser.h",
    "include/prism/prettyprint.h",
    "include/prism/regexp.h",
    "include/prism/static_literals.h",
    "include/prism/util/pm_buffer.h",
    "include/prism/util/pm_char.h",
    "include/prism/util/pm_constant_pool.h",
    "include/prism/util/pm_integer.h",
    "include/prism/util/pm_list.h",
    "include/prism/util/pm_memchr.h",
    "include/prism/util/pm_newline_list.h",
    "include/prism/util/pm_strncasecmp.h",
    "include/prism/util/pm_string.h",
    "include/prism/util/pm_strpbrk.h",
    "include/prism/version.h",
    "lib/prism.rb",
    "lib/prism/compiler.rb",
    "lib/prism/desugar_compiler.rb",
    "lib/prism/dispatcher.rb",
    "lib/prism/dot_visitor.rb",
    "lib/prism/dsl.rb",
    "lib/prism/ffi.rb",
    "lib/prism/inspect_visitor.rb",
    "lib/prism/lex_compat.rb",
    "lib/prism/mutation_compiler.rb",
    "lib/prism/node_ext.rb",
    "lib/prism/node.rb",
    "lib/prism/pack.rb",
    "lib/prism/parse_result.rb",
    "lib/prism/parse_result/comments.rb",
    "lib/prism/parse_result/errors.rb",
    "lib/prism/parse_result/newlines.rb",
    "lib/prism/pattern.rb",
    "lib/prism/polyfill/append_as_bytes.rb",
    "lib/prism/polyfill/byteindex.rb",
    "lib/prism/polyfill/scan_byte.rb",
    "lib/prism/polyfill/unpack1.rb",
    "lib/prism/polyfill/warn.rb",
    "lib/prism/reflection.rb",
    "lib/prism/relocation.rb",
    "lib/prism/serialize.rb",
    "lib/prism/string_query.rb",
    "lib/prism/translation.rb",
    "lib/prism/translation/parser.rb",
    "lib/prism/translation/parser_current.rb",
    "lib/prism/translation/parser33.rb",
    "lib/prism/translation/parser34.rb",
    "lib/prism/translation/parser35.rb",
    "lib/prism/translation/parser/builder.rb",
    "lib/prism/translation/parser/compiler.rb",
    "lib/prism/translation/parser/lexer.rb",
    "lib/prism/translation/ripper.rb",
    "lib/prism/translation/ripper/sexp.rb",
    "lib/prism/translation/ripper/shim.rb",
    "lib/prism/translation/ruby_parser.rb",
    "lib/prism/visitor.rb",
    "prism.gemspec",
    "rbi/prism.rbi",
    "rbi/prism/compiler.rbi",
    "rbi/prism/dsl.rbi",
    "rbi/prism/inspect_visitor.rbi",
    "rbi/prism/node_ext.rbi",
    "rbi/prism/node.rbi",
    "rbi/prism/parse_result.rbi",
    "rbi/prism/reflection.rbi",
    "rbi/prism/string_query.rbi",
    "rbi/prism/translation/parser.rbi",
    "rbi/prism/translation/parser33.rbi",
    "rbi/prism/translation/parser34.rbi",
    "rbi/prism/translation/parser35.rbi",
    "rbi/prism/translation/ripper.rbi",
    "rbi/prism/visitor.rbi",
    "sig/prism.rbs",
    "sig/prism/compiler.rbs",
    "sig/prism/dispatcher.rbs",
    "sig/prism/dot_visitor.rbs",
    "sig/prism/dsl.rbs",
    "sig/prism/inspect_visitor.rbs",
    "sig/prism/lex_compat.rbs",
    "sig/prism/mutation_compiler.rbs",
    "sig/prism/node_ext.rbs",
    "sig/prism/node.rbs",
    "sig/prism/pack.rbs",
    "sig/prism/parse_result.rbs",
    "sig/prism/parse_result/comments.rbs",
    "sig/prism/pattern.rbs",
    "sig/prism/reflection.rbs",
    "sig/prism/relocation.rbs",
    "sig/prism/serialize.rbs",
    "sig/prism/string_query.rbs",
    "sig/prism/visitor.rbs",
    "src/diagnostic.c",
    "src/encoding.c",
    "src/node.c",
    "src/options.c",
    "src/pack.c",
    "src/prettyprint.c",
    "src/prism.c",
    "src/regexp.c",
    "src/serialize.c",
    "src/static_literals.c",
    "src/token_type.c",
    "src/util/pm_buffer.c",
    "src/util/pm_char.c",
    "src/util/pm_constant_pool.c",
    "src/util/pm_integer.c",
    "src/util/pm_list.c",
    "src/util/pm_memchr.c",
    "src/util/pm_newline_list.c",
    "src/util/pm_string.c",
    "src/util/pm_strncasecmp.c",
    "src/util/pm_strpbrk.c"
  ]

  spec.extensions = ["ext/prism/extconf.rb"]
  spec.metadata["allowed_push_host"] = "https://rubygems.org"
  spec.metadata["source_code_uri"] = "https://github.com/ruby/prism"
  spec.metadata["changelog_uri"] = "https://github.com/ruby/prism/blob/main/CHANGELOG.md"
end
prism-1.5.1/rakelib/000077500000000000000000000000001506127434000142635ustar00rootroot00000000000000prism-1.5.1/rakelib/bear.rake000066400000000000000000000003751506127434000160450ustar00rootroot00000000000000# frozen_string_literal: true

desc "Generate compilation database"
task bear: [:clobber, :templates] do
  sh "which bear" do |ok, _|
    abort("Installing bear is required to generate the compilation database") unless ok
  end

  sh "bear -- make"
end
prism-1.5.1/rakelib/cargo.rake000066400000000000000000000105601506127434000162240ustar00rootroot00000000000000namespace :cargo do
  CRATES = ["ruby-prism-sys", "ruby-prism"]

  desc "Build and test the Rust packages"
  task build: [:templates] do
    gemspec = Gem::Specification.load("prism.gemspec")

    prism_sys_dir = Pathname(File.expand_path(File.join(__dir__, "../rust", "ruby-prism-sys")))
    prism_sys_vendor_dir = prism_sys_dir.join("vendor/prism-#{gemspec.version}")

    rm_rf(prism_sys_dir.join("vendor"))
    mkdir_p(prism_sys_vendor_dir)
    cp_r("./include", prism_sys_vendor_dir.join("include"))
    cp_r("./src", prism_sys_vendor_dir.join("src"))

    prism_dir = Pathname(File.expand_path(File.join(__dir__, "../rust", "ruby-prism")))
    prism_vendor_dir = prism_dir.join("vendor/prism-#{gemspec.version}")

    rm_rf(prism_dir.join("vendor"))
    mkdir_p(prism_vendor_dir)
    cp(File.expand_path("../config.yml", __dir__), prism_vendor_dir.join("config.yml"))

    # Align the Cargo.toml version with the gemspec version
    CRATES.each do |crate|
      cargo_toml_path = Pathname.new("rust/#{crate}/Cargo.toml")
      old_cargo_toml = cargo_toml_path.read
      new_cargo_toml = old_cargo_toml
        .gsub(/^version = ".*"/, %(version = "#{gemspec.version}"))
        .gsub(/^ruby-prism-sys = { version = ".*",/, %(ruby-prism-sys = { version = "#{gemspec.version}",))

      File.write(cargo_toml_path, new_cargo_toml)
    end
  end

  desc "Run all cargo tests"
  task test: [:build] do
    CRATES.each do |crate|
      Dir.chdir("rust/#{crate}") do
        sh "cargo test -- --nocapture"
      end
    end
  end

  desc "Run all examples"
  task examples: [:build] do
    Dir.chdir("rust/ruby-prism") do
      Dir.glob("examples/*").each do |example|
        puts "Running #{example}"

        script = File.join(example, "run.sh")
        if File.exist?(script)
          sh script
        else
          sh "cargo run --example #{example}"
        end
      end
    end
  end

  desc "Run clippy the Rust code"
  task lint: [:build] do
    CRATES.each do |crate|
      Dir.chdir("rust/#{crate}") do
        sh "cargo clippy --tests -- -W 'clippy::pedantic'"
        sh "cargo fmt --all -- --check"
      end
    end
  end

  desc "Run rustfmt on the Rust code"
  task fmt: [:build] do
    CRATES.each do |crate|
      Dir.chdir("rust/#{crate}") do
        sh "cargo fmt --all"
      end
    end
  end

  namespace :sanitize do
    [:leak, :address].each do |sanitizer|
      desc "Test with #{sanitizer} sanitizer"
      task sanitizer => :build do
        require "json"
        require "net/http"

        old_env = ENV.to_h
        ENV['RUSTFLAGS'] = "-Zsanitizer=#{sanitizer}"
        ENV['RUSTDOCFLAGS'] = "-Zsanitizer=#{sanitizer}"
        ENV['ASAN_OPTIONS'] = 'detect_stack_use_after_return=1'
        ENV['RUST_BACKTRACE'] = '0'

        target_info_url = "https://raw.githubusercontent.com/oxidize-rb/rb-sys/main/data/derived/ruby-to-rust.json"
        toolchain_data = Net::HTTP.get(URI.parse(target_info_url))
        toolchain_data = JSON.parse(toolchain_data)
        gem_platform = Gem::Platform.local
        current_target = toolchain_data.fetch("#{gem_platform.cpu}-#{gem_platform.os}")

        CRATES.each do |crate|
          Dir.chdir("rust/#{crate}") do
            sh("cargo +nightly test -Zbuild-std --target=#{current_target} -- --nocapture")
          end
        end
      ensure
        ENV.replace(old_env)
      end
    end

    desc "Test with all sanitizers"
    task all: [:leak, :address]
  end

  namespace :publish do
    desc "Publish the Rust crates"
    task :real do
      print "🚢 Publishing to crates.io in 5 seconds (use ctrl-c to cancel)"

      10.times do |i|
        sleep 0.5
        print "."
      end

      Rake::Task["cargo:build"].invoke

      CRATES.each do |crate|
        Dir.chdir("rust/#{crate}") do
          puts "🚢 Publishing #{crate} to crates.io"
          sh "cargo publish --allow-dirty"
        end
      end
    end

    desc "Dry run the publish of the Rust crates"
    task :dry do
      print "🌵 Running publish with --dry-run, use `rake cargo:publish:real` to actually publish"

      6.times do |i|
        sleep 0.5
        print "."
      end

      Rake::Task["cargo:build"].invoke

      CRATES.each do |crate|
        Dir.chdir("rust/#{crate}") do
          puts "🌵 [dry-run] Checking publish of #{crate} to crates.io"
          sh "cargo publish --dry-run --allow-dirty"
        end
      end
    end
  end

  task publish: ["cargo:publish:dry"]
end
prism-1.5.1/rakelib/char.rake000066400000000000000000000036311506127434000160470ustar00rootroot00000000000000# frozen_string_literal: true

desc "Generate the lookup tables for pm_char.c"
namespace :generate do
  task :char do
    puts "static const uint8_t pm_char_table[256] = {"
    puts "//#{(0...16).map { |value| value.to_s(16).upcase }.join("  ")}"

    (0...256).each_slice(16).with_index do |slice, row_index|
      row =
        slice.map do |codepoint|
          character = codepoint.chr

          value = 0
          value |= (1 << 0) if ["\t", "\n", "\v", "\f", "\r", " "].include?(character)
          value |= (1 << 1) if ["\t", "\v", "\f", "\r", " "].include?(character)
          value |= (1 << 2) if ["e", "i", "m", "n", "o", "s", "u", "x"].include?(character)

          "%d," % value
        end

      puts "  #{row.join(" ")} // #{row_index.to_s(16).upcase}x\n"
    end

    puts "};\nstatic const uint8_t pm_number_table[256] = {"
    puts "  // #{(0...16).map { |value| value.to_s(16).upcase }.join("     ")}"

    (0...256).each_slice(16).with_index do |slice, row_index|
      row =
        slice.map do |codepoint|
          character = codepoint.chr

          value = 0
          value |= (1 << 0) if ("0".."1").include?(character)
          value |= (1 << 1) if ("0".."1").include?(character) || character == "_"
          value |= (1 << 2) if ("0".."7").include?(character)
          value |= (1 << 3) if ("0".."7").include?(character) || character == "_"
          value |= (1 << 4) if ("0".."9").include?(character)
          value |= (1 << 5) if ("0".."9").include?(character) || character == "_"
          value |= (1 << 6) if ("0".."9").include?(character) || ("a".."f").include?(character) || ("A".."F").include?(character)
          value |= (1 << 7) if ("0".."9").include?(character) || ("a".."f").include?(character) || ("A".."F").include?(character) || character == "_"

          "0x%02x," % value
        end

      puts "  #{row.join(" ")} // #{row_index.to_s(16).upcase}x\n"
    end
    puts "};"
  end
end
prism-1.5.1/rakelib/check_manifest.rake000066400000000000000000000036171506127434000201010ustar00rootroot00000000000000desc "Perform a sanity check on the gemspec file list"
task check_manifest: :templates do
  raw_gemspec = Bundler.load_gemspec("prism.gemspec")

  ignore_directories = %w[
    .bundle
    .idea
    .git
    .github
    .cache
    .ruby-lsp
    .vscode
    autom4te.cache
    bin
    build
    cpp
    doc
    fuzz
    gemfiles
    javascript
    java
    java-wasm
    pkg
    rakelib
    rust
    sample
    snapshots
    sorbet
    suppressions
    templates
    test
    top-100-gems
    tmp
    vendor
  ]

  ignore_files = %w[
    .ruby-version
    .editorconfig
    .git-blame-ignore-revs
    .gitattributes
    .gitignore
    .gitmodules
    .travis.yml
    *.iml
    Doxyfile
    Gemfile
    Gemfile.lock
    Makefile
    Rakefile
    Steepfile
    config.log
    config.status
    configure.ac
    compile_commands.json
    include/prism/config.h
    lib/prism/prism.{so,bundle,jar}
    sig/_*/*.rbs
    sig/**/_*/*.rbs
    tags
  ]

  intended_directories = Dir.children(".")
    .select { |filename| File.directory?(filename) }
    .reject { |filename| ignore_directories.any? { |ig| File.fnmatch?(ig, filename) } }

  intended_files = Dir.children(".")
    .select { |filename| File.file?(filename) }
    .reject { |filename| ignore_files.any? { |ig| File.fnmatch?(ig, filename, File::FNM_EXTGLOB) } }

  intended_files += Dir.glob(intended_directories.map { |d| File.join(d, "/**/*") })
    .select { |filename| File.file?(filename) }
    .reject { |filename| ignore_files.any? { |ig| File.fnmatch?(ig, filename, File::FNM_EXTGLOB) } }
    .sort

  intended_files -= %w[a.out test.c test.rb]

  spec_files = raw_gemspec.files.sort
  missing_files = intended_files - spec_files

  unless missing_files.empty?
    puts "✖  files must be added to either the gemspec or the ignore list:"
    missing_files.sort.each { |f| puts "- #{f}" }
    puts "(see #{__FILE__})"
    exit(1)
  end

  puts "☑  manifest looks good"
end
prism-1.5.1/rakelib/lex.rake000066400000000000000000000270401506127434000157220ustar00rootroot00000000000000# frozen_string_literal: true
# typed: ignore

module Prism
  # This class is responsible for lexing files with both lex_compat and
  # lex_ripper and ensuring they match up. It keeps track of the files which
  # failed to match up, and the files which passed.
  class LexTask
    attr_reader :failing_files, :passing_file_count

    def initialize
      @passing_file_count = 0
      @failing_files = []
    end

    def compare(filepath)
      # If we can't read the file, then ignore it.
      return true if !File.file?(filepath) || !File.readable?(filepath)

      # Read the file into memory.
      source = File.read(filepath)

      # If the filepath contains invalid Ruby code, then ignore it.
      begin
        RubyVM::AbstractSyntaxTree.parse(source)
      rescue ArgumentError, SyntaxError
        return true
      end

      result = Prism.lex_compat(source)
      if result.errors.empty? && Prism.lex_ripper(source) == result.value
        @passing_file_count += 1
        true
      else
        @failing_files << filepath
        false
      end
    end

    def failing_file_count
      failing_files.length
    end

    def failed?
      failing_files.any?
    end

    def summary
      <<~RESULTS
        PASSING=#{passing_file_count}
        FAILING=#{failing_file_count}
        PERCENT=#{(passing_file_count.to_f / (passing_file_count + failing_file_count) * 100).round(2)}%
      RESULTS
    end
  end

  class << self
    # This method is responsible for iterating through a list of items and running
    # each item in a separate thread. It will block until all items have been
    # processed. This is particularly useful for tasks that are IO-bound like
    # downloading files or reading files from disk.
    def parallelize(items, &block)
      Thread.abort_on_exception = true

      queue = Queue.new
      items.each { |item| queue << item }

      workers =
        ENV.fetch("WORKERS") { 16 }.to_i.times.map do
          parallelize_thread(queue, &block)
        end

      workers.map(&:join)
    end

    private

    # Create a new thread with a minimal number of locals that it can access.
    def parallelize_thread(queue, &block)
      Thread.new { block.call(queue.shift) until queue.empty? }
    end
  end
end

TARGETS = {
  ruby: {
    repo: "https://github.com/ruby/ruby",
    sha: "52837fcec2340048f9bdc2169cde17243c5e9d6d",
    excludes: [
      # Contains an invalid break
      "sample/trick2018/01-kinaba/entry.rb",

      # Contains invalid syntax
      "spec/ruby/command_line/fixtures/bad_syntax.rb",

      # Requires an implicit -x, which ripper does not respect
      "tool/merger.rb",
    ]
  },
  discourse: {
    repo: "https://github.com/discourse/discourse",
    sha: "a5542eeab07ec43deb3bcd391e2e56ad30ebd676"
  }
}

# For each of the targets, we're going to define a task that will clone the repo
# into tmp/targets/TARGET at the specified SHA.
TARGETS.each do |name, target|
  repo = target.fetch(:repo)
  dirpath = File.join("tmp", "targets", name.to_s)

  desc "Clone #{repo} into #{dirpath}"
  file dirpath do
    mkdir_p dirpath
    chdir dirpath do
      sh "git init"
      sh "git remote add origin #{repo}"
      sh "git fetch --depth=1 origin #{target.fetch(:sha)}"
      sh "git reset --hard FETCH_HEAD"
    end
  end

  desc "Lex #{repo} and compare with lex_compat"
  task "lex:#{name}" => [dirpath, :compile] do
    $:.unshift(File.expand_path("../lib", __dir__))
    require "ripper"
    require "prism"

    plain_text = ENV.fetch("CI", false)
    warn_failing = ENV.fetch("VERBOSE", false)

    lex_task = Prism::LexTask.new
    filepaths = Dir[File.join(dirpath, "**", "*.rb")]

    if excludes = target[:excludes]
      filepaths -= excludes.map { |exclude| File.join(dirpath, exclude) }
    end

    filepaths.each do |filepath|
      print("#{filepath} ") if plain_text

      if lex_task.compare(filepath)
        print(plain_text ? "." : "\033[32m.\033[0m")
      else
        warn(filepath) if warn_failing
        print(plain_text ? "E" : "\033[31mE\033[0m")
      end

      puts if plain_text
    end

    puts("\n\n")

    if lex_task.failing_files.any?
      puts("Uh oh, there are some files which were previously passing but are now failing. Here are the files:")
      puts("    - #{lex_task.failing_files.map { _1.gsub(/tmp\/targets\/[a-zA-Z0-9_]*\//, "") }.join("\n    - ")}")
    else
      puts("The todos list in lex.rake is up to date")
    end

    puts(lex_task.summary)
    exit(1) if lex_task.failed?
  end
end

desc "Lex files and compare with lex_compat"
task lex: :compile do
  $:.unshift(File.expand_path("../lib", __dir__))
  require "ripper"
  require "prism"

  plain_text = ENV.fetch("CI", false)
  warn_failing = ENV.fetch("VERBOSE", false)

  lex_task = Prism::LexTask.new
  filepaths = Dir[ENV.fetch("FILEPATHS")]

  filepaths.each do |filepath|
    print("#{filepath} ") if plain_text

    if lex_task.compare(filepath)
      print(plain_text ? "." : "\033[32m.\033[0m")
    else
      warn(filepath) if warn_failing
      print(plain_text ? "E" : "\033[31mE\033[0m")
    end

    puts if plain_text
  end

  puts("\n\n#{lex_task.summary}")
  exit(1) if lex_task.failed?
end

directory "tmp/failing"

desc "Lex against the most recent version of various rubygems"
task "lex:rubygems": [:compile, "tmp/failing"] do
  $:.unshift(File.expand_path("../lib", __dir__))
  require "net/http"
  require "ripper"
  require "rubygems/package"
  require "tmpdir"
  require "prism"

  items = []
  Gem::SpecFetcher.new.available_specs(:latest).first.each do |source, gems|
    gems.each do |tuple|
      gem_name = File.basename(tuple.spec_name, ".gemspec")
      gem_uri = source.uri.merge("/gems/#{gem_name}.gem")
      items << [gem_name, gem_uri]
    end
  end

  warn_failing = ENV.fetch("VERBOSE", false)
  passing_gem_count = 0
  failing_gem_count = 0

  Prism.parallelize(items) do |(gem_name, gem_uri)|
  # items.each do |(gem_name, gem_uri)|
    response = Net::HTTP.get_response(gem_uri)
    next unless response.is_a?(Net::HTTPSuccess)

    Dir.mktmpdir do |directory|
      filepath = File.join(directory, "#{gem_name}.gem")
      File.write(filepath, response.body)

      begin
        Gem::Package.new(filepath).extract_files(directory, "[!~]*")
      rescue
        # If the gem fails to extract, we'll just skip it
        next
      end

      lex_task = Prism::LexTask.new
      Dir[File.join(directory, "**", "*.rb")].each do |filepath|
        unless lex_task.compare(filepath)
          cp filepath, "tmp/failing/#{SecureRandom.hex}-#{File.basename(filepath)}"
        end
      end

      if lex_task.failed?
        failing_gem_count += 1
        print("\033[31mE\033[0m")
      else
        passing_gem_count += 1
        warn(gem_name) if warn_failing
        print("\033[32m.\033[0m")
      end
    end
  end

  puts(<<~RESULTS)
    PASSING=#{passing_gem_count}
    FAILING=#{failing_gem_count}
    PERCENT=#{(passing_gem_count.to_f / (passing_gem_count + failing_gem_count) * 100).round(2)}%
  RESULTS
end

TOP_100_GEM_FILENAME = "rakelib/top-100-gems.yml"
TOP_100_GEMS_DIR = "top-100-gems"
TOP_100_GEMS_INVALID_SYNTAX_PREFIXES = %w[
  top-100-gems/brakeman-5.4.1/bundle/ruby/3.1.0/gems/erubis-2.7.0/lib/erubis/helpers/rails_form_helper.rb
  top-100-gems/devise-4.9.2/lib/generators/active_record/templates/
  top-100-gems/devise-4.9.2/lib/generators/templates/controllers/
  top-100-gems/fastlane-2.212.1/fastlane/lib/assets/custom_action_template.rb
]

namespace :download do
  directory TOP_100_GEMS_DIR

  desc "Download the top 100 rubygems under #{TOP_100_GEMS_DIR}/"
  task topgems: TOP_100_GEMS_DIR do
    $:.unshift(File.expand_path("../lib", __dir__))
    require "net/http"
    require "rubygems/package"
    require "tmpdir"

    Prism.parallelize(YAML.safe_load_file(TOP_100_GEM_FILENAME)) do |gem_name|
      directory = File.expand_path("#{TOP_100_GEMS_DIR}/#{gem_name}")
      next if File.directory?(directory)

      puts "Downloading #{gem_name}"

      uri = URI.parse("https://rubygems.org/gems/#{gem_name}.gem")
      response = Net::HTTP.get_response(uri)
      raise gem_name unless response.is_a?(Net::HTTPSuccess)

      Dir.mktmpdir do |tmpdir|
        filepath = File.join(tmpdir, "#{gem_name}.gem")
        File.write(filepath, response.body)
        Gem::Package.new(filepath).extract_files(directory, "**/*.rb")
      end
    end
  end
end

# This task parses each .rb file of the top 100 gems with prism and ensures they
# parse successfully (unless they are invalid syntax as confirmed by "ruby -c").
desc "Parse the top 100 rubygems"
task "parse:topgems": ["download:topgems", :compile] do
  $:.unshift(File.expand_path("../lib", __dir__))
  require "prism"

  incorrect = []
  Prism.parallelize(Dir["#{TOP_100_GEMS_DIR}/**/*.rb"]) do |filepath|
    result = Prism.parse_file(filepath)

    if TOP_100_GEMS_INVALID_SYNTAX_PREFIXES.any? { |prefix| filepath.start_with?(prefix) }
      # Check that the file failed to parse and that it actually contains
      # invalid syntax.
      incorrect << filepath if result.success? || system(RbConfig.ruby, "-c", filepath, out: File::NULL, err: File::NULL)
    else
      incorrect << filepath unless result.success?
    end
  end

  if incorrect.any?
    warn("The following files failed to parse:")
    warn("  - #{incorrect.join("\n  - ")}")
    exit(1)
  else
    puts("All files parsed successfully.")
  end
end

# This task lexes against the top 100 gems, and will exit(1) if any files fail
# to lex properly.
desc "Lex against the top 100 rubygems"
task "lex:topgems": ["download:topgems", :compile] do
  $:.unshift(File.expand_path("../lib", __dir__))
  require "net/http"
  require "ripper"
  require "rubygems/package"
  require "tmpdir"
  require "prism"

  gem_names = YAML.safe_load_file(TOP_100_GEM_FILENAME)
  failing_files = {}

  Prism.parallelize(gem_names) do |gem_name|
    puts "Lexing #{gem_name}"
    directory = File.expand_path("#{TOP_100_GEMS_DIR}/#{gem_name}")

    lex_task = Prism::LexTask.new
    Dir[File.join(directory, "**", "*.rb")].each do |filepath|
      lex_task.compare(filepath)
    end

    gem_failing_files = lex_task.failing_files.map { |todo| todo.delete_prefix("#{directory}/") }
    failing_files[gem_name] = gem_failing_files if gem_failing_files.any?
  end

  failing = failing_files.length
  passing = gem_names.length - failing

  puts(<<~RESULTS)
    PASSING=#{passing}
    FAILING=#{failing}
    PERCENT=#{(passing.to_f / gem_names.length * 100).round(2)}%
  RESULTS

  if failing > 0
    warn("The following files failed to lex:")
    warn(failing_files.to_yaml)
    exit(1)
  end
end

task "serialized_size:topgems": ["download:topgems"] do
  $:.unshift(File.expand_path("../lib", __dir__))
  require "prism"

  files = Dir["#{TOP_100_GEMS_DIR}/**/*.rb"]
  total_source_size = 0
  total_serialized_size = 0
  ratios = []
  files.each do |file|
    source_size = File.size(file)
    next if source_size == 0
    total_source_size += source_size

    serialized = Prism.dump_file(file)
    serialized_size = serialized.bytesize
    total_serialized_size += serialized_size

    ratios << Rational(serialized_size, source_size)
  end
  f = '%.3f'
  puts "Total sizes for top 100 gems:"
  puts "total source size:     #{'%9d' % total_source_size}"
  puts "total serialized size: #{'%9d' % total_serialized_size}"
  puts "total serialized/total source: #{f % (total_serialized_size.to_f / total_source_size)}"
  puts
  puts "Stats of ratio serialized/source per file:"
  puts "average: #{f % (ratios.sum / ratios.size)}"
  puts "median:  #{f % ratios.sort[ratios.size/2]}"
  puts "1st quartile: #{f % ratios.sort[ratios.size/4]}"
  puts "3rd quartile: #{f % ratios.sort[ratios.size*3/4]}"
  puts "min - max: #{"#{f} - #{f}" % ratios.minmax}"
end
prism-1.5.1/rakelib/lint.rake000066400000000000000000000034761506127434000161070ustar00rootroot00000000000000# frozen_string_literal: true

desc "Lint config.yml"
task :lint do
  require "yaml"
  config = YAML.safe_load_file(File.expand_path("../config.yml", __dir__))

  nodes = config.fetch("nodes")
  names = nodes.map { |node| node.fetch("name") }
  if names.sort != names
    warn("Nodes are not sorted alphabetically")

    names.sort.zip(names).each do |(sorted, unsorted)|
      warn("Expected #{sorted} got #{unsorted}") if sorted != unsorted
    end

    exit(1)
  end

  if (operators = nodes.select { |node| node.fetch("fields", []).any? { |field| field["name"] == "operator" } }).any?
    names = operators.map { |node| node.fetch("name") }
    warn("Nodes cannot have fields named 'operator' because it is a C++ reserved keyword, found in #{names.join(", ")}")
    exit(1)
  end

  if (uncommented = nodes.select { |node| !node.key?("comment") }).any?
    names = uncommented.map { |node| node.fetch("name") }
    warn("Expected all nodes to be commented, missing comments for #{names.join(", ")}")
    exit(1)
  end

  if (uncommented = nodes.select { |node| !%w[MissingNode ProgramNode].include?(node.fetch("name")) && !node.fetch("comment").match?(/^\s{4}/) }).any?
    names = uncommented.map { |node| node.fetch("name") }
    warn("Expected all nodes to have an example, missing comments for #{names.join(", ")}")
    exit(1)
  end

  failed = false
  extensions = %w[.c .h .erb .rb .yml .rake]

  `git ls-files -z`.split("\x0").each do |filepath|
    next unless extensions.include?(File.extname(filepath))

    File.foreach(filepath).with_index(1) do |line, index|
      if line.match?(/[ \t]+$/)
        warn("Trailing spaces found in #{filepath}:#{index}")
        failed = true
      end

      if line.match?(/^\t/)
        warn("Tabs found in #{filepath}:#{index}")
        failed = true
      end
    end
  end

  exit(1) if failed
end
prism-1.5.1/rakelib/rdoc.rake000066400000000000000000000024121506127434000160550ustar00rootroot00000000000000# frozen_string_literal: true

begin
  require "rdoc/task"
rescue LoadError
  # RDoc is not available
  return
end

if RDoc::VERSION <= "6.5.0"
  # RDoc 6.5.0 and earlier did not create an rdoc:coverage task. This patches it
  # in in the same way newer versions do.
  RDoc::Task.prepend(
    Module.new {
      def define
        super.tap do
          namespace rdoc_task_name do
            desc "Print RDoc coverage report"
            task :coverage do
              @before_running_rdoc.call if @before_running_rdoc
              opts = option_list << "-C"
              args = opts + @rdoc_files

              $stderr.puts "rdoc #{args.join(" ")}" if Rake.application.options.trace
              RDoc::RDoc.new.document(args)
            end
          end
        end
      end
    }
  )
end

RDoc::Task.new(:rdoc) do |rdoc|
  rdoc.main = "README.md"
  rdoc.markup = "markdown"

  rdoc.rdoc_dir = "doc/rb"
  rdoc.options.push("--all", "-x", "lib/prism/translation/ripper/shim.rb")

  rdoc.rdoc_files.include(
    "docs/*.md",
    "ext/**/*.c",
    "lib/**/*.rb",
    "src/**/*.c",
    "CODE_OF_CONDUCT.md",
    "CONTRIBUTING.md",
    "LICENSE.md",
    "README.md",
    *Prism::Template::TEMPLATES.grep(/\.(?:c|h|rb)$/)
  )
end

Rake::Task["rdoc"].prerequisites.unshift("templates")
prism-1.5.1/rakelib/seattlerb.rake000066400000000000000000000065271506127434000171260ustar00rootroot00000000000000# frozen_string_literal: true

namespace :seattlerb do
  desc "Ensure there's a local copy of seattlerb/ruby_parser"
  file "tmp/seattlerb" do
    sh "git clone --depth=1 https://github.com/seattlerb/ruby_parser tmp/seattlerb"
  end

  desc "Ensure we have a fixtures directory for the seattlerb tests"
  file "test/prism/fixtures/seattlerb" do
    mkdir_p "test/prism/fixtures/seattlerb"
  end

  desc "Import the seattlerb tests"
  task import: ["tmp/seattlerb", "test/prism/fixtures/seattlerb"] do
    require "bundler/inline"
    gemfile do
      source "https://rubygems.org"
      gem "minitest", require: "minitest/autorun"
      gem "ruby_parser"
    end

    # These files are not valid Ruby
    known_failures = %w[
      test/prism/fixtures/seattlerb/args_dstar__anon_solo.txt
      test/prism/fixtures/seattlerb/args_dstar__anon_trailing.txt
      test/prism/fixtures/seattlerb/args_star__anon_solo.txt
      test/prism/fixtures/seattlerb/args_star__anon_trailing.txt
      test/prism/fixtures/seattlerb/begin_else_return_value.txt
      test/prism/fixtures/seattlerb/block_break.txt
      test/prism/fixtures/seattlerb/block_next.txt
      test/prism/fixtures/seattlerb/block_yield.txt
      test/prism/fixtures/seattlerb/bug_begin_else.txt
      test/prism/fixtures/seattlerb/bug170.txt
      test/prism/fixtures/seattlerb/call_block_arg_unnamed.txt
      test/prism/fixtures/seattlerb/dasgn_icky2.txt
      test/prism/fixtures/seattlerb/iter_array_curly.txt
      test/prism/fixtures/seattlerb/magic_encoding_comment__bad.txt
      test/prism/fixtures/seattlerb/yield_arg.txt
      test/prism/fixtures/seattlerb/yield_call_assocs.txt
      test/prism/fixtures/seattlerb/yield_empty_parens.txt
    ]

    # Cleaning up some file names
    renames = [
      "aGVyZWRvY193dGZfSV9oYXRlX3lvdQ==\n",
      "aV9mdWNraW5nX2hhdGVf\n",
      "aV9oYXZlX25vX2ZyZWFraW5fY2x1ZQ==\n",
      "a2lsbF9tZQ==\n",
      "bW90aGVyZnVja2lu\n",
      "d3RmX2lfaGF0ZV95b3U=\n",
      "d3Rm\n",
      "em9tZ19zb21ldGltZXNfaV9oYXRlX3RoaXNfcHJvamVjdA==\n"
    ].map { _1.unpack1("m") }

    # The license is in the README
    cp "tmp/seattlerb/README.rdoc", "test/prism/fixtures/seattlerb/README.rdoc"

    require_relative "../tmp/seattlerb/test/test_ruby_parser"

    module Hook
      COLLECTED = Hash.new { |hash, key| hash[key] = [] }

      private

      def assert_parse(source, _)
        entry = caller.find { _1.include?("test_ruby_parser.rb") }
        name = entry[/\d+:in `(?:block (?:\(\d+ levels\) )?in )?(?:assert_|test_|?'/, 1]

        COLLECTED[name] << source
        super
      end
    end

    RubyParserTestCase.prepend(Hook)
    Minitest.after_run do
      Hook::COLLECTED.each do |(name, codes)|
        name = name.delete("?")

        # Clean up the names a bit
        renames.each_with_index do |rename, index|
          if name.start_with?(rename)
            name = "difficult#{index}_#{name.delete_prefix(rename)}"
            break
          end
        end

        filepath = "test/prism/fixtures/seattlerb/#{name}.txt"
        File.write(filepath, "#{codes.uniq.sort.join("\n\n")}\n")
      end

      # Remove all invalid Ruby files
      known_failures.each { rm _1 }
    end
  end

  desc "Clean up tmp files related to seattlerb"
  task :clean do
    rm_rf "tmp/seattlerb"
    rm_rf "test/prism/fixtures/seattlerb"
    rm_rf "test/prism/snapshots/seattlerb"
  end
end
prism-1.5.1/rakelib/serialization.rake000066400000000000000000000022031506127434000200010ustar00rootroot00000000000000# frozen_string_literal: true

task "test:java_loader" do
  # Recompile with PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS=1
  # Due to some JRuby bug this does not get propagated to the compile task, so require the caller to set the env var
  # ENV["PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS"] = "1"
  raise "this task requires $SERIALIZE_ONLY_SEMANTICS_FIELDS to be set" unless ENV["PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS"]

  Rake::Task["clobber"].invoke
  Rake::Task["test:java_loader:internal"].invoke
end

task "test:java_loader:internal" => :compile do
  fixtures = File.expand_path("../test/prism/fixtures", __dir__)

  $:.unshift(File.expand_path("../lib", __dir__))
  require "prism"
  raise "this task requires the FFI backend" unless Prism::BACKEND == :FFI
  require "fileutils"
  require 'java'
  require_relative '../tmp/prism.jar'

  Dir["**/*.txt", base: fixtures].each do |relative|
    path = "#{fixtures}/#{relative}"
    puts
    puts path
    serialized = Prism.dump_file(path)
    source_bytes = File.binread(path).unpack('c*')
    parse_result = org.prism.Loader.load(serialized.unpack('c*'), source_bytes)
    puts parse_result.value
  end
end
prism-1.5.1/rakelib/test.rake000066400000000000000000000033041506127434000161060ustar00rootroot00000000000000# frozen_string_literal: true

require "rake/testtask"

config = lambda do |t|
  t.libs << "test"
  t.libs << "lib"
  t.test_files = FileList["test/**/*_test.rb"]
end

Rake::TestTask.new(:test, &config)

namespace :test do
  class GdbTestTask < Rake::TestTask
    def ruby(*args, **options, &block)
      command = "gdb --args #{RUBY} #{args.join(" ")}"
      sh(command, **options, &block)
    end
  end

  GdbTestTask.new(gdb: :compile, &config)

  class LldbTestTask < Rake::TestTask
    def ruby(*args, **options, &block)
      command = "lldb #{RUBY} -- #{args.join(" ")}"
      sh(command, **options, &block)
    end
  end

  LldbTestTask.new(lldb: :compile, &config)

  desc "Run the tests for the rust bindings"
  task :rust do
    ["rust/ruby-prism", "rust/ruby-prism-sys"].each do |dir|
      Dir.chdir(dir) do
        sh("cargo test")
      end
    end
  end
end

# If we're on JRuby or TruffleRuby, we don't want to bother to configure
# memcheck or debug tests.
return if RUBY_ENGINE == "jruby" || RUBY_ENGINE == "truffleruby"

# Don't bother trying to configure memcheck on old versions of Ruby.
return if RUBY_VERSION < "3.0"

# Only attempt to configure memcheck if the gem is installed.
begin
  require "ruby_memcheck"
rescue LoadError
  return
end

namespace :test do
  RubyMemcheck.config(use_only_ruby_free_at_exit: false)
  RubyMemcheck::TestTask.new(valgrind_internal: :compile, &config)

  # Hide test:valgrind_internal from rake -T
  Rake::Task["test:valgrind_internal"].clear_comments

  desc "Run tests under valgrind"
  task :valgrind do
    # Recompile with PRISM_BUILD_DEBUG=1
    ENV["PRISM_BUILD_DEBUG"] = "1"
    Rake::Task["clobber"].invoke
    Rake::Task["test:valgrind_internal"].invoke
  end
end
prism-1.5.1/rakelib/top-100-gems.yml000066400000000000000000000037501506127434000170440ustar00rootroot00000000000000---
- actioncable-7.0.4.3
- actionmailbox-7.0.4.3
- actionmailer-7.0.4.3
- actionpack-7.0.4.3
- actiontext-7.0.4.3
- actionview-7.0.4.3
- activejob-7.0.4.3
- activemodel-7.0.4.3
- activerecord-7.0.4.3
- activestorage-7.0.4.3
- activesupport-7.0.4.3
- addressable-2.8.4
- autoprefixer-rails-10.4.13.0
- aws-partitions-1.744.0
- aws-sdk-cloudformation-1.77.0
- aws-sdk-cloudfront-1.76.0
- aws-sdk-cloudwatch-1.72.0
- aws-sdk-core-3.171.0
- aws-sdk-dynamodb-1.83.0
- aws-sdk-ec2-1.375.0
- aws-sdk-iam-1.77.0
- aws-sdk-kinesis-1.45.0
- aws-sdk-kms-1.63.0
- aws-sdk-lambda-1.93.0
- aws-sdk-rds-1.175.0
- aws-sdk-resources-3.162.0
- aws-sdk-s3-1.120.1
- aws-sdk-secretsmanager-1.73.0
- aws-sdk-sns-1.60.0
- aws-sdk-ssm-1.150.0
- backports-3.24.1
- brakeman-5.4.1
- bundler-2.4.11
- capybara-3.39.0
- concurrent-ruby-1.2.2
- connection_pool-2.4.0
- dalli-3.2.4
- database_cleaner-2.0.2
- devise-4.9.2
- dry-types-1.7.1
- elasticsearch-8.7.0
- elasticsearch-api-8.7.0
- excon-0.99.0
- faker-3.1.1
- faraday-retry-2.1.0
- fastlane-2.212.1
- fog-aws-3.18.0
- git-1.18.0
- google-cloud-errors-1.3.1
- google-protobuf-3.22.2
- googleauth-1.5.1
- graphql-2.0.21
- grpc-1.53.0
- jwt-2.7.0
- loofah-2.20.0
- mail-2.8.1
- mime-types-data-3.2023.0218.1
- minitest-5.18.0
- msgpack-1.7.0
- net-http-persistent-4.0.2
- net-ssh-7.1.0
- newrelic_rpm-9.1.0
- nio4r-2.5.9
- nokogiri-1.14.3
- octokit-6.1.1
- oj-3.14.3
- parser-3.2.2.0
- pg-1.4.6
- plist-3.7.0
- puma-6.2.1
- rack-3.0.7
- rack-cors-2.0.1
- rack-protection-3.0.6
- rack-test-2.1.0
- rails-7.0.4.3
- railties-7.0.4.3
- raindrops-0.20.1
- redis-store-1.9.2
- regexp_parser-2.7.0
- responders-3.1.0
- rouge-4.1.0
- rspec-core-3.12.1
- rspec-mocks-3.12.5
- rubocop-1.50.0
- rubocop-ast-1.28.0
- rubocop-performance-1.17.1
- rubocop-rails-2.19.0
- rubocop-rspec-2.19.0
- ruby-progressbar-1.13.0
- ruby_parser-3.20.0
- rubygems-update-3.4.11
- selenium-webdriver-4.8.6
- sidekiq-7.0.8
- sinatra-3.0.6
- slop-4.10.1
- sqlite3-1.6.2
- thin-1.8.2
- tilt-2.1.0
- yard-0.9.32
- zeitwerk-2.6.7
prism-1.5.1/rakelib/typecheck.rake000066400000000000000000000051171506127434000171120ustar00rootroot00000000000000# frozen_string_literal: true

namespace :typecheck do
  task tapioca: :templates do
    Rake::Task["compile:prism"].invoke

    # Yard crashes parsing steep, which is all run because of tapioca. So to
    # avoid this, we're going to monkey patch yard to ignore these kinds of
    # crashes so tapioca can keep running.
    require "yard"
    YARD.singleton_class.prepend(
      Module.new do
        def parse(*args, **kwargs)
          super
        rescue RangeError
          []
        end
      end
    )

    require "tapioca/internal"
    Tapioca::Cli.start(["configure"])
    Tapioca::Cli.start(["gems", "--exclude", "prism"])
    Tapioca::Cli.start(["todo"])
  end

  desc "Typecheck with Sorbet"
  task sorbet: :templates do
    locals = {
      polyfills: Dir["lib/prism/polyfill/**/*.rb"],
      gem_rbis: Dir["sorbet/rbi/**/*.rbi"]
    }

    File.write("sorbet/typed_overrides.yml", ERB.new(<<~YAML, trim_mode: "-").result_with_hash(locals))
      false:
        - ./lib/prism/lex_compat.rb
        - ./lib/prism/node_ext.rb
        - ./lib/prism/parse_result.rb
        - ./lib/prism/visitor.rb
        - ./lib/prism/translation/parser/lexer.rb
        - ./lib/prism/translation/ripper.rb
        - ./lib/prism/translation/ripper/sexp.rb
        - ./lib/prism/translation/ruby_parser.rb
        - ./lib/prism/inspect_visitor.rb
        - ./sample/prism/multiplex_constants.rb
        # We want to treat all polyfill files as "typed: false"
      <% polyfills.each do |file| -%>
        - ./<%= file %>
      <% end -%>
        # We want to treat all RBI files as "typed: false"
      <% gem_rbis.each do |file| -%>
        - ./<%= file %>
      <% end -%>
    YAML

    File.write("sorbet/config", <<~CONFIG)
      --dir=.
      --ignore=tmp/
      --ignore=vendor/
      --ignore=ext/
      --ignore=test/
      --ignore=rakelib/
      --ignore=Rakefile
      --ignore=top-100-gems/
      # Treat all files as "typed: true" by default
      --typed=true
      # Use the typed-override file to revert some files to "typed: false"
      --typed-override=sorbet/typed_overrides.yml
      # We want to permit initializing a class by constant assignment
      --suppress-error-code=4022
      # We want to permit redefining the existing method as a method alias
      --suppress-error-code=5037
      # We want to permit changing the type of a variable in a loop
      --suppress-error-code=7001
    CONFIG

    exec "#{::Gem::Specification.find_by_name("sorbet-static").full_gem_path}/libexec/sorbet"
  end

  desc "Typecheck with Steep"
  task steep: :templates do
    exec Gem.bin_path("steep", "steep"), "check"
  end
end
prism-1.5.1/rakelib/unparser.rake000066400000000000000000000030011506127434000167600ustar00rootroot00000000000000# frozen_string_literal: true

namespace :unparser do
  desc "Ensure there's a local copy of mbj/unparser"
  file "tmp/unparser" do
    sh "git clone --depth=1 https://github.com/mbj/unparser tmp/unparser"
  end

  desc "Ensure we have a fixtures directory for the unparser tests"
  file "test/prism/fixtures/unparser" do
    mkdir_p "test/prism/fixtures/unparser"
  end

  desc "Import the unparser tests"
  task import: ["tmp/unparser", "test/prism/fixtures/unparser"] do
    cp "tmp/unparser/LICENSE", "test/prism/fixtures/unparser/LICENSE"
    cp_r "tmp/unparser/test/corpus/", "test/prism/fixtures/unparser"

    Dir["test/prism/fixtures/unparser/**/*.rb"].each do |f|
      File.rename(f, f.sub(/\.rb$/, ".txt"))
    end

    # There's an issue with one of the test files in unparser. We'll correct it
    # until https://github.com/mbj/unparser/issues/340 is closed.
    filepath = "test/prism/fixtures/unparser/corpus/literal/pattern.txt"
    File.write(filepath, File.read(filepath).gsub("\"\#{\"a\"}\"", "\"a\""))

    # These files are not valid Ruby
    known_failures = %w[
      test/prism/fixtures/unparser/corpus/literal/binary.txt
      test/prism/fixtures/unparser/corpus/literal/control.txt
      test/prism/fixtures/unparser/corpus/literal/yield.txt
    ]

    # Remove all invalid Ruby files
    known_failures.each { rm _1 }
  end

  desc "Clean up tmp files related to unparser"
  task :clean do
    rm_rf "tmp/unparser"
    rm_rf "test/prism/fixtures/unparser"
    rm_rf "test/prism/snapshots/unparser"
  end
end
prism-1.5.1/rakelib/whitequark.rake000066400000000000000000000077521506127434000173260ustar00rootroot00000000000000# frozen_string_literal: true

# This file's purpose is to extract the examples from the whitequark/parser
# gem and generate a test file that we can use to ensure that our parser
# generates equivalent syntax trees when translating. To do this, it runs the
# parser's test suite but overrides the `assert_parses` method to collect the
# examples into a hash. Then, it writes out the hash to a file that we can use
# to generate our own tests.
#
# To run the test suite, it's important to note that we have to mirror both any
# APIs provided to the test suite (for example the ParseHelper module below).
# This is obviously relatively brittle, but it's effective for now.

namespace :whitequark do
  desc "Ensure there's a local copy of whitequark/parser"
  file "tmp/whitequark" do
    sh "git clone --depth=1 https://github.com/whitequark/parser tmp/whitequark"
  end

  desc "Ensure we have a fixtures directory for the whitequark/parser tests"
  file "test/prism/fixtures/whitequark" do
    mkdir_p "test/prism/fixtures/whitequark"
  end

  desc "Import the whitequark/parser tests"
  task import: ["tmp/whitequark", "test/prism/fixtures/whitequark"] do
    cp "tmp/whitequark/LICENSE.txt", "test/prism/fixtures/whitequark/LICENSE"

    mkdir_p "tmp/whitequark/scratch"
    touch "tmp/whitequark/scratch/helper.rb"
    touch "tmp/whitequark/scratch/parse_helper.rb"
    $:.unshift("tmp/whitequark/scratch")

    require "ast"
    module ParseHelper
      include AST::Sexp

      # This object is going to collect all of the examples from the parser gem
      # into a hash that we can use to generate our own tests.
      COLLECTED = Hash.new { |hash, key| hash[key] = [] }
      ALL_VERSIONS = %w[3.1 3.2 3.3]

      private

      def assert_context(*)
      end

      def assert_diagnoses(*)
      end

      def assert_diagnoses_many(*)
      end

      def refute_diagnoses(*)
      end

      def with_versions(*)
      end

      def assert_parses(_ast, code, _source_maps = "", versions = ALL_VERSIONS)
        # We're going to skip any examples that are for older Ruby versions
        # that we do not support.
        return if (versions & ALL_VERSIONS).empty?

        entry = caller_locations.find { _1.base_label.start_with?("test_") }
        name = entry.base_label.delete_prefix("test_")

        COLLECTED[name] << code
      end
    end

    require "bundler/inline"
    gemfile do
      source "https://rubygems.org"
      gem "parser", require: "parser/current"
      gem "minitest", require: "minitest/autorun"
    end

    require_relative "../tmp/whitequark/test/test_parser"

    Minitest.after_run do
      ParseHelper::COLLECTED.each do |(name, codes)|
        File.write("test/prism/fixtures/whitequark/#{name}.txt", "#{codes.sort.join("\n\n")}\n")
      end

      # These files are not valid Ruby
      known_failures = %w[
        test/prism/fixtures/whitequark/args_assocs_legacy.txt
        test/prism/fixtures/whitequark/args_assocs.txt
        test/prism/fixtures/whitequark/break_block.txt
        test/prism/fixtures/whitequark/break.txt
        test/prism/fixtures/whitequark/class_definition_in_while_cond.txt
        test/prism/fixtures/whitequark/control_meta_escape_chars_in_regexp__since_31.txt
        test/prism/fixtures/whitequark/if_while_after_class__since_32.txt
        test/prism/fixtures/whitequark/next_block.txt
        test/prism/fixtures/whitequark/next.txt
        test/prism/fixtures/whitequark/pattern_matching_pin_variable.txt
        test/prism/fixtures/whitequark/pattern_matching_hash_with_string_keys.txt
        test/prism/fixtures/whitequark/range_endless.txt
        test/prism/fixtures/whitequark/redo.txt
        test/prism/fixtures/whitequark/retry.txt
        test/prism/fixtures/whitequark/yield.txt
      ]

      # Remove all invalid Ruby files
      known_failures.each { rm _1 }
    end
  end

  desc "Clean up tmp files related to whitequark/parser"
  task :clean do
    rm_rf "tmp/whitequark"
    rm_rf "test/prism/fixtures/whitequark"
    rm_rf "test/prism/snapshots/whitequark"
  end
end
prism-1.5.1/rbi/000077500000000000000000000000001506127434000134265ustar00rootroot00000000000000prism-1.5.1/rbi/prism.rbi000066400000000000000000000252421506127434000152630ustar00rootroot00000000000000# typed: strict

module Prism
  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(String) }
  def self.dump(source, command_line: nil, encoding: nil, filepath: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(String) }
  def self.dump_file(filepath, command_line: nil, encoding: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::LexResult) }
  def self.lex(source, command_line: nil, encoding: nil, filepath: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::LexResult) }
  def self.lex_file(filepath, command_line: nil, encoding: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(source: String, options: T::Hash[Symbol, T.untyped]).returns(Prism::LexCompat::Result) }
  def self.lex_compat(source, **options); end

  sig { params(source: String).returns(T::Array[T.untyped]) }
  def self.lex_ripper(source); end

  sig { params(source: String, serialized: String, freeze: T.nilable(T::Boolean)).returns(Prism::ParseResult) }
  def self.load(source, serialized, freeze = false); end

  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
  def self.parse(source, command_line: nil, encoding: nil, filepath: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
  def self.parse_file(filepath, command_line: nil, encoding: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).void }
  def self.profile(source, command_line: nil, encoding: nil, filepath: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).void }
  def self.profile_file(filepath, command_line: nil, encoding: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(stream: T.any(IO, StringIO), command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
  def self.parse_stream(stream, command_line: nil, encoding: nil, filepath: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Array[Prism::Comment]) }
  def self.parse_comments(source, command_line: nil, encoding: nil, filepath: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Array[Prism::Comment]) }
  def self.parse_file_comments(filepath, command_line: nil, encoding: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseLexResult) }
  def self.parse_lex(source, command_line: nil, encoding: nil, filepath: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseLexResult) }
  def self.parse_lex_file(filepath, command_line: nil, encoding: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }
  def self.parse_success?(source, command_line: nil, encoding: nil, filepath: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), filepath: T.nilable(String), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }
  def self.parse_failure?(source, command_line: nil, encoding: nil, filepath: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }
  def self.parse_file_success?(filepath, command_line: nil, encoding: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(FalseClass, Encoding)), freeze: T.nilable(T::Boolean), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), main_script: T.nilable(T::Boolean), partial_script: T.nilable(T::Boolean), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }
  def self.parse_file_failure?(filepath, command_line: nil, encoding: nil, freeze: nil, frozen_string_literal: nil, line: nil, main_script: nil, partial_script: nil, scopes: nil, version: nil); end

  sig { params(locals: T::Array[Symbol], forwarding: T::Array[Symbol]).returns(Prism::Scope) }
  def self.scope(locals: [], forwarding: []); end
end
prism-1.5.1/rbi/prism/000077500000000000000000000000001506127434000145605ustar00rootroot00000000000000prism-1.5.1/rbi/prism/compiler.rbi000066400000000000000000000005351506127434000170730ustar00rootroot00000000000000# typed: strict

class Prism::Compiler
  sig { params(node: T.nilable(Prism::Node)).returns(T.untyped) }
  def visit(node); end

  sig { params(nodes: T::Array[T.nilable(Prism::Node)]).returns(T::Array[T.untyped]) }
  def visit_all(nodes); end

  sig { params(node: Prism::Node).returns(T::Array[T.untyped]) }
  def visit_child_nodes(node); end
end
prism-1.5.1/rbi/prism/inspect_visitor.rbi000066400000000000000000000004141506127434000205010ustar00rootroot00000000000000# typed: strict

class Prism::InspectVisitor < Prism::Visitor
  sig { params(indent: String).void }
  def initialize(indent = ""); end

  sig { params(node: Prism::Node).returns(String) }
  def self.compose(node); end

  sig { returns(String) }
  def compose; end
end
prism-1.5.1/rbi/prism/node_ext.rbi000066400000000000000000000042541506127434000170700ustar00rootroot00000000000000# typed: strict

class Prism::InterpolatedMatchLastLineNode < Prism::Node
  sig { returns(Integer) }
  def options; end
end

class Prism::InterpolatedRegularExpressionNode < Prism::Node
  sig { returns(Integer) }
  def options; end
end

class Prism::MatchLastLineNode < Prism::Node
  sig { returns(Integer) }
  def options; end
end

class Prism::RegularExpressionNode < Prism::Node
  sig { returns(Integer) }
  def options; end
end

class Prism::InterpolatedStringNode < Prism::Node
  sig { returns(T::Boolean) }
  def heredoc?; end
end

class Prism::InterpolatedXStringNode < Prism::Node
  sig { returns(T::Boolean) }
  def heredoc?; end
end

class Prism::StringNode < Prism::Node
  sig { returns(T::Boolean) }
  def heredoc?; end

  sig { returns(Prism::InterpolatedStringNode) }
  def to_interpolated; end
end

class Prism::XStringNode < Prism::Node
  sig { returns(T::Boolean) }
  def heredoc?; end

  sig { returns(Prism::InterpolatedXStringNode) }
  def to_interpolated; end
end

class Prism::ImaginaryNode < Prism::Node
  sig { returns(Complex) }
  def value; end
end

class Prism::RationalNode < Prism::Node
  sig { returns(Rational) }
  def value; end
end

class Prism::ConstantReadNode < Prism::Node
  sig { returns(T::Array[Symbol]) }
  def full_name_parts; end

  sig { returns(String) }
  def full_name; end
end

class Prism::ConstantWriteNode < Prism::Node
  sig { returns(T::Array[Symbol]) }
  def full_name_parts; end

  sig { returns(String) }
  def full_name; end
end

class Prism::ConstantPathNode < Prism::Node
  sig { returns(T::Array[Symbol]) }
  def full_name_parts; end

  sig { returns(String) }
  def full_name; end
end

class Prism::ConstantPathTargetNode < Prism::Node
  sig { returns(T::Array[Symbol]) }
  def full_name_parts; end

  sig { returns(String) }
  def full_name; end
end

class Prism::ConstantTargetNode < Prism::Node
  sig { returns(T::Array[Symbol]) }
  def full_name_parts; end

  sig { returns(String) }
  def full_name; end
end

class Prism::ParametersNode < Prism::Node
  sig { returns(T::Array[T.any([Symbol, Symbol], [Symbol])]) }
  def signature; end
end

class Prism::CallNode < Prism::Node
  sig { returns(T.nilable(Prism::Location)) }
  def full_message_loc; end
end
prism-1.5.1/rbi/prism/parse_result.rbi000066400000000000000000000273041506127434000177740ustar00rootroot00000000000000# typed: strict

class Prism::Source
  sig { returns(String) }
  def source; end

  sig { returns(Integer) }
  def start_line; end

  sig { returns(T::Array[Integer]) }
  def offsets; end

  sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
  def initialize(source, start_line = 1, offsets = []); end

  sig { params(start_line: Integer).void }
  def replace_start_line(start_line); end

  sig { params(offsets: T::Array[Integer]).void }
  def replace_offsets(offsets); end

  sig { returns(Encoding) }
  def encoding; end

  sig { returns(T::Array[String]) }
  def lines; end

  sig { params(byte_offset: Integer, length: Integer).returns(String) }
  def slice(byte_offset, length); end

  sig { params(byte_offset: Integer).returns(Integer) }
  def line(byte_offset); end

  sig { params(byte_offset: Integer).returns(Integer) }
  def line_start(byte_offset); end

  sig { params(byte_offset: Integer).returns(Integer) }
  def column(byte_offset); end

  sig { params(byte_offset: Integer).returns(Integer) }
  def character_offset(byte_offset); end

  sig { params(byte_offset: Integer).returns(Integer) }
  def character_column(byte_offset); end

  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
  def code_units_offset(byte_offset, encoding); end

  sig { params(encoding: Encoding).returns(T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))) }
  def code_units_cache(encoding); end

  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
  def code_units_column(byte_offset, encoding); end
end

class Prism::CodeUnitsCache
  sig { params(source: String, encoding: Encoding).void }
  def initialize(source, encoding); end

  sig { params(byte_offset: Integer).returns(Integer) }
  def [](byte_offset); end
end

class Prism::ASCIISource < Prism::Source
  sig { params(byte_offset: Integer).returns(Integer) }
  def character_offset(byte_offset); end

  sig { params(byte_offset: Integer).returns(Integer) }
  def character_column(byte_offset); end

  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
  def code_units_offset(byte_offset, encoding); end

  sig { params(encoding: Encoding).returns(T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))) }
  def code_units_cache(encoding); end

  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
  def code_units_column(byte_offset, encoding); end
end

class Prism::Location
  sig { returns(Prism::Source) }
  def source; end

  sig { returns(Integer) }
  def start_offset; end

  sig { returns(Integer) }
  def length; end

  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void }
  def initialize(source, start_offset, length); end

  sig { returns(T::Array[Prism::Comment]) }
  def leading_comments; end

  sig { params(comment: Prism::Comment).void }
  def leading_comment(comment); end

  sig { returns(T::Array[Prism::Comment]) }
  def trailing_comments; end

  sig { params(comment: Prism::Comment).void }
  def trailing_comment(comment); end

  sig { returns(T::Array[Prism::Comment]) }
  def comments; end

  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).returns(Prism::Location) }
  def copy(source: self.source, start_offset: self.start_offset, length: self.length); end

  sig { returns(Prism::Location) }
  def chop; end

  sig { returns(String) }
  def inspect; end

  sig { returns(T::Array[String]) }
  def source_lines; end

  sig { returns(String) }
  def slice; end

  sig { returns(Integer) }
  def start_character_offset; end

  sig { params(encoding: Encoding).returns(Integer) }
  def start_code_units_offset(encoding = Encoding::UTF_16LE); end

  sig { params(cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))).returns(Integer) }
  def cached_start_code_units_offset(cache); end

  sig { returns(Integer) }
  def end_offset; end

  sig { returns(Integer) }
  def end_character_offset; end

  sig { params(encoding: Encoding).returns(Integer) }
  def end_code_units_offset(encoding = Encoding::UTF_16LE); end

  sig { params(cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))).returns(Integer) }
  def cached_end_code_units_offset(cache); end

  sig { returns(Integer) }
  def start_line; end

  sig { returns(String) }
  def start_line_slice; end

  sig { returns(Integer) }
  def end_line; end

  sig { returns(Integer) }
  def start_column; end

  sig { returns(Integer) }
  def start_character_column; end

  sig { params(encoding: Encoding).returns(Integer) }
  def start_code_units_column(encoding = Encoding::UTF_16LE); end

  sig { params(cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))).returns(Integer) }
  def cached_start_code_units_column(cache); end

  sig { returns(Integer) }
  def end_column; end

  sig { returns(Integer) }
  def end_character_column; end

  sig { params(encoding: Encoding).returns(Integer) }
  def end_code_units_column(encoding = Encoding::UTF_16LE); end

  sig { params(cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))).returns(Integer) }
  def cached_end_code_units_column(cache); end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end

  sig { params(q: T.untyped).void }
  def pretty_print(q); end

  sig { params(other: T.untyped).returns(T::Boolean) }
  def ==(other); end

  sig { params(other: Prism::Location).returns(Prism::Location) }
  def join(other); end

  sig { params(string: String).returns(Prism::Location) }
  def adjoin(string); end
end

class Prism::Comment
  abstract!

  sig { returns(Prism::Location) }
  def location; end

  sig { params(location: Prism::Location).void }
  def initialize(location); end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end

  sig { returns(String) }
  def slice; end

  sig { abstract.returns(T::Boolean) }
  def trailing?; end
end

class Prism::InlineComment < Prism::Comment
  sig { override.returns(T::Boolean) }
  def trailing?; end

  sig { returns(String) }
  def inspect; end
end

class Prism::EmbDocComment < Prism::Comment
  sig { override.returns(T::Boolean) }
  def trailing?; end

  sig { returns(String) }
  def inspect; end
end

class Prism::MagicComment
  sig { returns(Prism::Location) }
  def key_loc; end

  sig { returns(Prism::Location) }
  def value_loc; end

  sig { params(key_loc: Prism::Location, value_loc: Prism::Location).void }
  def initialize(key_loc, value_loc); end

  sig { returns(String) }
  def key; end

  sig { returns(String) }
  def value; end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end

  sig { returns(String) }
  def inspect; end
end

class Prism::ParseError
  sig { returns(Symbol) }
  def type; end

  sig { returns(String) }
  def message; end

  sig { returns(Prism::Location) }
  def location; end

  sig { returns(Symbol) }
  def level; end

  sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
  def initialize(type, message, location, level); end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end

  sig { returns(String) }
  def inspect; end
end

class Prism::ParseWarning
  sig { returns(Symbol) }
  def type; end

  sig { returns(String) }
  def message; end

  sig { returns(Prism::Location) }
  def location; end

  sig { returns(Symbol) }
  def level; end

  sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
  def initialize(type, message, location, level); end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end

  sig { returns(String) }
  def inspect; end
end

class Prism::Result
  sig { params(comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
  def initialize(comments, magic_comments, data_loc, errors, warnings, source); end

  sig { returns(T::Array[Prism::Comment]) }
  def comments; end

  sig { returns(T::Array[Prism::MagicComment]) }
  def magic_comments; end

  sig { returns(T.nilable(Prism::Location)) }
  def data_loc; end

  sig { returns(T::Array[Prism::ParseError]) }
  def errors; end

  sig { returns(T::Array[Prism::ParseWarning]) }
  def warnings; end

  sig { returns(Prism::Source) }
  def source; end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end

  sig { returns(Encoding) }
  def encoding; end

  sig { returns(T::Boolean) }
  def success?; end

  sig { returns(T::Boolean) }
  def failure?; end

  sig { params(encoding: Encoding).returns(T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))) }
  def code_units_cache(encoding); end
end

class Prism::ParseResult < Prism::Result
  sig { params(value: Prism::ProgramNode, comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end

  sig { returns(Prism::ProgramNode) }
  def value; end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end
end

class Prism::LexResult < Prism::Result
  sig { params(value: T::Array[T.untyped], comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end

  sig { returns(T::Array[T.untyped]) }
  def value; end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end
end

class Prism::ParseLexResult < Prism::Result
  sig { params(value: [Prism::ProgramNode, T::Array[T.untyped]], comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end

  sig { returns([Prism::ProgramNode, T::Array[T.untyped]]) }
  def value; end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end
end

class Prism::Token
  sig { returns(Prism::Source) }
  def source; end

  sig { returns(Symbol) }
  def type; end

  sig { returns(String) }
  def value; end

  sig { params(source: Prism::Source, type: Symbol, value: String, location: T.any(Integer, Prism::Location)).void }
  def initialize(source, type, value, location); end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end

  sig { returns(Prism::Location) }
  def location; end

  sig { params(q: T.untyped).void }
  def pretty_print(q); end

  sig { params(other: T.untyped).returns(T::Boolean) }
  def ==(other); end
end

class Prism::Scope
  sig { returns(T::Array[Symbol]) }
  def locals; end

  sig { returns(T::Array[Symbol]) }
  def forwarding; end

  sig { params(locals: T::Array[Symbol], forwarding: T::Array[Symbol]).void }
  def initialize(locals, forwarding); end
end
prism-1.5.1/rbi/prism/reflection.rbi000066400000000000000000000025151506127434000174130ustar00rootroot00000000000000# typed: strict

module Prism::Reflection
end

class Prism::Reflection::Field
  sig { params(name: Symbol).void }
  def initialize(name); end

  sig { returns(Symbol) }
  def name; end
end

class Prism::Reflection::NodeField < Prism::Reflection::Field
end

class Prism::Reflection::OptionalNodeField < Prism::Reflection::Field
end

class Prism::Reflection::NodeListField < Prism::Reflection::Field
end

class Prism::Reflection::ConstantField < Prism::Reflection::Field
end

class Prism::Reflection::OptionalConstantField < Prism::Reflection::Field
end

class Prism::Reflection::ConstantListField < Prism::Reflection::Field
end

class Prism::Reflection::StringField < Prism::Reflection::Field
end

class Prism::Reflection::LocationField < Prism::Reflection::Field
end

class Prism::Reflection::OptionalLocationField < Prism::Reflection::Field
end

class Prism::Reflection::IntegerField < Prism::Reflection::Field
end

class Prism::Reflection::FloatField < Prism::Reflection::Field
end

class Prism::Reflection::FlagsField < Prism::Reflection::Field
  sig { params(name: Symbol, flags: T::Array[Symbol]).void }
  def initialize(name, flags); end

  sig { returns(T::Array[Symbol]) }
  def flags; end
end

module Prism::Reflection
  sig { params(node: T.class_of(Prism::Node)).returns(T::Array[Prism::Reflection::Field]) }
  def self.fields_for(node); end
end
prism-1.5.1/rbi/prism/string_query.rbi000066400000000000000000000004651506127434000200160ustar00rootroot00000000000000# typed: strict

class Prism::StringQuery
  sig { params(string: String).returns(T::Boolean) }
  def self.local?(string); end

  sig { params(string: String).returns(T::Boolean) }
  def self.constant?(string); end

  sig { params(string: String).returns(T::Boolean) }
  def self.method_name?(string); end
end
prism-1.5.1/rbi/prism/translation/000077500000000000000000000000001506127434000171165ustar00rootroot00000000000000prism-1.5.1/rbi/prism/translation/parser.rbi000066400000000000000000000004171506127434000211120ustar00rootroot00000000000000# typed: strict

# We keep these shims in here because our client libraries might not have parser
# in their bundle.
module Parser; end
class Parser::Base; end

class Prism::Translation::Parser < Parser::Base
  sig { overridable.returns(Integer) }
  def version; end
end
prism-1.5.1/rbi/prism/translation/parser33.rbi000066400000000000000000000002141506127434000212530ustar00rootroot00000000000000# typed: strict

class Prism::Translation::Parser33 < Prism::Translation::Parser
  sig { override.returns(Integer) }
  def version; end
end
prism-1.5.1/rbi/prism/translation/parser34.rbi000066400000000000000000000002141506127434000212540ustar00rootroot00000000000000# typed: strict

class Prism::Translation::Parser34 < Prism::Translation::Parser
  sig { override.returns(Integer) }
  def version; end
end
prism-1.5.1/rbi/prism/translation/parser35.rbi000066400000000000000000000002141506127434000212550ustar00rootroot00000000000000# typed: strict

class Prism::Translation::Parser35 < Prism::Translation::Parser
  sig { override.returns(Integer) }
  def version; end
end
prism-1.5.1/rbi/prism/translation/ripper.rbi000066400000000000000000000010511506127434000211120ustar00rootroot00000000000000# typed: strict

class Prism::Translation::Ripper < Prism::Compiler
  sig { returns(T::Boolean) }
  def error?; end

  sig { returns(T.untyped) }
  def parse; end

  sig { params(source: String, filename: String, lineno: Integer, raise_errors: T.untyped).returns(T.untyped) }
  def self.sexp_raw(source, filename = "-", lineno = 1, raise_errors: false); end

  sig { params(source: String, filename: String, lineno: Integer, raise_errors: T.untyped).returns(T.untyped) }
  def self.sexp(source, filename = "-", lineno = 1, raise_errors: false); end
end
prism-1.5.1/rust/000077500000000000000000000000001506127434000136475ustar00rootroot00000000000000prism-1.5.1/rust/.gitignore000066400000000000000000000000111506127434000156270ustar00rootroot00000000000000/target/
prism-1.5.1/rust/Cargo.lock000066400000000000000000000207751506127434000155670ustar00rootroot00000000000000# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4

[[package]]
name = "aho-corasick"
version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
dependencies = [
 "memchr",
]

[[package]]
name = "bindgen"
version = "0.72.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4f72209734318d0b619a5e0f5129918b848c416e122a3c4ce054e03cb87b726f"
dependencies = [
 "bitflags",
 "cexpr",
 "clang-sys",
 "itertools",
 "log",
 "prettyplease",
 "proc-macro2",
 "quote",
 "regex",
 "rustc-hash",
 "shlex",
 "syn",
]

[[package]]
name = "bitflags"
version = "2.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07"

[[package]]
name = "cc"
version = "1.0.83"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
dependencies = [
 "libc",
]

[[package]]
name = "cexpr"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
dependencies = [
 "nom",
]

[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

[[package]]
name = "clang-sys"
version = "1.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c688fc74432808e3eb684cae8830a86be1d66a2bd58e1f248ed0960a590baf6f"
dependencies = [
 "glob",
 "libc",
 "libloading",
]

[[package]]
name = "either"
version = "1.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"

[[package]]
name = "equivalent"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"

[[package]]
name = "glob"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"

[[package]]
name = "hashbrown"
version = "0.14.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"

[[package]]
name = "indexmap"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d530e1a18b1cb4c484e6e34556a0d948706958449fca0cab753d649f2bce3d1f"
dependencies = [
 "equivalent",
 "hashbrown",
]

[[package]]
name = "itertools"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
dependencies = [
 "either",
]

[[package]]
name = "itoa"
version = "1.0.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"

[[package]]
name = "libc"
version = "0.2.150"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "89d92a4743f9a61002fae18374ed11e7973f530cb3a3255fb354818118b2203c"

[[package]]
name = "libloading"
version = "0.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
dependencies = [
 "cfg-if",
 "winapi",
]

[[package]]
name = "log"
version = "0.4.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"

[[package]]
name = "memchr"
version = "2.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167"

[[package]]
name = "minimal-lexical"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"

[[package]]
name = "nom"
version = "7.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
dependencies = [
 "memchr",
 "minimal-lexical",
]

[[package]]
name = "prettyplease"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ae005bd773ab59b4725093fd7df83fd7892f7d8eafb48dbd7de6e024e4215f9d"
dependencies = [
 "proc-macro2",
 "syn",
]

[[package]]
name = "proc-macro2"
version = "1.0.95"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
dependencies = [
 "unicode-ident",
]

[[package]]
name = "quote"
version = "1.0.33"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
dependencies = [
 "proc-macro2",
]

[[package]]
name = "regex"
version = "1.10.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343"
dependencies = [
 "aho-corasick",
 "memchr",
 "regex-automata",
 "regex-syntax",
]

[[package]]
name = "regex-automata"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f"
dependencies = [
 "aho-corasick",
 "memchr",
 "regex-syntax",
]

[[package]]
name = "regex-syntax"
version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"

[[package]]
name = "ruby-prism"
version = "1.5.1"
dependencies = [
 "ruby-prism-sys",
 "serde",
 "serde_yaml",
]

[[package]]
name = "ruby-prism-sys"
version = "1.5.1"
dependencies = [
 "bindgen",
 "cc",
]

[[package]]
name = "rustc-hash"
version = "2.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"

[[package]]
name = "ryu"
version = "1.0.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"

[[package]]
name = "serde"
version = "1.0.193"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "25dd9975e68d0cb5aa1120c288333fc98731bd1dd12f561e468ea4728c042b89"
dependencies = [
 "serde_derive",
]

[[package]]
name = "serde_derive"
version = "1.0.193"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]

[[package]]
name = "serde_yaml"
version = "0.9.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3cc7a1570e38322cfe4154732e5110f887ea57e22b76f4bfd32b5bdd3368666c"
dependencies = [
 "indexmap",
 "itoa",
 "ryu",
 "serde",
 "unsafe-libyaml",
]

[[package]]
name = "shlex"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"

[[package]]
name = "syn"
version = "2.0.39"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "23e78b90f2fcf45d3e842032ce32e3f2d1545ba6636271dcbf24fa306d87be7a"
dependencies = [
 "proc-macro2",
 "quote",
 "unicode-ident",
]

[[package]]
name = "unicode-ident"
version = "1.0.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"

[[package]]
name = "unsafe-libyaml"
version = "0.2.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ab4c90930b95a82d00dc9e9ac071b4991924390d46cbd0dfe566148667605e4b"

[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
 "winapi-i686-pc-windows-gnu",
 "winapi-x86_64-pc-windows-gnu",
]

[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"

[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
prism-1.5.1/rust/Cargo.toml000066400000000000000000000001411506127434000155730ustar00rootroot00000000000000[workspace]
members = [
  "ruby-prism",
  "ruby-prism-sys",
]

resolver = "2" # Use 2021 edition
prism-1.5.1/rust/ruby-prism-sys/000077500000000000000000000000001506127434000165745ustar00rootroot00000000000000prism-1.5.1/rust/ruby-prism-sys/.gitignore000066400000000000000000000003241506127434000205630ustar00rootroot00000000000000# will have compiled files and executables
debug/
target/
vendor/

# These are backup files generated by rustfmt
**/*.rs.bk

# MSVC Windows builds of rustc generate these, which store debugging information
*.pdb
prism-1.5.1/rust/ruby-prism-sys/Cargo.toml000066400000000000000000000014051506127434000205240ustar00rootroot00000000000000[package]
name = "ruby-prism-sys"
version = "1.5.1"
edition = "2021"
license-file = "../../LICENSE.md"
repository = "https://github.com/ruby/prism"
description = "Rust bindings to Ruby's prism parsing library"
links = "prism"
authors = [
    "Steve Loveless ",
    "Ian Ker-Seymer ",
    "Kevin Newton ",
]
keywords = ["ruby", "parser", "ffi", "bindings"]
categories = [
    "api-bindings",
    "development-tools::ffi",
    "external-ffi-bindings",
    "parsing",
]
build = "build/main.rs"
include = ["src/", "build/", "Cargo.toml", "Cargo.lock", "README.md", "vendor"]

[build-dependencies]
bindgen = "0.72"
cc = { version = "1.0", optional = true }

[features]
default = ["vendored"]
vendored = ["dep:cc"]
prism-1.5.1/rust/ruby-prism-sys/README.md000066400000000000000000000032471506127434000200610ustar00rootroot00000000000000# ruby-prism-sys

Rust bindings to [ruby/prism](https://github.com/ruby/prism)'s C API.

## Examples

Currently the best examples are found in the integration tests (in `tests/`).

## Documentation

Since this crate has not been released, docs are not yet online anywhere. You can generate them,
however, from this directory in this repo by running `cargo doc`, then opening
`target/doc/ruby_prism_sys/index.html` in your browser. (You could, instead, combine those two steps by
doing `cargo doc --open`!)

## Development

### Dependencies

In addition to the Ruby prism dependencies, you shouldn't need anything else besides Rust.

### Updating bindings

`build.rs` (which gets called as part of running `cargo build`, `cargo test`, etc) is where we tell
`bindgen` which types, functions, etc. that we want it to generate for us. It's smart enough to know
to generate dependencies for items we specify in there (ex. `pm_parser_t` has fields of type
`pm_token_t`, but we don't need to tell `bindgen` about `pm_token_t`--it'll figure it out and
generate bindings for that type too).

If you want to generate new bindings, update `build.rs` accordingly, then run `cargo doc` and check
the docs; that should tell you if `bindgen` generated all the things you need or not.

### Testing

Since almost all of the code is generated by the well-tested
[`bindgen`](https://github.com/rust-lang/rust-bindgen) crate, we only have some cursory integration
tests in `tests/`, really just validating types and functions got generated appropriately. (They
also give some hints about how to use the API from Rust!) To run the tests, run `cargo test`.

Any new publicly exposed C API additions should get a test or two.
prism-1.5.1/rust/ruby-prism-sys/build/000077500000000000000000000000001506127434000176735ustar00rootroot00000000000000prism-1.5.1/rust/ruby-prism-sys/build/main.rs000066400000000000000000000136231506127434000211720ustar00rootroot00000000000000#[cfg(feature = "vendored")]
mod vendored;

use std::path::{Path, PathBuf};

fn main() {
    #[cfg(feature = "vendored")]
    vendored::build().expect("failed to build Prism from source");

    let ruby_build_path = prism_lib_path();
    let ruby_include_path = prism_include_path();

    // Tell cargo/rustc that we want to link against `libprism.a`.
    println!("cargo:rustc-link-lib=static=prism");

    // Add `[root]/build/` to the search paths, so it can find `libprism.a`.
    println!("cargo:rustc-link-search=native={}", ruby_build_path.to_str().unwrap());

    // This is where the magic happens.
    let bindings = generate_bindings(&ruby_include_path);

    // Write the bindings to file.
    write_bindings(&bindings);
}

/// Gets the path to project files (`libprism*`) at `[root]/build/`.
///
fn prism_lib_path() -> PathBuf {
    if let Ok(lib_dir) = std::env::var("PRISM_LIB_DIR") {
        return PathBuf::from(lib_dir);
    }

    cargo_manifest_path().join("../../build/").canonicalize().unwrap()
}

/// Gets the path to the header files that `bindgen` needs for doing code
/// generation.
///
fn prism_include_path() -> PathBuf {
    if let Ok(include_dir) = std::env::var("PRISM_INCLUDE_DIR") {
        return PathBuf::from(include_dir);
    }

    cargo_manifest_path().join("../../include/").canonicalize().unwrap()
}

fn cargo_manifest_path() -> PathBuf {
    PathBuf::from(std::env::var_os("CARGO_MANIFEST_DIR").unwrap())
}

#[derive(Debug)]
struct Callbacks;

impl bindgen::callbacks::ParseCallbacks for Callbacks {
    /// Accept a string that is a comment on a node. Replace any internal code
    /// examples that are indented by 4 spaces with a fenced code block.
    fn process_comment(&self, comment: &str) -> Option {
        let mut result = String::new();

        let mut in_code_block = false;
        let mut previous_blank = false;

        for line in comment.lines() {
            if in_code_block {
                if line.starts_with("    ") {
                    result.push_str(line.strip_prefix("    ").unwrap());
                } else {
                    in_code_block = false;
                    previous_blank = line.trim().is_empty();
                    result.push_str("```\n");
                    result.push_str(line);
                }
            } else if line.starts_with("    ") && previous_blank {
                in_code_block = true;
                result.push_str("``` ruby\n");
                result.push_str(line.strip_prefix("    ").unwrap());
            } else {
                previous_blank = line.trim().is_empty();
                result.push_str(line);
            }

            result.push('\n');
        }

        if in_code_block {
            result.push_str("```\n");
        }

        Some(result)
    }
}

/// Uses `bindgen` to generate bindings to the C API. Update this to allow new
/// types/functions/etc to be generated (it's allowlisted to only expose
/// functions that'd make sense for public consumption).
///
/// This method only generates code in memory here--it doesn't write it to file.
///
fn generate_bindings(ruby_include_path: &Path) -> bindgen::Bindings {
    bindgen::Builder::default()
        .derive_default(true)
        .generate_block(true)
        .generate_comments(true)
        .header(ruby_include_path.join("prism/defines.h").to_str().unwrap())
        .header(ruby_include_path.join("prism.h").to_str().unwrap())
        .clang_arg(format!("-I{}", ruby_include_path.to_str().unwrap()))
        .clang_arg("-fparse-all-comments")
        .impl_debug(true)
        .layout_tests(true)
        .merge_extern_blocks(true)
        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
        .parse_callbacks(Box::new(Callbacks))
        .prepend_enum_name(false)
        .size_t_is_usize(true)
        .sort_semantically(true)
        // Structs
        .allowlist_type("pm_comment_t")
        .allowlist_type("pm_diagnostic_t")
        .allowlist_type("pm_list_t")
        .allowlist_type("pm_magic_comment_t")
        .allowlist_type("pm_node_t")
        .allowlist_type("pm_node_type")
        .allowlist_type("pm_pack_size")
        .allowlist_type("pm_parser_t")
        .allowlist_type("pm_string_t")
        .allowlist_type(r"^pm_\w+_node_t")
        .allowlist_type(r"^pm_\w+_flags")
        // Enums
        .rustified_non_exhaustive_enum("pm_comment_type_t")
        .rustified_non_exhaustive_enum(r"pm_\w+_flags")
        .rustified_non_exhaustive_enum("pm_node_type")
        .rustified_non_exhaustive_enum("pm_pack_encoding")
        .rustified_non_exhaustive_enum("pm_pack_endian")
        .rustified_non_exhaustive_enum("pm_pack_length_type")
        .rustified_non_exhaustive_enum("pm_pack_result")
        .rustified_non_exhaustive_enum("pm_pack_signed")
        .rustified_non_exhaustive_enum("pm_pack_size")
        .rustified_non_exhaustive_enum("pm_pack_type")
        .rustified_non_exhaustive_enum("pm_pack_variant")
        // Functions
        .allowlist_function("pm_list_empty_p")
        .allowlist_function("pm_list_free")
        .allowlist_function("pm_node_destroy")
        .allowlist_function("pm_pack_parse")
        .allowlist_function("pm_parse")
        .allowlist_function("pm_parser_free")
        .allowlist_function("pm_parser_init")
        .allowlist_function("pm_size_to_native")
        .allowlist_function("pm_string_free")
        .allowlist_function("pm_string_length")
        .allowlist_function("pm_string_source")
        .allowlist_function("pm_version")
        // Vars
        .allowlist_var(r"^pm_encoding\S+")
        .generate()
        .expect("Unable to generate prism bindings")
}

/// Write the bindings to the `$OUT_DIR/bindings.rs` file. We'll pull these into
/// the actual library in `src/lib.rs`.
fn write_bindings(bindings: &bindgen::Bindings) {
    let out_path = PathBuf::from(std::env::var_os("OUT_DIR").unwrap());

    bindings
        .write_to_file(out_path.join("bindings.rs"))
        .expect("Couldn't write bindings!");
}
prism-1.5.1/rust/ruby-prism-sys/build/vendored.rs000066400000000000000000000074021506127434000220520ustar00rootroot00000000000000use std::{
    fs,
    path::{Path, PathBuf},
};

/// Builds libprism.a from source, and configures the build script to use it.
pub fn build() -> Result<(), Box> {
    assert!(
        vendor_dir().exists(),
        "Prism source directory does not exist, expected: {}",
        vendor_dir().display(),
    );

    println!("cargo:rerun-if-changed={}", vendor_dir().display());

    let out_dir = PathBuf::from(std::env::var_os("OUT_DIR").expect("OUT_DIR is not set"));
    let mut build = cc::Build::new();

    let mut defines = vec![("PRISM_EXPORT_SYMBOLS", "1")];
    let mut includes = vec![include_dir()];
    let mut flags = vec![];

    if let Ok(target) = std::env::var("TARGET") {
        if target.contains("wasm32") && target.contains("wasi") {
            println!("cargo:rerun-if-env-changed=WASI_SDK_PATH");

            if let Ok(wasi_sdk_path) = std::env::var("WASI_SDK_PATH").map(PathBuf::from) {
                let wasi_sdk_clang = wasi_sdk_path.join("bin").join("clang");
                build.compiler(wasi_sdk_clang);

                let wasi_sysroot = wasi_sdk_path.join("share").join("wasi-sysroot");
                flags.push(format!("--sysroot={}", wasi_sysroot.display()));

                let wasi_libc_include = wasi_sysroot.join("include");
                includes.push(wasi_libc_include.clone());

                let wasi_lib_dir = wasi_sysroot.join("lib/wasm32-wasi");
                println!("cargo:rustc-link-search=native={}", wasi_lib_dir.display());

                defines.push(("_WASI_EMULATED_MMAN", "1"));
                println!("cargo:rustc-link-lib=wasi-emulated-mman");
            } else {
                panic!("WASI_SDK_PATH is not set, cannot build for {target}");
            }
        }
    }

    for (key, value) in defines {
        build.define(key, value);
        push_bindgen_extra_clang_args(format!("-D{key}={value}"));
    }

    for include in includes {
        build.include(&include);
        push_bindgen_extra_clang_args(format!("-I{}", include.display()));
    }

    for flag in flags {
        build.flag(&flag);
        push_bindgen_extra_clang_args(flag);
    }

    build.files(source_files(src_dir()));
    build.out_dir(&out_dir);
    build.try_compile("prism")?;

    std::env::set_var("PRISM_INCLUDE_DIR", include_dir());
    std::env::set_var("PRISM_LIB_DIR", out_dir);

    Ok(())
}

fn version() -> &'static str {
    env!("CARGO_PKG_VERSION")
}

/// Generated by running the following command:
///
/// ```sh
/// bundle exec rake cargo:build
/// ```
fn vendor_dir() -> PathBuf {
    let prism_dir = format!("prism-{}", version());
    Path::new(env!("CARGO_MANIFEST_DIR")).join("vendor").join(prism_dir)
}

fn src_dir() -> PathBuf {
    vendor_dir().join("src")
}

fn include_dir() -> PathBuf {
    vendor_dir().join("include")
}

fn push_bindgen_extra_clang_args>(arg: T) {
    let env_var_name = format!("BINDGEN_EXTRA_CLANG_ARGS_{}", std::env::var("TARGET").unwrap());

    if let Ok(preexisting_arg) = std::env::var(&env_var_name) {
        std::env::set_var(env_var_name, format!("{} {}", preexisting_arg, arg.as_ref()));
    } else {
        std::env::set_var(env_var_name, arg.as_ref());
    }
}

fn source_files>(root_dir: P) -> Vec {
    let mut files = Vec::new();

    for entry in fs::read_dir(root_dir.as_ref()).unwrap() {
        let entry = entry.unwrap();
        let path = entry.path();

        if path.is_file() {
            let path = path.to_str().unwrap().to_string();

            if Path::new(&path)
                .extension()
                .is_some_and(|ext| ext.eq_ignore_ascii_case("c"))
            {
                files.push(path);
            }
        } else if path.is_dir() {
            files.extend(source_files(path));
        }
    }

    files
}
prism-1.5.1/rust/ruby-prism-sys/rustfmt.toml000066400000000000000000000000621506127434000211730ustar00rootroot00000000000000max_width = 120
match_block_trailing_comma = true
prism-1.5.1/rust/ruby-prism-sys/src/000077500000000000000000000000001506127434000173635ustar00rootroot00000000000000prism-1.5.1/rust/ruby-prism-sys/src/lib.rs000066400000000000000000000016731506127434000205060ustar00rootroot00000000000000//! # ruby-prism-sys
//!
//! FFI-bindings for `prism`.
//!
#![deny(unused_extern_crates)]
#![warn(
    clippy::all,
    clippy::nursery,
    clippy::pedantic,
    future_incompatible,
    missing_copy_implementations,
    missing_docs,
    nonstandard_style,
    rust_2018_idioms,
    trivial_casts,
    trivial_numeric_casts,
    unreachable_pub,
    unused_qualifications
)]

#[allow(clippy::all, clippy::pedantic, clippy::cognitive_complexity)]
#[allow(missing_copy_implementations)]
#[allow(missing_docs)]
#[allow(non_camel_case_types)]
#[allow(non_snake_case)]
#[allow(non_upper_case_globals)]
#[allow(unused_qualifications)]
#[allow(clippy::missing_const_for_fn)]
mod bindings {
    // In `build.rs`, we use `bindgen` to generate bindings based on C headers
    // and `libprism`. Here is where we pull in those bindings and make
    // them part of our library.
    include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
}

pub use self::bindings::*;
prism-1.5.1/rust/ruby-prism-sys/tests/000077500000000000000000000000001506127434000177365ustar00rootroot00000000000000prism-1.5.1/rust/ruby-prism-sys/tests/node_tests.rs000066400000000000000000000013721506127434000224560ustar00rootroot00000000000000use std::{ffi::CString, mem::MaybeUninit};

use ruby_prism_sys::{pm_node_destroy, pm_node_type};
use ruby_prism_sys::{pm_parse, pm_parser_free, pm_parser_init, pm_parser_t};

#[test]
fn node_test() {
    let mut parser = MaybeUninit::::uninit();
    let code = CString::new("class Foo; end").unwrap();

    unsafe {
        pm_parser_init(
            parser.as_mut_ptr(),
            code.as_ptr().cast::(),
            code.as_bytes().len(),
            std::ptr::null(),
        );

        let parser = parser.assume_init_mut();
        let parsed_node = pm_parse(parser);

        assert_eq!((*parsed_node).type_, pm_node_type::PM_PROGRAM_NODE as u16);

        pm_node_destroy(parser, parsed_node);
        pm_parser_free(parser);
    }
}
prism-1.5.1/rust/ruby-prism-sys/tests/pack_tests.rs000066400000000000000000000043771506127434000224570ustar00rootroot00000000000000use std::{ffi::CString, mem::MaybeUninit};

use ruby_prism_sys::{
    pm_pack_encoding, pm_pack_endian, pm_pack_length_type, pm_pack_parse, pm_pack_result, pm_pack_signed, pm_pack_size,
    pm_pack_type, pm_pack_variant, pm_size_to_native,
};

#[test]
fn pack_parse_test() {
    let variant_arg = pm_pack_variant::PM_PACK_VARIANT_PACK;
    let first_format = CString::new("C").unwrap();
    let end_format = CString::new("").unwrap();
    let mut format = vec![first_format.as_ptr(), end_format.as_ptr()];

    let mut type_out = MaybeUninit::::uninit();
    let mut signed_type_out = MaybeUninit::::uninit();
    let mut endian_out = MaybeUninit::::uninit();
    let mut size_out = MaybeUninit::::uninit();
    let mut length_type_out = MaybeUninit::::uninit();
    let mut length_out = 0_u64;
    let mut encoding_out = MaybeUninit::::uninit();

    unsafe {
        let result = pm_pack_parse(
            variant_arg,
            format.as_mut_ptr(),
            end_format.as_ptr(),
            type_out.as_mut_ptr(),
            signed_type_out.as_mut_ptr(),
            endian_out.as_mut_ptr(),
            size_out.as_mut_ptr(),
            length_type_out.as_mut_ptr(),
            &raw mut length_out,
            encoding_out.as_mut_ptr(),
        );

        assert_eq!(result, pm_pack_result::PM_PACK_OK);

        let type_out = type_out.assume_init();
        let signed_type_out = signed_type_out.assume_init();
        let endian_out = endian_out.assume_init();
        let size_out = size_out.assume_init();
        let length_type_out = length_type_out.assume_init();
        let encoding_out = encoding_out.assume_init();

        assert_eq!(type_out, pm_pack_type::PM_PACK_INTEGER);
        assert_eq!(signed_type_out, pm_pack_signed::PM_PACK_UNSIGNED);
        assert_eq!(endian_out, pm_pack_endian::PM_PACK_AGNOSTIC_ENDIAN);
        assert_eq!(size_out, pm_pack_size::PM_PACK_SIZE_8);
        assert_eq!(length_type_out, pm_pack_length_type::PM_PACK_LENGTH_FIXED);
        assert_eq!(length_out, 1);
        assert_eq!(encoding_out, pm_pack_encoding::PM_PACK_ENCODING_ASCII_8BIT);

        let native_size = pm_size_to_native(size_out);
        assert_eq!(native_size, 1);
    }
}
prism-1.5.1/rust/ruby-prism-sys/tests/parser_tests.rs000066400000000000000000000057071506127434000230330ustar00rootroot00000000000000use std::{
    ffi::{CStr, CString},
    mem::MaybeUninit,
    path::Path,
};

use ruby_prism_sys::{
    pm_comment_t, pm_comment_type_t, pm_diagnostic_t, pm_node_destroy, pm_parse, pm_parser_free, pm_parser_init,
    pm_parser_t,
};

fn ruby_file_contents() -> (CString, usize) {
    let rust_path = Path::new(env!("CARGO_MANIFEST_DIR"));
    let ruby_file_path = rust_path.join("../../lib/prism.rb").canonicalize().unwrap();
    let file_contents = std::fs::read_to_string(ruby_file_path).unwrap();
    let len = file_contents.len();

    (CString::new(file_contents).unwrap(), len)
}

#[test]
fn init_test() {
    let (ruby_file_contents, len) = ruby_file_contents();
    let source = ruby_file_contents.as_ptr().cast::();
    let mut parser = MaybeUninit::::uninit();

    unsafe {
        pm_parser_init(parser.as_mut_ptr(), source, len, std::ptr::null());
        let parser = parser.assume_init_mut();

        pm_parser_free(parser);
    }
}

#[test]
fn comments_test() {
    let source = CString::new("# Meow!").unwrap();
    let mut parser = MaybeUninit::::uninit();

    unsafe {
        pm_parser_init(
            parser.as_mut_ptr(),
            source.as_ptr().cast::(),
            source.as_bytes().len(),
            std::ptr::null(),
        );
        let parser = parser.assume_init_mut();
        let node = pm_parse(parser);

        let comment_list = &parser.comment_list;
        let comment = comment_list.head as *const pm_comment_t;
        assert_eq!((*comment).type_, pm_comment_type_t::PM_COMMENT_INLINE);

        let location = {
            let start = (*comment).location.start.offset_from(parser.start);
            let end = (*comment).location.end.offset_from(parser.start);
            start..end
        };
        assert_eq!(location, 0..7);

        pm_node_destroy(parser, node);
        pm_parser_free(parser);
    }
}

#[test]
fn diagnostics_test() {
    let source = CString::new("class Foo;").unwrap();
    let mut parser = MaybeUninit::::uninit();

    unsafe {
        pm_parser_init(
            parser.as_mut_ptr(),
            source.as_ptr().cast::(),
            source.as_bytes().len(),
            std::ptr::null(),
        );
        let parser = parser.assume_init_mut();
        let node = pm_parse(parser);

        let error_list = &parser.error_list;
        assert!(!error_list.head.is_null());

        let error = error_list.head as *const pm_diagnostic_t;
        let message = CStr::from_ptr((*error).message);
        assert_eq!(
            message.to_string_lossy(),
            "unexpected end-of-input, assuming it is closing the parent top level context"
        );

        let location = {
            let start = (*error).location.start.offset_from(parser.start);
            let end = (*error).location.end.offset_from(parser.start);
            start..end
        };
        assert_eq!(location, 10..10);

        pm_node_destroy(parser, node);
        pm_parser_free(parser);
    }
}
prism-1.5.1/rust/ruby-prism-sys/tests/utils_tests.rs000066400000000000000000000056751506127434000227030ustar00rootroot00000000000000use std::{
    ffi::{CStr, CString},
    mem::MaybeUninit,
};

#[test]
fn version_test() {
    use ruby_prism_sys::pm_version;

    let cstring = unsafe {
        let version = pm_version();
        CStr::from_ptr(version)
    };

    assert_eq!(&cstring.to_string_lossy(), "1.5.1");
}

#[test]
fn list_test() {
    use ruby_prism_sys::{pm_list_empty_p, pm_list_free, pm_list_t};

    let mut list = MaybeUninit::::zeroed();

    unsafe {
        let list = list.assume_init_mut();

        assert!(pm_list_empty_p(list));

        pm_list_free(list);
    }
}

mod string {
    use ruby_prism_sys::{
        pm_string_free, pm_string_length, pm_string_source, pm_string_t, pm_string_t__bindgen_ty_1, PM_STRING_CONSTANT,
        PM_STRING_MAPPED, PM_STRING_OWNED, PM_STRING_SHARED,
    };

    use super::*;

    struct S {
        c_string: CString,
        pm_string: pm_string_t,
    }

    impl S {
        fn start_ptr(&self) -> *const u8 {
            self.c_string.as_ptr().cast::()
        }
    }

    fn make_string(string_type: pm_string_t__bindgen_ty_1) -> S {
        let c_string = CString::new("0123456789012345").unwrap();

        let pm_string = pm_string_t {
            type_: string_type,
            source: c_string.as_ptr().cast::(),
            length: c_string.as_bytes().len(),
        };

        S { c_string, pm_string }
    }

    #[test]
    fn shared_string_test() {
        let mut s = make_string(PM_STRING_SHARED);

        unsafe {
            let len = pm_string_length(&raw const s.pm_string);
            assert_eq!(len, 16);

            let result_start = pm_string_source(&raw const s.pm_string);
            assert_eq!(s.start_ptr(), result_start);

            pm_string_free(&raw mut s.pm_string);
        }
    }

    #[test]
    fn owned_string_test() {
        let s = make_string(PM_STRING_OWNED);

        unsafe {
            let result_len = pm_string_length(&raw const s.pm_string);
            assert_eq!(result_len, 16);

            let result_start = pm_string_source(&raw const s.pm_string);
            assert_eq!(s.pm_string.source, result_start);

            // Don't drop the pm_string--we don't own it anymore!
        }
    }

    #[test]
    fn constant_string_test() {
        let mut s = make_string(PM_STRING_CONSTANT);

        unsafe {
            let result_len = pm_string_length(&raw const s.pm_string);
            assert_eq!(result_len, 16);

            let result_start = pm_string_source(&raw const s.pm_string);
            assert_eq!(s.pm_string.source, result_start);

            pm_string_free(&raw mut s.pm_string);
        }
    }

    #[test]
    fn mapped_string_test() {
        let s = make_string(PM_STRING_MAPPED);

        unsafe {
            let result_len = pm_string_length(&raw const s.pm_string);
            assert_eq!(result_len, 16);

            let result_start = pm_string_source(&raw const s.pm_string);
            assert_eq!(s.pm_string.source, result_start);
        }
    }
}
prism-1.5.1/rust/ruby-prism/000077500000000000000000000000001506127434000157605ustar00rootroot00000000000000prism-1.5.1/rust/ruby-prism/.gitignore000066400000000000000000000003241506127434000177470ustar00rootroot00000000000000# will have compiled files and executables
debug/
target/
vendor/

# These are backup files generated by rustfmt
**/*.rs.bk

# MSVC Windows builds of rustc generate these, which store debugging information
*.pdb
prism-1.5.1/rust/ruby-prism/Cargo.toml000066400000000000000000000016431506127434000177140ustar00rootroot00000000000000[package]
name = "ruby-prism"
version = "1.5.1"
edition = "2021"
license-file = "../../LICENSE.md"
repository = "https://github.com/ruby/prism"
description = "Rustified version of Ruby's prism parsing library"
authors = [
    "Steve Loveless ",
    "Ian Ker-Seymer ",
    "Kevin Newton ",
]
keywords = ["ruby", "parser", "ffi", "bindings"]
categories = [
    "api-bindings",
    "development-tools::ffi",
    "external-ffi-bindings",
    "parsing",
]

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
include = ["src/", "build.rs", "Cargo.toml", "Cargo.lock", "vendor"]

[build-dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_yaml = "0.9"

[dependencies]
ruby-prism-sys = { version = "1.5.1", path = "../ruby-prism-sys" }

[features]
default = ["vendored"]
vendored = ["ruby-prism-sys/vendored"]
prism-1.5.1/rust/ruby-prism/build.rs000066400000000000000000000630011506127434000174250ustar00rootroot00000000000000#![allow(clippy::too_many_lines, clippy::uninlined_format_args)]

use serde::Deserialize;
use std::fs::File;
use std::io::Write;
use std::path::Path;

#[derive(Debug, Deserialize)]
enum NodeFieldType {
    #[serde(rename = "node")]
    Node,

    #[serde(rename = "node?")]
    OptionalNode,

    #[serde(rename = "node[]")]
    NodeList,

    #[serde(rename = "string")]
    String,

    #[serde(rename = "constant")]
    Constant,

    #[serde(rename = "constant?")]
    OptionalConstant,

    #[serde(rename = "constant[]")]
    ConstantList,

    #[serde(rename = "location")]
    Location,

    #[serde(rename = "location?")]
    OptionalLocation,

    #[serde(rename = "uint8")]
    UInt8,

    #[serde(rename = "uint32")]
    UInt32,

    #[serde(rename = "integer")]
    Integer,

    #[serde(rename = "double")]
    Double,
}

#[derive(Debug, Deserialize)]
#[allow(dead_code)]
struct OnErrorType {
    #[serde(rename = "on error")]
    kind: String,
}

#[derive(Debug, Deserialize)]
#[serde(untagged)]
#[allow(dead_code)]
enum UnionKind {
    OnSuccess(String),
    OnError(OnErrorType),
}

#[derive(Debug, Deserialize)]
#[serde(untagged)]
#[allow(dead_code)]
enum NodeFieldKind {
    Concrete(String),
    Union(Vec),
}

#[derive(Debug, Deserialize)]
struct NodeField {
    name: String,

    #[serde(rename = "type")]
    field_type: NodeFieldType,

    kind: Option,
}

#[derive(Debug, Deserialize)]
struct FlagValue {
    name: String,
    comment: String,
}

#[derive(Debug, Deserialize)]
struct Flags {
    name: String,

    #[serde(default)]
    values: Vec,
}

#[derive(Debug, Deserialize)]
struct Node {
    name: String,

    flags: Option,

    #[serde(default)]
    fields: Vec,

    comment: String,
}

#[derive(Debug, Deserialize)]
struct Config {
    nodes: Vec,
    flags: Vec,
}

/// The main function for the build script. This will be run by Cargo when
/// building the library.
///
fn main() -> Result<(), Box> {
    let prism_dir = format!("prism-{}", env!("CARGO_PKG_VERSION"));
    let config_path = Path::new(env!("CARGO_MANIFEST_DIR")).join("vendor").join(prism_dir).join("config.yml");

    let config_file = std::fs::File::open(&config_path)?;
    println!("cargo:rerun-if-changed={}", config_path.to_str().unwrap());

    let config: Config = serde_yaml::from_reader(config_file)?;
    write_bindings(&config)?;

    Ok(())
}

/// Returns the name of a C struct from the given node name.
fn struct_name(name: &str) -> String {
    let mut result = String::with_capacity(1 + name.len());

    for char in name.chars() {
        if char.is_uppercase() {
            result.push('_');
        }
        result.push(char.to_lowercase().next().unwrap());
    }

    result
}

fn kind_to_type(kind: &String) -> String {
    match kind.as_str() {
        "non-void expression" | "pattern expression" | "Node" => String::new(),
        _ => kind.to_string(),
    }
}

/// Returns the name of the C type from the given node name.
fn type_name(name: &str) -> String {
    let mut result = String::with_capacity(8 + name.len());
    result.push_str("PM");

    for char in name.chars() {
        if char.is_uppercase() {
            result.push('_');
        }
        result.push(char.to_uppercase().next().unwrap());
    }

    result
}

/// Returns the name of the C enum constant from the given flag name and value.
fn enum_const_name(name: &str, value: &str) -> String {
    let mut result = String::with_capacity(8 + name.len() + value.len());
    result.push_str("PM");

    for char in name.chars() {
        if char.is_uppercase() {
            result.push('_');
        }
        result.extend(char.to_uppercase());
    }

    result.push('_');
    result.push_str(value);

    result
}

/// Returns the name of the C enum type from the given flag name.
fn enum_type_name(name: &str) -> String {
    let mut result = String::with_capacity(8 + name.len());
    result.push_str("pm");

    for char in name.chars() {
        if char.is_uppercase() {
            result.push('_');
        }
        result.extend(char.to_lowercase());
    }

    result
}

/// Returns the accessor function name from the given flag value.
fn accessor_func_name(value: &str) -> String {
    let mut result = String::with_capacity(8 + value.len());
    result.push_str("is_");

    for char in value.chars() {
        result.extend(char.to_lowercase());
    }

    result
}

/// Write the generated struct for the node to the file.
fn write_node(file: &mut File, flags: &[Flags], node: &Node) -> Result<(), Box> {
    let mut example = false;

    for line in node.comment.lines() {
        if let Some(stripped) = line.strip_prefix("    ") {
            if !example {
                writeln!(file, "/// ```ruby")?;
                example = true;
            }
            writeln!(file, "/// {}", stripped)?;
        } else {
            if example {
                writeln!(file, "/// ```")?;
                example = false;
            }
            writeln!(file, "/// {}", line)?;
        }
    }

    if example {
        writeln!(file, "/// ```")?;
    }

    writeln!(file, "pub struct {}<'pr> {{", node.name)?;
    writeln!(file, "    /// The pointer to the parser this node came from.")?;
    writeln!(file, "    parser: NonNull,")?;
    writeln!(file)?;
    writeln!(file, "    /// The raw pointer to the node allocated by prism.")?;
    writeln!(file, "    pointer: *mut pm{}_t,", struct_name(&node.name))?;
    writeln!(file)?;
    writeln!(file, "    /// The marker to indicate the lifetime of the pointer.")?;
    writeln!(file, "    marker: PhantomData<&'pr mut pm{}_t>", struct_name(&node.name))?;
    writeln!(file, "}}")?;
    writeln!(file)?;
    writeln!(file, "impl<'pr> {}<'pr> {{", node.name)?;
    writeln!(file, "    /// Converts this node to a generic node.")?;
    writeln!(file, "    #[must_use]")?;
    writeln!(file, "    pub const fn as_node(&self) -> Node<'pr> {{")?;
    writeln!(file, "        Node::{} {{ parser: self.parser, pointer: self.pointer, marker: PhantomData }}", node.name)?;
    writeln!(file, "    }}")?;
    writeln!(file)?;
    writeln!(file, "    /// Returns the location of this node.")?;
    writeln!(file, "    #[must_use]")?;
    writeln!(file, "    pub fn location(&self) -> Location<'pr> {{")?;
    writeln!(file, "        let pointer: *mut pm_location_t = unsafe {{ &raw mut (*self.pointer).base.location }};")?;
    writeln!(file, "        Location::new(self.parser, unsafe {{ &(*pointer) }})")?;
    writeln!(file, "    }}")?;
    writeln!(file)?;
    writeln!(file, "    /// Returns the flags of this node.")?;
    writeln!(file, "    #[must_use]")?;
    writeln!(file, "    pub fn flags(&self) -> pm_node_flags_t {{")?;
    writeln!(file, "        unsafe {{ (*self.pointer).base.flags }}")?;
    writeln!(file, "    }}")?;

    if let Some(kind) = &node.flags {
        let our_flags = flags.iter().filter(|f| &f.name == kind).collect::>();
        assert!(our_flags.len() == 1);

        for flag in our_flags {
            for value in &flag.values {
                writeln!(file)?;
                writeln!(file, "    /// {}", value.comment)?;
                writeln!(file, "    #[must_use]")?;
                writeln!(file, "    pub fn {}(&self) -> bool {{", accessor_func_name(&value.name))?;
                writeln!(file, "        (self.flags() & {}) != 0", enum_const_name(&flag.name, &value.name))?;
                writeln!(file, "    }}")?;
            }
        }
    }

    for field in &node.fields {
        writeln!(file)?;
        writeln!(file, "    /// Returns the `{}` param", field.name)?;
        writeln!(file, "    #[must_use]")?;

        match field.field_type {
            NodeFieldType::Node => match &field.kind {
                Some(NodeFieldKind::Concrete(raw_kind)) if !kind_to_type(raw_kind).is_empty() => {
                    let kind = kind_to_type(raw_kind);
                    writeln!(file, "    pub fn {}(&self) -> {}<'pr> {{", field.name, kind)?;
                    writeln!(file, "        let node: *mut pm{}_t = unsafe {{ (*self.pointer).{} }};", struct_name(&kind), field.name)?;
                    writeln!(file, "        {} {{ parser: self.parser, pointer: node, marker: PhantomData }}", kind)?;
                    writeln!(file, "    }}")?;
                },
                _ => {
                    writeln!(file, "    pub fn {}(&self) -> Node<'pr> {{", field.name)?;
                    writeln!(file, "        let node: *mut pm_node_t = unsafe {{ (*self.pointer).{} }};", field.name)?;
                    writeln!(file, "        Node::new(self.parser, node)")?;
                    writeln!(file, "    }}")?;
                },
            },
            NodeFieldType::OptionalNode => match &field.kind {
                Some(NodeFieldKind::Concrete(raw_kind)) if !kind_to_type(raw_kind).is_empty() => {
                    let kind = kind_to_type(raw_kind);
                    writeln!(file, "    pub fn {}(&self) -> Option<{}<'pr>> {{", field.name, kind)?;
                    writeln!(file, "        let node: *mut pm{}_t = unsafe {{ (*self.pointer).{} }};", struct_name(&kind), field.name)?;
                    writeln!(file, "        if node.is_null() {{")?;
                    writeln!(file, "            None")?;
                    writeln!(file, "        }} else {{")?;
                    writeln!(file, "            Some({} {{ parser: self.parser, pointer: node, marker: PhantomData }})", kind)?;
                    writeln!(file, "        }}")?;
                    writeln!(file, "    }}")?;
                },
                _ => {
                    writeln!(file, "    pub fn {}(&self) -> Option> {{", field.name)?;
                    writeln!(file, "        let node: *mut pm_node_t = unsafe {{ (*self.pointer).{} }};", field.name)?;
                    writeln!(file, "        if node.is_null() {{")?;
                    writeln!(file, "            None")?;
                    writeln!(file, "        }} else {{")?;
                    writeln!(file, "            Some(Node::new(self.parser, node))")?;
                    writeln!(file, "        }}")?;
                    writeln!(file, "    }}")?;
                },
            },
            NodeFieldType::NodeList => {
                writeln!(file, "    pub fn {}(&self) -> NodeList<'pr> {{", field.name)?;
                writeln!(file, "        let pointer: *mut pm_node_list = unsafe {{ &raw mut (*self.pointer).{} }};", field.name)?;
                writeln!(file, "        NodeList {{ parser: self.parser, pointer: unsafe {{ NonNull::new_unchecked(pointer) }}, marker: PhantomData }}")?;
                writeln!(file, "    }}")?;
            },
            NodeFieldType::String => {
                writeln!(file, "    pub fn {}(&self) -> &[u8] {{", field.name)?;
                writeln!(file, "        unsafe {{")?;
                writeln!(file, "            let source = (*self.pointer).{}.source;", field.name)?;
                writeln!(file, "            if source.is_null() {{")?;
                writeln!(file, "                return &[];")?;
                writeln!(file, "            }}")?;
                writeln!(file, "            let length = (*self.pointer).{}.length;", field.name)?;
                writeln!(file, "            std::slice::from_raw_parts(source, length)")?;
                writeln!(file, "        }}")?;
                writeln!(file, "    }}")?;
            },
            NodeFieldType::Constant => {
                writeln!(file, "    pub fn {}(&self) -> ConstantId<'pr> {{", field.name)?;
                writeln!(file, "        ConstantId::new(self.parser, unsafe {{ (*self.pointer).{} }})", field.name)?;
                writeln!(file, "    }}")?;
            },
            NodeFieldType::OptionalConstant => {
                writeln!(file, "    pub fn {}(&self) -> Option> {{", field.name)?;
                writeln!(file, "        let id = unsafe {{ (*self.pointer).{} }};", field.name)?;
                writeln!(file, "        if id == 0 {{")?;
                writeln!(file, "            None")?;
                writeln!(file, "        }} else {{")?;
                writeln!(file, "            Some(ConstantId::new(self.parser, id))")?;
                writeln!(file, "        }}")?;
                writeln!(file, "    }}")?;
            },
            NodeFieldType::ConstantList => {
                writeln!(file, "    pub fn {}(&self) -> ConstantList<'pr> {{", field.name)?;
                writeln!(file, "        let pointer: *mut pm_constant_id_list_t = unsafe {{ &raw mut (*self.pointer).{} }};", field.name)?;
                writeln!(file, "        ConstantList {{ parser: self.parser, pointer: unsafe {{ NonNull::new_unchecked(pointer) }}, marker: PhantomData }}")?;
                writeln!(file, "    }}")?;
            },
            NodeFieldType::Location => {
                writeln!(file, "    pub fn {}(&self) -> Location<'pr> {{", field.name)?;
                writeln!(file, "        let pointer: *mut pm_location_t = unsafe {{ &raw mut (*self.pointer).{} }};", field.name)?;
                writeln!(file, "        Location::new(self.parser, unsafe {{ &(*pointer) }})")?;
                writeln!(file, "    }}")?;
            },
            NodeFieldType::OptionalLocation => {
                writeln!(file, "    pub fn {}(&self) -> Option> {{", field.name)?;
                writeln!(file, "        let pointer: *mut pm_location_t = unsafe {{ &raw mut (*self.pointer).{} }};", field.name)?;
                writeln!(file, "        let start = unsafe {{ (*pointer).start }};")?;
                writeln!(file, "        if start.is_null() {{")?;
                writeln!(file, "            None")?;
                writeln!(file, "        }} else {{")?;
                writeln!(file, "            Some(Location::new(self.parser, unsafe {{ &(*pointer) }}))")?;
                writeln!(file, "        }}")?;
                writeln!(file, "    }}")?;
            },
            NodeFieldType::UInt8 => {
                writeln!(file, "    pub fn {}(&self) -> u8 {{", field.name)?;
                writeln!(file, "        unsafe {{ (*self.pointer).{} }}", field.name)?;
                writeln!(file, "    }}")?;
            },
            NodeFieldType::UInt32 => {
                writeln!(file, "    pub fn {}(&self) -> u32 {{", field.name)?;
                writeln!(file, "        unsafe {{ (*self.pointer).{} }}", field.name)?;
                writeln!(file, "    }}")?;
            },
            NodeFieldType::Integer => {
                writeln!(file, "    pub fn {}(&self) -> Integer<'pr> {{", field.name)?;
                writeln!(file, "        Integer::new(unsafe {{ &raw const(*self.pointer).{} }})", field.name)?;
                writeln!(file, "    }}")?;
            },
            NodeFieldType::Double => {
                writeln!(file, "    pub fn {}(&self) -> f64 {{", field.name)?;
                writeln!(file, "        unsafe {{ (*self.pointer).{} }}", field.name)?;
                writeln!(file, "    }}")?;
            },
        }
    }

    writeln!(file, "}}")?;
    writeln!(file)?;

    writeln!(file, "impl std::fmt::Debug for {}<'_> {{", node.name)?;
    writeln!(file, "    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {{")?;

    write!(file, "        write!(f, \"{}(", node.name)?;
    if node.fields.is_empty() {
        write!(file, ")\"")?;
    } else {
        let mut padding = false;
        for _ in &node.fields {
            if padding {
                write!(file, ", ")?;
            }
            write!(file, "{{:?}}")?;
            padding = true;
        }

        write!(file, ")\", ")?;
        padding = false;

        for field in &node.fields {
            if padding {
                write!(file, ", ")?;
            }
            write!(file, "self.{}()", field.name)?;
            padding = true;
        }
    }

    writeln!(file, ")")?;
    writeln!(file, "    }}")?;
    writeln!(file, "}}")?;

    Ok(())
}

/// Write the visit trait to the file.
fn write_visit(file: &mut File, config: &Config) -> Result<(), Box> {
    writeln!(file, "/// A trait for visiting the AST.")?;
    writeln!(file, "pub trait Visit<'pr> {{")?;
    writeln!(file, "   /// Called prior to visiting a node with potential child nodes.")?;
    writeln!(file, "   fn visit_branch_node_enter(&mut self, _node: Node<'pr>) {{")?;
    writeln!(file, "   }}")?;
    writeln!(file)?;
    writeln!(file, "   /// Called after visiting a node with potential child nodes.")?;
    writeln!(file, "   fn visit_branch_node_leave(&mut self) {{")?;
    writeln!(file, "   }}")?;
    writeln!(file)?;
    writeln!(file, "   /// Called prior to visiting a node that cannot have child nodes.")?;
    writeln!(file, "   fn visit_leaf_node_enter(&mut self, _node: Node<'pr>) {{")?;
    writeln!(file, "   }}")?;
    writeln!(file)?;
    writeln!(file, "   /// Called after visiting a node that cannot have child nodes.")?;
    writeln!(file, "   fn visit_leaf_node_leave(&mut self) {{")?;
    writeln!(file, "   }}")?;
    writeln!(file)?;
    writeln!(file, "   /// Visits a node.")?;
    writeln!(file, "   fn visit(&mut self, node: &Node<'pr>) {{")?;
    writeln!(file, "       match node {{")?;

    for node in &config.nodes {
        let has_child_nodes = node.fields.iter().any(|f| matches!(f.field_type, NodeFieldType::Node | NodeFieldType::OptionalNode | NodeFieldType::NodeList));
        let (pre_func, post_func) = if has_child_nodes { ("visit_branch_node_enter", "visit_branch_node_leave") } else { ("visit_leaf_node_enter", "visit_leaf_node_leave") };
        writeln!(file, "           Node::{} {{ parser, pointer, marker }} => {{", node.name)?;
        writeln!(file, "               let concrete = {} {{ parser: *parser, pointer: *pointer, marker: *marker }};", node.name)?;
        writeln!(file, "               self.{}(concrete.as_node());", pre_func)?;
        writeln!(file, "               self.visit{}(&concrete);", struct_name(&node.name))?;
        writeln!(file, "               self.{}();", post_func)?;
        writeln!(file, "           }}")?;
    }

    writeln!(file, "       }}")?;
    writeln!(file, "   }}")?;

    for node in &config.nodes {
        writeln!(file)?;
        writeln!(file, "    /// Visits a `{}` node.", node.name)?;
        writeln!(file, "    fn visit{}(&mut self, node: &{}<'pr>) {{", struct_name(&node.name), node.name)?;
        writeln!(file, "        visit{}(self, node);", struct_name(&node.name))?;
        writeln!(file, "    }}")?;
    }
    writeln!(file, "}}")?;

    for node in &config.nodes {
        writeln!(file)?;
        writeln!(file, "/// The default visitor implementation for a `{}` node.", node.name)?;

        let children = node.fields.iter().any(|f| matches!(f.field_type, NodeFieldType::Node | NodeFieldType::OptionalNode | NodeFieldType::NodeList));

        if children {
            writeln!(file, "pub fn visit{}<'pr, V>(visitor: &mut V, node: &{}<'pr>)", struct_name(&node.name), node.name)?;
            writeln!(file, "where")?;
            writeln!(file, "    V: Visit<'pr> + ?Sized,")?;
            writeln!(file, "{{")?;

            for field in &node.fields {
                match field.field_type {
                    NodeFieldType::Node => {
                        if let Some(NodeFieldKind::Concrete(raw_kind)) = &field.kind {
                            let kind = kind_to_type(raw_kind);
                            writeln!(file, "    visitor.visit{}(&node.{}());", struct_name(&kind), field.name)?;
                        } else {
                            writeln!(file, "    visitor.visit(&node.{}());", field.name)?;
                        }
                    },
                    NodeFieldType::OptionalNode => {
                        if let Some(NodeFieldKind::Concrete(raw_kind)) = &field.kind {
                            let kind = kind_to_type(raw_kind);
                            writeln!(file, "    if let Some(node) = node.{}() {{", field.name)?;
                            writeln!(file, "        visitor.visit{}(&node);", struct_name(&kind))?;
                            writeln!(file, "    }}")?;
                        } else {
                            writeln!(file, "    if let Some(node) = node.{}() {{", field.name)?;
                            writeln!(file, "        visitor.visit(&node);")?;
                            writeln!(file, "    }}")?;
                        }
                    },
                    NodeFieldType::NodeList => {
                        writeln!(file, "    for node in &node.{}() {{", field.name)?;
                        writeln!(file, "        visitor.visit(&node);")?;
                        writeln!(file, "    }}")?;
                    },
                    _ => {},
                }
            }

            writeln!(file, "}}")?;
        } else {
            writeln!(file, "pub const fn visit{}<'pr, V>(_visitor: &mut V, _node: &{}<'pr>)", struct_name(&node.name), node.name)?;
            writeln!(file, "where")?;
            writeln!(file, "    V: Visit<'pr> + ?Sized,")?;
            writeln!(file, "{{}}")?;
        }
    }

    Ok(())
}

/// Write the bindings to the `$OUT_DIR/bindings.rs` file. We'll pull these into
/// the actual library in `src/lib.rs`.
fn write_bindings(config: &Config) -> Result<(), Box> {
    let out_dir = std::env::var_os("OUT_DIR").unwrap();
    let dest_path = Path::new(&out_dir).join("bindings.rs");
    let mut file = std::fs::File::create(&dest_path).expect("Unable to create file");

    write!(
        file,
        r"
use std::marker::PhantomData;
use std::ptr::NonNull;

#[allow(clippy::wildcard_imports)]
use ruby_prism_sys::*;
use crate::{{ConstantId, ConstantList, Integer, Location, NodeList}};
"
    )?;

    for node in &config.nodes {
        writeln!(file, "const {}: u16 = pm_node_type::{} as u16;", type_name(&node.name), type_name(&node.name))?;
    }
    writeln!(file)?;
    for flag in &config.flags {
        for value in &flag.values {
            let const_name = enum_const_name(&flag.name, &value.name);
            writeln!(file, "const {}: u16 = {}::{} as u16;", &const_name, enum_type_name(&flag.name), &const_name)?;
        }
    }
    writeln!(file)?;

    writeln!(file, "/// An enum representing the different kinds of nodes that can be parsed.")?;
    writeln!(file, "pub enum Node<'pr> {{")?;

    for node in &config.nodes {
        writeln!(file, "    /// The `{}` node", node.name)?;
        writeln!(file, "    {} {{", node.name)?;
        writeln!(file, "        /// The pointer to the associated parser this node came from.")?;
        writeln!(file, "        parser: NonNull,")?;
        writeln!(file)?;
        writeln!(file, "        /// The raw pointer to the node allocated by prism.")?;
        writeln!(file, "        pointer: *mut pm{}_t,", struct_name(&node.name))?;
        writeln!(file)?;
        writeln!(file, "        /// The marker to indicate the lifetime of the pointer.")?;
        writeln!(file, "        marker: PhantomData<&'pr mut pm{}_t>", struct_name(&node.name))?;
        writeln!(file, "    }},")?;
    }

    writeln!(file, "}}")?;
    writeln!(file)?;

    writeln!(
        file,
        r"
impl<'pr> Node<'pr> {{
    /// Creates a new node from the given pointer.
    ///
    /// # Panics
    ///
    /// Panics if the node type cannot be read.
    ///
    #[allow(clippy::not_unsafe_ptr_arg_deref)]
    pub(crate) fn new(parser: NonNull, node: *mut pm_node_t) -> Self {{
        match unsafe {{ (*node).type_ }} {{
"
    )?;

    for node in &config.nodes {
        writeln!(file, "            {} => Self::{} {{ parser, pointer: node.cast::(), marker: PhantomData }},", type_name(&node.name), node.name, struct_name(&node.name))?;
    }

    writeln!(file, "            _ => panic!(\"Unknown node type: {{}}\", unsafe {{ (*node).type_ }})")?;
    writeln!(file, "        }}")?;
    writeln!(file, "    }}")?;
    writeln!(file)?;

    writeln!(file, "    /// Returns the location of this node.")?;
    writeln!(file, "    #[must_use]")?;
    writeln!(file, "    pub fn location(&self) -> Location<'pr> {{")?;
    writeln!(file, "        match *self {{")?;
    for node in &config.nodes {
        writeln!(file, "            Self::{} {{ pointer, parser, .. }} => Location::new(parser, unsafe {{ &((*pointer.cast::()).location) }}),", node.name)?;
    }
    writeln!(file, "        }}")?;
    writeln!(file, "    }}")?;
    writeln!(file)?;

    for node in &config.nodes {
        writeln!(file, "    /// Returns the node as a `{}`.", node.name)?;
        writeln!(file, "    #[must_use]")?;
        writeln!(file, "    pub const fn as{}(&self) -> Option<{}<'pr>> {{", struct_name(&node.name), node.name)?;
        writeln!(file, "        match *self {{")?;
        writeln!(file, "            Self::{} {{ parser, pointer, marker }} => Some({} {{ parser, pointer, marker }}),", node.name, node.name)?;
        writeln!(file, "            _ => None")?;
        writeln!(file, "        }}")?;
        writeln!(file, "    }}")?;
    }

    writeln!(file, "}}")?;
    writeln!(file)?;

    writeln!(file, "impl std::fmt::Debug for Node<'_> {{")?;
    writeln!(file, "    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {{")?;
    writeln!(file, "        match *self {{")?;

    for node in &config.nodes {
        writeln!(file, "            Self::{} {{ parser, pointer, marker }} => write!(f, \"{{:?}}\", {} {{ parser, pointer, marker }}),", node.name, node.name)?;
    }

    writeln!(file, "        }}")?;
    writeln!(file, "    }}")?;
    writeln!(file, "}}")?;
    writeln!(file)?;

    for node in &config.nodes {
        write_node(&mut file, &config.flags, node)?;
        writeln!(file)?;
    }

    write_visit(&mut file, config)?;

    Ok(())
}
prism-1.5.1/rust/ruby-prism/examples/000077500000000000000000000000001506127434000175765ustar00rootroot00000000000000prism-1.5.1/rust/ruby-prism/examples/wasm/000077500000000000000000000000001506127434000205455ustar00rootroot00000000000000prism-1.5.1/rust/ruby-prism/examples/wasm/main.rs000066400000000000000000000007241506127434000220420ustar00rootroot00000000000000use std::io::{stdin, Read};

fn main() {
    let mut source = String::new();
    stdin().read_to_string(&mut source).unwrap();
    let result = ruby_prism::parse(source.as_ref());
    let comments_count = result.comments().count();
    let warnings_count = result.warnings().count();
    let errors_count = result.errors().count();
    println!("  comments: {comments_count}");
    println!("  warnings: {warnings_count}");
    println!("  errors: {errors_count}");
}
prism-1.5.1/rust/ruby-prism/examples/wasm/run.sh000077500000000000000000000035261506127434000217160ustar00rootroot00000000000000#!/bin/bash

set -ex

WASI_SDK_VERSION_MAJOR="25"
WASI_SDK_VERSION="$WASI_SDK_VERSION_MAJOR.0"
TMPDIR="$(pwd)/tmp"
WASI_SDK_PATH="${TMPDIR}/wasi-sdk-${WASI_SDK_VERSION}"
WASI_SDK_TAR="${TMPDIR}/wasi-sdk.tar.gz"
WASM_BUILD_DIR="./target/wasm32-wasip1/debug/examples"
WASM_FILE="${WASM_BUILD_DIR}/wasm.wasm"

export WASI_SDK_PATH

download_wasi_sdk() {
  if [ -d "${WASI_SDK_PATH}" ]; then
    echo "WASI SDK already downloaded to ${WASI_SDK_PATH}" >&2
    return
  fi

  mkdir -p "${TMPDIR}"

  if [ "$(uname)" == "Darwin" ]; then
    echo "Downloading wasi-sdk for macOS" >&2
    curl -sLo "${WASI_SDK_TAR}" "https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${WASI_SDK_VERSION_MAJOR}/wasi-sdk-${WASI_SDK_VERSION}-x86_64-macos.tar.gz" >&2
  elif [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]; then
    echo "Downloading wasi-sdk for Linux" >&2
    curl -sLo "${WASI_SDK_TAR}" "https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${WASI_SDK_VERSION_MAJOR}/wasi-sdk-${WASI_SDK_VERSION}-x86_64-linux.tar.gz" >&2
  else
    echo "Unsupported platform" >&2
    exit 1
  fi

  tar -xzf "${WASI_SDK_TAR}" -C "${TMPDIR}" >&2
  echo "WASI SDK downloaded to ${TMPDIR}" >&2

  if [ "$(uname)" == "Darwin" ]; then
    mv ${TMPDIR}/wasi-sdk-${WASI_SDK_VERSION}-x86_64-macos ${WASI_SDK_PATH}
  elif [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]; then
    mv ${TMPDIR}/wasi-sdk-${WASI_SDK_VERSION}-x86_64-linux ${WASI_SDK_PATH}
  else
    echo "Unsupported platform" >&2
    exit 1
  fi
}

build_wasm() {
  cargo build --target=wasm32-wasip1 --example wasm >&2
  echo "WASM built to ${WASM_FILE}" >&2
}

download_wasi_sdk
build_wasm

if command -v wasmtime >/dev/null 2>&1; then
  for ruby_file in ../../lib/**/*.rb; do
    echo "${ruby_file}"
    wasmtime run "${WASM_FILE}" < "${ruby_file}"
  done
else
  echo "wasmtime not found, skipping run..." >&2
fi
prism-1.5.1/rust/ruby-prism/rustfmt.toml000066400000000000000000000000621506127434000203570ustar00rootroot00000000000000max_width = 300
match_block_trailing_comma = true
prism-1.5.1/rust/ruby-prism/src/000077500000000000000000000000001506127434000165475ustar00rootroot00000000000000prism-1.5.1/rust/ruby-prism/src/lib.rs000066400000000000000000001205411506127434000176660ustar00rootroot00000000000000//! # ruby-prism
//!
//! Rustified version of Ruby's prism parser.
//!
#![warn(clippy::all, clippy::nursery, clippy::pedantic, future_incompatible, missing_docs, nonstandard_style, rust_2018_idioms, trivial_casts, trivial_numeric_casts, unreachable_pub, unused_qualifications)]

// Most of the code in this file is generated, so sometimes it generates code
// that doesn't follow the clippy rules. We don't want to see those warnings.
#[allow(clippy::too_many_lines, clippy::use_self)]
mod bindings {
    // In `build.rs`, we generate bindings based on the config.yml file. Here is
    // where we pull in those bindings and make them part of our library.
    include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
}

use std::ffi::{c_char, CStr};
use std::marker::PhantomData;
use std::mem::MaybeUninit;
use std::ptr::NonNull;

pub use self::bindings::*;
use ruby_prism_sys::{pm_comment_t, pm_comment_type_t, pm_constant_id_list_t, pm_constant_id_t, pm_diagnostic_t, pm_integer_t, pm_location_t, pm_magic_comment_t, pm_node_destroy, pm_node_list, pm_node_t, pm_parse, pm_parser_free, pm_parser_init, pm_parser_t};

/// A range in the source file.
pub struct Location<'pr> {
    parser: NonNull,
    pub(crate) start: *const u8,
    pub(crate) end: *const u8,
    marker: PhantomData<&'pr [u8]>,
}

impl<'pr> Location<'pr> {
    /// Returns a byte slice for the range.
    /// # Panics
    /// Panics if the end offset is not greater than the start offset.
    #[must_use]
    pub fn as_slice(&self) -> &'pr [u8] {
        unsafe {
            let len = usize::try_from(self.end.offset_from(self.start)).expect("end should point to memory after start");
            std::slice::from_raw_parts(self.start, len)
        }
    }

    /// Return a Location from the given `pm_location_t`.
    #[must_use]
    pub(crate) const fn new(parser: NonNull, loc: &'pr pm_location_t) -> Self {
        Location {
            parser,
            start: loc.start,
            end: loc.end,
            marker: PhantomData,
        }
    }

    /// Return a Location starting at self and ending at the end of other.
    /// Returns None if both locations did not originate from the same parser,
    /// or if self starts after other.
    #[must_use]
    pub fn join(&self, other: &Self) -> Option {
        if self.parser != other.parser || self.start > other.start {
            None
        } else {
            Some(Location {
                parser: self.parser,
                start: self.start,
                end: other.end,
                marker: PhantomData,
            })
        }
    }

    /// Return the start offset from the beginning of the parsed source.
    /// # Panics
    /// Panics if the start offset is not greater than the parser's start.
    #[must_use]
    pub fn start_offset(&self) -> usize {
        unsafe {
            let parser_start = (*self.parser.as_ptr()).start;
            usize::try_from(self.start.offset_from(parser_start)).expect("start should point to memory after the parser's start")
        }
    }

    /// Return the end offset from the beginning of the parsed source.
    /// # Panics
    /// Panics if the end offset is not greater than the parser's start.
    #[must_use]
    pub fn end_offset(&self) -> usize {
        unsafe {
            let parser_start = (*self.parser.as_ptr()).start;
            usize::try_from(self.end.offset_from(parser_start)).expect("end should point to memory after the parser's start")
        }
    }
}

impl std::fmt::Debug for Location<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let slice: &[u8] = self.as_slice();

        let mut visible = String::new();
        visible.push('"');

        for &byte in slice {
            let part: Vec = std::ascii::escape_default(byte).collect();
            visible.push_str(std::str::from_utf8(&part).unwrap());
        }

        visible.push('"');
        write!(f, "{visible}")
    }
}

/// An iterator over the nodes in a list.
pub struct NodeListIter<'pr> {
    parser: NonNull,
    pointer: NonNull,
    index: usize,
    marker: PhantomData<&'pr mut pm_node_list>,
}

impl<'pr> Iterator for NodeListIter<'pr> {
    type Item = Node<'pr>;

    fn next(&mut self) -> Option {
        if self.index >= unsafe { self.pointer.as_ref().size } {
            None
        } else {
            let node: *mut pm_node_t = unsafe { *(self.pointer.as_ref().nodes.add(self.index)) };
            self.index += 1;
            Some(Node::new(self.parser, node))
        }
    }
}

/// A list of nodes.
pub struct NodeList<'pr> {
    parser: NonNull,
    pointer: NonNull,
    marker: PhantomData<&'pr mut pm_node_list>,
}

impl<'pr> NodeList<'pr> {
    /// Returns an iterator over the nodes.
    #[must_use]
    pub const fn iter(&self) -> NodeListIter<'pr> {
        NodeListIter {
            parser: self.parser,
            pointer: self.pointer,
            index: 0,
            marker: PhantomData,
        }
    }
}

impl<'pr> IntoIterator for &NodeList<'pr> {
    type Item = Node<'pr>;
    type IntoIter = NodeListIter<'pr>;
    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

impl std::fmt::Debug for NodeList<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self.iter().collect::>())
    }
}

/// A handle for a constant ID.
pub struct ConstantId<'pr> {
    parser: NonNull,
    id: pm_constant_id_t,
    marker: PhantomData<&'pr mut pm_constant_id_t>,
}

impl<'pr> ConstantId<'pr> {
    const fn new(parser: NonNull, id: pm_constant_id_t) -> Self {
        ConstantId { parser, id, marker: PhantomData }
    }

    /// Returns a byte slice for the constant ID.
    ///
    /// # Panics
    ///
    /// Panics if the constant ID is not found in the constant pool.
    #[must_use]
    pub fn as_slice(&self) -> &'pr [u8] {
        unsafe {
            let pool = &(*self.parser.as_ptr()).constant_pool;
            let constant = &(*pool.constants.add((self.id - 1).try_into().unwrap()));
            std::slice::from_raw_parts(constant.start, constant.length)
        }
    }
}

impl std::fmt::Debug for ConstantId<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self.id)
    }
}

/// An iterator over the constants in a list.
pub struct ConstantListIter<'pr> {
    parser: NonNull,
    pointer: NonNull,
    index: usize,
    marker: PhantomData<&'pr mut pm_constant_id_list_t>,
}

impl<'pr> Iterator for ConstantListIter<'pr> {
    type Item = ConstantId<'pr>;

    fn next(&mut self) -> Option {
        if self.index >= unsafe { self.pointer.as_ref().size } {
            None
        } else {
            let constant_id: pm_constant_id_t = unsafe { *(self.pointer.as_ref().ids.add(self.index)) };
            self.index += 1;
            Some(ConstantId::new(self.parser, constant_id))
        }
    }
}

/// A list of constants.
pub struct ConstantList<'pr> {
    /// The raw pointer to the parser where this list came from.
    parser: NonNull,

    /// The raw pointer to the list allocated by prism.
    pointer: NonNull,

    /// The marker to indicate the lifetime of the pointer.
    marker: PhantomData<&'pr mut pm_constant_id_list_t>,
}

impl<'pr> ConstantList<'pr> {
    /// Returns an iterator over the constants in the list.
    #[must_use]
    pub const fn iter(&self) -> ConstantListIter<'pr> {
        ConstantListIter {
            parser: self.parser,
            pointer: self.pointer,
            index: 0,
            marker: PhantomData,
        }
    }
}

impl<'pr> IntoIterator for &ConstantList<'pr> {
    type Item = ConstantId<'pr>;
    type IntoIter = ConstantListIter<'pr>;
    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

impl std::fmt::Debug for ConstantList<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self.iter().collect::>())
    }
}

/// A handle for an arbitarily-sized integer.
pub struct Integer<'pr> {
    /// The raw pointer to the integer allocated by prism.
    pointer: *const pm_integer_t,

    /// The marker to indicate the lifetime of the pointer.
    marker: PhantomData<&'pr mut pm_constant_id_t>,
}

impl Integer<'_> {
    const fn new(pointer: *const pm_integer_t) -> Self {
        Integer { pointer, marker: PhantomData }
    }

    /// Returns the sign and the u32 digits representation of the integer,
    /// ordered least significant digit first.
    #[must_use]
    pub const fn to_u32_digits(&self) -> (bool, &[u32]) {
        let negative = unsafe { (*self.pointer).negative };
        let length = unsafe { (*self.pointer).length };
        let values = unsafe { (*self.pointer).values };

        if values.is_null() {
            let value_ptr = unsafe { std::ptr::addr_of!((*self.pointer).value) };
            let slice = unsafe { std::slice::from_raw_parts(value_ptr, 1) };
            (negative, slice)
        } else {
            let slice = unsafe { std::slice::from_raw_parts(values, length) };
            (negative, slice)
        }
    }
}

impl std::fmt::Debug for Integer<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self.pointer)
    }
}

impl TryInto for Integer<'_> {
    type Error = ();

    fn try_into(self) -> Result {
        let negative = unsafe { (*self.pointer).negative };
        let length = unsafe { (*self.pointer).length };

        if length == 0 {
            i32::try_from(unsafe { (*self.pointer).value }).map_or(Err(()), |value| if negative { Ok(-value) } else { Ok(value) })
        } else {
            Err(())
        }
    }
}

/// A diagnostic message that came back from the parser.
#[derive(Debug)]
pub struct Diagnostic<'pr> {
    diag: NonNull,
    parser: NonNull,
    marker: PhantomData<&'pr pm_diagnostic_t>,
}

impl<'pr> Diagnostic<'pr> {
    /// Returns the message associated with the diagnostic.
    ///
    /// # Panics
    ///
    /// Panics if the message is not able to be converted into a `CStr`.
    ///
    #[must_use]
    pub fn message(&self) -> &str {
        unsafe {
            let message: *mut c_char = self.diag.as_ref().message.cast_mut();
            CStr::from_ptr(message).to_str().expect("prism allows only UTF-8 for diagnostics.")
        }
    }

    /// The location of the diagnostic in the source.
    #[must_use]
    pub const fn location(&self) -> Location<'pr> {
        Location::new(self.parser, unsafe { &self.diag.as_ref().location })
    }
}

/// A comment that was found during parsing.
#[derive(Debug)]
pub struct Comment<'pr> {
    content: NonNull,
    parser: NonNull,
    marker: PhantomData<&'pr pm_comment_t>,
}

/// The type of the comment
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CommentType {
    /// `InlineComment` corresponds to comments that start with #.
    InlineComment,
    /// `EmbDocComment` corresponds to comments that are surrounded by =begin and =end.
    EmbDocComment,
}

impl<'pr> Comment<'pr> {
    /// Returns the text of the comment.
    ///
    /// # Panics
    /// Panics if the end offset is not greater than the start offset.
    #[must_use]
    pub fn text(&self) -> &[u8] {
        self.location().as_slice()
    }

    /// Returns the type of the comment.
    #[must_use]
    pub fn type_(&self) -> CommentType {
        let type_ = unsafe { self.content.as_ref().type_ };
        if type_ == pm_comment_type_t::PM_COMMENT_EMBDOC {
            CommentType::EmbDocComment
        } else {
            CommentType::InlineComment
        }
    }

    /// The location of the comment in the source.
    #[must_use]
    pub const fn location(&self) -> Location<'pr> {
        Location::new(self.parser, unsafe { &self.content.as_ref().location })
    }
}

/// A magic comment that was found during parsing.
#[derive(Debug)]
pub struct MagicComment<'pr> {
    comment: NonNull,
    marker: PhantomData<&'pr pm_magic_comment_t>,
}

impl MagicComment<'_> {
    /// Returns the text of the comment's key.
    #[must_use]
    pub const fn key(&self) -> &[u8] {
        unsafe {
            let start = self.comment.as_ref().key_start;
            let len = self.comment.as_ref().key_length as usize;
            std::slice::from_raw_parts(start, len)
        }
    }

    /// Returns the text of the comment's value.
    #[must_use]
    pub const fn value(&self) -> &[u8] {
        unsafe {
            let start = self.comment.as_ref().value_start;
            let len = self.comment.as_ref().value_length as usize;
            std::slice::from_raw_parts(start, len)
        }
    }
}

/// A struct created by the `errors` or `warnings` methods on `ParseResult`. It
/// can be used to iterate over the diagnostics in the parse result.
pub struct Diagnostics<'pr> {
    diagnostic: *mut pm_diagnostic_t,
    parser: NonNull,
    marker: PhantomData<&'pr pm_diagnostic_t>,
}

impl<'pr> Iterator for Diagnostics<'pr> {
    type Item = Diagnostic<'pr>;

    fn next(&mut self) -> Option {
        if let Some(diagnostic) = NonNull::new(self.diagnostic) {
            let current = Diagnostic {
                diag: diagnostic,
                parser: self.parser,
                marker: PhantomData,
            };
            self.diagnostic = unsafe { diagnostic.as_ref().node.next.cast::() };
            Some(current)
        } else {
            None
        }
    }
}

/// A struct created by the `comments` method on `ParseResult`. It can be used
/// to iterate over the comments in the parse result.
pub struct Comments<'pr> {
    comment: *mut pm_comment_t,
    parser: NonNull,
    marker: PhantomData<&'pr pm_comment_t>,
}

impl<'pr> Iterator for Comments<'pr> {
    type Item = Comment<'pr>;

    fn next(&mut self) -> Option {
        if let Some(comment) = NonNull::new(self.comment) {
            let current = Comment {
                content: comment,
                parser: self.parser,
                marker: PhantomData,
            };
            self.comment = unsafe { comment.as_ref().node.next.cast::() };
            Some(current)
        } else {
            None
        }
    }
}

/// A struct created by the `magic_comments` method on `ParseResult`. It can be used
/// to iterate over the magic comments in the parse result.
pub struct MagicComments<'pr> {
    comment: *mut pm_magic_comment_t,
    marker: PhantomData<&'pr pm_magic_comment_t>,
}

impl<'pr> Iterator for MagicComments<'pr> {
    type Item = MagicComment<'pr>;

    fn next(&mut self) -> Option {
        if let Some(comment) = NonNull::new(self.comment) {
            let current = MagicComment { comment, marker: PhantomData };
            self.comment = unsafe { comment.as_ref().node.next.cast::() };
            Some(current)
        } else {
            None
        }
    }
}

/// The result of parsing a source string.
#[derive(Debug)]
pub struct ParseResult<'pr> {
    source: &'pr [u8],
    parser: NonNull,
    node: NonNull,
}

impl<'pr> ParseResult<'pr> {
    /// Returns the source string that was parsed.
    #[must_use]
    pub const fn source(&self) -> &'pr [u8] {
        self.source
    }

    /// Returns whether we found a `frozen_string_literal` magic comment with a true value.
    #[must_use]
    pub fn frozen_string_literals(&self) -> bool {
        unsafe { (*self.parser.as_ptr()).frozen_string_literal == 1 }
    }

    /// Returns a slice of the source string that was parsed using the given
    /// location range.
    ///
    /// # Panics
    /// Panics if start offset or end offset are not valid offsets from the root.
    #[must_use]
    pub fn as_slice(&self, location: &Location<'pr>) -> &'pr [u8] {
        let root = self.source.as_ptr();

        let start = usize::try_from(unsafe { location.start.offset_from(root) }).expect("start should point to memory after root");
        let end = usize::try_from(unsafe { location.end.offset_from(root) }).expect("end should point to memory after root");

        &self.source[start..end]
    }

    /// Returns an iterator that can be used to iterate over the errors in the
    /// parse result.
    #[must_use]
    pub fn errors(&self) -> Diagnostics<'_> {
        unsafe {
            let list = &mut (*self.parser.as_ptr()).error_list;
            Diagnostics {
                diagnostic: list.head.cast::(),
                parser: self.parser,
                marker: PhantomData,
            }
        }
    }

    /// Returns an iterator that can be used to iterate over the warnings in the
    /// parse result.
    #[must_use]
    pub fn warnings(&self) -> Diagnostics<'_> {
        unsafe {
            let list = &mut (*self.parser.as_ptr()).warning_list;
            Diagnostics {
                diagnostic: list.head.cast::(),
                parser: self.parser,
                marker: PhantomData,
            }
        }
    }

    /// Returns an iterator that can be used to iterate over the comments in the
    /// parse result.
    #[must_use]
    pub fn comments(&self) -> Comments<'_> {
        unsafe {
            let list = &mut (*self.parser.as_ptr()).comment_list;
            Comments {
                comment: list.head.cast::(),
                parser: self.parser,
                marker: PhantomData,
            }
        }
    }

    /// Returns an iterator that can be used to iterate over the magic comments in the
    /// parse result.
    #[must_use]
    pub fn magic_comments(&self) -> MagicComments<'_> {
        unsafe {
            let list = &mut (*self.parser.as_ptr()).magic_comment_list;
            MagicComments {
                comment: list.head.cast::(),
                marker: PhantomData,
            }
        }
    }

    /// Returns an optional location of the __END__ marker and the rest of the content of the file.
    #[must_use]
    pub fn data_loc(&self) -> Option> {
        let location = unsafe { &(*self.parser.as_ptr()).data_loc };
        if location.start.is_null() {
            None
        } else {
            Some(Location::new(self.parser, location))
        }
    }

    /// Returns the root node of the parse result.
    #[must_use]
    pub fn node(&self) -> Node<'_> {
        Node::new(self.parser, self.node.as_ptr())
    }
}

impl Drop for ParseResult<'_> {
    fn drop(&mut self) {
        unsafe {
            pm_node_destroy(self.parser.as_ptr(), self.node.as_ptr());
            pm_parser_free(self.parser.as_ptr());
            drop(Box::from_raw(self.parser.as_ptr()));
        }
    }
}

/// Parses the given source string and returns a parse result.
///
/// # Panics
///
/// Panics if the parser fails to initialize.
///
#[must_use]
pub fn parse(source: &[u8]) -> ParseResult<'_> {
    unsafe {
        let uninit = Box::new(MaybeUninit::::uninit());
        let uninit = Box::into_raw(uninit);

        pm_parser_init((*uninit).as_mut_ptr(), source.as_ptr(), source.len(), std::ptr::null());

        let parser = (*uninit).assume_init_mut();
        let parser = NonNull::new_unchecked(parser);

        let node = pm_parse(parser.as_ptr());
        let node = NonNull::new_unchecked(node);

        ParseResult { source, parser, node }
    }
}

#[cfg(test)]
mod tests {
    use super::parse;

    #[test]
    fn comments_test() {
        let source = "# comment 1\n# comment 2\n# comment 3\n";
        let result = parse(source.as_ref());

        for comment in result.comments() {
            assert_eq!(super::CommentType::InlineComment, comment.type_());
            let text = std::str::from_utf8(comment.text()).unwrap();
            assert!(text.starts_with("# comment"));
        }
    }

    #[test]
    fn magic_comments_test() {
        use crate::MagicComment;

        let source = "# typed: ignore\n# typed:true\n#typed: strict\n";
        let result = parse(source.as_ref());

        let comments: Vec> = result.magic_comments().collect();
        assert_eq!(3, comments.len());

        assert_eq!(b"typed", comments[0].key());
        assert_eq!(b"ignore", comments[0].value());

        assert_eq!(b"typed", comments[1].key());
        assert_eq!(b"true", comments[1].value());

        assert_eq!(b"typed", comments[2].key());
        assert_eq!(b"strict", comments[2].value());
    }

    #[test]
    fn data_loc_test() {
        let source = "1";
        let result = parse(source.as_ref());
        let data_loc = result.data_loc();
        assert!(data_loc.is_none());

        let source = "__END__\nabc\n";
        let result = parse(source.as_ref());
        let data_loc = result.data_loc().unwrap();
        let slice = std::str::from_utf8(result.as_slice(&data_loc)).unwrap();
        assert_eq!(slice, "__END__\nabc\n");

        let source = "1\n2\n3\n__END__\nabc\ndef\n";
        let result = parse(source.as_ref());
        let data_loc = result.data_loc().unwrap();
        let slice = std::str::from_utf8(result.as_slice(&data_loc)).unwrap();
        assert_eq!(slice, "__END__\nabc\ndef\n");
    }

    #[test]
    fn location_test() {
        let source = "111 + 222 + 333";
        let result = parse(source.as_ref());

        let node = result.node();
        let node = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let node = node.as_call_node().unwrap().receiver().unwrap();
        let plus = node.as_call_node().unwrap();
        let node = plus.arguments().unwrap().arguments().iter().next().unwrap();

        let location = node.as_integer_node().unwrap().location();
        let slice = std::str::from_utf8(result.as_slice(&location)).unwrap();

        assert_eq!(slice, "222");
        assert_eq!(6, location.start_offset());
        assert_eq!(9, location.end_offset());

        let recv_loc = plus.receiver().unwrap().location();
        assert_eq!(recv_loc.as_slice(), b"111");
        assert_eq!(0, recv_loc.start_offset());
        assert_eq!(3, recv_loc.end_offset());

        let joined = recv_loc.join(&location).unwrap();
        assert_eq!(joined.as_slice(), b"111 + 222");

        let not_joined = location.join(&recv_loc);
        assert!(not_joined.is_none());

        {
            let result = parse(source.as_ref());
            let node = result.node();
            let node = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
            let node = node.as_call_node().unwrap().receiver().unwrap();
            let plus = node.as_call_node().unwrap();
            let node = plus.arguments().unwrap().arguments().iter().next().unwrap();

            let location = node.as_integer_node().unwrap().location();
            let not_joined = recv_loc.join(&location);
            assert!(not_joined.is_none());

            let not_joined = location.join(&recv_loc);
            assert!(not_joined.is_none());
        }

        let location = node.location();
        let slice = std::str::from_utf8(result.as_slice(&location)).unwrap();

        assert_eq!(slice, "222");

        let slice = std::str::from_utf8(location.as_slice()).unwrap();

        assert_eq!(slice, "222");
    }

    #[test]
    fn visitor_test() {
        use super::{visit_interpolated_regular_expression_node, visit_regular_expression_node, InterpolatedRegularExpressionNode, RegularExpressionNode, Visit};

        struct RegularExpressionVisitor {
            count: usize,
        }

        impl Visit<'_> for RegularExpressionVisitor {
            fn visit_interpolated_regular_expression_node(&mut self, node: &InterpolatedRegularExpressionNode<'_>) {
                self.count += 1;
                visit_interpolated_regular_expression_node(self, node);
            }

            fn visit_regular_expression_node(&mut self, node: &RegularExpressionNode<'_>) {
                self.count += 1;
                visit_regular_expression_node(self, node);
            }
        }

        let source = "# comment 1\n# comment 2\nmodule Foo; class Bar; /abc #{/def/}/; end; end";
        let result = parse(source.as_ref());

        let mut visitor = RegularExpressionVisitor { count: 0 };
        visitor.visit(&result.node());

        assert_eq!(visitor.count, 2);
    }

    #[test]
    fn node_upcast_test() {
        use super::Node;

        let source = "module Foo; end";
        let result = parse(source.as_ref());

        let node = result.node();
        let upcast_node = node.as_program_node().unwrap().as_node();
        assert!(matches!(upcast_node, Node::ProgramNode { .. }));

        let node = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let upcast_node = node.as_module_node().unwrap().as_node();
        assert!(matches!(upcast_node, Node::ModuleNode { .. }));
    }

    #[test]
    fn constant_id_test() {
        let source = "module Foo; x = 1; end";
        let result = parse(source.as_ref());

        let node = result.node();
        let module = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let module = module.as_module_node().unwrap();
        let locals = module.locals().iter().collect::>();

        assert_eq!(locals.len(), 1);

        assert_eq!(locals[0].as_slice(), b"x");
    }

    #[test]
    fn optional_loc_test() {
        let source = r"
module Example
  x = call_func(3, 4)
  y = x.call_func 5, 6
end
";
        let result = parse(source.as_ref());

        let node = result.node();
        let module = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let module = module.as_module_node().unwrap();
        let body = module.body();
        let writes = body.iter().next().unwrap().as_statements_node().unwrap().body().iter().collect::>();
        assert_eq!(writes.len(), 2);

        let asgn = &writes[0];
        let call = asgn.as_local_variable_write_node().unwrap().value();
        let call = call.as_call_node().unwrap();

        let call_operator_loc = call.call_operator_loc();
        assert!(call_operator_loc.is_none());
        let closing_loc = call.closing_loc();
        assert!(closing_loc.is_some());

        let asgn = &writes[1];
        let call = asgn.as_local_variable_write_node().unwrap().value();
        let call = call.as_call_node().unwrap();

        let call_operator_loc = call.call_operator_loc();
        assert!(call_operator_loc.is_some());
        let closing_loc = call.closing_loc();
        assert!(closing_loc.is_none());
    }

    #[test]
    fn frozen_strings_test() {
        let source = r#"
# frozen_string_literal: true
"foo"
"#;
        let result = parse(source.as_ref());
        assert!(result.frozen_string_literals());

        let source = "3";
        let result = parse(source.as_ref());
        assert!(!result.frozen_string_literals());
    }

    #[test]
    fn string_flags_test() {
        let source = r#"
# frozen_string_literal: true
"foo"
"#;
        let result = parse(source.as_ref());

        let node = result.node();
        let string = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let string = string.as_string_node().unwrap();
        assert!(string.is_frozen());

        let source = r#"
"foo"
"#;
        let result = parse(source.as_ref());

        let node = result.node();
        let string = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let string = string.as_string_node().unwrap();
        assert!(!string.is_frozen());
    }

    #[test]
    fn call_flags_test() {
        let source = r"
x
";
        let result = parse(source.as_ref());

        let node = result.node();
        let call = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let call = call.as_call_node().unwrap();
        assert!(call.is_variable_call());

        let source = r"
x&.foo
";
        let result = parse(source.as_ref());

        let node = result.node();
        let call = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let call = call.as_call_node().unwrap();
        assert!(call.is_safe_navigation());
    }

    #[test]
    fn integer_flags_test() {
        let source = r"
0b1
";
        let result = parse(source.as_ref());

        let node = result.node();
        let i = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let i = i.as_integer_node().unwrap();
        assert!(i.is_binary());
        assert!(!i.is_decimal());
        assert!(!i.is_octal());
        assert!(!i.is_hexadecimal());

        let source = r"
1
";
        let result = parse(source.as_ref());

        let node = result.node();
        let i = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let i = i.as_integer_node().unwrap();
        assert!(!i.is_binary());
        assert!(i.is_decimal());
        assert!(!i.is_octal());
        assert!(!i.is_hexadecimal());

        let source = r"
0o1
";
        let result = parse(source.as_ref());

        let node = result.node();
        let i = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let i = i.as_integer_node().unwrap();
        assert!(!i.is_binary());
        assert!(!i.is_decimal());
        assert!(i.is_octal());
        assert!(!i.is_hexadecimal());

        let source = r"
0x1
";
        let result = parse(source.as_ref());

        let node = result.node();
        let i = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let i = i.as_integer_node().unwrap();
        assert!(!i.is_binary());
        assert!(!i.is_decimal());
        assert!(!i.is_octal());
        assert!(i.is_hexadecimal());
    }

    #[test]
    fn range_flags_test() {
        let source = r"
0..1
";
        let result = parse(source.as_ref());

        let node = result.node();
        let range = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let range = range.as_range_node().unwrap();
        assert!(!range.is_exclude_end());

        let source = r"
0...1
";
        let result = parse(source.as_ref());

        let node = result.node();
        let range = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let range = range.as_range_node().unwrap();
        assert!(range.is_exclude_end());
    }

    #[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
    #[test]
    fn regex_flags_test() {
        let source = r"
/a/i
";
        let result = parse(source.as_ref());

        let node = result.node();
        let regex = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let regex = regex.as_regular_expression_node().unwrap();
        assert!(regex.is_ignore_case());
        assert!(!regex.is_extended());
        assert!(!regex.is_multi_line());
        assert!(!regex.is_euc_jp());
        assert!(!regex.is_ascii_8bit());
        assert!(!regex.is_windows_31j());
        assert!(!regex.is_utf_8());
        assert!(!regex.is_once());

        let source = r"
/a/x
";
        let result = parse(source.as_ref());

        let node = result.node();
        let regex = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let regex = regex.as_regular_expression_node().unwrap();
        assert!(!regex.is_ignore_case());
        assert!(regex.is_extended());
        assert!(!regex.is_multi_line());
        assert!(!regex.is_euc_jp());
        assert!(!regex.is_ascii_8bit());
        assert!(!regex.is_windows_31j());
        assert!(!regex.is_utf_8());
        assert!(!regex.is_once());

        let source = r"
/a/m
";
        let result = parse(source.as_ref());

        let node = result.node();
        let regex = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let regex = regex.as_regular_expression_node().unwrap();
        assert!(!regex.is_ignore_case());
        assert!(!regex.is_extended());
        assert!(regex.is_multi_line());
        assert!(!regex.is_euc_jp());
        assert!(!regex.is_ascii_8bit());
        assert!(!regex.is_windows_31j());
        assert!(!regex.is_utf_8());
        assert!(!regex.is_once());

        let source = r"
/a/e
";
        let result = parse(source.as_ref());

        let node = result.node();
        let regex = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let regex = regex.as_regular_expression_node().unwrap();
        assert!(!regex.is_ignore_case());
        assert!(!regex.is_extended());
        assert!(!regex.is_multi_line());
        assert!(regex.is_euc_jp());
        assert!(!regex.is_ascii_8bit());
        assert!(!regex.is_windows_31j());
        assert!(!regex.is_utf_8());
        assert!(!regex.is_once());

        let source = r"
/a/n
";
        let result = parse(source.as_ref());

        let node = result.node();
        let regex = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let regex = regex.as_regular_expression_node().unwrap();
        assert!(!regex.is_ignore_case());
        assert!(!regex.is_extended());
        assert!(!regex.is_multi_line());
        assert!(!regex.is_euc_jp());
        assert!(regex.is_ascii_8bit());
        assert!(!regex.is_windows_31j());
        assert!(!regex.is_utf_8());
        assert!(!regex.is_once());

        let source = r"
/a/s
";
        let result = parse(source.as_ref());

        let node = result.node();
        let regex = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let regex = regex.as_regular_expression_node().unwrap();
        assert!(!regex.is_ignore_case());
        assert!(!regex.is_extended());
        assert!(!regex.is_multi_line());
        assert!(!regex.is_euc_jp());
        assert!(!regex.is_ascii_8bit());
        assert!(regex.is_windows_31j());
        assert!(!regex.is_utf_8());
        assert!(!regex.is_once());

        let source = r"
/a/u
";
        let result = parse(source.as_ref());

        let node = result.node();
        let regex = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let regex = regex.as_regular_expression_node().unwrap();
        assert!(!regex.is_ignore_case());
        assert!(!regex.is_extended());
        assert!(!regex.is_multi_line());
        assert!(!regex.is_euc_jp());
        assert!(!regex.is_ascii_8bit());
        assert!(!regex.is_windows_31j());
        assert!(regex.is_utf_8());
        assert!(!regex.is_once());

        let source = r"
/a/o
";
        let result = parse(source.as_ref());

        let node = result.node();
        let regex = node.as_program_node().unwrap().statements().body().iter().next().unwrap();
        let regex = regex.as_regular_expression_node().unwrap();
        assert!(!regex.is_ignore_case());
        assert!(!regex.is_extended());
        assert!(!regex.is_multi_line());
        assert!(!regex.is_euc_jp());
        assert!(!regex.is_ascii_8bit());
        assert!(!regex.is_windows_31j());
        assert!(!regex.is_utf_8());
        assert!(regex.is_once());
    }

    #[test]
    fn visitor_traversal_test() {
        use crate::{Node, Visit};

        #[derive(Default)]
        struct NodeCounts {
            pre_parent: usize,
            post_parent: usize,
            pre_leaf: usize,
            post_leaf: usize,
        }

        #[derive(Default)]
        struct CountingVisitor {
            counts: NodeCounts,
        }

        impl Visit<'_> for CountingVisitor {
            fn visit_branch_node_enter(&mut self, _node: Node<'_>) {
                self.counts.pre_parent += 1;
            }

            fn visit_branch_node_leave(&mut self) {
                self.counts.post_parent += 1;
            }

            fn visit_leaf_node_enter(&mut self, _node: Node<'_>) {
                self.counts.pre_leaf += 1;
            }

            fn visit_leaf_node_leave(&mut self) {
                self.counts.post_leaf += 1;
            }
        }

        let source = r"
module Example
  x = call_func(3, 4)
  y = x.call_func 5, 6
end
";
        let result = parse(source.as_ref());
        let node = result.node();
        let mut visitor = CountingVisitor::default();
        visitor.visit(&node);

        assert_eq!(7, visitor.counts.pre_parent);
        assert_eq!(7, visitor.counts.post_parent);
        assert_eq!(6, visitor.counts.pre_leaf);
        assert_eq!(6, visitor.counts.post_leaf);
    }

    #[test]
    fn visitor_lifetime_test() {
        use crate::{Node, Visit};

        #[derive(Default)]
        struct StackingNodeVisitor<'a> {
            stack: Vec>,
            max_depth: usize,
        }

        impl<'pr> Visit<'pr> for StackingNodeVisitor<'pr> {
            fn visit_branch_node_enter(&mut self, node: Node<'pr>) {
                self.stack.push(node);
            }

            fn visit_branch_node_leave(&mut self) {
                self.stack.pop();
            }

            fn visit_leaf_node_leave(&mut self) {
                self.max_depth = self.max_depth.max(self.stack.len());
            }
        }

        let source = r"
module Example
  x = call_func(3, 4)
  y = x.call_func 5, 6
end
";
        let result = parse(source.as_ref());
        let node = result.node();
        let mut visitor = StackingNodeVisitor::default();
        visitor.visit(&node);

        assert_eq!(0, visitor.stack.len());
        assert_eq!(5, visitor.max_depth);
    }

    #[test]
    fn integer_value_test() {
        let result = parse("0xA".as_ref());
        let integer = result.node().as_program_node().unwrap().statements().body().iter().next().unwrap().as_integer_node().unwrap().value();
        let value: i32 = integer.try_into().unwrap();

        assert_eq!(value, 10);
    }

    #[test]
    fn integer_small_value_to_u32_digits_test() {
        let result = parse("0xA".as_ref());
        let integer = result.node().as_program_node().unwrap().statements().body().iter().next().unwrap().as_integer_node().unwrap().value();
        let (negative, digits) = integer.to_u32_digits();

        assert!(!negative);
        assert_eq!(digits, &[10]);
    }

    #[test]
    fn integer_large_value_to_u32_digits_test() {
        let result = parse("0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".as_ref());
        let integer = result.node().as_program_node().unwrap().statements().body().iter().next().unwrap().as_integer_node().unwrap().value();
        let (negative, digits) = integer.to_u32_digits();

        assert!(!negative);
        assert_eq!(digits, &[4_294_967_295, 4_294_967_295, 4_294_967_295, 2_147_483_647]);
    }

    #[test]
    fn float_value_test() {
        let result = parse("1.0".as_ref());
        let value: f64 = result.node().as_program_node().unwrap().statements().body().iter().next().unwrap().as_float_node().unwrap().value();

        assert!((value - 1.0).abs() < f64::EPSILON);
    }

    #[test]
    fn regex_value_test() {
        let result = parse(b"//");
        let node = result.node().as_program_node().unwrap().statements().body().iter().next().unwrap().as_regular_expression_node().unwrap();
        assert_eq!(node.unescaped(), b"");
    }

    #[test]
    fn node_field_lifetime_test() {
        // The code below wouldn't typecheck prior to https://github.com/ruby/prism/pull/2519,
        // but we need to stop clippy from complaining about it.
        #![allow(clippy::needless_pass_by_value)]

        use crate::Node;

        #[derive(Default)]
        struct Extract<'pr> {
            scopes: Vec>,
        }

        impl<'pr> Extract<'pr> {
            fn push_scope(&mut self, path: Node<'pr>) {
                if let Some(cread) = path.as_constant_read_node() {
                    self.scopes.push(cread.name());
                } else if let Some(cpath) = path.as_constant_path_node() {
                    if let Some(parent) = cpath.parent() {
                        self.push_scope(parent);
                    }
                    self.scopes.push(cpath.name().unwrap());
                } else {
                    panic!("Wrong node kind!");
                }
            }
        }

        let source = "Some::Random::Constant";
        let result = parse(source.as_ref());
        let node = result.node();
        let mut extractor = Extract::default();
        extractor.push_scope(node.as_program_node().unwrap().statements().body().iter().next().unwrap());
        assert_eq!(3, extractor.scopes.len());
    }

    #[test]
    fn malformed_shebang() {
        let source = "#!\x00";
        let result = parse(source.as_ref());
        assert!(result.errors().next().is_none());
        assert!(result.warnings().next().is_none());
    }
}
prism-1.5.1/sample/000077500000000000000000000000001506127434000141335ustar00rootroot00000000000000prism-1.5.1/sample/prism/000077500000000000000000000000001506127434000152655ustar00rootroot00000000000000prism-1.5.1/sample/prism/find_calls.rb000066400000000000000000000055251506127434000177170ustar00rootroot00000000000000# This script finds calls to a specific method with a certain keyword parameter
# within a given source file.

require "prism"
require "pp"

# For deprecation or refactoring purposes, it's often useful to find all of the
# places that call a specific method with a specific k  eyword parameter. This is
# easily accomplished with a visitor such as this one.
class QuxParameterVisitor < Prism::Visitor
  def initialize(calls)
    @calls = calls
  end

  def visit_call_node(node)
    @calls << node if qux?(node)
    super
  end

  private

  def qux?(node)
    # All nodes implement pattern matching, so you can use the `in` operator to
    # pull out all of their individual fields. As you can see by this extensive
    # pattern match, this is quite a powerful feature.
    node in {
      # This checks that the receiver is the constant Qux or the constant path
      # ::Qux. We are assuming relative constants are fine in this case.
      receiver: (
        Prism::ConstantReadNode[name: :Qux] |
        Prism::ConstantPathNode[parent: nil, name: :Qux]
      ),
      # This checks that the name of the method is qux. We purposefully are not
      # checking the call operator (., ::, or &.) because we want all of them.
      # In other ASTs, this would be multiple node types, but prism combines
      # them all into one for convenience.
      name: :qux,
      arguments: Prism::ArgumentsNode[
        # Here we're going to use the "find" pattern to find the keyword hash
        # node that has the correct key.
        arguments: [
          *,
          Prism::KeywordHashNode[
            # Here we'll use another "find" pattern to find the key that we are
            # specifically looking for.
            elements: [
              *,
              # Finally, we can assert against the key itself. Note that we are
              # not looking at the value of hash pair, because we are only
              # specifically looking for a key.
              Prism::AssocNode[key: Prism::SymbolNode[unescaped: "qux"]],
              *
            ]
          ],
          *
        ]
      ]
    }
  end
end

calls = []
Prism.parse_stream(DATA).value.accept(QuxParameterVisitor.new(calls))

calls.each do |call|
  print "CallNode "
  puts PP.pp(call.location, +"")
  print "  "
  puts call.slice
end

# =>
# CallNode (5,6)-(5,29)
#   Qux.qux(222, qux: true)
# CallNode (9,6)-(9,30)
#   Qux&.qux(333, qux: true)
# CallNode (20,6)-(20,51)
#   Qux::qux(888, qux: ::Qux.qux(999, qux: true))
# CallNode (20,25)-(20,50)
#   ::Qux.qux(999, qux: true)

__END__
module Foo
  class Bar
    def baz1
      Qux.qux(111)
      Qux.qux(222, qux: true)
    end

    def baz2
      Qux&.qux(333, qux: true)
      Qux&.qux(444)
    end

    def baz3
      qux(555, qux: false)
      666.qux(666)
    end

    def baz4
      Qux::qux(777)
      Qux::qux(888, qux: ::Qux.qux(999, qux: true))
    end
  end
end
prism-1.5.1/sample/prism/find_comments.rb000066400000000000000000000065421506127434000204460ustar00rootroot00000000000000# This script finds all of the comments within a given source file for a method.

require "prism"

class FindMethodComments < Prism::Visitor
  def initialize(target, comments, nesting = [])
    @target = target
    @comments = comments
    @nesting = nesting
  end

  # These visit methods are specific to each class. Defining a visitor allows
  # you to group functionality that applies to all node types into a single
  # class. You can find which method corresponds to which node type by looking
  # at the class name, calling #type on the node, or by looking at the #accept
  # method definition on the node.
  def visit_module_node(node)
    visitor = FindMethodComments.new(@target, @comments, [*@nesting, node.name])
    node.compact_child_nodes.each { |child| child.accept(visitor) }
  end

  def visit_class_node(node)
    # We could keep track of an internal state where we push the class name here
    # and then pop it after the visit is complete. However, it is often simpler
    # and cleaner to generate a new visitor instance when the state changes,
    # because then the state is immutable and it's easier to reason about. This
    # also provides for more debugging opportunity in the initializer.
    visitor = FindMethodComments.new(@target, @comments, [*@nesting, node.name])
    node.compact_child_nodes.each { |child| child.accept(visitor) }
  end

  def visit_def_node(node)
    if [*@nesting, node.name] == @target
      # Comments are always attached to locations (either inner locations on a
      # node like the location of a keyword or the location on the node itself).
      # Nodes are considered either "leading" or "trailing", which means that
      # they occur before or after the location, respectively. In this case of
      # documentation, we only want to consider leading comments. You can also
      # fetch all of the comments on a location with #comments.
      @comments.concat(node.location.leading_comments)
    else
      super
    end
  end
end

# Most of the time, the concept of "finding" something in the AST can be
# accomplished either with a queue or with a visitor. In this case we will use a
# visitor, but a queue would work just as well.
def find_comments(result, path)
  target = path.split(/::|#/).map(&:to_sym)
  comments = []

  result.value.accept(FindMethodComments.new(target, comments))
  comments
end

result = Prism.parse_stream(DATA)
result.attach_comments!

find_comments(result, "Foo#foo").each do |comment|
  puts comment.inspect
  puts comment.slice
end

# =>
# #>
# # This is the documentation
# #>
# # for the foo method.

find_comments(result, "Foo::Bar#bar").each do |comment|
  puts comment.inspect
  puts comment.slice
end

# =>
# #>
# # This is documentation
# #>
# # for the bar method.

__END__
# This is the documentation
# for the Foo module.
module Foo
  # This is documentation
  # for the Bar class.
  class Bar
    # This is documentation
    # for the bar method.
    def bar
    end
  end

  # This is the documentation
  # for the foo method.
  def foo
  end
end
prism-1.5.1/sample/prism/locate_nodes.rb000066400000000000000000000055371506127434000202630ustar00rootroot00000000000000# This script locates a set of nodes determined by a line and column (in bytes).

require "prism"
require "pp"

# This method determines if the given location covers the given line and column.
# It's important to note that columns (and offsets) in prism are always in
# bytes. This is because prism supports all 90 source encodings that Ruby
# supports. You can always retrieve the column (or offset) of a location in
# other units with other provided APIs, like #start_character_column or
# #start_code_units_column.
def covers?(location, line:, column:)
  start_line = location.start_line
  end_line = location.end_line

  if start_line == end_line
    # If the location only spans one line, then we only check if the line
    # matches and that the column is covered by the column range.
    line == start_line && (location.start_column...location.end_column).cover?(column)
  else
    # Otherwise, we check that it is on the start line and the column is greater
    # than or equal to the start column, or that it is on the end line and the
    # column is less than the end column, or that it is between the start and
    # end lines.
    (line == start_line && column >= location.start_column) ||
      (line == end_line && column < location.end_column) ||
      (line > start_line && line < end_line)
  end
end

# This method descends down into the AST whose root is `node` and returns the
# array of all of the nodes that cover the given line and column.
def locate(node, line:, column:)
  queue = [node]
  result = []

  # We could use a recursive method here instead if we wanted, but it's
  # important to note that that will not work for ASTs that are nested deeply
  # enough to cause a stack overflow.
  while (node = queue.shift)
    result << node

    # Nodes have `child_nodes` and `compact_child_nodes`. `child_nodes` have
    # consistent indices but include `nil` for optional fields that are not
    # present, whereas `compact_child_nodes` has inconsistent indices but does
    # not include `nil` for optional fields that are not present.
    node.compact_child_nodes.find do |child|
      queue << child if covers?(child.location, line: line, column: column)
    end
  end

  result
end

result = Prism.parse_stream(DATA)
locate(result.value, line: 4, column: 14).each_with_index do |node, index|
  print " " * index
  print node.class.name.split("::", 2).last
  print " "
  puts PP.pp(node.location, +"")
end

# =>
# ProgramNode (1,0)-(7,3)
#  StatementsNode (1,0)-(7,3)
#   ModuleNode (1,0)-(7,3)
#    StatementsNode (2,2)-(6,5)
#     ClassNode (2,2)-(6,5)
#      StatementsNode (3,4)-(5,7)
#       DefNode (3,4)-(5,7)
#        StatementsNode (4,6)-(4,21)
#         CallNode (4,6)-(4,21)
#          CallNode (4,6)-(4,15)
#           ArgumentsNode (4,12)-(4,15)
#            IntegerNode (4,12)-(4,15)

__END__
module Foo
  class Bar
    def baz
      111 + 222 + 333
    end
  end
end
prism-1.5.1/sample/prism/make_tags.rb000066400000000000000000000216361506127434000175550ustar00rootroot00000000000000# This script generates a tags file using Prism to parse the Ruby files.

require "prism"

# This visitor is responsible for visiting the nodes in the AST and generating
# the appropriate tags. The tags are stored in the entries array as strings.
class TagsVisitor < Prism::Visitor
  # This represents an entry in the tags file, which is a tab-separated line. It
  # houses the logic for how an entry is constructed.
  class Entry
    attr_reader :parts

    def initialize(name, filepath, pattern, type)
      @parts = [name, filepath, pattern, type]
    end

    def attribute(key, value)
      parts << "#{key}:#{value}"
    end

    def attribute_class(nesting, names)
      return if nesting.empty? && names.length == 1
      attribute("class", [*nesting, names].flatten.tap(&:pop).join("."))
    end

    def attribute_inherits(names)
      attribute("inherits", names.join(".")) if names
    end

    def to_line
      parts.join("\t")
    end
  end

  private_constant :Entry

  attr_reader :entries, :filepath, :lines, :nesting, :singleton

  # Initialize the visitor with the given parameters. The first three parameters
  # are constant throughout the visit, while the last two are controlled by the
  # visitor as it traverses the AST. These are treated as immutable by virtue of
  # the visit methods constructing new visitors when they need to change.
  def initialize(entries, filepath, lines, nesting = [], singleton = false)
    @entries = entries
    @filepath = filepath
    @lines = lines
    @nesting = nesting
    @singleton = singleton
  end

  # Visit a method alias node and generate the appropriate tags.
  #
  #     alias m2 m1
  #
  def visit_alias_method_node(node)
    enter(node.new_name.unescaped.to_sym, node, "a") do |entry|
      entry.attribute_class(nesting, [nil])
    end

    super
  end

  # Visit a method call to attr_reader, attr_writer, or attr_accessor without a
  # receiver and generate the appropriate tags. Note that this ignores the fact
  # that these methods could be overridden, which is a limitation of this
  # script.
  #
  #     attr_accessor :m1
  #
  def visit_call_node(node)
    if !node.receiver && %i[attr_reader attr_writer attr_accessor].include?(name = node.name)
      (node.arguments&.arguments || []).grep(Prism::SymbolNode).each do |argument|
        if name != :attr_writer
          enter(:"#{argument.unescaped}", argument, singleton ? "F" : "f") do |entry|
            entry.attribute_class(nesting, [nil])
          end
        end

        if name != :attr_reader
          enter(:"#{argument.unescaped}=", argument, singleton ? "F" : "f") do |entry|
            entry.attribute_class(nesting, [nil])
          end
        end
      end
    end

    super
  end

  # Visit a class node and generate the appropriate tags.
  #
  #     class C1
  #     end
  #
  def visit_class_node(node)
    if (names = names_for(node.constant_path))
      enter(names.last, node, "c") do |entry|
        entry.attribute_class(nesting, names)
        entry.attribute_inherits(names_for(node.superclass))
      end

      node.body&.accept(copy_visitor([*nesting, names], singleton))
    end
  end

  # Visit a constant path write node and generate the appropriate tags.
  #
  #     C1::C2 = 1
  #
  def visit_constant_path_write_node(node)
    if (names = names_for(node.target))
      enter(names.last, node, "C") do |entry|
        entry.attribute_class(nesting, names)
      end
    end

    super
  end

  # Visit a constant write node and generate the appropriate tags.
  #
  #     C1 = 1
  #
  def visit_constant_write_node(node)
    enter(node.name, node, "C") do |entry|
      entry.attribute_class(nesting, [nil])
    end

    super
  end

  # Visit a method definition node and generate the appropriate tags.
  #
  #     def m1; end
  #
  def visit_def_node(node)
    enter(node.name, node, (node.receiver || singleton) ? "F" : "f") do |entry|
      entry.attribute_class(nesting, [nil])
    end

    super
  end

  # Visit a module node and generate the appropriate tags.
  #
  #     module M1
  #     end
  #
  def visit_module_node(node)
    if (names = names_for(node.constant_path))
      enter(names.last, node, "m") do |entry|
        entry.attribute_class(nesting, names)
      end

      node.body&.accept(copy_visitor([*nesting, names], singleton))
    end
  end

  # Visit a singleton class node and generate the appropriate tags.
  #
  #     class << self
  #     end
  #
  def visit_singleton_class_node(node)
    case node.expression
    when Prism::SelfNode
      node.body&.accept(copy_visitor(nesting, true))
    when Prism::ConstantReadNode, Prism::ConstantPathNode
      if (names = names_for(node.expression))
        node.body&.accept(copy_visitor([*nesting, names], true))
      end
    else
      node.body&.accept(copy_visitor([*nesting, nil], true))
    end
  end

  private

  # Generate a new visitor with the given dynamic options. The static options
  # are copied over automatically.
  def copy_visitor(nesting, singleton)
    TagsVisitor.new(entries, filepath, lines, nesting, singleton)
  end

  # Generate a new entry for the given name, node, and type and add it into the
  # list of entries. The block is used to add additional attributes to the
  # entry.
  def enter(name, node, type)
    line = lines[node.location.start_line - 1].chomp
    pattern = "/^#{line.gsub("\\", "\\\\\\\\").gsub("/", "\\/")}$/;\""

    entry = Entry.new(name, filepath, pattern, type)
    yield entry

    entries << entry.to_line
  end

  # Retrieve the names for the given node. This is used to construct the class
  # attribute for the tags.
  def names_for(node)
    case node
    when Prism::ConstantPathNode
      names = names_for(node.parent)
      return unless names

      names << node.name
    when Prism::ConstantReadNode
      [node.name]
    when Prism::SelfNode
      [:self]
    else
      # dynamic
    end
  end
end

# Parse the Ruby file and visit all of the nodes in the resulting AST. Once all
# of the nodes have been visited, the entries array should be populated with the
# tags.
result = Prism.parse_stream(DATA)
result.value.accept(TagsVisitor.new(entries = [], __FILE__, result.source.lines))

# Print the tags to STDOUT.
puts "!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;\" to lines/"
puts "!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/"
puts entries.sort

# =>
# !_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
# !_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
# C1	sample/prism/make_tags.rb	/^    class C1$/;"	c	class:M1.M2
# C2	sample/prism/make_tags.rb	/^      class C2 < Object$/;"	c	class:M1.M2.C1	inherits:Object
# C6	sample/prism/make_tags.rb	/^  C6 = 1$/;"	C	class:M1
# C7	sample/prism/make_tags.rb	/^  C7 = 2$/;"	C	class:M1
# C9	sample/prism/make_tags.rb	/^  C8::C9 = 3$/;"	C	class:M1.C8
# M1	sample/prism/make_tags.rb	/^module M1$/;"	m
# M2	sample/prism/make_tags.rb	/^  module M2$/;"	m	class:M1
# M4	sample/prism/make_tags.rb	/^  module M3::M4$/;"	m	class:M1.M3
# M5	sample/prism/make_tags.rb	/^  module self::M5$/;"	m	class:M1.self
# m1	sample/prism/make_tags.rb	/^        def m1; end$/;"	f	class:M1.M2.C1.C2
# m10	sample/prism/make_tags.rb	/^    attr_accessor :m10, :m11$/;"	f	class:M1.M3.M4
# m10=	sample/prism/make_tags.rb	/^    attr_accessor :m10, :m11$/;"	f	class:M1.M3.M4
# m11	sample/prism/make_tags.rb	/^    attr_accessor :m10, :m11$/;"	f	class:M1.M3.M4
# m11=	sample/prism/make_tags.rb	/^    attr_accessor :m10, :m11$/;"	f	class:M1.M3.M4
# m12	sample/prism/make_tags.rb	/^    attr_reader :m12, :m13, :m14$/;"	f	class:M1.M3.M4
# m13	sample/prism/make_tags.rb	/^    attr_reader :m12, :m13, :m14$/;"	f	class:M1.M3.M4
# m14	sample/prism/make_tags.rb	/^    attr_reader :m12, :m13, :m14$/;"	f	class:M1.M3.M4
# m15=	sample/prism/make_tags.rb	/^    attr_writer :m15$/;"	f	class:M1.M3.M4
# m2	sample/prism/make_tags.rb	/^        def m2; end$/;"	f	class:M1.M2.C1.C2
# m3	sample/prism/make_tags.rb	/^        alias m3 m1$/;"	a	class:M1.M2.C1.C2
# m4	sample/prism/make_tags.rb	/^        alias :m4 :m2$/;"	a	class:M1.M2.C1.C2
# m5	sample/prism/make_tags.rb	/^        def self.m5; end$/;"	F	class:M1.M2.C1.C2
# m6	sample/prism/make_tags.rb	/^          def m6; end$/;"	F	class:M1.M2.C1.C2
# m7	sample/prism/make_tags.rb	/^          def m7; end$/;"	F	class:M1.M2.C1.C2.C3
# m8	sample/prism/make_tags.rb	/^          def m8; end$/;"	F	class:M1.M2.C1.C2.C4.C5
# m9	sample/prism/make_tags.rb	/^          def m9; end$/;"	F	class:M1.M2.C1.C2.

__END__
module M1
  module M2
    class C1
      class C2 < Object
        def m1; end
        def m2; end

        alias m3 m1
        alias :m4 :m2

        def self.m5; end

        class << self
          def m6; end
        end

        class << C3
          def m7; end
        end

        class << C4::C5
          def m8; end
        end

        class << c
          def m9; end
        end
      end
    end
  end

  module M3::M4
    attr_accessor :m10, :m11
    attr_reader :m12, :m13, :m14
    attr_writer :m15
  end

  module self::M5
  end

  C6 = 1
  C7 = 2
  C8::C9 = 3
end
prism-1.5.1/sample/prism/multiplex_constants.rb000066400000000000000000000101401506127434000217250ustar00rootroot00000000000000# This script indexes the classes and modules within a set of files using the
# saved source functionality.

require "prism"
require "etc"
require "tempfile"

module Indexer
  # A class that implements the #enter functionality so that it can be passed to
  # the various save* APIs. This effectively bundles up all of the node_id and
  # field_name pairs so that they can be written back to the parent process.
  class Repository
    attr_reader :scope, :entries

    def initialize
      @scope = []
      @entries = []
    end

    def with(next_scope)
      previous_scope = scope
      @scope = scope + next_scope
      yield
      @scope = previous_scope
    end

    def empty?
      entries.empty?
    end

    def enter(node_id, field_name)
      entries << [scope.join("::"), node_id, field_name]
    end
  end

  # Visit the classes and modules in the AST and save their locations into the
  # repository.
  class Visitor < Prism::Visitor
    attr_reader :repository

    def initialize(repository)
      @repository = repository
    end

    def visit_class_node(node)
      repository.with(node.constant_path.full_name_parts) do
        node.constant_path.save_location(repository)
        visit(node.body)
      end
    end

    def visit_module_node(node)
      repository.with(node.constant_path.full_name_parts) do
        node.constant_path.save_location(repository)
        visit(node.body)
      end
    end
  end

  # Index the classes and modules within a file. If there are any entries,
  # return them as a serialized string to the parent process.
  def self.index(filepath)
    repository = Repository.new
    Prism.parse_file(filepath).value.accept(Visitor.new(repository))
    "#{filepath}|#{repository.entries.join("|")}" unless repository.empty?
  end
end

def index_glob(glob, count = Etc.nprocessors - 1)
  process_ids = []
  filepath_writers = []
  index_reader, index_writer = IO.pipe

  # For each number in count, fork off a worker that has access to two pipes.
  # The first pipe is the index_writer, to which it writes all of the results of
  # indexing the various files. The second pipe is the filepath_reader, from
  # which it reads the filepaths that it needs to index.
  count.times do
    filepath_reader, filepath_writer = IO.pipe

    process_ids << fork do
      filepath_writer.close
      index_reader.close

      while (filepath = filepath_reader.gets(chomp: true))
        results = Indexer.index(filepath)
        index_writer.puts(results) if results
      end
    end

    filepath_reader.close
    filepath_writers << filepath_writer
  end

  index_writer.close

  # In a separate thread, write all of the filepaths to the various worker
  # processes. This is done in a separate threads since puts will eventually
  # block when each of the pipe buffers fills up. We write in a round-robin
  # fashion to the various workers. This could be improved using a work-stealing
  # algorithm, but is fine if you don't end up having a ton of variety in the
  # size of your files.
  writer_thread =
    Thread.new do
      Dir[glob].each_with_index do |filepath, index|
        filepath_writers[index % count].puts(filepath)
      end
    end

  index = Hash.new { |hash, key| hash[key] = [] }

  # In a separate thread, read all of the results from the various worker
  # processes and store them in the index. This is done in a separate thread so
  # that reads and writes can be interleaved. This is important so that the
  # index pipe doesn't fill up and block the writer.
  reader_thread =
    Thread.new do
      while (line = index_reader.gets(chomp: true))
        filepath, *entries = line.split("|")
        repository = Prism::Relocation.filepath(filepath).filepath.lines.code_unit_columns(Encoding::UTF_16LE).leading_comments

        entries.each_slice(3) do |(name, node_id, field_name)|
          index[name] << repository.enter(Integer(node_id), field_name.to_sym)
        end
      end
    end

  writer_thread.join
  filepath_writers.each(&:close)

  reader_thread.join
  index_reader.close

  process_ids.each { |process_id| Process.wait(process_id) }
  index
end

index_glob(File.expand_path("../../lib/**/*.rb", __dir__))
prism-1.5.1/sample/prism/relocate_constants.rb000066400000000000000000000032331506127434000215050ustar00rootroot00000000000000# This script finds the declaration of all classes and modules and stores them
# in a hash for an in-memory database of constants.

require "prism"

class RelocationVisitor < Prism::Visitor
  attr_reader :index, :repository, :scope

  def initialize(index, repository, scope = [])
    @index = index
    @repository = repository
    @scope = scope
  end

  def visit_class_node(node)
    next_scope = scope + node.constant_path.full_name_parts
    index[next_scope.join("::")] << node.constant_path.save(repository)
    node.body&.accept(RelocationVisitor.new(index, repository, next_scope))
  end

  def visit_module_node(node)
    next_scope = scope + node.constant_path.full_name_parts
    index[next_scope.join("::")] << node.constant_path.save(repository)
    node.body&.accept(RelocationVisitor.new(index, repository, next_scope))
  end
end

# Create an index that will store a mapping between the names of constants to a
# list of the locations where they are declared or re-opened.
index = Hash.new { |hash, key| hash[key] = [] }

# Loop through every file in the lib directory of this repository and parse them
# with Prism. Then visit them using the RelocateVisitor to store their
# repository entries in the index.
Dir[File.expand_path("../../lib/**/*.rb", __dir__)].each do |filepath|
  repository = Prism::Relocation.filepath(filepath).filepath.lines.code_unit_columns(Encoding::UTF_16LE)
  Prism.parse_file(filepath).value.accept(RelocationVisitor.new(index, repository))
end

puts index["Prism::ParametersNode"].map { |entry| "#{entry.filepath}:#{entry.start_line}:#{entry.start_code_units_column}" }
# =>
# prism/lib/prism/node.rb:13889:8
# prism/lib/prism/node_ext.rb:267:8
prism-1.5.1/sample/prism/visit_nodes.rb000066400000000000000000000036001506127434000201370ustar00rootroot00000000000000# This script visits all of the nodes of a specific type within a given source
# file. It uses the visitor class to traverse the AST.

require "prism"
require "pp"

class CaseInsensitiveRegularExpressionVisitor < Prism::Visitor
  def initialize(regexps)
    @regexps = regexps
  end

  # As the visitor is walking the tree, this method will only be called when it
  # encounters a regular expression node. We can then call any regular
  # expression -specific APIs. In this case, we are only interested in the
  # regular expressions that are case-insensitive, which we can retrieve with
  # the #ignore_case? method.
  def visit_regular_expression_node(node)
    @regexps << node if node.ignore_case?
    super
  end

  def visit_interpolated_regular_expression_node(node)
    @regexps << node if node.ignore_case?

    # The default behavior of the visitor is to continue visiting the children
    # of the node. Because Ruby is so dynamic, it's actually possible for
    # another regular expression to be interpolated in statements contained
    # within the #{} contained in this interpolated regular expression node. By
    # calling `super`, we ensure the visitor will continue. Failing to call
    # `super` will cause the visitor to stop the traversal of the tree, which
    # can also be useful in some cases.
    super
  end
end

result = Prism.parse_stream(DATA)
regexps = []

result.value.accept(CaseInsensitiveRegularExpressionVisitor.new(regexps))
regexps.each do |node|
  print node.class.name.split("::", 2).last
  print " "
  puts PP.pp(node.location, +"")

  if node.is_a?(Prism::RegularExpressionNode)
    print "  "
    p node.unescaped
  end
end

# =>
# InterpolatedRegularExpressionNode (3,9)-(3,47)
# RegularExpressionNode (3,16)-(3,22)
#   "bar"
# RegularExpressionNode (4,9)-(4,15)
#   "bar"

__END__
class Foo
  REG1 = /foo/
  REG2 = /foo #{/bar/i =~ "" ? "bar" : "baz"}/i
  REG3 = /bar/i
end
prism-1.5.1/sig/000077500000000000000000000000001506127434000134345ustar00rootroot00000000000000prism-1.5.1/sig/_shims/000077500000000000000000000000001506127434000147165ustar00rootroot00000000000000prism-1.5.1/sig/_shims/module.rbs000066400000000000000000000007351506127434000167200ustar00rootroot00000000000000class Module < Object
  # "private" and "protected" accept an array of symbols.
  # Like when you do `private attr_reader :foo, :bar`
  def private: (Array[Symbol]) -> Array[Symbol]
             | ...
  def protected: (Array[Symbol]) -> Array[Symbol]
             | ...

  # "define_method" accepts a block that's evaluated within
  # the context of the instance:
  def define_method: (interned symbol) { () [self: instance] -> untyped } -> Symbol
                   | ...
end
prism-1.5.1/sig/_shims/string.rbs000066400000000000000000000001411506127434000167300ustar00rootroot00000000000000class String
  def start_with?: (*(string | Regexp) prefixes) -> bool
                 | ...
end
prism-1.5.1/sig/prism/000077500000000000000000000000001506127434000145665ustar00rootroot00000000000000prism-1.5.1/sig/prism/_private/000077500000000000000000000000001506127434000163775ustar00rootroot00000000000000prism-1.5.1/sig/prism/_private/node.rbs000066400000000000000000000002221506127434000200300ustar00rootroot00000000000000module Prism
  class Node
    @newline_flag: bool

    def newline_flag?: () -> bool
    def newline_flag!: (Array[bool] lines) -> void
  end
end
prism-1.5.1/sig/prism/_private/node_ext.rbs000066400000000000000000000005111506127434000207110ustar00rootroot00000000000000module Prism
  module RegularExpressionOptions: InterpolatedMatchLastLineNode, InterpolatedRegularExpressionNode, MatchLastLineNode, RegularExpressionNode
    def options: () -> Integer
  end

  module HeredocQuery: InterpolatedStringNode, InterpolatedXStringNode, StringNode, XStringNode
    def heredoc?: () -> bool?
  end
end
prism-1.5.1/sig/prism/_private/pack.rbs000066400000000000000000000033521506127434000200300ustar00rootroot00000000000000module Prism
  module Pack
    SPACE: :SPACE
    COMMENT: :COMMENT
    INTEGER: :INTEGER
    UTF8: :UTF8
    BER: :BER
    FLOAT: :FLOAT
    STRING_SPACE_PADDED: :STRING_SPACE_PADDED
    STRING_NULL_PADDED: :STRING_NULL_PADDED
    STRING_NULL_TERMINATED: :STRING_NULL_TERMINATED
    STRING_MSB: :STRING_MSB
    STRING_LSB: :STRING_LSB
    STRING_HEX_HIGH: :STRING_HEX_HIGH
    STRING_HEX_LOW: :STRING_HEX_LOW
    STRING_UU: :STRING_UU
    STRING_MIME: :STRING_MIME
    STRING_BASE64: :STRING_BASE64
    STRING_FIXED: :STRING_FIXED
    STRING_POINTER: :STRING_POINTER
    MOVE: :MOVE
    BACK: :BACK
    NULL: :NULL
    UNSIGNED: :UNSIGNED
    SIGNED: :SIGNED
    SIGNED_NA: :SIGNED_NA
    AGNOSTIC_ENDIAN: :AGNOSTIC_ENDIAN
    LITTLE_ENDIAN: :LITTLE_ENDIAN
    BIG_ENDIAN: :BIG_ENDIAN
    NATIVE_ENDIAN: :NATIVE_ENDIAN
    ENDIAN_NA: :ENDIAN_NA
    SIZE_SHORT: :SIZE_SHORT
    SIZE_INT: :SIZE_INT
    SIZE_LONG: :SIZE_LONG
    SIZE_LONG_LONG: :SIZE_LONG_LONG
    SIZE_8: :SIZE_8
    SIZE_16: :SIZE_16
    SIZE_32: :SIZE_32
    SIZE_64: :SIZE_64
    SIZE_P: :SIZE_P
    SIZE_NA: :SIZE_NA
    LENGTH_FIXED: :LENGTH_FIXED
    LENGTH_MAX: :LENGTH_MAX
    LENGTH_RELATIVE: :LENGTH_RELATIVE
    LENGTH_NA: :LENGTH_NA

    class Directive
      ENDIAN_DESCRIPTIONS: Hash[endianness, String]
      SIGNED_DESCRIPTIONS: Hash[signness, String]
      SIZE_DESCRIPTIONS: Hash[size, String]

      def initialize: (
        Symbol version,
        variant variant,
        String source,
        directive_type type,
        signness signed,
        endianness endian,
        size size,
        length_type length_type,
        Integer length
      ) -> void
    end

    class Format
      def initialize: (Array[Directive] directives, Encoding encoding) -> void
    end
  end
end
prism-1.5.1/sig/prism/_private/parse_result.rbs000066400000000000000000000023561506127434000216250ustar00rootroot00000000000000module Prism
  class Source
    private

    def find_line: (Integer) -> Integer
  end

  class CodeUnitsCache
    class UTF16Counter
      def initialize: (String source, Encoding encoding) -> void
      def count: (Integer byte_offset, Integer byte_length) -> Integer
    end

    class LengthCounter
      def initialize: (String source, Encoding encoding) -> void
      def count: (Integer byte_offset, Integer byte_length) -> Integer
    end
  end

  class Location
    private

    def source!: () -> Source
  end

  class ParseResult
    def attach_comments!: () -> void
    def mark_newlines!: () -> untyped

    class Errors
      attr_reader parse_result: ParseResult

      def initialize: (ParseResult parse_result) -> void
      def format: () -> String
    end

    class Newlines < Visitor
      @newline_marked: Array[bool]

      # Create a new Newlines visitor with the given newline offsets.
      def initialize: (Array[bool] newline_marked) -> void

      def visit_block_node: (BlockNode node) -> void
      def visit_lambda_node: (LambdaNode node) -> void
      def visit_if_node: (IfNode node) -> void
      def visit_unless_node: (UnlessNode node) -> void
      def visit_statements_node: (StatementsNode node) -> void
    end
  end
end
prism-1.5.1/sig/prism/_private/pattern.rbs000066400000000000000000000016561506127434000205740ustar00rootroot00000000000000module Prism
  class Pattern
    class CompilationError < StandardError
      def initialize: (String) -> void
    end

    @compiled: Proc?

    private

    def combine_and: (Proc, Proc) -> Proc
    def combine_or: (Proc, Proc) -> Proc
    def compile_error: (Prism::node?) -> Proc
    def compile_array_pattern_node: (ArrayPatternNode) -> Proc
    def compile_alternation_pattern_node: (AlternationPatternNode) -> Proc
    def compile_constant_path_node: (ConstantPathNode) -> Proc
    def compile_constant_read_node: (ConstantReadNode) -> Proc
    def compile_constant_name: (Prism::node, Symbol) -> Proc
    def compile_hash_pattern_node: (HashPatternNode) -> Proc
    def compile_nil_node: (NilNode) -> Proc
    def compile_regular_expression_node: (RegularExpressionNode) -> Proc
    def compile_string_node: (StringNode) -> Proc
    def compile_symbol_node: (SymbolNode) -> Proc
    def compile_node: (Prism::node?) -> Proc
  end
end
prism-1.5.1/sig/prism/_private/relocation.rbs000066400000000000000000000003551506127434000212510ustar00rootroot00000000000000module Prism
  module Relocation
    class Entry
      def reify!: (entry_values values) -> void
    end

    class Repository
      def enter: (Integer node_id, Symbol field_name) -> Entry
      def reify!: () -> void
    end
  end
end
prism-1.5.1/sig/prism/_private/string_query.rbs000066400000000000000000000002731506127434000216440ustar00rootroot00000000000000module Prism
  class StringQuery
    def self.local?: (String string) -> bool
    def self.constant?: (String string) -> bool
    def self.method_name?: (String string) -> bool
  end
end
prism-1.5.1/sig/prism/compiler.rbs000066400000000000000000000003141506127434000171060ustar00rootroot00000000000000module Prism
  class Compiler
    include _Visitor

    def visit: (Prism::node?) -> untyped
    def visit_all: (Array[Prism::node?]) -> untyped
    def visit_child_nodes: (Prism::node) -> void
  end
end
prism-1.5.1/sig/prism/dispatcher.rbs000066400000000000000000000010461506127434000174250ustar00rootroot00000000000000module Prism
  class Dispatcher < Visitor
    attr_reader listeners: Hash[Symbol, Array[untyped]]

    def initialize: () -> void
    def register: (untyped, *Symbol) -> void
    def register_public_methods: (untyped) -> void
    def dispatch: (Prism::node) -> void
    def dispatch_once: (Prism::node) -> void

    private def register_events: (untyped, Array[Symbol]) -> void

    class DispatchOnce < Visitor
      attr_reader listeners: Hash[Symbol, Array[untyped]]

      def initialize: (Hash[Symbol, Array[untyped]]) -> void
    end
  end
end
prism-1.5.1/sig/prism/dot_visitor.rbs000066400000000000000000000001601506127434000176400ustar00rootroot00000000000000module Prism
  class DotVisitor < Visitor
    def initialize: () -> void
    def to_dot: () -> String
  end
end
prism-1.5.1/sig/prism/inspect_visitor.rbs000066400000000000000000000007741506127434000205320ustar00rootroot00000000000000module Prism
  class InspectVisitor < Visitor
    class Replace
      attr_reader value: String

      def initialize: (String value) -> void
    end

    attr_reader indent: String
    attr_reader commands: Array[[String | node | Replace, String]]

    def initialize: (?String indent) -> void
    def compose: () -> String

    def self.compose: (node node) -> String

    private

    def inspect_node: (String name, node node) -> String
    def inspect_location: (Location? location) -> String
  end
end
prism-1.5.1/sig/prism/lex_compat.rbs000066400000000000000000000007411506127434000174330ustar00rootroot00000000000000module Prism
  class LexCompat
    class Result < Prism::Result
      attr_reader value: Array[[[Integer, Integer], Symbol, String, untyped]]

      def initialize: (Array[[[Integer, Integer], Symbol, String, untyped]] value, Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void  
      def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
    end
  end
end
prism-1.5.1/sig/prism/node_ext.rbs000066400000000000000000000063131506127434000171060ustar00rootroot00000000000000module Prism
  class Node
    def deprecated: (*String replacements) -> void
  end

  class InterpolatedMatchLastLineNode < Node
    def options: () -> Integer
  end

  class InterpolatedRegularExpressionNode < Node
    def options: () -> Integer
  end

  class MatchLastLineNode < Node
    def options: () -> Integer
  end

  class RegularExpressionNode < Node
    def options: () -> Integer
  end

  class InterpolatedStringNode < Node
    def heredoc?: () -> bool
  end

  class InterpolatedXStringNode < Node
    def heredoc?: () -> bool
  end

  class StringNode < Node
    def heredoc?: () -> bool
    def to_interpolated: () -> InterpolatedStringNode
  end

  class XStringNode < Node
    def heredoc?: () -> bool
    def to_interpolated: () -> InterpolatedXStringNode
  end

  class ImaginaryNode < Node
    def value: () -> Complex
  end

  class RationalNode < Node
    def value: () -> Rational
    def numeric: () -> (IntegerNode | FloatNode)
  end

  class ConstantReadNode < Node
    def full_name_parts: () -> Array[Symbol]
    def full_name: () -> String
  end

  class ConstantWriteNode < Node
    def full_name_parts: () -> Array[Symbol]
    def full_name: () -> String
  end

  class ConstantPathNode < Node
    class DynamicPartsInConstantPathError < StandardError
    end

    class MissingNodesInConstantPathError < StandardError
    end

    def full_name_parts: () -> Array[Symbol]
    def full_name: () -> String
    def child: () -> (ConstantReadNode | MissingNode)
  end

  class ConstantPathTargetNode < Node
    def full_name_parts: () -> Array[Symbol]
    def full_name: () -> String
    def child: () -> (ConstantReadNode | MissingNode)
  end

  class ConstantTargetNode < Node
    def full_name_parts: () -> Array[Symbol]
    def full_name: () -> String
  end

  class ParametersNode < Node
    def signature: () -> Array[[Symbol, Symbol] | [Symbol]]
  end

  class CallNode < Node
    def full_message_loc: () -> Location?
  end

  class CallOperatorWriteNode < Node
    def operator: () -> Symbol
    def operator_loc: () -> Location
  end

  class ClassVariableOperatorWriteNode < Node
    def operator: () -> Symbol
    def operator_loc: () -> Location
  end

  class ConstantOperatorWriteNode < Node
    def operator: () -> Symbol
    def operator_loc: () -> Location
  end

  class ConstantPathOperatorWriteNode < Node
    def operator: () -> Symbol
    def operator_loc: () -> Location
  end

  class GlobalVariableOperatorWriteNode < Node
    def operator: () -> Symbol
    def operator_loc: () -> Location
  end

  class IndexOperatorWriteNode < Node
    def operator: () -> Symbol
    def operator_loc: () -> Location
  end

  class InstanceVariableOperatorWriteNode < Node
    def operator: () -> Symbol
    def operator_loc: () -> Location
  end

  class LocalVariableOperatorWriteNode < Node
    def operator: () -> Symbol
    def operator_loc: () -> Location
  end

  class CaseMatchNode < Node
    def consequent: () -> ElseNode?
  end

  class CaseNode < Node
    def consequent: () -> ElseNode?
  end

  class IfNode < Node
    def consequent: () -> (ElseNode | IfNode | nil)
  end

  class RescueNode < Node
    def consequent: () -> RescueNode?
  end

  class UnlessNode < Node
    def consequent: () -> ElseNode?
  end
end
prism-1.5.1/sig/prism/pack.rbs000066400000000000000000000027151506127434000162210ustar00rootroot00000000000000module Prism
  module Pack
    type variant = :pack | :unpack

    def self.parse: (Symbol version, variant variant, String source) -> Format

    class Directive
      type directive_type = :SPACE | :COMMENT | :INTEGER | :UTF8 | :BER | :FLOAT | :STRING_SPACE_PADDED |
                            :STRING_NULL_PADDED | :STRING_NULL_TERMINATED | :STRING_MSB | :STRING_LSB |
                            :STRING_HEX_HIGH | :STRING_HEX_LOW | :STRING_UU | :STRING_MIME | :STRING_BASE64 |
                            :STRING_FIXED | :STRING_POINTER | :MOVE | :BACK | :NULL

      type signness = :UNSIGNED | :SIGNED | :SIGNED_NA

      type endianness = :AGNOSTIC_ENDIAN | :LITTLE_ENDIAN | :BIG_ENDIAN | :NATIVE_ENDIAN | :ENDIAN_NA

      type size = :SIZE_SHORT | :SIZE_INT | :SIZE_LONG | :SIZE_LONG_LONG | :SIZE_8 | :SIZE_16 | :SIZE_32 |
                  :SIZE_64 | :SIZE_P | :SIZE_NA

      type length_type = :LENGTH_FIXED | :LENGTH_MAX | :LENGTH_RELATIVE | :LENGTH_NA


      attr_reader version: Symbol
      attr_reader variant: variant
      attr_reader source: String
      attr_reader type: directive_type
      attr_reader signed: signness
      attr_reader endian: endianness
      attr_reader size: size
      attr_reader length_type: length_type
      attr_reader length: Integer

      def describe: () -> String
    end

    class Format
      attr_reader directives: Array[Directive]
      attr_reader encoding: Encoding

      def describe: () -> String
    end
  end
end
prism-1.5.1/sig/prism/parse_result.rbs000066400000000000000000000162361506127434000200160ustar00rootroot00000000000000module Prism
  interface _CodeUnitsCache
    def []: (Integer byte_offset) -> Integer
  end

  class Source
    attr_reader source: String
    attr_reader start_line: Integer
    attr_reader offsets: Array[Integer]

    def initialize: (String source, ?Integer start_line, ?Array[Integer] offsets) -> void
    def replace_start_line: (Integer start_line) -> void
    def replace_offsets: (Array[Integer] offsets) -> void
    def encoding: () -> Encoding
    def lines: () -> Array[String]
    def slice: (Integer byte_offset, Integer length) -> String
    def line: (Integer byte_offset) -> Integer
    def line_start: (Integer byte_offset) -> Integer
    def line_end: (Integer byte_offset) -> Integer
    def line_offset: (Integer byte_offset) -> Integer
    def column: (Integer byte_offset) -> Integer
    def character_offset: (Integer byte_offset) -> Integer
    def character_column: (Integer byte_offset) -> Integer
    def code_units_offset: (Integer byte_offset, Encoding encoding) -> Integer
    def code_units_cache: (Encoding encoding) -> _CodeUnitsCache
    def code_units_column: (Integer byte_offset, Encoding encoding) -> Integer
    def deep_freeze: () -> void

    def self.for: (String source) -> Source
  end

  class CodeUnitsCache
    def initialize: (String source, Encoding encoding) -> void
    def []: (Integer byte_offset) -> Integer
  end

  class ASCIISource < Source
    def character_offset: (Integer byte_offset) -> Integer
    def character_column: (Integer byte_offset) -> Integer
    def code_units_offset: (Integer byte_offset, Encoding encoding) -> Integer
    def code_units_cache: (Encoding encoding) -> _CodeUnitsCache
    def code_units_column: (Integer byte_offset, Encoding encoding) -> Integer
  end

  class Location
    attr_reader source: Source
    attr_reader start_offset: Integer
    attr_reader length: Integer

    def initialize: (Source source, Integer start_offset, Integer length) -> void
    def leading_comments: () -> Array[comment]
    def leading_comment: (comment) -> void
    def trailing_comments: () -> Array[comment]
    def trailing_comment: (comment) -> void
    def comments: () -> Array[comment]
    def copy: (?source: Source, ?start_offset: Integer, ?length: Integer) -> Location
    def chop: () -> Location
    def source_lines: () -> Array[String]
    def slice: () -> String
    def slice_lines: () -> String
    def start_character_offset: () -> Integer
    def start_code_units_offset: (Encoding encoding) -> Integer
    def cached_start_code_units_offset: (_CodeUnitsCache cache) -> Integer
    def end_offset: () -> Integer
    def end_character_offset: () -> Integer
    def end_code_units_offset: (Encoding encoding) -> Integer
    def cached_end_code_units_offset: (_CodeUnitsCache cache) -> Integer
    def start_line: () -> Integer
    def start_line_slice: () -> String
    def end_line: () -> Integer
    def start_column: () -> Integer
    def start_character_column: () -> Integer
    def start_code_units_column: (Encoding encoding) -> Integer
    def cached_start_code_units_column: (_CodeUnitsCache cache) -> Integer
    def end_column: () -> Integer
    def end_character_column: () -> Integer
    def end_code_units_column: (Encoding encoding) -> Integer
    def cached_end_code_units_column: (_CodeUnitsCache cache) -> Integer
    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
    def pretty_print: (untyped q) -> untyped
    def join: (Location other) -> Location
    def adjoin: (String string) -> Location
  end

  class Comment
    attr_reader location: Location

    def initialize: (Location location) -> void
    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
    def slice: () -> String
  end

  interface _Comment
    def trailing?: () -> bool
  end

  type comment = Comment & _Comment

  class InlineComment < Comment
    include _Comment
  end

  class EmbDocComment < Comment
    include _Comment
  end

  class MagicComment
    attr_reader key_loc: Location
    attr_reader value_loc: Location

    def initialize: (Location key_loc, Location value_loc) -> void

    def key: () -> String
    def value: () -> String

    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
  end

  class ParseError
    attr_reader type: Symbol
    attr_reader message: String
    attr_reader location: Location
    attr_reader level: Symbol

    def initialize: (Symbol type, String message, Location location, Symbol level) -> void
    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
  end

  class ParseWarning
    attr_reader type: Symbol
    attr_reader message: String
    attr_reader location: Location
    attr_reader level: Symbol

    def initialize: (Symbol type, String message, Location location, Symbol level) -> void
    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
  end

  class Result
    attr_reader comments: Array[comment]
    attr_reader magic_comments: Array[MagicComment]
    attr_reader data_loc: Location?
    attr_reader errors: Array[ParseError]
    attr_reader warnings: Array[ParseWarning]
    attr_reader source: Source

    def initialize: (Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
    def encoding: () -> Encoding
    def success?: () -> bool
    def failure?: () -> bool
    def code_units_cache: (Encoding encoding) -> _CodeUnitsCache
  end

  class ParseResult < Result
    attr_reader value: ProgramNode

    def initialize: (ProgramNode value, Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
    def errors_format: () -> String
  end

  class LexResult < Result
    attr_reader value: Array[[Token, Integer]]

    def initialize: (Array[[Token, Integer]] value, Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
  end

  class ParseLexResult < Result
    attr_reader value: [ProgramNode, Array[[Token, Integer]]]

    def initialize: ([ProgramNode, Array[[Token, Integer]]] value, Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
  end

  class Token
    attr_reader source: Source
    attr_reader type: Symbol
    attr_reader value: String
    attr_reader location: Location

    def initialize: (Source source, Symbol type, String value, Location location) -> void
    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
    def pretty_print: (untyped q) -> untyped
    def ==: (untyped other) -> bool
    def deep_freeze: () -> void
  end

  class Scope
    attr_reader locals: Array[Symbol]
    attr_reader forwarding: Array[Symbol]

    def initialize: (Array[Symbol] locals, Array[Symbol] forwarding) -> void
  end
end
prism-1.5.1/sig/prism/parse_result/000077500000000000000000000000001506127434000172765ustar00rootroot00000000000000prism-1.5.1/sig/prism/parse_result/comments.rbs000066400000000000000000000015051506127434000216340ustar00rootroot00000000000000module Prism
  class ParseResult < Result
    class Comments
      interface _Target
        def start_offset: () -> Integer
        def end_offset: () -> Integer
        def encloses?: (comment) -> bool
        def leading_comment: (comment) -> void
        def trailing_comment: (comment) -> void
      end

      class NodeTarget
        include _Target

        attr_reader node: node

        def initialize: (node) -> void
      end

      class LocationTarget
        include _Target

        attr_reader location: Location

        def initialize: (Location location) -> void
      end

      attr_reader parse_result: ParseResult

      def initialize: (ParseResult parse_result) -> void
      def attach!: () -> void

      private

      def nearest_targets: (node, comment) -> [_Target?, _Target, _Target?]
    end
  end
end
prism-1.5.1/sig/prism/pattern.rbs000066400000000000000000000005101506127434000167470ustar00rootroot00000000000000module Prism
  class Pattern
    class CompilationError < StandardError
    end

    attr_reader query: String

    def initialize: (String query) -> void
    def compile: () -> Proc
    def scan: (Prism::node root) { (Prism::node) -> void } -> void
            | (Prism::node root) -> ::Enumerator[Prism::node, void]
  end
end
prism-1.5.1/sig/prism/reflection.rbs000066400000000000000000000014601506127434000174310ustar00rootroot00000000000000module Prism
  module Reflection
    class Field
      attr_reader name: Symbol

      def initialize: (Symbol name) -> void
    end

    class NodeField < Field
    end

    class OptionalNodeField < Field
    end

    class NodeListField < Field
    end

    class ConstantField < Field
    end

    class OptionalConstantField < Field
    end

    class ConstantListField < Field
    end

    class StringField < Field
    end

    class LocationField < Field
    end

    class OptionalLocationField < Field
    end

    class IntegerField < Field
    end

    class FloatField < Field
    end

    class FlagsField < Field
      attr_reader flags: Array[Symbol]

      def initialize: (Symbol name, Array[Symbol] flags) -> void
    end

    def self.fields_for: (singleton(Node) node) -> Array[Field]
  end
end
prism-1.5.1/sig/prism/relocation.rbs000066400000000000000000000116211506127434000174360ustar00rootroot00000000000000module Prism
  module Relocation
    interface _Value
      def start_line: () -> Integer
      def end_line: () -> Integer
      def start_offset: () -> Integer
      def end_offset: () -> Integer
      def start_character_offset: () -> Integer
      def end_character_offset: () -> Integer
      def cached_start_code_units_offset: (_CodeUnitsCache cache) -> Integer
      def cached_end_code_units_offset: (_CodeUnitsCache cache) -> Integer
      def start_column: () -> Integer
      def end_column: () -> Integer
      def start_character_column: () -> Integer
      def end_character_column: () -> Integer
      def cached_start_code_units_column: (_CodeUnitsCache cache) -> Integer
      def cached_end_code_units_column: (_CodeUnitsCache cache) -> Integer
      def leading_comments: () -> Array[Comment]
      def trailing_comments: () -> Array[Comment]
    end

    interface _Field
      def fields: (_Value value) -> entry_values
    end

    type entry_value = untyped
    type entry_values = Hash[Symbol, entry_value]

    class Entry
      class MissingValueError < StandardError
      end

      def initialize: (Repository repository) -> void

      def filepath: () -> String

      def start_line: () -> Integer
      def end_line: () -> Integer

      def start_offset: () -> Integer
      def end_offset: () -> Integer
      def start_character_offset: () -> Integer
      def end_character_offset: () -> Integer
      def start_code_units_offset: () -> Integer
      def end_code_units_offset: () -> Integer

      def start_column: () -> Integer
      def end_column: () -> Integer
      def start_character_column: () -> Integer
      def end_character_column: () -> Integer
      def start_code_units_column: () -> Integer
      def end_code_units_column: () -> Integer

      def leading_comments: () -> Array[CommentsField::Comment]
      def trailing_comments: () -> Array[CommentsField::Comment]
      def comments: () -> Array[CommentsField::Comment]

      private

      def fetch_value: (Symbol name) -> entry_value
      def values: () -> entry_values
    end

    class Source
      attr_reader value: untyped

      def initialize: (untyped value) -> void

      def result: () -> ParseResult
      def code_units_cache: (Encoding encoding) -> _CodeUnitsCache
    end

    class SourceFilepath < Source
      def result: () -> ParseResult
    end

    class SourceString < Source
      def result: () -> ParseResult
    end

    class FilepathField
      attr_reader value: String

      def initialize: (String value) -> void

      def fields: (_Value value) -> entry_values
    end

    class LinesField
      def fields: (_Value value) -> entry_values
    end

    class OffsetsField
      def fields: (_Value value) -> entry_values
    end

    class CharacterOffsetsField
      def fields: (_Value value) -> entry_values
    end

    class CodeUnitOffsetsField
      attr_reader repository: Repository
      attr_reader encoding: Encoding

      def initialize: (Repository repository, Encoding encoding) -> void
      def fields: (_Value value) -> entry_values

      private

      def cache: () -> _CodeUnitsCache
    end

    class ColumnsField
      def fields: (_Value value) -> entry_values
    end

    class CharacterColumnsField
      def fields: (_Value value) -> entry_values
    end

    class CodeUnitColumnsField
      attr_reader repository: Repository
      attr_reader encoding: Encoding

      def initialize: (Repository repository, Encoding encoding) -> void
      def fields: (_Value value) -> entry_values

      private

      def cache: () -> _CodeUnitsCache
    end

    class CommentsField
      class Comment
        attr_reader slice: String

        def initialize: (String slice) -> void
      end

      private

      def comments: (entry_value value) -> Array[Comment]
    end

    class LeadingCommentsField < CommentsField
      def fields: (_Value value) -> entry_values
    end

    class TrailingCommentsField < CommentsField
      def fields: (_Value value) -> entry_values
    end

    class Repository
      class ConfigurationError < StandardError
      end

      attr_reader source: Source
      attr_reader fields: Hash[Symbol, _Field]
      attr_reader entries: Hash[Integer, Hash[Symbol, Entry]]

      def initialize: (Source source) -> void

      def code_units_cache: (Encoding encoding) -> _CodeUnitsCache

      def filepath: () -> self
      def lines: () -> self
      def offsets: () -> self
      def character_offsets: () -> self
      def code_unit_offsets: (Encoding encoding) -> self
      def columns: () -> self
      def character_columns: () -> self
      def code_unit_columns: (Encoding encoding) -> self
      def leading_comments: () -> self
      def trailing_comments: () -> self
      def comments: () -> self

      private

      def field: (Symbol name, _Field) -> self
    end

    def self.filepath: (String value) -> Repository
    def self.string: (String value) -> Repository
  end
end
prism-1.5.1/sig/prism/serialize.rbs000066400000000000000000000004651506127434000172720ustar00rootroot00000000000000module Prism
  module Serialize
    def self.load_parse: (String, String, bool) -> ParseResult
    def self.load_lex: (String, String, bool) -> LexResult
    def self.load_parse_comments: (String, String, bool) -> Array[comment]
    def self.load_parse_lex: (String, String, bool) -> ParseLexResult
  end
end
prism-1.5.1/sig/prism/string_query.rbs000066400000000000000000000003221506127434000200260ustar00rootroot00000000000000module Prism
  class StringQuery
    attr_reader string: String

    def initialize: (String string) -> void

    def local?: () -> bool
    def constant?: () -> bool
    def method_name?: () -> bool
  end
end
prism-1.5.1/snapshots/000077500000000000000000000000001506127434000146745ustar00rootroot00000000000000prism-1.5.1/snapshots/alias.txt000066400000000000000000000267471506127434000165460ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(23,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(23,11))
    ├── flags: ∅
    └── body: (length: 12)
        ├── @ AliasMethodNode (location: (1,0)-(1,15))
        │   ├── flags: newline
        │   ├── new_name:
        │   │   @ SymbolNode (location: (1,6)-(1,10))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (1,6)-(1,7) = ":"
        │   │   ├── value_loc: (1,7)-(1,10) = "foo"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "foo"
        │   ├── old_name:
        │   │   @ SymbolNode (location: (1,11)-(1,15))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (1,11)-(1,12) = ":"
        │   │   ├── value_loc: (1,12)-(1,15) = "bar"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "bar"
        │   └── keyword_loc: (1,0)-(1,5) = "alias"
        ├── @ AliasMethodNode (location: (3,0)-(3,21))
        │   ├── flags: newline
        │   ├── new_name:
        │   │   @ SymbolNode (location: (3,6)-(3,13))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (3,6)-(3,9) = "%s["
        │   │   ├── value_loc: (3,9)-(3,12) = "abc"
        │   │   ├── closing_loc: (3,12)-(3,13) = "]"
        │   │   └── unescaped: "abc"
        │   ├── old_name:
        │   │   @ SymbolNode (location: (3,14)-(3,21))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (3,14)-(3,17) = "%s["
        │   │   ├── value_loc: (3,17)-(3,20) = "def"
        │   │   ├── closing_loc: (3,20)-(3,21) = "]"
        │   │   └── unescaped: "def"
        │   └── keyword_loc: (3,0)-(3,5) = "alias"
        ├── @ AliasMethodNode (location: (5,0)-(5,19))
        │   ├── flags: newline
        │   ├── new_name:
        │   │   @ SymbolNode (location: (5,6)-(5,12))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (5,6)-(5,8) = ":'"
        │   │   ├── value_loc: (5,8)-(5,11) = "abc"
        │   │   ├── closing_loc: (5,11)-(5,12) = "'"
        │   │   └── unescaped: "abc"
        │   ├── old_name:
        │   │   @ SymbolNode (location: (5,13)-(5,19))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (5,13)-(5,15) = ":'"
        │   │   ├── value_loc: (5,15)-(5,18) = "def"
        │   │   ├── closing_loc: (5,18)-(5,19) = "'"
        │   │   └── unescaped: "def"
        │   └── keyword_loc: (5,0)-(5,5) = "alias"
        ├── @ AliasMethodNode (location: (7,0)-(7,23))
        │   ├── flags: newline
        │   ├── new_name:
        │   │   @ InterpolatedSymbolNode (location: (7,6)-(7,16))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (7,6)-(7,8) = ":\""
        │   │   ├── parts: (length: 2)
        │   │   │   ├── @ StringNode (location: (7,8)-(7,11))
        │   │   │   │   ├── flags: static_literal, frozen
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── content_loc: (7,8)-(7,11) = "abc"
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── unescaped: "abc"
        │   │   │   └── @ EmbeddedStatementsNode (location: (7,11)-(7,15))
        │   │   │       ├── flags: ∅
        │   │   │       ├── opening_loc: (7,11)-(7,13) = "\#{"
        │   │   │       ├── statements:
        │   │   │       │   @ StatementsNode (location: (7,13)-(7,14))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   └── body: (length: 1)
        │   │   │       │       └── @ IntegerNode (location: (7,13)-(7,14))
        │   │   │       │           ├── flags: static_literal, decimal
        │   │   │       │           └── value: 1
        │   │   │       └── closing_loc: (7,14)-(7,15) = "}"
        │   │   └── closing_loc: (7,15)-(7,16) = "\""
        │   ├── old_name:
        │   │   @ SymbolNode (location: (7,17)-(7,23))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (7,17)-(7,19) = ":'"
        │   │   ├── value_loc: (7,19)-(7,22) = "def"
        │   │   ├── closing_loc: (7,22)-(7,23) = "'"
        │   │   └── unescaped: "def"
        │   └── keyword_loc: (7,0)-(7,5) = "alias"
        ├── @ AliasGlobalVariableNode (location: (9,0)-(9,11))
        │   ├── flags: newline
        │   ├── new_name:
        │   │   @ GlobalVariableReadNode (location: (9,6)-(9,8))
        │   │   ├── flags: ∅
        │   │   └── name: :$a
        │   ├── old_name:
        │   │   @ BackReferenceReadNode (location: (9,9)-(9,11))
        │   │   ├── flags: ∅
        │   │   └── name: :$'
        │   └── keyword_loc: (9,0)-(9,5) = "alias"
        ├── @ AliasMethodNode (location: (11,0)-(11,13))
        │   ├── flags: newline
        │   ├── new_name:
        │   │   @ SymbolNode (location: (11,6)-(11,9))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: ∅
        │   │   ├── value_loc: (11,6)-(11,9) = "foo"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "foo"
        │   ├── old_name:
        │   │   @ SymbolNode (location: (11,10)-(11,13))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: ∅
        │   │   ├── value_loc: (11,10)-(11,13) = "bar"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "bar"
        │   └── keyword_loc: (11,0)-(11,5) = "alias"
        ├── @ AliasGlobalVariableNode (location: (13,0)-(13,15))
        │   ├── flags: newline
        │   ├── new_name:
        │   │   @ GlobalVariableReadNode (location: (13,6)-(13,10))
        │   │   ├── flags: ∅
        │   │   └── name: :$foo
        │   ├── old_name:
        │   │   @ GlobalVariableReadNode (location: (13,11)-(13,15))
        │   │   ├── flags: ∅
        │   │   └── name: :$bar
        │   └── keyword_loc: (13,0)-(13,5) = "alias"
        ├── @ AliasMethodNode (location: (15,0)-(15,12))
        │   ├── flags: newline
        │   ├── new_name:
        │   │   @ SymbolNode (location: (15,6)-(15,9))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: ∅
        │   │   ├── value_loc: (15,6)-(15,9) = "foo"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "foo"
        │   ├── old_name:
        │   │   @ SymbolNode (location: (15,10)-(15,12))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: ∅
        │   │   ├── value_loc: (15,10)-(15,12) = "if"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "if"
        │   └── keyword_loc: (15,0)-(15,5) = "alias"
        ├── @ AliasMethodNode (location: (17,0)-(17,13))
        │   ├── flags: newline
        │   ├── new_name:
        │   │   @ SymbolNode (location: (17,6)-(17,9))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: ∅
        │   │   ├── value_loc: (17,6)-(17,9) = "foo"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "foo"
        │   ├── old_name:
        │   │   @ SymbolNode (location: (17,10)-(17,13))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: ∅
        │   │   ├── value_loc: (17,10)-(17,13) = "<=>"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "<=>"
        │   └── keyword_loc: (17,0)-(17,5) = "alias"
        ├── @ AliasMethodNode (location: (19,0)-(19,15))
        │   ├── flags: newline
        │   ├── new_name:
        │   │   @ SymbolNode (location: (19,6)-(19,9))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (19,6)-(19,7) = ":"
        │   │   ├── value_loc: (19,7)-(19,9) = "=="
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "=="
        │   ├── old_name:
        │   │   @ SymbolNode (location: (19,10)-(19,15))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (19,10)-(19,11) = ":"
        │   │   ├── value_loc: (19,11)-(19,15) = "eql?"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "eql?"
        │   └── keyword_loc: (19,0)-(19,5) = "alias"
        ├── @ AliasMethodNode (location: (21,0)-(21,9))
        │   ├── flags: newline
        │   ├── new_name:
        │   │   @ SymbolNode (location: (21,6)-(21,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: ∅
        │   │   ├── value_loc: (21,6)-(21,7) = "A"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "A"
        │   ├── old_name:
        │   │   @ SymbolNode (location: (21,8)-(21,9))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: ∅
        │   │   ├── value_loc: (21,8)-(21,9) = "B"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "B"
        │   └── keyword_loc: (21,0)-(21,5) = "alias"
        └── @ AliasMethodNode (location: (23,0)-(23,11))
            ├── flags: newline
            ├── new_name:
            │   @ SymbolNode (location: (23,6)-(23,8))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (23,6)-(23,7) = ":"
            │   ├── value_loc: (23,7)-(23,8) = "A"
            │   ├── closing_loc: ∅
            │   └── unescaped: "A"
            ├── old_name:
            │   @ SymbolNode (location: (23,9)-(23,11))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (23,9)-(23,10) = ":"
            │   ├── value_loc: (23,10)-(23,11) = "B"
            │   ├── closing_loc: ∅
            │   └── unescaped: "B"
            └── keyword_loc: (23,0)-(23,5) = "alias"
prism-1.5.1/snapshots/arithmetic.txt000066400000000000000000000317061506127434000175750ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(13,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(13,8))
    ├── flags: ∅
    └── body: (length: 7)
        ├── @ CallNode (location: (1,0)-(1,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,4)-(1,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (1,4)-(1,8))
        │   │           ├── flags: ∅
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (1,5)-(1,8))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :bar
        │   │           │   ├── message_loc: (1,5)-(1,8) = "bar"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :!
        │   │           ├── message_loc: (1,4)-(1,5) = "!"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,4))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (3,1)-(3,4))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (3,1)-(3,4) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :-@
        │   │   ├── message_loc: (3,0)-(3,1) = "-"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :*
        │   ├── message_loc: (3,4)-(3,5) = "*"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,5)-(3,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (3,5)-(3,8))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (3,5)-(3,8) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (5,0)-(5,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (5,0)-(5,4))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (5,1)-(5,4))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (5,1)-(5,4) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :+@
        │   │   ├── message_loc: (5,0)-(5,1) = "+"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :**
        │   ├── message_loc: (5,4)-(5,6) = "**"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (5,6)-(5,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (5,6)-(5,9))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (5,6)-(5,9) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (7,0)-(7,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (7,0)-(7,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (7,4)-(7,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (7,4)-(7,8))
        │   │           ├── flags: ∅
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (7,5)-(7,8))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :bar
        │   │           │   ├── message_loc: (7,5)-(7,8) = "bar"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :~
        │   │           ├── message_loc: (7,4)-(7,5) = "~"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (9,0)-(9,17))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (9,0)-(9,10))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (9,0)-(9,3))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (9,0)-(9,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :<<
        │   │   ├── message_loc: (9,4)-(9,6) = "<<"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (9,7)-(9,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ CallNode (location: (9,7)-(9,10))
        │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :bar
        │   │   │           ├── message_loc: (9,7)-(9,10) = "bar"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :<<
        │   ├── message_loc: (9,11)-(9,13) = "<<"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (9,14)-(9,17))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (9,14)-(9,17))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :baz
        │   │           ├── message_loc: (9,14)-(9,17) = "baz"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (11,0)-(11,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (11,1)-(11,5))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ IntegerNode (location: (11,1)-(11,2))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :**
        │   │   ├── message_loc: (11,2)-(11,4) = "**"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (11,4)-(11,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (11,4)-(11,5))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :-@
        │   ├── message_loc: (11,0)-(11,1) = "-"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (13,0)-(13,8))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (13,0)-(13,2))
            │   ├── flags: static_literal, decimal
            │   └── value: -1
            ├── call_operator_loc: (13,2)-(13,3) = "."
            ├── name: :zero?
            ├── message_loc: (13,3)-(13,8) = "zero?"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/arrays.txt000066400000000000000000003237771506127434000167610ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(122,32))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(122,32))
    ├── flags: ∅
    └── body: (length: 50)
        ├── @ ArrayNode (location: (1,0)-(1,4))
        │   ├── flags: newline, contains_splat
        │   ├── elements: (length: 1)
        │   │   └── @ SplatNode (location: (1,1)-(1,3))
        │   │       ├── flags: ∅
        │   │       ├── operator_loc: (1,1)-(1,2) = "*"
        │   │       └── expression:
        │   │           @ CallNode (location: (1,2)-(1,3))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (1,2)-(1,3) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── opening_loc: (1,0)-(1,1) = "["
        │   └── closing_loc: (1,3)-(1,4) = "]"
        ├── @ CallNode (location: (3,0)-(3,23))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (3,3)-(3,13) = "[bar, baz]"
        │   ├── opening_loc: (3,3)-(3,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,4)-(3,23))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 3)
        │   │       ├── @ CallNode (location: (3,4)-(3,7))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :bar
        │   │       │   ├── message_loc: (3,4)-(3,7) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       ├── @ CallNode (location: (3,9)-(3,12))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :baz
        │   │       │   ├── message_loc: (3,9)-(3,12) = "baz"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ ArrayNode (location: (3,16)-(3,23))
        │   │           ├── flags: static_literal
        │   │           ├── elements: (length: 3)
        │   │           │   ├── @ IntegerNode (location: (3,16)-(3,17))
        │   │           │   │   ├── flags: static_literal, decimal
        │   │           │   │   └── value: 1
        │   │           │   ├── @ IntegerNode (location: (3,19)-(3,20))
        │   │           │   │   ├── flags: static_literal, decimal
        │   │           │   │   └── value: 2
        │   │           │   └── @ IntegerNode (location: (3,22)-(3,23))
        │   │           │       ├── flags: static_literal, decimal
        │   │           │       └── value: 3
        │   │           ├── opening_loc: ∅
        │   │           └── closing_loc: ∅
        │   ├── closing_loc: (3,12)-(3,13) = "]"
        │   └── block: ∅
        ├── @ ArrayNode (location: (5,0)-(5,13))
        │   ├── flags: newline
        │   ├── elements: (length: 1)
        │   │   └── @ KeywordHashNode (location: (5,1)-(5,12))
        │   │       ├── flags: symbol_keys
        │   │       └── elements: (length: 1)
        │   │           └── @ AssocNode (location: (5,1)-(5,12))
        │   │               ├── flags: ∅
        │   │               ├── key:
        │   │               │   @ SymbolNode (location: (5,1)-(5,3))
        │   │               │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │               │   ├── opening_loc: ∅
        │   │               │   ├── value_loc: (5,1)-(5,2) = "a"
        │   │               │   ├── closing_loc: (5,2)-(5,3) = ":"
        │   │               │   └── unescaped: "a"
        │   │               ├── value:
        │   │               │   @ ArrayNode (location: (5,4)-(5,12))
        │   │               │   ├── flags: static_literal
        │   │               │   ├── elements: (length: 2)
        │   │               │   │   ├── @ SymbolNode (location: (5,5)-(5,7))
        │   │               │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │               │   │   │   ├── opening_loc: (5,5)-(5,6) = ":"
        │   │               │   │   │   ├── value_loc: (5,6)-(5,7) = "b"
        │   │               │   │   │   ├── closing_loc: ∅
        │   │               │   │   │   └── unescaped: "b"
        │   │               │   │   └── @ SymbolNode (location: (5,9)-(5,11))
        │   │               │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │               │   │       ├── opening_loc: (5,9)-(5,10) = ":"
        │   │               │   │       ├── value_loc: (5,10)-(5,11) = "c"
        │   │               │   │       ├── closing_loc: ∅
        │   │               │   │       └── unescaped: "c"
        │   │               │   ├── opening_loc: (5,4)-(5,5) = "["
        │   │               │   └── closing_loc: (5,11)-(5,12) = "]"
        │   │               └── operator_loc: ∅
        │   ├── opening_loc: (5,0)-(5,1) = "["
        │   └── closing_loc: (5,12)-(5,13) = "]"
        ├── @ ArrayNode (location: (9,0)-(15,1))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 5)
        │   │   ├── @ SymbolNode (location: (9,1)-(9,3))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (9,1)-(9,2) = ":"
        │   │   │   ├── value_loc: (9,2)-(9,3) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   ├── @ SymbolNode (location: (9,5)-(9,7))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (9,5)-(9,6) = ":"
        │   │   │   ├── value_loc: (9,6)-(9,7) = "b"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "b"
        │   │   ├── @ SymbolNode (location: (10,0)-(10,2))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (10,0)-(10,1) = ":"
        │   │   │   ├── value_loc: (10,1)-(10,2) = "c"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "c"
        │   │   ├── @ IntegerNode (location: (10,3)-(10,4))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   └── @ SymbolNode (location: (14,0)-(14,2))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: (14,0)-(14,1) = ":"
        │   │       ├── value_loc: (14,1)-(14,2) = "d"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "d"
        │   ├── opening_loc: (9,0)-(9,1) = "["
        │   └── closing_loc: (15,0)-(15,1) = "]"
        ├── @ ArrayNode (location: (18,0)-(26,1))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 5)
        │   │   ├── @ SymbolNode (location: (18,1)-(18,3))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (18,1)-(18,2) = ":"
        │   │   │   ├── value_loc: (18,2)-(18,3) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   ├── @ SymbolNode (location: (18,5)-(18,7))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (18,5)-(18,6) = ":"
        │   │   │   ├── value_loc: (18,6)-(18,7) = "b"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "b"
        │   │   ├── @ SymbolNode (location: (19,0)-(19,2))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (19,0)-(19,1) = ":"
        │   │   │   ├── value_loc: (19,1)-(19,2) = "c"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "c"
        │   │   ├── @ IntegerNode (location: (19,3)-(19,4))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   └── @ SymbolNode (location: (23,0)-(23,2))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: (23,0)-(23,1) = ":"
        │   │       ├── value_loc: (23,1)-(23,2) = "d"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "d"
        │   ├── opening_loc: (18,0)-(18,1) = "["
        │   └── closing_loc: (26,0)-(26,1) = "]"
        ├── @ ArrayNode (location: (28,0)-(28,12))
        │   ├── flags: newline
        │   ├── elements: (length: 1)
        │   │   └── @ KeywordHashNode (location: (28,1)-(28,11))
        │   │       ├── flags: ∅
        │   │       └── elements: (length: 1)
        │   │           └── @ AssocNode (location: (28,1)-(28,11))
        │   │               ├── flags: ∅
        │   │               ├── key:
        │   │               │   @ CallNode (location: (28,1)-(28,4))
        │   │               │   ├── flags: variable_call, ignore_visibility
        │   │               │   ├── receiver: ∅
        │   │               │   ├── call_operator_loc: ∅
        │   │               │   ├── name: :foo
        │   │               │   ├── message_loc: (28,1)-(28,4) = "foo"
        │   │               │   ├── opening_loc: ∅
        │   │               │   ├── arguments: ∅
        │   │               │   ├── closing_loc: ∅
        │   │               │   └── block: ∅
        │   │               ├── value:
        │   │               │   @ CallNode (location: (28,8)-(28,11))
        │   │               │   ├── flags: variable_call, ignore_visibility
        │   │               │   ├── receiver: ∅
        │   │               │   ├── call_operator_loc: ∅
        │   │               │   ├── name: :bar
        │   │               │   ├── message_loc: (28,8)-(28,11) = "bar"
        │   │               │   ├── opening_loc: ∅
        │   │               │   ├── arguments: ∅
        │   │               │   ├── closing_loc: ∅
        │   │               │   └── block: ∅
        │   │               └── operator_loc: (28,5)-(28,7) = "=>"
        │   ├── opening_loc: (28,0)-(28,1) = "["
        │   └── closing_loc: (28,11)-(28,12) = "]"
        ├── @ CallNode (location: (30,0)-(30,19))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ CallNode (location: (30,0)-(30,8))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (30,0)-(30,3))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (30,0)-(30,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :[]
        │   │   ├── message_loc: (30,3)-(30,8) = "[bar]"
        │   │   ├── opening_loc: (30,3)-(30,4) = "["
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (30,4)-(30,7))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ CallNode (location: (30,4)-(30,7))
        │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :bar
        │   │   │           ├── message_loc: (30,4)-(30,7) = "bar"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── closing_loc: (30,7)-(30,8) = "]"
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (30,8)-(30,13) = "[baz]"
        │   ├── opening_loc: (30,8)-(30,9) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (30,9)-(30,19))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (30,9)-(30,12))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :baz
        │   │       │   ├── message_loc: (30,9)-(30,12) = "baz"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (30,16)-(30,19))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :qux
        │   │           ├── message_loc: (30,16)-(30,19) = "qux"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (30,12)-(30,13) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (32,0)-(32,13))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (32,0)-(32,8))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (32,0)-(32,3))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (32,0)-(32,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :[]
        │   │   ├── message_loc: (32,3)-(32,8) = "[bar]"
        │   │   ├── opening_loc: (32,3)-(32,4) = "["
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (32,4)-(32,7))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ CallNode (location: (32,4)-(32,7))
        │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :bar
        │   │   │           ├── message_loc: (32,4)-(32,7) = "bar"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── closing_loc: (32,7)-(32,8) = "]"
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]
        │   ├── message_loc: (32,8)-(32,13) = "[baz]"
        │   ├── opening_loc: (32,8)-(32,9) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (32,9)-(32,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (32,9)-(32,12))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :baz
        │   │           ├── message_loc: (32,9)-(32,12) = "baz"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (32,12)-(32,13) = "]"
        │   └── block: ∅
        ├── @ ArrayNode (location: (34,0)-(35,1))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 0)
        │   ├── opening_loc: (34,0)-(34,1) = "["
        │   └── closing_loc: (35,0)-(35,1) = "]"
        ├── @ CallNode (location: (37,0)-(37,13))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (37,0)-(37,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (37,0)-(37,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]
        │   ├── message_loc: (37,3)-(37,13) = "[bar, baz]"
        │   ├── opening_loc: (37,3)-(37,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (37,4)-(37,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (37,4)-(37,7))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :bar
        │   │       │   ├── message_loc: (37,4)-(37,7) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (37,9)-(37,12))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :baz
        │   │           ├── message_loc: (37,9)-(37,12) = "baz"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (37,12)-(37,13) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (39,0)-(39,19))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ CallNode (location: (39,0)-(39,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (39,0)-(39,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (39,3)-(39,13) = "[bar, baz]"
        │   ├── opening_loc: (39,3)-(39,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (39,4)-(39,19))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 3)
        │   │       ├── @ CallNode (location: (39,4)-(39,7))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :bar
        │   │       │   ├── message_loc: (39,4)-(39,7) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       ├── @ CallNode (location: (39,9)-(39,12))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :baz
        │   │       │   ├── message_loc: (39,9)-(39,12) = "baz"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (39,16)-(39,19))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :qux
        │   │           ├── message_loc: (39,16)-(39,19) = "qux"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (39,12)-(39,13) = "]"
        │   └── block: ∅
        ├── @ MultiWriteNode (location: (41,0)-(41,21))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ IndexTargetNode (location: (41,0)-(41,6))
        │   │   │   ├── flags: attribute_write
        │   │   │   ├── receiver:
        │   │   │   │   @ CallNode (location: (41,0)-(41,3))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :foo
        │   │   │   │   ├── message_loc: (41,0)-(41,3) = "foo"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── opening_loc: (41,3)-(41,4) = "["
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (41,4)-(41,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (41,4)-(41,5))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 0
        │   │   │   ├── closing_loc: (41,5)-(41,6) = "]"
        │   │   │   └── block: ∅
        │   │   └── @ IndexTargetNode (location: (41,8)-(41,14))
        │   │       ├── flags: attribute_write
        │   │       ├── receiver:
        │   │       │   @ CallNode (location: (41,8)-(41,11))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :bar
        │   │       │   ├── message_loc: (41,8)-(41,11) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       ├── opening_loc: (41,11)-(41,12) = "["
        │   │       ├── arguments:
        │   │       │   @ ArgumentsNode (location: (41,12)-(41,13))
        │   │       │   ├── flags: ∅
        │   │       │   └── arguments: (length: 1)
        │   │       │       └── @ IntegerNode (location: (41,12)-(41,13))
        │   │       │           ├── flags: static_literal, decimal
        │   │       │           └── value: 0
        │   │       ├── closing_loc: (41,13)-(41,14) = "]"
        │   │       └── block: ∅
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (41,15)-(41,16) = "="
        │   └── value:
        │       @ ArrayNode (location: (41,17)-(41,21))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (41,17)-(41,18))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (41,20)-(41,21))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: ∅
        │       └── closing_loc: ∅
        ├── @ CallNode (location: (43,0)-(43,19))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (43,0)-(43,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (43,0)-(43,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]
        │   ├── message_loc: (43,3)-(43,19) = "[bar[baz] = qux]"
        │   ├── opening_loc: (43,3)-(43,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (43,4)-(43,18))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (43,4)-(43,18))
        │   │           ├── flags: attribute_write
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (43,4)-(43,7))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :bar
        │   │           │   ├── message_loc: (43,4)-(43,7) = "bar"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :[]=
        │   │           ├── message_loc: (43,7)-(43,12) = "[baz]"
        │   │           ├── opening_loc: (43,7)-(43,8) = "["
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (43,8)-(43,18))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 2)
        │   │           │       ├── @ CallNode (location: (43,8)-(43,11))
        │   │           │       │   ├── flags: variable_call, ignore_visibility
        │   │           │       │   ├── receiver: ∅
        │   │           │       │   ├── call_operator_loc: ∅
        │   │           │       │   ├── name: :baz
        │   │           │       │   ├── message_loc: (43,8)-(43,11) = "baz"
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── arguments: ∅
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   └── block: ∅
        │   │           │       └── @ CallNode (location: (43,15)-(43,18))
        │   │           │           ├── flags: variable_call, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :qux
        │   │           │           ├── message_loc: (43,15)-(43,18) = "qux"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── closing_loc: (43,11)-(43,12) = "]"
        │   │           └── block: ∅
        │   ├── closing_loc: (43,18)-(43,19) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (45,0)-(45,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (45,0)-(45,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (45,0)-(45,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]
        │   ├── message_loc: (45,3)-(45,8) = "[bar]"
        │   ├── opening_loc: (45,3)-(45,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (45,4)-(45,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (45,4)-(45,7))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (45,4)-(45,7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (45,7)-(45,8) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (47,0)-(47,14))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ CallNode (location: (47,0)-(47,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (47,0)-(47,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (47,3)-(47,8) = "[bar]"
        │   ├── opening_loc: (47,3)-(47,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (47,4)-(47,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (47,4)-(47,7))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :bar
        │   │       │   ├── message_loc: (47,4)-(47,7) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (47,11)-(47,14))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :baz
        │   │           ├── message_loc: (47,11)-(47,14) = "baz"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (47,7)-(47,8) = "]"
        │   └── block: ∅
        ├── @ ArrayNode (location: (49,0)-(49,6))
        │   ├── flags: newline
        │   ├── elements: (length: 1)
        │   │   └── @ KeywordHashNode (location: (49,1)-(49,5))
        │   │       ├── flags: ∅
        │   │       └── elements: (length: 1)
        │   │           └── @ AssocSplatNode (location: (49,1)-(49,5))
        │   │               ├── flags: ∅
        │   │               ├── value:
        │   │               │   @ HashNode (location: (49,3)-(49,5))
        │   │               │   ├── flags: static_literal
        │   │               │   ├── opening_loc: (49,3)-(49,4) = "{"
        │   │               │   ├── elements: (length: 0)
        │   │               │   └── closing_loc: (49,4)-(49,5) = "}"
        │   │               └── operator_loc: (49,1)-(49,3) = "**"
        │   ├── opening_loc: (49,0)-(49,1) = "["
        │   └── closing_loc: (49,5)-(49,6) = "]"
        ├── @ ArrayNode (location: (51,0)-(51,6))
        │   ├── flags: newline
        │   ├── elements: (length: 1)
        │   │   └── @ KeywordHashNode (location: (51,1)-(51,5))
        │   │       ├── flags: ∅
        │   │       └── elements: (length: 1)
        │   │           └── @ AssocSplatNode (location: (51,1)-(51,5))
        │   │               ├── flags: ∅
        │   │               ├── value:
        │   │               │   @ CallNode (location: (51,3)-(51,5))
        │   │               │   ├── flags: variable_call, ignore_visibility
        │   │               │   ├── receiver: ∅
        │   │               │   ├── call_operator_loc: ∅
        │   │               │   ├── name: :kw
        │   │               │   ├── message_loc: (51,3)-(51,5) = "kw"
        │   │               │   ├── opening_loc: ∅
        │   │               │   ├── arguments: ∅
        │   │               │   ├── closing_loc: ∅
        │   │               │   └── block: ∅
        │   │               └── operator_loc: (51,1)-(51,3) = "**"
        │   ├── opening_loc: (51,0)-(51,1) = "["
        │   └── closing_loc: (51,5)-(51,6) = "]"
        ├── @ ArrayNode (location: (53,0)-(53,9))
        │   ├── flags: newline
        │   ├── elements: (length: 2)
        │   │   ├── @ IntegerNode (location: (53,1)-(53,2))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   └── @ KeywordHashNode (location: (53,4)-(53,8))
        │   │       ├── flags: ∅
        │   │       └── elements: (length: 1)
        │   │           └── @ AssocSplatNode (location: (53,4)-(53,8))
        │   │               ├── flags: ∅
        │   │               ├── value:
        │   │               │   @ CallNode (location: (53,6)-(53,8))
        │   │               │   ├── flags: variable_call, ignore_visibility
        │   │               │   ├── receiver: ∅
        │   │               │   ├── call_operator_loc: ∅
        │   │               │   ├── name: :kw
        │   │               │   ├── message_loc: (53,6)-(53,8) = "kw"
        │   │               │   ├── opening_loc: ∅
        │   │               │   ├── arguments: ∅
        │   │               │   ├── closing_loc: ∅
        │   │               │   └── block: ∅
        │   │               └── operator_loc: (53,4)-(53,6) = "**"
        │   ├── opening_loc: (53,0)-(53,1) = "["
        │   └── closing_loc: (53,8)-(53,9) = "]"
        ├── @ ArrayNode (location: (55,0)-(55,21))
        │   ├── flags: newline
        │   ├── elements: (length: 2)
        │   │   ├── @ IntegerNode (location: (55,1)-(55,2))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   └── @ KeywordHashNode (location: (55,4)-(55,20))
        │   │       ├── flags: ∅
        │   │       └── elements: (length: 3)
        │   │           ├── @ AssocSplatNode (location: (55,4)-(55,8))
        │   │           │   ├── flags: ∅
        │   │           │   ├── value:
        │   │           │   │   @ CallNode (location: (55,6)-(55,8))
        │   │           │   │   ├── flags: variable_call, ignore_visibility
        │   │           │   │   ├── receiver: ∅
        │   │           │   │   ├── call_operator_loc: ∅
        │   │           │   │   ├── name: :kw
        │   │           │   │   ├── message_loc: (55,6)-(55,8) = "kw"
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── arguments: ∅
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── block: ∅
        │   │           │   └── operator_loc: (55,4)-(55,6) = "**"
        │   │           ├── @ AssocSplatNode (location: (55,10)-(55,14))
        │   │           │   ├── flags: ∅
        │   │           │   ├── value:
        │   │           │   │   @ HashNode (location: (55,12)-(55,14))
        │   │           │   │   ├── flags: static_literal
        │   │           │   │   ├── opening_loc: (55,12)-(55,13) = "{"
        │   │           │   │   ├── elements: (length: 0)
        │   │           │   │   └── closing_loc: (55,13)-(55,14) = "}"
        │   │           │   └── operator_loc: (55,10)-(55,12) = "**"
        │   │           └── @ AssocSplatNode (location: (55,16)-(55,20))
        │   │               ├── flags: ∅
        │   │               ├── value:
        │   │               │   @ CallNode (location: (55,18)-(55,20))
        │   │               │   ├── flags: variable_call, ignore_visibility
        │   │               │   ├── receiver: ∅
        │   │               │   ├── call_operator_loc: ∅
        │   │               │   ├── name: :kw
        │   │               │   ├── message_loc: (55,18)-(55,20) = "kw"
        │   │               │   ├── opening_loc: ∅
        │   │               │   ├── arguments: ∅
        │   │               │   ├── closing_loc: ∅
        │   │               │   └── block: ∅
        │   │               └── operator_loc: (55,16)-(55,18) = "**"
        │   ├── opening_loc: (55,0)-(55,1) = "["
        │   └── closing_loc: (55,20)-(55,21) = "]"
        ├── @ ArrayNode (location: (57,0)-(59,1))
        │   ├── flags: newline
        │   ├── elements: (length: 1)
        │   │   └── @ KeywordHashNode (location: (58,2)-(58,12))
        │   │       ├── flags: ∅
        │   │       └── elements: (length: 1)
        │   │           └── @ AssocNode (location: (58,2)-(58,12))
        │   │               ├── flags: ∅
        │   │               ├── key:
        │   │               │   @ CallNode (location: (58,2)-(58,5))
        │   │               │   ├── flags: variable_call, ignore_visibility
        │   │               │   ├── receiver: ∅
        │   │               │   ├── call_operator_loc: ∅
        │   │               │   ├── name: :foo
        │   │               │   ├── message_loc: (58,2)-(58,5) = "foo"
        │   │               │   ├── opening_loc: ∅
        │   │               │   ├── arguments: ∅
        │   │               │   ├── closing_loc: ∅
        │   │               │   └── block: ∅
        │   │               ├── value:
        │   │               │   @ CallNode (location: (58,9)-(58,12))
        │   │               │   ├── flags: variable_call, ignore_visibility
        │   │               │   ├── receiver: ∅
        │   │               │   ├── call_operator_loc: ∅
        │   │               │   ├── name: :bar
        │   │               │   ├── message_loc: (58,9)-(58,12) = "bar"
        │   │               │   ├── opening_loc: ∅
        │   │               │   ├── arguments: ∅
        │   │               │   ├── closing_loc: ∅
        │   │               │   └── block: ∅
        │   │               └── operator_loc: (58,6)-(58,8) = "=>"
        │   ├── opening_loc: (57,0)-(57,1) = "["
        │   └── closing_loc: (59,0)-(59,1) = "]"
        ├── @ ArrayNode (location: (62,0)-(62,17))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 3)
        │   │   ├── @ SymbolNode (location: (62,3)-(62,6))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── value_loc: (62,3)-(62,6) = "one"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "one"
        │   │   ├── @ SymbolNode (location: (62,7)-(62,10))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── value_loc: (62,7)-(62,10) = "two"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "two"
        │   │   └── @ SymbolNode (location: (62,11)-(62,16))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: ∅
        │   │       ├── value_loc: (62,11)-(62,16) = "three"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "three"
        │   ├── opening_loc: (62,0)-(62,3) = "%i#"
        │   └── closing_loc: (62,16)-(62,17) = "#"
        ├── @ ArrayNode (location: (64,0)-(64,17))
        │   ├── flags: newline
        │   ├── elements: (length: 3)
        │   │   ├── @ StringNode (location: (64,3)-(64,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (64,3)-(64,6) = "one"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "one"
        │   │   ├── @ StringNode (location: (64,7)-(64,10))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (64,7)-(64,10) = "two"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "two"
        │   │   └── @ StringNode (location: (64,11)-(64,16))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (64,11)-(64,16) = "three"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "three"
        │   ├── opening_loc: (64,0)-(64,3) = "%w#"
        │   └── closing_loc: (64,16)-(64,17) = "#"
        ├── @ XStringNode (location: (66,0)-(66,17))
        │   ├── flags: newline
        │   ├── opening_loc: (66,0)-(66,3) = "%x#"
        │   ├── content_loc: (66,3)-(66,16) = "one two three"
        │   ├── closing_loc: (66,16)-(66,17) = "#"
        │   └── unescaped: "one two three"
        ├── @ ArrayNode (location: (69,0)-(69,17))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 3)
        │   │   ├── @ SymbolNode (location: (69,3)-(69,6))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── value_loc: (69,3)-(69,6) = "one"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "one"
        │   │   ├── @ SymbolNode (location: (69,7)-(69,10))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── value_loc: (69,7)-(69,10) = "two"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "two"
        │   │   └── @ SymbolNode (location: (69,11)-(69,16))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: ∅
        │   │       ├── value_loc: (69,11)-(69,16) = "three"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "three"
        │   ├── opening_loc: (69,0)-(69,3) = "%i@"
        │   └── closing_loc: (69,16)-(69,17) = "@"
        ├── @ ArrayNode (location: (71,0)-(71,17))
        │   ├── flags: newline
        │   ├── elements: (length: 3)
        │   │   ├── @ StringNode (location: (71,3)-(71,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (71,3)-(71,6) = "one"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "one"
        │   │   ├── @ StringNode (location: (71,7)-(71,10))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (71,7)-(71,10) = "two"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "two"
        │   │   └── @ StringNode (location: (71,11)-(71,16))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (71,11)-(71,16) = "three"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "three"
        │   ├── opening_loc: (71,0)-(71,3) = "%w@"
        │   └── closing_loc: (71,16)-(71,17) = "@"
        ├── @ XStringNode (location: (73,0)-(73,17))
        │   ├── flags: newline
        │   ├── opening_loc: (73,0)-(73,3) = "%x@"
        │   ├── content_loc: (73,3)-(73,16) = "one two three"
        │   ├── closing_loc: (73,16)-(73,17) = "@"
        │   └── unescaped: "one two three"
        ├── @ ArrayNode (location: (76,0)-(76,17))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 3)
        │   │   ├── @ SymbolNode (location: (76,3)-(76,6))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── value_loc: (76,3)-(76,6) = "one"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "one"
        │   │   ├── @ SymbolNode (location: (76,7)-(76,10))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── value_loc: (76,7)-(76,10) = "two"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "two"
        │   │   └── @ SymbolNode (location: (76,11)-(76,16))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: ∅
        │   │       ├── value_loc: (76,11)-(76,16) = "three"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "three"
        │   ├── opening_loc: (76,0)-(76,3) = "%i{"
        │   └── closing_loc: (76,16)-(76,17) = "}"
        ├── @ ArrayNode (location: (78,0)-(78,17))
        │   ├── flags: newline
        │   ├── elements: (length: 3)
        │   │   ├── @ StringNode (location: (78,3)-(78,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (78,3)-(78,6) = "one"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "one"
        │   │   ├── @ StringNode (location: (78,7)-(78,10))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (78,7)-(78,10) = "two"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "two"
        │   │   └── @ StringNode (location: (78,11)-(78,16))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (78,11)-(78,16) = "three"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "three"
        │   ├── opening_loc: (78,0)-(78,3) = "%w{"
        │   └── closing_loc: (78,16)-(78,17) = "}"
        ├── @ XStringNode (location: (80,0)-(80,17))
        │   ├── flags: newline
        │   ├── opening_loc: (80,0)-(80,3) = "%x{"
        │   ├── content_loc: (80,3)-(80,16) = "one two three"
        │   ├── closing_loc: (80,16)-(80,17) = "}"
        │   └── unescaped: "one two three"
        ├── @ ArrayNode (location: (82,0)-(82,7))
        │   ├── flags: newline
        │   ├── elements: (length: 1)
        │   │   └── @ StringNode (location: (82,3)-(82,6))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (82,3)-(82,6) = "\\C:"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\\C:"
        │   ├── opening_loc: (82,0)-(82,3) = "%w["
        │   └── closing_loc: (82,6)-(82,7) = "]"
        ├── @ IndexOperatorWriteNode (location: (84,0)-(84,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (84,0)-(84,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (84,0)-(84,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (84,3)-(84,4) = "["
        │   ├── arguments: ∅
        │   ├── closing_loc: (84,4)-(84,5) = "]"
        │   ├── block: ∅
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (84,6)-(84,8) = "+="
        │   └── value:
        │       @ IntegerNode (location: (84,9)-(84,10))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ IndexOrWriteNode (location: (86,0)-(86,11))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (86,0)-(86,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (86,0)-(86,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (86,3)-(86,4) = "["
        │   ├── arguments: ∅
        │   ├── closing_loc: (86,4)-(86,5) = "]"
        │   ├── block: ∅
        │   ├── operator_loc: (86,6)-(86,9) = "||="
        │   └── value:
        │       @ IntegerNode (location: (86,10)-(86,11))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ IndexAndWriteNode (location: (88,0)-(88,11))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (88,0)-(88,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (88,0)-(88,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (88,3)-(88,4) = "["
        │   ├── arguments: ∅
        │   ├── closing_loc: (88,4)-(88,5) = "]"
        │   ├── block: ∅
        │   ├── operator_loc: (88,6)-(88,9) = "&&="
        │   └── value:
        │       @ IntegerNode (location: (88,10)-(88,11))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ IndexOperatorWriteNode (location: (90,0)-(90,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (90,0)-(90,7))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (90,0)-(90,3))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (90,0)-(90,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: (90,3)-(90,4) = "."
        │   │   ├── name: :foo
        │   │   ├── message_loc: (90,4)-(90,7) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (90,7)-(90,8) = "["
        │   ├── arguments: ∅
        │   ├── closing_loc: (90,8)-(90,9) = "]"
        │   ├── block: ∅
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (90,10)-(90,12) = "+="
        │   └── value:
        │       @ IntegerNode (location: (90,13)-(90,14))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ IndexOrWriteNode (location: (92,0)-(92,15))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (92,0)-(92,7))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (92,0)-(92,3))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (92,0)-(92,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: (92,3)-(92,4) = "."
        │   │   ├── name: :foo
        │   │   ├── message_loc: (92,4)-(92,7) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (92,7)-(92,8) = "["
        │   ├── arguments: ∅
        │   ├── closing_loc: (92,8)-(92,9) = "]"
        │   ├── block: ∅
        │   ├── operator_loc: (92,10)-(92,13) = "||="
        │   └── value:
        │       @ IntegerNode (location: (92,14)-(92,15))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ IndexAndWriteNode (location: (94,0)-(94,15))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (94,0)-(94,7))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (94,0)-(94,3))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (94,0)-(94,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: (94,3)-(94,4) = "."
        │   │   ├── name: :foo
        │   │   ├── message_loc: (94,4)-(94,7) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (94,7)-(94,8) = "["
        │   ├── arguments: ∅
        │   ├── closing_loc: (94,8)-(94,9) = "]"
        │   ├── block: ∅
        │   ├── operator_loc: (94,10)-(94,13) = "&&="
        │   └── value:
        │       @ IntegerNode (location: (94,14)-(94,15))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ IndexOperatorWriteNode (location: (96,0)-(96,13))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (96,0)-(96,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (96,0)-(96,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (96,3)-(96,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (96,4)-(96,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (96,4)-(96,7))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (96,4)-(96,7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (96,7)-(96,8) = "]"
        │   ├── block: ∅
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (96,9)-(96,11) = "+="
        │   └── value:
        │       @ IntegerNode (location: (96,12)-(96,13))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ IndexOrWriteNode (location: (98,0)-(98,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (98,0)-(98,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (98,0)-(98,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (98,3)-(98,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (98,4)-(98,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (98,4)-(98,7))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (98,4)-(98,7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (98,7)-(98,8) = "]"
        │   ├── block: ∅
        │   ├── operator_loc: (98,9)-(98,12) = "||="
        │   └── value:
        │       @ IntegerNode (location: (98,13)-(98,14))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ IndexAndWriteNode (location: (100,0)-(100,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (100,0)-(100,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (100,0)-(100,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (100,3)-(100,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (100,4)-(100,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (100,4)-(100,7))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (100,4)-(100,7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (100,7)-(100,8) = "]"
        │   ├── block: ∅
        │   ├── operator_loc: (100,9)-(100,12) = "&&="
        │   └── value:
        │       @ IntegerNode (location: (100,13)-(100,14))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ IndexOperatorWriteNode (location: (102,0)-(102,17))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (102,0)-(102,7))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (102,0)-(102,3))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (102,0)-(102,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: (102,3)-(102,4) = "."
        │   │   ├── name: :foo
        │   │   ├── message_loc: (102,4)-(102,7) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (102,7)-(102,8) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (102,8)-(102,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (102,8)-(102,11))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (102,8)-(102,11) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (102,11)-(102,12) = "]"
        │   ├── block: ∅
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (102,13)-(102,15) = "+="
        │   └── value:
        │       @ IntegerNode (location: (102,16)-(102,17))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ IndexOrWriteNode (location: (104,0)-(104,18))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (104,0)-(104,7))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (104,0)-(104,3))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (104,0)-(104,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: (104,3)-(104,4) = "."
        │   │   ├── name: :foo
        │   │   ├── message_loc: (104,4)-(104,7) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (104,7)-(104,8) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (104,8)-(104,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (104,8)-(104,11))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (104,8)-(104,11) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (104,11)-(104,12) = "]"
        │   ├── block: ∅
        │   ├── operator_loc: (104,13)-(104,16) = "||="
        │   └── value:
        │       @ IntegerNode (location: (104,17)-(104,18))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ IndexAndWriteNode (location: (106,0)-(106,18))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (106,0)-(106,7))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (106,0)-(106,3))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (106,0)-(106,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: (106,3)-(106,4) = "."
        │   │   ├── name: :foo
        │   │   ├── message_loc: (106,4)-(106,7) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (106,7)-(106,8) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (106,8)-(106,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (106,8)-(106,11))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (106,8)-(106,11) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (106,11)-(106,12) = "]"
        │   ├── block: ∅
        │   ├── operator_loc: (106,13)-(106,16) = "&&="
        │   └── value:
        │       @ IntegerNode (location: (106,17)-(106,18))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ DefNode (location: (108,0)-(108,19))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (108,4)-(108,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (108,6)-(108,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (108,6)-(108,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (108,6)-(108,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (108,10)-(108,14))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (108,10)-(108,14))
        │   │           ├── flags: newline
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (108,10)-(108,11))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :a
        │   │           │   ├── message_loc: (108,10)-(108,11) = "a"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :[]
        │   │           ├── message_loc: (108,11)-(108,14) = "[*]"
        │   │           ├── opening_loc: (108,11)-(108,12) = "["
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (108,12)-(108,13))
        │   │           │   ├── flags: contains_splat
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ SplatNode (location: (108,12)-(108,13))
        │   │           │           ├── flags: ∅
        │   │           │           ├── operator_loc: (108,12)-(108,13) = "*"
        │   │           │           └── expression: ∅
        │   │           ├── closing_loc: (108,13)-(108,14) = "]"
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (108,0)-(108,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (108,5)-(108,6) = "("
        │   ├── rparen_loc: (108,7)-(108,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (108,16)-(108,19) = "end"
        ├── @ DefNode (location: (110,0)-(110,22))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (110,4)-(110,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (110,6)-(110,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (110,6)-(110,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (110,6)-(110,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (110,10)-(110,17))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (110,10)-(110,17))
        │   │           ├── flags: newline
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (110,10)-(110,11))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :a
        │   │           │   ├── message_loc: (110,10)-(110,11) = "a"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :[]
        │   │           ├── message_loc: (110,11)-(110,17) = "[1, *]"
        │   │           ├── opening_loc: (110,11)-(110,12) = "["
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (110,12)-(110,16))
        │   │           │   ├── flags: contains_splat
        │   │           │   └── arguments: (length: 2)
        │   │           │       ├── @ IntegerNode (location: (110,12)-(110,13))
        │   │           │       │   ├── flags: static_literal, decimal
        │   │           │       │   └── value: 1
        │   │           │       └── @ SplatNode (location: (110,15)-(110,16))
        │   │           │           ├── flags: ∅
        │   │           │           ├── operator_loc: (110,15)-(110,16) = "*"
        │   │           │           └── expression: ∅
        │   │           ├── closing_loc: (110,16)-(110,17) = "]"
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (110,0)-(110,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (110,5)-(110,6) = "("
        │   ├── rparen_loc: (110,7)-(110,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (110,19)-(110,22) = "end"
        ├── @ DefNode (location: (112,0)-(112,23))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (112,4)-(112,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (112,6)-(112,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (112,6)-(112,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (112,6)-(112,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (112,10)-(112,18))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (112,10)-(112,18))
        │   │           ├── flags: newline, attribute_write
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (112,10)-(112,11))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :a
        │   │           │   ├── message_loc: (112,10)-(112,11) = "a"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :[]=
        │   │           ├── message_loc: (112,11)-(112,14) = "[*]"
        │   │           ├── opening_loc: (112,11)-(112,12) = "["
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (112,12)-(112,18))
        │   │           │   ├── flags: contains_splat
        │   │           │   └── arguments: (length: 2)
        │   │           │       ├── @ SplatNode (location: (112,12)-(112,13))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── operator_loc: (112,12)-(112,13) = "*"
        │   │           │       │   └── expression: ∅
        │   │           │       └── @ IntegerNode (location: (112,17)-(112,18))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── closing_loc: (112,13)-(112,14) = "]"
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (112,0)-(112,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (112,5)-(112,6) = "("
        │   ├── rparen_loc: (112,7)-(112,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (112,20)-(112,23) = "end"
        ├── @ DefNode (location: (114,0)-(114,26))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (114,4)-(114,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (114,6)-(114,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (114,6)-(114,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (114,6)-(114,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (114,10)-(114,21))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (114,10)-(114,21))
        │   │           ├── flags: newline, attribute_write
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (114,10)-(114,11))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :a
        │   │           │   ├── message_loc: (114,10)-(114,11) = "a"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :[]=
        │   │           ├── message_loc: (114,11)-(114,17) = "[1, *]"
        │   │           ├── opening_loc: (114,11)-(114,12) = "["
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (114,12)-(114,21))
        │   │           │   ├── flags: contains_splat
        │   │           │   └── arguments: (length: 3)
        │   │           │       ├── @ IntegerNode (location: (114,12)-(114,13))
        │   │           │       │   ├── flags: static_literal, decimal
        │   │           │       │   └── value: 1
        │   │           │       ├── @ SplatNode (location: (114,15)-(114,16))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── operator_loc: (114,15)-(114,16) = "*"
        │   │           │       │   └── expression: ∅
        │   │           │       └── @ IntegerNode (location: (114,20)-(114,21))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── closing_loc: (114,16)-(114,17) = "]"
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (114,0)-(114,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (114,5)-(114,6) = "("
        │   ├── rparen_loc: (114,7)-(114,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (114,23)-(114,26) = "end"
        ├── @ DefNode (location: (116,0)-(116,24))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (116,4)-(116,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (116,6)-(116,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (116,6)-(116,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (116,6)-(116,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (116,10)-(116,19))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IndexOperatorWriteNode (location: (116,10)-(116,19))
        │   │           ├── flags: newline
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (116,10)-(116,11))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :a
        │   │           │   ├── message_loc: (116,10)-(116,11) = "a"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── opening_loc: (116,11)-(116,12) = "["
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (116,12)-(116,13))
        │   │           │   ├── flags: contains_splat
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ SplatNode (location: (116,12)-(116,13))
        │   │           │           ├── flags: ∅
        │   │           │           ├── operator_loc: (116,12)-(116,13) = "*"
        │   │           │           └── expression: ∅
        │   │           ├── closing_loc: (116,13)-(116,14) = "]"
        │   │           ├── block: ∅
        │   │           ├── binary_operator: :+
        │   │           ├── binary_operator_loc: (116,15)-(116,17) = "+="
        │   │           └── value:
        │   │               @ IntegerNode (location: (116,18)-(116,19))
        │   │               ├── flags: static_literal, decimal
        │   │               └── value: 1
        │   ├── locals: []
        │   ├── def_keyword_loc: (116,0)-(116,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (116,5)-(116,6) = "("
        │   ├── rparen_loc: (116,7)-(116,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (116,21)-(116,24) = "end"
        ├── @ DefNode (location: (118,0)-(118,28))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (118,4)-(118,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (118,6)-(118,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (118,6)-(118,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (118,6)-(118,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (118,10)-(118,23))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IndexAndWriteNode (location: (118,10)-(118,23))
        │   │           ├── flags: newline
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (118,10)-(118,11))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :a
        │   │           │   ├── message_loc: (118,10)-(118,11) = "a"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── opening_loc: (118,11)-(118,12) = "["
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (118,12)-(118,16))
        │   │           │   ├── flags: contains_splat
        │   │           │   └── arguments: (length: 2)
        │   │           │       ├── @ IntegerNode (location: (118,12)-(118,13))
        │   │           │       │   ├── flags: static_literal, decimal
        │   │           │       │   └── value: 1
        │   │           │       └── @ SplatNode (location: (118,15)-(118,16))
        │   │           │           ├── flags: ∅
        │   │           │           ├── operator_loc: (118,15)-(118,16) = "*"
        │   │           │           └── expression: ∅
        │   │           ├── closing_loc: (118,16)-(118,17) = "]"
        │   │           ├── block: ∅
        │   │           ├── operator_loc: (118,18)-(118,21) = "&&="
        │   │           └── value:
        │   │               @ IntegerNode (location: (118,22)-(118,23))
        │   │               ├── flags: static_literal, decimal
        │   │               └── value: 1
        │   ├── locals: []
        │   ├── def_keyword_loc: (118,0)-(118,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (118,5)-(118,6) = "("
        │   ├── rparen_loc: (118,7)-(118,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (118,25)-(118,28) = "end"
        ├── @ DefNode (location: (120,0)-(120,29))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (120,4)-(120,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (120,6)-(120,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (120,6)-(120,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (120,6)-(120,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (120,0)-(120,29))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (120,10)-(120,24))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (120,10)-(120,16) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: (120,17)-(120,19) = "=>"
        │   │   │   ├── reference:
        │   │   │   │   @ IndexTargetNode (location: (120,20)-(120,24))
        │   │   │   │   ├── flags: attribute_write
        │   │   │   │   ├── receiver:
        │   │   │   │   │   @ CallNode (location: (120,20)-(120,21))
        │   │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   │   ├── receiver: ∅
        │   │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   │   ├── name: :a
        │   │   │   │   │   ├── message_loc: (120,20)-(120,21) = "a"
        │   │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   │   ├── arguments: ∅
        │   │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   │   └── block: ∅
        │   │   │   │   ├── opening_loc: (120,21)-(120,22) = "["
        │   │   │   │   ├── arguments:
        │   │   │   │   │   @ ArgumentsNode (location: (120,22)-(120,23))
        │   │   │   │   │   ├── flags: contains_splat
        │   │   │   │   │   └── arguments: (length: 1)
        │   │   │   │   │       └── @ SplatNode (location: (120,22)-(120,23))
        │   │   │   │   │           ├── flags: ∅
        │   │   │   │   │           ├── operator_loc: (120,22)-(120,23) = "*"
        │   │   │   │   │           └── expression: ∅
        │   │   │   │   ├── closing_loc: (120,23)-(120,24) = "]"
        │   │   │   │   └── block: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   ├── statements: ∅
        │   │   │   └── subsequent: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause: ∅
        │   │   └── end_keyword_loc: (120,26)-(120,29) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (120,0)-(120,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (120,5)-(120,6) = "("
        │   ├── rparen_loc: (120,7)-(120,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (120,26)-(120,29) = "end"
        └── @ DefNode (location: (122,0)-(122,32))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (122,4)-(122,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (122,6)-(122,7))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest:
            │   │   @ RestParameterNode (location: (122,6)-(122,7))
            │   │   ├── flags: ∅
            │   │   ├── name: ∅
            │   │   ├── name_loc: ∅
            │   │   └── operator_loc: (122,6)-(122,7) = "*"
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body:
            │   @ BeginNode (location: (122,0)-(122,32))
            │   ├── flags: ∅
            │   ├── begin_keyword_loc: ∅
            │   ├── statements: ∅
            │   ├── rescue_clause:
            │   │   @ RescueNode (location: (122,10)-(122,27))
            │   │   ├── flags: ∅
            │   │   ├── keyword_loc: (122,10)-(122,16) = "rescue"
            │   │   ├── exceptions: (length: 0)
            │   │   ├── operator_loc: (122,17)-(122,19) = "=>"
            │   │   ├── reference:
            │   │   │   @ IndexTargetNode (location: (122,20)-(122,27))
            │   │   │   ├── flags: attribute_write
            │   │   │   ├── receiver:
            │   │   │   │   @ CallNode (location: (122,20)-(122,21))
            │   │   │   │   ├── flags: variable_call, ignore_visibility
            │   │   │   │   ├── receiver: ∅
            │   │   │   │   ├── call_operator_loc: ∅
            │   │   │   │   ├── name: :a
            │   │   │   │   ├── message_loc: (122,20)-(122,21) = "a"
            │   │   │   │   ├── opening_loc: ∅
            │   │   │   │   ├── arguments: ∅
            │   │   │   │   ├── closing_loc: ∅
            │   │   │   │   └── block: ∅
            │   │   │   ├── opening_loc: (122,21)-(122,22) = "["
            │   │   │   ├── arguments:
            │   │   │   │   @ ArgumentsNode (location: (122,22)-(122,26))
            │   │   │   │   ├── flags: contains_splat
            │   │   │   │   └── arguments: (length: 2)
            │   │   │   │       ├── @ IntegerNode (location: (122,22)-(122,23))
            │   │   │   │       │   ├── flags: static_literal, decimal
            │   │   │   │       │   └── value: 1
            │   │   │   │       └── @ SplatNode (location: (122,25)-(122,26))
            │   │   │   │           ├── flags: ∅
            │   │   │   │           ├── operator_loc: (122,25)-(122,26) = "*"
            │   │   │   │           └── expression: ∅
            │   │   │   ├── closing_loc: (122,26)-(122,27) = "]"
            │   │   │   └── block: ∅
            │   │   ├── then_keyword_loc: ∅
            │   │   ├── statements: ∅
            │   │   └── subsequent: ∅
            │   ├── else_clause: ∅
            │   ├── ensure_clause: ∅
            │   └── end_keyword_loc: (122,29)-(122,32) = "end"
            ├── locals: []
            ├── def_keyword_loc: (122,0)-(122,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (122,5)-(122,6) = "("
            ├── rparen_loc: (122,7)-(122,8) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (122,29)-(122,32) = "end"
prism-1.5.1/snapshots/begin_ensure.txt000066400000000000000000000523771506127434000201200ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(21,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(21,15))
    ├── flags: ∅
    └── body: (length: 5)
        ├── @ BeginNode (location: (1,0)-(5,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (2,0)-(2,1))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (2,0)-(2,1))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (2,0)-(2,1) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause:
        │   │   @ EnsureNode (location: (3,0)-(5,3))
        │   │   ├── flags: ∅
        │   │   ├── ensure_keyword_loc: (3,0)-(3,6) = "ensure"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (4,0)-(4,1))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (4,0)-(4,1))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (4,0)-(4,1) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── end_keyword_loc: (5,0)-(5,3) = "end"
        │   └── end_keyword_loc: (5,0)-(5,3) = "end"
        ├── @ BeginNode (location: (7,0)-(7,24))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (7,0)-(7,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (7,7)-(7,8))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (7,7)-(7,8))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (7,7)-(7,8) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause:
        │   │   @ EnsureNode (location: (7,10)-(7,24))
        │   │   ├── flags: ∅
        │   │   ├── ensure_keyword_loc: (7,10)-(7,16) = "ensure"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (7,18)-(7,19))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (7,18)-(7,19))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (7,18)-(7,19) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── end_keyword_loc: (7,21)-(7,24) = "end"
        │   └── end_keyword_loc: (7,21)-(7,24) = "end"
        ├── @ BeginNode (location: (9,0)-(11,4))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (9,0)-(9,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (9,6)-(9,7))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (9,6)-(9,7))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (9,6)-(9,7) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause:
        │   │   @ EnsureNode (location: (10,1)-(11,4))
        │   │   ├── flags: ∅
        │   │   ├── ensure_keyword_loc: (10,1)-(10,7) = "ensure"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (10,8)-(10,9))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (10,8)-(10,9))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (10,8)-(10,9) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── end_keyword_loc: (11,1)-(11,4) = "end"
        │   └── end_keyword_loc: (11,1)-(11,4) = "end"
        ├── @ BeginNode (location: (13,0)-(13,22))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (13,0)-(13,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (13,6)-(13,7))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (13,6)-(13,7))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (13,6)-(13,7) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause:
        │   │   @ EnsureNode (location: (13,9)-(13,22))
        │   │   ├── flags: ∅
        │   │   ├── ensure_keyword_loc: (13,9)-(13,15) = "ensure"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (13,16)-(13,17))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (13,16)-(13,17))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (13,16)-(13,17) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── end_keyword_loc: (13,19)-(13,22) = "end"
        │   └── end_keyword_loc: (13,19)-(13,22) = "end"
        └── @ BeginNode (location: (15,0)-(21,15))
            ├── flags: newline
            ├── begin_keyword_loc: (15,0)-(15,5) = "begin"
            ├── statements:
            │   @ StatementsNode (location: (15,6)-(21,11))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ BeginNode (location: (15,6)-(21,11))
            │           ├── flags: newline
            │           ├── begin_keyword_loc: (15,6)-(15,11) = "begin"
            │           ├── statements:
            │           │   @ StatementsNode (location: (15,11)-(21,7))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ CallNode (location: (15,11)-(21,7))
            │           │           ├── flags: newline
            │           │           ├── receiver:
            │           │           │   @ SymbolNode (location: (15,11)-(15,13))
            │           │           │   ├── flags: static_literal, forced_us_ascii_encoding
            │           │           │   ├── opening_loc: (15,11)-(15,12) = ":"
            │           │           │   ├── value_loc: (15,12)-(15,13) = "s"
            │           │           │   ├── closing_loc: ∅
            │           │           │   └── unescaped: "s"
            │           │           ├── call_operator_loc: (15,13)-(15,14) = "."
            │           │           ├── name: :l
            │           │           ├── message_loc: (15,14)-(15,15) = "l"
            │           │           ├── opening_loc: ∅
            │           │           ├── arguments:
            │           │           │   @ ArgumentsNode (location: (15,16)-(21,7))
            │           │           │   ├── flags: ∅
            │           │           │   └── arguments: (length: 1)
            │           │           │       └── @ BeginNode (location: (15,16)-(21,7))
            │           │           │           ├── flags: ∅
            │           │           │           ├── begin_keyword_loc: (15,16)-(15,21) = "begin"
            │           │           │           ├── statements: ∅
            │           │           │           ├── rescue_clause: ∅
            │           │           │           ├── else_clause: ∅
            │           │           │           ├── ensure_clause:
            │           │           │           │   @ EnsureNode (location: (15,22)-(21,7))
            │           │           │           │   ├── flags: ∅
            │           │           │           │   ├── ensure_keyword_loc: (15,22)-(15,28) = "ensure"
            │           │           │           │   ├── statements:
            │           │           │           │   │   @ StatementsNode (location: (15,29)-(21,3))
            │           │           │           │   │   ├── flags: ∅
            │           │           │           │   │   └── body: (length: 1)
            │           │           │           │   │       └── @ CallNode (location: (15,29)-(21,3))
            │           │           │           │   │           ├── flags: newline
            │           │           │           │   │           ├── receiver:
            │           │           │           │   │           │   @ ConstantReadNode (location: (15,29)-(15,35))
            │           │           │           │   │           │   ├── flags: ∅
            │           │           │           │   │           │   └── name: :Module
            │           │           │           │   │           ├── call_operator_loc: (15,35)-(15,36) = "."
            │           │           │           │   │           ├── name: :new
            │           │           │           │   │           ├── message_loc: (15,36)-(15,39) = "new"
            │           │           │           │   │           ├── opening_loc: ∅
            │           │           │           │   │           ├── arguments: ∅
            │           │           │           │   │           ├── closing_loc: ∅
            │           │           │           │   │           └── block:
            │           │           │           │   │               @ BlockNode (location: (15,40)-(21,3))
            │           │           │           │   │               ├── flags: ∅
            │           │           │           │   │               ├── locals: []
            │           │           │           │   │               ├── parameters: ∅
            │           │           │           │   │               ├── body:
            │           │           │           │   │               │   @ StatementsNode (location: (16,2)-(20,5))
            │           │           │           │   │               │   ├── flags: ∅
            │           │           │           │   │               │   └── body: (length: 1)
            │           │           │           │   │               │       └── @ BeginNode (location: (16,2)-(20,5))
            │           │           │           │   │               │           ├── flags: newline
            │           │           │           │   │               │           ├── begin_keyword_loc: (16,2)-(16,7) = "begin"
            │           │           │           │   │               │           ├── statements:
            │           │           │           │   │               │           │   @ StatementsNode (location: (17,4)-(17,9))
            │           │           │           │   │               │           │   ├── flags: ∅
            │           │           │           │   │               │           │   └── body: (length: 1)
            │           │           │           │   │               │           │       └── @ BreakNode (location: (17,4)-(17,9))
            │           │           │           │   │               │           │           ├── flags: newline
            │           │           │           │   │               │           │           ├── arguments: ∅
            │           │           │           │   │               │           │           └── keyword_loc: (17,4)-(17,9) = "break"
            │           │           │           │   │               │           ├── rescue_clause: ∅
            │           │           │           │   │               │           ├── else_clause: ∅
            │           │           │           │   │               │           ├── ensure_clause:
            │           │           │           │   │               │           │   @ EnsureNode (location: (18,4)-(20,5))
            │           │           │           │   │               │           │   ├── flags: ∅
            │           │           │           │   │               │           │   ├── ensure_keyword_loc: (18,4)-(18,10) = "ensure"
            │           │           │           │   │               │           │   ├── statements:
            │           │           │           │   │               │           │   │   @ StatementsNode (location: (18,11)-(19,7))
            │           │           │           │   │               │           │   │   ├── flags: ∅
            │           │           │           │   │               │           │   │   └── body: (length: 1)
            │           │           │           │   │               │           │   │       └── @ CallNode (location: (18,11)-(19,7))
            │           │           │           │   │               │           │   │           ├── flags: newline
            │           │           │           │   │               │           │   │           ├── receiver:
            │           │           │           │   │               │           │   │           │   @ ConstantReadNode (location: (18,11)-(18,17))
            │           │           │           │   │               │           │   │           │   ├── flags: ∅
            │           │           │           │   │               │           │   │           │   └── name: :Module
            │           │           │           │   │               │           │   │           ├── call_operator_loc: (18,17)-(18,18) = "."
            │           │           │           │   │               │           │   │           ├── name: :new
            │           │           │           │   │               │           │   │           ├── message_loc: (18,18)-(18,21) = "new"
            │           │           │           │   │               │           │   │           ├── opening_loc: ∅
            │           │           │           │   │               │           │   │           ├── arguments: ∅
            │           │           │           │   │               │           │   │           ├── closing_loc: ∅
            │           │           │           │   │               │           │   │           └── block:
            │           │           │           │   │               │           │   │               @ BlockNode (location: (18,22)-(19,7))
            │           │           │           │   │               │           │   │               ├── flags: ∅
            │           │           │           │   │               │           │   │               ├── locals: []
            │           │           │           │   │               │           │   │               ├── parameters: ∅
            │           │           │           │   │               │           │   │               ├── body: ∅
            │           │           │           │   │               │           │   │               ├── opening_loc: (18,22)-(18,24) = "do"
            │           │           │           │   │               │           │   │               └── closing_loc: (19,4)-(19,7) = "end"
            │           │           │           │   │               │           │   └── end_keyword_loc: (20,2)-(20,5) = "end"
            │           │           │           │   │               │           └── end_keyword_loc: (20,2)-(20,5) = "end"
            │           │           │           │   │               ├── opening_loc: (15,40)-(15,42) = "do"
            │           │           │           │   │               └── closing_loc: (21,0)-(21,3) = "end"
            │           │           │           │   └── end_keyword_loc: (21,4)-(21,7) = "end"
            │           │           │           └── end_keyword_loc: (21,4)-(21,7) = "end"
            │           │           ├── closing_loc: ∅
            │           │           └── block: ∅
            │           ├── rescue_clause: ∅
            │           ├── else_clause: ∅
            │           ├── ensure_clause: ∅
            │           └── end_keyword_loc: (21,8)-(21,11) = "end"
            ├── rescue_clause: ∅
            ├── else_clause: ∅
            ├── ensure_clause: ∅
            └── end_keyword_loc: (21,12)-(21,15) = "end"
prism-1.5.1/snapshots/begin_rescue.txt000066400000000000000000001374541506127434000201050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(84,3))
├── flags: ∅
├── locals: [:ex]
└── statements:
    @ StatementsNode (location: (1,0)-(84,3))
    ├── flags: ∅
    └── body: (length: 20)
        ├── @ BeginNode (location: (1,0)-(1,33))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (1,7)-(1,8))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (1,7)-(1,8))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (1,7)-(1,8) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (1,10)-(1,19))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (1,10)-(1,16) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (1,18)-(1,19))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (1,18)-(1,19))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (1,18)-(1,19) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause:
        │   │   @ ElseNode (location: (1,21)-(1,33))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (1,21)-(1,25) = "else"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (1,27)-(1,28))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (1,27)-(1,28))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :c
        │   │   │           ├── message_loc: (1,27)-(1,28) = "c"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── end_keyword_loc: (1,30)-(1,33) = "end"
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (1,30)-(1,33) = "end"
        ├── @ BeginNode (location: (3,0)-(3,44))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (3,0)-(3,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (3,7)-(3,8))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (3,7)-(3,8))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (3,7)-(3,8) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (3,10)-(3,19))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (3,10)-(3,16) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (3,18)-(3,19))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (3,18)-(3,19))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (3,18)-(3,19) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause:
        │   │   @ ElseNode (location: (3,21)-(3,36))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (3,21)-(3,25) = "else"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (3,27)-(3,28))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (3,27)-(3,28))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :c
        │   │   │           ├── message_loc: (3,27)-(3,28) = "c"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── end_keyword_loc: (3,30)-(3,36) = "ensure"
        │   ├── ensure_clause:
        │   │   @ EnsureNode (location: (3,30)-(3,44))
        │   │   ├── flags: ∅
        │   │   ├── ensure_keyword_loc: (3,30)-(3,36) = "ensure"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (3,38)-(3,39))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (3,38)-(3,39))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :d
        │   │   │           ├── message_loc: (3,38)-(3,39) = "d"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── end_keyword_loc: (3,41)-(3,44) = "end"
        │   └── end_keyword_loc: (3,41)-(3,44) = "end"
        ├── @ BeginNode (location: (5,0)-(5,19))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (5,0)-(5,5) = "begin"
        │   ├── statements: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (5,7)-(5,13))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (5,7)-(5,13) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (5,16)-(5,19) = "end"
        ├── @ BeginNode (location: (7,0)-(7,28))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (7,0)-(7,5) = "begin"
        │   ├── statements: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (7,7)-(7,13))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (7,7)-(7,13) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause:
        │   │   @ EnsureNode (location: (7,16)-(7,28))
        │   │   ├── flags: ∅
        │   │   ├── ensure_keyword_loc: (7,16)-(7,22) = "ensure"
        │   │   ├── statements: ∅
        │   │   └── end_keyword_loc: (7,25)-(7,28) = "end"
        │   └── end_keyword_loc: (7,25)-(7,28) = "end"
        ├── @ BeginNode (location: (9,0)-(9,26))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (9,0)-(9,5) = "begin"
        │   ├── statements: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (9,7)-(9,13))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (9,7)-(9,13) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause:
        │   │   @ ElseNode (location: (9,16)-(9,26))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (9,16)-(9,20) = "else"
        │   │   ├── statements: ∅
        │   │   └── end_keyword_loc: (9,23)-(9,26) = "end"
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (9,23)-(9,26) = "end"
        ├── @ BeginNode (location: (11,0)-(13,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (11,0)-(11,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (12,0)-(12,1))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (12,0)-(12,1))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (12,0)-(12,1) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (13,0)-(13,3) = "end"
        ├── @ BeginNode (location: (15,0)-(15,13))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (15,0)-(15,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (15,7)-(15,8))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (15,7)-(15,8))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (15,7)-(15,8) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (15,10)-(15,13) = "end"
        ├── @ BeginNode (location: (17,0)-(18,4))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (17,0)-(17,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (17,6)-(17,7))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (17,6)-(17,7))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (17,6)-(17,7) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (18,1)-(18,4) = "end"
        ├── @ BeginNode (location: (20,0)-(20,12))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (20,0)-(20,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (20,6)-(20,7))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (20,6)-(20,7))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (20,6)-(20,7) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (20,9)-(20,12) = "end"
        ├── @ BeginNode (location: (22,0)-(30,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (22,0)-(22,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (23,0)-(23,1))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (23,0)-(23,1))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (23,0)-(23,1) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (24,0)-(29,1))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (24,0)-(24,6) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (25,0)-(25,1))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (25,0)-(25,1))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (25,0)-(25,1) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent:
        │   │       @ RescueNode (location: (26,0)-(29,1))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (26,0)-(26,6) = "rescue"
        │   │       ├── exceptions: (length: 0)
        │   │       ├── operator_loc: ∅
        │   │       ├── reference: ∅
        │   │       ├── then_keyword_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (27,0)-(27,1))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (27,0)-(27,1))
        │   │       │           ├── flags: newline, variable_call, ignore_visibility
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :c
        │   │       │           ├── message_loc: (27,0)-(27,1) = "c"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments: ∅
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       └── subsequent:
        │   │           @ RescueNode (location: (28,0)-(29,1))
        │   │           ├── flags: ∅
        │   │           ├── keyword_loc: (28,0)-(28,6) = "rescue"
        │   │           ├── exceptions: (length: 0)
        │   │           ├── operator_loc: ∅
        │   │           ├── reference: ∅
        │   │           ├── then_keyword_loc: ∅
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (29,0)-(29,1))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (29,0)-(29,1))
        │   │           │           ├── flags: newline, variable_call, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :d
        │   │           │           ├── message_loc: (29,0)-(29,1) = "d"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (30,0)-(30,3) = "end"
        ├── @ BeginNode (location: (32,0)-(38,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (32,0)-(32,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (33,2)-(33,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (33,2)-(33,3))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (33,2)-(33,3) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (34,0)-(37,3))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (34,0)-(34,6) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ ConstantReadNode (location: (34,7)-(34,16))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :Exception
        │   │   ├── operator_loc: (34,17)-(34,19) = "=>"
        │   │   ├── reference:
        │   │   │   @ LocalVariableTargetNode (location: (34,20)-(34,22))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :ex
        │   │   │   └── depth: 0
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (35,2)-(35,3))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (35,2)-(35,3))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (35,2)-(35,3) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent:
        │   │       @ RescueNode (location: (36,0)-(37,3))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (36,0)-(36,6) = "rescue"
        │   │       ├── exceptions: (length: 2)
        │   │       │   ├── @ ConstantReadNode (location: (36,7)-(36,23))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :AnotherException
        │   │       │   └── @ ConstantReadNode (location: (36,25)-(36,41))
        │   │       │       ├── flags: ∅
        │   │       │       └── name: :OneMoreException
        │   │       ├── operator_loc: (36,42)-(36,44) = "=>"
        │   │       ├── reference:
        │   │       │   @ LocalVariableTargetNode (location: (36,45)-(36,47))
        │   │       │   ├── flags: ∅
        │   │       │   ├── name: :ex
        │   │       │   └── depth: 0
        │   │       ├── then_keyword_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (37,2)-(37,3))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (37,2)-(37,3))
        │   │       │           ├── flags: newline, variable_call, ignore_visibility
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :c
        │   │       │           ├── message_loc: (37,2)-(37,3) = "c"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments: ∅
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (38,0)-(38,3) = "end"
        ├── @ BeginNode (location: (40,0)-(46,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (40,0)-(40,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (41,2)-(41,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (41,2)-(41,3))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (41,2)-(41,3) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (42,0)-(43,3))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (42,0)-(42,6) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ ConstantReadNode (location: (42,7)-(42,16))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :Exception
        │   │   ├── operator_loc: (42,17)-(42,19) = "=>"
        │   │   ├── reference:
        │   │   │   @ LocalVariableTargetNode (location: (42,20)-(42,22))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :ex
        │   │   │   └── depth: 0
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (43,2)-(43,3))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (43,2)-(43,3))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (43,2)-(43,3) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause:
        │   │   @ EnsureNode (location: (44,0)-(46,3))
        │   │   ├── flags: ∅
        │   │   ├── ensure_keyword_loc: (44,0)-(44,6) = "ensure"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (45,2)-(45,3))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (45,2)-(45,3))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (45,2)-(45,3) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── end_keyword_loc: (46,0)-(46,3) = "end"
        │   └── end_keyword_loc: (46,0)-(46,3) = "end"
        ├── @ StringNode (location: (48,0)-(48,6))
        │   ├── flags: newline
        │   ├── opening_loc: (48,0)-(48,2) = "%!"
        │   ├── content_loc: (48,2)-(48,5) = "abc"
        │   ├── closing_loc: (48,5)-(48,6) = "!"
        │   └── unescaped: "abc"
        ├── @ BeginNode (location: (50,0)-(54,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (50,0)-(50,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (51,0)-(51,1))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (51,0)-(51,1))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (51,0)-(51,1) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (52,0)-(53,1))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (52,0)-(52,6) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (53,0)-(53,1))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (53,0)-(53,1))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (53,0)-(53,1) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (54,0)-(54,3) = "end"
        ├── @ BeginNode (location: (56,0)-(56,20))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (56,0)-(56,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (56,6)-(56,7))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (56,6)-(56,7))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (56,6)-(56,7) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (56,8)-(56,16))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (56,8)-(56,14) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (56,15)-(56,16))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (56,15)-(56,16))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (56,15)-(56,16) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (56,17)-(56,20) = "end"
        ├── @ BeginNode (location: (58,0)-(60,5))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (58,0)-(58,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (59,0)-(59,1))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (59,0)-(59,1))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (59,0)-(59,1) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (59,2)-(60,1))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (59,2)-(59,8) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (60,0)-(60,1))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (60,0)-(60,1))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (60,0)-(60,1) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (60,2)-(60,5) = "end"
        ├── @ BeginNode (location: (62,0)-(66,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (62,0)-(62,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (63,0)-(63,1))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (63,0)-(63,1))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (63,0)-(63,1) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (64,0)-(65,1))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (64,0)-(64,6) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ ConstantReadNode (location: (64,7)-(64,16))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :Exception
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (65,0)-(65,1))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (65,0)-(65,1))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (65,0)-(65,1) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (66,0)-(66,3) = "end"
        ├── @ BeginNode (location: (68,0)-(72,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (68,0)-(68,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (69,0)-(69,1))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (69,0)-(69,1))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (69,0)-(69,1) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (70,0)-(71,1))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (70,0)-(70,6) = "rescue"
        │   │   ├── exceptions: (length: 2)
        │   │   │   ├── @ ConstantReadNode (location: (70,7)-(70,16))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :Exception
        │   │   │   └── @ ConstantReadNode (location: (70,18)-(70,33))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :CustomException
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (71,0)-(71,1))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (71,0)-(71,1))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (71,0)-(71,1) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (72,0)-(72,3) = "end"
        ├── @ BeginNode (location: (74,0)-(78,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (74,0)-(74,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (75,2)-(75,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (75,2)-(75,3))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (75,2)-(75,3) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (76,0)-(77,3))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (76,0)-(76,6) = "rescue"
        │   │   ├── exceptions: (length: 2)
        │   │   │   ├── @ ConstantReadNode (location: (76,7)-(76,16))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :Exception
        │   │   │   └── @ ConstantReadNode (location: (76,18)-(76,33))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :CustomException
        │   │   ├── operator_loc: (76,34)-(76,36) = "=>"
        │   │   ├── reference:
        │   │   │   @ LocalVariableTargetNode (location: (76,37)-(76,39))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :ex
        │   │   │   └── depth: 0
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (77,2)-(77,3))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (77,2)-(77,3))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (77,2)-(77,3) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (78,0)-(78,3) = "end"
        └── @ BeginNode (location: (80,0)-(84,3))
            ├── flags: newline
            ├── begin_keyword_loc: (80,0)-(80,5) = "begin"
            ├── statements:
            │   @ StatementsNode (location: (81,2)-(81,3))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (81,2)-(81,3))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :a
            │           ├── message_loc: (81,2)-(81,3) = "a"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── rescue_clause:
            │   @ RescueNode (location: (82,0)-(83,3))
            │   ├── flags: ∅
            │   ├── keyword_loc: (82,0)-(82,6) = "rescue"
            │   ├── exceptions: (length: 1)
            │   │   └── @ ConstantReadNode (location: (82,7)-(82,16))
            │   │       ├── flags: ∅
            │   │       └── name: :Exception
            │   ├── operator_loc: (82,17)-(82,19) = "=>"
            │   ├── reference:
            │   │   @ LocalVariableTargetNode (location: (82,20)-(82,22))
            │   │   ├── flags: ∅
            │   │   ├── name: :ex
            │   │   └── depth: 0
            │   ├── then_keyword_loc: ∅
            │   ├── statements:
            │   │   @ StatementsNode (location: (83,2)-(83,3))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (83,2)-(83,3))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :b
            │   │           ├── message_loc: (83,2)-(83,3) = "b"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── subsequent: ∅
            ├── else_clause: ∅
            ├── ensure_clause: ∅
            └── end_keyword_loc: (84,0)-(84,3) = "end"
prism-1.5.1/snapshots/blocks.txt000066400000000000000000001340601506127434000167160ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(54,17))
├── flags: ∅
├── locals: [:fork]
└── statements:
    @ StatementsNode (location: (1,0)-(54,17))
    ├── flags: ∅
    └── body: (length: 20)
        ├── @ CallNode (location: (1,0)-(1,16))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]
        │   ├── message_loc: (1,3)-(1,8) = "[bar]"
        │   ├── opening_loc: (1,3)-(1,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,4)-(1,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (1,4)-(1,7))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (1,4)-(1,7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (1,7)-(1,8) = "]"
        │   └── block:
        │       @ BlockNode (location: (1,9)-(1,16))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (1,11)-(1,14))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (1,11)-(1,14))
        │       │           ├── flags: newline, variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :baz
        │       │           ├── message_loc: (1,11)-(1,14) = "baz"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (1,9)-(1,10) = "{"
        │       └── closing_loc: (1,15)-(1,16) = "}"
        ├── @ CallNode (location: (3,0)-(5,3))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]
        │   ├── message_loc: (3,3)-(3,8) = "[bar]"
        │   ├── opening_loc: (3,3)-(3,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,4)-(3,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (3,4)-(3,7))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (3,4)-(3,7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (3,7)-(3,8) = "]"
        │   └── block:
        │       @ BlockNode (location: (3,9)-(5,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (4,0)-(4,3))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (4,0)-(4,3))
        │       │           ├── flags: newline, variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :baz
        │       │           ├── message_loc: (4,0)-(4,3) = "baz"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (3,9)-(3,11) = "do"
        │       └── closing_loc: (5,0)-(5,3) = "end"
        ├── @ CallNode (location: (7,0)-(7,35))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (7,0)-(7,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :x
        │   │   ├── message_loc: (7,0)-(7,1) = "x"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (7,1)-(7,2) = "."
        │   ├── name: :reduce
        │   ├── message_loc: (7,2)-(7,8) = "reduce"
        │   ├── opening_loc: (7,8)-(7,9) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (7,9)-(7,10))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (7,9)-(7,10))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 0
        │   ├── closing_loc: (7,10)-(7,11) = ")"
        │   └── block:
        │       @ BlockNode (location: (7,12)-(7,35))
        │       ├── flags: ∅
        │       ├── locals: [:x, :memo]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (7,14)-(7,23))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (7,15)-(7,22))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 2)
        │       │   │   │   ├── @ RequiredParameterNode (location: (7,15)-(7,16))
        │       │   │   │   │   ├── flags: ∅
        │       │   │   │   │   └── name: :x
        │       │   │   │   └── @ RequiredParameterNode (location: (7,18)-(7,22))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :memo
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (7,14)-(7,15) = "|"
        │       │   └── closing_loc: (7,22)-(7,23) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (7,24)-(7,33))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ LocalVariableOperatorWriteNode (location: (7,24)-(7,33))
        │       │           ├── flags: newline
        │       │           ├── name_loc: (7,24)-(7,28) = "memo"
        │       │           ├── binary_operator_loc: (7,29)-(7,31) = "+="
        │       │           ├── value:
        │       │           │   @ LocalVariableReadNode (location: (7,32)-(7,33))
        │       │           │   ├── flags: ∅
        │       │           │   ├── name: :x
        │       │           │   └── depth: 0
        │       │           ├── name: :memo
        │       │           ├── binary_operator: :+
        │       │           └── depth: 0
        │       ├── opening_loc: (7,12)-(7,13) = "{"
        │       └── closing_loc: (7,34)-(7,35) = "}"
        ├── @ CallNode (location: (9,0)-(9,10))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (9,0)-(9,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (9,4)-(9,10))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (9,4)-(9,6) = "do"
        │       └── closing_loc: (9,7)-(9,10) = "end"
        ├── @ CallNode (location: (11,0)-(11,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (11,0)-(11,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (11,4)-(11,21))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (11,4)-(11,7))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :bar
        │   │       │   ├── message_loc: (11,4)-(11,7) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ ParenthesesNode (location: (11,9)-(11,21))
        │   │           ├── flags: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (11,10)-(11,20))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (11,10)-(11,20))
        │   │           │           ├── flags: newline, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :baz
        │   │           │           ├── message_loc: (11,10)-(11,13) = "baz"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block:
        │   │           │               @ BlockNode (location: (11,14)-(11,20))
        │   │           │               ├── flags: ∅
        │   │           │               ├── locals: []
        │   │           │               ├── parameters: ∅
        │   │           │               ├── body: ∅
        │   │           │               ├── opening_loc: (11,14)-(11,16) = "do"
        │   │           │               └── closing_loc: (11,17)-(11,20) = "end"
        │   │           ├── opening_loc: (11,9)-(11,10) = "("
        │   │           └── closing_loc: (11,20)-(11,21) = ")"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (13,0)-(13,14))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (13,0)-(13,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (13,4)-(13,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (13,4)-(13,7))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (13,4)-(13,7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (13,8)-(13,14))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (13,8)-(13,10) = "do"
        │       └── closing_loc: (13,11)-(13,14) = "end"
        ├── @ CallNode (location: (15,0)-(15,18))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (15,0)-(15,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (15,4)-(15,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (15,4)-(15,11))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (15,4)-(15,7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (15,8)-(15,11))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ CallNode (location: (15,8)-(15,11))
        │   │           │           ├── flags: variable_call, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :baz
        │   │           │           ├── message_loc: (15,8)-(15,11) = "baz"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (15,12)-(15,18))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (15,12)-(15,14) = "do"
        │       └── closing_loc: (15,15)-(15,18) = "end"
        ├── @ CallNode (location: (17,0)-(18,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (17,0)-(17,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (17,4)-(18,3))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (17,7)-(17,17))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (17,8)-(17,16))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 1)
        │       │   │   │   └── @ OptionalParameterNode (location: (17,8)-(17,16))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :a
        │       │   │   │       ├── name_loc: (17,8)-(17,9) = "a"
        │       │   │   │       ├── operator_loc: (17,10)-(17,11) = "="
        │       │   │   │       └── value:
        │       │   │   │           @ CallNode (location: (17,12)-(17,16))
        │       │   │   │           ├── flags: ∅
        │       │   │   │           ├── receiver:
        │       │   │   │           │   @ CallNode (location: (17,12)-(17,13))
        │       │   │   │           │   ├── flags: variable_call, ignore_visibility
        │       │   │   │           │   ├── receiver: ∅
        │       │   │   │           │   ├── call_operator_loc: ∅
        │       │   │   │           │   ├── name: :b
        │       │   │   │           │   ├── message_loc: (17,12)-(17,13) = "b"
        │       │   │   │           │   ├── opening_loc: ∅
        │       │   │   │           │   ├── arguments: ∅
        │       │   │   │           │   ├── closing_loc: ∅
        │       │   │   │           │   └── block: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :[]
        │       │   │   │           ├── message_loc: (17,13)-(17,16) = "[1]"
        │       │   │   │           ├── opening_loc: (17,13)-(17,14) = "["
        │       │   │   │           ├── arguments:
        │       │   │   │           │   @ ArgumentsNode (location: (17,14)-(17,15))
        │       │   │   │           │   ├── flags: ∅
        │       │   │   │           │   └── arguments: (length: 1)
        │       │   │   │           │       └── @ IntegerNode (location: (17,14)-(17,15))
        │       │   │   │           │           ├── flags: static_literal, decimal
        │       │   │   │           │           └── value: 1
        │       │   │   │           ├── closing_loc: (17,15)-(17,16) = "]"
        │       │   │   │           └── block: ∅
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (17,7)-(17,8) = "|"
        │       │   └── closing_loc: (17,16)-(17,17) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (17,4)-(17,6) = "do"
        │       └── closing_loc: (18,0)-(18,3) = "end"
        ├── @ CallNode (location: (20,0)-(22,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (20,0)-(20,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (20,4)-(22,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (20,4)-(22,3))
        │       │   ├── flags: ∅
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (21,0)-(21,6))
        │       │   │   ├── flags: ∅
        │       │   │   ├── keyword_loc: (21,0)-(21,6) = "rescue"
        │       │   │   ├── exceptions: (length: 0)
        │       │   │   ├── operator_loc: ∅
        │       │   │   ├── reference: ∅
        │       │   │   ├── then_keyword_loc: ∅
        │       │   │   ├── statements: ∅
        │       │   │   └── subsequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (22,0)-(22,3) = "end"
        │       ├── opening_loc: (20,4)-(20,6) = "do"
        │       └── closing_loc: (22,0)-(22,3) = "end"
        ├── @ CallNode (location: (24,0)-(29,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (24,0)-(24,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (24,4)-(29,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (25,2)-(28,5))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (25,2)-(28,5))
        │       │           ├── flags: newline, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :bar
        │       │           ├── message_loc: (25,2)-(25,5) = "bar"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block:
        │       │               @ BlockNode (location: (25,6)-(28,5))
        │       │               ├── flags: ∅
        │       │               ├── locals: []
        │       │               ├── parameters: ∅
        │       │               ├── body:
        │       │               │   @ StatementsNode (location: (26,4)-(27,7))
        │       │               │   ├── flags: ∅
        │       │               │   └── body: (length: 1)
        │       │               │       └── @ CallNode (location: (26,4)-(27,7))
        │       │               │           ├── flags: newline, ignore_visibility
        │       │               │           ├── receiver: ∅
        │       │               │           ├── call_operator_loc: ∅
        │       │               │           ├── name: :baz
        │       │               │           ├── message_loc: (26,4)-(26,7) = "baz"
        │       │               │           ├── opening_loc: ∅
        │       │               │           ├── arguments: ∅
        │       │               │           ├── closing_loc: ∅
        │       │               │           └── block:
        │       │               │               @ BlockNode (location: (26,8)-(27,7))
        │       │               │               ├── flags: ∅
        │       │               │               ├── locals: []
        │       │               │               ├── parameters: ∅
        │       │               │               ├── body: ∅
        │       │               │               ├── opening_loc: (26,8)-(26,10) = "do"
        │       │               │               └── closing_loc: (27,4)-(27,7) = "end"
        │       │               ├── opening_loc: (25,6)-(25,8) = "do"
        │       │               └── closing_loc: (28,2)-(28,5) = "end"
        │       ├── opening_loc: (24,4)-(24,6) = "do"
        │       └── closing_loc: (29,0)-(29,3) = "end"
        ├── @ CallNode (location: (31,0)-(31,16))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (31,0)-(31,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (31,0)-(31,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]
        │   ├── message_loc: (31,3)-(31,8) = "[bar]"
        │   ├── opening_loc: (31,3)-(31,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (31,4)-(31,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (31,4)-(31,7))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (31,4)-(31,7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (31,7)-(31,8) = "]"
        │   └── block:
        │       @ BlockNode (location: (31,9)-(31,16))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (31,11)-(31,14))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (31,11)-(31,14))
        │       │           ├── flags: newline, variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :baz
        │       │           ├── message_loc: (31,11)-(31,14) = "baz"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (31,9)-(31,10) = "{"
        │       └── closing_loc: (31,15)-(31,16) = "}"
        ├── @ CallNode (location: (33,0)-(33,24))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (33,0)-(33,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (33,4)-(33,24))
        │       ├── flags: ∅
        │       ├── locals: [:x, :y, :z]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (33,6)-(33,20))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (33,7)-(33,19))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (33,7)-(33,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :x
        │       │   │   ├── optionals: (length: 1)
        │       │   │   │   └── @ OptionalParameterNode (location: (33,10)-(33,15))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :y
        │       │   │   │       ├── name_loc: (33,10)-(33,11) = "y"
        │       │   │   │       ├── operator_loc: (33,12)-(33,13) = "="
        │       │   │   │       └── value:
        │       │   │   │           @ IntegerNode (location: (33,14)-(33,15))
        │       │   │   │           ├── flags: static_literal, decimal
        │       │   │   │           └── value: 2
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 1)
        │       │   │   │   └── @ RequiredKeywordParameterNode (location: (33,17)-(33,19))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :z
        │       │   │   │       └── name_loc: (33,17)-(33,19) = "z:"
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (33,6)-(33,7) = "|"
        │       │   └── closing_loc: (33,19)-(33,20) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (33,21)-(33,22))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ LocalVariableReadNode (location: (33,21)-(33,22))
        │       │           ├── flags: newline
        │       │           ├── name: :x
        │       │           └── depth: 0
        │       ├── opening_loc: (33,4)-(33,5) = "{"
        │       └── closing_loc: (33,23)-(33,24) = "}"
        ├── @ CallNode (location: (35,0)-(35,11))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (35,0)-(35,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (35,4)-(35,11))
        │       ├── flags: ∅
        │       ├── locals: [:x]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (35,6)-(35,9))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (35,7)-(35,8))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (35,7)-(35,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :x
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (35,6)-(35,7) = "|"
        │       │   └── closing_loc: (35,8)-(35,9) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (35,4)-(35,5) = "{"
        │       └── closing_loc: (35,10)-(35,11) = "}"
        ├── @ LocalVariableWriteNode (location: (37,0)-(37,8))
        │   ├── flags: newline
        │   ├── name: :fork
        │   ├── depth: 0
        │   ├── name_loc: (37,0)-(37,4) = "fork"
        │   ├── value:
        │   │   @ IntegerNode (location: (37,7)-(37,8))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (37,5)-(37,6) = "="
        ├── @ CallNode (location: (38,0)-(39,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :fork
        │   ├── message_loc: (38,0)-(38,4) = "fork"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (38,5)-(39,3))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (38,8)-(38,11))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (38,9)-(38,10))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (38,9)-(38,10))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (38,8)-(38,9) = "|"
        │       │   └── closing_loc: (38,10)-(38,11) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (38,5)-(38,7) = "do"
        │       └── closing_loc: (39,0)-(39,3) = "end"
        ├── @ CallNode (location: (41,0)-(41,12))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :fork
        │   ├── message_loc: (41,0)-(41,4) = "fork"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (41,5)-(41,12))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (41,7)-(41,10))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (41,8)-(41,9))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (41,8)-(41,9))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (41,7)-(41,8) = "|"
        │       │   └── closing_loc: (41,9)-(41,10) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (41,5)-(41,6) = "{"
        │       └── closing_loc: (41,11)-(41,12) = "}"
        ├── @ CallNode (location: (43,0)-(44,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :C
        │   ├── message_loc: (43,0)-(43,1) = "C"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (43,2)-(44,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (43,2)-(43,4) = "do"
        │       └── closing_loc: (44,0)-(44,3) = "end"
        ├── @ CallNode (location: (46,0)-(46,4))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :C
        │   ├── message_loc: (46,0)-(46,1) = "C"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (46,2)-(46,4))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (46,2)-(46,3) = "{"
        │       └── closing_loc: (46,3)-(46,4) = "}"
        ├── @ CallNode (location: (48,0)-(52,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (48,0)-(48,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (48,4)-(52,1))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (48,4)-(52,1))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :lambda
        │   │           ├── message_loc: (48,4)-(48,10) = "lambda"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (48,11)-(52,1))
        │   │               ├── flags: ∅
        │   │               ├── locals: [:a, :b]
        │   │               ├── parameters:
        │   │               │   @ BlockParametersNode (location: (48,13)-(51,3))
        │   │               │   ├── flags: ∅
        │   │               │   ├── parameters:
        │   │               │   │   @ ParametersNode (location: (49,2)-(50,6))
        │   │               │   │   ├── flags: ∅
        │   │               │   │   ├── requireds: (length: 0)
        │   │               │   │   ├── optionals: (length: 0)
        │   │               │   │   ├── rest: ∅
        │   │               │   │   ├── posts: (length: 0)
        │   │               │   │   ├── keywords: (length: 2)
        │   │               │   │   │   ├── @ OptionalKeywordParameterNode (location: (49,2)-(49,6))
        │   │               │   │   │   │   ├── flags: ∅
        │   │               │   │   │   │   ├── name: :a
        │   │               │   │   │   │   ├── name_loc: (49,2)-(49,4) = "a:"
        │   │               │   │   │   │   └── value:
        │   │               │   │   │   │       @ IntegerNode (location: (49,5)-(49,6))
        │   │               │   │   │   │       ├── flags: static_literal, decimal
        │   │               │   │   │   │       └── value: 1
        │   │               │   │   │   └── @ OptionalKeywordParameterNode (location: (50,2)-(50,6))
        │   │               │   │   │       ├── flags: ∅
        │   │               │   │   │       ├── name: :b
        │   │               │   │   │       ├── name_loc: (50,2)-(50,4) = "b:"
        │   │               │   │   │       └── value:
        │   │               │   │   │           @ IntegerNode (location: (50,5)-(50,6))
        │   │               │   │   │           ├── flags: static_literal, decimal
        │   │               │   │   │           └── value: 2
        │   │               │   │   ├── keyword_rest: ∅
        │   │               │   │   └── block: ∅
        │   │               │   ├── locals: (length: 0)
        │   │               │   ├── opening_loc: (48,13)-(48,14) = "|"
        │   │               │   └── closing_loc: (51,2)-(51,3) = "|"
        │   │               ├── body: ∅
        │   │               ├── opening_loc: (48,11)-(48,12) = "{"
        │   │               └── closing_loc: (52,0)-(52,1) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (54,0)-(54,17))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :foo
            ├── message_loc: (54,0)-(54,3) = "foo"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (54,4)-(54,17))
                ├── flags: ∅
                ├── locals: [:bar]
                ├── parameters:
                │   @ BlockParametersNode (location: (54,7)-(54,13))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (54,8)-(54,12))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (54,8)-(54,11))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :bar
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest:
                │   │   │   @ ImplicitRestNode (location: (54,11)-(54,12))
                │   │   │   └── flags: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (54,7)-(54,8) = "|"
                │   └── closing_loc: (54,12)-(54,13) = "|"
                ├── body: ∅
                ├── opening_loc: (54,4)-(54,6) = "do"
                └── closing_loc: (54,14)-(54,17) = "end"
prism-1.5.1/snapshots/boolean_operators.txt000066400000000000000000000051721506127434000211570ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,7))
├── flags: ∅
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (1,0)-(5,7))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ LocalVariableAndWriteNode (location: (1,0)-(1,7))
        │   ├── flags: newline
        │   ├── name_loc: (1,0)-(1,1) = "a"
        │   ├── operator_loc: (1,2)-(1,5) = "&&="
        │   ├── value:
        │   │   @ CallNode (location: (1,6)-(1,7))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :b
        │   │   ├── message_loc: (1,6)-(1,7) = "b"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── name: :a
        │   └── depth: 0
        ├── @ LocalVariableOperatorWriteNode (location: (3,0)-(3,6))
        │   ├── flags: newline
        │   ├── name_loc: (3,0)-(3,1) = "a"
        │   ├── binary_operator_loc: (3,2)-(3,4) = "+="
        │   ├── value:
        │   │   @ CallNode (location: (3,5)-(3,6))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :b
        │   │   ├── message_loc: (3,5)-(3,6) = "b"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── name: :a
        │   ├── binary_operator: :+
        │   └── depth: 0
        └── @ LocalVariableOrWriteNode (location: (5,0)-(5,7))
            ├── flags: newline
            ├── name_loc: (5,0)-(5,1) = "a"
            ├── operator_loc: (5,2)-(5,5) = "||="
            ├── value:
            │   @ CallNode (location: (5,6)-(5,7))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :b
            │   ├── message_loc: (5,6)-(5,7) = "b"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── name: :a
            └── depth: 0
prism-1.5.1/snapshots/booleans.txt000066400000000000000000000006431506127434000172420ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,4))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ FalseNode (location: (1,0)-(1,5))
        │   └── flags: newline, static_literal
        └── @ TrueNode (location: (3,0)-(3,4))
            └── flags: newline, static_literal
prism-1.5.1/snapshots/break.txt000066400000000000000000001056151506127434000165310ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(33,21))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(33,21))
    ├── flags: ∅
    └── body: (length: 15)
        ├── @ CallNode (location: (1,0)-(1,13))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (1,0)-(1,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,4)-(1,13))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (1,6)-(1,11))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (1,6)-(1,11))
        │       │           ├── flags: newline
        │       │           ├── arguments: ∅
        │       │           └── keyword_loc: (1,6)-(1,11) = "break"
        │       ├── opening_loc: (1,4)-(1,5) = "{"
        │       └── closing_loc: (1,12)-(1,13) = "}"
        ├── @ CallNode (location: (3,0)-(3,27))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (3,0)-(3,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (3,4)-(3,27))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (3,6)-(3,25))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (3,6)-(3,25))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (3,12)-(3,25))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 3)
        │       │           │       ├── @ ParenthesesNode (location: (3,12)-(3,15))
        │       │           │       │   ├── flags: ∅
        │       │           │       │   ├── body:
        │       │           │       │   │   @ StatementsNode (location: (3,13)-(3,14))
        │       │           │       │   │   ├── flags: ∅
        │       │           │       │   │   └── body: (length: 1)
        │       │           │       │   │       └── @ IntegerNode (location: (3,13)-(3,14))
        │       │           │       │   │           ├── flags: newline, static_literal, decimal
        │       │           │       │   │           └── value: 1
        │       │           │       │   ├── opening_loc: (3,12)-(3,13) = "("
        │       │           │       │   └── closing_loc: (3,14)-(3,15) = ")"
        │       │           │       ├── @ ParenthesesNode (location: (3,17)-(3,20))
        │       │           │       │   ├── flags: ∅
        │       │           │       │   ├── body:
        │       │           │       │   │   @ StatementsNode (location: (3,18)-(3,19))
        │       │           │       │   │   ├── flags: ∅
        │       │           │       │   │   └── body: (length: 1)
        │       │           │       │   │       └── @ IntegerNode (location: (3,18)-(3,19))
        │       │           │       │   │           ├── flags: newline, static_literal, decimal
        │       │           │       │   │           └── value: 2
        │       │           │       │   ├── opening_loc: (3,17)-(3,18) = "("
        │       │           │       │   └── closing_loc: (3,19)-(3,20) = ")"
        │       │           │       └── @ ParenthesesNode (location: (3,22)-(3,25))
        │       │           │           ├── flags: ∅
        │       │           │           ├── body:
        │       │           │           │   @ StatementsNode (location: (3,23)-(3,24))
        │       │           │           │   ├── flags: ∅
        │       │           │           │   └── body: (length: 1)
        │       │           │           │       └── @ IntegerNode (location: (3,23)-(3,24))
        │       │           │           │           ├── flags: newline, static_literal, decimal
        │       │           │           │           └── value: 3
        │       │           │           ├── opening_loc: (3,22)-(3,23) = "("
        │       │           │           └── closing_loc: (3,24)-(3,25) = ")"
        │       │           └── keyword_loc: (3,6)-(3,11) = "break"
        │       ├── opening_loc: (3,4)-(3,5) = "{"
        │       └── closing_loc: (3,26)-(3,27) = "}"
        ├── @ CallNode (location: (5,0)-(5,15))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (5,0)-(5,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (5,4)-(5,15))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (5,6)-(5,13))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (5,6)-(5,13))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (5,12)-(5,13))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ IntegerNode (location: (5,12)-(5,13))
        │       │           │           ├── flags: static_literal, decimal
        │       │           │           └── value: 1
        │       │           └── keyword_loc: (5,6)-(5,11) = "break"
        │       ├── opening_loc: (5,4)-(5,5) = "{"
        │       └── closing_loc: (5,14)-(5,15) = "}"
        ├── @ CallNode (location: (7,0)-(8,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (7,0)-(7,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (7,4)-(8,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (7,6)-(8,1))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (7,6)-(8,1))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (7,12)-(8,1))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 3)
        │       │           │       ├── @ IntegerNode (location: (7,12)-(7,13))
        │       │           │       │   ├── flags: static_literal, decimal
        │       │           │       │   └── value: 1
        │       │           │       ├── @ IntegerNode (location: (7,15)-(7,16))
        │       │           │       │   ├── flags: static_literal, decimal
        │       │           │       │   └── value: 2
        │       │           │       └── @ IntegerNode (location: (8,0)-(8,1))
        │       │           │           ├── flags: static_literal, decimal
        │       │           │           └── value: 3
        │       │           └── keyword_loc: (7,6)-(7,11) = "break"
        │       ├── opening_loc: (7,4)-(7,5) = "{"
        │       └── closing_loc: (8,2)-(8,3) = "}"
        ├── @ CallNode (location: (10,0)-(10,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (10,0)-(10,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (10,4)-(10,21))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (10,6)-(10,19))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (10,6)-(10,19))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (10,12)-(10,19))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 3)
        │       │           │       ├── @ IntegerNode (location: (10,12)-(10,13))
        │       │           │       │   ├── flags: static_literal, decimal
        │       │           │       │   └── value: 1
        │       │           │       ├── @ IntegerNode (location: (10,15)-(10,16))
        │       │           │       │   ├── flags: static_literal, decimal
        │       │           │       │   └── value: 2
        │       │           │       └── @ IntegerNode (location: (10,18)-(10,19))
        │       │           │           ├── flags: static_literal, decimal
        │       │           │           └── value: 3
        │       │           └── keyword_loc: (10,6)-(10,11) = "break"
        │       ├── opening_loc: (10,4)-(10,5) = "{"
        │       └── closing_loc: (10,20)-(10,21) = "}"
        ├── @ CallNode (location: (12,0)-(12,23))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (12,0)-(12,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (12,4)-(12,23))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (12,6)-(12,21))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (12,6)-(12,21))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (12,12)-(12,21))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ ArrayNode (location: (12,12)-(12,21))
        │       │           │           ├── flags: static_literal
        │       │           │           ├── elements: (length: 3)
        │       │           │           │   ├── @ IntegerNode (location: (12,13)-(12,14))
        │       │           │           │   │   ├── flags: static_literal, decimal
        │       │           │           │   │   └── value: 1
        │       │           │           │   ├── @ IntegerNode (location: (12,16)-(12,17))
        │       │           │           │   │   ├── flags: static_literal, decimal
        │       │           │           │   │   └── value: 2
        │       │           │           │   └── @ IntegerNode (location: (12,19)-(12,20))
        │       │           │           │       ├── flags: static_literal, decimal
        │       │           │           │       └── value: 3
        │       │           │           ├── opening_loc: (12,12)-(12,13) = "["
        │       │           │           └── closing_loc: (12,20)-(12,21) = "]"
        │       │           └── keyword_loc: (12,6)-(12,11) = "break"
        │       ├── opening_loc: (12,4)-(12,5) = "{"
        │       └── closing_loc: (12,22)-(12,23) = "}"
        ├── @ CallNode (location: (14,0)-(17,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (14,0)-(14,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (14,4)-(17,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (14,6)-(17,1))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (14,6)-(17,1))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (14,11)-(17,1))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ ParenthesesNode (location: (14,11)-(17,1))
        │       │           │           ├── flags: multiple_statements
        │       │           │           ├── body:
        │       │           │           │   @ StatementsNode (location: (15,2)-(16,3))
        │       │           │           │   ├── flags: ∅
        │       │           │           │   └── body: (length: 2)
        │       │           │           │       ├── @ IntegerNode (location: (15,2)-(15,3))
        │       │           │           │       │   ├── flags: newline, static_literal, decimal
        │       │           │           │       │   └── value: 1
        │       │           │           │       └── @ IntegerNode (location: (16,2)-(16,3))
        │       │           │           │           ├── flags: newline, static_literal, decimal
        │       │           │           │           └── value: 2
        │       │           │           ├── opening_loc: (14,11)-(14,12) = "("
        │       │           │           └── closing_loc: (17,0)-(17,1) = ")"
        │       │           └── keyword_loc: (14,6)-(14,11) = "break"
        │       ├── opening_loc: (14,4)-(14,5) = "{"
        │       └── closing_loc: (17,2)-(17,3) = "}"
        ├── @ CallNode (location: (19,0)-(19,15))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (19,0)-(19,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (19,4)-(19,15))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (19,6)-(19,13))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (19,6)-(19,13))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (19,11)-(19,13))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ ParenthesesNode (location: (19,11)-(19,13))
        │       │           │           ├── flags: ∅
        │       │           │           ├── body: ∅
        │       │           │           ├── opening_loc: (19,11)-(19,12) = "("
        │       │           │           └── closing_loc: (19,12)-(19,13) = ")"
        │       │           └── keyword_loc: (19,6)-(19,11) = "break"
        │       ├── opening_loc: (19,4)-(19,5) = "{"
        │       └── closing_loc: (19,14)-(19,15) = "}"
        ├── @ CallNode (location: (21,0)-(21,16))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (21,0)-(21,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (21,4)-(21,16))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (21,6)-(21,14))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BreakNode (location: (21,6)-(21,14))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (21,11)-(21,14))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ ParenthesesNode (location: (21,11)-(21,14))
        │       │           │           ├── flags: ∅
        │       │           │           ├── body:
        │       │           │           │   @ StatementsNode (location: (21,12)-(21,13))
        │       │           │           │   ├── flags: ∅
        │       │           │           │   └── body: (length: 1)
        │       │           │           │       └── @ IntegerNode (location: (21,12)-(21,13))
        │       │           │           │           ├── flags: newline, static_literal, decimal
        │       │           │           │           └── value: 1
        │       │           │           ├── opening_loc: (21,11)-(21,12) = "("
        │       │           │           └── closing_loc: (21,13)-(21,14) = ")"
        │       │           └── keyword_loc: (21,6)-(21,11) = "break"
        │       ├── opening_loc: (21,4)-(21,5) = "{"
        │       └── closing_loc: (21,15)-(21,16) = "}"
        ├── @ CallNode (location: (23,0)-(23,17))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (23,0)-(23,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (23,4)-(23,17))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (23,6)-(23,15))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ ParenthesesNode (location: (23,6)-(23,15))
        │       │           ├── flags: newline
        │       │           ├── body:
        │       │           │   @ StatementsNode (location: (23,7)-(23,14))
        │       │           │   ├── flags: ∅
        │       │           │   └── body: (length: 1)
        │       │           │       └── @ BreakNode (location: (23,7)-(23,14))
        │       │           │           ├── flags: newline
        │       │           │           ├── arguments:
        │       │           │           │   @ ArgumentsNode (location: (23,13)-(23,14))
        │       │           │           │   ├── flags: ∅
        │       │           │           │   └── arguments: (length: 1)
        │       │           │           │       └── @ IntegerNode (location: (23,13)-(23,14))
        │       │           │           │           ├── flags: static_literal, decimal
        │       │           │           │           └── value: 1
        │       │           │           └── keyword_loc: (23,7)-(23,12) = "break"
        │       │           ├── opening_loc: (23,6)-(23,7) = "("
        │       │           └── closing_loc: (23,14)-(23,15) = ")"
        │       ├── opening_loc: (23,4)-(23,5) = "{"
        │       └── closing_loc: (23,16)-(23,17) = "}"
        ├── @ CallNode (location: (25,0)-(25,24))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (25,0)-(25,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (25,4)-(25,24))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (25,6)-(25,22))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ AndNode (location: (25,6)-(25,22))
        │       │           ├── flags: newline
        │       │           ├── left:
        │       │           │   @ CallNode (location: (25,6)-(25,9))
        │       │           │   ├── flags: variable_call, ignore_visibility
        │       │           │   ├── receiver: ∅
        │       │           │   ├── call_operator_loc: ∅
        │       │           │   ├── name: :foo
        │       │           │   ├── message_loc: (25,6)-(25,9) = "foo"
        │       │           │   ├── opening_loc: ∅
        │       │           │   ├── arguments: ∅
        │       │           │   ├── closing_loc: ∅
        │       │           │   └── block: ∅
        │       │           ├── right:
        │       │           │   @ ParenthesesNode (location: (25,13)-(25,22))
        │       │           │   ├── flags: ∅
        │       │           │   ├── body:
        │       │           │   │   @ StatementsNode (location: (25,14)-(25,21))
        │       │           │   │   ├── flags: ∅
        │       │           │   │   └── body: (length: 1)
        │       │           │   │       └── @ BreakNode (location: (25,14)-(25,21))
        │       │           │   │           ├── flags: newline
        │       │           │   │           ├── arguments:
        │       │           │   │           │   @ ArgumentsNode (location: (25,20)-(25,21))
        │       │           │   │           │   ├── flags: ∅
        │       │           │   │           │   └── arguments: (length: 1)
        │       │           │   │           │       └── @ IntegerNode (location: (25,20)-(25,21))
        │       │           │   │           │           ├── flags: static_literal, decimal
        │       │           │   │           │           └── value: 1
        │       │           │   │           └── keyword_loc: (25,14)-(25,19) = "break"
        │       │           │   ├── opening_loc: (25,13)-(25,14) = "("
        │       │           │   └── closing_loc: (25,21)-(25,22) = ")"
        │       │           └── operator_loc: (25,10)-(25,12) = "&&"
        │       ├── opening_loc: (25,4)-(25,5) = "{"
        │       └── closing_loc: (25,23)-(25,24) = "}"
        ├── @ CallNode (location: (27,0)-(27,22))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (27,0)-(27,16))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (27,0)-(27,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (27,4)-(27,16))
        │   │       ├── flags: ∅
        │   │       ├── locals: []
        │   │       ├── parameters: ∅
        │   │       ├── body:
        │   │       │   @ StatementsNode (location: (27,6)-(27,14))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ BreakNode (location: (27,6)-(27,14))
        │   │       │           ├── flags: newline
        │   │       │           ├── arguments:
        │   │       │           │   @ ArgumentsNode (location: (27,12)-(27,14))
        │   │       │           │   ├── flags: ∅
        │   │       │           │   └── arguments: (length: 1)
        │   │       │           │       └── @ IntegerNode (location: (27,12)-(27,14))
        │   │       │           │           ├── flags: static_literal, decimal
        │   │       │           │           └── value: 42
        │   │       │           └── keyword_loc: (27,6)-(27,11) = "break"
        │   │       ├── opening_loc: (27,4)-(27,5) = "{"
        │   │       └── closing_loc: (27,15)-(27,16) = "}"
        │   ├── call_operator_loc: ∅
        │   ├── name: :==
        │   ├── message_loc: (27,17)-(27,19) = "=="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (27,20)-(27,22))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (27,20)-(27,22))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 42
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (29,0)-(29,23))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (29,0)-(29,17))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (29,0)-(29,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (29,4)-(29,17))
        │   │       ├── flags: ∅
        │   │       ├── locals: [:a]
        │   │       ├── parameters:
        │   │       │   @ BlockParametersNode (location: (29,6)-(29,9))
        │   │       │   ├── flags: ∅
        │   │       │   ├── parameters:
        │   │       │   │   @ ParametersNode (location: (29,7)-(29,8))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── requireds: (length: 1)
        │   │       │   │   │   └── @ RequiredParameterNode (location: (29,7)-(29,8))
        │   │       │   │   │       ├── flags: ∅
        │   │       │   │   │       └── name: :a
        │   │       │   │   ├── optionals: (length: 0)
        │   │       │   │   ├── rest: ∅
        │   │       │   │   ├── posts: (length: 0)
        │   │       │   │   ├── keywords: (length: 0)
        │   │       │   │   ├── keyword_rest: ∅
        │   │       │   │   └── block: ∅
        │   │       │   ├── locals: (length: 0)
        │   │       │   ├── opening_loc: (29,6)-(29,7) = "|"
        │   │       │   └── closing_loc: (29,8)-(29,9) = "|"
        │   │       ├── body:
        │   │       │   @ StatementsNode (location: (29,10)-(29,15))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ BreakNode (location: (29,10)-(29,15))
        │   │       │           ├── flags: newline
        │   │       │           ├── arguments: ∅
        │   │       │           └── keyword_loc: (29,10)-(29,15) = "break"
        │   │       ├── opening_loc: (29,4)-(29,5) = "{"
        │   │       └── closing_loc: (29,16)-(29,17) = "}"
        │   ├── call_operator_loc: ∅
        │   ├── name: :==
        │   ├── message_loc: (29,18)-(29,20) = "=="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (29,21)-(29,23))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (29,21)-(29,23))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 42
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ WhileNode (location: (31,0)-(31,21))
        │   ├── flags: newline
        │   ├── keyword_loc: (31,0)-(31,5) = "while"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: (31,18)-(31,21) = "end"
        │   ├── predicate:
        │   │   @ AndNode (location: (31,6)-(31,16))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ CallNode (location: (31,6)-(31,7))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :_
        │   │   │   ├── message_loc: (31,6)-(31,7) = "_"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── right:
        │   │   │   @ BreakNode (location: (31,11)-(31,16))
        │   │   │   ├── flags: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   └── keyword_loc: (31,11)-(31,16) = "break"
        │   │   └── operator_loc: (31,8)-(31,10) = "&&"
        │   └── statements: ∅
        └── @ UntilNode (location: (33,0)-(33,21))
            ├── flags: newline
            ├── keyword_loc: (33,0)-(33,5) = "until"
            ├── do_keyword_loc: ∅
            ├── closing_loc: (33,18)-(33,21) = "end"
            ├── predicate:
            │   @ AndNode (location: (33,6)-(33,16))
            │   ├── flags: ∅
            │   ├── left:
            │   │   @ CallNode (location: (33,6)-(33,7))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :_
            │   │   ├── message_loc: (33,6)-(33,7) = "_"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── right:
            │   │   @ BreakNode (location: (33,11)-(33,16))
            │   │   ├── flags: ∅
            │   │   ├── arguments: ∅
            │   │   └── keyword_loc: (33,11)-(33,16) = "break"
            │   └── operator_loc: (33,8)-(33,10) = "&&"
            └── statements: ∅
prism-1.5.1/snapshots/case.txt000066400000000000000000001007131506127434000163520ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(55,3))
├── flags: ∅
├── locals: [:b]
└── statements:
    @ StatementsNode (location: (1,0)-(55,3))
    ├── flags: ∅
    └── body: (length: 15)
        ├── @ CaseNode (location: (1,0)-(3,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (1,5)-(1,8))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (1,5)-(1,6) = ":"
        │   │   ├── value_loc: (1,6)-(1,8) = "hi"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "hi"
        │   ├── conditions: (length: 1)
        │   │   └── @ WhenNode (location: (2,0)-(2,8))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (2,0)-(2,4) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ SymbolNode (location: (2,5)-(2,8))
        │   │       │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │       ├── opening_loc: (2,5)-(2,6) = ":"
        │   │       │       ├── value_loc: (2,6)-(2,8) = "hi"
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── unescaped: "hi"
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (3,0)-(3,3) = "end"
        ├── @ CaseNode (location: (5,0)-(5,58))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ TrueNode (location: (5,5)-(5,9))
        │   │   └── flags: static_literal
        │   ├── conditions: (length: 2)
        │   │   ├── @ WhenNode (location: (5,11)-(5,30))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (5,11)-(5,15) = "when"
        │   │   │   ├── conditions: (length: 1)
        │   │   │   │   └── @ TrueNode (location: (5,16)-(5,20))
        │   │   │   │       └── flags: static_literal
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   └── statements:
        │   │   │       @ StatementsNode (location: (5,22)-(5,30))
        │   │   │       ├── flags: ∅
        │   │   │       └── body: (length: 1)
        │   │   │           └── @ CallNode (location: (5,22)-(5,30))
        │   │   │               ├── flags: newline, ignore_visibility
        │   │   │               ├── receiver: ∅
        │   │   │               ├── call_operator_loc: ∅
        │   │   │               ├── name: :puts
        │   │   │               ├── message_loc: (5,22)-(5,26) = "puts"
        │   │   │               ├── opening_loc: ∅
        │   │   │               ├── arguments:
        │   │   │               │   @ ArgumentsNode (location: (5,27)-(5,30))
        │   │   │               │   ├── flags: ∅
        │   │   │               │   └── arguments: (length: 1)
        │   │   │               │       └── @ SymbolNode (location: (5,27)-(5,30))
        │   │   │               │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │               │           ├── opening_loc: (5,27)-(5,28) = ":"
        │   │   │               │           ├── value_loc: (5,28)-(5,30) = "hi"
        │   │   │               │           ├── closing_loc: ∅
        │   │   │               │           └── unescaped: "hi"
        │   │   │               ├── closing_loc: ∅
        │   │   │               └── block: ∅
        │   │   └── @ WhenNode (location: (5,32)-(5,53))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (5,32)-(5,36) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ FalseNode (location: (5,37)-(5,42))
        │   │       │       └── flags: static_literal
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements:
        │   │           @ StatementsNode (location: (5,44)-(5,53))
        │   │           ├── flags: ∅
        │   │           └── body: (length: 1)
        │   │               └── @ CallNode (location: (5,44)-(5,53))
        │   │                   ├── flags: newline, ignore_visibility
        │   │                   ├── receiver: ∅
        │   │                   ├── call_operator_loc: ∅
        │   │                   ├── name: :puts
        │   │                   ├── message_loc: (5,44)-(5,48) = "puts"
        │   │                   ├── opening_loc: ∅
        │   │                   ├── arguments:
        │   │                   │   @ ArgumentsNode (location: (5,49)-(5,53))
        │   │                   │   ├── flags: ∅
        │   │                   │   └── arguments: (length: 1)
        │   │                   │       └── @ SymbolNode (location: (5,49)-(5,53))
        │   │                   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │           ├── opening_loc: (5,49)-(5,50) = ":"
        │   │                   │           ├── value_loc: (5,50)-(5,53) = "bye"
        │   │                   │           ├── closing_loc: ∅
        │   │                   │           └── unescaped: "bye"
        │   │                   ├── closing_loc: ∅
        │   │                   └── block: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (5,0)-(5,4) = "case"
        │   └── end_keyword_loc: (5,55)-(5,58) = "end"
        ├── @ CaseNode (location: (7,0)-(7,20))
        │   ├── flags: newline
        │   ├── predicate: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ WhenNode (location: (7,6)-(7,15))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (7,6)-(7,10) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ SplatNode (location: (7,11)-(7,15))
        │   │       │       ├── flags: ∅
        │   │       │       ├── operator_loc: (7,11)-(7,12) = "*"
        │   │       │       └── expression:
        │   │       │           @ CallNode (location: (7,12)-(7,15))
        │   │       │           ├── flags: variable_call, ignore_visibility
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :foo
        │   │       │           ├── message_loc: (7,12)-(7,15) = "foo"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments: ∅
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (7,0)-(7,4) = "case"
        │   └── end_keyword_loc: (7,17)-(7,20) = "end"
        ├── @ CaseNode (location: (9,0)-(13,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (9,5)-(9,8))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (9,5)-(9,6) = ":"
        │   │   ├── value_loc: (9,6)-(9,8) = "hi"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "hi"
        │   ├── conditions: (length: 1)
        │   │   └── @ WhenNode (location: (10,0)-(10,8))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (10,0)-(10,4) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ SymbolNode (location: (10,5)-(10,8))
        │   │       │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │       ├── opening_loc: (10,5)-(10,6) = ":"
        │   │       │       ├── value_loc: (10,6)-(10,8) = "hi"
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── unescaped: "hi"
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements: ∅
        │   ├── else_clause:
        │   │   @ ElseNode (location: (11,0)-(13,3))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (11,0)-(11,4) = "else"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (12,0)-(12,2))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ SymbolNode (location: (12,0)-(12,2))
        │   │   │           ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   │   │           ├── opening_loc: (12,0)-(12,1) = ":"
        │   │   │           ├── value_loc: (12,1)-(12,2) = "b"
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── unescaped: "b"
        │   │   └── end_keyword_loc: (13,0)-(13,3) = "end"
        │   ├── case_keyword_loc: (9,0)-(9,4) = "case"
        │   └── end_keyword_loc: (13,0)-(13,3) = "end"
        ├── @ CaseNode (location: (15,0)-(15,36))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (15,5)-(15,9))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :this
        │   │   ├── message_loc: (15,5)-(15,9) = "this"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ WhenNode (location: (15,11)-(15,31))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (15,11)-(15,15) = "when"
        │   │       ├── conditions: (length: 2)
        │   │       │   ├── @ ConstantReadNode (location: (15,16)-(15,22))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :FooBar
        │   │       │   └── @ ConstantReadNode (location: (15,24)-(15,31))
        │   │       │       ├── flags: ∅
        │   │       │       └── name: :BazBonk
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (15,0)-(15,4) = "case"
        │   └── end_keyword_loc: (15,33)-(15,36) = "end"
        ├── @ CaseNode (location: (17,0)-(19,3))
        │   ├── flags: newline
        │   ├── predicate: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ WhenNode (location: (18,0)-(18,15))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (18,0)-(18,4) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ CallNode (location: (18,5)-(18,15))
        │   │       │       ├── flags: ∅
        │   │       │       ├── receiver:
        │   │       │       │   @ CallNode (location: (18,5)-(18,8))
        │   │       │       │   ├── flags: variable_call, ignore_visibility
        │   │       │       │   ├── receiver: ∅
        │   │       │       │   ├── call_operator_loc: ∅
        │   │       │       │   ├── name: :foo
        │   │       │       │   ├── message_loc: (18,5)-(18,8) = "foo"
        │   │       │       │   ├── opening_loc: ∅
        │   │       │       │   ├── arguments: ∅
        │   │       │       │   ├── closing_loc: ∅
        │   │       │       │   └── block: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── name: :==
        │   │       │       ├── message_loc: (18,9)-(18,11) = "=="
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments:
        │   │       │       │   @ ArgumentsNode (location: (18,12)-(18,15))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── arguments: (length: 1)
        │   │       │       │       └── @ CallNode (location: (18,12)-(18,15))
        │   │       │       │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :bar
        │   │       │       │           ├── message_loc: (18,12)-(18,15) = "bar"
        │   │       │       │           ├── opening_loc: ∅
        │   │       │       │           ├── arguments: ∅
        │   │       │       │           ├── closing_loc: ∅
        │   │       │       │           └── block: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── block: ∅
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (17,0)-(17,4) = "case"
        │   └── end_keyword_loc: (19,0)-(19,3) = "end"
        ├── @ CaseNode (location: (21,0)-(25,3))
        │   ├── flags: newline
        │   ├── predicate: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ WhenNode (location: (22,0)-(22,6))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (22,0)-(22,4) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ CallNode (location: (22,5)-(22,6))
        │   │       │       ├── flags: variable_call, ignore_visibility
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── name: :a
        │   │       │       ├── message_loc: (22,5)-(22,6) = "a"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── block: ∅
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements: ∅
        │   ├── else_clause:
        │   │   @ ElseNode (location: (23,0)-(25,3))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (23,0)-(23,4) = "else"
        │   │   ├── statements: ∅
        │   │   └── end_keyword_loc: (25,0)-(25,3) = "end"
        │   ├── case_keyword_loc: (21,0)-(21,4) = "case"
        │   └── end_keyword_loc: (25,0)-(25,3) = "end"
        ├── @ CaseNode (location: (27,0)-(30,6))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (27,5)-(27,9))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :type
        │   │   ├── message_loc: (27,5)-(27,9) = "type"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ WhenNode (location: (28,3)-(28,10))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (28,3)-(28,7) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ SymbolNode (location: (28,8)-(28,10))
        │   │       │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │       ├── opening_loc: (28,8)-(28,9) = ":"
        │   │       │       ├── value_loc: (28,9)-(28,10) = "b"
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── unescaped: "b"
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements: ∅
        │   ├── else_clause:
        │   │   @ ElseNode (location: (29,5)-(30,6))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (29,5)-(29,9) = "else"
        │   │   ├── statements: ∅
        │   │   └── end_keyword_loc: (30,3)-(30,6) = "end"
        │   ├── case_keyword_loc: (27,0)-(27,4) = "case"
        │   └── end_keyword_loc: (30,3)-(30,6) = "end"
        ├── @ CaseNode (location: (32,0)-(32,25))
        │   ├── flags: newline
        │   ├── predicate: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ WhenNode (location: (32,14)-(32,20))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (32,14)-(32,18) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ IntegerNode (location: (32,19)-(32,20))
        │   │       │       ├── flags: static_literal, decimal
        │   │       │       └── value: 1
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (32,0)-(32,4) = "case"
        │   └── end_keyword_loc: (32,22)-(32,25) = "end"
        ├── @ CaseNode (location: (34,0)-(36,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ MatchPredicateNode (location: (34,5)-(34,11))
        │   │   ├── flags: ∅
        │   │   ├── value:
        │   │   │   @ IntegerNode (location: (34,5)-(34,6))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── pattern:
        │   │   │   @ IntegerNode (location: (34,10)-(34,11))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 2
        │   │   └── operator_loc: (34,7)-(34,9) = "in"
        │   ├── conditions: (length: 1)
        │   │   └── @ WhenNode (location: (35,0)-(35,6))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (35,0)-(35,4) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ IntegerNode (location: (35,5)-(35,6))
        │   │       │       ├── flags: static_literal, decimal
        │   │       │       └── value: 3
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (34,0)-(34,4) = "case"
        │   └── end_keyword_loc: (36,0)-(36,3) = "end"
        ├── @ CaseNode (location: (38,0)-(38,24))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ MatchPredicateNode (location: (38,5)-(38,11))
        │   │   ├── flags: ∅
        │   │   ├── value:
        │   │   │   @ IntegerNode (location: (38,5)-(38,6))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── pattern:
        │   │   │   @ IntegerNode (location: (38,10)-(38,11))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 2
        │   │   └── operator_loc: (38,7)-(38,9) = "in"
        │   ├── conditions: (length: 1)
        │   │   └── @ WhenNode (location: (38,13)-(38,19))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (38,13)-(38,17) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ IntegerNode (location: (38,18)-(38,19))
        │   │       │       ├── flags: static_literal, decimal
        │   │       │       └── value: 3
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (38,0)-(38,4) = "case"
        │   └── end_keyword_loc: (38,21)-(38,24) = "end"
        ├── @ CaseMatchNode (location: (40,0)-(42,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ MatchPredicateNode (location: (40,5)-(40,11))
        │   │   ├── flags: ∅
        │   │   ├── value:
        │   │   │   @ IntegerNode (location: (40,5)-(40,6))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── pattern:
        │   │   │   @ IntegerNode (location: (40,10)-(40,11))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 2
        │   │   └── operator_loc: (40,7)-(40,9) = "in"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (41,0)-(41,4))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IntegerNode (location: (41,3)-(41,4))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 3
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (41,0)-(41,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (40,0)-(40,4) = "case"
        │   └── end_keyword_loc: (42,0)-(42,3) = "end"
        ├── @ CaseMatchNode (location: (44,0)-(44,22))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ MatchPredicateNode (location: (44,5)-(44,11))
        │   │   ├── flags: ∅
        │   │   ├── value:
        │   │   │   @ IntegerNode (location: (44,5)-(44,6))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── pattern:
        │   │   │   @ IntegerNode (location: (44,10)-(44,11))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 2
        │   │   └── operator_loc: (44,7)-(44,9) = "in"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (44,13)-(44,17))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IntegerNode (location: (44,16)-(44,17))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 3
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (44,13)-(44,15) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (44,0)-(44,4) = "case"
        │   └── end_keyword_loc: (44,19)-(44,22) = "end"
        ├── @ CaseMatchNode (location: (46,0)-(49,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (46,5)-(46,6))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (46,5)-(46,6) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (47,0)-(48,3))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (47,3)-(47,15))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (47,5)-(47,7) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ AndNode (location: (47,8)-(47,15))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── left:
        │   │       │   │   │   @ CallNode (location: (47,8)-(47,9))
        │   │       │   │   │   ├── flags: variable_call, ignore_visibility
        │   │       │   │   │   ├── receiver: ∅
        │   │       │   │   │   ├── call_operator_loc: ∅
        │   │       │   │   │   ├── name: :c
        │   │       │   │   │   ├── message_loc: (47,8)-(47,9) = "c"
        │   │       │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   ├── arguments: ∅
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── block: ∅
        │   │       │   │   ├── right:
        │   │       │   │   │   @ CallNode (location: (47,14)-(47,15))
        │   │       │   │   │   ├── flags: variable_call, ignore_visibility
        │   │       │   │   │   ├── receiver: ∅
        │   │       │   │   │   ├── call_operator_loc: ∅
        │   │       │   │   │   ├── name: :d
        │   │       │   │   │   ├── message_loc: (47,14)-(47,15) = "d"
        │   │       │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   ├── arguments: ∅
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── block: ∅
        │   │       │   │   └── operator_loc: (47,10)-(47,13) = "and"
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (47,3)-(47,4))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ LocalVariableTargetNode (location: (47,3)-(47,4))
        │   │       │   │           ├── flags: newline
        │   │       │   │           ├── name: :b
        │   │       │   │           └── depth: 0
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (48,2)-(48,3))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (48,2)-(48,3))
        │   │       │           ├── flags: newline, variable_call, ignore_visibility
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :e
        │   │       │           ├── message_loc: (48,2)-(48,3) = "e"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments: ∅
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       ├── in_loc: (47,0)-(47,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (46,0)-(46,4) = "case"
        │   └── end_keyword_loc: (49,0)-(49,3) = "end"
        └── @ CallNode (location: (51,0)-(55,3))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (51,0)-(51,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: (51,1)-(51,2) = "."
            ├── name: :then
            ├── message_loc: (51,2)-(51,6) = "then"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (51,7)-(55,3))
                ├── flags: ∅
                ├── locals: [:_1]
                ├── parameters:
                │   @ NumberedParametersNode (location: (51,7)-(55,3))
                │   ├── flags: ∅
                │   └── maximum: 1
                ├── body:
                │   @ StatementsNode (location: (52,2)-(54,5))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ CaseMatchNode (location: (52,2)-(54,5))
                │           ├── flags: newline
                │           ├── predicate:
                │           │   @ IntegerNode (location: (52,7)-(52,8))
                │           │   ├── flags: static_literal, decimal
                │           │   └── value: 1
                │           ├── conditions: (length: 1)
                │           │   └── @ InNode (location: (53,2)-(53,8))
                │           │       ├── flags: ∅
                │           │       ├── pattern:
                │           │       │   @ PinnedVariableNode (location: (53,5)-(53,8))
                │           │       │   ├── flags: ∅
                │           │       │   ├── variable:
                │           │       │   │   @ LocalVariableReadNode (location: (53,6)-(53,8))
                │           │       │   │   ├── flags: ∅
                │           │       │   │   ├── name: :_1
                │           │       │   │   └── depth: 0
                │           │       │   └── operator_loc: (53,5)-(53,6) = "^"
                │           │       ├── statements: ∅
                │           │       ├── in_loc: (53,2)-(53,4) = "in"
                │           │       └── then_loc: ∅
                │           ├── else_clause: ∅
                │           ├── case_keyword_loc: (52,2)-(52,6) = "case"
                │           └── end_keyword_loc: (54,2)-(54,5) = "end"
                ├── opening_loc: (51,7)-(51,9) = "do"
                └── closing_loc: (55,0)-(55,3) = "end"
prism-1.5.1/snapshots/case_in_hash_key.txt000066400000000000000000000223211506127434000207110ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(6,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(6,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(6,3))
            ├── flags: newline
            ├── predicate:
            │   @ IntegerNode (location: (1,5)-(1,6))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── conditions: (length: 2)
            │   ├── @ InNode (location: (2,0)-(3,18))
            │   │   ├── flags: ∅
            │   │   ├── pattern:
            │   │   │   @ IntegerNode (location: (2,3)-(2,4))
            │   │   │   ├── flags: static_literal, decimal
            │   │   │   └── value: 2
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (3,2)-(3,18))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ CallNode (location: (3,2)-(3,18))
            │   │   │           ├── flags: newline
            │   │   │           ├── receiver:
            │   │   │           │   @ ConstantReadNode (location: (3,2)-(3,3))
            │   │   │           │   ├── flags: ∅
            │   │   │           │   └── name: :A
            │   │   │           ├── call_operator_loc: (3,3)-(3,4) = "."
            │   │   │           ├── name: :print
            │   │   │           ├── message_loc: (3,4)-(3,9) = "print"
            │   │   │           ├── opening_loc: ∅
            │   │   │           ├── arguments:
            │   │   │           │   @ ArgumentsNode (location: (3,10)-(3,18))
            │   │   │           │   ├── flags: contains_keywords
            │   │   │           │   └── arguments: (length: 1)
            │   │   │           │       └── @ KeywordHashNode (location: (3,10)-(3,18))
            │   │   │           │           ├── flags: symbol_keys
            │   │   │           │           └── elements: (length: 1)
            │   │   │           │               └── @ AssocNode (location: (3,10)-(3,18))
            │   │   │           │                   ├── flags: ∅
            │   │   │           │                   ├── key:
            │   │   │           │                   │   @ SymbolNode (location: (3,10)-(3,18))
            │   │   │           │                   │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │   │           │                   │   ├── opening_loc: ∅
            │   │   │           │                   │   ├── value_loc: (3,10)-(3,17) = "message"
            │   │   │           │                   │   ├── closing_loc: (3,17)-(3,18) = ":"
            │   │   │           │                   │   └── unescaped: "message"
            │   │   │           │                   ├── value:
            │   │   │           │                   │   @ ImplicitNode (location: (3,10)-(3,18))
            │   │   │           │                   │   ├── flags: ∅
            │   │   │           │                   │   └── value:
            │   │   │           │                   │       @ CallNode (location: (3,10)-(3,18))
            │   │   │           │                   │       ├── flags: ignore_visibility
            │   │   │           │                   │       ├── receiver: ∅
            │   │   │           │                   │       ├── call_operator_loc: ∅
            │   │   │           │                   │       ├── name: :message
            │   │   │           │                   │       ├── message_loc: (3,10)-(3,17) = "message"
            │   │   │           │                   │       ├── opening_loc: ∅
            │   │   │           │                   │       ├── arguments: ∅
            │   │   │           │                   │       ├── closing_loc: ∅
            │   │   │           │                   │       └── block: ∅
            │   │   │           │                   └── operator_loc: ∅
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── block: ∅
            │   │   ├── in_loc: (2,0)-(2,2) = "in"
            │   │   └── then_loc: ∅
            │   └── @ InNode (location: (4,0)-(5,18))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ IntegerNode (location: (4,3)-(4,4))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 3
            │       ├── statements:
            │       │   @ StatementsNode (location: (5,2)-(5,18))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ CallNode (location: (5,2)-(5,18))
            │       │           ├── flags: newline
            │       │           ├── receiver:
            │       │           │   @ ConstantReadNode (location: (5,2)-(5,3))
            │       │           │   ├── flags: ∅
            │       │           │   └── name: :A
            │       │           ├── call_operator_loc: (5,3)-(5,4) = "."
            │       │           ├── name: :print
            │       │           ├── message_loc: (5,4)-(5,9) = "print"
            │       │           ├── opening_loc: ∅
            │       │           ├── arguments:
            │       │           │   @ ArgumentsNode (location: (5,10)-(5,18))
            │       │           │   ├── flags: contains_keywords
            │       │           │   └── arguments: (length: 1)
            │       │           │       └── @ KeywordHashNode (location: (5,10)-(5,18))
            │       │           │           ├── flags: symbol_keys
            │       │           │           └── elements: (length: 1)
            │       │           │               └── @ AssocNode (location: (5,10)-(5,18))
            │       │           │                   ├── flags: ∅
            │       │           │                   ├── key:
            │       │           │                   │   @ SymbolNode (location: (5,10)-(5,18))
            │       │           │                   │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │           │                   │   ├── opening_loc: ∅
            │       │           │                   │   ├── value_loc: (5,10)-(5,17) = "message"
            │       │           │                   │   ├── closing_loc: (5,17)-(5,18) = ":"
            │       │           │                   │   └── unescaped: "message"
            │       │           │                   ├── value:
            │       │           │                   │   @ ImplicitNode (location: (5,10)-(5,18))
            │       │           │                   │   ├── flags: ∅
            │       │           │                   │   └── value:
            │       │           │                   │       @ CallNode (location: (5,10)-(5,18))
            │       │           │                   │       ├── flags: ignore_visibility
            │       │           │                   │       ├── receiver: ∅
            │       │           │                   │       ├── call_operator_loc: ∅
            │       │           │                   │       ├── name: :message
            │       │           │                   │       ├── message_loc: (5,10)-(5,17) = "message"
            │       │           │                   │       ├── opening_loc: ∅
            │       │           │                   │       ├── arguments: ∅
            │       │           │                   │       ├── closing_loc: ∅
            │       │           │                   │       └── block: ∅
            │       │           │                   └── operator_loc: ∅
            │       │           ├── closing_loc: ∅
            │       │           └── block: ∅
            │       ├── in_loc: (4,0)-(4,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (6,0)-(6,3) = "end"
prism-1.5.1/snapshots/classes.txt000066400000000000000000000545651506127434000171110ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(35,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(35,3))
    ├── flags: ∅
    └── body: (length: 14)
        ├── @ ClassNode (location: (1,0)-(1,17))
        │   ├── flags: newline
        │   ├── locals: [:a]
        │   ├── class_keyword_loc: (1,0)-(1,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (1,6)-(1,7))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (1,8)-(1,13))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableWriteNode (location: (1,8)-(1,13))
        │   │           ├── flags: newline
        │   │           ├── name: :a
        │   │           ├── depth: 0
        │   │           ├── name_loc: (1,8)-(1,9) = "a"
        │   │           ├── value:
        │   │           │   @ IntegerNode (location: (1,12)-(1,13))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 1
        │   │           └── operator_loc: (1,10)-(1,11) = "="
        │   ├── end_keyword_loc: (1,14)-(1,17) = "end"
        │   └── name: :A
        ├── @ ClassNode (location: (3,0)-(3,20))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (3,0)-(3,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (3,6)-(3,7))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (3,0)-(3,20))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   ├── rescue_clause: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (3,9)-(3,20))
        │   │   │   ├── flags: ∅
        │   │   │   ├── ensure_keyword_loc: (3,9)-(3,15) = "ensure"
        │   │   │   ├── statements: ∅
        │   │   │   └── end_keyword_loc: (3,17)-(3,20) = "end"
        │   │   └── end_keyword_loc: (3,17)-(3,20) = "end"
        │   ├── end_keyword_loc: (3,17)-(3,20) = "end"
        │   └── name: :A
        ├── @ ClassNode (location: (5,0)-(5,34))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (5,0)-(5,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (5,6)-(5,7))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (5,0)-(5,34))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (5,9)-(5,15))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (5,9)-(5,15) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   ├── statements: ∅
        │   │   │   └── subsequent: ∅
        │   │   ├── else_clause:
        │   │   │   @ ElseNode (location: (5,17)-(5,29))
        │   │   │   ├── flags: ∅
        │   │   │   ├── else_keyword_loc: (5,17)-(5,21) = "else"
        │   │   │   ├── statements: ∅
        │   │   │   └── end_keyword_loc: (5,23)-(5,29) = "ensure"
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (5,23)-(5,34))
        │   │   │   ├── flags: ∅
        │   │   │   ├── ensure_keyword_loc: (5,23)-(5,29) = "ensure"
        │   │   │   ├── statements: ∅
        │   │   │   └── end_keyword_loc: (5,31)-(5,34) = "end"
        │   │   └── end_keyword_loc: (5,31)-(5,34) = "end"
        │   ├── end_keyword_loc: (5,31)-(5,34) = "end"
        │   └── name: :A
        ├── @ ClassNode (location: (7,0)-(9,3))
        │   ├── flags: newline
        │   ├── locals: [:a]
        │   ├── class_keyword_loc: (7,0)-(7,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (7,6)-(7,7))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: (7,8)-(7,9) = "<"
        │   ├── superclass:
        │   │   @ ConstantReadNode (location: (7,10)-(7,11))
        │   │   ├── flags: ∅
        │   │   └── name: :B
        │   ├── body:
        │   │   @ StatementsNode (location: (8,0)-(8,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableWriteNode (location: (8,0)-(8,5))
        │   │           ├── flags: newline
        │   │           ├── name: :a
        │   │           ├── depth: 0
        │   │           ├── name_loc: (8,0)-(8,1) = "a"
        │   │           ├── value:
        │   │           │   @ IntegerNode (location: (8,4)-(8,5))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 1
        │   │           └── operator_loc: (8,2)-(8,3) = "="
        │   ├── end_keyword_loc: (9,0)-(9,3) = "end"
        │   └── name: :A
        ├── @ SingletonClassNode (location: (11,0)-(12,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (11,0)-(11,5) = "class"
        │   ├── operator_loc: (11,6)-(11,8) = "<<"
        │   ├── expression:
        │   │   @ CallNode (location: (11,9)-(11,16))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (11,13)-(11,16))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (11,13)-(11,16) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (11,9)-(11,12) = "not"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   └── end_keyword_loc: (12,0)-(12,3) = "end"
        ├── @ ClassNode (location: (14,0)-(14,40))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (14,0)-(14,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (14,6)-(14,7))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (14,9)-(14,35))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ SingletonClassNode (location: (14,9)-(14,35))
        │   │           ├── flags: newline
        │   │           ├── locals: []
        │   │           ├── class_keyword_loc: (14,9)-(14,14) = "class"
        │   │           ├── operator_loc: (14,15)-(14,17) = "<<"
        │   │           ├── expression:
        │   │           │   @ SelfNode (location: (14,18)-(14,22))
        │   │           │   └── flags: ∅
        │   │           ├── body:
        │   │           │   @ BeginNode (location: (14,9)-(14,35))
        │   │           │   ├── flags: ∅
        │   │           │   ├── begin_keyword_loc: ∅
        │   │           │   ├── statements: ∅
        │   │           │   ├── rescue_clause: ∅
        │   │           │   ├── else_clause: ∅
        │   │           │   ├── ensure_clause:
        │   │           │   │   @ EnsureNode (location: (14,24)-(14,35))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── ensure_keyword_loc: (14,24)-(14,30) = "ensure"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── end_keyword_loc: (14,32)-(14,35) = "end"
        │   │           │   └── end_keyword_loc: (14,32)-(14,35) = "end"
        │   │           └── end_keyword_loc: (14,32)-(14,35) = "end"
        │   ├── end_keyword_loc: (14,37)-(14,40) = "end"
        │   └── name: :A
        ├── @ ClassNode (location: (16,0)-(16,54))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (16,0)-(16,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (16,6)-(16,7))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (16,9)-(16,49))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ SingletonClassNode (location: (16,9)-(16,49))
        │   │           ├── flags: newline
        │   │           ├── locals: []
        │   │           ├── class_keyword_loc: (16,9)-(16,14) = "class"
        │   │           ├── operator_loc: (16,15)-(16,17) = "<<"
        │   │           ├── expression:
        │   │           │   @ SelfNode (location: (16,18)-(16,22))
        │   │           │   └── flags: ∅
        │   │           ├── body:
        │   │           │   @ BeginNode (location: (16,9)-(16,49))
        │   │           │   ├── flags: ∅
        │   │           │   ├── begin_keyword_loc: ∅
        │   │           │   ├── statements: ∅
        │   │           │   ├── rescue_clause:
        │   │           │   │   @ RescueNode (location: (16,24)-(16,30))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── keyword_loc: (16,24)-(16,30) = "rescue"
        │   │           │   │   ├── exceptions: (length: 0)
        │   │           │   │   ├── operator_loc: ∅
        │   │           │   │   ├── reference: ∅
        │   │           │   │   ├── then_keyword_loc: ∅
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── subsequent: ∅
        │   │           │   ├── else_clause:
        │   │           │   │   @ ElseNode (location: (16,32)-(16,44))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── else_keyword_loc: (16,32)-(16,36) = "else"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── end_keyword_loc: (16,38)-(16,44) = "ensure"
        │   │           │   ├── ensure_clause:
        │   │           │   │   @ EnsureNode (location: (16,38)-(16,49))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── ensure_keyword_loc: (16,38)-(16,44) = "ensure"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── end_keyword_loc: (16,46)-(16,49) = "end"
        │   │           │   └── end_keyword_loc: (16,46)-(16,49) = "end"
        │   │           └── end_keyword_loc: (16,46)-(16,49) = "end"
        │   ├── end_keyword_loc: (16,51)-(16,54) = "end"
        │   └── name: :A
        ├── @ SingletonClassNode (location: (18,0)-(19,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (18,0)-(18,5) = "class"
        │   ├── operator_loc: (18,6)-(18,8) = "<<"
        │   ├── expression:
        │   │   @ CallNode (location: (18,9)-(18,16))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (18,9)-(18,12))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (18,9)-(18,12) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: (18,12)-(18,13) = "."
        │   │   ├── name: :bar
        │   │   ├── message_loc: (18,13)-(18,16) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   └── end_keyword_loc: (19,0)-(19,3) = "end"
        ├── @ SingletonClassNode (location: (21,0)-(21,20))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (21,0)-(21,5) = "class"
        │   ├── operator_loc: (21,6)-(21,8) = "<<"
        │   ├── expression:
        │   │   @ CallNode (location: (21,9)-(21,16))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (21,9)-(21,12))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (21,9)-(21,12) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: (21,12)-(21,13) = "."
        │   │   ├── name: :bar
        │   │   ├── message_loc: (21,13)-(21,16) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   └── end_keyword_loc: (21,17)-(21,20) = "end"
        ├── @ SingletonClassNode (location: (23,0)-(24,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (23,0)-(23,5) = "class"
        │   ├── operator_loc: (23,6)-(23,8) = "<<"
        │   ├── expression:
        │   │   @ SelfNode (location: (23,9)-(23,13))
        │   │   └── flags: ∅
        │   ├── body: ∅
        │   └── end_keyword_loc: (24,0)-(24,3) = "end"
        ├── @ SingletonClassNode (location: (26,0)-(26,17))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (26,0)-(26,5) = "class"
        │   ├── operator_loc: (26,6)-(26,8) = "<<"
        │   ├── expression:
        │   │   @ SelfNode (location: (26,9)-(26,13))
        │   │   └── flags: ∅
        │   ├── body: ∅
        │   └── end_keyword_loc: (26,14)-(26,17) = "end"
        ├── @ SingletonClassNode (location: (28,0)-(30,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (28,0)-(28,5) = "class"
        │   ├── operator_loc: (28,6)-(28,8) = "<<"
        │   ├── expression:
        │   │   @ SelfNode (location: (28,9)-(28,13))
        │   │   └── flags: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (29,0)-(29,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (29,0)-(29,5))
        │   │           ├── flags: newline
        │   │           ├── receiver:
        │   │           │   @ IntegerNode (location: (29,0)-(29,1))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 1
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :+
        │   │           ├── message_loc: (29,2)-(29,3) = "+"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (29,4)-(29,5))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (29,4)-(29,5))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 2
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   └── end_keyword_loc: (30,0)-(30,3) = "end"
        ├── @ SingletonClassNode (location: (32,0)-(32,23))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (32,0)-(32,5) = "class"
        │   ├── operator_loc: (32,6)-(32,8) = "<<"
        │   ├── expression:
        │   │   @ SelfNode (location: (32,9)-(32,13))
        │   │   └── flags: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (32,14)-(32,19))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (32,14)-(32,19))
        │   │           ├── flags: newline
        │   │           ├── receiver:
        │   │           │   @ IntegerNode (location: (32,14)-(32,15))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 1
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :+
        │   │           ├── message_loc: (32,16)-(32,17) = "+"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (32,18)-(32,19))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (32,18)-(32,19))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 2
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   └── end_keyword_loc: (32,20)-(32,23) = "end"
        └── @ ClassNode (location: (34,0)-(35,3))
            ├── flags: newline
            ├── locals: []
            ├── class_keyword_loc: (34,0)-(34,5) = "class"
            ├── constant_path:
            │   @ ConstantReadNode (location: (34,6)-(34,7))
            │   ├── flags: ∅
            │   └── name: :A
            ├── inheritance_operator_loc: (34,8)-(34,9) = "<"
            ├── superclass:
            │   @ CallNode (location: (34,10)-(34,14))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ ConstantReadNode (location: (34,10)-(34,11))
            │   │   ├── flags: ∅
            │   │   └── name: :B
            │   ├── call_operator_loc: ∅
            │   ├── name: :[]
            │   ├── message_loc: (34,11)-(34,14) = "[1]"
            │   ├── opening_loc: (34,11)-(34,12) = "["
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (34,12)-(34,13))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 1)
            │   │       └── @ IntegerNode (location: (34,12)-(34,13))
            │   │           ├── flags: static_literal, decimal
            │   │           └── value: 1
            │   ├── closing_loc: (34,13)-(34,14) = "]"
            │   └── block: ∅
            ├── body: ∅
            ├── end_keyword_loc: (35,0)-(35,3) = "end"
            └── name: :A
prism-1.5.1/snapshots/command_method_call.txt000066400000000000000000001206551506127434000214170ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(41,10))
├── flags: ∅
├── locals: [:foo, :bar]
└── statements:
    @ StatementsNode (location: (1,0)-(41,10))
    ├── flags: ∅
    └── body: (length: 21)
        ├── @ CallNode (location: (1,0)-(1,5))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,4)-(1,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (1,4)-(1,5))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,9))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,4)-(3,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (3,4)-(3,9))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (3,4)-(3,7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (3,8)-(3,9))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (3,8)-(3,9))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ IfNode (location: (5,0)-(5,14))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (5,6)-(5,8) = "if"
        │   ├── predicate:
        │   │   @ CallNode (location: (5,9)-(5,14))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (5,9)-(5,12) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (5,13)-(5,14))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (5,13)-(5,14))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (5,0)-(5,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (5,0)-(5,5))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :foo
        │   │           ├── message_loc: (5,0)-(5,3) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (5,4)-(5,5))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (5,4)-(5,5))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: ∅
        ├── @ UnlessNode (location: (7,0)-(7,18))
        │   ├── flags: newline
        │   ├── keyword_loc: (7,6)-(7,12) = "unless"
        │   ├── predicate:
        │   │   @ CallNode (location: (7,13)-(7,18))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (7,13)-(7,16) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (7,17)-(7,18))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (7,17)-(7,18))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (7,0)-(7,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (7,0)-(7,5))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :foo
        │   │           ├── message_loc: (7,0)-(7,3) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (7,4)-(7,5))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (7,4)-(7,5))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── else_clause: ∅
        │   └── end_keyword_loc: ∅
        ├── @ WhileNode (location: (9,0)-(9,17))
        │   ├── flags: newline
        │   ├── keyword_loc: (9,6)-(9,11) = "while"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (9,12)-(9,17))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (9,12)-(9,15) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (9,16)-(9,17))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (9,16)-(9,17))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── statements:
        │       @ StatementsNode (location: (9,0)-(9,5))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ CallNode (location: (9,0)-(9,5))
        │               ├── flags: newline, ignore_visibility
        │               ├── receiver: ∅
        │               ├── call_operator_loc: ∅
        │               ├── name: :foo
        │               ├── message_loc: (9,0)-(9,3) = "foo"
        │               ├── opening_loc: ∅
        │               ├── arguments:
        │               │   @ ArgumentsNode (location: (9,4)-(9,5))
        │               │   ├── flags: ∅
        │               │   └── arguments: (length: 1)
        │               │       └── @ IntegerNode (location: (9,4)-(9,5))
        │               │           ├── flags: static_literal, decimal
        │               │           └── value: 1
        │               ├── closing_loc: ∅
        │               └── block: ∅
        ├── @ UntilNode (location: (11,0)-(11,17))
        │   ├── flags: newline
        │   ├── keyword_loc: (11,6)-(11,11) = "until"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (11,12)-(11,17))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (11,12)-(11,15) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (11,16)-(11,17))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (11,16)-(11,17))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── statements:
        │       @ StatementsNode (location: (11,0)-(11,5))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ CallNode (location: (11,0)-(11,5))
        │               ├── flags: newline, ignore_visibility
        │               ├── receiver: ∅
        │               ├── call_operator_loc: ∅
        │               ├── name: :foo
        │               ├── message_loc: (11,0)-(11,3) = "foo"
        │               ├── opening_loc: ∅
        │               ├── arguments:
        │               │   @ ArgumentsNode (location: (11,4)-(11,5))
        │               │   ├── flags: ∅
        │               │   └── arguments: (length: 1)
        │               │       └── @ IntegerNode (location: (11,4)-(11,5))
        │               │           ├── flags: static_literal, decimal
        │               │           └── value: 1
        │               ├── closing_loc: ∅
        │               └── block: ∅
        ├── @ RescueModifierNode (location: (13,0)-(13,18))
        │   ├── flags: newline
        │   ├── expression:
        │   │   @ CallNode (location: (13,0)-(13,5))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (13,0)-(13,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (13,4)-(13,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (13,4)-(13,5))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── keyword_loc: (13,6)-(13,12) = "rescue"
        │   └── rescue_expression:
        │       @ CallNode (location: (13,13)-(13,18))
        │       ├── flags: ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (13,13)-(13,16) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments:
        │       │   @ ArgumentsNode (location: (13,17)-(13,18))
        │       │   ├── flags: ∅
        │       │   └── arguments: (length: 1)
        │       │       └── @ IntegerNode (location: (13,17)-(13,18))
        │       │           ├── flags: static_literal, decimal
        │       │           └── value: 2
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ CallNode (location: (15,0)-(15,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (15,0)-(15,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (15,0)-(15,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]
        │   ├── message_loc: (15,3)-(15,10) = "[bar 1]"
        │   ├── opening_loc: (15,3)-(15,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (15,4)-(15,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (15,4)-(15,9))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (15,4)-(15,7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (15,8)-(15,9))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (15,8)-(15,9))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (15,9)-(15,10) = "]"
        │   └── block: ∅
        ├── @ AndNode (location: (17,0)-(17,15))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ CallNode (location: (17,0)-(17,5))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (17,0)-(17,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (17,4)-(17,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (17,4)-(17,5))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── right:
        │   │   @ CallNode (location: (17,10)-(17,15))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (17,10)-(17,13) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (17,14)-(17,15))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (17,14)-(17,15))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (17,6)-(17,9) = "and"
        ├── @ OrNode (location: (19,0)-(19,14))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ CallNode (location: (19,0)-(19,5))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (19,0)-(19,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (19,4)-(19,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (19,4)-(19,5))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── right:
        │   │   @ CallNode (location: (19,9)-(19,14))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (19,9)-(19,12) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (19,13)-(19,14))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (19,13)-(19,14))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (19,6)-(19,8) = "or"
        ├── @ CallNode (location: (21,0)-(21,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (21,4)-(21,9))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (21,4)-(21,7) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (21,8)-(21,9))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (21,8)-(21,9))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :!
        │   ├── message_loc: (21,0)-(21,3) = "not"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ LocalVariableWriteNode (location: (23,0)-(23,17))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── depth: 0
        │   ├── name_loc: (23,0)-(23,3) = "foo"
        │   ├── value:
        │   │   @ LocalVariableWriteNode (location: (23,6)-(23,17))
        │   │   ├── flags: ∅
        │   │   ├── name: :bar
        │   │   ├── depth: 0
        │   │   ├── name_loc: (23,6)-(23,9) = "bar"
        │   │   ├── value:
        │   │   │   @ CallNode (location: (23,12)-(23,17))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :baz
        │   │   │   ├── message_loc: (23,12)-(23,15) = "baz"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (23,16)-(23,17))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (23,16)-(23,17))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── operator_loc: (23,10)-(23,11) = "="
        │   └── operator_loc: (23,4)-(23,5) = "="
        ├── @ DefNode (location: (25,0)-(25,15))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (25,4)-(25,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (25,10)-(25,15))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (25,10)-(25,15))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (25,10)-(25,13) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (25,14)-(25,15))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (25,14)-(25,15))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (25,0)-(25,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (25,8)-(25,9) = "="
        │   └── end_keyword_loc: ∅
        ├── @ CallNode (location: (27,0)-(27,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (27,0)-(27,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: (27,1)-(27,2) = "."
        │   ├── name: :foo
        │   ├── message_loc: (27,2)-(27,5) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (27,6)-(27,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (27,6)-(27,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (29,0)-(29,11))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (29,0)-(29,5))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ IntegerNode (location: (29,0)-(29,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── call_operator_loc: (29,1)-(29,2) = "."
        │   │   ├── name: :foo
        │   │   ├── message_loc: (29,2)-(29,5) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (29,5)-(29,6) = "."
        │   ├── name: :bar
        │   ├── message_loc: (29,6)-(29,9) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (29,10)-(29,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (29,10)-(29,11))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (31,0)-(31,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (31,0)-(31,8))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (31,0)-(31,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── receiver:
        │   │   │   │   @ IntegerNode (location: (31,0)-(31,1))
        │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   └── value: 1
        │   │   │   ├── call_operator_loc: (31,1)-(31,2) = "."
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (31,2)-(31,5) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :[]
        │   │   ├── message_loc: (31,5)-(31,8) = "[2]"
        │   │   ├── opening_loc: (31,5)-(31,6) = "["
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (31,6)-(31,7))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (31,6)-(31,7))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: (31,7)-(31,8) = "]"
        │   │   └── block: ∅
        │   ├── call_operator_loc: (31,8)-(31,9) = "."
        │   ├── name: :bar
        │   ├── message_loc: (31,9)-(31,12) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (31,13)-(31,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (31,13)-(31,14))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 3
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (33,0)-(33,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (33,0)-(33,8))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ IntegerNode (location: (33,0)-(33,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── call_operator_loc: (33,1)-(33,2) = "."
        │   │   ├── name: :foo
        │   │   ├── message_loc: (33,2)-(33,5) = "foo"
        │   │   ├── opening_loc: (33,5)-(33,6) = "("
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (33,6)-(33,7))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (33,6)-(33,7))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: (33,7)-(33,8) = ")"
        │   │   └── block: ∅
        │   ├── call_operator_loc: (33,8)-(33,9) = "."
        │   ├── name: :bar
        │   ├── message_loc: (33,9)-(33,12) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (33,13)-(33,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (33,13)-(33,14))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 3
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (35,0)-(35,15))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (35,0)-(35,9))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ IntegerNode (location: (35,0)-(35,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── call_operator_loc: (35,1)-(35,2) = "."
        │   │   ├── name: :foo
        │   │   ├── message_loc: (35,2)-(35,5) = "foo"
        │   │   ├── opening_loc: (35,5)-(35,6) = "("
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: (35,8)-(35,9) = ")"
        │   │   └── block:
        │   │       @ BlockArgumentNode (location: (35,6)-(35,8))
        │   │       ├── flags: ∅
        │   │       ├── expression:
        │   │       │   @ IntegerNode (location: (35,7)-(35,8))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 2
        │   │       └── operator_loc: (35,6)-(35,7) = "&"
        │   ├── call_operator_loc: (35,9)-(35,10) = "."
        │   ├── name: :bar
        │   ├── message_loc: (35,10)-(35,13) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (35,14)-(35,15))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (35,14)-(35,15))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 3
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ AndNode (location: (37,0)-(37,17))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ CallNode (location: (37,0)-(37,6))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (37,1)-(37,6))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (37,1)-(37,4) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (37,5)-(37,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (37,5)-(37,6))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (37,0)-(37,1) = "!"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── right:
        │   │   @ CallNode (location: (37,11)-(37,17))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (37,12)-(37,17))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :bar
        │   │   │   ├── message_loc: (37,12)-(37,15) = "bar"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (37,16)-(37,17))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (37,16)-(37,17))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 2
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (37,11)-(37,12) = "!"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (37,7)-(37,10) = "and"
        ├── @ OrNode (location: (39,0)-(39,16))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ CallNode (location: (39,0)-(39,6))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (39,1)-(39,6))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (39,1)-(39,4) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (39,5)-(39,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (39,5)-(39,6))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (39,0)-(39,1) = "!"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── right:
        │   │   @ CallNode (location: (39,10)-(39,16))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (39,11)-(39,16))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :bar
        │   │   │   ├── message_loc: (39,11)-(39,14) = "bar"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (39,15)-(39,16))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (39,15)-(39,16))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 2
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (39,10)-(39,11) = "!"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (39,7)-(39,9) = "or"
        └── @ CallNode (location: (41,0)-(41,10))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (41,4)-(41,10))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ CallNode (location: (41,5)-(41,10))
            │   │   ├── flags: ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :foo
            │   │   ├── message_loc: (41,5)-(41,8) = "foo"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments:
            │   │   │   @ ArgumentsNode (location: (41,9)-(41,10))
            │   │   │   ├── flags: ∅
            │   │   │   └── arguments: (length: 1)
            │   │   │       └── @ IntegerNode (location: (41,9)-(41,10))
            │   │   │           ├── flags: static_literal, decimal
            │   │   │           └── value: 1
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :!
            │   ├── message_loc: (41,4)-(41,5) = "!"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :!
            ├── message_loc: (41,0)-(41,3) = "not"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/comment_single.txt000066400000000000000000000012051506127434000204360ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,3))
            ├── flags: newline, variable_call, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :foo
            ├── message_loc: (1,0)-(1,3) = "foo"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/comments.txt000066400000000000000000000150741506127434000172710ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(24,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(24,5))
    ├── flags: ∅
    └── body: (length: 9)
        ├── @ CallNode (location: (1,0)-(1,1))
        │   ├── flags: newline, variable_call, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (1,0)-(1,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,1))
        │   ├── flags: newline, variable_call, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :b
        │   ├── message_loc: (3,0)-(3,1) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (5,0)-(5,1))
        │   ├── flags: newline, variable_call, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :c
        │   ├── message_loc: (5,0)-(5,1) = "c"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (6,0)-(6,1))
        │   ├── flags: newline, variable_call, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :d
        │   ├── message_loc: (6,0)-(6,1) = "d"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (8,0)-(10,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (8,0)-(8,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :e
        │   │   ├── message_loc: (8,0)-(8,1) = "e"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (10,2)-(10,3) = "."
        │   ├── name: :f
        │   ├── message_loc: (10,3)-(10,4) = "f"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (12,0)-(14,2))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (12,0)-(12,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :g
        │   │   ├── message_loc: (12,0)-(12,1) = "g"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (14,0)-(14,1) = "."
        │   ├── name: :h
        │   ├── message_loc: (14,1)-(14,2) = "h"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (16,0)-(17,2))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (16,0)-(16,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :i
        │   │   ├── message_loc: (16,0)-(16,1) = "i"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (17,0)-(17,1) = "."
        │   ├── name: :j
        │   ├── message_loc: (17,1)-(17,2) = "j"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (19,0)-(20,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (19,0)-(19,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :k
        │   │   ├── message_loc: (19,0)-(19,1) = "k"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (20,2)-(20,3) = "."
        │   ├── name: :l
        │   ├── message_loc: (20,3)-(20,4) = "l"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (22,0)-(24,5))
            ├── flags: newline, safe_navigation
            ├── receiver:
            │   @ CallNode (location: (22,0)-(22,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :m
            │   ├── message_loc: (22,0)-(22,1) = "m"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (24,2)-(24,4) = "&."
            ├── name: :n
            ├── message_loc: (24,4)-(24,5) = "n"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/constants.txt000066400000000000000000001745571506127434000174740ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(184,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(184,10))
    ├── flags: ∅
    └── body: (length: 90)
        ├── @ ConstantPathNode (location: (1,0)-(1,4))
        │   ├── flags: newline
        │   ├── parent:
        │   │   @ ConstantReadNode (location: (1,0)-(1,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── name: :B
        │   ├── delimiter_loc: (1,1)-(1,3) = "::"
        │   └── name_loc: (1,3)-(1,4) = "B"
        ├── @ ConstantPathNode (location: (3,0)-(3,7))
        │   ├── flags: newline
        │   ├── parent:
        │   │   @ ConstantPathNode (location: (3,0)-(3,4))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (3,0)-(3,1))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :A
        │   │   ├── name: :B
        │   │   ├── delimiter_loc: (3,1)-(3,3) = "::"
        │   │   └── name_loc: (3,3)-(3,4) = "B"
        │   ├── name: :C
        │   ├── delimiter_loc: (3,4)-(3,6) = "::"
        │   └── name_loc: (3,6)-(3,7) = "C"
        ├── @ ConstantPathNode (location: (5,0)-(5,4))
        │   ├── flags: newline
        │   ├── parent:
        │   │   @ CallNode (location: (5,0)-(5,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (5,0)-(5,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── name: :B
        │   ├── delimiter_loc: (5,1)-(5,3) = "::"
        │   └── name_loc: (5,3)-(5,4) = "B"
        ├── @ ConstantPathWriteNode (location: (7,0)-(7,8))
        │   ├── flags: newline
        │   ├── target:
        │   │   @ ConstantPathNode (location: (7,0)-(7,4))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (7,0)-(7,1))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :A
        │   │   ├── name: :B
        │   │   ├── delimiter_loc: (7,1)-(7,3) = "::"
        │   │   └── name_loc: (7,3)-(7,4) = "B"
        │   ├── operator_loc: (7,5)-(7,6) = "="
        │   └── value:
        │       @ IntegerNode (location: (7,7)-(7,8))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ ConstantWriteNode (location: (9,0)-(9,5))
        │   ├── flags: newline
        │   ├── name: :A
        │   ├── name_loc: (9,0)-(9,1) = "A"
        │   ├── value:
        │   │   @ IntegerNode (location: (9,4)-(9,5))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (9,2)-(9,3) = "="
        ├── @ ConstantReadNode (location: (11,0)-(11,3))
        │   ├── flags: newline
        │   └── name: :ABC
        ├── @ CallNode (location: (13,0)-(13,5))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :Foo
        │   ├── message_loc: (13,0)-(13,3) = "Foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (13,4)-(13,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (13,4)-(13,5))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (15,0)-(15,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :Foo
        │   ├── message_loc: (15,0)-(15,3) = "Foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (15,4)-(15,8))
        │   │   ├── flags: contains_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (15,4)-(15,8))
        │   │           ├── flags: ∅
        │   │           ├── operator_loc: (15,4)-(15,5) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (15,5)-(15,8))
        │   │               ├── flags: variable_call, ignore_visibility
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :bar
        │   │               ├── message_loc: (15,5)-(15,8) = "bar"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (17,0)-(17,9))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :Foo
        │   ├── message_loc: (17,0)-(17,3) = "Foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (17,4)-(17,9))
        │   │   ├── flags: contains_keywords, contains_keyword_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (17,4)-(17,9))
        │   │           ├── flags: ∅
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocSplatNode (location: (17,4)-(17,9))
        │   │                   ├── flags: ∅
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (17,6)-(17,9))
        │   │                   │   ├── flags: variable_call, ignore_visibility
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── name: :bar
        │   │                   │   ├── message_loc: (17,6)-(17,9) = "bar"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── block: ∅
        │   │                   └── operator_loc: (17,4)-(17,6) = "**"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (19,0)-(19,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :Foo
        │   ├── message_loc: (19,0)-(19,3) = "Foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockArgumentNode (location: (19,4)-(19,8))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (19,5)-(19,8))
        │       │   ├── flags: variable_call, ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :bar
        │       │   ├── message_loc: (19,5)-(19,8) = "bar"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       └── operator_loc: (19,4)-(19,5) = "&"
        ├── @ CallNode (location: (21,0)-(21,13))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (21,0)-(21,3))
        │   │   ├── flags: ∅
        │   │   └── name: :Foo
        │   ├── call_operator_loc: (21,3)-(21,5) = "::"
        │   ├── name: :Bar
        │   ├── message_loc: (21,5)-(21,8) = "Bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (21,9)-(21,13))
        │   │   ├── flags: contains_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (21,9)-(21,13))
        │   │           ├── flags: ∅
        │   │           ├── operator_loc: (21,9)-(21,10) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (21,10)-(21,13))
        │   │               ├── flags: variable_call, ignore_visibility
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :baz
        │   │               ├── message_loc: (21,10)-(21,13) = "baz"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (23,0)-(23,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (23,0)-(23,3))
        │   │   ├── flags: ∅
        │   │   └── name: :Foo
        │   ├── call_operator_loc: (23,3)-(23,5) = "::"
        │   ├── name: :Bar
        │   ├── message_loc: (23,5)-(23,8) = "Bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (23,9)-(23,14))
        │   │   ├── flags: contains_keywords, contains_keyword_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (23,9)-(23,14))
        │   │           ├── flags: ∅
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocSplatNode (location: (23,9)-(23,14))
        │   │                   ├── flags: ∅
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (23,11)-(23,14))
        │   │                   │   ├── flags: variable_call, ignore_visibility
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── name: :baz
        │   │                   │   ├── message_loc: (23,11)-(23,14) = "baz"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── block: ∅
        │   │                   └── operator_loc: (23,9)-(23,11) = "**"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (25,0)-(25,13))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (25,0)-(25,3))
        │   │   ├── flags: ∅
        │   │   └── name: :Foo
        │   ├── call_operator_loc: (25,3)-(25,5) = "::"
        │   ├── name: :Bar
        │   ├── message_loc: (25,5)-(25,8) = "Bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockArgumentNode (location: (25,9)-(25,13))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (25,10)-(25,13))
        │       │   ├── flags: variable_call, ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :baz
        │       │   ├── message_loc: (25,10)-(25,13) = "baz"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       └── operator_loc: (25,9)-(25,10) = "&"
        ├── @ CallNode (location: (27,0)-(27,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantPathNode (location: (27,0)-(27,3))
        │   │   ├── flags: ∅
        │   │   ├── parent: ∅
        │   │   ├── name: :A
        │   │   ├── delimiter_loc: (27,0)-(27,2) = "::"
        │   │   └── name_loc: (27,2)-(27,3) = "A"
        │   ├── call_operator_loc: (27,3)-(27,5) = "::"
        │   ├── name: :foo
        │   ├── message_loc: (27,5)-(27,8) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ ConstantPathWriteNode (location: (29,0)-(29,7))
        │   ├── flags: newline
        │   ├── target:
        │   │   @ ConstantPathNode (location: (29,0)-(29,3))
        │   │   ├── flags: ∅
        │   │   ├── parent: ∅
        │   │   ├── name: :A
        │   │   ├── delimiter_loc: (29,0)-(29,2) = "::"
        │   │   └── name_loc: (29,2)-(29,3) = "A"
        │   ├── operator_loc: (29,4)-(29,5) = "="
        │   └── value:
        │       @ IntegerNode (location: (29,6)-(29,7))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ ConstantPathWriteNode (location: (31,0)-(31,10))
        │   ├── flags: newline
        │   ├── target:
        │   │   @ ConstantPathNode (location: (31,0)-(31,6))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantPathNode (location: (31,0)-(31,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── parent: ∅
        │   │   │   ├── name: :A
        │   │   │   ├── delimiter_loc: (31,0)-(31,2) = "::"
        │   │   │   └── name_loc: (31,2)-(31,3) = "A"
        │   │   ├── name: :B
        │   │   ├── delimiter_loc: (31,3)-(31,5) = "::"
        │   │   └── name_loc: (31,5)-(31,6) = "B"
        │   ├── operator_loc: (31,7)-(31,8) = "="
        │   └── value:
        │       @ IntegerNode (location: (31,9)-(31,10))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ ConstantPathNode (location: (33,0)-(33,6))
        │   ├── flags: newline
        │   ├── parent:
        │   │   @ ConstantPathNode (location: (33,0)-(33,3))
        │   │   ├── flags: ∅
        │   │   ├── parent: ∅
        │   │   ├── name: :A
        │   │   ├── delimiter_loc: (33,0)-(33,2) = "::"
        │   │   └── name_loc: (33,2)-(33,3) = "A"
        │   ├── name: :B
        │   ├── delimiter_loc: (33,3)-(33,5) = "::"
        │   └── name_loc: (33,5)-(33,6) = "B"
        ├── @ ConstantPathNode (location: (35,0)-(35,3))
        │   ├── flags: newline
        │   ├── parent: ∅
        │   ├── name: :A
        │   ├── delimiter_loc: (35,0)-(35,2) = "::"
        │   └── name_loc: (35,2)-(35,3) = "A"
        ├── @ CallNode (location: (37,0)-(37,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (37,0)-(37,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (37,1)-(37,3) = "::"
        │   ├── name: :false
        │   ├── message_loc: (37,3)-(37,8) = "false"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (39,0)-(39,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantPathNode (location: (39,0)-(39,4))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (39,0)-(39,1))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :A
        │   │   ├── name: :B
        │   │   ├── delimiter_loc: (39,1)-(39,3) = "::"
        │   │   └── name_loc: (39,3)-(39,4) = "B"
        │   ├── call_operator_loc: (39,4)-(39,6) = "::"
        │   ├── name: :true
        │   ├── message_loc: (39,6)-(39,10) = "true"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (41,0)-(41,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (41,0)-(41,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (41,1)-(41,3) = "::"
        │   ├── name: :&
        │   ├── message_loc: (41,3)-(41,4) = "&"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (43,0)-(43,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (43,0)-(43,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (43,1)-(43,3) = "::"
        │   ├── name: :`
        │   ├── message_loc: (43,3)-(43,4) = "`"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (45,0)-(45,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (45,0)-(45,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (45,1)-(45,3) = "::"
        │   ├── name: :!
        │   ├── message_loc: (45,3)-(45,4) = "!"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (47,0)-(47,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (47,0)-(47,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (47,1)-(47,3) = "::"
        │   ├── name: :!=
        │   ├── message_loc: (47,3)-(47,5) = "!="
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (49,0)-(49,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (49,0)-(49,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (49,1)-(49,3) = "::"
        │   ├── name: :^
        │   ├── message_loc: (49,3)-(49,4) = "^"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (51,0)-(51,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (51,0)-(51,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (51,1)-(51,3) = "::"
        │   ├── name: :==
        │   ├── message_loc: (51,3)-(51,5) = "=="
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (53,0)-(53,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (53,0)-(53,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (53,1)-(53,3) = "::"
        │   ├── name: :===
        │   ├── message_loc: (53,3)-(53,6) = "==="
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (55,0)-(55,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (55,0)-(55,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (55,1)-(55,3) = "::"
        │   ├── name: :=~
        │   ├── message_loc: (55,3)-(55,5) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (57,0)-(57,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (57,0)-(57,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (57,1)-(57,3) = "::"
        │   ├── name: :>
        │   ├── message_loc: (57,3)-(57,4) = ">"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (59,0)-(59,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (59,0)-(59,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (59,1)-(59,3) = "::"
        │   ├── name: :>=
        │   ├── message_loc: (59,3)-(59,5) = ">="
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (61,0)-(61,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (61,0)-(61,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (61,1)-(61,3) = "::"
        │   ├── name: :>>
        │   ├── message_loc: (61,3)-(61,5) = ">>"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (63,0)-(63,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (63,0)-(63,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (63,1)-(63,3) = "::"
        │   ├── name: :<<
        │   ├── message_loc: (63,3)-(63,5) = "<<"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ ConstantPathNode (location: (65,0)-(67,1))
        │   ├── flags: newline
        │   ├── parent:
        │   │   @ ConstantReadNode (location: (65,0)-(65,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── name: :C
        │   ├── delimiter_loc: (65,1)-(65,3) = "::"
        │   └── name_loc: (67,0)-(67,1) = "C"
        ├── @ CallNode (location: (69,0)-(69,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (69,0)-(69,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (69,1)-(69,3) = "::"
        │   ├── name: :alias
        │   ├── message_loc: (69,3)-(69,8) = "alias"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (71,0)-(71,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (71,0)-(71,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (71,1)-(71,3) = "::"
        │   ├── name: :and
        │   ├── message_loc: (71,3)-(71,6) = "and"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (73,0)-(73,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (73,0)-(73,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (73,1)-(73,3) = "::"
        │   ├── name: :begin
        │   ├── message_loc: (73,3)-(73,8) = "begin"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ ConstantPathNode (location: (75,0)-(75,8))
        │   ├── flags: newline
        │   ├── parent:
        │   │   @ ConstantReadNode (location: (75,0)-(75,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── name: :BEGIN
        │   ├── delimiter_loc: (75,1)-(75,3) = "::"
        │   └── name_loc: (75,3)-(75,8) = "BEGIN"
        ├── @ CallNode (location: (77,0)-(77,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (77,0)-(77,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (77,1)-(77,3) = "::"
        │   ├── name: :break
        │   ├── message_loc: (77,3)-(77,8) = "break"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (79,0)-(79,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (79,0)-(79,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (79,1)-(79,3) = "::"
        │   ├── name: :class
        │   ├── message_loc: (79,3)-(79,8) = "class"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (81,0)-(81,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (81,0)-(81,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (81,1)-(81,3) = "::"
        │   ├── name: :def
        │   ├── message_loc: (81,3)-(81,6) = "def"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (83,0)-(83,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (83,0)-(83,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (83,1)-(83,3) = "::"
        │   ├── name: :defined
        │   ├── message_loc: (83,3)-(83,10) = "defined"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (85,0)-(85,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (85,0)-(85,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (85,1)-(85,3) = "::"
        │   ├── name: :do
        │   ├── message_loc: (85,3)-(85,5) = "do"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (87,0)-(87,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (87,0)-(87,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (87,1)-(87,3) = "::"
        │   ├── name: :else
        │   ├── message_loc: (87,3)-(87,7) = "else"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (89,0)-(89,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (89,0)-(89,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (89,1)-(89,3) = "::"
        │   ├── name: :elsif
        │   ├── message_loc: (89,3)-(89,8) = "elsif"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (91,0)-(91,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (91,0)-(91,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (91,1)-(91,3) = "::"
        │   ├── name: :end
        │   ├── message_loc: (91,3)-(91,6) = "end"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ ConstantPathNode (location: (93,0)-(93,6))
        │   ├── flags: newline
        │   ├── parent:
        │   │   @ ConstantReadNode (location: (93,0)-(93,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── name: :END
        │   ├── delimiter_loc: (93,1)-(93,3) = "::"
        │   └── name_loc: (93,3)-(93,6) = "END"
        ├── @ CallNode (location: (95,0)-(95,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (95,0)-(95,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (95,1)-(95,3) = "::"
        │   ├── name: :ensure
        │   ├── message_loc: (95,3)-(95,9) = "ensure"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (97,0)-(97,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (97,0)-(97,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (97,1)-(97,3) = "::"
        │   ├── name: :false
        │   ├── message_loc: (97,3)-(97,8) = "false"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (99,0)-(99,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (99,0)-(99,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (99,1)-(99,3) = "::"
        │   ├── name: :for
        │   ├── message_loc: (99,3)-(99,6) = "for"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (101,0)-(101,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (101,0)-(101,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (101,1)-(101,3) = "::"
        │   ├── name: :if
        │   ├── message_loc: (101,3)-(101,5) = "if"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (103,0)-(103,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (103,0)-(103,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (103,1)-(103,3) = "::"
        │   ├── name: :in
        │   ├── message_loc: (103,3)-(103,5) = "in"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (105,0)-(105,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (105,0)-(105,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (105,1)-(105,3) = "::"
        │   ├── name: :next
        │   ├── message_loc: (105,3)-(105,7) = "next"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (107,0)-(107,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (107,0)-(107,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (107,1)-(107,3) = "::"
        │   ├── name: :nil
        │   ├── message_loc: (107,3)-(107,6) = "nil"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (109,0)-(109,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (109,0)-(109,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (109,1)-(109,3) = "::"
        │   ├── name: :not
        │   ├── message_loc: (109,3)-(109,6) = "not"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (111,0)-(111,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (111,0)-(111,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (111,1)-(111,3) = "::"
        │   ├── name: :or
        │   ├── message_loc: (111,3)-(111,5) = "or"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (113,0)-(113,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (113,0)-(113,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (113,1)-(113,3) = "::"
        │   ├── name: :redo
        │   ├── message_loc: (113,3)-(113,7) = "redo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (115,0)-(115,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (115,0)-(115,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (115,1)-(115,3) = "::"
        │   ├── name: :rescue
        │   ├── message_loc: (115,3)-(115,9) = "rescue"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (117,0)-(117,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (117,0)-(117,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (117,1)-(117,3) = "::"
        │   ├── name: :retry
        │   ├── message_loc: (117,3)-(117,8) = "retry"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (119,0)-(119,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (119,0)-(119,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (119,1)-(119,3) = "::"
        │   ├── name: :return
        │   ├── message_loc: (119,3)-(119,9) = "return"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (121,0)-(121,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (121,0)-(121,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (121,1)-(121,3) = "::"
        │   ├── name: :self
        │   ├── message_loc: (121,3)-(121,7) = "self"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (123,0)-(123,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (123,0)-(123,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (123,1)-(123,3) = "::"
        │   ├── name: :super
        │   ├── message_loc: (123,3)-(123,8) = "super"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (125,0)-(125,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (125,0)-(125,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (125,1)-(125,3) = "::"
        │   ├── name: :then
        │   ├── message_loc: (125,3)-(125,7) = "then"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (127,0)-(127,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (127,0)-(127,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (127,1)-(127,3) = "::"
        │   ├── name: :true
        │   ├── message_loc: (127,3)-(127,7) = "true"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (129,0)-(129,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (129,0)-(129,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (129,1)-(129,3) = "::"
        │   ├── name: :undef
        │   ├── message_loc: (129,3)-(129,8) = "undef"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (131,0)-(131,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (131,0)-(131,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (131,1)-(131,3) = "::"
        │   ├── name: :unless
        │   ├── message_loc: (131,3)-(131,9) = "unless"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (133,0)-(133,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (133,0)-(133,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (133,1)-(133,3) = "::"
        │   ├── name: :until
        │   ├── message_loc: (133,3)-(133,8) = "until"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (135,0)-(135,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (135,0)-(135,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (135,1)-(135,3) = "::"
        │   ├── name: :when
        │   ├── message_loc: (135,3)-(135,7) = "when"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (137,0)-(137,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (137,0)-(137,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (137,1)-(137,3) = "::"
        │   ├── name: :while
        │   ├── message_loc: (137,3)-(137,8) = "while"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (139,0)-(139,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (139,0)-(139,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (139,1)-(139,3) = "::"
        │   ├── name: :yield
        │   ├── message_loc: (139,3)-(139,8) = "yield"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (141,0)-(141,15))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (141,0)-(141,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (141,1)-(141,3) = "::"
        │   ├── name: :__ENCODING__
        │   ├── message_loc: (141,3)-(141,15) = "__ENCODING__"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (143,0)-(143,11))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (143,0)-(143,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (143,1)-(143,3) = "::"
        │   ├── name: :__FILE__
        │   ├── message_loc: (143,3)-(143,11) = "__FILE__"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (145,0)-(145,11))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (145,0)-(145,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (145,1)-(145,3) = "::"
        │   ├── name: :__LINE__
        │   ├── message_loc: (145,3)-(145,11) = "__LINE__"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (147,0)-(147,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (147,0)-(147,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (147,1)-(147,3) = "::"
        │   ├── name: :<
        │   ├── message_loc: (147,3)-(147,4) = "<"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (149,0)-(149,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (149,0)-(149,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (149,1)-(149,3) = "::"
        │   ├── name: :<=>
        │   ├── message_loc: (149,3)-(149,6) = "<=>"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (151,0)-(151,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (151,0)-(151,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (151,1)-(151,3) = "::"
        │   ├── name: :<<
        │   ├── message_loc: (151,3)-(151,5) = "<<"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (153,0)-(153,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (153,0)-(153,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (153,1)-(153,3) = "::"
        │   ├── name: :-
        │   ├── message_loc: (153,3)-(153,4) = "-"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (155,0)-(155,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (155,0)-(155,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (155,1)-(155,3) = "::"
        │   ├── name: :%
        │   ├── message_loc: (155,3)-(155,4) = "%"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (157,0)-(157,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (157,0)-(157,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (157,1)-(157,3) = "::"
        │   ├── name: :%
        │   ├── message_loc: (157,3)-(157,4) = "%"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (157,4)-(157,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (157,4)-(157,5))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :i
        │   │           ├── message_loc: (157,4)-(157,5) = "i"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (159,0)-(159,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (159,0)-(159,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (159,1)-(159,3) = "::"
        │   ├── name: :%
        │   ├── message_loc: (159,3)-(159,4) = "%"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (159,4)-(159,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (159,4)-(159,5))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :w
        │   │           ├── message_loc: (159,4)-(159,5) = "w"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (161,0)-(161,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (161,0)-(161,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (161,1)-(161,3) = "::"
        │   ├── name: :%
        │   ├── message_loc: (161,3)-(161,4) = "%"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (161,4)-(161,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (161,4)-(161,5))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :x
        │   │           ├── message_loc: (161,4)-(161,5) = "x"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (163,0)-(163,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (163,0)-(163,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (163,1)-(163,3) = "::"
        │   ├── name: :%
        │   ├── message_loc: (163,3)-(163,4) = "%"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (163,4)-(163,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ConstantReadNode (location: (163,4)-(163,5))
        │   │           ├── flags: ∅
        │   │           └── name: :I
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (165,0)-(165,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (165,0)-(165,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (165,1)-(165,3) = "::"
        │   ├── name: :%
        │   ├── message_loc: (165,3)-(165,4) = "%"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (165,4)-(165,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ConstantReadNode (location: (165,4)-(165,5))
        │   │           ├── flags: ∅
        │   │           └── name: :W
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (167,0)-(167,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (167,0)-(167,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (167,1)-(167,3) = "::"
        │   ├── name: :|
        │   ├── message_loc: (167,3)-(167,4) = "|"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (169,0)-(169,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (169,0)-(169,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (169,1)-(169,3) = "::"
        │   ├── name: :+
        │   ├── message_loc: (169,3)-(169,4) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (171,0)-(171,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (171,0)-(171,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (171,1)-(171,3) = "::"
        │   ├── name: :/
        │   ├── message_loc: (171,3)-(171,4) = "/"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (173,0)-(173,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (173,0)-(173,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (173,1)-(173,3) = "::"
        │   ├── name: :*
        │   ├── message_loc: (173,3)-(173,4) = "*"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (175,0)-(175,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (175,0)-(175,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (175,1)-(175,3) = "::"
        │   ├── name: :**
        │   ├── message_loc: (175,3)-(175,5) = "**"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (177,0)-(177,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (177,0)-(177,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (177,1)-(177,3) = "::"
        │   ├── name: :~
        │   ├── message_loc: (177,3)-(177,4) = "~"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ ConstantPathNode (location: (179,0)-(180,1))
        │   ├── flags: newline
        │   ├── parent:
        │   │   @ CallNode (location: (179,0)-(179,4))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ ConstantReadNode (location: (179,0)-(179,1))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :A
        │   │   ├── call_operator_loc: (179,1)-(179,3) = "::"
        │   │   ├── name: :_
        │   │   ├── message_loc: (179,3)-(179,4) = "_"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── name: :C
        │   ├── delimiter_loc: (179,4)-(179,6) = "::"
        │   └── name_loc: (180,0)-(180,1) = "C"
        └── @ RangeNode (location: (182,0)-(184,10))
            ├── flags: newline
            ├── left:
            │   @ CallNode (location: (182,0)-(182,4))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ ConstantReadNode (location: (182,0)-(182,1))
            │   │   ├── flags: ∅
            │   │   └── name: :A
            │   ├── call_operator_loc: (182,1)-(182,3) = "::"
            │   ├── name: :_
            │   ├── message_loc: (182,3)-(182,4) = "_"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── right:
            │   @ CallNode (location: (184,0)-(184,10))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ ConstantReadNode (location: (184,0)-(184,1))
            │   │   ├── flags: ∅
            │   │   └── name: :A
            │   ├── call_operator_loc: (184,1)-(184,3) = "::"
            │   ├── name: :__END__
            │   ├── message_loc: (184,3)-(184,10) = "__END__"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            └── operator_loc: (182,4)-(182,6) = ".."
prism-1.5.1/snapshots/dash_heredocs.txt000066400000000000000000000400071506127434000202310ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(57,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(57,11))
    ├── flags: ∅
    └── body: (length: 13)
        ├── @ StringNode (location: (1,0)-(1,6))
        │   ├── flags: newline
        │   ├── opening_loc: (1,0)-(1,6) = "<<-EOF"
        │   ├── content_loc: (2,0)-(3,0) = "  a\n"
        │   ├── closing_loc: (3,0)-(4,0) = "EOF\n"
        │   └── unescaped: "  a\n"
        ├── @ CallNode (location: (5,0)-(5,20))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ StringNode (location: (5,0)-(5,8))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (5,0)-(5,8) = "<<-FIRST"
        │   │   ├── content_loc: (6,0)-(7,0) = "  a\n"
        │   │   ├── closing_loc: (7,0)-(8,0) = "FIRST\n"
        │   │   └── unescaped: "  a\n"
        │   ├── call_operator_loc: ∅
        │   ├── name: :+
        │   ├── message_loc: (5,9)-(5,10) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (5,11)-(5,20))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (5,11)-(5,20))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (5,11)-(5,20) = "<<-SECOND"
        │   │           ├── content_loc: (8,0)-(9,0) = "  b\n"
        │   │           ├── closing_loc: (9,0)-(10,0) = "SECOND\n"
        │   │           └── unescaped: "  b\n"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ InterpolatedXStringNode (location: (11,0)-(11,8))
        │   ├── flags: newline
        │   ├── opening_loc: (11,0)-(11,8) = "<<-`EOF`"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (12,0)-(13,0))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (12,0)-(13,0) = "  a\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "  a\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (13,0)-(13,4))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (13,0)-(13,2) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (13,2)-(13,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (13,2)-(13,3))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :b
        │   │   │   │           ├── message_loc: (13,2)-(13,3) = "b"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── closing_loc: (13,3)-(13,4) = "}"
        │   │   └── @ StringNode (location: (13,4)-(14,0))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (13,4)-(14,0) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (14,0)-(15,0) = "EOF\n"
        ├── @ StringNode (location: (16,0)-(16,6))
        │   ├── flags: newline
        │   ├── opening_loc: (16,0)-(16,6) = "<<-EOF"
        │   ├── content_loc: (17,0)-(18,0) = "  a\n"
        │   ├── closing_loc: (18,0)-(19,0) = "EOF\n"
        │   └── unescaped: "  a\n"
        ├── @ StringNode (location: (20,0)-(20,6))
        │   ├── flags: newline
        │   ├── opening_loc: (20,0)-(20,6) = "<<-EOF"
        │   ├── content_loc: (21,0)-(23,0) = "  a\n  b\n"
        │   ├── closing_loc: (23,0)-(24,0) = "  EOF\n"
        │   └── unescaped: "  a\n  b\n"
        ├── @ InterpolatedStringNode (location: (25,0)-(25,8))
        │   ├── flags: newline
        │   ├── opening_loc: (25,0)-(25,8) = "<<-\"EOF\""
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (26,0)-(27,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (26,0)-(27,0) = "  a\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "  a\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (27,0)-(27,4))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (27,0)-(27,2) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (27,2)-(27,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (27,2)-(27,3))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :b
        │   │   │   │           ├── message_loc: (27,2)-(27,3) = "b"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── closing_loc: (27,3)-(27,4) = "}"
        │   │   └── @ StringNode (location: (27,4)-(28,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (27,4)-(28,0) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (28,0)-(29,0) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (30,0)-(30,6))
        │   ├── flags: newline
        │   ├── opening_loc: (30,0)-(30,6) = "<<-EOF"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (31,0)-(32,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (31,0)-(32,0) = "  a\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "  a\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (32,0)-(32,4))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (32,0)-(32,2) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (32,2)-(32,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (32,2)-(32,3))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :b
        │   │   │   │           ├── message_loc: (32,2)-(32,3) = "b"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── closing_loc: (32,3)-(32,4) = "}"
        │   │   └── @ StringNode (location: (32,4)-(33,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (32,4)-(33,0) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (33,0)-(34,0) = "EOF\n"
        ├── @ StringNode (location: (35,0)-(35,6))
        │   ├── flags: newline
        │   ├── opening_loc: (35,0)-(35,2) = "%#"
        │   ├── content_loc: (35,2)-(35,5) = "abc"
        │   ├── closing_loc: (35,5)-(35,6) = "#"
        │   └── unescaped: "abc"
        ├── @ StringNode (location: (37,0)-(37,6))
        │   ├── flags: newline
        │   ├── opening_loc: (37,0)-(37,6) = "<<-EOF"
        │   ├── content_loc: (38,0)-(40,0) = "  a\n  b\n"
        │   ├── closing_loc: (40,0)-(41,0) = "EOF\n"
        │   └── unescaped: "  a\n  b\n"
        ├── @ StringNode (location: (42,0)-(42,5))
        │   ├── flags: newline
        │   ├── opening_loc: (42,0)-(42,5) = "<<-''"
        │   ├── content_loc: (43,0)-(43,0) = ""
        │   ├── closing_loc: (43,0)-(44,0) = "\n"
        │   └── unescaped: ""
        ├── @ StringNode (location: (45,0)-(45,8))
        │   ├── flags: newline
        │   ├── opening_loc: (45,0)-(45,8) = "<<-'EOF'"
        │   ├── content_loc: (46,0)-(47,0) = "  a \#{1}\n"
        │   ├── closing_loc: (47,0)-(48,0) = "EOF\n"
        │   └── unescaped: "  a \#{1}\n"
        ├── @ CallNode (location: (49,0)-(49,11))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ StringNode (location: (49,0)-(49,4))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (49,0)-(49,4) = "<<-A"
        │   │   ├── content_loc: (50,0)-(51,0) = "  a\n"
        │   │   ├── closing_loc: (51,0)-(52,0) = "A\n"
        │   │   └── unescaped: "  a\n"
        │   ├── call_operator_loc: ∅
        │   ├── name: :+
        │   ├── message_loc: (49,5)-(49,6) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (49,7)-(49,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (49,7)-(49,11))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (49,7)-(49,11) = "<<-B"
        │   │           ├── parts: (length: 3)
        │   │           │   ├── @ StringNode (location: (52,0)-(53,2))
        │   │           │   │   ├── flags: static_literal, frozen
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (52,0)-(53,2) = "  b\n  "
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "  b\n  "
        │   │           │   ├── @ EmbeddedStatementsNode (location: (53,2)-(54,3))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── opening_loc: (53,2)-(53,4) = "\#{"
        │   │           │   │   ├── statements:
        │   │           │   │   │   @ StatementsNode (location: (53,4)-(53,5))
        │   │           │   │   │   ├── flags: ∅
        │   │           │   │   │   └── body: (length: 1)
        │   │           │   │   │       └── @ IntegerNode (location: (53,4)-(53,5))
        │   │           │   │   │           ├── flags: static_literal, decimal
        │   │           │   │   │           └── value: 2
        │   │           │   │   └── closing_loc: (54,2)-(54,3) = "}"
        │   │           │   └── @ StringNode (location: (54,3)-(55,0))
        │   │           │       ├── flags: static_literal, frozen
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (54,3)-(55,0) = "\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "\n"
        │   │           └── closing_loc: (55,0)-(56,0) = "B\n"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (57,0)-(57,11))
            ├── flags: newline
            ├── receiver:
            │   @ StringNode (location: (57,0)-(57,4))
            │   ├── flags: ∅
            │   ├── opening_loc: (57,0)-(57,4) = "<<-A"
            │   ├── content_loc: (58,0)-(59,0) = "  a\n"
            │   ├── closing_loc: (59,0)-(60,0) = "A\n"
            │   └── unescaped: "  a\n"
            ├── call_operator_loc: ∅
            ├── name: :+
            ├── message_loc: (57,5)-(57,6) = "+"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (57,7)-(57,11))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ InterpolatedStringNode (location: (57,7)-(57,11))
            │           ├── flags: ∅
            │           ├── opening_loc: (57,7)-(57,11) = "<<-B"
            │           ├── parts: (length: 3)
            │           │   ├── @ StringNode (location: (60,0)-(61,2))
            │           │   │   ├── flags: static_literal, frozen
            │           │   │   ├── opening_loc: ∅
            │           │   │   ├── content_loc: (60,0)-(61,2) = "  b\n  "
            │           │   │   ├── closing_loc: ∅
            │           │   │   └── unescaped: "  b\n  "
            │           │   ├── @ EmbeddedStatementsNode (location: (61,2)-(62,4))
            │           │   │   ├── flags: ∅
            │           │   │   ├── opening_loc: (61,2)-(61,4) = "\#{"
            │           │   │   ├── statements:
            │           │   │   │   @ StatementsNode (location: (62,2)-(62,3))
            │           │   │   │   ├── flags: ∅
            │           │   │   │   └── body: (length: 1)
            │           │   │   │       └── @ IntegerNode (location: (62,2)-(62,3))
            │           │   │   │           ├── flags: static_literal, decimal
            │           │   │   │           └── value: 2
            │           │   │   └── closing_loc: (62,3)-(62,4) = "}"
            │           │   └── @ StringNode (location: (62,4)-(63,0))
            │           │       ├── flags: static_literal, frozen
            │           │       ├── opening_loc: ∅
            │           │       ├── content_loc: (62,4)-(63,0) = "\n"
            │           │       ├── closing_loc: ∅
            │           │       └── unescaped: "\n"
            │           └── closing_loc: (63,0)-(64,0) = "B\n"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/defined.txt000066400000000000000000000144251506127434000170410ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(19,2))
├── flags: ∅
├── locals: [:x]
└── statements:
    @ StatementsNode (location: (1,0)-(19,2))
    ├── flags: ∅
    └── body: (length: 8)
        ├── @ AndNode (location: (1,0)-(1,25))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ DefinedNode (location: (1,0)-(1,10))
        │   │   ├── flags: ∅
        │   │   ├── lparen_loc: ∅
        │   │   ├── value:
        │   │   │   @ IntegerNode (location: (1,9)-(1,10))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── rparen_loc: ∅
        │   │   └── keyword_loc: (1,0)-(1,8) = "defined?"
        │   ├── right:
        │   │   @ DefinedNode (location: (1,15)-(1,25))
        │   │   ├── flags: ∅
        │   │   ├── lparen_loc: ∅
        │   │   ├── value:
        │   │   │   @ IntegerNode (location: (1,24)-(1,25))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 2
        │   │   ├── rparen_loc: ∅
        │   │   └── keyword_loc: (1,15)-(1,23) = "defined?"
        │   └── operator_loc: (1,11)-(1,14) = "and"
        ├── @ DefinedNode (location: (3,0)-(3,16))
        │   ├── flags: newline
        │   ├── lparen_loc: (3,8)-(3,9) = "("
        │   ├── value:
        │   │   @ LocalVariableOperatorWriteNode (location: (3,9)-(3,15))
        │   │   ├── flags: ∅
        │   │   ├── name_loc: (3,9)-(3,10) = "x"
        │   │   ├── binary_operator_loc: (3,11)-(3,13) = "%="
        │   │   ├── value:
        │   │   │   @ IntegerNode (location: (3,14)-(3,15))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 2
        │   │   ├── name: :x
        │   │   ├── binary_operator: :%
        │   │   └── depth: 0
        │   ├── rparen_loc: (3,15)-(3,16) = ")"
        │   └── keyword_loc: (3,0)-(3,8) = "defined?"
        ├── @ DefinedNode (location: (5,0)-(5,21))
        │   ├── flags: newline
        │   ├── lparen_loc: (5,8)-(5,9) = "("
        │   ├── value:
        │   │   @ AndNode (location: (5,9)-(5,20))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ CallNode (location: (5,9)-(5,12))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (5,9)-(5,12) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── right:
        │   │   │   @ CallNode (location: (5,17)-(5,20))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :bar
        │   │   │   ├── message_loc: (5,17)-(5,20) = "bar"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── operator_loc: (5,13)-(5,16) = "and"
        │   ├── rparen_loc: (5,20)-(5,21) = ")"
        │   └── keyword_loc: (5,0)-(5,8) = "defined?"
        ├── @ DefinedNode (location: (7,0)-(7,10))
        │   ├── flags: newline
        │   ├── lparen_loc: ∅
        │   ├── value:
        │   │   @ IntegerNode (location: (7,9)-(7,10))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── rparen_loc: ∅
        │   └── keyword_loc: (7,0)-(7,8) = "defined?"
        ├── @ DefinedNode (location: (9,0)-(10,1))
        │   ├── flags: newline
        │   ├── lparen_loc: (9,8)-(9,9) = "("
        │   ├── value:
        │   │   @ StringNode (location: (9,9)-(9,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (9,9)-(9,10) = "\""
        │   │   ├── content_loc: (9,10)-(9,13) = "foo"
        │   │   ├── closing_loc: (9,13)-(9,14) = "\""
        │   │   └── unescaped: "foo"
        │   ├── rparen_loc: (10,0)-(10,1) = ")"
        │   └── keyword_loc: (9,0)-(9,8) = "defined?"
        ├── @ DefinedNode (location: (12,0)-(13,1))
        │   ├── flags: newline
        │   ├── lparen_loc: ∅
        │   ├── value:
        │   │   @ IntegerNode (location: (13,0)-(13,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── rparen_loc: ∅
        │   └── keyword_loc: (12,0)-(12,8) = "defined?"
        ├── @ DefinedNode (location: (15,0)-(16,3))
        │   ├── flags: newline
        │   ├── lparen_loc: (16,0)-(16,1) = "("
        │   ├── value:
        │   │   @ IntegerNode (location: (16,1)-(16,2))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── rparen_loc: (16,2)-(16,3) = ")"
        │   └── keyword_loc: (15,0)-(15,8) = "defined?"
        └── @ DefinedNode (location: (18,0)-(19,2))
            ├── flags: newline
            ├── lparen_loc: ∅
            ├── value:
            │   @ ParenthesesNode (location: (19,0)-(19,2))
            │   ├── flags: ∅
            │   ├── body: ∅
            │   ├── opening_loc: (19,0)-(19,1) = "("
            │   └── closing_loc: (19,1)-(19,2) = ")"
            ├── rparen_loc: ∅
            └── keyword_loc: (18,0)-(18,8) = "defined?"
prism-1.5.1/snapshots/dos_endings.txt000066400000000000000000000151351506127434000177360ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(17,20))
├── flags: ∅
├── locals: [:x, :a]
└── statements:
    @ StatementsNode (location: (1,0)-(17,20))
    ├── flags: ∅
    └── body: (length: 5)
        ├── @ CallNode (location: (1,0)-(2,12))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :puts
        │   ├── message_loc: (1,0)-(1,4) = "puts"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,5)-(2,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (1,5)-(2,12))
        │   │           ├── flags: static_literal
        │   │           ├── opening_loc: ∅
        │   │           ├── parts: (length: 2)
        │   │           │   ├── @ StringNode (location: (1,5)-(1,9))
        │   │           │   │   ├── flags: static_literal, frozen
        │   │           │   │   ├── opening_loc: (1,5)-(1,6) = "\""
        │   │           │   │   ├── content_loc: (1,6)-(1,8) = "hi"
        │   │           │   │   ├── closing_loc: (1,8)-(1,9) = "\""
        │   │           │   │   └── unescaped: "hi"
        │   │           │   └── @ StringNode (location: (2,5)-(2,12))
        │   │           │       ├── flags: static_literal, frozen
        │   │           │       ├── opening_loc: (2,5)-(2,6) = "\""
        │   │           │       ├── content_loc: (2,6)-(2,11) = "there"
        │   │           │       ├── closing_loc: (2,11)-(2,12) = "\""
        │   │           │       └── unescaped: "there"
        │   │           └── closing_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ ArrayNode (location: (4,0)-(5,2))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 1)
        │   │   └── @ SymbolNode (location: (4,3)-(5,1))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: ∅
        │   │       ├── value_loc: (4,3)-(5,1) = "a\\\r\nb"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\nb"
        │   ├── opening_loc: (4,0)-(4,3) = "%I{"
        │   └── closing_loc: (5,1)-(5,2) = "}"
        ├── @ StringNode (location: (7,0)-(7,4))
        │   ├── flags: newline
        │   ├── opening_loc: (7,0)-(7,4) = "<<-E"
        │   ├── content_loc: (8,0)-(11,0) = "    1 \\\r\n    2\r\n    3\r\n"
        │   ├── closing_loc: (11,0)-(12,0) = "E\r\n"
        │   └── unescaped: "    1     2\n    3\n"
        ├── @ LocalVariableWriteNode (location: (13,0)-(15,0))
        │   ├── flags: newline
        │   ├── name: :x
        │   ├── depth: 0
        │   ├── name_loc: (13,0)-(13,1) = "x"
        │   ├── value:
        │   │   @ StringNode (location: (13,4)-(15,0))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (13,4)-(14,0) = "%\r\n"
        │   │   ├── content_loc: (14,0)-(14,0) = ""
        │   │   ├── closing_loc: (14,0)-(15,0) = "\r\n"
        │   │   └── unescaped: ""
        │   └── operator_loc: (13,2)-(13,3) = "="
        └── @ LocalVariableWriteNode (location: (17,0)-(17,20))
            ├── flags: newline
            ├── name: :a
            ├── depth: 0
            ├── name_loc: (17,0)-(17,1) = "a"
            ├── value:
            │   @ CallNode (location: (17,4)-(17,20))
            │   ├── flags: ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (17,4)-(17,7) = "foo"
            │   ├── opening_loc: (17,7)-(17,8) = "("
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (17,8)-(17,19))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 1)
            │   │       └── @ CallNode (location: (17,8)-(17,19))
            │   │           ├── flags: ∅
            │   │           ├── receiver:
            │   │           │   @ InterpolatedStringNode (location: (17,8)-(17,14))
            │   │           │   ├── flags: static_literal
            │   │           │   ├── opening_loc: (17,8)-(17,14) = "<<~EOF"
            │   │           │   ├── parts: (length: 2)
            │   │           │   │   ├── @ StringNode (location: (18,0)-(19,0))
            │   │           │   │   │   ├── flags: static_literal, frozen
            │   │           │   │   │   ├── opening_loc: ∅
            │   │           │   │   │   ├── content_loc: (18,0)-(19,0) = "\r\n"
            │   │           │   │   │   ├── closing_loc: ∅
            │   │           │   │   │   └── unescaped: "\n"
            │   │           │   │   └── @ StringNode (location: (19,0)-(20,0))
            │   │           │   │       ├── flags: static_literal, frozen
            │   │           │   │       ├── opening_loc: ∅
            │   │           │   │       ├── content_loc: (19,0)-(20,0) = "    baz\r\n"
            │   │           │   │       ├── closing_loc: ∅
            │   │           │   │       └── unescaped: "baz\n"
            │   │           │   └── closing_loc: (20,0)-(21,0) = "  EOF\r\n"
            │   │           ├── call_operator_loc: (17,14)-(17,15) = "."
            │   │           ├── name: :chop
            │   │           ├── message_loc: (17,15)-(17,19) = "chop"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   ├── closing_loc: (17,19)-(17,20) = ")"
            │   └── block: ∅
            └── operator_loc: (17,2)-(17,3) = "="
prism-1.5.1/snapshots/dstring.txt000066400000000000000000000222131506127434000171070ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(42,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(42,4))
    ├── flags: ∅
    └── body: (length: 11)
        ├── @ StringNode (location: (1,0)-(2,6))
        │   ├── flags: newline
        │   ├── opening_loc: (1,0)-(1,1) = "\""
        │   ├── content_loc: (1,1)-(2,5) = "foo\n  bar"
        │   ├── closing_loc: (2,5)-(2,6) = "\""
        │   └── unescaped: "foo\n  bar"
        ├── @ InterpolatedStringNode (location: (4,0)-(5,9))
        │   ├── flags: newline
        │   ├── opening_loc: (4,0)-(4,1) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (4,1)-(5,2))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (4,1)-(5,2) = "foo\n  "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo\n  "
        │   │   └── @ EmbeddedStatementsNode (location: (5,2)-(5,8))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (5,2)-(5,4) = "\#{"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (5,4)-(5,7))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (5,4)-(5,7))
        │   │       │           ├── flags: variable_call, ignore_visibility
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :bar
        │   │       │           ├── message_loc: (5,4)-(5,7) = "bar"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments: ∅
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       └── closing_loc: (5,7)-(5,8) = "}"
        │   └── closing_loc: (5,8)-(5,9) = "\""
        ├── @ InterpolatedStringNode (location: (7,0)-(9,2))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: ∅
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (7,0)-(8,2))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: (7,0)-(7,1) = "\""
        │   │   │   ├── content_loc: (7,1)-(8,1) = "fo\no"
        │   │   │   ├── closing_loc: (8,1)-(8,2) = "\""
        │   │   │   └── unescaped: "fo\no"
        │   │   └── @ StringNode (location: (8,3)-(9,2))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: (8,3)-(8,4) = "\""
        │   │       ├── content_loc: (8,4)-(9,1) = "ba\nr"
        │   │       ├── closing_loc: (9,1)-(9,2) = "\""
        │   │       └── unescaped: "ba\nr"
        │   └── closing_loc: ∅
        ├── @ StringNode (location: (11,0)-(13,1))
        │   ├── flags: newline
        │   ├── opening_loc: (11,0)-(11,1) = "\""
        │   ├── content_loc: (11,1)-(13,0) = "\nfoo\\\n"
        │   ├── closing_loc: (13,0)-(13,1) = "\""
        │   └── unescaped: "\nfoo"
        ├── @ StringNode (location: (15,0)-(17,1))
        │   ├── flags: newline
        │   ├── opening_loc: (15,0)-(15,1) = "\""
        │   ├── content_loc: (15,1)-(17,0) = "\nfoo\\\\\n"
        │   ├── closing_loc: (17,0)-(17,1) = "\""
        │   └── unescaped: "\nfoo\\\n"
        ├── @ StringNode (location: (19,0)-(21,1))
        │   ├── flags: newline
        │   ├── opening_loc: (19,0)-(19,1) = "\""
        │   ├── content_loc: (19,1)-(21,0) = "\nfoo\\\\\\\n"
        │   ├── closing_loc: (21,0)-(21,1) = "\""
        │   └── unescaped: "\nfoo\\"
        ├── @ StringNode (location: (23,0)-(25,1))
        │   ├── flags: newline
        │   ├── opening_loc: (23,0)-(23,1) = "\""
        │   ├── content_loc: (23,1)-(25,0) = "\nfoo\\\\\\\\\n"
        │   ├── closing_loc: (25,0)-(25,1) = "\""
        │   └── unescaped: "\nfoo\\\\\n"
        ├── @ StringNode (location: (27,0)-(29,1))
        │   ├── flags: newline
        │   ├── opening_loc: (27,0)-(27,1) = "\""
        │   ├── content_loc: (27,1)-(29,0) = "\nfoo\\\\\\\\\\\n"
        │   ├── closing_loc: (29,0)-(29,1) = "\""
        │   └── unescaped: "\nfoo\\\\"
        ├── @ InterpolatedStringNode (location: (31,0)-(35,1))
        │   ├── flags: newline
        │   ├── opening_loc: (31,0)-(31,1) = "\""
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (31,1)-(34,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (31,1)-(34,0) = "\nfoo\\\nb\\nar\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\nfoob\nar\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (34,0)-(34,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (34,0)-(34,2) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (34,2)-(34,3) = "}"
        │   │   └── @ StringNode (location: (34,3)-(35,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (34,3)-(35,0) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (35,0)-(35,1) = "\""
        ├── @ InterpolatedStringNode (location: (37,0)-(39,15))
        │   ├── flags: newline
        │   ├── opening_loc: (37,0)-(37,1) = "\""
        │   ├── parts: (length: 7)
        │   │   ├── @ StringNode (location: (37,1)-(38,2))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (37,1)-(38,2) = "foo\n\\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo\n\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (38,2)-(38,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (38,2)-(38,4) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (38,4)-(38,5) = "}"
        │   │   ├── @ StringNode (location: (38,5)-(38,12))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (38,5)-(38,12) = "bar\\n\\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "bar\n\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (38,12)-(38,15))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (38,12)-(38,14) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (38,14)-(38,15) = "}"
        │   │   ├── @ StringNode (location: (38,15)-(39,6))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (38,15)-(39,6) = "\na\\nb\\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\na\nb\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (39,6)-(39,9))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (39,6)-(39,8) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (39,8)-(39,9) = "}"
        │   │   └── @ StringNode (location: (39,9)-(39,14))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (39,9)-(39,14) = "\\nc\\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\nc\n"
        │   └── closing_loc: (39,14)-(39,15) = "\""
        └── @ StringNode (location: (41,0)-(42,4))
            ├── flags: newline
            ├── opening_loc: (41,0)-(41,1) = "\""
            ├── content_loc: (41,1)-(42,3) = "\n’"
            ├── closing_loc: (42,3)-(42,4) = "\""
            └── unescaped: "\n’"
prism-1.5.1/snapshots/dsym_str.txt000066400000000000000000000015541506127434000173060ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,4))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ SymbolNode (location: (1,0)-(2,6))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (1,0)-(1,2) = ":\""
        │   ├── value_loc: (1,2)-(2,5) = "foo\n  bar"
        │   ├── closing_loc: (2,5)-(2,6) = "\""
        │   └── unescaped: "foo\n  bar"
        └── @ SymbolNode (location: (4,0)-(5,4))
            ├── flags: newline, static_literal
            ├── opening_loc: (4,0)-(4,2) = ":\""
            ├── value_loc: (4,2)-(5,3) = "\n’"
            ├── closing_loc: (5,3)-(5,4) = "\""
            └── unescaped: "\n’"
prism-1.5.1/snapshots/embdoc_no_newline_at_end.txt000066400000000000000000000003141506127434000224130ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,0))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,0))
    ├── flags: ∅
    └── body: (length: 0)
prism-1.5.1/snapshots/emoji_method_calls.txt000066400000000000000000000026641506127434000212660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,12))
            ├── flags: newline, attribute_write
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,0)-(1,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (1,3)-(1,4) = "."
            ├── name: :🌊=
            ├── message_loc: (1,4)-(1,8) = "🌊"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,11)-(1,12))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,11)-(1,12))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/encoding_binary.txt000066400000000000000000000051201506127434000205650ustar00rootroot00000000000000@ ProgramNode (location: (3,0)-(9,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (3,0)-(9,8))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ StringNode (location: (3,0)-(3,6))
        │   ├── flags: newline
        │   ├── opening_loc: (3,0)-(3,1) = "\""
        │   ├── content_loc: (3,1)-(3,5) = "\\xcd"
        │   ├── closing_loc: (3,5)-(3,6) = "\""
        │   └── unescaped: "\xCD"
        ├── @ SymbolNode (location: (5,0)-(5,7))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (5,0)-(5,2) = ":\""
        │   ├── value_loc: (5,2)-(5,6) = "\\xcd"
        │   ├── closing_loc: (5,6)-(5,7) = "\""
        │   └── unescaped: "\xCD"
        ├── @ InterpolatedRegularExpressionNode (location: (7,0)-(7,11))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (7,0)-(7,1) = "/"
        │   ├── parts: (length: 1)
        │   │   └── @ EmbeddedStatementsNode (location: (7,1)-(7,10))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (7,1)-(7,3) = "\#{"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (7,3)-(7,9))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ StringNode (location: (7,3)-(7,9))
        │   │       │           ├── flags: static_literal, frozen
        │   │       │           ├── opening_loc: (7,3)-(7,4) = "\""
        │   │       │           ├── content_loc: (7,4)-(7,8) = "\\xcd"
        │   │       │           ├── closing_loc: (7,8)-(7,9) = "\""
        │   │       │           └── unescaped: "\xCD"
        │   │       └── closing_loc: (7,9)-(7,10) = "}"
        │   └── closing_loc: (7,10)-(7,11) = "/"
        └── @ ArrayNode (location: (9,0)-(9,8))
            ├── flags: newline
            ├── elements: (length: 1)
            │   └── @ StringNode (location: (9,3)-(9,7))
            │       ├── flags: ∅
            │       ├── opening_loc: ∅
            │       ├── content_loc: (9,3)-(9,7) = "\\xC0"
            │       ├── closing_loc: ∅
            │       └── unescaped: "\xC0"
            ├── opening_loc: (9,0)-(9,3) = "%W["
            └── closing_loc: (9,7)-(9,8) = "]"
prism-1.5.1/snapshots/encoding_euc_jp.txt000066400000000000000000000021301506127434000205440ustar00rootroot00000000000000@ ProgramNode (location: (4,0)-(6,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (4,0)-(6,14))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ StringNode (location: (4,0)-(4,10))
        │   ├── flags: newline
        │   ├── opening_loc: (4,0)-(4,1) = "\""
        │   ├── content_loc: (4,1)-(4,9) = "\\x8E\\x01"
        │   ├── closing_loc: (4,9)-(4,10) = "\""
        │   └── unescaped: "\x8E\x01"
        └── @ ArrayNode (location: (6,0)-(6,14))
            ├── flags: newline
            ├── elements: (length: 1)
            │   └── @ StringNode (location: (6,3)-(6,13))
            │       ├── flags: ∅
            │       ├── opening_loc: ∅
            │       ├── content_loc: (6,3)-(6,13) = "\"\\x8E\\x01\""
            │       ├── closing_loc: ∅
            │       └── unescaped: "\"\x8E\x01\""
            ├── opening_loc: (6,0)-(6,3) = "%W["
            └── closing_loc: (6,13)-(6,14) = "]"
prism-1.5.1/snapshots/endless_methods.txt000066400000000000000000000202771506127434000206250ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,15))
├── flags: ∅
├── locals: [:x]
└── statements:
    @ StatementsNode (location: (1,0)-(7,15))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ DefNode (location: (1,0)-(1,11))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (1,4)-(1,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (1,10)-(1,11))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (1,10)-(1,11))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (1,8)-(1,9) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (3,0)-(3,14))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (3,4)-(3,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (3,10)-(3,14))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (3,10)-(3,14))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :A
        │   │           ├── message_loc: (3,10)-(3,11) = "A"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (3,12)-(3,14))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ StringNode (location: (3,12)-(3,14))
        │   │           │           ├── flags: ∅
        │   │           │           ├── opening_loc: (3,12)-(3,13) = "\""
        │   │           │           ├── content_loc: (3,13)-(3,13) = ""
        │   │           │           ├── closing_loc: (3,13)-(3,14) = "\""
        │   │           │           └── unescaped: ""
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (3,0)-(3,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (3,8)-(3,9) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (5,0)-(5,22))
        │   ├── flags: newline
        │   ├── name: :method
        │   ├── name_loc: (5,4)-(5,10) = "method"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (5,13)-(5,22))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (5,13)-(5,22))
        │   │           ├── flags: ∅
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (5,13)-(5,18))
        │   │           │   ├── flags: ∅
        │   │           │   ├── receiver:
        │   │           │   │   @ IntegerNode (location: (5,13)-(5,14))
        │   │           │   │   ├── flags: static_literal, decimal
        │   │           │   │   └── value: 1
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :+
        │   │           │   ├── message_loc: (5,15)-(5,16) = "+"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments:
        │   │           │   │   @ ArgumentsNode (location: (5,17)-(5,18))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   └── arguments: (length: 1)
        │   │           │   │       └── @ IntegerNode (location: (5,17)-(5,18))
        │   │           │   │           ├── flags: static_literal, decimal
        │   │           │   │           └── value: 2
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :+
        │   │           ├── message_loc: (5,19)-(5,20) = "+"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (5,21)-(5,22))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (5,21)-(5,22))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 3
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (5,0)-(5,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (5,11)-(5,12) = "="
        │   └── end_keyword_loc: ∅
        └── @ LocalVariableWriteNode (location: (7,0)-(7,15))
            ├── flags: newline
            ├── name: :x
            ├── depth: 0
            ├── name_loc: (7,0)-(7,1) = "x"
            ├── value:
            │   @ DefNode (location: (7,4)-(7,15))
            │   ├── flags: ∅
            │   ├── name: :f
            │   ├── name_loc: (7,8)-(7,9) = "f"
            │   ├── receiver: ∅
            │   ├── parameters: ∅
            │   ├── body:
            │   │   @ StatementsNode (location: (7,12)-(7,15))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (7,12)-(7,15))
            │   │           ├── flags: ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :p
            │   │           ├── message_loc: (7,12)-(7,13) = "p"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments:
            │   │           │   @ ArgumentsNode (location: (7,14)-(7,15))
            │   │           │   ├── flags: ∅
            │   │           │   └── arguments: (length: 1)
            │   │           │       └── @ IntegerNode (location: (7,14)-(7,15))
            │   │           │           ├── flags: static_literal, decimal
            │   │           │           └── value: 1
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   ├── locals: []
            │   ├── def_keyword_loc: (7,4)-(7,7) = "def"
            │   ├── operator_loc: ∅
            │   ├── lparen_loc: ∅
            │   ├── rparen_loc: ∅
            │   ├── equal_loc: (7,10)-(7,11) = "="
            │   └── end_keyword_loc: ∅
            └── operator_loc: (7,2)-(7,3) = "="
prism-1.5.1/snapshots/endless_methods_command_call.txt000066400000000000000000000725421506127434000233200ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(8,31))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(8,31))
    ├── flags: ∅
    └── body: (length: 8)
        ├── @ CallNode (location: (1,0)-(1,30))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :private
        │   ├── message_loc: (1,0)-(1,7) = "private"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,8)-(1,30))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ DefNode (location: (1,8)-(1,30))
        │   │           ├── flags: ∅
        │   │           ├── name: :foo
        │   │           ├── name_loc: (1,12)-(1,15) = "foo"
        │   │           ├── receiver: ∅
        │   │           ├── parameters: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (1,18)-(1,30))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (1,18)-(1,30))
        │   │           │           ├── flags: ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :puts
        │   │           │           ├── message_loc: (1,18)-(1,22) = "puts"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (1,23)-(1,30))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ StringNode (location: (1,23)-(1,30))
        │   │           │           │           ├── flags: ∅
        │   │           │           │           ├── opening_loc: (1,23)-(1,24) = "\""
        │   │           │           │           ├── content_loc: (1,24)-(1,29) = "Hello"
        │   │           │           │           ├── closing_loc: (1,29)-(1,30) = "\""
        │   │           │           │           └── unescaped: "Hello"
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── locals: []
        │   │           ├── def_keyword_loc: (1,8)-(1,11) = "def"
        │   │           ├── operator_loc: ∅
        │   │           ├── lparen_loc: ∅
        │   │           ├── rparen_loc: ∅
        │   │           ├── equal_loc: (1,16)-(1,17) = "="
        │   │           └── end_keyword_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (2,0)-(2,39))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :private
        │   ├── message_loc: (2,0)-(2,7) = "private"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (2,8)-(2,39))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ DefNode (location: (2,8)-(2,39))
        │   │           ├── flags: ∅
        │   │           ├── name: :foo
        │   │           ├── name_loc: (2,12)-(2,15) = "foo"
        │   │           ├── receiver: ∅
        │   │           ├── parameters: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (2,18)-(2,39))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (2,18)-(2,39))
        │   │           │           ├── flags: ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :puts
        │   │           │           ├── message_loc: (2,18)-(2,22) = "puts"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (2,23)-(2,39))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   └── arguments: (length: 2)
        │   │           │           │       ├── @ StringNode (location: (2,23)-(2,30))
        │   │           │           │       │   ├── flags: ∅
        │   │           │           │       │   ├── opening_loc: (2,23)-(2,24) = "\""
        │   │           │           │       │   ├── content_loc: (2,24)-(2,29) = "Hello"
        │   │           │           │       │   ├── closing_loc: (2,29)-(2,30) = "\""
        │   │           │           │       │   └── unescaped: "Hello"
        │   │           │           │       └── @ StringNode (location: (2,32)-(2,39))
        │   │           │           │           ├── flags: ∅
        │   │           │           │           ├── opening_loc: (2,32)-(2,33) = "\""
        │   │           │           │           ├── content_loc: (2,33)-(2,38) = "World"
        │   │           │           │           ├── closing_loc: (2,38)-(2,39) = "\""
        │   │           │           │           └── unescaped: "World"
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── locals: []
        │   │           ├── def_keyword_loc: (2,8)-(2,11) = "def"
        │   │           ├── operator_loc: ∅
        │   │           ├── lparen_loc: ∅
        │   │           ├── rparen_loc: ∅
        │   │           ├── equal_loc: (2,16)-(2,17) = "="
        │   │           └── end_keyword_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,42))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :private
        │   ├── message_loc: (3,0)-(3,7) = "private"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,8)-(3,30))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ DefNode (location: (3,8)-(3,30))
        │   │           ├── flags: ∅
        │   │           ├── name: :foo
        │   │           ├── name_loc: (3,12)-(3,15) = "foo"
        │   │           ├── receiver: ∅
        │   │           ├── parameters: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (3,18)-(3,30))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (3,18)-(3,30))
        │   │           │           ├── flags: ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :puts
        │   │           │           ├── message_loc: (3,18)-(3,22) = "puts"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (3,23)-(3,30))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ StringNode (location: (3,23)-(3,30))
        │   │           │           │           ├── flags: ∅
        │   │           │           │           ├── opening_loc: (3,23)-(3,24) = "\""
        │   │           │           │           ├── content_loc: (3,24)-(3,29) = "Hello"
        │   │           │           │           ├── closing_loc: (3,29)-(3,30) = "\""
        │   │           │           │           └── unescaped: "Hello"
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── locals: []
        │   │           ├── def_keyword_loc: (3,8)-(3,11) = "def"
        │   │           ├── operator_loc: ∅
        │   │           ├── lparen_loc: ∅
        │   │           ├── rparen_loc: ∅
        │   │           ├── equal_loc: (3,16)-(3,17) = "="
        │   │           └── end_keyword_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (3,31)-(3,42))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (3,34)-(3,38))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (3,34)-(3,38))
        │       │           ├── flags: newline, variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :expr
        │       │           ├── message_loc: (3,34)-(3,38) = "expr"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (3,31)-(3,33) = "do"
        │       └── closing_loc: (3,39)-(3,42) = "end"
        ├── @ CallNode (location: (4,0)-(4,32))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :private
        │   ├── message_loc: (4,0)-(4,7) = "private"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (4,8)-(4,32))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ DefNode (location: (4,8)-(4,32))
        │   │           ├── flags: ∅
        │   │           ├── name: :foo
        │   │           ├── name_loc: (4,12)-(4,15) = "foo"
        │   │           ├── receiver: ∅
        │   │           ├── parameters: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (4,20)-(4,32))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (4,20)-(4,32))
        │   │           │           ├── flags: ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :puts
        │   │           │           ├── message_loc: (4,20)-(4,24) = "puts"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (4,25)-(4,32))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ StringNode (location: (4,25)-(4,32))
        │   │           │           │           ├── flags: ∅
        │   │           │           │           ├── opening_loc: (4,25)-(4,26) = "\""
        │   │           │           │           ├── content_loc: (4,26)-(4,31) = "Hello"
        │   │           │           │           ├── closing_loc: (4,31)-(4,32) = "\""
        │   │           │           │           └── unescaped: "Hello"
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── locals: []
        │   │           ├── def_keyword_loc: (4,8)-(4,11) = "def"
        │   │           ├── operator_loc: ∅
        │   │           ├── lparen_loc: (4,15)-(4,16) = "("
        │   │           ├── rparen_loc: (4,16)-(4,17) = ")"
        │   │           ├── equal_loc: (4,18)-(4,19) = "="
        │   │           └── end_keyword_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (5,0)-(5,27))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :private
        │   ├── message_loc: (5,0)-(5,7) = "private"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (5,8)-(5,27))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ DefNode (location: (5,8)-(5,27))
        │   │           ├── flags: ∅
        │   │           ├── name: :foo
        │   │           ├── name_loc: (5,12)-(5,15) = "foo"
        │   │           ├── receiver: ∅
        │   │           ├── parameters:
        │   │           │   @ ParametersNode (location: (5,16)-(5,17))
        │   │           │   ├── flags: ∅
        │   │           │   ├── requireds: (length: 1)
        │   │           │   │   └── @ RequiredParameterNode (location: (5,16)-(5,17))
        │   │           │   │       ├── flags: ∅
        │   │           │   │       └── name: :x
        │   │           │   ├── optionals: (length: 0)
        │   │           │   ├── rest: ∅
        │   │           │   ├── posts: (length: 0)
        │   │           │   ├── keywords: (length: 0)
        │   │           │   ├── keyword_rest: ∅
        │   │           │   └── block: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (5,21)-(5,27))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (5,21)-(5,27))
        │   │           │           ├── flags: ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :puts
        │   │           │           ├── message_loc: (5,21)-(5,25) = "puts"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (5,26)-(5,27))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ LocalVariableReadNode (location: (5,26)-(5,27))
        │   │           │           │           ├── flags: ∅
        │   │           │           │           ├── name: :x
        │   │           │           │           └── depth: 0
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── locals: [:x]
        │   │           ├── def_keyword_loc: (5,8)-(5,11) = "def"
        │   │           ├── operator_loc: ∅
        │   │           ├── lparen_loc: (5,15)-(5,16) = "("
        │   │           ├── rparen_loc: (5,17)-(5,18) = ")"
        │   │           ├── equal_loc: (5,19)-(5,20) = "="
        │   │           └── end_keyword_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (6,0)-(6,34))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :private
        │   ├── message_loc: (6,0)-(6,7) = "private"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (6,8)-(6,34))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ DefNode (location: (6,8)-(6,34))
        │   │           ├── flags: ∅
        │   │           ├── name: :foo
        │   │           ├── name_loc: (6,16)-(6,19) = "foo"
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (6,12)-(6,15))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :obj
        │   │           │   ├── message_loc: (6,12)-(6,15) = "obj"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── parameters: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (6,22)-(6,34))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (6,22)-(6,34))
        │   │           │           ├── flags: ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :puts
        │   │           │           ├── message_loc: (6,22)-(6,26) = "puts"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (6,27)-(6,34))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ StringNode (location: (6,27)-(6,34))
        │   │           │           │           ├── flags: ∅
        │   │           │           │           ├── opening_loc: (6,27)-(6,28) = "\""
        │   │           │           │           ├── content_loc: (6,28)-(6,33) = "Hello"
        │   │           │           │           ├── closing_loc: (6,33)-(6,34) = "\""
        │   │           │           │           └── unescaped: "Hello"
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── locals: []
        │   │           ├── def_keyword_loc: (6,8)-(6,11) = "def"
        │   │           ├── operator_loc: (6,15)-(6,16) = "."
        │   │           ├── lparen_loc: ∅
        │   │           ├── rparen_loc: ∅
        │   │           ├── equal_loc: (6,20)-(6,21) = "="
        │   │           └── end_keyword_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (7,0)-(7,36))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :private
        │   ├── message_loc: (7,0)-(7,7) = "private"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (7,8)-(7,36))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ DefNode (location: (7,8)-(7,36))
        │   │           ├── flags: ∅
        │   │           ├── name: :foo
        │   │           ├── name_loc: (7,16)-(7,19) = "foo"
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (7,12)-(7,15))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :obj
        │   │           │   ├── message_loc: (7,12)-(7,15) = "obj"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── parameters: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (7,24)-(7,36))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (7,24)-(7,36))
        │   │           │           ├── flags: ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :puts
        │   │           │           ├── message_loc: (7,24)-(7,28) = "puts"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (7,29)-(7,36))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ StringNode (location: (7,29)-(7,36))
        │   │           │           │           ├── flags: ∅
        │   │           │           │           ├── opening_loc: (7,29)-(7,30) = "\""
        │   │           │           │           ├── content_loc: (7,30)-(7,35) = "Hello"
        │   │           │           │           ├── closing_loc: (7,35)-(7,36) = "\""
        │   │           │           │           └── unescaped: "Hello"
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── locals: []
        │   │           ├── def_keyword_loc: (7,8)-(7,11) = "def"
        │   │           ├── operator_loc: (7,15)-(7,16) = "."
        │   │           ├── lparen_loc: (7,19)-(7,20) = "("
        │   │           ├── rparen_loc: (7,20)-(7,21) = ")"
        │   │           ├── equal_loc: (7,22)-(7,23) = "="
        │   │           └── end_keyword_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (8,0)-(8,31))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :private
            ├── message_loc: (8,0)-(8,7) = "private"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (8,8)-(8,31))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ DefNode (location: (8,8)-(8,31))
            │           ├── flags: ∅
            │           ├── name: :foo
            │           ├── name_loc: (8,16)-(8,19) = "foo"
            │           ├── receiver:
            │           │   @ CallNode (location: (8,12)-(8,15))
            │           │   ├── flags: variable_call, ignore_visibility
            │           │   ├── receiver: ∅
            │           │   ├── call_operator_loc: ∅
            │           │   ├── name: :obj
            │           │   ├── message_loc: (8,12)-(8,15) = "obj"
            │           │   ├── opening_loc: ∅
            │           │   ├── arguments: ∅
            │           │   ├── closing_loc: ∅
            │           │   └── block: ∅
            │           ├── parameters:
            │           │   @ ParametersNode (location: (8,20)-(8,21))
            │           │   ├── flags: ∅
            │           │   ├── requireds: (length: 1)
            │           │   │   └── @ RequiredParameterNode (location: (8,20)-(8,21))
            │           │   │       ├── flags: ∅
            │           │   │       └── name: :x
            │           │   ├── optionals: (length: 0)
            │           │   ├── rest: ∅
            │           │   ├── posts: (length: 0)
            │           │   ├── keywords: (length: 0)
            │           │   ├── keyword_rest: ∅
            │           │   └── block: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (8,25)-(8,31))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ CallNode (location: (8,25)-(8,31))
            │           │           ├── flags: ignore_visibility
            │           │           ├── receiver: ∅
            │           │           ├── call_operator_loc: ∅
            │           │           ├── name: :puts
            │           │           ├── message_loc: (8,25)-(8,29) = "puts"
            │           │           ├── opening_loc: ∅
            │           │           ├── arguments:
            │           │           │   @ ArgumentsNode (location: (8,30)-(8,31))
            │           │           │   ├── flags: ∅
            │           │           │   └── arguments: (length: 1)
            │           │           │       └── @ LocalVariableReadNode (location: (8,30)-(8,31))
            │           │           │           ├── flags: ∅
            │           │           │           ├── name: :x
            │           │           │           └── depth: 0
            │           │           ├── closing_loc: ∅
            │           │           └── block: ∅
            │           ├── locals: [:x]
            │           ├── def_keyword_loc: (8,8)-(8,11) = "def"
            │           ├── operator_loc: (8,15)-(8,16) = "."
            │           ├── lparen_loc: (8,19)-(8,20) = "("
            │           ├── rparen_loc: (8,21)-(8,22) = ")"
            │           ├── equal_loc: (8,23)-(8,24) = "="
            │           └── end_keyword_loc: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/endless_range_in_conditional.txt000066400000000000000000000052751506127434000233300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,12))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ IfNode (location: (1,0)-(1,13))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (1,0)-(1,2) = "if"
        │   ├── predicate:
        │   │   @ FlipFlopNode (location: (1,3)-(1,7))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (1,3)-(1,4))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (1,6)-(1,7))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 2
        │   │   └── operator_loc: (1,4)-(1,6) = ".."
        │   ├── then_keyword_loc: ∅
        │   ├── statements: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (1,10)-(1,13) = "end"
        ├── @ IfNode (location: (2,0)-(2,12))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (2,0)-(2,2) = "if"
        │   ├── predicate:
        │   │   @ FlipFlopNode (location: (2,3)-(2,6))
        │   │   ├── flags: static_literal
        │   │   ├── left: ∅
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (2,5)-(2,6))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   └── operator_loc: (2,3)-(2,5) = ".."
        │   ├── then_keyword_loc: ∅
        │   ├── statements: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (2,9)-(2,12) = "end"
        └── @ IfNode (location: (3,0)-(3,12))
            ├── flags: newline
            ├── if_keyword_loc: (3,0)-(3,2) = "if"
            ├── predicate:
            │   @ FlipFlopNode (location: (3,3)-(3,6))
            │   ├── flags: static_literal
            │   ├── left:
            │   │   @ IntegerNode (location: (3,3)-(3,4))
            │   │   ├── flags: static_literal, decimal
            │   │   └── value: 1
            │   ├── right: ∅
            │   └── operator_loc: (3,4)-(3,6) = ".."
            ├── then_keyword_loc: ∅
            ├── statements: ∅
            ├── subsequent: ∅
            └── end_keyword_loc: (3,9)-(3,12) = "end"
prism-1.5.1/snapshots/for.txt000066400000000000000000000260351506127434000162310ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(19,22))
├── flags: ∅
├── locals: [:i, :j, :k]
└── statements:
    @ StatementsNode (location: (1,0)-(19,22))
    ├── flags: ∅
    └── body: (length: 6)
        ├── @ ForNode (location: (1,0)-(3,3))
        │   ├── flags: newline
        │   ├── index:
        │   │   @ LocalVariableTargetNode (location: (1,4)-(1,5))
        │   │   ├── flags: ∅
        │   │   ├── name: :i
        │   │   └── depth: 0
        │   ├── collection:
        │   │   @ RangeNode (location: (1,9)-(1,14))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (1,9)-(1,10))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (1,12)-(1,14))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 10
        │   │   └── operator_loc: (1,10)-(1,12) = ".."
        │   ├── statements:
        │   │   @ StatementsNode (location: (2,0)-(2,1))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (2,0)-(2,1))
        │   │           ├── flags: newline
        │   │           ├── name: :i
        │   │           └── depth: 0
        │   ├── for_keyword_loc: (1,0)-(1,3) = "for"
        │   ├── in_keyword_loc: (1,6)-(1,8) = "in"
        │   ├── do_keyword_loc: ∅
        │   └── end_keyword_loc: (3,0)-(3,3) = "end"
        ├── @ ForNode (location: (5,0)-(5,22))
        │   ├── flags: newline
        │   ├── index:
        │   │   @ LocalVariableTargetNode (location: (5,4)-(5,5))
        │   │   ├── flags: ∅
        │   │   ├── name: :i
        │   │   └── depth: 0
        │   ├── collection:
        │   │   @ RangeNode (location: (5,9)-(5,14))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (5,9)-(5,10))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (5,12)-(5,14))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 10
        │   │   └── operator_loc: (5,10)-(5,12) = ".."
        │   ├── statements:
        │   │   @ StatementsNode (location: (5,16)-(5,17))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (5,16)-(5,17))
        │   │           ├── flags: newline
        │   │           ├── name: :i
        │   │           └── depth: 0
        │   ├── for_keyword_loc: (5,0)-(5,3) = "for"
        │   ├── in_keyword_loc: (5,6)-(5,8) = "in"
        │   ├── do_keyword_loc: ∅
        │   └── end_keyword_loc: (5,19)-(5,22) = "end"
        ├── @ ForNode (location: (7,0)-(9,3))
        │   ├── flags: newline
        │   ├── index:
        │   │   @ MultiTargetNode (location: (7,4)-(7,7))
        │   │   ├── flags: ∅
        │   │   ├── lefts: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (7,4)-(7,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :i
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (7,6)-(7,7))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :j
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── rights: (length: 0)
        │   │   ├── lparen_loc: ∅
        │   │   └── rparen_loc: ∅
        │   ├── collection:
        │   │   @ RangeNode (location: (7,11)-(7,16))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (7,11)-(7,12))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (7,14)-(7,16))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 10
        │   │   └── operator_loc: (7,12)-(7,14) = ".."
        │   ├── statements:
        │   │   @ StatementsNode (location: (8,0)-(8,1))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (8,0)-(8,1))
        │   │           ├── flags: newline
        │   │           ├── name: :i
        │   │           └── depth: 0
        │   ├── for_keyword_loc: (7,0)-(7,3) = "for"
        │   ├── in_keyword_loc: (7,8)-(7,10) = "in"
        │   ├── do_keyword_loc: ∅
        │   └── end_keyword_loc: (9,0)-(9,3) = "end"
        ├── @ ForNode (location: (11,0)-(13,3))
        │   ├── flags: newline
        │   ├── index:
        │   │   @ MultiTargetNode (location: (11,4)-(11,9))
        │   │   ├── flags: ∅
        │   │   ├── lefts: (length: 3)
        │   │   │   ├── @ LocalVariableTargetNode (location: (11,4)-(11,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :i
        │   │   │   │   └── depth: 0
        │   │   │   ├── @ LocalVariableTargetNode (location: (11,6)-(11,7))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :j
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (11,8)-(11,9))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :k
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── rights: (length: 0)
        │   │   ├── lparen_loc: ∅
        │   │   └── rparen_loc: ∅
        │   ├── collection:
        │   │   @ RangeNode (location: (11,13)-(11,18))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (11,13)-(11,14))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (11,16)-(11,18))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 10
        │   │   └── operator_loc: (11,14)-(11,16) = ".."
        │   ├── statements:
        │   │   @ StatementsNode (location: (12,0)-(12,1))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (12,0)-(12,1))
        │   │           ├── flags: newline
        │   │           ├── name: :i
        │   │           └── depth: 0
        │   ├── for_keyword_loc: (11,0)-(11,3) = "for"
        │   ├── in_keyword_loc: (11,10)-(11,12) = "in"
        │   ├── do_keyword_loc: ∅
        │   └── end_keyword_loc: (13,0)-(13,3) = "end"
        ├── @ ForNode (location: (15,0)-(17,3))
        │   ├── flags: newline
        │   ├── index:
        │   │   @ LocalVariableTargetNode (location: (15,4)-(15,5))
        │   │   ├── flags: ∅
        │   │   ├── name: :i
        │   │   └── depth: 0
        │   ├── collection:
        │   │   @ RangeNode (location: (15,9)-(15,14))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (15,9)-(15,10))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (15,12)-(15,14))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 10
        │   │   └── operator_loc: (15,10)-(15,12) = ".."
        │   ├── statements:
        │   │   @ StatementsNode (location: (16,0)-(16,1))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (16,0)-(16,1))
        │   │           ├── flags: newline
        │   │           ├── name: :i
        │   │           └── depth: 0
        │   ├── for_keyword_loc: (15,0)-(15,3) = "for"
        │   ├── in_keyword_loc: (15,6)-(15,8) = "in"
        │   ├── do_keyword_loc: (15,15)-(15,17) = "do"
        │   └── end_keyword_loc: (17,0)-(17,3) = "end"
        └── @ ForNode (location: (19,0)-(19,22))
            ├── flags: newline
            ├── index:
            │   @ LocalVariableTargetNode (location: (19,4)-(19,5))
            │   ├── flags: ∅
            │   ├── name: :i
            │   └── depth: 0
            ├── collection:
            │   @ RangeNode (location: (19,9)-(19,14))
            │   ├── flags: static_literal
            │   ├── left:
            │   │   @ IntegerNode (location: (19,9)-(19,10))
            │   │   ├── flags: static_literal, decimal
            │   │   └── value: 1
            │   ├── right:
            │   │   @ IntegerNode (location: (19,12)-(19,14))
            │   │   ├── flags: static_literal, decimal
            │   │   └── value: 10
            │   └── operator_loc: (19,10)-(19,12) = ".."
            ├── statements:
            │   @ StatementsNode (location: (19,16)-(19,17))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ LocalVariableReadNode (location: (19,16)-(19,17))
            │           ├── flags: newline
            │           ├── name: :i
            │           └── depth: 0
            ├── for_keyword_loc: (19,0)-(19,3) = "for"
            ├── in_keyword_loc: (19,6)-(19,8) = "in"
            ├── do_keyword_loc: ∅
            └── end_keyword_loc: (19,19)-(19,22) = "end"
prism-1.5.1/snapshots/global_variables.txt000066400000000000000000000262701506127434000207340ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(93,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(93,4))
    ├── flags: ∅
    └── body: (length: 47)
        ├── @ GlobalVariableReadNode (location: (1,0)-(1,16))
        │   ├── flags: newline
        │   └── name: :$global_variable
        ├── @ GlobalVariableReadNode (location: (3,0)-(3,2))
        │   ├── flags: newline
        │   └── name: :$_
        ├── @ GlobalVariableReadNode (location: (5,0)-(5,3))
        │   ├── flags: newline
        │   └── name: :$-w
        ├── @ GlobalVariableReadNode (location: (7,0)-(7,10))
        │   ├── flags: newline
        │   └── name: :$LOAD_PATH
        ├── @ GlobalVariableReadNode (location: (9,0)-(9,6))
        │   ├── flags: newline
        │   └── name: :$stdin
        ├── @ GlobalVariableReadNode (location: (11,0)-(11,7))
        │   ├── flags: newline
        │   └── name: :$stdout
        ├── @ GlobalVariableReadNode (location: (13,0)-(13,7))
        │   ├── flags: newline
        │   └── name: :$stderr
        ├── @ GlobalVariableReadNode (location: (15,0)-(15,2))
        │   ├── flags: newline
        │   └── name: :$!
        ├── @ GlobalVariableReadNode (location: (17,0)-(17,2))
        │   ├── flags: newline
        │   └── name: :$?
        ├── @ GlobalVariableReadNode (location: (19,0)-(19,2))
        │   ├── flags: newline
        │   └── name: :$~
        ├── @ BackReferenceReadNode (location: (21,0)-(21,2))
        │   ├── flags: newline
        │   └── name: :$&
        ├── @ BackReferenceReadNode (location: (23,0)-(23,2))
        │   ├── flags: newline
        │   └── name: :$`
        ├── @ BackReferenceReadNode (location: (25,0)-(25,2))
        │   ├── flags: newline
        │   └── name: :$'
        ├── @ BackReferenceReadNode (location: (27,0)-(27,2))
        │   ├── flags: newline
        │   └── name: :$+
        ├── @ GlobalVariableReadNode (location: (29,0)-(29,2))
        │   ├── flags: newline
        │   └── name: :$:
        ├── @ GlobalVariableReadNode (location: (31,0)-(31,2))
        │   ├── flags: newline
        │   └── name: :$;
        ├── @ GlobalVariableReadNode (location: (33,0)-(33,2))
        │   ├── flags: newline
        │   └── name: :$,
        ├── @ GlobalVariableReadNode (location: (35,0)-(35,6))
        │   ├── flags: newline
        │   └── name: :$DEBUG
        ├── @ GlobalVariableReadNode (location: (37,0)-(37,9))
        │   ├── flags: newline
        │   └── name: :$FILENAME
        ├── @ GlobalVariableReadNode (location: (39,0)-(39,2))
        │   ├── flags: newline
        │   └── name: :$0
        ├── @ GlobalVariableReadNode (location: (41,0)-(41,3))
        │   ├── flags: newline
        │   └── name: :$-0
        ├── @ GlobalVariableReadNode (location: (43,0)-(43,16))
        │   ├── flags: newline
        │   └── name: :$LOADED_FEATURES
        ├── @ GlobalVariableReadNode (location: (45,0)-(45,8))
        │   ├── flags: newline
        │   └── name: :$VERBOSE
        ├── @ GlobalVariableReadNode (location: (47,0)-(47,3))
        │   ├── flags: newline
        │   └── name: :$-K
        ├── @ SymbolNode (location: (49,0)-(49,17))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (49,0)-(49,1) = ":"
        │   ├── value_loc: (49,1)-(49,17) = "$global_variable"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$global_variable"
        ├── @ SymbolNode (location: (51,0)-(51,3))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (51,0)-(51,1) = ":"
        │   ├── value_loc: (51,1)-(51,3) = "$_"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$_"
        ├── @ SymbolNode (location: (53,0)-(53,4))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (53,0)-(53,1) = ":"
        │   ├── value_loc: (53,1)-(53,4) = "$-w"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$-w"
        ├── @ SymbolNode (location: (55,0)-(55,11))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (55,0)-(55,1) = ":"
        │   ├── value_loc: (55,1)-(55,11) = "$LOAD_PATH"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$LOAD_PATH"
        ├── @ SymbolNode (location: (57,0)-(57,7))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (57,0)-(57,1) = ":"
        │   ├── value_loc: (57,1)-(57,7) = "$stdin"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$stdin"
        ├── @ SymbolNode (location: (59,0)-(59,8))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (59,0)-(59,1) = ":"
        │   ├── value_loc: (59,1)-(59,8) = "$stdout"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$stdout"
        ├── @ SymbolNode (location: (61,0)-(61,8))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (61,0)-(61,1) = ":"
        │   ├── value_loc: (61,1)-(61,8) = "$stderr"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$stderr"
        ├── @ SymbolNode (location: (63,0)-(63,3))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (63,0)-(63,1) = ":"
        │   ├── value_loc: (63,1)-(63,3) = "$!"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$!"
        ├── @ SymbolNode (location: (65,0)-(65,3))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (65,0)-(65,1) = ":"
        │   ├── value_loc: (65,1)-(65,3) = "$?"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$?"
        ├── @ SymbolNode (location: (67,0)-(67,3))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (67,0)-(67,1) = ":"
        │   ├── value_loc: (67,1)-(67,3) = "$~"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$~"
        ├── @ SymbolNode (location: (69,0)-(69,3))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (69,0)-(69,1) = ":"
        │   ├── value_loc: (69,1)-(69,3) = "$&"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$&"
        ├── @ SymbolNode (location: (71,0)-(71,3))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (71,0)-(71,1) = ":"
        │   ├── value_loc: (71,1)-(71,3) = "$`"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$`"
        ├── @ SymbolNode (location: (73,0)-(73,3))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (73,0)-(73,1) = ":"
        │   ├── value_loc: (73,1)-(73,3) = "$'"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$'"
        ├── @ SymbolNode (location: (75,0)-(75,3))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (75,0)-(75,1) = ":"
        │   ├── value_loc: (75,1)-(75,3) = "$+"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$+"
        ├── @ SymbolNode (location: (77,0)-(77,3))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (77,0)-(77,1) = ":"
        │   ├── value_loc: (77,1)-(77,3) = "$:"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$:"
        ├── @ SymbolNode (location: (79,0)-(79,3))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (79,0)-(79,1) = ":"
        │   ├── value_loc: (79,1)-(79,3) = "$;"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$;"
        ├── @ SymbolNode (location: (81,0)-(81,7))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (81,0)-(81,1) = ":"
        │   ├── value_loc: (81,1)-(81,7) = "$DEBUG"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$DEBUG"
        ├── @ SymbolNode (location: (83,0)-(83,10))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (83,0)-(83,1) = ":"
        │   ├── value_loc: (83,1)-(83,10) = "$FILENAME"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$FILENAME"
        ├── @ SymbolNode (location: (85,0)-(85,3))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (85,0)-(85,1) = ":"
        │   ├── value_loc: (85,1)-(85,3) = "$0"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$0"
        ├── @ SymbolNode (location: (87,0)-(87,4))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (87,0)-(87,1) = ":"
        │   ├── value_loc: (87,1)-(87,4) = "$-0"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$-0"
        ├── @ SymbolNode (location: (89,0)-(89,17))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (89,0)-(89,1) = ":"
        │   ├── value_loc: (89,1)-(89,17) = "$LOADED_FEATURES"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$LOADED_FEATURES"
        ├── @ SymbolNode (location: (91,0)-(91,9))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (91,0)-(91,1) = ":"
        │   ├── value_loc: (91,1)-(91,9) = "$VERBOSE"
        │   ├── closing_loc: ∅
        │   └── unescaped: "$VERBOSE"
        └── @ SymbolNode (location: (93,0)-(93,4))
            ├── flags: newline, static_literal, forced_us_ascii_encoding
            ├── opening_loc: (93,0)-(93,1) = ":"
            ├── value_loc: (93,1)-(93,4) = "$-K"
            ├── closing_loc: ∅
            └── unescaped: "$-K"
prism-1.5.1/snapshots/hashes.txt000066400000000000000000000632331506127434000167170ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(28,9))
├── flags: ∅
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (1,0)-(28,9))
    ├── flags: ∅
    └── body: (length: 10)
        ├── @ HashNode (location: (1,0)-(1,2))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (1,0)-(1,1) = "{"
        │   ├── elements: (length: 0)
        │   └── closing_loc: (1,1)-(1,2) = "}"
        ├── @ HashNode (location: (3,0)-(4,1))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (3,0)-(3,1) = "{"
        │   ├── elements: (length: 0)
        │   └── closing_loc: (4,0)-(4,1) = "}"
        ├── @ HashNode (location: (6,0)-(6,18))
        │   ├── flags: newline
        │   ├── opening_loc: (6,0)-(6,1) = "{"
        │   ├── elements: (length: 2)
        │   │   ├── @ AssocNode (location: (6,2)-(6,8))
        │   │   │   ├── flags: ∅
        │   │   │   ├── key:
        │   │   │   │   @ CallNode (location: (6,2)-(6,3))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :a
        │   │   │   │   ├── message_loc: (6,2)-(6,3) = "a"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── value:
        │   │   │   │   @ CallNode (location: (6,7)-(6,8))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   ├── message_loc: (6,7)-(6,8) = "b"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── operator_loc: (6,4)-(6,6) = "=>"
        │   │   └── @ AssocNode (location: (6,10)-(6,16))
        │   │       ├── flags: ∅
        │   │       ├── key:
        │   │       │   @ CallNode (location: (6,10)-(6,11))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :c
        │   │       │   ├── message_loc: (6,10)-(6,11) = "c"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       ├── value:
        │   │       │   @ CallNode (location: (6,15)-(6,16))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :d
        │   │       │   ├── message_loc: (6,15)-(6,16) = "d"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── operator_loc: (6,12)-(6,14) = "=>"
        │   └── closing_loc: (6,17)-(6,18) = "}"
        ├── @ HashNode (location: (8,0)-(8,15))
        │   ├── flags: newline
        │   ├── opening_loc: (8,0)-(8,1) = "{"
        │   ├── elements: (length: 2)
        │   │   ├── @ AssocNode (location: (8,2)-(8,8))
        │   │   │   ├── flags: ∅
        │   │   │   ├── key:
        │   │   │   │   @ CallNode (location: (8,2)-(8,3))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :a
        │   │   │   │   ├── message_loc: (8,2)-(8,3) = "a"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── value:
        │   │   │   │   @ CallNode (location: (8,7)-(8,8))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   ├── message_loc: (8,7)-(8,8) = "b"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── operator_loc: (8,4)-(8,6) = "=>"
        │   │   └── @ AssocSplatNode (location: (8,10)-(8,13))
        │   │       ├── flags: ∅
        │   │       ├── value:
        │   │       │   @ CallNode (location: (8,12)-(8,13))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :c
        │   │       │   ├── message_loc: (8,12)-(8,13) = "c"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── operator_loc: (8,10)-(8,12) = "**"
        │   └── closing_loc: (8,14)-(8,15) = "}"
        ├── @ HashNode (location: (10,0)-(16,5))
        │   ├── flags: newline
        │   ├── opening_loc: (10,0)-(10,1) = "{"
        │   ├── elements: (length: 2)
        │   │   ├── @ AssocNode (location: (11,6)-(11,10))
        │   │   │   ├── flags: ∅
        │   │   │   ├── key:
        │   │   │   │   @ SymbolNode (location: (11,6)-(11,8))
        │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── value_loc: (11,6)-(11,7) = "a"
        │   │   │   │   ├── closing_loc: (11,7)-(11,8) = ":"
        │   │   │   │   └── unescaped: "a"
        │   │   │   ├── value:
        │   │   │   │   @ CallNode (location: (11,9)-(11,10))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   ├── message_loc: (11,9)-(11,10) = "b"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── operator_loc: ∅
        │   │   └── @ AssocNode (location: (12,6)-(12,10))
        │   │       ├── flags: ∅
        │   │       ├── key:
        │   │       │   @ SymbolNode (location: (12,6)-(12,8))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── value_loc: (12,6)-(12,7) = "c"
        │   │       │   ├── closing_loc: (12,7)-(12,8) = ":"
        │   │       │   └── unescaped: "c"
        │   │       ├── value:
        │   │       │   @ CallNode (location: (12,9)-(12,10))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :d
        │   │       │   ├── message_loc: (12,9)-(12,10) = "d"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── operator_loc: ∅
        │   └── closing_loc: (16,4)-(16,5) = "}"
        ├── @ HashNode (location: (18,0)-(18,25))
        │   ├── flags: newline
        │   ├── opening_loc: (18,0)-(18,1) = "{"
        │   ├── elements: (length: 4)
        │   │   ├── @ AssocNode (location: (18,2)-(18,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── key:
        │   │   │   │   @ SymbolNode (location: (18,2)-(18,4))
        │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── value_loc: (18,2)-(18,3) = "a"
        │   │   │   │   ├── closing_loc: (18,3)-(18,4) = ":"
        │   │   │   │   └── unescaped: "a"
        │   │   │   ├── value:
        │   │   │   │   @ CallNode (location: (18,5)-(18,6))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   ├── message_loc: (18,5)-(18,6) = "b"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── operator_loc: ∅
        │   │   ├── @ AssocNode (location: (18,8)-(18,12))
        │   │   │   ├── flags: ∅
        │   │   │   ├── key:
        │   │   │   │   @ SymbolNode (location: (18,8)-(18,10))
        │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── value_loc: (18,8)-(18,9) = "c"
        │   │   │   │   ├── closing_loc: (18,9)-(18,10) = ":"
        │   │   │   │   └── unescaped: "c"
        │   │   │   ├── value:
        │   │   │   │   @ CallNode (location: (18,11)-(18,12))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :d
        │   │   │   │   ├── message_loc: (18,11)-(18,12) = "d"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── operator_loc: ∅
        │   │   ├── @ AssocSplatNode (location: (18,14)-(18,17))
        │   │   │   ├── flags: ∅
        │   │   │   ├── value:
        │   │   │   │   @ CallNode (location: (18,16)-(18,17))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :e
        │   │   │   │   ├── message_loc: (18,16)-(18,17) = "e"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── operator_loc: (18,14)-(18,16) = "**"
        │   │   └── @ AssocNode (location: (18,19)-(18,23))
        │   │       ├── flags: ∅
        │   │       ├── key:
        │   │       │   @ SymbolNode (location: (18,19)-(18,21))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── value_loc: (18,19)-(18,20) = "f"
        │   │       │   ├── closing_loc: (18,20)-(18,21) = ":"
        │   │       │   └── unescaped: "f"
        │   │       ├── value:
        │   │       │   @ CallNode (location: (18,22)-(18,23))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :g
        │   │       │   ├── message_loc: (18,22)-(18,23) = "g"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── operator_loc: ∅
        │   └── closing_loc: (18,24)-(18,25) = "}"
        ├── @ HashNode (location: (20,0)-(20,12))
        │   ├── flags: newline
        │   ├── opening_loc: (20,0)-(20,1) = "{"
        │   ├── elements: (length: 1)
        │   │   └── @ AssocNode (location: (20,2)-(20,10))
        │   │       ├── flags: ∅
        │   │       ├── key:
        │   │       │   @ SymbolNode (location: (20,2)-(20,6))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (20,2)-(20,3) = "\""
        │   │       │   ├── value_loc: (20,3)-(20,4) = "a"
        │   │       │   ├── closing_loc: (20,4)-(20,6) = "\":"
        │   │       │   └── unescaped: "a"
        │   │       ├── value:
        │   │       │   @ CallNode (location: (20,7)-(20,10))
        │   │       │   ├── flags: ∅
        │   │       │   ├── receiver:
        │   │       │   │   @ CallNode (location: (20,8)-(20,10))
        │   │       │   │   ├── flags: ignore_visibility
        │   │       │   │   ├── receiver: ∅
        │   │       │   │   ├── call_operator_loc: ∅
        │   │       │   │   ├── name: :b?
        │   │       │   │   ├── message_loc: (20,8)-(20,10) = "b?"
        │   │       │   │   ├── opening_loc: ∅
        │   │       │   │   ├── arguments: ∅
        │   │       │   │   ├── closing_loc: ∅
        │   │       │   │   └── block: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :!
        │   │       │   ├── message_loc: (20,7)-(20,8) = "!"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── operator_loc: ∅
        │   └── closing_loc: (20,11)-(20,12) = "}"
        ├── @ LocalVariableWriteNode (location: (22,0)-(22,5))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── depth: 0
        │   ├── name_loc: (22,0)-(22,1) = "a"
        │   ├── value:
        │   │   @ IntegerNode (location: (22,4)-(22,5))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (22,2)-(22,3) = "="
        ├── @ CallNode (location: (23,0)-(26,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (23,0)-(23,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (23,4)-(26,3))
        │       ├── flags: ∅
        │       ├── locals: [:b]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (24,2)-(25,20))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 2)
        │       │       ├── @ LocalVariableWriteNode (location: (24,2)-(24,7))
        │       │       │   ├── flags: newline
        │       │       │   ├── name: :b
        │       │       │   ├── depth: 0
        │       │       │   ├── name_loc: (24,2)-(24,3) = "b"
        │       │       │   ├── value:
        │       │       │   │   @ IntegerNode (location: (24,6)-(24,7))
        │       │       │   │   ├── flags: static_literal, decimal
        │       │       │   │   └── value: 1
        │       │       │   └── operator_loc: (24,4)-(24,5) = "="
        │       │       └── @ HashNode (location: (25,2)-(25,20))
        │       │           ├── flags: newline
        │       │           ├── opening_loc: (25,2)-(25,3) = "{"
        │       │           ├── elements: (length: 4)
        │       │           │   ├── @ AssocNode (location: (25,4)-(25,6))
        │       │           │   │   ├── flags: ∅
        │       │           │   │   ├── key:
        │       │           │   │   │   @ SymbolNode (location: (25,4)-(25,6))
        │       │           │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │       │           │   │   │   ├── opening_loc: ∅
        │       │           │   │   │   ├── value_loc: (25,4)-(25,5) = "a"
        │       │           │   │   │   ├── closing_loc: (25,5)-(25,6) = ":"
        │       │           │   │   │   └── unescaped: "a"
        │       │           │   │   ├── value:
        │       │           │   │   │   @ ImplicitNode (location: (25,4)-(25,6))
        │       │           │   │   │   ├── flags: ∅
        │       │           │   │   │   └── value:
        │       │           │   │   │       @ LocalVariableReadNode (location: (25,4)-(25,6))
        │       │           │   │   │       ├── flags: ∅
        │       │           │   │   │       ├── name: :a
        │       │           │   │   │       └── depth: 1
        │       │           │   │   └── operator_loc: ∅
        │       │           │   ├── @ AssocNode (location: (25,8)-(25,10))
        │       │           │   │   ├── flags: ∅
        │       │           │   │   ├── key:
        │       │           │   │   │   @ SymbolNode (location: (25,8)-(25,10))
        │       │           │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │       │           │   │   │   ├── opening_loc: ∅
        │       │           │   │   │   ├── value_loc: (25,8)-(25,9) = "b"
        │       │           │   │   │   ├── closing_loc: (25,9)-(25,10) = ":"
        │       │           │   │   │   └── unescaped: "b"
        │       │           │   │   ├── value:
        │       │           │   │   │   @ ImplicitNode (location: (25,8)-(25,10))
        │       │           │   │   │   ├── flags: ∅
        │       │           │   │   │   └── value:
        │       │           │   │   │       @ LocalVariableReadNode (location: (25,8)-(25,10))
        │       │           │   │   │       ├── flags: ∅
        │       │           │   │   │       ├── name: :b
        │       │           │   │   │       └── depth: 0
        │       │           │   │   └── operator_loc: ∅
        │       │           │   ├── @ AssocNode (location: (25,12)-(25,14))
        │       │           │   │   ├── flags: ∅
        │       │           │   │   ├── key:
        │       │           │   │   │   @ SymbolNode (location: (25,12)-(25,14))
        │       │           │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │       │           │   │   │   ├── opening_loc: ∅
        │       │           │   │   │   ├── value_loc: (25,12)-(25,13) = "c"
        │       │           │   │   │   ├── closing_loc: (25,13)-(25,14) = ":"
        │       │           │   │   │   └── unescaped: "c"
        │       │           │   │   ├── value:
        │       │           │   │   │   @ ImplicitNode (location: (25,12)-(25,14))
        │       │           │   │   │   ├── flags: ∅
        │       │           │   │   │   └── value:
        │       │           │   │   │       @ CallNode (location: (25,12)-(25,14))
        │       │           │   │   │       ├── flags: ignore_visibility
        │       │           │   │   │       ├── receiver: ∅
        │       │           │   │   │       ├── call_operator_loc: ∅
        │       │           │   │   │       ├── name: :c
        │       │           │   │   │       ├── message_loc: (25,12)-(25,13) = "c"
        │       │           │   │   │       ├── opening_loc: ∅
        │       │           │   │   │       ├── arguments: ∅
        │       │           │   │   │       ├── closing_loc: ∅
        │       │           │   │   │       └── block: ∅
        │       │           │   │   └── operator_loc: ∅
        │       │           │   └── @ AssocNode (location: (25,16)-(25,18))
        │       │           │       ├── flags: ∅
        │       │           │       ├── key:
        │       │           │       │   @ SymbolNode (location: (25,16)-(25,18))
        │       │           │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │       │           │       │   ├── opening_loc: ∅
        │       │           │       │   ├── value_loc: (25,16)-(25,17) = "D"
        │       │           │       │   ├── closing_loc: (25,17)-(25,18) = ":"
        │       │           │       │   └── unescaped: "D"
        │       │           │       ├── value:
        │       │           │       │   @ ImplicitNode (location: (25,16)-(25,18))
        │       │           │       │   ├── flags: ∅
        │       │           │       │   └── value:
        │       │           │       │       @ ConstantReadNode (location: (25,16)-(25,18))
        │       │           │       │       ├── flags: ∅
        │       │           │       │       └── name: :D
        │       │           │       └── operator_loc: ∅
        │       │           └── closing_loc: (25,19)-(25,20) = "}"
        │       ├── opening_loc: (23,4)-(23,6) = "do"
        │       └── closing_loc: (26,0)-(26,3) = "end"
        └── @ HashNode (location: (28,0)-(28,9))
            ├── flags: newline, static_literal
            ├── opening_loc: (28,0)-(28,1) = "{"
            ├── elements: (length: 1)
            │   └── @ AssocNode (location: (28,2)-(28,7))
            │       ├── flags: static_literal
            │       ├── key:
            │       │   @ SymbolNode (location: (28,2)-(28,4))
            │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   ├── opening_loc: ∅
            │       │   ├── value_loc: (28,2)-(28,3) = "a"
            │       │   ├── closing_loc: (28,3)-(28,4) = ":"
            │       │   └── unescaped: "a"
            │       ├── value:
            │       │   @ IntegerNode (location: (28,5)-(28,7))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: -1
            │       └── operator_loc: ∅
            └── closing_loc: (28,8)-(28,9) = "}"
prism-1.5.1/snapshots/heredoc.txt000066400000000000000000000007641506127434000170550ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ StringNode (location: (1,0)-(1,6))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,6) = "<
        │   ├── message_loc: (31,2)-(31,5) = "<=>"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (31,6)-(31,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (31,6)-(31,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (33,0)-(33,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (33,0)-(33,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: ∅
        │   ├── name: :==
        │   ├── message_loc: (33,2)-(33,4) = "=="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (33,5)-(33,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (33,5)-(33,6))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (35,0)-(35,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (35,0)-(35,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: ∅
        │   ├── name: :===
        │   ├── message_loc: (35,2)-(35,5) = "==="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (35,6)-(35,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (35,6)-(35,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (37,0)-(37,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (37,0)-(37,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: ∅
        │   ├── name: :=~
        │   ├── message_loc: (37,2)-(37,4) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (37,5)-(37,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (37,5)-(37,6))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (39,0)-(39,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (39,0)-(39,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: ∅
        │   ├── name: :>
        │   ├── message_loc: (39,2)-(39,3) = ">"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (39,4)-(39,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (39,4)-(39,5))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (41,0)-(41,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (41,0)-(41,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: ∅
        │   ├── name: :>=
        │   ├── message_loc: (41,2)-(41,4) = ">="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (41,5)-(41,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (41,5)-(41,6))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (43,0)-(43,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (43,0)-(43,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: ∅
        │   ├── name: :>>
        │   ├── message_loc: (43,2)-(43,4) = ">>"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (43,5)-(43,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (43,5)-(43,6))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (45,0)-(45,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (45,0)-(45,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: ∅
        │   ├── name: :^
        │   ├── message_loc: (45,2)-(45,3) = "^"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (45,4)-(45,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (45,4)-(45,5))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (47,0)-(47,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (47,0)-(47,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: ∅
        │   ├── name: :|
        │   ├── message_loc: (47,2)-(47,3) = "|"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (47,4)-(47,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (47,4)-(47,5))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ AndNode (location: (49,0)-(49,6))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ IntegerNode (location: (49,0)-(49,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── right:
        │   │   @ IntegerNode (location: (49,5)-(49,6))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 2
        │   └── operator_loc: (49,2)-(49,4) = "&&"
        ├── @ AndNode (location: (51,0)-(51,7))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ IntegerNode (location: (51,0)-(51,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── right:
        │   │   @ IntegerNode (location: (51,6)-(51,7))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 2
        │   └── operator_loc: (51,2)-(51,5) = "and"
        ├── @ CallNode (location: (53,0)-(53,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (53,0)-(53,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: ∅
        │   ├── name: :*
        │   ├── message_loc: (53,2)-(53,3) = "*"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (53,4)-(53,10))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (53,4)-(53,10))
        │   │           ├── flags: ∅
        │   │           ├── receiver:
        │   │           │   @ IntegerNode (location: (53,4)-(53,5))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 2
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :**
        │   │           ├── message_loc: (53,6)-(53,8) = "**"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (53,9)-(53,10))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (53,9)-(53,10))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 3
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (55,0)-(55,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (55,0)-(55,5))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ IntegerNode (location: (55,0)-(55,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :*
        │   │   ├── message_loc: (55,2)-(55,3) = "*"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (55,4)-(55,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (55,4)-(55,5))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :+
        │   ├── message_loc: (55,6)-(55,7) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (55,8)-(55,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (55,8)-(55,9))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 3
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ OrNode (location: (57,0)-(57,6))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ IntegerNode (location: (57,0)-(57,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── right:
        │   │   @ IntegerNode (location: (57,5)-(57,6))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 2
        │   └── operator_loc: (57,2)-(57,4) = "or"
        ├── @ OrNode (location: (59,0)-(59,6))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ IntegerNode (location: (59,0)-(59,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── right:
        │   │   @ IntegerNode (location: (59,5)-(59,6))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 2
        │   └── operator_loc: (59,2)-(59,4) = "||"
        ├── @ CallNode (location: (61,0)-(61,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (61,0)-(61,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: ∅
        │   ├── name: :+
        │   ├── message_loc: (61,2)-(61,3) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (61,4)-(61,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (61,4)-(61,9))
        │   │           ├── flags: ∅
        │   │           ├── receiver:
        │   │           │   @ IntegerNode (location: (61,4)-(61,5))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 2
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :*
        │   │           ├── message_loc: (61,6)-(61,7) = "*"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (61,8)-(61,9))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (61,8)-(61,9))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 3
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ ParenthesesNode (location: (63,0)-(63,7))
            ├── flags: newline
            ├── body:
            │   @ StatementsNode (location: (63,1)-(63,6))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (63,1)-(63,6))
            │           ├── flags: newline
            │           ├── receiver:
            │           │   @ IntegerNode (location: (63,1)-(63,2))
            │           │   ├── flags: static_literal, decimal
            │           │   └── value: 1
            │           ├── call_operator_loc: ∅
            │           ├── name: :+
            │           ├── message_loc: (63,3)-(63,4) = "+"
            │           ├── opening_loc: ∅
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (63,5)-(63,6))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 1)
            │           │       └── @ IntegerNode (location: (63,5)-(63,6))
            │           │           ├── flags: static_literal, decimal
            │           │           └── value: 1
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── opening_loc: (63,0)-(63,1) = "("
            └── closing_loc: (63,6)-(63,7) = ")"
prism-1.5.1/snapshots/it.txt000066400000000000000000000040651506127434000160560ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,9))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(3,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :x
        │   ├── message_loc: (1,0)-(1,1) = "x"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,2)-(3,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters:
        │       │   @ ItParametersNode (location: (1,2)-(3,3))
        │       │   └── flags: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (2,2)-(2,4))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ ItLocalVariableReadNode (location: (2,2)-(2,4))
        │       │           └── flags: newline
        │       ├── opening_loc: (1,2)-(1,4) = "do"
        │       └── closing_loc: (3,0)-(3,3) = "end"
        └── @ LambdaNode (location: (5,0)-(5,9))
            ├── flags: newline
            ├── locals: []
            ├── operator_loc: (5,0)-(5,2) = "->"
            ├── opening_loc: (5,3)-(5,4) = "{"
            ├── closing_loc: (5,8)-(5,9) = "}"
            ├── parameters:
            │   @ ItParametersNode (location: (5,0)-(5,9))
            │   └── flags: ∅
            └── body:
                @ StatementsNode (location: (5,5)-(5,7))
                ├── flags: ∅
                └── body: (length: 1)
                    └── @ ItLocalVariableReadNode (location: (5,5)-(5,7))
                        └── flags: newline
prism-1.5.1/snapshots/it_assignment.txt000066400000000000000000000057551506127434000203150ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,24))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,24))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,24))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,2))
            │   ├── flags: static_literal, decimal
            │   └── value: 42
            ├── call_operator_loc: (1,2)-(1,3) = "."
            ├── name: :tap
            ├── message_loc: (1,3)-(1,6) = "tap"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,7)-(1,24))
                ├── flags: ∅
                ├── locals: [:it]
                ├── parameters: ∅
                ├── body:
                │   @ StatementsNode (location: (1,9)-(1,22))
                │   ├── flags: ∅
                │   └── body: (length: 2)
                │       ├── @ LocalVariableWriteNode (location: (1,9)-(1,16))
                │       │   ├── flags: newline
                │       │   ├── name: :it
                │       │   ├── depth: 0
                │       │   ├── name_loc: (1,9)-(1,11) = "it"
                │       │   ├── value:
                │       │   │   @ LocalVariableReadNode (location: (1,14)-(1,16))
                │       │   │   ├── flags: ∅
                │       │   │   ├── name: :it
                │       │   │   └── depth: 0
                │       │   └── operator_loc: (1,12)-(1,13) = "="
                │       └── @ CallNode (location: (1,18)-(1,22))
                │           ├── flags: newline, ignore_visibility
                │           ├── receiver: ∅
                │           ├── call_operator_loc: ∅
                │           ├── name: :p
                │           ├── message_loc: (1,18)-(1,19) = "p"
                │           ├── opening_loc: ∅
                │           ├── arguments:
                │           │   @ ArgumentsNode (location: (1,20)-(1,22))
                │           │   ├── flags: ∅
                │           │   └── arguments: (length: 1)
                │           │       └── @ LocalVariableReadNode (location: (1,20)-(1,22))
                │           │           ├── flags: ∅
                │           │           ├── name: :it
                │           │           └── depth: 0
                │           ├── closing_loc: ∅
                │           └── block: ∅
                ├── opening_loc: (1,7)-(1,8) = "{"
                └── closing_loc: (1,23)-(1,24) = "}"
prism-1.5.1/snapshots/it_indirect_writes.txt000066400000000000000000000546471506127434000213470ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(23,24))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(23,24))
    ├── flags: ∅
    └── body: (length: 12)
        ├── @ CallNode (location: (1,0)-(1,15))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (1,0)-(1,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,4)-(1,15))
        │       ├── flags: ∅
        │       ├── locals: [:it]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (1,6)-(1,13))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ LocalVariableOperatorWriteNode (location: (1,6)-(1,13))
        │       │           ├── flags: newline
        │       │           ├── name_loc: (1,6)-(1,8) = "it"
        │       │           ├── binary_operator_loc: (1,9)-(1,11) = "+="
        │       │           ├── value:
        │       │           │   @ IntegerNode (location: (1,12)-(1,13))
        │       │           │   ├── flags: static_literal, decimal
        │       │           │   └── value: 1
        │       │           ├── name: :it
        │       │           ├── binary_operator: :+
        │       │           └── depth: 0
        │       ├── opening_loc: (1,4)-(1,5) = "{"
        │       └── closing_loc: (1,14)-(1,15) = "}"
        ├── @ CallNode (location: (3,0)-(3,16))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (3,0)-(3,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (3,4)-(3,16))
        │       ├── flags: ∅
        │       ├── locals: [:it]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (3,6)-(3,14))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ LocalVariableOrWriteNode (location: (3,6)-(3,14))
        │       │           ├── flags: newline
        │       │           ├── name_loc: (3,6)-(3,8) = "it"
        │       │           ├── operator_loc: (3,9)-(3,12) = "||="
        │       │           ├── value:
        │       │           │   @ IntegerNode (location: (3,13)-(3,14))
        │       │           │   ├── flags: static_literal, decimal
        │       │           │   └── value: 1
        │       │           ├── name: :it
        │       │           └── depth: 0
        │       ├── opening_loc: (3,4)-(3,5) = "{"
        │       └── closing_loc: (3,15)-(3,16) = "}"
        ├── @ CallNode (location: (5,0)-(5,16))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (5,0)-(5,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (5,4)-(5,16))
        │       ├── flags: ∅
        │       ├── locals: [:it]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (5,6)-(5,14))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ LocalVariableAndWriteNode (location: (5,6)-(5,14))
        │       │           ├── flags: newline
        │       │           ├── name_loc: (5,6)-(5,8) = "it"
        │       │           ├── operator_loc: (5,9)-(5,12) = "&&="
        │       │           ├── value:
        │       │           │   @ IntegerNode (location: (5,13)-(5,14))
        │       │           │   ├── flags: static_literal, decimal
        │       │           │   └── value: 1
        │       │           ├── name: :it
        │       │           └── depth: 0
        │       ├── opening_loc: (5,4)-(5,5) = "{"
        │       └── closing_loc: (5,15)-(5,16) = "}"
        ├── @ CallNode (location: (7,0)-(7,19))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (7,0)-(7,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (7,4)-(7,19))
        │       ├── flags: ∅
        │       ├── locals: [:it]
        │       ├── parameters:
        │       │   @ ItParametersNode (location: (7,4)-(7,19))
        │       │   └── flags: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (7,6)-(7,17))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 2)
        │       │       ├── @ ItLocalVariableReadNode (location: (7,6)-(7,8))
        │       │       │   └── flags: newline
        │       │       └── @ LocalVariableOperatorWriteNode (location: (7,10)-(7,17))
        │       │           ├── flags: newline
        │       │           ├── name_loc: (7,10)-(7,12) = "it"
        │       │           ├── binary_operator_loc: (7,13)-(7,15) = "+="
        │       │           ├── value:
        │       │           │   @ IntegerNode (location: (7,16)-(7,17))
        │       │           │   ├── flags: static_literal, decimal
        │       │           │   └── value: 1
        │       │           ├── name: :it
        │       │           ├── binary_operator: :+
        │       │           └── depth: 0
        │       ├── opening_loc: (7,4)-(7,5) = "{"
        │       └── closing_loc: (7,18)-(7,19) = "}"
        ├── @ CallNode (location: (9,0)-(9,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (9,0)-(9,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (9,4)-(9,20))
        │       ├── flags: ∅
        │       ├── locals: [:it]
        │       ├── parameters:
        │       │   @ ItParametersNode (location: (9,4)-(9,20))
        │       │   └── flags: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (9,6)-(9,18))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 2)
        │       │       ├── @ ItLocalVariableReadNode (location: (9,6)-(9,8))
        │       │       │   └── flags: newline
        │       │       └── @ LocalVariableOrWriteNode (location: (9,10)-(9,18))
        │       │           ├── flags: newline
        │       │           ├── name_loc: (9,10)-(9,12) = "it"
        │       │           ├── operator_loc: (9,13)-(9,16) = "||="
        │       │           ├── value:
        │       │           │   @ IntegerNode (location: (9,17)-(9,18))
        │       │           │   ├── flags: static_literal, decimal
        │       │           │   └── value: 1
        │       │           ├── name: :it
        │       │           └── depth: 0
        │       ├── opening_loc: (9,4)-(9,5) = "{"
        │       └── closing_loc: (9,19)-(9,20) = "}"
        ├── @ CallNode (location: (11,0)-(11,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (11,0)-(11,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (11,4)-(11,20))
        │       ├── flags: ∅
        │       ├── locals: [:it]
        │       ├── parameters:
        │       │   @ ItParametersNode (location: (11,4)-(11,20))
        │       │   └── flags: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (11,6)-(11,18))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 2)
        │       │       ├── @ ItLocalVariableReadNode (location: (11,6)-(11,8))
        │       │       │   └── flags: newline
        │       │       └── @ LocalVariableAndWriteNode (location: (11,10)-(11,18))
        │       │           ├── flags: newline
        │       │           ├── name_loc: (11,10)-(11,12) = "it"
        │       │           ├── operator_loc: (11,13)-(11,16) = "&&="
        │       │           ├── value:
        │       │           │   @ IntegerNode (location: (11,17)-(11,18))
        │       │           │   ├── flags: static_literal, decimal
        │       │           │   └── value: 1
        │       │           ├── name: :it
        │       │           └── depth: 0
        │       ├── opening_loc: (11,4)-(11,5) = "{"
        │       └── closing_loc: (11,19)-(11,20) = "}"
        ├── @ CallNode (location: (13,0)-(13,19))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (13,0)-(13,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (13,4)-(13,19))
        │       ├── flags: ∅
        │       ├── locals: [:it]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (13,6)-(13,17))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 2)
        │       │       ├── @ LocalVariableOperatorWriteNode (location: (13,6)-(13,13))
        │       │       │   ├── flags: newline
        │       │       │   ├── name_loc: (13,6)-(13,8) = "it"
        │       │       │   ├── binary_operator_loc: (13,9)-(13,11) = "+="
        │       │       │   ├── value:
        │       │       │   │   @ IntegerNode (location: (13,12)-(13,13))
        │       │       │   │   ├── flags: static_literal, decimal
        │       │       │   │   └── value: 1
        │       │       │   ├── name: :it
        │       │       │   ├── binary_operator: :+
        │       │       │   └── depth: 0
        │       │       └── @ LocalVariableReadNode (location: (13,15)-(13,17))
        │       │           ├── flags: newline
        │       │           ├── name: :it
        │       │           └── depth: 0
        │       ├── opening_loc: (13,4)-(13,5) = "{"
        │       └── closing_loc: (13,18)-(13,19) = "}"
        ├── @ CallNode (location: (15,0)-(15,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (15,0)-(15,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (15,4)-(15,20))
        │       ├── flags: ∅
        │       ├── locals: [:it]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (15,6)-(15,18))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 2)
        │       │       ├── @ LocalVariableOrWriteNode (location: (15,6)-(15,14))
        │       │       │   ├── flags: newline
        │       │       │   ├── name_loc: (15,6)-(15,8) = "it"
        │       │       │   ├── operator_loc: (15,9)-(15,12) = "||="
        │       │       │   ├── value:
        │       │       │   │   @ IntegerNode (location: (15,13)-(15,14))
        │       │       │   │   ├── flags: static_literal, decimal
        │       │       │   │   └── value: 1
        │       │       │   ├── name: :it
        │       │       │   └── depth: 0
        │       │       └── @ LocalVariableReadNode (location: (15,16)-(15,18))
        │       │           ├── flags: newline
        │       │           ├── name: :it
        │       │           └── depth: 0
        │       ├── opening_loc: (15,4)-(15,5) = "{"
        │       └── closing_loc: (15,19)-(15,20) = "}"
        ├── @ CallNode (location: (17,0)-(17,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (17,0)-(17,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (17,4)-(17,20))
        │       ├── flags: ∅
        │       ├── locals: [:it]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (17,6)-(17,18))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 2)
        │       │       ├── @ LocalVariableAndWriteNode (location: (17,6)-(17,14))
        │       │       │   ├── flags: newline
        │       │       │   ├── name_loc: (17,6)-(17,8) = "it"
        │       │       │   ├── operator_loc: (17,9)-(17,12) = "&&="
        │       │       │   ├── value:
        │       │       │   │   @ IntegerNode (location: (17,13)-(17,14))
        │       │       │   │   ├── flags: static_literal, decimal
        │       │       │   │   └── value: 1
        │       │       │   ├── name: :it
        │       │       │   └── depth: 0
        │       │       └── @ LocalVariableReadNode (location: (17,16)-(17,18))
        │       │           ├── flags: newline
        │       │           ├── name: :it
        │       │           └── depth: 0
        │       ├── opening_loc: (17,4)-(17,5) = "{"
        │       └── closing_loc: (17,19)-(17,20) = "}"
        ├── @ CallNode (location: (19,0)-(19,23))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (19,0)-(19,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (19,4)-(19,23))
        │       ├── flags: ∅
        │       ├── locals: [:it]
        │       ├── parameters:
        │       │   @ ItParametersNode (location: (19,4)-(19,23))
        │       │   └── flags: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (19,6)-(19,21))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 3)
        │       │       ├── @ ItLocalVariableReadNode (location: (19,6)-(19,8))
        │       │       │   └── flags: newline
        │       │       ├── @ LocalVariableOperatorWriteNode (location: (19,10)-(19,17))
        │       │       │   ├── flags: newline
        │       │       │   ├── name_loc: (19,10)-(19,12) = "it"
        │       │       │   ├── binary_operator_loc: (19,13)-(19,15) = "+="
        │       │       │   ├── value:
        │       │       │   │   @ IntegerNode (location: (19,16)-(19,17))
        │       │       │   │   ├── flags: static_literal, decimal
        │       │       │   │   └── value: 1
        │       │       │   ├── name: :it
        │       │       │   ├── binary_operator: :+
        │       │       │   └── depth: 0
        │       │       └── @ LocalVariableReadNode (location: (19,19)-(19,21))
        │       │           ├── flags: newline
        │       │           ├── name: :it
        │       │           └── depth: 0
        │       ├── opening_loc: (19,4)-(19,5) = "{"
        │       └── closing_loc: (19,22)-(19,23) = "}"
        ├── @ CallNode (location: (21,0)-(21,24))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (21,0)-(21,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (21,4)-(21,24))
        │       ├── flags: ∅
        │       ├── locals: [:it]
        │       ├── parameters:
        │       │   @ ItParametersNode (location: (21,4)-(21,24))
        │       │   └── flags: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (21,6)-(21,22))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 3)
        │       │       ├── @ ItLocalVariableReadNode (location: (21,6)-(21,8))
        │       │       │   └── flags: newline
        │       │       ├── @ LocalVariableOrWriteNode (location: (21,10)-(21,18))
        │       │       │   ├── flags: newline
        │       │       │   ├── name_loc: (21,10)-(21,12) = "it"
        │       │       │   ├── operator_loc: (21,13)-(21,16) = "||="
        │       │       │   ├── value:
        │       │       │   │   @ IntegerNode (location: (21,17)-(21,18))
        │       │       │   │   ├── flags: static_literal, decimal
        │       │       │   │   └── value: 1
        │       │       │   ├── name: :it
        │       │       │   └── depth: 0
        │       │       └── @ LocalVariableReadNode (location: (21,20)-(21,22))
        │       │           ├── flags: newline
        │       │           ├── name: :it
        │       │           └── depth: 0
        │       ├── opening_loc: (21,4)-(21,5) = "{"
        │       └── closing_loc: (21,23)-(21,24) = "}"
        └── @ CallNode (location: (23,0)-(23,24))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :tap
            ├── message_loc: (23,0)-(23,3) = "tap"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (23,4)-(23,24))
                ├── flags: ∅
                ├── locals: [:it]
                ├── parameters:
                │   @ ItParametersNode (location: (23,4)-(23,24))
                │   └── flags: ∅
                ├── body:
                │   @ StatementsNode (location: (23,6)-(23,22))
                │   ├── flags: ∅
                │   └── body: (length: 3)
                │       ├── @ ItLocalVariableReadNode (location: (23,6)-(23,8))
                │       │   └── flags: newline
                │       ├── @ LocalVariableAndWriteNode (location: (23,10)-(23,18))
                │       │   ├── flags: newline
                │       │   ├── name_loc: (23,10)-(23,12) = "it"
                │       │   ├── operator_loc: (23,13)-(23,16) = "&&="
                │       │   ├── value:
                │       │   │   @ IntegerNode (location: (23,17)-(23,18))
                │       │   │   ├── flags: static_literal, decimal
                │       │   │   └── value: 1
                │       │   ├── name: :it
                │       │   └── depth: 0
                │       └── @ LocalVariableReadNode (location: (23,20)-(23,22))
                │           ├── flags: newline
                │           ├── name: :it
                │           └── depth: 0
                ├── opening_loc: (23,4)-(23,5) = "{"
                └── closing_loc: (23,23)-(23,24) = "}"
prism-1.5.1/snapshots/it_read_and_assignment.txt000066400000000000000000000100771506127434000221230ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,30))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,30))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,30))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,2))
            │   ├── flags: static_literal, decimal
            │   └── value: 42
            ├── call_operator_loc: (1,2)-(1,3) = "."
            ├── name: :tap
            ├── message_loc: (1,3)-(1,6) = "tap"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,7)-(1,30))
                ├── flags: ∅
                ├── locals: [:it]
                ├── parameters:
                │   @ ItParametersNode (location: (1,7)-(1,30))
                │   └── flags: ∅
                ├── body:
                │   @ StatementsNode (location: (1,9)-(1,28))
                │   ├── flags: ∅
                │   └── body: (length: 3)
                │       ├── @ CallNode (location: (1,9)-(1,13))
                │       │   ├── flags: newline, ignore_visibility
                │       │   ├── receiver: ∅
                │       │   ├── call_operator_loc: ∅
                │       │   ├── name: :p
                │       │   ├── message_loc: (1,9)-(1,10) = "p"
                │       │   ├── opening_loc: ∅
                │       │   ├── arguments:
                │       │   │   @ ArgumentsNode (location: (1,11)-(1,13))
                │       │   │   ├── flags: ∅
                │       │   │   └── arguments: (length: 1)
                │       │   │       └── @ ItLocalVariableReadNode (location: (1,11)-(1,13))
                │       │   │           └── flags: ∅
                │       │   ├── closing_loc: ∅
                │       │   └── block: ∅
                │       ├── @ LocalVariableWriteNode (location: (1,15)-(1,22))
                │       │   ├── flags: newline
                │       │   ├── name: :it
                │       │   ├── depth: 0
                │       │   ├── name_loc: (1,15)-(1,17) = "it"
                │       │   ├── value:
                │       │   │   @ LocalVariableReadNode (location: (1,20)-(1,22))
                │       │   │   ├── flags: ∅
                │       │   │   ├── name: :it
                │       │   │   └── depth: 0
                │       │   └── operator_loc: (1,18)-(1,19) = "="
                │       └── @ CallNode (location: (1,24)-(1,28))
                │           ├── flags: newline, ignore_visibility
                │           ├── receiver: ∅
                │           ├── call_operator_loc: ∅
                │           ├── name: :p
                │           ├── message_loc: (1,24)-(1,25) = "p"
                │           ├── opening_loc: ∅
                │           ├── arguments:
                │           │   @ ArgumentsNode (location: (1,26)-(1,28))
                │           │   ├── flags: ∅
                │           │   └── arguments: (length: 1)
                │           │       └── @ LocalVariableReadNode (location: (1,26)-(1,28))
                │           │           ├── flags: ∅
                │           │           ├── name: :it
                │           │           └── depth: 0
                │           ├── closing_loc: ∅
                │           └── block: ∅
                ├── opening_loc: (1,7)-(1,8) = "{"
                └── closing_loc: (1,29)-(1,30) = "}"
prism-1.5.1/snapshots/keyword_method_names.txt000066400000000000000000000161401506127434000216460ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(20,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(20,3))
    ├── flags: ∅
    └── body: (length: 7)
        ├── @ DefNode (location: (1,0)-(2,3))
        │   ├── flags: newline
        │   ├── name: :def
        │   ├── name_loc: (1,4)-(1,7) = "def"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (2,0)-(2,3) = "end"
        ├── @ DefNode (location: (4,0)-(5,3))
        │   ├── flags: newline
        │   ├── name: :ensure
        │   ├── name_loc: (4,9)-(4,15) = "ensure"
        │   ├── receiver:
        │   │   @ SelfNode (location: (4,4)-(4,8))
        │   │   └── flags: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (4,0)-(4,3) = "def"
        │   ├── operator_loc: (4,8)-(4,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (5,0)-(5,3) = "end"
        ├── @ CallNode (location: (7,0)-(10,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :private
        │   ├── message_loc: (7,0)-(7,7) = "private"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (7,8)-(10,3))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ DefNode (location: (7,8)-(10,3))
        │   │           ├── flags: ∅
        │   │           ├── name: :foo
        │   │           ├── name_loc: (7,12)-(7,15) = "foo"
        │   │           ├── receiver: ∅
        │   │           ├── parameters: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (8,2)-(9,5))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (8,2)-(9,5))
        │   │           │           ├── flags: newline, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :bar
        │   │           │           ├── message_loc: (8,2)-(8,5) = "bar"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block:
        │   │           │               @ BlockNode (location: (8,6)-(9,5))
        │   │           │               ├── flags: ∅
        │   │           │               ├── locals: []
        │   │           │               ├── parameters: ∅
        │   │           │               ├── body: ∅
        │   │           │               ├── opening_loc: (8,6)-(8,8) = "do"
        │   │           │               └── closing_loc: (9,2)-(9,5) = "end"
        │   │           ├── locals: []
        │   │           ├── def_keyword_loc: (7,8)-(7,11) = "def"
        │   │           ├── operator_loc: ∅
        │   │           ├── lparen_loc: ∅
        │   │           ├── rparen_loc: ∅
        │   │           ├── equal_loc: ∅
        │   │           └── end_keyword_loc: (10,0)-(10,3) = "end"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ DefNode (location: (12,0)-(13,3))
        │   ├── flags: newline
        │   ├── name: :m
        │   ├── name_loc: (12,4)-(12,5) = "m"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (12,6)-(12,14))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (12,6)-(12,7))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ NoKeywordsParameterNode (location: (12,9)-(12,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (12,9)-(12,11) = "**"
        │   │   │   └── keyword_loc: (12,11)-(12,14) = "nil"
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (12,0)-(12,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (12,5)-(12,6) = "("
        │   ├── rparen_loc: (12,14)-(12,15) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (13,0)-(13,3) = "end"
        ├── @ StringNode (location: (15,0)-(15,6))
        │   ├── flags: newline
        │   ├── opening_loc: (15,0)-(15,2) = "%{"
        │   ├── content_loc: (15,2)-(15,5) = "abc"
        │   ├── closing_loc: (15,5)-(15,6) = "}"
        │   └── unescaped: "abc"
        ├── @ StringNode (location: (17,0)-(17,6))
        │   ├── flags: newline
        │   ├── opening_loc: (17,0)-(17,2) = "%\""
        │   ├── content_loc: (17,2)-(17,5) = "abc"
        │   ├── closing_loc: (17,5)-(17,6) = "\""
        │   └── unescaped: "abc"
        └── @ DefNode (location: (19,0)-(20,3))
            ├── flags: newline
            ├── name: :a
            ├── name_loc: (19,9)-(19,10) = "a"
            ├── receiver:
            │   @ NilNode (location: (19,4)-(19,7))
            │   └── flags: static_literal
            ├── parameters: ∅
            ├── body: ∅
            ├── locals: []
            ├── def_keyword_loc: (19,0)-(19,3) = "def"
            ├── operator_loc: (19,7)-(19,9) = "::"
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (20,0)-(20,3) = "end"
prism-1.5.1/snapshots/keywords.txt000066400000000000000000000055111506127434000173060ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(11,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(11,8))
    ├── flags: ∅
    └── body: (length: 6)
        ├── @ CallNode (location: (1,0)-(1,12))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (1,0)-(1,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,4)-(1,12))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (1,6)-(1,10))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ RedoNode (location: (1,6)-(1,10))
        │       │           └── flags: newline
        │       ├── opening_loc: (1,4)-(1,5) = "{"
        │       └── closing_loc: (1,11)-(1,12) = "}"
        ├── @ BeginNode (location: (3,0)-(3,25))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (3,0)-(3,5) = "begin"
        │   ├── statements: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (3,7)-(3,20))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (3,7)-(3,13) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (3,15)-(3,20))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ RetryNode (location: (3,15)-(3,20))
        │   │   │           └── flags: newline
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (3,22)-(3,25) = "end"
        ├── @ SelfNode (location: (5,0)-(5,4))
        │   └── flags: newline
        ├── @ SourceEncodingNode (location: (7,0)-(7,12))
        │   └── flags: newline, static_literal
        ├── @ SourceFileNode (location: (9,0)-(9,8))
        │   ├── flags: newline
        │   └── filepath: "keywords.txt"
        └── @ SourceLineNode (location: (11,0)-(11,8))
            └── flags: newline, static_literal
prism-1.5.1/snapshots/lambda.txt000066400000000000000000000651251506127434000166660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(27,2))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(27,2))
    ├── flags: ∅
    └── body: (length: 10)
        ├── @ LambdaNode (location: (1,0)-(3,4))
        │   ├── flags: newline
        │   ├── locals: [:foo]
        │   ├── operator_loc: (1,0)-(1,2) = "->"
        │   ├── opening_loc: (3,2)-(3,3) = "{"
        │   ├── closing_loc: (3,3)-(3,4) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (1,2)-(3,1))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (2,2)-(2,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 1)
        │   │   │   │   └── @ RequiredParameterNode (location: (2,2)-(2,5))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       └── name: :foo
        │   │   │   ├── optionals: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 0)
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: (1,2)-(1,3) = "("
        │   │   └── closing_loc: (3,0)-(3,1) = ")"
        │   └── body: ∅
        ├── @ LambdaNode (location: (5,0)-(5,18))
        │   ├── flags: newline
        │   ├── locals: [:x]
        │   ├── operator_loc: (5,0)-(5,2) = "->"
        │   ├── opening_loc: (5,15)-(5,16) = "{"
        │   ├── closing_loc: (5,17)-(5,18) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (5,2)-(5,14))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (5,3)-(5,13))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 0)
        │   │   │   ├── optionals: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 1)
        │   │   │   │   └── @ OptionalKeywordParameterNode (location: (5,3)-(5,13))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :x
        │   │   │   │       ├── name_loc: (5,3)-(5,5) = "x:"
        │   │   │   │       └── value:
        │   │   │   │           @ InterpolatedStringNode (location: (5,6)-(5,13))
        │   │   │   │           ├── flags: ∅
        │   │   │   │           ├── opening_loc: (5,6)-(5,7) = "\""
        │   │   │   │           ├── parts: (length: 2)
        │   │   │   │           │   ├── @ StringNode (location: (5,7)-(5,8))
        │   │   │   │           │   │   ├── flags: static_literal, frozen
        │   │   │   │           │   │   ├── opening_loc: ∅
        │   │   │   │           │   │   ├── content_loc: (5,7)-(5,8) = "b"
        │   │   │   │           │   │   ├── closing_loc: ∅
        │   │   │   │           │   │   └── unescaped: "b"
        │   │   │   │           │   └── @ EmbeddedStatementsNode (location: (5,8)-(5,12))
        │   │   │   │           │       ├── flags: ∅
        │   │   │   │           │       ├── opening_loc: (5,8)-(5,10) = "\#{"
        │   │   │   │           │       ├── statements:
        │   │   │   │           │       │   @ StatementsNode (location: (5,10)-(5,11))
        │   │   │   │           │       │   ├── flags: ∅
        │   │   │   │           │       │   └── body: (length: 1)
        │   │   │   │           │       │       └── @ CallNode (location: (5,10)-(5,11))
        │   │   │   │           │       │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           │       │           ├── receiver: ∅
        │   │   │   │           │       │           ├── call_operator_loc: ∅
        │   │   │   │           │       │           ├── name: :a
        │   │   │   │           │       │           ├── message_loc: (5,10)-(5,11) = "a"
        │   │   │   │           │       │           ├── opening_loc: ∅
        │   │   │   │           │       │           ├── arguments: ∅
        │   │   │   │           │       │           ├── closing_loc: ∅
        │   │   │   │           │       │           └── block: ∅
        │   │   │   │           │       └── closing_loc: (5,11)-(5,12) = "}"
        │   │   │   │           └── closing_loc: (5,12)-(5,13) = "\""
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: (5,2)-(5,3) = "("
        │   │   └── closing_loc: (5,13)-(5,14) = ")"
        │   └── body: ∅
        ├── @ LambdaNode (location: (7,0)-(7,15))
        │   ├── flags: newline
        │   ├── locals: [:a]
        │   ├── operator_loc: (7,0)-(7,2) = "->"
        │   ├── opening_loc: (7,13)-(7,14) = "{"
        │   ├── closing_loc: (7,14)-(7,15) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (7,2)-(7,12))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (7,3)-(7,11))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 0)
        │   │   │   ├── optionals: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 1)
        │   │   │   │   └── @ OptionalKeywordParameterNode (location: (7,3)-(7,11))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :a
        │   │   │   │       ├── name_loc: (7,3)-(7,5) = "a:"
        │   │   │   │       └── value:
        │   │   │   │           @ CallNode (location: (7,6)-(7,11))
        │   │   │   │           ├── flags: ∅
        │   │   │   │           ├── receiver:
        │   │   │   │           │   @ CallNode (location: (7,6)-(7,7))
        │   │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │   │           │   ├── receiver: ∅
        │   │   │   │           │   ├── call_operator_loc: ∅
        │   │   │   │           │   ├── name: :b
        │   │   │   │           │   ├── message_loc: (7,6)-(7,7) = "b"
        │   │   │   │           │   ├── opening_loc: ∅
        │   │   │   │           │   ├── arguments: ∅
        │   │   │   │           │   ├── closing_loc: ∅
        │   │   │   │           │   └── block: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :*
        │   │   │   │           ├── message_loc: (7,8)-(7,9) = "*"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments:
        │   │   │   │           │   @ ArgumentsNode (location: (7,10)-(7,11))
        │   │   │   │           │   ├── flags: ∅
        │   │   │   │           │   └── arguments: (length: 1)
        │   │   │   │           │       └── @ IntegerNode (location: (7,10)-(7,11))
        │   │   │   │           │           ├── flags: static_literal, decimal
        │   │   │   │           │           └── value: 3
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: (7,2)-(7,3) = "("
        │   │   └── closing_loc: (7,11)-(7,12) = ")"
        │   └── body: ∅
        ├── @ LambdaNode (location: (9,0)-(9,19))
        │   ├── flags: newline
        │   ├── locals: [:foo]
        │   ├── operator_loc: (9,0)-(9,2) = "->"
        │   ├── opening_loc: (9,13)-(9,15) = "do"
        │   ├── closing_loc: (9,16)-(9,19) = "end"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (9,3)-(9,12))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (9,3)-(9,12))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 0)
        │   │   │   ├── optionals: (length: 1)
        │   │   │   │   └── @ OptionalParameterNode (location: (9,3)-(9,12))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :foo
        │   │   │   │       ├── name_loc: (9,3)-(9,6) = "foo"
        │   │   │   │       ├── operator_loc: (9,7)-(9,8) = "="
        │   │   │   │       └── value:
        │   │   │   │           @ CallNode (location: (9,9)-(9,12))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :bar
        │   │   │   │           ├── message_loc: (9,9)-(9,12) = "bar"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 0)
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── body: ∅
        ├── @ LambdaNode (location: (11,0)-(11,18))
        │   ├── flags: newline
        │   ├── locals: [:foo]
        │   ├── operator_loc: (11,0)-(11,2) = "->"
        │   ├── opening_loc: (11,12)-(11,14) = "do"
        │   ├── closing_loc: (11,15)-(11,18) = "end"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (11,3)-(11,11))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (11,3)-(11,11))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 0)
        │   │   │   ├── optionals: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 1)
        │   │   │   │   └── @ OptionalKeywordParameterNode (location: (11,3)-(11,11))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :foo
        │   │   │   │       ├── name_loc: (11,3)-(11,7) = "foo:"
        │   │   │   │       └── value:
        │   │   │   │           @ CallNode (location: (11,8)-(11,11))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :bar
        │   │   │   │           ├── message_loc: (11,8)-(11,11) = "bar"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── body: ∅
        ├── @ DefNode (location: (13,0)-(15,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (13,4)-(13,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (13,8)-(13,13))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (13,8)-(13,9))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (13,8)-(13,9) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ KeywordRestParameterNode (location: (13,11)-(13,13))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (13,11)-(13,13) = "**"
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (14,2)-(14,21))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LambdaNode (location: (14,2)-(14,21))
        │   │           ├── flags: newline
        │   │           ├── locals: []
        │   │           ├── operator_loc: (14,2)-(14,4) = "->"
        │   │           ├── opening_loc: (14,7)-(14,8) = "{"
        │   │           ├── closing_loc: (14,20)-(14,21) = "}"
        │   │           ├── parameters:
        │   │           │   @ BlockParametersNode (location: (14,4)-(14,6))
        │   │           │   ├── flags: ∅
        │   │           │   ├── parameters: ∅
        │   │           │   ├── locals: (length: 0)
        │   │           │   ├── opening_loc: (14,4)-(14,5) = "("
        │   │           │   └── closing_loc: (14,5)-(14,6) = ")"
        │   │           └── body:
        │   │               @ StatementsNode (location: (14,9)-(14,19))
        │   │               ├── flags: ∅
        │   │               └── body: (length: 1)
        │   │                   └── @ CallNode (location: (14,9)-(14,19))
        │   │                       ├── flags: newline, ignore_visibility
        │   │                       ├── receiver: ∅
        │   │                       ├── call_operator_loc: ∅
        │   │                       ├── name: :bar
        │   │                       ├── message_loc: (14,9)-(14,12) = "bar"
        │   │                       ├── opening_loc: (14,12)-(14,13) = "("
        │   │                       ├── arguments:
        │   │                       │   @ ArgumentsNode (location: (14,13)-(14,18))
        │   │                       │   ├── flags: contains_keywords, contains_keyword_splat, contains_splat
        │   │                       │   └── arguments: (length: 2)
        │   │                       │       ├── @ SplatNode (location: (14,13)-(14,14))
        │   │                       │       │   ├── flags: ∅
        │   │                       │       │   ├── operator_loc: (14,13)-(14,14) = "*"
        │   │                       │       │   └── expression: ∅
        │   │                       │       └── @ KeywordHashNode (location: (14,16)-(14,18))
        │   │                       │           ├── flags: ∅
        │   │                       │           └── elements: (length: 1)
        │   │                       │               └── @ AssocSplatNode (location: (14,16)-(14,18))
        │   │                       │                   ├── flags: ∅
        │   │                       │                   ├── value: ∅
        │   │                       │                   └── operator_loc: (14,16)-(14,18) = "**"
        │   │                       ├── closing_loc: (14,18)-(14,19) = ")"
        │   │                       └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (13,0)-(13,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (13,7)-(13,8) = "("
        │   ├── rparen_loc: (13,13)-(13,14) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (15,0)-(15,3) = "end"
        ├── @ CallNode (location: (17,0)-(18,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :p
        │   ├── message_loc: (17,0)-(17,1) = "p"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (17,1)-(18,3))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (17,2)-(18,2))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (17,3)-(18,1))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 1)
        │       │   │   │   └── @ OptionalKeywordParameterNode (location: (17,3)-(18,1))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── name: :a
        │       │   │   │       ├── name_loc: (17,3)-(17,5) = "a:"
        │       │   │   │       └── value:
        │       │   │   │           @ CallNode (location: (18,0)-(18,1))
        │       │   │   │           ├── flags: variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :b
        │       │   │   │           ├── message_loc: (18,0)-(18,1) = "b"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (17,2)-(17,3) = "|"
        │       │   └── closing_loc: (18,1)-(18,2) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (17,1)-(17,2) = "{"
        │       └── closing_loc: (18,2)-(18,3) = "}"
        ├── @ LambdaNode (location: (20,0)-(21,4))
        │   ├── flags: newline
        │   ├── locals: [:a]
        │   ├── operator_loc: (20,0)-(20,2) = "->"
        │   ├── opening_loc: (21,2)-(21,3) = "{"
        │   ├── closing_loc: (21,3)-(21,4) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (20,2)-(21,2))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (20,3)-(21,1))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 0)
        │   │   │   ├── optionals: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 1)
        │   │   │   │   └── @ OptionalKeywordParameterNode (location: (20,3)-(21,1))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :a
        │   │   │   │       ├── name_loc: (20,3)-(20,5) = "a:"
        │   │   │   │       └── value:
        │   │   │   │           @ CallNode (location: (21,0)-(21,1))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :b
        │   │   │   │           ├── message_loc: (21,0)-(21,1) = "b"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: (20,2)-(20,3) = "("
        │   │   └── closing_loc: (21,1)-(21,2) = ")"
        │   └── body: ∅
        ├── @ LambdaNode (location: (23,0)-(24,3))
        │   ├── flags: newline
        │   ├── locals: [:a]
        │   ├── operator_loc: (23,0)-(23,2) = "->"
        │   ├── opening_loc: (24,1)-(24,2) = "{"
        │   ├── closing_loc: (24,2)-(24,3) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (23,2)-(24,1))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (23,2)-(24,1))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 0)
        │   │   │   ├── optionals: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 1)
        │   │   │   │   └── @ OptionalKeywordParameterNode (location: (23,2)-(24,1))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :a
        │   │   │   │       ├── name_loc: (23,2)-(23,4) = "a:"
        │   │   │   │       └── value:
        │   │   │   │           @ CallNode (location: (24,0)-(24,1))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :b
        │   │   │   │           ├── message_loc: (24,0)-(24,1) = "b"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── body: ∅
        └── @ LambdaNode (location: (26,0)-(27,2))
            ├── flags: newline
            ├── locals: [:a]
            ├── operator_loc: (26,0)-(26,2) = "->"
            ├── opening_loc: (27,0)-(27,1) = "{"
            ├── closing_loc: (27,1)-(27,2) = "}"
            ├── parameters:
            │   @ BlockParametersNode (location: (26,2)-(26,4))
            │   ├── flags: ∅
            │   ├── parameters:
            │   │   @ ParametersNode (location: (26,2)-(26,4))
            │   │   ├── flags: ∅
            │   │   ├── requireds: (length: 0)
            │   │   ├── optionals: (length: 0)
            │   │   ├── rest: ∅
            │   │   ├── posts: (length: 0)
            │   │   ├── keywords: (length: 1)
            │   │   │   └── @ RequiredKeywordParameterNode (location: (26,2)-(26,4))
            │   │   │       ├── flags: ∅
            │   │   │       ├── name: :a
            │   │   │       └── name_loc: (26,2)-(26,4) = "a:"
            │   │   ├── keyword_rest: ∅
            │   │   └── block: ∅
            │   ├── locals: (length: 0)
            │   ├── opening_loc: ∅
            │   └── closing_loc: ∅
            └── body: ∅
prism-1.5.1/snapshots/leading_logical.txt000066400000000000000000000122101506127434000205260ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(21,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(21,5))
    ├── flags: ∅
    └── body: (length: 8)
        ├── @ AndNode (location: (1,0)-(3,4))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ AndNode (location: (1,0)-(2,4))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (1,0)-(1,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (2,3)-(2,4))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 2
        │   │   └── operator_loc: (2,0)-(2,2) = "&&"
        │   ├── right:
        │   │   @ IntegerNode (location: (3,3)-(3,4))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 3
        │   └── operator_loc: (3,0)-(3,2) = "&&"
        ├── @ OrNode (location: (5,0)-(7,4))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ OrNode (location: (5,0)-(6,4))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (5,0)-(5,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (6,3)-(6,4))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 2
        │   │   └── operator_loc: (6,0)-(6,2) = "||"
        │   ├── right:
        │   │   @ IntegerNode (location: (7,3)-(7,4))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 3
        │   └── operator_loc: (7,0)-(7,2) = "||"
        ├── @ AndNode (location: (9,0)-(11,5))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ AndNode (location: (9,0)-(10,5))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (9,0)-(9,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (10,4)-(10,5))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 2
        │   │   └── operator_loc: (10,0)-(10,3) = "and"
        │   ├── right:
        │   │   @ IntegerNode (location: (11,4)-(11,5))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 3
        │   └── operator_loc: (11,0)-(11,3) = "and"
        ├── @ OrNode (location: (13,0)-(15,4))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ OrNode (location: (13,0)-(14,4))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (13,0)-(13,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (14,3)-(14,4))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 2
        │   │   └── operator_loc: (14,0)-(14,2) = "or"
        │   ├── right:
        │   │   @ IntegerNode (location: (15,3)-(15,4))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 3
        │   └── operator_loc: (15,0)-(15,2) = "or"
        ├── @ IntegerNode (location: (17,0)-(17,1))
        │   ├── flags: newline, static_literal, decimal
        │   └── value: 1
        ├── @ CallNode (location: (18,0)-(18,6))
        │   ├── flags: newline, variable_call, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :andfoo
        │   ├── message_loc: (18,0)-(18,6) = "andfoo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ IntegerNode (location: (20,0)-(20,1))
        │   ├── flags: newline, static_literal, decimal
        │   └── value: 2
        └── @ CallNode (location: (21,0)-(21,5))
            ├── flags: newline, variable_call, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :orfoo
            ├── message_loc: (21,0)-(21,5) = "orfoo"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/method_calls.txt000066400000000000000000004671541506127434000201140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(156,19))
├── flags: ∅
├── locals: [:foo]
└── statements:
    @ StatementsNode (location: (1,0)-(156,19))
    ├── flags: ∅
    └── body: (length: 67)
        ├── @ CallNode (location: (1,0)-(1,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (1,3)-(1,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (1,4)-(1,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,8)-(1,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (1,8)-(1,14))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (1,8)-(1,10) = "%{"
        │   │           ├── content_loc: (1,10)-(1,13) = "baz"
        │   │           ├── closing_loc: (1,13)-(1,14) = "}"
        │   │           └── unescaped: "baz"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (3,0)-(3,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (3,1)-(3,2) = "."
        │   ├── name: :b
        │   ├── message_loc: (3,2)-(3,3) = "b"
        │   ├── opening_loc: (3,3)-(3,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,4)-(3,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (3,4)-(3,5))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :c
        │   │       │   ├── message_loc: (3,4)-(3,5) = "c"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (3,7)-(3,8))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :d
        │   │           ├── message_loc: (3,7)-(3,8) = "d"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (3,8)-(3,9) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (5,0)-(5,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (5,0)-(5,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (5,0)-(5,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (5,1)-(5,2) = "."
        │   ├── name: :b
        │   ├── message_loc: (5,2)-(5,3) = "b"
        │   ├── opening_loc: (5,3)-(5,4) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (5,4)-(5,5) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (7,0)-(9,7))
        │   ├── flags: newline, safe_navigation
        │   ├── receiver:
        │   │   @ CallNode (location: (7,0)-(8,6))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (7,0)-(7,3))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (7,0)-(7,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: (8,2)-(8,3) = "."
        │   │   ├── name: :bar
        │   │   ├── message_loc: (8,3)-(8,6) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (9,2)-(9,4) = "&."
        │   ├── name: :baz
        │   ├── message_loc: (9,4)-(9,7) = "baz"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (11,0)-(11,2))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a!
        │   ├── message_loc: (11,0)-(11,2) = "a!"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (13,0)-(13,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (13,0)-(13,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (13,0)-(13,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (13,1)-(13,2) = "."
        │   ├── name: :call
        │   ├── message_loc: ∅
        │   ├── opening_loc: (13,2)-(13,3) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (13,3)-(13,4) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (15,0)-(15,11))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (15,0)-(15,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (15,0)-(15,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (15,1)-(15,2) = "."
        │   ├── name: :call
        │   ├── message_loc: ∅
        │   ├── opening_loc: (15,2)-(15,3) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (15,3)-(15,10))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 3)
        │   │       ├── @ IntegerNode (location: (15,3)-(15,4))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 1
        │   │       ├── @ IntegerNode (location: (15,6)-(15,7))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 2
        │   │       └── @ IntegerNode (location: (15,9)-(15,10))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 3
        │   ├── closing_loc: (15,10)-(15,11) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (17,0)-(17,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (17,0)-(17,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (17,0)-(17,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (17,1)-(17,3) = "::"
        │   ├── name: :b
        │   ├── message_loc: (17,3)-(17,4) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (19,0)-(19,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (19,0)-(19,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (19,0)-(19,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (19,1)-(19,3) = "::"
        │   ├── name: :b
        │   ├── message_loc: (19,3)-(19,4) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (19,5)-(19,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (19,5)-(19,6))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :c
        │   │           ├── message_loc: (19,5)-(19,6) = "c"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (21,0)-(21,11))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ CallNode (location: (21,0)-(21,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (21,0)-(21,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (21,3)-(21,4) = "."
        │   ├── name: :bar=
        │   ├── message_loc: (21,4)-(21,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (21,10)-(21,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (21,10)-(21,11))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (23,0)-(23,2))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a?
        │   ├── message_loc: (23,0)-(23,2) = "a?"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (25,0)-(25,9))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (25,0)-(25,1) = "a"
        │   ├── opening_loc: (25,1)-(25,2) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (25,8)-(25,9) = ")"
        │   └── block:
        │       @ BlockArgumentNode (location: (25,2)-(25,8))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (25,3)-(25,8))
        │       │   ├── flags: variable_call, ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :block
        │       │   ├── message_loc: (25,3)-(25,8) = "block"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       └── operator_loc: (25,2)-(25,3) = "&"
        ├── @ CallNode (location: (27,0)-(27,11))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (27,0)-(27,1) = "a"
        │   ├── opening_loc: (27,1)-(27,2) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (27,2)-(27,10))
        │   │   ├── flags: contains_keywords, contains_keyword_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (27,2)-(27,10))
        │   │           ├── flags: ∅
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocSplatNode (location: (27,2)-(27,10))
        │   │                   ├── flags: ∅
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (27,4)-(27,10))
        │   │                   │   ├── flags: variable_call, ignore_visibility
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── name: :kwargs
        │   │                   │   ├── message_loc: (27,4)-(27,10) = "kwargs"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── block: ∅
        │   │                   └── operator_loc: (27,2)-(27,4) = "**"
        │   ├── closing_loc: (27,10)-(27,11) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (29,0)-(29,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (29,0)-(29,3))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (29,0)-(29,1))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :a
        │   │   │   ├── message_loc: (29,0)-(29,1) = "a"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: (29,1)-(29,2) = "."
        │   │   ├── name: :b
        │   │   ├── message_loc: (29,2)-(29,3) = "b"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (29,3)-(29,4) = "."
        │   ├── name: :c
        │   ├── message_loc: (29,4)-(29,5) = "c"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (31,0)-(31,7))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (31,0)-(31,1) = "a"
        │   ├── opening_loc: (31,1)-(31,2) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (31,2)-(31,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (31,2)-(31,3))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (31,2)-(31,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (31,5)-(31,6))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :c
        │   │           ├── message_loc: (31,5)-(31,6) = "c"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (31,6)-(31,7) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (33,0)-(33,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (33,0)-(33,1) = "a"
        │   ├── opening_loc: (33,1)-(33,2) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (33,2)-(33,3) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (35,0)-(35,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (35,0)-(35,1) = "a"
        │   ├── opening_loc: (35,1)-(35,2) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (35,2)-(35,7))
        │   │   ├── flags: contains_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (35,2)-(35,7))
        │   │           ├── flags: ∅
        │   │           ├── operator_loc: (35,2)-(35,3) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (35,3)-(35,7))
        │   │               ├── flags: variable_call, ignore_visibility
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :args
        │   │               ├── message_loc: (35,3)-(35,7) = "args"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── closing_loc: (35,7)-(35,8) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (37,0)-(37,6))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (37,0)-(37,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (37,2)-(37,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (37,2)-(37,3))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (37,2)-(37,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (37,5)-(37,6))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :c
        │   │           ├── message_loc: (37,5)-(37,6) = "c"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (39,0)-(39,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (39,0)-(39,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (39,0)-(39,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (39,1)-(39,2) = "."
        │   ├── name: :b
        │   ├── message_loc: (39,2)-(39,3) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (39,4)-(39,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (39,4)-(39,5))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :c
        │   │       │   ├── message_loc: (39,4)-(39,5) = "c"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (39,7)-(39,8))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :d
        │   │           ├── message_loc: (39,7)-(39,8) = "d"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ MultiWriteNode (location: (41,0)-(41,23))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ CallTargetNode (location: (41,0)-(41,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── receiver:
        │   │   │   │   @ CallNode (location: (41,0)-(41,3))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :foo
        │   │   │   │   ├── message_loc: (41,0)-(41,3) = "foo"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── call_operator_loc: (41,3)-(41,4) = "."
        │   │   │   ├── name: :foo=
        │   │   │   └── message_loc: (41,4)-(41,7) = "foo"
        │   │   └── @ CallTargetNode (location: (41,9)-(41,16))
        │   │       ├── flags: ∅
        │   │       ├── receiver:
        │   │       │   @ CallNode (location: (41,9)-(41,12))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :bar
        │   │       │   ├── message_loc: (41,9)-(41,12) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       ├── call_operator_loc: (41,12)-(41,13) = "."
        │   │       ├── name: :bar=
        │   │       └── message_loc: (41,13)-(41,16) = "bar"
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (41,17)-(41,18) = "="
        │   └── value:
        │       @ ArrayNode (location: (41,19)-(41,23))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (41,19)-(41,20))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (41,22)-(41,23))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: ∅
        │       └── closing_loc: ∅
        ├── @ CallNode (location: (43,0)-(43,4))
        │   ├── flags: newline, safe_navigation
        │   ├── receiver:
        │   │   @ CallNode (location: (43,0)-(43,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (43,0)-(43,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (43,1)-(43,3) = "&."
        │   ├── name: :b
        │   ├── message_loc: (43,3)-(43,4) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (45,0)-(45,5))
        │   ├── flags: newline, safe_navigation
        │   ├── receiver:
        │   │   @ CallNode (location: (45,0)-(45,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (45,0)-(45,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (45,1)-(45,3) = "&."
        │   ├── name: :call
        │   ├── message_loc: ∅
        │   ├── opening_loc: (45,3)-(45,4) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (45,4)-(45,5) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (47,0)-(47,7))
        │   ├── flags: newline, safe_navigation
        │   ├── receiver:
        │   │   @ CallNode (location: (47,0)-(47,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (47,0)-(47,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (47,1)-(47,3) = "&."
        │   ├── name: :b
        │   ├── message_loc: (47,3)-(47,4) = "b"
        │   ├── opening_loc: (47,4)-(47,5) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (47,5)-(47,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (47,5)-(47,6))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :c
        │   │           ├── message_loc: (47,5)-(47,6) = "c"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (47,6)-(47,7) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (49,0)-(49,6))
        │   ├── flags: newline, safe_navigation
        │   ├── receiver:
        │   │   @ CallNode (location: (49,0)-(49,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (49,0)-(49,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (49,1)-(49,3) = "&."
        │   ├── name: :b
        │   ├── message_loc: (49,3)-(49,4) = "b"
        │   ├── opening_loc: (49,4)-(49,5) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (49,5)-(49,6) = ")"
        │   └── block: ∅
        ├── @ IfNode (location: (51,0)-(51,33))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (51,11)-(51,13) = "if"
        │   ├── predicate:
        │   │   @ AndNode (location: (51,14)-(51,33))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ OrNode (location: (51,14)-(51,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── left:
        │   │   │   │   @ CallNode (location: (51,14)-(51,18))
        │   │   │   │   ├── flags: ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :bar?
        │   │   │   │   ├── message_loc: (51,14)-(51,18) = "bar?"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── right:
        │   │   │   │   @ CallNode (location: (51,22)-(51,25))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :baz
        │   │   │   │   ├── message_loc: (51,22)-(51,25) = "baz"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── operator_loc: (51,19)-(51,21) = "or"
        │   │   ├── right:
        │   │   │   @ CallNode (location: (51,30)-(51,33))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :qux
        │   │   │   ├── message_loc: (51,30)-(51,33) = "qux"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── operator_loc: (51,26)-(51,29) = "and"
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (51,0)-(51,10))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (51,0)-(51,10))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :foo
        │   │           ├── message_loc: (51,0)-(51,3) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (51,4)-(51,10))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 2)
        │   │           │       ├── @ SymbolNode (location: (51,4)-(51,6))
        │   │           │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │           │       │   ├── opening_loc: (51,4)-(51,5) = ":"
        │   │           │       │   ├── value_loc: (51,5)-(51,6) = "a"
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   └── unescaped: "a"
        │   │           │       └── @ SymbolNode (location: (51,8)-(51,10))
        │   │           │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           │           ├── opening_loc: (51,8)-(51,9) = ":"
        │   │           │           ├── value_loc: (51,9)-(51,10) = "b"
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── unescaped: "b"
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: ∅
        ├── @ CallNode (location: (53,0)-(56,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (53,0)-(53,3) = "foo"
        │   ├── opening_loc: (53,3)-(53,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (53,4)-(55,4))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (53,4)-(53,6))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (53,4)-(53,5) = ":"
        │   │       │   ├── value_loc: (53,5)-(53,6) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ SymbolNode (location: (55,2)-(55,4))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (55,2)-(55,3) = ":"
        │   │           ├── value_loc: (55,3)-(55,4) = "b"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "b"
        │   ├── closing_loc: (56,0)-(56,1) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (58,0)-(58,10))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (58,0)-(58,3) = "foo"
        │   ├── opening_loc: (58,3)-(58,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (58,4)-(58,9))
        │   │   ├── flags: contains_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (58,4)-(58,9))
        │   │           ├── flags: ∅
        │   │           ├── operator_loc: (58,4)-(58,5) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (58,5)-(58,9))
        │   │               ├── flags: variable_call, ignore_visibility
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :rest
        │   │               ├── message_loc: (58,5)-(58,9) = "rest"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── closing_loc: (58,9)-(58,10) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (60,0)-(60,40))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (60,0)-(60,3) = "foo"
        │   ├── opening_loc: (60,3)-(60,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (60,4)-(60,32))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (60,4)-(60,6))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (60,4)-(60,5) = ":"
        │   │       │   ├── value_loc: (60,5)-(60,6) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ KeywordHashNode (location: (60,8)-(60,32))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 2)
        │   │               ├── @ AssocNode (location: (60,8)-(60,22))
        │   │               │   ├── flags: ∅
        │   │               │   ├── key:
        │   │               │   │   @ SymbolNode (location: (60,8)-(60,10))
        │   │               │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │               │   │   ├── opening_loc: (60,8)-(60,9) = ":"
        │   │               │   │   ├── value_loc: (60,9)-(60,10) = "h"
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "h"
        │   │               │   ├── value:
        │   │               │   │   @ ArrayNode (location: (60,14)-(60,22))
        │   │               │   │   ├── flags: static_literal
        │   │               │   │   ├── elements: (length: 2)
        │   │               │   │   │   ├── @ SymbolNode (location: (60,15)-(60,17))
        │   │               │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │               │   │   │   │   ├── opening_loc: (60,15)-(60,16) = ":"
        │   │               │   │   │   │   ├── value_loc: (60,16)-(60,17) = "x"
        │   │               │   │   │   │   ├── closing_loc: ∅
        │   │               │   │   │   │   └── unescaped: "x"
        │   │               │   │   │   └── @ SymbolNode (location: (60,19)-(60,21))
        │   │               │   │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │               │   │   │       ├── opening_loc: (60,19)-(60,20) = ":"
        │   │               │   │   │       ├── value_loc: (60,20)-(60,21) = "y"
        │   │               │   │   │       ├── closing_loc: ∅
        │   │               │   │   │       └── unescaped: "y"
        │   │               │   │   ├── opening_loc: (60,14)-(60,15) = "["
        │   │               │   │   └── closing_loc: (60,21)-(60,22) = "]"
        │   │               │   └── operator_loc: (60,11)-(60,13) = "=>"
        │   │               └── @ AssocNode (location: (60,24)-(60,32))
        │   │                   ├── flags: static_literal
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (60,24)-(60,26))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: (60,24)-(60,25) = ":"
        │   │                   │   ├── value_loc: (60,25)-(60,26) = "a"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "a"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (60,30)-(60,32))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: (60,30)-(60,31) = ":"
        │   │                   │   ├── value_loc: (60,31)-(60,32) = "b"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "b"
        │   │                   └── operator_loc: (60,27)-(60,29) = "=>"
        │   ├── closing_loc: (60,39)-(60,40) = ")"
        │   └── block:
        │       @ BlockArgumentNode (location: (60,34)-(60,39))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ SymbolNode (location: (60,35)-(60,39))
        │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │       │   ├── opening_loc: (60,35)-(60,36) = ":"
        │       │   ├── value_loc: (60,36)-(60,39) = "bar"
        │       │   ├── closing_loc: ∅
        │       │   └── unescaped: "bar"
        │       └── operator_loc: (60,34)-(60,35) = "&"
        ├── @ CallNode (location: (62,0)-(62,49))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :hi
        │   ├── message_loc: (62,0)-(62,2) = "hi"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (62,3)-(62,49))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ IntegerNode (location: (62,3)-(62,6))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 123
        │   │       └── @ HashNode (location: (62,8)-(62,49))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (62,8)-(62,9) = "{"
        │   │           ├── elements: (length: 3)
        │   │           │   ├── @ AssocNode (location: (62,10)-(62,27))
        │   │           │   │   ├── flags: static_literal
        │   │           │   │   ├── key:
        │   │           │   │   │   @ SymbolNode (location: (62,10)-(62,16))
        │   │           │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │           │   │   │   ├── opening_loc: (62,10)-(62,11) = ":"
        │   │           │   │   │   ├── value_loc: (62,11)-(62,16) = "there"
        │   │           │   │   │   ├── closing_loc: ∅
        │   │           │   │   │   └── unescaped: "there"
        │   │           │   │   ├── value:
        │   │           │   │   │   @ SymbolNode (location: (62,20)-(62,27))
        │   │           │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │           │   │   │   ├── opening_loc: (62,20)-(62,21) = ":"
        │   │           │   │   │   ├── value_loc: (62,21)-(62,27) = "friend"
        │   │           │   │   │   ├── closing_loc: ∅
        │   │           │   │   │   └── unescaped: "friend"
        │   │           │   │   └── operator_loc: (62,17)-(62,19) = "=>"
        │   │           │   ├── @ AssocSplatNode (location: (62,29)-(62,33))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── value:
        │   │           │   │   │   @ HashNode (location: (62,31)-(62,33))
        │   │           │   │   │   ├── flags: static_literal
        │   │           │   │   │   ├── opening_loc: (62,31)-(62,32) = "{"
        │   │           │   │   │   ├── elements: (length: 0)
        │   │           │   │   │   └── closing_loc: (62,32)-(62,33) = "}"
        │   │           │   │   └── operator_loc: (62,29)-(62,31) = "**"
        │   │           │   └── @ AssocNode (location: (62,35)-(62,47))
        │   │           │       ├── flags: static_literal
        │   │           │       ├── key:
        │   │           │       │   @ SymbolNode (location: (62,35)-(62,42))
        │   │           │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── value_loc: (62,35)-(62,41) = "whatup"
        │   │           │       │   ├── closing_loc: (62,41)-(62,42) = ":"
        │   │           │       │   └── unescaped: "whatup"
        │   │           │       ├── value:
        │   │           │       │   @ SymbolNode (location: (62,43)-(62,47))
        │   │           │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │           │       │   ├── opening_loc: (62,43)-(62,44) = ":"
        │   │           │       │   ├── value_loc: (62,44)-(62,47) = "dog"
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   └── unescaped: "dog"
        │   │           │       └── operator_loc: ∅
        │   │           └── closing_loc: (62,48)-(62,49) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (64,0)-(64,36))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (64,0)-(64,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (64,4)-(64,15))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (64,4)-(64,6))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (64,4)-(64,5) = ":"
        │   │       │   ├── value_loc: (64,5)-(64,6) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ KeywordHashNode (location: (64,8)-(64,15))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (64,8)-(64,15))
        │   │                   ├── flags: static_literal
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (64,8)-(64,10))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (64,8)-(64,9) = "b"
        │   │                   │   ├── closing_loc: (64,9)-(64,10) = ":"
        │   │                   │   └── unescaped: "b"
        │   │                   ├── value:
        │   │                   │   @ TrueNode (location: (64,11)-(64,15))
        │   │                   │   └── flags: static_literal
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (64,16)-(64,36))
        │       ├── flags: ∅
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (64,19)-(64,25))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (64,20)-(64,24))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 2)
        │       │   │   │   ├── @ RequiredParameterNode (location: (64,20)-(64,21))
        │       │   │   │   │   ├── flags: ∅
        │       │   │   │   │   └── name: :a
        │       │   │   │   └── @ RequiredParameterNode (location: (64,23)-(64,24))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :b
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (64,19)-(64,20) = "|"
        │       │   └── closing_loc: (64,24)-(64,25) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (64,26)-(64,32))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (64,26)-(64,32))
        │       │           ├── flags: newline, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :puts
        │       │           ├── message_loc: (64,26)-(64,30) = "puts"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (64,31)-(64,32))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ LocalVariableReadNode (location: (64,31)-(64,32))
        │       │           │           ├── flags: ∅
        │       │           │           ├── name: :a
        │       │           │           └── depth: 0
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (64,16)-(64,18) = "do"
        │       └── closing_loc: (64,33)-(64,36) = "end"
        ├── @ CallNode (location: (66,0)-(66,17))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :hi
        │   ├── message_loc: (66,0)-(66,2) = "hi"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (66,3)-(66,17))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (66,3)-(66,17))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (66,3)-(66,17))
        │   │                   ├── flags: static_literal
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (66,3)-(66,9))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (66,3)-(66,8) = "there"
        │   │                   │   ├── closing_loc: (66,8)-(66,9) = ":"
        │   │                   │   └── unescaped: "there"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (66,10)-(66,17))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: (66,10)-(66,11) = ":"
        │   │                   │   ├── value_loc: (66,11)-(66,17) = "friend"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "friend"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (68,0)-(68,40))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :hi
        │   ├── message_loc: (68,0)-(68,2) = "hi"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (68,3)-(68,40))
        │   │   ├── flags: contains_keywords, contains_keyword_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (68,3)-(68,40))
        │   │           ├── flags: ∅
        │   │           └── elements: (length: 3)
        │   │               ├── @ AssocNode (location: (68,3)-(68,20))
        │   │               │   ├── flags: static_literal
        │   │               │   ├── key:
        │   │               │   │   @ SymbolNode (location: (68,3)-(68,9))
        │   │               │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │               │   │   ├── opening_loc: (68,3)-(68,4) = ":"
        │   │               │   │   ├── value_loc: (68,4)-(68,9) = "there"
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "there"
        │   │               │   ├── value:
        │   │               │   │   @ SymbolNode (location: (68,13)-(68,20))
        │   │               │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │               │   │   ├── opening_loc: (68,13)-(68,14) = ":"
        │   │               │   │   ├── value_loc: (68,14)-(68,20) = "friend"
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "friend"
        │   │               │   └── operator_loc: (68,10)-(68,12) = "=>"
        │   │               ├── @ AssocSplatNode (location: (68,22)-(68,26))
        │   │               │   ├── flags: ∅
        │   │               │   ├── value:
        │   │               │   │   @ HashNode (location: (68,24)-(68,26))
        │   │               │   │   ├── flags: static_literal
        │   │               │   │   ├── opening_loc: (68,24)-(68,25) = "{"
        │   │               │   │   ├── elements: (length: 0)
        │   │               │   │   └── closing_loc: (68,25)-(68,26) = "}"
        │   │               │   └── operator_loc: (68,22)-(68,24) = "**"
        │   │               └── @ AssocNode (location: (68,28)-(68,40))
        │   │                   ├── flags: static_literal
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (68,28)-(68,35))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (68,28)-(68,34) = "whatup"
        │   │                   │   ├── closing_loc: (68,34)-(68,35) = ":"
        │   │                   │   └── unescaped: "whatup"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (68,36)-(68,40))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: (68,36)-(68,37) = ":"
        │   │                   │   ├── value_loc: (68,37)-(68,40) = "dog"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "dog"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (70,0)-(70,41))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :hi
        │   ├── message_loc: (70,0)-(70,2) = "hi"
        │   ├── opening_loc: (70,2)-(70,3) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (70,3)-(70,40))
        │   │   ├── flags: contains_keywords, contains_keyword_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (70,3)-(70,40))
        │   │           ├── flags: ∅
        │   │           └── elements: (length: 3)
        │   │               ├── @ AssocNode (location: (70,3)-(70,20))
        │   │               │   ├── flags: static_literal
        │   │               │   ├── key:
        │   │               │   │   @ SymbolNode (location: (70,3)-(70,9))
        │   │               │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │               │   │   ├── opening_loc: (70,3)-(70,4) = ":"
        │   │               │   │   ├── value_loc: (70,4)-(70,9) = "there"
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "there"
        │   │               │   ├── value:
        │   │               │   │   @ SymbolNode (location: (70,13)-(70,20))
        │   │               │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │               │   │   ├── opening_loc: (70,13)-(70,14) = ":"
        │   │               │   │   ├── value_loc: (70,14)-(70,20) = "friend"
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "friend"
        │   │               │   └── operator_loc: (70,10)-(70,12) = "=>"
        │   │               ├── @ AssocSplatNode (location: (70,22)-(70,26))
        │   │               │   ├── flags: ∅
        │   │               │   ├── value:
        │   │               │   │   @ HashNode (location: (70,24)-(70,26))
        │   │               │   │   ├── flags: static_literal
        │   │               │   │   ├── opening_loc: (70,24)-(70,25) = "{"
        │   │               │   │   ├── elements: (length: 0)
        │   │               │   │   └── closing_loc: (70,25)-(70,26) = "}"
        │   │               │   └── operator_loc: (70,22)-(70,24) = "**"
        │   │               └── @ AssocNode (location: (70,28)-(70,40))
        │   │                   ├── flags: static_literal
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (70,28)-(70,35))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (70,28)-(70,34) = "whatup"
        │   │                   │   ├── closing_loc: (70,34)-(70,35) = ":"
        │   │                   │   └── unescaped: "whatup"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (70,36)-(70,40))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: (70,36)-(70,37) = ":"
        │   │                   │   ├── value_loc: (70,37)-(70,40) = "dog"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "dog"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (70,40)-(70,41) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (72,0)-(72,36))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (72,0)-(72,3) = "foo"
        │   ├── opening_loc: (72,3)-(72,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (72,4)-(72,26))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ HashNode (location: (72,4)-(72,26))
        │   │           ├── flags: static_literal
        │   │           ├── opening_loc: (72,4)-(72,5) = "{"
        │   │           ├── elements: (length: 2)
        │   │           │   ├── @ AssocNode (location: (72,6)-(72,13))
        │   │           │   │   ├── flags: static_literal
        │   │           │   │   ├── key:
        │   │           │   │   │   @ SymbolNode (location: (72,6)-(72,8))
        │   │           │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │           │   │   │   ├── opening_loc: ∅
        │   │           │   │   │   ├── value_loc: (72,6)-(72,7) = "a"
        │   │           │   │   │   ├── closing_loc: (72,7)-(72,8) = ":"
        │   │           │   │   │   └── unescaped: "a"
        │   │           │   │   ├── value:
        │   │           │   │   │   @ TrueNode (location: (72,9)-(72,13))
        │   │           │   │   │   └── flags: static_literal
        │   │           │   │   └── operator_loc: ∅
        │   │           │   └── @ AssocNode (location: (72,15)-(72,23))
        │   │           │       ├── flags: static_literal
        │   │           │       ├── key:
        │   │           │       │   @ SymbolNode (location: (72,15)-(72,17))
        │   │           │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── value_loc: (72,15)-(72,16) = "b"
        │   │           │       │   ├── closing_loc: (72,16)-(72,17) = ":"
        │   │           │       │   └── unescaped: "b"
        │   │           │       ├── value:
        │   │           │       │   @ FalseNode (location: (72,18)-(72,23))
        │   │           │       │   └── flags: static_literal
        │   │           │       └── operator_loc: ∅
        │   │           └── closing_loc: (72,25)-(72,26) = "}"
        │   ├── closing_loc: (72,35)-(72,36) = ")"
        │   └── block:
        │       @ BlockArgumentNode (location: (72,28)-(72,35))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ SymbolNode (location: (72,29)-(72,35))
        │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │       │   ├── opening_loc: (72,29)-(72,30) = ":"
        │       │   ├── value_loc: (72,30)-(72,35) = "block"
        │       │   ├── closing_loc: ∅
        │       │   └── unescaped: "block"
        │       └── operator_loc: (72,28)-(72,29) = "&"
        ├── @ CallNode (location: (74,0)-(74,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :hi
        │   ├── message_loc: (74,0)-(74,2) = "hi"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (74,3)-(74,20))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (74,3)-(74,20))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (74,3)-(74,20))
        │   │                   ├── flags: static_literal
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (74,3)-(74,9))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: (74,3)-(74,4) = ":"
        │   │                   │   ├── value_loc: (74,4)-(74,9) = "there"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "there"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (74,13)-(74,20))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: (74,13)-(74,14) = ":"
        │   │                   │   ├── value_loc: (74,14)-(74,20) = "friend"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "friend"
        │   │                   └── operator_loc: (74,10)-(74,12) = "=>"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (76,0)-(78,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (76,0)-(76,3) = "foo"
        │   ├── opening_loc: (76,3)-(76,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (76,4)-(77,2))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (76,4)-(76,6))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (76,4)-(76,5) = ":"
        │   │       │   ├── value_loc: (76,5)-(76,6) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ SymbolNode (location: (77,0)-(77,2))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (77,0)-(77,1) = ":"
        │   │           ├── value_loc: (77,1)-(77,2) = "b"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "b"
        │   ├── closing_loc: (78,0)-(78,1) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (80,0)-(83,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (80,0)-(80,3) = "foo"
        │   ├── opening_loc: (80,3)-(80,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (81,0)-(82,5))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (81,0)-(81,2))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (81,0)-(81,1) = ":"
        │   │       │   ├── value_loc: (81,1)-(81,2) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ KeywordHashNode (location: (82,0)-(82,5))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (82,0)-(82,5))
        │   │                   ├── flags: static_literal
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (82,0)-(82,2))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (82,0)-(82,1) = "b"
        │   │                   │   ├── closing_loc: (82,1)-(82,2) = ":"
        │   │                   │   └── unescaped: "b"
        │   │                   ├── value:
        │   │                   │   @ SymbolNode (location: (82,3)-(82,5))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: (82,3)-(82,4) = ":"
        │   │                   │   ├── value_loc: (82,4)-(82,5) = "c"
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── unescaped: "c"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (83,0)-(83,1) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (85,0)-(85,11))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (85,0)-(85,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockArgumentNode (location: (85,4)-(85,11))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ SymbolNode (location: (85,5)-(85,11))
        │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │       │   ├── opening_loc: (85,5)-(85,6) = ":"
        │       │   ├── value_loc: (85,6)-(85,11) = "block"
        │       │   ├── closing_loc: ∅
        │       │   └── unescaped: "block"
        │       └── operator_loc: (85,4)-(85,5) = "&"
        ├── @ CallNode (location: (87,0)-(87,30))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (87,0)-(87,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (87,4)-(87,21))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (87,4)-(87,21))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 2)
        │   │               ├── @ AssocNode (location: (87,4)-(87,11))
        │   │               │   ├── flags: static_literal
        │   │               │   ├── key:
        │   │               │   │   @ SymbolNode (location: (87,4)-(87,6))
        │   │               │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │               │   │   ├── opening_loc: ∅
        │   │               │   │   ├── value_loc: (87,4)-(87,5) = "a"
        │   │               │   │   ├── closing_loc: (87,5)-(87,6) = ":"
        │   │               │   │   └── unescaped: "a"
        │   │               │   ├── value:
        │   │               │   │   @ TrueNode (location: (87,7)-(87,11))
        │   │               │   │   └── flags: static_literal
        │   │               │   └── operator_loc: ∅
        │   │               └── @ AssocNode (location: (87,13)-(87,21))
        │   │                   ├── flags: static_literal
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (87,13)-(87,15))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (87,13)-(87,14) = "b"
        │   │                   │   ├── closing_loc: (87,14)-(87,15) = ":"
        │   │                   │   └── unescaped: "b"
        │   │                   ├── value:
        │   │                   │   @ FalseNode (location: (87,16)-(87,21))
        │   │                   │   └── flags: static_literal
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockArgumentNode (location: (87,23)-(87,30))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ SymbolNode (location: (87,24)-(87,30))
        │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │       │   ├── opening_loc: (87,24)-(87,25) = ":"
        │       │   ├── value_loc: (87,25)-(87,30) = "block"
        │       │   ├── closing_loc: ∅
        │       │   └── unescaped: "block"
        │       └── operator_loc: (87,23)-(87,24) = "&"
        ├── @ CallNode (location: (89,0)-(89,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :some_func
        │   ├── message_loc: (89,0)-(89,9) = "some_func"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (89,10)-(89,21))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 2)
        │   │       ├── @ IntegerNode (location: (89,10)-(89,11))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 1
        │   │       └── @ KeywordHashNode (location: (89,13)-(89,21))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (89,13)-(89,21))
        │   │                   ├── flags: static_literal
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (89,13)-(89,19))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (89,13)-(89,18) = "kwarg"
        │   │                   │   ├── closing_loc: (89,18)-(89,19) = ":"
        │   │                   │   └── unescaped: "kwarg"
        │   │                   ├── value:
        │   │                   │   @ IntegerNode (location: (89,20)-(89,21))
        │   │                   │   ├── flags: static_literal, decimal
        │   │                   │   └── value: 2
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (91,0)-(91,18))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (91,0)-(91,6))
        │   │   ├── flags: ∅
        │   │   └── name: :Kernel
        │   ├── call_operator_loc: (91,6)-(91,7) = "."
        │   ├── name: :Integer
        │   ├── message_loc: (91,7)-(91,14) = "Integer"
        │   ├── opening_loc: (91,14)-(91,15) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (91,15)-(91,17))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (91,15)-(91,17))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 10
        │   ├── closing_loc: (91,17)-(91,18) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (93,0)-(93,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (93,0)-(93,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :x
        │   │   ├── message_loc: (93,0)-(93,1) = "x"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (93,1)-(93,2) = "."
        │   ├── name: :each
        │   ├── message_loc: (93,2)-(93,6) = "each"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (93,7)-(93,10))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (93,7)-(93,8) = "{"
        │       └── closing_loc: (93,9)-(93,10) = "}"
        ├── @ CallNode (location: (95,0)-(95,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (95,0)-(95,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (95,0)-(95,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (95,3)-(95,4) = "."
        │   ├── name: :map
        │   ├── message_loc: (95,4)-(95,7) = "map"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (95,8)-(95,14))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (95,10)-(95,12))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ BackReferenceReadNode (location: (95,10)-(95,12))
        │       │           ├── flags: newline
        │       │           └── name: :$&
        │       ├── opening_loc: (95,8)-(95,9) = "{"
        │       └── closing_loc: (95,13)-(95,14) = "}"
        ├── @ CallNode (location: (97,0)-(97,12))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantPathNode (location: (97,0)-(97,4))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (97,0)-(97,1))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :A
        │   │   ├── name: :B
        │   │   ├── delimiter_loc: (97,1)-(97,3) = "::"
        │   │   └── name_loc: (97,3)-(97,4) = "B"
        │   ├── call_operator_loc: (97,4)-(97,6) = "::"
        │   ├── name: :C
        │   ├── message_loc: (97,6)-(97,7) = "C"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (97,8)-(97,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (97,8)-(97,12))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (97,8)-(97,9) = ":"
        │   │           ├── value_loc: (97,9)-(97,12) = "foo"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "foo"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (99,0)-(99,13))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantPathNode (location: (99,0)-(99,4))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (99,0)-(99,1))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :A
        │   │   ├── name: :B
        │   │   ├── delimiter_loc: (99,1)-(99,3) = "::"
        │   │   └── name_loc: (99,3)-(99,4) = "B"
        │   ├── call_operator_loc: (99,4)-(99,6) = "::"
        │   ├── name: :C
        │   ├── message_loc: (99,6)-(99,7) = "C"
        │   ├── opening_loc: (99,7)-(99,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (99,8)-(99,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (99,8)-(99,12))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (99,8)-(99,9) = ":"
        │   │           ├── value_loc: (99,9)-(99,12) = "foo"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "foo"
        │   ├── closing_loc: (99,12)-(99,13) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (101,0)-(101,17))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantPathNode (location: (101,0)-(101,4))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (101,0)-(101,1))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :A
        │   │   ├── name: :B
        │   │   ├── delimiter_loc: (101,1)-(101,3) = "::"
        │   │   └── name_loc: (101,3)-(101,4) = "B"
        │   ├── call_operator_loc: (101,4)-(101,6) = "::"
        │   ├── name: :C
        │   ├── message_loc: (101,6)-(101,7) = "C"
        │   ├── opening_loc: (101,7)-(101,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (101,8)-(101,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (101,8)-(101,12))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (101,8)-(101,9) = ":"
        │   │           ├── value_loc: (101,9)-(101,12) = "foo"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "foo"
        │   ├── closing_loc: (101,12)-(101,13) = ")"
        │   └── block:
        │       @ BlockNode (location: (101,14)-(101,17))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (101,14)-(101,15) = "{"
        │       └── closing_loc: (101,16)-(101,17) = "}"
        ├── @ CallNode (location: (103,0)-(103,12))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (103,0)-(103,3) = "foo"
        │   ├── opening_loc: (103,3)-(103,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (103,4)-(103,11))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (103,4)-(103,11))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (103,4)-(103,11))
        │   │                   ├── flags: static_literal
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (103,4)-(103,8))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: (103,4)-(103,5) = "\""
        │   │                   │   ├── value_loc: (103,5)-(103,6) = "a"
        │   │                   │   ├── closing_loc: (103,6)-(103,8) = "\":"
        │   │                   │   └── unescaped: "a"
        │   │                   ├── value:
        │   │                   │   @ IntegerNode (location: (103,9)-(103,11))
        │   │                   │   ├── flags: static_literal, decimal
        │   │                   │   └── value: -1
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (103,11)-(103,12) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (105,0)-(105,28))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (105,0)-(105,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (105,4)-(105,28))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (105,4)-(105,28))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (105,4)-(105,28))
        │   │                   ├── flags: ∅
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (105,4)-(105,8))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (105,4)-(105,7) = "bar"
        │   │                   │   ├── closing_loc: (105,7)-(105,8) = ":"
        │   │                   │   └── unescaped: "bar"
        │   │                   ├── value:
        │   │                   │   @ HashNode (location: (105,9)-(105,28))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: (105,9)-(105,10) = "{"
        │   │                   │   ├── elements: (length: 1)
        │   │                   │   │   └── @ AssocNode (location: (105,11)-(105,26))
        │   │                   │   │       ├── flags: ∅
        │   │                   │   │       ├── key:
        │   │                   │   │       │   @ SymbolNode (location: (105,11)-(105,15))
        │   │                   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   │       │   ├── opening_loc: ∅
        │   │                   │   │       │   ├── value_loc: (105,11)-(105,14) = "baz"
        │   │                   │   │       │   ├── closing_loc: (105,14)-(105,15) = ":"
        │   │                   │   │       │   └── unescaped: "baz"
        │   │                   │   │       ├── value:
        │   │                   │   │       │   @ CallNode (location: (105,16)-(105,26))
        │   │                   │   │       │   ├── flags: ignore_visibility
        │   │                   │   │       │   ├── receiver: ∅
        │   │                   │   │       │   ├── call_operator_loc: ∅
        │   │                   │   │       │   ├── name: :qux
        │   │                   │   │       │   ├── message_loc: (105,16)-(105,19) = "qux"
        │   │                   │   │       │   ├── opening_loc: ∅
        │   │                   │   │       │   ├── arguments: ∅
        │   │                   │   │       │   ├── closing_loc: ∅
        │   │                   │   │       │   └── block:
        │   │                   │   │       │       @ BlockNode (location: (105,20)-(105,26))
        │   │                   │   │       │       ├── flags: ∅
        │   │                   │   │       │       ├── locals: []
        │   │                   │   │       │       ├── parameters: ∅
        │   │                   │   │       │       ├── body: ∅
        │   │                   │   │       │       ├── opening_loc: (105,20)-(105,22) = "do"
        │   │                   │   │       │       └── closing_loc: (105,23)-(105,26) = "end"
        │   │                   │   │       └── operator_loc: ∅
        │   │                   │   └── closing_loc: (105,27)-(105,28) = "}"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (107,0)-(107,24))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (107,0)-(107,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (107,4)-(107,24))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (107,4)-(107,24))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (107,4)-(107,24))
        │   │                   ├── flags: ∅
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (107,4)-(107,8))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (107,4)-(107,7) = "bar"
        │   │                   │   ├── closing_loc: (107,7)-(107,8) = ":"
        │   │                   │   └── unescaped: "bar"
        │   │                   ├── value:
        │   │                   │   @ HashNode (location: (107,9)-(107,24))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: (107,9)-(107,10) = "{"
        │   │                   │   ├── elements: (length: 1)
        │   │                   │   │   └── @ AssocSplatNode (location: (107,11)-(107,22))
        │   │                   │   │       ├── flags: ∅
        │   │                   │   │       ├── value:
        │   │                   │   │       │   @ CallNode (location: (107,13)-(107,22))
        │   │                   │   │       │   ├── flags: ignore_visibility
        │   │                   │   │       │   ├── receiver: ∅
        │   │                   │   │       │   ├── call_operator_loc: ∅
        │   │                   │   │       │   ├── name: :kw
        │   │                   │   │       │   ├── message_loc: (107,13)-(107,15) = "kw"
        │   │                   │   │       │   ├── opening_loc: ∅
        │   │                   │   │       │   ├── arguments: ∅
        │   │                   │   │       │   ├── closing_loc: ∅
        │   │                   │   │       │   └── block:
        │   │                   │   │       │       @ BlockNode (location: (107,16)-(107,22))
        │   │                   │   │       │       ├── flags: ∅
        │   │                   │   │       │       ├── locals: []
        │   │                   │   │       │       ├── parameters: ∅
        │   │                   │   │       │       ├── body: ∅
        │   │                   │   │       │       ├── opening_loc: (107,16)-(107,18) = "do"
        │   │                   │   │       │       └── closing_loc: (107,19)-(107,22) = "end"
        │   │                   │   │       └── operator_loc: (107,11)-(107,13) = "**"
        │   │                   │   └── closing_loc: (107,23)-(107,24) = "}"
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (109,0)-(109,36))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (109,0)-(109,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (109,4)-(109,29))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (109,4)-(109,29))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (109,4)-(109,5) = "\""
        │   │           ├── parts: (length: 1)
        │   │           │   └── @ EmbeddedStatementsNode (location: (109,5)-(109,28))
        │   │           │       ├── flags: ∅
        │   │           │       ├── opening_loc: (109,5)-(109,7) = "\#{"
        │   │           │       ├── statements:
        │   │           │       │   @ StatementsNode (location: (109,7)-(109,27))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   └── body: (length: 1)
        │   │           │       │       └── @ CallNode (location: (109,7)-(109,27))
        │   │           │       │           ├── flags: ∅
        │   │           │       │           ├── receiver:
        │   │           │       │           │   @ CallNode (location: (109,7)-(109,10))
        │   │           │       │           │   ├── flags: variable_call, ignore_visibility
        │   │           │       │           │   ├── receiver: ∅
        │   │           │       │           │   ├── call_operator_loc: ∅
        │   │           │       │           │   ├── name: :bar
        │   │           │       │           │   ├── message_loc: (109,7)-(109,10) = "bar"
        │   │           │       │           │   ├── opening_loc: ∅
        │   │           │       │           │   ├── arguments: ∅
        │   │           │       │           │   ├── closing_loc: ∅
        │   │           │       │           │   └── block: ∅
        │   │           │       │           ├── call_operator_loc: (109,10)-(109,11) = "."
        │   │           │       │           ├── name: :map
        │   │           │       │           ├── message_loc: (109,11)-(109,14) = "map"
        │   │           │       │           ├── opening_loc: ∅
        │   │           │       │           ├── arguments: ∅
        │   │           │       │           ├── closing_loc: ∅
        │   │           │       │           └── block:
        │   │           │       │               @ BlockNode (location: (109,15)-(109,27))
        │   │           │       │               ├── flags: ∅
        │   │           │       │               ├── locals: []
        │   │           │       │               ├── parameters: ∅
        │   │           │       │               ├── body:
        │   │           │       │               │   @ StatementsNode (location: (109,18)-(109,23))
        │   │           │       │               │   ├── flags: ∅
        │   │           │       │               │   └── body: (length: 1)
        │   │           │       │               │       └── @ StringNode (location: (109,18)-(109,23))
        │   │           │       │               │           ├── flags: newline
        │   │           │       │               │           ├── opening_loc: (109,18)-(109,19) = "\""
        │   │           │       │               │           ├── content_loc: (109,19)-(109,22) = "baz"
        │   │           │       │               │           ├── closing_loc: (109,22)-(109,23) = "\""
        │   │           │       │               │           └── unescaped: "baz"
        │   │           │       │               ├── opening_loc: (109,15)-(109,17) = "do"
        │   │           │       │               └── closing_loc: (109,24)-(109,27) = "end"
        │   │           │       └── closing_loc: (109,27)-(109,28) = "}"
        │   │           └── closing_loc: (109,28)-(109,29) = "\""
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (109,30)-(109,36))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (109,30)-(109,32) = "do"
        │       └── closing_loc: (109,33)-(109,36) = "end"
        ├── @ CallNode (location: (111,0)-(111,28))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (111,0)-(111,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (111,4)-(111,28))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ClassNode (location: (111,4)-(111,28))
        │   │           ├── flags: ∅
        │   │           ├── locals: []
        │   │           ├── class_keyword_loc: (111,4)-(111,9) = "class"
        │   │           ├── constant_path:
        │   │           │   @ ConstantReadNode (location: (111,10)-(111,13))
        │   │           │   ├── flags: ∅
        │   │           │   └── name: :Bar
        │   │           ├── inheritance_operator_loc: ∅
        │   │           ├── superclass: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (111,14)-(111,24))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (111,14)-(111,24))
        │   │           │           ├── flags: newline, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :baz
        │   │           │           ├── message_loc: (111,14)-(111,17) = "baz"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block:
        │   │           │               @ BlockNode (location: (111,18)-(111,24))
        │   │           │               ├── flags: ∅
        │   │           │               ├── locals: []
        │   │           │               ├── parameters: ∅
        │   │           │               ├── body: ∅
        │   │           │               ├── opening_loc: (111,18)-(111,20) = "do"
        │   │           │               └── closing_loc: (111,21)-(111,24) = "end"
        │   │           ├── end_keyword_loc: (111,25)-(111,28) = "end"
        │   │           └── name: :Bar
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (113,0)-(113,29))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (113,0)-(113,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (113,4)-(113,29))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ModuleNode (location: (113,4)-(113,29))
        │   │           ├── flags: ∅
        │   │           ├── locals: []
        │   │           ├── module_keyword_loc: (113,4)-(113,10) = "module"
        │   │           ├── constant_path:
        │   │           │   @ ConstantReadNode (location: (113,11)-(113,14))
        │   │           │   ├── flags: ∅
        │   │           │   └── name: :Bar
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (113,15)-(113,25))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (113,15)-(113,25))
        │   │           │           ├── flags: newline, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :baz
        │   │           │           ├── message_loc: (113,15)-(113,18) = "baz"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block:
        │   │           │               @ BlockNode (location: (113,19)-(113,25))
        │   │           │               ├── flags: ∅
        │   │           │               ├── locals: []
        │   │           │               ├── parameters: ∅
        │   │           │               ├── body: ∅
        │   │           │               ├── opening_loc: (113,19)-(113,21) = "do"
        │   │           │               └── closing_loc: (113,22)-(113,25) = "end"
        │   │           ├── end_keyword_loc: (113,26)-(113,29) = "end"
        │   │           └── name: :Bar
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (115,0)-(115,16))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (115,0)-(115,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (115,4)-(115,16))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ArrayNode (location: (115,4)-(115,16))
        │   │           ├── flags: ∅
        │   │           ├── elements: (length: 1)
        │   │           │   └── @ CallNode (location: (115,5)-(115,15))
        │   │           │       ├── flags: ignore_visibility
        │   │           │       ├── receiver: ∅
        │   │           │       ├── call_operator_loc: ∅
        │   │           │       ├── name: :baz
        │   │           │       ├── message_loc: (115,5)-(115,8) = "baz"
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── arguments: ∅
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── block:
        │   │           │           @ BlockNode (location: (115,9)-(115,15))
        │   │           │           ├── flags: ∅
        │   │           │           ├── locals: []
        │   │           │           ├── parameters: ∅
        │   │           │           ├── body: ∅
        │   │           │           ├── opening_loc: (115,9)-(115,11) = "do"
        │   │           │           └── closing_loc: (115,12)-(115,15) = "end"
        │   │           ├── opening_loc: (115,4)-(115,5) = "["
        │   │           └── closing_loc: (115,15)-(115,16) = "]"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (117,0)-(117,28))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :p
        │   ├── message_loc: (117,0)-(117,1) = "p"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (117,2)-(117,28))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ BeginNode (location: (117,2)-(117,28))
        │   │           ├── flags: ∅
        │   │           ├── begin_keyword_loc: (117,2)-(117,7) = "begin"
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (117,8)-(117,24))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (117,8)-(117,24))
        │   │           │           ├── flags: newline
        │   │           │           ├── receiver:
        │   │           │           │   @ IntegerNode (location: (117,8)-(117,9))
        │   │           │           │   ├── flags: static_literal, decimal
        │   │           │           │   └── value: 1
        │   │           │           ├── call_operator_loc: (117,9)-(117,10) = "."
        │   │           │           ├── name: :times
        │   │           │           ├── message_loc: (117,10)-(117,15) = "times"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block:
        │   │           │               @ BlockNode (location: (117,16)-(117,24))
        │   │           │               ├── flags: ∅
        │   │           │               ├── locals: []
        │   │           │               ├── parameters: ∅
        │   │           │               ├── body:
        │   │           │               │   @ StatementsNode (location: (117,19)-(117,20))
        │   │           │               │   ├── flags: ∅
        │   │           │               │   └── body: (length: 1)
        │   │           │               │       └── @ IntegerNode (location: (117,19)-(117,20))
        │   │           │               │           ├── flags: newline, static_literal, decimal
        │   │           │               │           └── value: 1
        │   │           │               ├── opening_loc: (117,16)-(117,18) = "do"
        │   │           │               └── closing_loc: (117,21)-(117,24) = "end"
        │   │           ├── rescue_clause: ∅
        │   │           ├── else_clause: ∅
        │   │           ├── ensure_clause: ∅
        │   │           └── end_keyword_loc: (117,25)-(117,28) = "end"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (119,0)-(124,5))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (119,0)-(119,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (119,4)-(124,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SymbolNode (location: (119,4)-(119,6))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (119,4)-(119,5) = ":"
        │   │       │   ├── value_loc: (119,5)-(119,6) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── @ IfNode (location: (120,2)-(124,5))
        │   │           ├── flags: newline
        │   │           ├── if_keyword_loc: (120,2)-(120,4) = "if"
        │   │           ├── predicate:
        │   │           │   @ CallNode (location: (120,5)-(120,6))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :x
        │   │           │   ├── message_loc: (120,5)-(120,6) = "x"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── then_keyword_loc: ∅
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (121,4)-(123,7))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (121,4)-(123,7))
        │   │           │           ├── flags: newline, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :bar
        │   │           │           ├── message_loc: (121,4)-(121,7) = "bar"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block:
        │   │           │               @ BlockNode (location: (121,8)-(123,7))
        │   │           │               ├── flags: ∅
        │   │           │               ├── locals: [:a]
        │   │           │               ├── parameters:
        │   │           │               │   @ BlockParametersNode (location: (121,11)-(121,14))
        │   │           │               │   ├── flags: ∅
        │   │           │               │   ├── parameters:
        │   │           │               │   │   @ ParametersNode (location: (121,12)-(121,13))
        │   │           │               │   │   ├── flags: ∅
        │   │           │               │   │   ├── requireds: (length: 1)
        │   │           │               │   │   │   └── @ RequiredParameterNode (location: (121,12)-(121,13))
        │   │           │               │   │   │       ├── flags: ∅
        │   │           │               │   │   │       └── name: :a
        │   │           │               │   │   ├── optionals: (length: 0)
        │   │           │               │   │   ├── rest: ∅
        │   │           │               │   │   ├── posts: (length: 0)
        │   │           │               │   │   ├── keywords: (length: 0)
        │   │           │               │   │   ├── keyword_rest: ∅
        │   │           │               │   │   └── block: ∅
        │   │           │               │   ├── locals: (length: 0)
        │   │           │               │   ├── opening_loc: (121,11)-(121,12) = "|"
        │   │           │               │   └── closing_loc: (121,13)-(121,14) = "|"
        │   │           │               ├── body:
        │   │           │               │   @ StatementsNode (location: (122,6)-(122,7))
        │   │           │               │   ├── flags: ∅
        │   │           │               │   └── body: (length: 1)
        │   │           │               │       └── @ LocalVariableReadNode (location: (122,6)-(122,7))
        │   │           │               │           ├── flags: newline
        │   │           │               │           ├── name: :a
        │   │           │               │           └── depth: 0
        │   │           │               ├── opening_loc: (121,8)-(121,10) = "do"
        │   │           │               └── closing_loc: (123,4)-(123,7) = "end"
        │   │           ├── subsequent: ∅
        │   │           └── end_keyword_loc: (124,2)-(124,5) = "end"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (126,0)-(135,5))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (126,0)-(126,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (126,4)-(135,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 3)
        │   │       ├── @ SymbolNode (location: (126,4)-(126,6))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (126,4)-(126,5) = ":"
        │   │       │   ├── value_loc: (126,5)-(126,6) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       ├── @ WhileNode (location: (127,2)-(131,5))
        │   │       │   ├── flags: ∅
        │   │       │   ├── keyword_loc: (127,2)-(127,7) = "while"
        │   │       │   ├── do_keyword_loc: ∅
        │   │       │   ├── closing_loc: (131,2)-(131,5) = "end"
        │   │       │   ├── predicate:
        │   │       │   │   @ CallNode (location: (127,8)-(127,9))
        │   │       │   │   ├── flags: variable_call, ignore_visibility
        │   │       │   │   ├── receiver: ∅
        │   │       │   │   ├── call_operator_loc: ∅
        │   │       │   │   ├── name: :x
        │   │       │   │   ├── message_loc: (127,8)-(127,9) = "x"
        │   │       │   │   ├── opening_loc: ∅
        │   │       │   │   ├── arguments: ∅
        │   │       │   │   ├── closing_loc: ∅
        │   │       │   │   └── block: ∅
        │   │       │   └── statements:
        │   │       │       @ StatementsNode (location: (128,4)-(130,7))
        │   │       │       ├── flags: ∅
        │   │       │       └── body: (length: 1)
        │   │       │           └── @ CallNode (location: (128,4)-(130,7))
        │   │       │               ├── flags: newline, ignore_visibility
        │   │       │               ├── receiver: ∅
        │   │       │               ├── call_operator_loc: ∅
        │   │       │               ├── name: :bar
        │   │       │               ├── message_loc: (128,4)-(128,7) = "bar"
        │   │       │               ├── opening_loc: ∅
        │   │       │               ├── arguments: ∅
        │   │       │               ├── closing_loc: ∅
        │   │       │               └── block:
        │   │       │                   @ BlockNode (location: (128,8)-(130,7))
        │   │       │                   ├── flags: ∅
        │   │       │                   ├── locals: [:a]
        │   │       │                   ├── parameters:
        │   │       │                   │   @ BlockParametersNode (location: (128,11)-(128,14))
        │   │       │                   │   ├── flags: ∅
        │   │       │                   │   ├── parameters:
        │   │       │                   │   │   @ ParametersNode (location: (128,12)-(128,13))
        │   │       │                   │   │   ├── flags: ∅
        │   │       │                   │   │   ├── requireds: (length: 1)
        │   │       │                   │   │   │   └── @ RequiredParameterNode (location: (128,12)-(128,13))
        │   │       │                   │   │   │       ├── flags: ∅
        │   │       │                   │   │   │       └── name: :a
        │   │       │                   │   │   ├── optionals: (length: 0)
        │   │       │                   │   │   ├── rest: ∅
        │   │       │                   │   │   ├── posts: (length: 0)
        │   │       │                   │   │   ├── keywords: (length: 0)
        │   │       │                   │   │   ├── keyword_rest: ∅
        │   │       │                   │   │   └── block: ∅
        │   │       │                   │   ├── locals: (length: 0)
        │   │       │                   │   ├── opening_loc: (128,11)-(128,12) = "|"
        │   │       │                   │   └── closing_loc: (128,13)-(128,14) = "|"
        │   │       │                   ├── body:
        │   │       │                   │   @ StatementsNode (location: (129,6)-(129,7))
        │   │       │                   │   ├── flags: ∅
        │   │       │                   │   └── body: (length: 1)
        │   │       │                   │       └── @ LocalVariableReadNode (location: (129,6)-(129,7))
        │   │       │                   │           ├── flags: newline
        │   │       │                   │           ├── name: :a
        │   │       │                   │           └── depth: 0
        │   │       │                   ├── opening_loc: (128,8)-(128,10) = "do"
        │   │       │                   └── closing_loc: (130,4)-(130,7) = "end"
        │   │       └── @ UntilNode (location: (132,2)-(135,5))
        │   │           ├── flags: ∅
        │   │           ├── keyword_loc: (132,2)-(132,7) = "until"
        │   │           ├── do_keyword_loc: ∅
        │   │           ├── closing_loc: (135,2)-(135,5) = "end"
        │   │           ├── predicate:
        │   │           │   @ CallNode (location: (132,8)-(132,9))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :x
        │   │           │   ├── message_loc: (132,8)-(132,9) = "x"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           └── statements:
        │   │               @ StatementsNode (location: (133,4)-(134,7))
        │   │               ├── flags: ∅
        │   │               └── body: (length: 1)
        │   │                   └── @ CallNode (location: (133,4)-(134,7))
        │   │                       ├── flags: newline, ignore_visibility
        │   │                       ├── receiver: ∅
        │   │                       ├── call_operator_loc: ∅
        │   │                       ├── name: :baz
        │   │                       ├── message_loc: (133,4)-(133,7) = "baz"
        │   │                       ├── opening_loc: ∅
        │   │                       ├── arguments: ∅
        │   │                       ├── closing_loc: ∅
        │   │                       └── block:
        │   │                           @ BlockNode (location: (133,8)-(134,7))
        │   │                           ├── flags: ∅
        │   │                           ├── locals: []
        │   │                           ├── parameters: ∅
        │   │                           ├── body: ∅
        │   │                           ├── opening_loc: (133,8)-(133,10) = "do"
        │   │                           └── closing_loc: (134,4)-(134,7) = "end"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (137,0)-(137,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ HashNode (location: (137,0)-(137,2))
        │   │   ├── flags: static_literal
        │   │   ├── opening_loc: (137,0)-(137,1) = "{"
        │   │   ├── elements: (length: 0)
        │   │   └── closing_loc: (137,1)-(137,2) = "}"
        │   ├── call_operator_loc: ∅
        │   ├── name: :+
        │   ├── message_loc: (137,3)-(137,4) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (137,5)-(137,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (137,5)-(137,9))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :A
        │   │           ├── message_loc: (137,5)-(137,6) = "A"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (137,7)-(137,9))
        │   │               ├── flags: ∅
        │   │               ├── locals: []
        │   │               ├── parameters: ∅
        │   │               ├── body: ∅
        │   │               ├── opening_loc: (137,7)-(137,8) = "{"
        │   │               └── closing_loc: (137,8)-(137,9) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (139,0)-(139,16))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ HashNode (location: (139,0)-(139,2))
        │   │   ├── flags: static_literal
        │   │   ├── opening_loc: (139,0)-(139,1) = "{"
        │   │   ├── elements: (length: 0)
        │   │   └── closing_loc: (139,1)-(139,2) = "}"
        │   ├── call_operator_loc: ∅
        │   ├── name: :+
        │   ├── message_loc: (139,3)-(139,4) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (139,5)-(139,16))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (139,5)-(139,16))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :A
        │   │           ├── message_loc: (139,5)-(139,6) = "A"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (139,7)-(139,16))
        │   │               ├── flags: ∅
        │   │               ├── locals: [:a]
        │   │               ├── parameters:
        │   │               │   @ BlockParametersNode (location: (139,9)-(139,12))
        │   │               │   ├── flags: ∅
        │   │               │   ├── parameters:
        │   │               │   │   @ ParametersNode (location: (139,10)-(139,11))
        │   │               │   │   ├── flags: ∅
        │   │               │   │   ├── requireds: (length: 1)
        │   │               │   │   │   └── @ RequiredParameterNode (location: (139,10)-(139,11))
        │   │               │   │   │       ├── flags: ∅
        │   │               │   │   │       └── name: :a
        │   │               │   │   ├── optionals: (length: 0)
        │   │               │   │   ├── rest: ∅
        │   │               │   │   ├── posts: (length: 0)
        │   │               │   │   ├── keywords: (length: 0)
        │   │               │   │   ├── keyword_rest: ∅
        │   │               │   │   └── block: ∅
        │   │               │   ├── locals: (length: 0)
        │   │               │   ├── opening_loc: (139,9)-(139,10) = "|"
        │   │               │   └── closing_loc: (139,11)-(139,12) = "|"
        │   │               ├── body:
        │   │               │   @ StatementsNode (location: (139,13)-(139,14))
        │   │               │   ├── flags: ∅
        │   │               │   └── body: (length: 1)
        │   │               │       └── @ LocalVariableReadNode (location: (139,13)-(139,14))
        │   │               │           ├── flags: newline
        │   │               │           ├── name: :a
        │   │               │           └── depth: 0
        │   │               ├── opening_loc: (139,7)-(139,8) = "{"
        │   │               └── closing_loc: (139,15)-(139,16) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (141,0)-(141,11))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (141,0)-(141,4))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :A
        │   │   ├── message_loc: (141,0)-(141,1) = "A"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (141,2)-(141,4))
        │   │       ├── flags: ∅
        │   │       ├── locals: []
        │   │       ├── parameters: ∅
        │   │       ├── body: ∅
        │   │       ├── opening_loc: (141,2)-(141,3) = "{"
        │   │       └── closing_loc: (141,3)-(141,4) = "}"
        │   ├── call_operator_loc: ∅
        │   ├── name: :+
        │   ├── message_loc: (141,5)-(141,6) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (141,7)-(141,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (141,7)-(141,11))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :A
        │   │           ├── message_loc: (141,7)-(141,8) = "A"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (141,9)-(141,11))
        │   │               ├── flags: ∅
        │   │               ├── locals: []
        │   │               ├── parameters: ∅
        │   │               ├── body: ∅
        │   │               ├── opening_loc: (141,9)-(141,10) = "{"
        │   │               └── closing_loc: (141,10)-(141,11) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (143,0)-(143,11))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (143,0)-(143,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :lst
        │   │   ├── message_loc: (143,0)-(143,3) = "lst"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :<<
        │   ├── message_loc: (143,4)-(143,6) = "<<"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (143,7)-(143,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (143,7)-(143,11))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :A
        │   │           ├── message_loc: (143,7)-(143,8) = "A"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (143,9)-(143,11))
        │   │               ├── flags: ∅
        │   │               ├── locals: []
        │   │               ├── parameters: ∅
        │   │               ├── body: ∅
        │   │               ├── opening_loc: (143,9)-(143,10) = "{"
        │   │               └── closing_loc: (143,10)-(143,11) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ InterpolatedStringNode (location: (145,0)-(145,17))
        │   ├── flags: newline
        │   ├── opening_loc: (145,0)-(145,1) = "\""
        │   ├── parts: (length: 1)
        │   │   └── @ EmbeddedStatementsNode (location: (145,1)-(145,16))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (145,1)-(145,3) = "\#{"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (145,4)-(145,14))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (145,4)-(145,14))
        │   │       │           ├── flags: ignore_visibility
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :join
        │   │       │           ├── message_loc: (145,4)-(145,8) = "join"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments:
        │   │       │           │   @ ArgumentsNode (location: (145,9)-(145,14))
        │   │       │           │   ├── flags: ∅
        │   │       │           │   └── arguments: (length: 1)
        │   │       │           │       └── @ ParenthesesNode (location: (145,9)-(145,14))
        │   │       │           │           ├── flags: ∅
        │   │       │           │           ├── body:
        │   │       │           │           │   @ StatementsNode (location: (145,10)-(145,13))
        │   │       │           │           │   ├── flags: ∅
        │   │       │           │           │   └── body: (length: 1)
        │   │       │           │           │       └── @ StringNode (location: (145,10)-(145,13))
        │   │       │           │           │           ├── flags: newline
        │   │       │           │           │           ├── opening_loc: (145,10)-(145,11) = "\""
        │   │       │           │           │           ├── content_loc: (145,11)-(145,12) = " "
        │   │       │           │           │           ├── closing_loc: (145,12)-(145,13) = "\""
        │   │       │           │           │           └── unescaped: " "
        │   │       │           │           ├── opening_loc: (145,9)-(145,10) = "("
        │   │       │           │           └── closing_loc: (145,13)-(145,14) = ")"
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       └── closing_loc: (145,15)-(145,16) = "}"
        │   └── closing_loc: (145,16)-(145,17) = "\""
        ├── @ InterpolatedStringNode (location: (147,0)-(147,8))
        │   ├── flags: newline
        │   ├── opening_loc: (147,0)-(147,1) = "\""
        │   ├── parts: (length: 1)
        │   │   └── @ EmbeddedStatementsNode (location: (147,1)-(147,7))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (147,1)-(147,3) = "\#{"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (147,3)-(147,6))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ ParenthesesNode (location: (147,3)-(147,6))
        │   │       │           ├── flags: ∅
        │   │       │           ├── body:
        │   │       │           │   @ StatementsNode (location: (147,4)-(147,5))
        │   │       │           │   ├── flags: ∅
        │   │       │           │   └── body: (length: 1)
        │   │       │           │       └── @ CallNode (location: (147,4)-(147,5))
        │   │       │           │           ├── flags: newline, variable_call, ignore_visibility
        │   │       │           │           ├── receiver: ∅
        │   │       │           │           ├── call_operator_loc: ∅
        │   │       │           │           ├── name: :v
        │   │       │           │           ├── message_loc: (147,4)-(147,5) = "v"
        │   │       │           │           ├── opening_loc: ∅
        │   │       │           │           ├── arguments: ∅
        │   │       │           │           ├── closing_loc: ∅
        │   │       │           │           └── block: ∅
        │   │       │           ├── opening_loc: (147,3)-(147,4) = "("
        │   │       │           └── closing_loc: (147,5)-(147,6) = ")"
        │   │       └── closing_loc: (147,6)-(147,7) = "}"
        │   └── closing_loc: (147,7)-(147,8) = "\""
        ├── @ DefNode (location: (149,0)-(149,18))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (149,4)-(149,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (149,6)-(149,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (149,6)-(149,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (149,6)-(149,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (149,10)-(149,13))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (149,10)-(149,13))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :p
        │   │           ├── message_loc: (149,10)-(149,11) = "p"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (149,12)-(149,13))
        │   │           │   ├── flags: contains_splat
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ SplatNode (location: (149,12)-(149,13))
        │   │           │           ├── flags: ∅
        │   │           │           ├── operator_loc: (149,12)-(149,13) = "*"
        │   │           │           └── expression: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (149,0)-(149,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (149,5)-(149,6) = "("
        │   ├── rparen_loc: (149,7)-(149,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (149,15)-(149,18) = "end"
        ├── @ CallNode (location: (151,0)-(151,16))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (151,0)-(151,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (151,4)-(151,16))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ IntegerNode (location: (151,4)-(151,5))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 1
        │   │       └── @ CallNode (location: (151,7)-(151,16))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :Bar
        │   │           ├── message_loc: (151,7)-(151,10) = "Bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (151,11)-(151,16))
        │   │               ├── flags: ∅
        │   │               ├── locals: []
        │   │               ├── parameters: ∅
        │   │               ├── body:
        │   │               │   @ StatementsNode (location: (151,13)-(151,14))
        │   │               │   ├── flags: ∅
        │   │               │   └── body: (length: 1)
        │   │               │       └── @ IntegerNode (location: (151,13)-(151,14))
        │   │               │           ├── flags: newline, static_literal, decimal
        │   │               │           └── value: 1
        │   │               ├── opening_loc: (151,11)-(151,12) = "{"
        │   │               └── closing_loc: (151,15)-(151,16) = "}"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ LocalVariableWriteNode (location: (153,0)-(153,7))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── depth: 0
        │   ├── name_loc: (153,0)-(153,3) = "foo"
        │   ├── value:
        │   │   @ IntegerNode (location: (153,6)-(153,7))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (153,4)-(153,5) = "="
        ├── @ CallNode (location: (154,0)-(154,6))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (154,0)-(154,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (154,4)-(154,6))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (154,4)-(154,5) = "{"
        │       └── closing_loc: (154,5)-(154,6) = "}"
        └── @ CallNode (location: (156,0)-(156,19))
            ├── flags: newline
            ├── receiver:
            │   @ InstanceVariableReadNode (location: (156,0)-(156,2))
            │   ├── flags: ∅
            │   └── name: :@a
            ├── call_operator_loc: (156,2)-(156,3) = "."
            ├── name: :b
            ├── message_loc: (156,3)-(156,4) = "b"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (156,5)-(156,19))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 1)
            │       └── @ KeywordHashNode (location: (156,5)-(156,19))
            │           ├── flags: ∅
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (156,5)-(156,19))
            │                   ├── flags: ∅
            │                   ├── key:
            │                   │   @ InterpolatedSymbolNode (location: (156,5)-(156,16))
            │                   │   ├── flags: ∅
            │                   │   ├── opening_loc: (156,5)-(156,6) = "\""
            │                   │   ├── parts: (length: 2)
            │                   │   │   ├── @ StringNode (location: (156,6)-(156,7))
            │                   │   │   │   ├── flags: static_literal, frozen
            │                   │   │   │   ├── opening_loc: ∅
            │                   │   │   │   ├── content_loc: (156,6)-(156,7) = "c"
            │                   │   │   │   ├── closing_loc: ∅
            │                   │   │   │   └── unescaped: "c"
            │                   │   │   └── @ EmbeddedStatementsNode (location: (156,7)-(156,14))
            │                   │   │       ├── flags: ∅
            │                   │   │       ├── opening_loc: (156,7)-(156,9) = "\#{"
            │                   │   │       ├── statements:
            │                   │   │       │   @ StatementsNode (location: (156,9)-(156,13))
            │                   │   │       │   ├── flags: ∅
            │                   │   │       │   └── body: (length: 1)
            │                   │   │       │       └── @ CallNode (location: (156,9)-(156,13))
            │                   │   │       │           ├── flags: variable_call, ignore_visibility
            │                   │   │       │           ├── receiver: ∅
            │                   │   │       │           ├── call_operator_loc: ∅
            │                   │   │       │           ├── name: :name
            │                   │   │       │           ├── message_loc: (156,9)-(156,13) = "name"
            │                   │   │       │           ├── opening_loc: ∅
            │                   │   │       │           ├── arguments: ∅
            │                   │   │       │           ├── closing_loc: ∅
            │                   │   │       │           └── block: ∅
            │                   │   │       └── closing_loc: (156,13)-(156,14) = "}"
            │                   │   └── closing_loc: (156,14)-(156,16) = "\":"
            │                   ├── value:
            │                   │   @ IntegerNode (location: (156,17)-(156,19))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 42
            │                   └── operator_loc: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/methods.txt000066400000000000000000004070151506127434000171070ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(190,3))
├── flags: ∅
├── locals: [:a, :c, :foo]
└── statements:
    @ StatementsNode (location: (1,0)-(190,3))
    ├── flags: ∅
    └── body: (length: 71)
        ├── @ DefNode (location: (1,0)-(2,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (1,4)-(1,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (1,8)-(1,18))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 2)
        │   │   │       │   ├── @ RequiredParameterNode (location: (1,9)-(1,12))
        │   │   │       │   │   ├── flags: ∅
        │   │   │       │   │   └── name: :bar
        │   │   │       │   └── @ RequiredParameterNode (location: (1,14)-(1,17))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :baz
        │   │   │       ├── rest: ∅
        │   │   │       ├── rights: (length: 0)
        │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
        │   │   │       └── rparen_loc: (1,17)-(1,18) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar, :baz]
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (1,7)-(1,8) = "("
        │   ├── rparen_loc: (1,18)-(1,19) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (2,0)-(2,3) = "end"
        ├── @ DefNode (location: (4,0)-(5,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (4,4)-(4,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (4,8)-(4,44))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (4,8)-(4,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 2)
        │   │   │       │   ├── @ RequiredParameterNode (location: (4,9)-(4,12))
        │   │   │       │   │   ├── flags: ∅
        │   │   │       │   │   └── name: :bar
        │   │   │       │   └── @ RequiredParameterNode (location: (4,14)-(4,17))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :baz
        │   │   │       ├── rest: ∅
        │   │   │       ├── rights: (length: 0)
        │   │   │       ├── lparen_loc: (4,8)-(4,9) = "("
        │   │   │       └── rparen_loc: (4,17)-(4,18) = ")"
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (4,20)-(4,32))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :optional
        │   │   │       ├── name_loc: (4,20)-(4,28) = "optional"
        │   │   │       ├── operator_loc: (4,29)-(4,30) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (4,31)-(4,32))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (4,34)-(4,44))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 2)
        │   │   │       │   ├── @ RequiredParameterNode (location: (4,35)-(4,38))
        │   │   │       │   │   ├── flags: ∅
        │   │   │       │   │   └── name: :bin
        │   │   │       │   └── @ RequiredParameterNode (location: (4,40)-(4,43))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :bag
        │   │   │       ├── rest: ∅
        │   │   │       ├── rights: (length: 0)
        │   │   │       ├── lparen_loc: (4,34)-(4,35) = "("
        │   │   │       └── rparen_loc: (4,43)-(4,44) = ")"
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar, :baz, :optional, :bin, :bag]
        │   ├── def_keyword_loc: (4,0)-(4,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (4,7)-(4,8) = "("
        │   ├── rparen_loc: (4,44)-(4,45) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (5,0)-(5,3) = "end"
        ├── @ DefNode (location: (8,0)-(8,18))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (8,4)-(8,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (8,0)-(8,18))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   ├── rescue_clause: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (8,7)-(8,18))
        │   │   │   ├── flags: ∅
        │   │   │   ├── ensure_keyword_loc: (8,7)-(8,13) = "ensure"
        │   │   │   ├── statements: ∅
        │   │   │   └── end_keyword_loc: (8,15)-(8,18) = "end"
        │   │   └── end_keyword_loc: (8,15)-(8,18) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (8,0)-(8,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (8,15)-(8,18) = "end"
        ├── @ DefNode (location: (10,0)-(11,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (10,8)-(10,9) = "a"
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (10,4)-(10,7))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ CallNode (location: (10,5)-(10,6))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :b
        │   │   │   ├── message_loc: (10,5)-(10,6) = "b"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── opening_loc: (10,4)-(10,5) = "("
        │   │   └── closing_loc: (10,6)-(10,7) = ")"
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (10,0)-(10,3) = "def"
        │   ├── operator_loc: (10,7)-(10,8) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (11,0)-(11,3) = "end"
        ├── @ DefNode (location: (13,0)-(14,3))
        │   ├── flags: newline
        │   ├── name: :b
        │   ├── name_loc: (13,9)-(13,10) = "b"
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (13,4)-(13,7))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ CallNode (location: (13,5)-(13,6))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :a
        │   │   │   ├── message_loc: (13,5)-(13,6) = "a"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── opening_loc: (13,4)-(13,5) = "("
        │   │   └── closing_loc: (13,6)-(13,7) = ")"
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (13,0)-(13,3) = "def"
        │   ├── operator_loc: (13,7)-(13,9) = "::"
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (14,0)-(14,3) = "end"
        ├── @ DefNode (location: (16,0)-(17,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (16,10)-(16,11) = "a"
        │   ├── receiver:
        │   │   @ FalseNode (location: (16,4)-(16,9))
        │   │   └── flags: static_literal
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (16,0)-(16,3) = "def"
        │   ├── operator_loc: (16,9)-(16,10) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (17,0)-(17,3) = "end"
        ├── @ DefNode (location: (19,0)-(20,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (19,4)-(19,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (19,6)-(19,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (19,6)-(19,9))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (19,0)-(19,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (19,5)-(19,6) = "("
        │   ├── rparen_loc: (19,9)-(19,10) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (20,0)-(20,3) = "end"
        ├── @ DefNode (location: (22,0)-(23,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (22,9)-(22,10) = "a"
        │   ├── receiver:
        │   │   @ GlobalVariableReadNode (location: (22,4)-(22,8))
        │   │   ├── flags: ∅
        │   │   └── name: :$var
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (22,0)-(22,3) = "def"
        │   ├── operator_loc: (22,8)-(22,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (23,0)-(23,3) = "end"
        ├── @ DefNode (location: (25,0)-(26,3))
        │   ├── flags: newline
        │   ├── name: :b
        │   ├── name_loc: (25,6)-(25,7) = "b"
        │   ├── receiver:
        │   │   @ CallNode (location: (25,4)-(25,5))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (25,4)-(25,5) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (25,0)-(25,3) = "def"
        │   ├── operator_loc: (25,5)-(25,6) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (26,0)-(26,3) = "end"
        ├── @ DefNode (location: (28,0)-(29,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (28,9)-(28,10) = "a"
        │   ├── receiver:
        │   │   @ InstanceVariableReadNode (location: (28,4)-(28,8))
        │   │   ├── flags: ∅
        │   │   └── name: :@var
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (28,0)-(28,3) = "def"
        │   ├── operator_loc: (28,8)-(28,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (29,0)-(29,3) = "end"
        ├── @ DefNode (location: (31,0)-(31,13))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (31,4)-(31,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (31,6)-(31,8))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ RequiredKeywordParameterNode (location: (31,6)-(31,8))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :b
        │   │   │       └── name_loc: (31,6)-(31,8) = "b:"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (31,0)-(31,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (31,10)-(31,13) = "end"
        ├── @ StringNode (location: (33,0)-(33,6))
        │   ├── flags: newline
        │   ├── opening_loc: (33,0)-(33,2) = "%,"
        │   ├── content_loc: (33,2)-(33,5) = "abc"
        │   ├── closing_loc: (33,5)-(33,6) = ","
        │   └── unescaped: "abc"
        ├── @ DefNode (location: (35,0)-(36,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (35,4)-(35,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (35,6)-(35,8))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ RequiredKeywordParameterNode (location: (35,6)-(35,8))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :b
        │   │   │       └── name_loc: (35,6)-(35,8) = "b:"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (35,0)-(35,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (35,5)-(35,6) = "("
        │   ├── rparen_loc: (35,8)-(35,9) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (36,0)-(36,3) = "end"
        ├── @ DefNode (location: (38,0)-(39,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (38,4)-(38,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (38,6)-(38,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ KeywordRestParameterNode (location: (38,6)-(38,9))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :b
        │   │   │   ├── name_loc: (38,8)-(38,9) = "b"
        │   │   │   └── operator_loc: (38,6)-(38,8) = "**"
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (38,0)-(38,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (38,5)-(38,6) = "("
        │   ├── rparen_loc: (38,9)-(38,10) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (39,0)-(39,3) = "end"
        ├── @ DefNode (location: (41,0)-(42,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (41,4)-(41,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (41,6)-(41,8))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ KeywordRestParameterNode (location: (41,6)-(41,8))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (41,6)-(41,8) = "**"
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (41,0)-(41,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (41,5)-(41,6) = "("
        │   ├── rparen_loc: (41,8)-(41,9) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (42,0)-(42,3) = "end"
        ├── @ LocalVariableWriteNode (location: (44,0)-(44,5))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── depth: 0
        │   ├── name_loc: (44,0)-(44,1) = "a"
        │   ├── value:
        │   │   @ IntegerNode (location: (44,4)-(44,5))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (44,2)-(44,3) = "="
        ├── @ DefNode (location: (44,7)-(45,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (44,11)-(44,12) = "a"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (44,7)-(44,10) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (45,0)-(45,3) = "end"
        ├── @ DefNode (location: (47,0)-(48,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (47,4)-(47,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (47,6)-(47,13))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 3)
        │   │   │   ├── @ RequiredParameterNode (location: (47,6)-(47,7))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :b
        │   │   │   ├── @ RequiredParameterNode (location: (47,9)-(47,10))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :c
        │   │   │   └── @ RequiredParameterNode (location: (47,12)-(47,13))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :d
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b, :c, :d]
        │   ├── def_keyword_loc: (47,0)-(47,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (48,0)-(48,3) = "end"
        ├── @ DefNode (location: (50,0)-(51,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (50,8)-(50,9) = "a"
        │   ├── receiver:
        │   │   @ NilNode (location: (50,4)-(50,7))
        │   │   └── flags: static_literal
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (50,0)-(50,3) = "def"
        │   ├── operator_loc: (50,7)-(50,8) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (51,0)-(51,3) = "end"
        ├── @ DefNode (location: (53,0)-(54,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (53,4)-(53,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (53,6)-(53,14))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 2)
        │   │   │   ├── @ RequiredKeywordParameterNode (location: (53,6)-(53,8))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   └── name_loc: (53,6)-(53,8) = "b:"
        │   │   │   └── @ OptionalKeywordParameterNode (location: (53,10)-(53,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :c
        │   │   │       ├── name_loc: (53,10)-(53,12) = "c:"
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (53,13)-(53,14))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b, :c]
        │   ├── def_keyword_loc: (53,0)-(53,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (54,0)-(54,3) = "end"
        ├── @ DefNode (location: (56,0)-(57,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (56,4)-(56,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (56,6)-(56,14))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 2)
        │   │   │   ├── @ RequiredKeywordParameterNode (location: (56,6)-(56,8))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   └── name_loc: (56,6)-(56,8) = "b:"
        │   │   │   └── @ OptionalKeywordParameterNode (location: (56,10)-(56,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :c
        │   │   │       ├── name_loc: (56,10)-(56,12) = "c:"
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (56,13)-(56,14))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b, :c]
        │   ├── def_keyword_loc: (56,0)-(56,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (56,5)-(56,6) = "("
        │   ├── rparen_loc: (56,14)-(56,15) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (57,0)-(57,3) = "end"
        ├── @ DefNode (location: (59,0)-(61,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (59,4)-(59,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (59,6)-(60,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 2)
        │   │   │   ├── @ OptionalKeywordParameterNode (location: (59,6)-(60,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   ├── name_loc: (59,6)-(59,8) = "b:"
        │   │   │   │   └── value:
        │   │   │   │       @ IntegerNode (location: (60,2)-(60,3))
        │   │   │   │       ├── flags: static_literal, decimal
        │   │   │   │       └── value: 1
        │   │   │   └── @ RequiredKeywordParameterNode (location: (60,5)-(60,7))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :c
        │   │   │       └── name_loc: (60,5)-(60,7) = "c:"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b, :c]
        │   ├── def_keyword_loc: (59,0)-(59,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (59,5)-(59,6) = "("
        │   ├── rparen_loc: (60,7)-(60,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (61,0)-(61,3) = "end"
        ├── @ StringNode (location: (63,0)-(63,6))
        │   ├── flags: newline
        │   ├── opening_loc: (63,0)-(63,2) = "%."
        │   ├── content_loc: (63,2)-(63,5) = "abc"
        │   ├── closing_loc: (63,5)-(63,6) = "."
        │   └── unescaped: "abc"
        ├── @ DefNode (location: (65,0)-(66,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (65,4)-(65,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (65,6)-(65,18))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 2)
        │   │   │   ├── @ OptionalParameterNode (location: (65,6)-(65,11))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   ├── name_loc: (65,6)-(65,7) = "b"
        │   │   │   │   ├── operator_loc: (65,8)-(65,9) = "="
        │   │   │   │   └── value:
        │   │   │   │       @ IntegerNode (location: (65,10)-(65,11))
        │   │   │   │       ├── flags: static_literal, decimal
        │   │   │   │       └── value: 1
        │   │   │   └── @ OptionalParameterNode (location: (65,13)-(65,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :c
        │   │   │       ├── name_loc: (65,13)-(65,14) = "c"
        │   │   │       ├── operator_loc: (65,15)-(65,16) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (65,17)-(65,18))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b, :c]
        │   ├── def_keyword_loc: (65,0)-(65,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (66,0)-(66,3) = "end"
        ├── @ DefNode (location: (68,0)-(69,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (68,4)-(68,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (68,0)-(68,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (68,5)-(68,6) = "("
        │   ├── rparen_loc: (68,6)-(68,7) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (69,0)-(69,3) = "end"
        ├── @ DefNode (location: (71,0)-(72,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (71,4)-(71,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (71,6)-(71,14))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (71,6)-(71,7))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :b
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (71,9)-(71,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :c
        │   │   │       ├── name_loc: (71,9)-(71,10) = "c"
        │   │   │       ├── operator_loc: (71,11)-(71,12) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (71,13)-(71,14))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b, :c]
        │   ├── def_keyword_loc: (71,0)-(71,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (72,0)-(72,3) = "end"
        ├── @ DefNode (location: (74,0)-(75,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (74,4)-(74,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (74,6)-(74,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (74,6)-(74,7))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :b
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (74,0)-(74,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (75,0)-(75,3) = "end"
        ├── @ DefNode (location: (77,0)-(77,32))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (77,4)-(77,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (77,0)-(77,32))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (77,7)-(77,13))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (77,7)-(77,13) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   ├── statements: ∅
        │   │   │   └── subsequent: ∅
        │   │   ├── else_clause:
        │   │   │   @ ElseNode (location: (77,15)-(77,27))
        │   │   │   ├── flags: ∅
        │   │   │   ├── else_keyword_loc: (77,15)-(77,19) = "else"
        │   │   │   ├── statements: ∅
        │   │   │   └── end_keyword_loc: (77,21)-(77,27) = "ensure"
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (77,21)-(77,32))
        │   │   │   ├── flags: ∅
        │   │   │   ├── ensure_keyword_loc: (77,21)-(77,27) = "ensure"
        │   │   │   ├── statements: ∅
        │   │   │   └── end_keyword_loc: (77,29)-(77,32) = "end"
        │   │   └── end_keyword_loc: (77,29)-(77,32) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (77,0)-(77,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (77,29)-(77,32) = "end"
        ├── @ DefNode (location: (79,0)-(80,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (79,4)-(79,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (79,6)-(79,8))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (79,6)-(79,8))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :b
        │   │   │   ├── name_loc: (79,7)-(79,8) = "b"
        │   │   │   └── operator_loc: (79,6)-(79,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (79,0)-(79,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (80,0)-(80,3) = "end"
        ├── @ DefNode (location: (82,0)-(83,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (82,4)-(82,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (82,6)-(82,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (82,6)-(82,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (82,6)-(82,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (82,0)-(82,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (82,5)-(82,6) = "("
        │   ├── rparen_loc: (82,7)-(82,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (83,0)-(83,3) = "end"
        ├── @ DefNode (location: (85,0)-(87,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (85,4)-(85,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (86,0)-(86,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableWriteNode (location: (86,0)-(86,5))
        │   │           ├── flags: newline
        │   │           ├── name: :b
        │   │           ├── depth: 0
        │   │           ├── name_loc: (86,0)-(86,1) = "b"
        │   │           ├── value:
        │   │           │   @ IntegerNode (location: (86,4)-(86,5))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 1
        │   │           └── operator_loc: (86,2)-(86,3) = "="
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (85,0)-(85,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (87,0)-(87,3) = "end"
        ├── @ DefNode (location: (89,0)-(90,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (89,9)-(89,10) = "a"
        │   ├── receiver:
        │   │   @ SelfNode (location: (89,4)-(89,8))
        │   │   └── flags: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (89,0)-(89,3) = "def"
        │   ├── operator_loc: (89,8)-(89,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (90,0)-(90,3) = "end"
        ├── @ DefNode (location: (92,0)-(93,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (92,9)-(92,10) = "a"
        │   ├── receiver:
        │   │   @ TrueNode (location: (92,4)-(92,8))
        │   │   └── flags: static_literal
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (92,0)-(92,3) = "def"
        │   ├── operator_loc: (92,8)-(92,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (93,0)-(93,3) = "end"
        ├── @ DefNode (location: (95,0)-(96,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (95,4)-(95,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (95,0)-(95,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (96,0)-(96,3) = "end"
        ├── @ DefNode (location: (98,0)-(101,3))
        │   ├── flags: newline
        │   ├── name: :hi
        │   ├── name_loc: (98,4)-(98,6) = "hi"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (99,0)-(100,4))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 2)
        │   │       ├── @ IfNode (location: (99,0)-(99,18))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (99,11)-(99,13) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ TrueNode (location: (99,14)-(99,18))
        │   │       │   │   └── flags: static_literal
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (99,0)-(99,10))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ReturnNode (location: (99,0)-(99,10))
        │   │       │   │           ├── flags: newline
        │   │       │   │           ├── keyword_loc: (99,0)-(99,6) = "return"
        │   │       │   │           └── arguments:
        │   │       │   │               @ ArgumentsNode (location: (99,7)-(99,10))
        │   │       │   │               ├── flags: ∅
        │   │       │   │               └── arguments: (length: 1)
        │   │       │   │                   └── @ SymbolNode (location: (99,7)-(99,10))
        │   │       │   │                       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │                       ├── opening_loc: (99,7)-(99,8) = ":"
        │   │       │   │                       ├── value_loc: (99,8)-(99,10) = "hi"
        │   │       │   │                       ├── closing_loc: ∅
        │   │       │   │                       └── unescaped: "hi"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       └── @ SymbolNode (location: (100,0)-(100,4))
        │   │           ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (100,0)-(100,1) = ":"
        │   │           ├── value_loc: (100,1)-(100,4) = "bye"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "bye"
        │   ├── locals: []
        │   ├── def_keyword_loc: (98,0)-(98,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (101,0)-(101,3) = "end"
        ├── @ DefNode (location: (103,0)-(103,11))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (103,4)-(103,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (103,10)-(103,11))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (103,10)-(103,11))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── locals: []
        │   ├── def_keyword_loc: (103,0)-(103,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (103,8)-(103,9) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (104,0)-(104,11))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (104,4)-(104,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (104,10)-(104,11))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (104,10)-(104,11))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── locals: []
        │   ├── def_keyword_loc: (104,0)-(104,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (104,8)-(104,9) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (106,0)-(106,18))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (106,4)-(106,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (106,8)-(106,11))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (106,8)-(106,11))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :bar
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (106,15)-(106,18))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (106,15)-(106,18))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 123
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (106,0)-(106,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (106,7)-(106,8) = "("
        │   ├── rparen_loc: (106,11)-(106,12) = ")"
        │   ├── equal_loc: (106,13)-(106,14) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (108,0)-(108,13))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (108,4)-(108,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (108,10)-(108,13))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (108,10)-(108,13))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 123
        │   ├── locals: []
        │   ├── def_keyword_loc: (108,0)-(108,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (108,8)-(108,9) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (110,0)-(110,19))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (110,4)-(110,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (110,6)-(110,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (110,6)-(110,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (110,6)-(110,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (110,10)-(110,14))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (110,10)-(110,14))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (110,10)-(110,11) = "b"
        │   │           ├── opening_loc: (110,11)-(110,12) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (110,12)-(110,13))
        │   │           │   ├── flags: contains_splat
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ SplatNode (location: (110,12)-(110,13))
        │   │           │           ├── flags: ∅
        │   │           │           ├── operator_loc: (110,12)-(110,13) = "*"
        │   │           │           └── expression: ∅
        │   │           ├── closing_loc: (110,13)-(110,14) = ")"
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (110,0)-(110,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (110,5)-(110,6) = "("
        │   ├── rparen_loc: (110,7)-(110,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (110,16)-(110,19) = "end"
        ├── @ DefNode (location: (112,0)-(112,33))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (112,4)-(112,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (112,6)-(112,11))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (112,6)-(112,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (112,6)-(112,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ KeywordRestParameterNode (location: (112,9)-(112,11))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (112,9)-(112,11) = "**"
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (112,14)-(112,28))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (112,14)-(112,28))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (112,14)-(112,15) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (112,16)-(112,28))
        │   │               ├── flags: ∅
        │   │               ├── locals: []
        │   │               ├── parameters: ∅
        │   │               ├── body:
        │   │               │   @ StatementsNode (location: (112,18)-(112,26))
        │   │               │   ├── flags: ∅
        │   │               │   └── body: (length: 1)
        │   │               │       └── @ CallNode (location: (112,18)-(112,26))
        │   │               │           ├── flags: newline, ignore_visibility
        │   │               │           ├── receiver: ∅
        │   │               │           ├── call_operator_loc: ∅
        │   │               │           ├── name: :c
        │   │               │           ├── message_loc: (112,18)-(112,19) = "c"
        │   │               │           ├── opening_loc: (112,19)-(112,20) = "("
        │   │               │           ├── arguments:
        │   │               │           │   @ ArgumentsNode (location: (112,20)-(112,25))
        │   │               │           │   ├── flags: contains_keywords, contains_keyword_splat, contains_splat
        │   │               │           │   └── arguments: (length: 2)
        │   │               │           │       ├── @ SplatNode (location: (112,20)-(112,21))
        │   │               │           │       │   ├── flags: ∅
        │   │               │           │       │   ├── operator_loc: (112,20)-(112,21) = "*"
        │   │               │           │       │   └── expression: ∅
        │   │               │           │       └── @ KeywordHashNode (location: (112,23)-(112,25))
        │   │               │           │           ├── flags: ∅
        │   │               │           │           └── elements: (length: 1)
        │   │               │           │               └── @ AssocSplatNode (location: (112,23)-(112,25))
        │   │               │           │                   ├── flags: ∅
        │   │               │           │                   ├── value: ∅
        │   │               │           │                   └── operator_loc: (112,23)-(112,25) = "**"
        │   │               │           ├── closing_loc: (112,25)-(112,26) = ")"
        │   │               │           └── block: ∅
        │   │               ├── opening_loc: (112,16)-(112,17) = "{"
        │   │               └── closing_loc: (112,27)-(112,28) = "}"
        │   ├── locals: []
        │   ├── def_keyword_loc: (112,0)-(112,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (112,5)-(112,6) = "("
        │   ├── rparen_loc: (112,11)-(112,12) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (112,30)-(112,33) = "end"
        ├── @ DefNode (location: (114,0)-(114,23))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (114,4)-(114,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (114,6)-(114,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (114,6)-(114,9))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (114,12)-(114,18))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (114,12)-(114,18))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (114,12)-(114,13) = "b"
        │   │           ├── opening_loc: (114,13)-(114,14) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (114,14)-(114,17))
        │   │           │   ├── flags: contains_forwarding
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (114,14)-(114,17))
        │   │           │           └── flags: ∅
        │   │           ├── closing_loc: (114,17)-(114,18) = ")"
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (114,0)-(114,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (114,5)-(114,6) = "("
        │   ├── rparen_loc: (114,9)-(114,10) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (114,20)-(114,23) = "end"
        ├── @ DefNode (location: (116,0)-(116,29))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (116,4)-(116,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (116,6)-(116,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (116,6)-(116,9))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (116,12)-(116,24))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (116,12)-(116,24))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (116,12)-(116,13) = "b"
        │   │           ├── opening_loc: (116,13)-(116,14) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (116,14)-(116,23))
        │   │           │   ├── flags: contains_forwarding
        │   │           │   └── arguments: (length: 3)
        │   │           │       ├── @ IntegerNode (location: (116,14)-(116,15))
        │   │           │       │   ├── flags: static_literal, decimal
        │   │           │       │   └── value: 1
        │   │           │       ├── @ IntegerNode (location: (116,17)-(116,18))
        │   │           │       │   ├── flags: static_literal, decimal
        │   │           │       │   └── value: 2
        │   │           │       └── @ ForwardingArgumentsNode (location: (116,20)-(116,23))
        │   │           │           └── flags: ∅
        │   │           ├── closing_loc: (116,23)-(116,24) = ")"
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (116,0)-(116,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (116,5)-(116,6) = "("
        │   ├── rparen_loc: (116,9)-(116,10) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (116,26)-(116,29) = "end"
        ├── @ DefNode (location: (118,0)-(119,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (118,12)-(118,13) = "a"
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (118,4)-(118,11))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ LocalVariableWriteNode (location: (118,5)-(118,10))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :c
        │   │   │   ├── depth: 0
        │   │   │   ├── name_loc: (118,5)-(118,6) = "c"
        │   │   │   ├── value:
        │   │   │   │   @ CallNode (location: (118,9)-(118,10))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   ├── message_loc: (118,9)-(118,10) = "b"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── operator_loc: (118,7)-(118,8) = "="
        │   │   ├── opening_loc: (118,4)-(118,5) = "("
        │   │   └── closing_loc: (118,10)-(118,11) = ")"
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (118,0)-(118,3) = "def"
        │   ├── operator_loc: (118,11)-(118,12) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (119,0)-(119,3) = "end"
        ├── @ DefNode (location: (121,0)-(122,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (121,4)-(121,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (121,6)-(121,8))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (121,6)-(121,8))
        │   │       ├── flags: ∅
        │   │       ├── name: :b
        │   │       ├── name_loc: (121,7)-(121,8) = "b"
        │   │       └── operator_loc: (121,6)-(121,7) = "&"
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (121,0)-(121,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (122,0)-(122,3) = "end"
        ├── @ DefNode (location: (124,0)-(125,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (124,4)-(124,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (124,6)-(124,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (124,6)-(124,7))
        │   │       ├── flags: ∅
        │   │       ├── name: ∅
        │   │       ├── name_loc: ∅
        │   │       └── operator_loc: (124,6)-(124,7) = "&"
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (124,0)-(124,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (124,5)-(124,6) = "("
        │   ├── rparen_loc: (124,7)-(124,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (125,0)-(125,3) = "end"
        ├── @ DefNode (location: (127,0)-(128,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (127,10)-(127,11) = "a"
        │   ├── receiver:
        │   │   @ ClassVariableReadNode (location: (127,4)-(127,9))
        │   │   ├── flags: ∅
        │   │   └── name: :@@var
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (127,0)-(127,3) = "def"
        │   ├── operator_loc: (127,9)-(127,10) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (128,0)-(128,3) = "end"
        ├── @ DefNode (location: (130,0)-(131,3))
        │   ├── flags: newline
        │   ├── name: :C
        │   ├── name_loc: (130,12)-(130,13) = "C"
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (130,4)-(130,11))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ LocalVariableWriteNode (location: (130,5)-(130,10))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :a
        │   │   │   ├── depth: 0
        │   │   │   ├── name_loc: (130,5)-(130,6) = "a"
        │   │   │   ├── value:
        │   │   │   │   @ CallNode (location: (130,9)-(130,10))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   ├── message_loc: (130,9)-(130,10) = "b"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── operator_loc: (130,7)-(130,8) = "="
        │   │   ├── opening_loc: (130,4)-(130,5) = "("
        │   │   └── closing_loc: (130,10)-(130,11) = ")"
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (130,0)-(130,3) = "def"
        │   ├── operator_loc: (130,11)-(130,12) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (131,0)-(131,3) = "end"
        ├── @ DefNode (location: (133,0)-(133,28))
        │   ├── flags: newline
        │   ├── name: :Array_function
        │   ├── name_loc: (133,9)-(133,23) = "Array_function"
        │   ├── receiver:
        │   │   @ SelfNode (location: (133,4)-(133,8))
        │   │   └── flags: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (133,0)-(133,3) = "def"
        │   ├── operator_loc: (133,8)-(133,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (133,25)-(133,28) = "end"
        ├── @ ConstantWriteNode (location: (135,0)-(135,9))
        │   ├── flags: newline
        │   ├── name: :Const
        │   ├── name_loc: (135,0)-(135,5) = "Const"
        │   ├── value:
        │   │   @ IntegerNode (location: (135,8)-(135,9))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (135,6)-(135,7) = "="
        ├── @ DefNode (location: (135,11)-(136,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (135,21)-(135,22) = "a"
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (135,15)-(135,20))
        │   │   ├── flags: ∅
        │   │   └── name: :Const
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (135,11)-(135,14) = "def"
        │   ├── operator_loc: (135,20)-(135,21) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (136,0)-(136,3) = "end"
        ├── @ DefNode (location: (138,0)-(138,31))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (138,4)-(138,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (138,6)-(138,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (138,6)-(138,9))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (138,12)-(138,26))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (138,12)-(138,26))
        │   │           ├── flags: newline
        │   │           ├── opening_loc: (138,12)-(138,13) = "\""
        │   │           ├── parts: (length: 2)
        │   │           │   ├── @ StringNode (location: (138,13)-(138,16))
        │   │           │   │   ├── flags: static_literal, frozen
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (138,13)-(138,16) = "foo"
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "foo"
        │   │           │   └── @ EmbeddedStatementsNode (location: (138,16)-(138,25))
        │   │           │       ├── flags: ∅
        │   │           │       ├── opening_loc: (138,16)-(138,18) = "\#{"
        │   │           │       ├── statements:
        │   │           │       │   @ StatementsNode (location: (138,18)-(138,24))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   └── body: (length: 1)
        │   │           │       │       └── @ CallNode (location: (138,18)-(138,24))
        │   │           │       │           ├── flags: ignore_visibility
        │   │           │       │           ├── receiver: ∅
        │   │           │       │           ├── call_operator_loc: ∅
        │   │           │       │           ├── name: :b
        │   │           │       │           ├── message_loc: (138,18)-(138,19) = "b"
        │   │           │       │           ├── opening_loc: (138,19)-(138,20) = "("
        │   │           │       │           ├── arguments:
        │   │           │       │           │   @ ArgumentsNode (location: (138,20)-(138,23))
        │   │           │       │           │   ├── flags: contains_forwarding
        │   │           │       │           │   └── arguments: (length: 1)
        │   │           │       │           │       └── @ ForwardingArgumentsNode (location: (138,20)-(138,23))
        │   │           │       │           │           └── flags: ∅
        │   │           │       │           ├── closing_loc: (138,23)-(138,24) = ")"
        │   │           │       │           └── block: ∅
        │   │           │       └── closing_loc: (138,24)-(138,25) = "}"
        │   │           └── closing_loc: (138,25)-(138,26) = "\""
        │   ├── locals: []
        │   ├── def_keyword_loc: (138,0)-(138,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (138,5)-(138,6) = "("
        │   ├── rparen_loc: (138,9)-(138,10) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (138,28)-(138,31) = "end"
        ├── @ DefNode (location: (140,0)-(142,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (140,4)-(140,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (141,2)-(141,30))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (141,2)-(141,30))
        │   │           ├── flags: newline
        │   │           ├── receiver:
        │   │           │   @ HashNode (location: (141,2)-(141,4))
        │   │           │   ├── flags: static_literal
        │   │           │   ├── opening_loc: (141,2)-(141,3) = "{"
        │   │           │   ├── elements: (length: 0)
        │   │           │   └── closing_loc: (141,3)-(141,4) = "}"
        │   │           ├── call_operator_loc: (141,4)-(141,5) = "."
        │   │           ├── name: :merge
        │   │           ├── message_loc: (141,5)-(141,10) = "merge"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (141,11)-(141,30))
        │   │           │   ├── flags: contains_keywords, contains_keyword_splat
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ KeywordHashNode (location: (141,11)-(141,30))
        │   │           │           ├── flags: ∅
        │   │           │           └── elements: (length: 3)
        │   │           │               ├── @ AssocSplatNode (location: (141,11)-(141,16))
        │   │           │               │   ├── flags: ∅
        │   │           │               │   ├── value:
        │   │           │               │   │   @ CallNode (location: (141,13)-(141,16))
        │   │           │               │   │   ├── flags: variable_call, ignore_visibility
        │   │           │               │   │   ├── receiver: ∅
        │   │           │               │   │   ├── call_operator_loc: ∅
        │   │           │               │   │   ├── name: :bar
        │   │           │               │   │   ├── message_loc: (141,13)-(141,16) = "bar"
        │   │           │               │   │   ├── opening_loc: ∅
        │   │           │               │   │   ├── arguments: ∅
        │   │           │               │   │   ├── closing_loc: ∅
        │   │           │               │   │   └── block: ∅
        │   │           │               │   └── operator_loc: (141,11)-(141,13) = "**"
        │   │           │               ├── @ AssocSplatNode (location: (141,18)-(141,23))
        │   │           │               │   ├── flags: ∅
        │   │           │               │   ├── value:
        │   │           │               │   │   @ CallNode (location: (141,20)-(141,23))
        │   │           │               │   │   ├── flags: variable_call, ignore_visibility
        │   │           │               │   │   ├── receiver: ∅
        │   │           │               │   │   ├── call_operator_loc: ∅
        │   │           │               │   │   ├── name: :baz
        │   │           │               │   │   ├── message_loc: (141,20)-(141,23) = "baz"
        │   │           │               │   │   ├── opening_loc: ∅
        │   │           │               │   │   ├── arguments: ∅
        │   │           │               │   │   ├── closing_loc: ∅
        │   │           │               │   │   └── block: ∅
        │   │           │               │   └── operator_loc: (141,18)-(141,20) = "**"
        │   │           │               └── @ AssocSplatNode (location: (141,25)-(141,30))
        │   │           │                   ├── flags: ∅
        │   │           │                   ├── value:
        │   │           │                   │   @ CallNode (location: (141,27)-(141,30))
        │   │           │                   │   ├── flags: variable_call, ignore_visibility
        │   │           │                   │   ├── receiver: ∅
        │   │           │                   │   ├── call_operator_loc: ∅
        │   │           │                   │   ├── name: :qux
        │   │           │                   │   ├── message_loc: (141,27)-(141,30) = "qux"
        │   │           │                   │   ├── opening_loc: ∅
        │   │           │                   │   ├── arguments: ∅
        │   │           │                   │   ├── closing_loc: ∅
        │   │           │                   │   └── block: ∅
        │   │           │                   └── operator_loc: (141,25)-(141,27) = "**"
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (140,0)-(140,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (142,0)-(142,3) = "end"
        ├── @ DefNode (location: (144,0)-(145,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (144,4)-(144,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (144,8)-(144,19))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (144,8)-(144,19))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       ├── name_loc: (144,8)-(144,10) = "a:"
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (144,11)-(144,19))
        │   │   │           ├── flags: ∅
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (144,12)-(144,18))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 1)
        │   │   │           │       └── @ RangeNode (location: (144,12)-(144,18))
        │   │   │           │           ├── flags: newline, static_literal, exclude_end
        │   │   │           │           ├── left:
        │   │   │           │           │   @ IntegerNode (location: (144,12)-(144,13))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 1
        │   │   │           │           ├── right:
        │   │   │           │           │   @ IntegerNode (location: (144,16)-(144,18))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 10
        │   │   │           │           └── operator_loc: (144,13)-(144,16) = "..."
        │   │   │           ├── opening_loc: (144,11)-(144,12) = "("
        │   │   │           └── closing_loc: (144,18)-(144,19) = ")"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (144,0)-(144,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (144,7)-(144,8) = "("
        │   ├── rparen_loc: (144,19)-(144,20) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (145,0)-(145,3) = "end"
        ├── @ DefNode (location: (147,0)-(148,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (147,4)-(147,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (147,8)-(147,18))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (147,8)-(147,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       ├── name_loc: (147,8)-(147,10) = "a:"
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (147,11)-(147,18))
        │   │   │           ├── flags: ∅
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (147,12)-(147,17))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 1)
        │   │   │           │       └── @ RangeNode (location: (147,12)-(147,17))
        │   │   │           │           ├── flags: newline, static_literal, exclude_end
        │   │   │           │           ├── left: ∅
        │   │   │           │           ├── right:
        │   │   │           │           │   @ IntegerNode (location: (147,15)-(147,17))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 10
        │   │   │           │           └── operator_loc: (147,12)-(147,15) = "..."
        │   │   │           ├── opening_loc: (147,11)-(147,12) = "("
        │   │   │           └── closing_loc: (147,17)-(147,18) = ")"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (147,0)-(147,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (147,7)-(147,8) = "("
        │   ├── rparen_loc: (147,18)-(147,19) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (148,0)-(148,3) = "end"
        ├── @ DefNode (location: (150,0)-(151,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (150,4)-(150,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (150,8)-(150,17))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (150,8)-(150,17))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       ├── name_loc: (150,8)-(150,10) = "a:"
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (150,11)-(150,17))
        │   │   │           ├── flags: ∅
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (150,12)-(150,16))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 1)
        │   │   │           │       └── @ RangeNode (location: (150,12)-(150,16))
        │   │   │           │           ├── flags: newline, static_literal, exclude_end
        │   │   │           │           ├── left:
        │   │   │           │           │   @ IntegerNode (location: (150,12)-(150,13))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 1
        │   │   │           │           ├── right: ∅
        │   │   │           │           └── operator_loc: (150,13)-(150,16) = "..."
        │   │   │           ├── opening_loc: (150,11)-(150,12) = "("
        │   │   │           └── closing_loc: (150,16)-(150,17) = ")"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (150,0)-(150,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (150,7)-(150,8) = "("
        │   ├── rparen_loc: (150,17)-(150,18) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (151,0)-(151,3) = "end"
        ├── @ DefNode (location: (153,0)-(154,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (153,4)-(153,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (153,8)-(153,20))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (153,8)-(153,20))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       ├── name_loc: (153,8)-(153,9) = "a"
        │   │   │       ├── operator_loc: (153,10)-(153,11) = "="
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (153,12)-(153,20))
        │   │   │           ├── flags: ∅
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (153,13)-(153,19))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 1)
        │   │   │           │       └── @ RangeNode (location: (153,13)-(153,19))
        │   │   │           │           ├── flags: newline, static_literal, exclude_end
        │   │   │           │           ├── left:
        │   │   │           │           │   @ IntegerNode (location: (153,13)-(153,14))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 1
        │   │   │           │           ├── right:
        │   │   │           │           │   @ IntegerNode (location: (153,17)-(153,19))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 10
        │   │   │           │           └── operator_loc: (153,14)-(153,17) = "..."
        │   │   │           ├── opening_loc: (153,12)-(153,13) = "("
        │   │   │           └── closing_loc: (153,19)-(153,20) = ")"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (153,0)-(153,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (153,7)-(153,8) = "("
        │   ├── rparen_loc: (153,20)-(153,21) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (154,0)-(154,3) = "end"
        ├── @ DefNode (location: (156,0)-(157,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (156,4)-(156,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (156,8)-(156,19))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (156,8)-(156,19))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       ├── name_loc: (156,8)-(156,9) = "a"
        │   │   │       ├── operator_loc: (156,10)-(156,11) = "="
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (156,12)-(156,19))
        │   │   │           ├── flags: ∅
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (156,13)-(156,18))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 1)
        │   │   │           │       └── @ RangeNode (location: (156,13)-(156,18))
        │   │   │           │           ├── flags: newline, static_literal, exclude_end
        │   │   │           │           ├── left: ∅
        │   │   │           │           ├── right:
        │   │   │           │           │   @ IntegerNode (location: (156,16)-(156,18))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 10
        │   │   │           │           └── operator_loc: (156,13)-(156,16) = "..."
        │   │   │           ├── opening_loc: (156,12)-(156,13) = "("
        │   │   │           └── closing_loc: (156,18)-(156,19) = ")"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (156,0)-(156,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (156,7)-(156,8) = "("
        │   ├── rparen_loc: (156,19)-(156,20) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (157,0)-(157,3) = "end"
        ├── @ DefNode (location: (159,0)-(160,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (159,4)-(159,7) = "bar"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (159,8)-(159,18))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (159,8)-(159,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       ├── name_loc: (159,8)-(159,9) = "a"
        │   │   │       ├── operator_loc: (159,10)-(159,11) = "="
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (159,12)-(159,18))
        │   │   │           ├── flags: ∅
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (159,13)-(159,17))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 1)
        │   │   │           │       └── @ RangeNode (location: (159,13)-(159,17))
        │   │   │           │           ├── flags: newline, static_literal, exclude_end
        │   │   │           │           ├── left:
        │   │   │           │           │   @ IntegerNode (location: (159,13)-(159,14))
        │   │   │           │           │   ├── flags: static_literal, decimal
        │   │   │           │           │   └── value: 1
        │   │   │           │           ├── right: ∅
        │   │   │           │           └── operator_loc: (159,14)-(159,17) = "..."
        │   │   │           ├── opening_loc: (159,12)-(159,13) = "("
        │   │   │           └── closing_loc: (159,17)-(159,18) = ")"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (159,0)-(159,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (159,7)-(159,8) = "("
        │   ├── rparen_loc: (159,18)-(159,19) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (160,0)-(160,3) = "end"
        ├── @ DefNode (location: (162,0)-(164,3))
        │   ├── flags: newline
        │   ├── name: :method
        │   ├── name_loc: (162,4)-(162,10) = "method"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (162,11)-(162,12))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (162,11)-(162,12))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (163,2)-(163,14))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (163,2)-(163,14))
        │   │           ├── flags: newline
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (163,2)-(163,6))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :item
        │   │           │   ├── message_loc: (163,2)-(163,6) = "item"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :>>
        │   │           ├── message_loc: (163,7)-(163,9) = ">>"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (163,10)-(163,14))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ CallNode (location: (163,10)-(163,14))
        │   │           │           ├── flags: ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :a
        │   │           │           ├── message_loc: (163,10)-(163,11) = "a"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block:
        │   │           │               @ BlockNode (location: (163,12)-(163,14))
        │   │           │               ├── flags: ∅
        │   │           │               ├── locals: []
        │   │           │               ├── parameters: ∅
        │   │           │               ├── body: ∅
        │   │           │               ├── opening_loc: (163,12)-(163,13) = "{"
        │   │           │               └── closing_loc: (163,13)-(163,14) = "}"
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (162,0)-(162,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (162,10)-(162,11) = "("
        │   ├── rparen_loc: (162,12)-(162,13) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (164,0)-(164,3) = "end"
        ├── @ LocalVariableWriteNode (location: (166,0)-(166,7))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── depth: 0
        │   ├── name_loc: (166,0)-(166,3) = "foo"
        │   ├── value:
        │   │   @ IntegerNode (location: (166,6)-(166,7))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (166,4)-(166,5) = "="
        ├── @ DefNode (location: (167,0)-(167,16))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (167,8)-(167,11) = "bar"
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (167,4)-(167,7))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (167,0)-(167,3) = "def"
        │   ├── operator_loc: (167,7)-(167,8) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (167,13)-(167,16) = "end"
        ├── @ DefNode (location: (169,0)-(169,18))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (169,4)-(169,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (169,6)-(169,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (169,6)-(169,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (169,6)-(169,7) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (169,10)-(169,13))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ ArrayNode (location: (169,10)-(169,13))
        │   │           ├── flags: newline, contains_splat
        │   │           ├── elements: (length: 1)
        │   │           │   └── @ SplatNode (location: (169,11)-(169,12))
        │   │           │       ├── flags: ∅
        │   │           │       ├── operator_loc: (169,11)-(169,12) = "*"
        │   │           │       └── expression: ∅
        │   │           ├── opening_loc: (169,10)-(169,11) = "["
        │   │           └── closing_loc: (169,12)-(169,13) = "]"
        │   ├── locals: []
        │   ├── def_keyword_loc: (169,0)-(169,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (169,5)-(169,6) = "("
        │   ├── rparen_loc: (169,7)-(169,8) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (169,15)-(169,18) = "end"
        ├── @ DefNode (location: (171,0)-(171,15))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (171,4)-(171,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (171,6)-(171,10))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (171,6)-(171,10))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :x
        │   │   │       ├── name_loc: (171,6)-(171,8) = "x:"
        │   │   │       └── value:
        │   │   │           @ CallNode (location: (171,8)-(171,10))
        │   │   │           ├── flags: ∅
        │   │   │           ├── receiver:
        │   │   │           │   @ CallNode (location: (171,9)-(171,10))
        │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── name: :a
        │   │   │           │   ├── message_loc: (171,9)-(171,10) = "a"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── block: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :-@
        │   │   │           ├── message_loc: (171,8)-(171,9) = "-"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:x]
        │   ├── def_keyword_loc: (171,0)-(171,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (171,12)-(171,15) = "end"
        ├── @ DefNode (location: (173,0)-(173,15))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (173,4)-(173,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (173,6)-(173,10))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (173,6)-(173,10))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :x
        │   │   │       ├── name_loc: (173,6)-(173,8) = "x:"
        │   │   │       └── value:
        │   │   │           @ CallNode (location: (173,8)-(173,10))
        │   │   │           ├── flags: ∅
        │   │   │           ├── receiver:
        │   │   │           │   @ CallNode (location: (173,9)-(173,10))
        │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── name: :a
        │   │   │           │   ├── message_loc: (173,9)-(173,10) = "a"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── block: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :+@
        │   │   │           ├── message_loc: (173,8)-(173,9) = "+"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:x]
        │   ├── def_keyword_loc: (173,0)-(173,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (173,12)-(173,15) = "end"
        ├── @ DefNode (location: (175,0)-(175,15))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (175,4)-(175,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (175,6)-(175,10))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (175,6)-(175,10))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :x
        │   │   │       ├── name_loc: (175,6)-(175,8) = "x:"
        │   │   │       └── value:
        │   │   │           @ CallNode (location: (175,8)-(175,10))
        │   │   │           ├── flags: ∅
        │   │   │           ├── receiver:
        │   │   │           │   @ CallNode (location: (175,9)-(175,10))
        │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── name: :a
        │   │   │           │   ├── message_loc: (175,9)-(175,10) = "a"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── block: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :!
        │   │   │           ├── message_loc: (175,8)-(175,9) = "!"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:x]
        │   ├── def_keyword_loc: (175,0)-(175,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (175,12)-(175,15) = "end"
        ├── @ DefNode (location: (177,0)-(177,20))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (177,4)-(177,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (177,8)-(177,15))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (177,8)-(177,15))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :x
        │   │   │       ├── name_loc: (177,8)-(177,10) = "x:"
        │   │   │       └── value:
        │   │   │           @ StringNode (location: (177,10)-(177,15))
        │   │   │           ├── flags: ∅
        │   │   │           ├── opening_loc: (177,10)-(177,12) = "%("
        │   │   │           ├── content_loc: (177,12)-(177,14) = "xx"
        │   │   │           ├── closing_loc: (177,14)-(177,15) = ")"
        │   │   │           └── unescaped: "xx"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:x]
        │   ├── def_keyword_loc: (177,0)-(177,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (177,17)-(177,20) = "end"
        ├── @ DefNode (location: (179,0)-(181,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (179,4)-(179,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (179,8)-(179,11))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (179,8)-(179,11))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (180,2)-(180,10))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (180,2)-(180,10))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (180,2)-(180,5) = "bar"
        │   │           ├── opening_loc: (180,5)-(180,6) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (180,6)-(180,9))
        │   │           │   ├── flags: contains_forwarding
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (180,6)-(180,9))
        │   │           │           └── flags: ∅
        │   │           ├── closing_loc: (180,9)-(180,10) = ")"
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (179,0)-(179,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (179,7)-(179,8) = "("
        │   ├── rparen_loc: (179,11)-(179,12) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (181,0)-(181,3) = "end"
        ├── @ DefNode (location: (183,0)-(183,42))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (183,4)-(183,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (183,8)-(183,37))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (183,8)-(183,37))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (183,8)-(183,11) = "bar"
        │   │   │       ├── operator_loc: (183,12)-(183,13) = "="
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (183,14)-(183,37))
        │   │   │           ├── flags: multiple_statements
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (183,15)-(183,36))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 2)
        │   │   │           │       ├── @ DefNode (location: (183,15)-(183,33))
        │   │   │           │       │   ├── flags: newline
        │   │   │           │       │   ├── name: :baz
        │   │   │           │       │   ├── name_loc: (183,19)-(183,22) = "baz"
        │   │   │           │       │   ├── receiver: ∅
        │   │   │           │       │   ├── parameters:
        │   │   │           │       │   │   @ ParametersNode (location: (183,23)-(183,26))
        │   │   │           │       │   │   ├── flags: ∅
        │   │   │           │       │   │   ├── requireds: (length: 1)
        │   │   │           │       │   │   │   └── @ RequiredParameterNode (location: (183,23)-(183,26))
        │   │   │           │       │   │   │       ├── flags: ∅
        │   │   │           │       │   │   │       └── name: :bar
        │   │   │           │       │   │   ├── optionals: (length: 0)
        │   │   │           │       │   │   ├── rest: ∅
        │   │   │           │       │   │   ├── posts: (length: 0)
        │   │   │           │       │   │   ├── keywords: (length: 0)
        │   │   │           │       │   │   ├── keyword_rest: ∅
        │   │   │           │       │   │   └── block: ∅
        │   │   │           │       │   ├── body:
        │   │   │           │       │   │   @ StatementsNode (location: (183,30)-(183,33))
        │   │   │           │       │   │   ├── flags: ∅
        │   │   │           │       │   │   └── body: (length: 1)
        │   │   │           │       │   │       └── @ LocalVariableReadNode (location: (183,30)-(183,33))
        │   │   │           │       │   │           ├── flags: ∅
        │   │   │           │       │   │           ├── name: :bar
        │   │   │           │       │   │           └── depth: 0
        │   │   │           │       │   ├── locals: [:bar]
        │   │   │           │       │   ├── def_keyword_loc: (183,15)-(183,18) = "def"
        │   │   │           │       │   ├── operator_loc: ∅
        │   │   │           │       │   ├── lparen_loc: (183,22)-(183,23) = "("
        │   │   │           │       │   ├── rparen_loc: (183,26)-(183,27) = ")"
        │   │   │           │       │   ├── equal_loc: (183,28)-(183,29) = "="
        │   │   │           │       │   └── end_keyword_loc: ∅
        │   │   │           │       └── @ IntegerNode (location: (183,35)-(183,36))
        │   │   │           │           ├── flags: newline, static_literal, decimal
        │   │   │           │           └── value: 1
        │   │   │           ├── opening_loc: (183,14)-(183,15) = "("
        │   │   │           └── closing_loc: (183,36)-(183,37) = ")"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (183,41)-(183,42))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (183,41)-(183,42))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (183,0)-(183,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (183,7)-(183,8) = "("
        │   ├── rparen_loc: (183,37)-(183,38) = ")"
        │   ├── equal_loc: (183,39)-(183,40) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (185,0)-(185,37))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (185,21)-(185,24) = "foo"
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (185,4)-(185,20))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ ClassNode (location: (185,5)-(185,19))
        │   │   │   ├── flags: ∅
        │   │   │   ├── locals: []
        │   │   │   ├── class_keyword_loc: (185,5)-(185,10) = "class"
        │   │   │   ├── constant_path:
        │   │   │   │   @ ConstantReadNode (location: (185,11)-(185,14))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :Foo
        │   │   │   ├── inheritance_operator_loc: ∅
        │   │   │   ├── superclass: ∅
        │   │   │   ├── body: ∅
        │   │   │   ├── end_keyword_loc: (185,16)-(185,19) = "end"
        │   │   │   └── name: :Foo
        │   │   ├── opening_loc: (185,4)-(185,5) = "("
        │   │   └── closing_loc: (185,19)-(185,20) = ")"
        │   ├── parameters:
        │   │   @ ParametersNode (location: (185,25)-(185,32))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (185,25)-(185,32))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (185,25)-(185,28) = "bar"
        │   │   │       ├── operator_loc: (185,29)-(185,30) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (185,31)-(185,32))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (185,36)-(185,37))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (185,36)-(185,37))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (185,0)-(185,3) = "def"
        │   ├── operator_loc: (185,20)-(185,21) = "."
        │   ├── lparen_loc: (185,24)-(185,25) = "("
        │   ├── rparen_loc: (185,32)-(185,33) = ")"
        │   ├── equal_loc: (185,34)-(185,35) = "="
        │   └── end_keyword_loc: ∅
        └── @ ModuleNode (location: (187,0)-(190,3))
            ├── flags: newline
            ├── locals: []
            ├── module_keyword_loc: (187,0)-(187,6) = "module"
            ├── constant_path:
            │   @ ConstantReadNode (location: (187,7)-(187,10))
            │   ├── flags: ∅
            │   └── name: :Foo
            ├── body:
            │   @ StatementsNode (location: (188,2)-(189,5))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ DefNode (location: (188,2)-(189,5))
            │           ├── flags: newline
            │           ├── name: :clone
            │           ├── name_loc: (188,6)-(188,11) = "clone"
            │           ├── receiver: ∅
            │           ├── parameters:
            │           │   @ ParametersNode (location: (188,12)-(188,39))
            │           │   ├── flags: ∅
            │           │   ├── requireds: (length: 0)
            │           │   ├── optionals: (length: 1)
            │           │   │   └── @ OptionalParameterNode (location: (188,12)-(188,39))
            │           │   │       ├── flags: ∅
            │           │   │       ├── name: :opts
            │           │   │       ├── name_loc: (188,12)-(188,16) = "opts"
            │           │   │       ├── operator_loc: (188,17)-(188,18) = "="
            │           │   │       └── value:
            │           │   │           @ OrNode (location: (188,19)-(188,39))
            │           │   │           ├── flags: ∅
            │           │   │           ├── left:
            │           │   │           │   @ NilNode (location: (188,19)-(188,22))
            │           │   │           │   └── flags: static_literal
            │           │   │           ├── right:
            │           │   │           │   @ ParenthesesNode (location: (188,26)-(188,39))
            │           │   │           │   ├── flags: ∅
            │           │   │           │   ├── body:
            │           │   │           │   │   @ StatementsNode (location: (188,27)-(188,38))
            │           │   │           │   │   ├── flags: ∅
            │           │   │           │   │   └── body: (length: 1)
            │           │   │           │   │       └── @ ReturnNode (location: (188,27)-(188,38))
            │           │   │           │   │           ├── flags: newline
            │           │   │           │   │           ├── keyword_loc: (188,27)-(188,33) = "return"
            │           │   │           │   │           └── arguments:
            │           │   │           │   │               @ ArgumentsNode (location: (188,34)-(188,38))
            │           │   │           │   │               ├── flags: ∅
            │           │   │           │   │               └── arguments: (length: 1)
            │           │   │           │   │                   └── @ SelfNode (location: (188,34)-(188,38))
            │           │   │           │   │                       └── flags: ∅
            │           │   │           │   ├── opening_loc: (188,26)-(188,27) = "("
            │           │   │           │   └── closing_loc: (188,38)-(188,39) = ")"
            │           │   │           └── operator_loc: (188,23)-(188,25) = "||"
            │           │   ├── rest: ∅
            │           │   ├── posts: (length: 0)
            │           │   ├── keywords: (length: 0)
            │           │   ├── keyword_rest: ∅
            │           │   └── block: ∅
            │           ├── body: ∅
            │           ├── locals: [:opts]
            │           ├── def_keyword_loc: (188,2)-(188,5) = "def"
            │           ├── operator_loc: ∅
            │           ├── lparen_loc: (188,11)-(188,12) = "("
            │           ├── rparen_loc: (188,39)-(188,40) = ")"
            │           ├── equal_loc: ∅
            │           └── end_keyword_loc: (189,2)-(189,5) = "end"
            ├── end_keyword_loc: (190,0)-(190,3) = "end"
            └── name: :Foo
prism-1.5.1/snapshots/modules.txt000066400000000000000000000255051506127434000171140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(18,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(18,3))
    ├── flags: ∅
    └── body: (length: 7)
        ├── @ ModuleNode (location: (1,0)-(1,18))
        │   ├── flags: newline
        │   ├── locals: [:a]
        │   ├── module_keyword_loc: (1,0)-(1,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (1,7)-(1,8))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (1,9)-(1,14))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableWriteNode (location: (1,9)-(1,14))
        │   │           ├── flags: newline
        │   │           ├── name: :a
        │   │           ├── depth: 0
        │   │           ├── name_loc: (1,9)-(1,10) = "a"
        │   │           ├── value:
        │   │           │   @ IntegerNode (location: (1,13)-(1,14))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 1
        │   │           └── operator_loc: (1,11)-(1,12) = "="
        │   ├── end_keyword_loc: (1,15)-(1,18) = "end"
        │   └── name: :A
        ├── @ InterpolatedStringNode (location: (3,0)-(3,18))
        │   ├── flags: newline
        │   ├── opening_loc: (3,0)-(3,3) = "%Q{"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (3,3)-(3,7))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (3,3)-(3,7) = "aaa "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "aaa "
        │   │   ├── @ EmbeddedStatementsNode (location: (3,7)-(3,13))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (3,7)-(3,9) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (3,9)-(3,12))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (3,9)-(3,12))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :bbb
        │   │   │   │           ├── message_loc: (3,9)-(3,12) = "bbb"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── closing_loc: (3,12)-(3,13) = "}"
        │   │   └── @ StringNode (location: (3,13)-(3,17))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (3,13)-(3,17) = " ccc"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: " ccc"
        │   └── closing_loc: (3,17)-(3,18) = "}"
        ├── @ ModuleNode (location: (5,0)-(6,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── module_keyword_loc: (5,0)-(5,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantPathNode (location: (5,7)-(5,11))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ CallNode (location: (5,7)-(5,8))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :m
        │   │   │   ├── message_loc: (5,7)-(5,8) = "m"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── name: :M
        │   │   ├── delimiter_loc: (5,8)-(5,10) = "::"
        │   │   └── name_loc: (5,10)-(5,11) = "M"
        │   ├── body: ∅
        │   ├── end_keyword_loc: (6,0)-(6,3) = "end"
        │   └── name: :M
        ├── @ ModuleNode (location: (8,0)-(9,19))
        │   ├── flags: newline
        │   ├── locals: [:x]
        │   ├── module_keyword_loc: (8,0)-(8,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (8,7)-(8,8))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── body:
        │   │   @ BeginNode (location: (8,0)-(9,19))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (9,1)-(9,6))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ LocalVariableWriteNode (location: (9,1)-(9,6))
        │   │   │           ├── flags: newline
        │   │   │           ├── name: :x
        │   │   │           ├── depth: 0
        │   │   │           ├── name_loc: (9,1)-(9,2) = "x"
        │   │   │           ├── value:
        │   │   │           │   @ IntegerNode (location: (9,5)-(9,6))
        │   │   │           │   ├── flags: static_literal, decimal
        │   │   │           │   └── value: 1
        │   │   │           └── operator_loc: (9,3)-(9,4) = "="
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (9,8)-(9,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (9,8)-(9,14) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   ├── statements: ∅
        │   │   │   └── subsequent: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause: ∅
        │   │   └── end_keyword_loc: (9,16)-(9,19) = "end"
        │   ├── end_keyword_loc: (9,16)-(9,19) = "end"
        │   └── name: :A
        ├── @ ModuleNode (location: (11,0)-(12,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── module_keyword_loc: (11,0)-(11,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantPathNode (location: (11,7)-(11,10))
        │   │   ├── flags: ∅
        │   │   ├── parent: ∅
        │   │   ├── name: :A
        │   │   ├── delimiter_loc: (11,7)-(11,9) = "::"
        │   │   └── name_loc: (11,9)-(11,10) = "A"
        │   ├── body: ∅
        │   ├── end_keyword_loc: (12,0)-(12,3) = "end"
        │   └── name: :A
        ├── @ ModuleNode (location: (14,0)-(15,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── module_keyword_loc: (14,0)-(14,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantPathNode (location: (14,7)-(14,13))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ CallNode (location: (14,7)-(14,10))
        │   │   │   ├── flags: ∅
        │   │   │   ├── receiver:
        │   │   │   │   @ ConstantReadNode (location: (14,7)-(14,8))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :A
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :[]
        │   │   │   ├── message_loc: (14,8)-(14,10) = "[]"
        │   │   │   ├── opening_loc: (14,8)-(14,9) = "["
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: (14,9)-(14,10) = "]"
        │   │   │   └── block: ∅
        │   │   ├── name: :B
        │   │   ├── delimiter_loc: (14,10)-(14,12) = "::"
        │   │   └── name_loc: (14,12)-(14,13) = "B"
        │   ├── body: ∅
        │   ├── end_keyword_loc: (15,0)-(15,3) = "end"
        │   └── name: :B
        └── @ ModuleNode (location: (17,0)-(18,3))
            ├── flags: newline
            ├── locals: []
            ├── module_keyword_loc: (17,0)-(17,6) = "module"
            ├── constant_path:
            │   @ ConstantPathNode (location: (17,7)-(17,14))
            │   ├── flags: ∅
            │   ├── parent:
            │   │   @ CallNode (location: (17,7)-(17,11))
            │   │   ├── flags: ∅
            │   │   ├── receiver:
            │   │   │   @ ConstantReadNode (location: (17,7)-(17,8))
            │   │   │   ├── flags: ∅
            │   │   │   └── name: :A
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :[]
            │   │   ├── message_loc: (17,8)-(17,11) = "[1]"
            │   │   ├── opening_loc: (17,8)-(17,9) = "["
            │   │   ├── arguments:
            │   │   │   @ ArgumentsNode (location: (17,9)-(17,10))
            │   │   │   ├── flags: ∅
            │   │   │   └── arguments: (length: 1)
            │   │   │       └── @ IntegerNode (location: (17,9)-(17,10))
            │   │   │           ├── flags: static_literal, decimal
            │   │   │           └── value: 1
            │   │   ├── closing_loc: (17,10)-(17,11) = "]"
            │   │   └── block: ∅
            │   ├── name: :B
            │   ├── delimiter_loc: (17,11)-(17,13) = "::"
            │   └── name_loc: (17,13)-(17,14) = "B"
            ├── body: ∅
            ├── end_keyword_loc: (18,0)-(18,3) = "end"
            └── name: :B
prism-1.5.1/snapshots/multi_write.txt000066400000000000000000000130571506127434000200070ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,26))
├── flags: ∅
├── locals: [:foo, :bar]
└── statements:
    @ StatementsNode (location: (1,0)-(4,26))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ LocalVariableWriteNode (location: (1,0)-(1,18))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── depth: 0
        │   ├── name_loc: (1,0)-(1,3) = "foo"
        │   ├── value:
        │   │   @ RescueModifierNode (location: (1,6)-(1,18))
        │   │   ├── flags: ∅
        │   │   ├── expression:
        │   │   │   @ IntegerNode (location: (1,6)-(1,7))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── keyword_loc: (1,8)-(1,14) = "rescue"
        │   │   └── rescue_expression:
        │   │       @ NilNode (location: (1,15)-(1,18))
        │   │       └── flags: static_literal
        │   └── operator_loc: (1,4)-(1,5) = "="
        ├── @ MultiWriteNode (location: (2,0)-(2,23))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ LocalVariableTargetNode (location: (2,0)-(2,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :foo
        │   │   │   └── depth: 0
        │   │   └── @ LocalVariableTargetNode (location: (2,5)-(2,8))
        │   │       ├── flags: ∅
        │   │       ├── name: :bar
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (2,9)-(2,10) = "="
        │   └── value:
        │       @ RescueModifierNode (location: (2,11)-(2,23))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ IntegerNode (location: (2,11)-(2,12))
        │       │   ├── flags: static_literal, decimal
        │       │   └── value: 1
        │       ├── keyword_loc: (2,13)-(2,19) = "rescue"
        │       └── rescue_expression:
        │           @ NilNode (location: (2,20)-(2,23))
        │           └── flags: static_literal
        ├── @ RescueModifierNode (location: (3,0)-(3,21))
        │   ├── flags: newline
        │   ├── expression:
        │   │   @ LocalVariableWriteNode (location: (3,0)-(3,10))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   ├── depth: 0
        │   │   ├── name_loc: (3,0)-(3,3) = "foo"
        │   │   ├── value:
        │   │   │   @ ArrayNode (location: (3,6)-(3,10))
        │   │   │   ├── flags: static_literal
        │   │   │   ├── elements: (length: 2)
        │   │   │   │   ├── @ IntegerNode (location: (3,6)-(3,7))
        │   │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   │   └── value: 1
        │   │   │   │   └── @ IntegerNode (location: (3,9)-(3,10))
        │   │   │   │       ├── flags: static_literal, decimal
        │   │   │   │       └── value: 2
        │   │   │   ├── opening_loc: ∅
        │   │   │   └── closing_loc: ∅
        │   │   └── operator_loc: (3,4)-(3,5) = "="
        │   ├── keyword_loc: (3,11)-(3,17) = "rescue"
        │   └── rescue_expression:
        │       @ NilNode (location: (3,18)-(3,21))
        │       └── flags: static_literal
        └── @ MultiWriteNode (location: (4,0)-(4,26))
            ├── flags: newline
            ├── lefts: (length: 2)
            │   ├── @ LocalVariableTargetNode (location: (4,0)-(4,3))
            │   │   ├── flags: ∅
            │   │   ├── name: :foo
            │   │   └── depth: 0
            │   └── @ LocalVariableTargetNode (location: (4,5)-(4,8))
            │       ├── flags: ∅
            │       ├── name: :bar
            │       └── depth: 0
            ├── rest: ∅
            ├── rights: (length: 0)
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── operator_loc: (4,9)-(4,10) = "="
            └── value:
                @ RescueModifierNode (location: (4,11)-(4,26))
                ├── flags: ∅
                ├── expression:
                │   @ ArrayNode (location: (4,11)-(4,15))
                │   ├── flags: static_literal
                │   ├── elements: (length: 2)
                │   │   ├── @ IntegerNode (location: (4,11)-(4,12))
                │   │   │   ├── flags: static_literal, decimal
                │   │   │   └── value: 1
                │   │   └── @ IntegerNode (location: (4,14)-(4,15))
                │   │       ├── flags: static_literal, decimal
                │   │       └── value: 2
                │   ├── opening_loc: ∅
                │   └── closing_loc: ∅
                ├── keyword_loc: (4,16)-(4,22) = "rescue"
                └── rescue_expression:
                    @ NilNode (location: (4,23)-(4,26))
                    └── flags: static_literal
prism-1.5.1/snapshots/newline_terminated.txt000066400000000000000000000126541506127434000213220ustar00rootroot00000000000000@ ProgramNode (location: (3,0)-(41,0))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (3,0)-(41,0))
    ├── flags: ∅
    └── body: (length: 17)
        ├── @ StringNode (location: (3,0)-(3,6))
        │   ├── flags: newline
        │   ├── opening_loc: (3,0)-(3,2) = "% "
        │   ├── content_loc: (3,2)-(3,5) = "abc"
        │   ├── closing_loc: (3,5)-(3,6) = " "
        │   └── unescaped: "abc"
        ├── @ StringNode (location: (4,0)-(4,6))
        │   ├── flags: newline
        │   ├── opening_loc: (4,0)-(4,2) = "%\t"
        │   ├── content_loc: (4,2)-(4,5) = "abc"
        │   ├── closing_loc: (4,5)-(4,6) = "\t"
        │   └── unescaped: "abc"
        ├── @ StringNode (location: (5,0)-(5,6))
        │   ├── flags: newline
        │   ├── opening_loc: (5,0)-(5,2) = "%\v"
        │   ├── content_loc: (5,2)-(5,5) = "abc"
        │   ├── closing_loc: (5,5)-(5,6) = "\v"
        │   └── unescaped: "abc"
        ├── @ StringNode (location: (6,0)-(6,6))
        │   ├── flags: newline
        │   ├── opening_loc: (6,0)-(6,2) = "%\r"
        │   ├── content_loc: (6,2)-(6,5) = "abc"
        │   ├── closing_loc: (6,5)-(6,6) = "\r"
        │   └── unescaped: "abc"
        ├── @ StringNode (location: (7,0)-(9,0))
        │   ├── flags: newline
        │   ├── opening_loc: (7,0)-(8,0) = "%\n"
        │   ├── content_loc: (8,0)-(8,3) = "abc"
        │   ├── closing_loc: (8,3)-(9,0) = "\n"
        │   └── unescaped: "abc"
        ├── @ StringNode (location: (10,0)-(10,6))
        │   ├── flags: newline
        │   ├── opening_loc: (10,0)-(10,2) = "%\u0000"
        │   ├── content_loc: (10,2)-(10,5) = "abc"
        │   ├── closing_loc: (10,5)-(10,6) = "\u0000"
        │   └── unescaped: "abc"
        ├── @ StringNode (location: (11,0)-(13,0))
        │   ├── flags: newline
        │   ├── opening_loc: (11,0)-(12,0) = "%\n"
        │   ├── content_loc: (12,0)-(12,3) = "abc"
        │   ├── closing_loc: (12,3)-(13,0) = "\n"
        │   └── unescaped: "abc"
        ├── @ StringNode (location: (14,0)-(16,0))
        │   ├── flags: newline
        │   ├── opening_loc: (14,0)-(15,0) = "%\n"
        │   ├── content_loc: (15,0)-(15,4) = "\rabc"
        │   ├── closing_loc: (15,4)-(16,0) = "\n"
        │   └── unescaped: "\rabc"
        ├── @ StringNode (location: (17,0)-(19,0))
        │   ├── flags: newline
        │   ├── opening_loc: (17,0)-(18,0) = "%\n"
        │   ├── content_loc: (18,0)-(18,4) = "\rabc"
        │   ├── closing_loc: (18,4)-(19,0) = "\n"
        │   └── unescaped: "\rabc"
        ├── @ StringNode (location: (20,0)-(22,0))
        │   ├── flags: newline
        │   ├── opening_loc: (20,0)-(21,0) = "%\n"
        │   ├── content_loc: (21,0)-(21,3) = "abc"
        │   ├── closing_loc: (21,3)-(22,0) = "\n"
        │   └── unescaped: "abc"
        ├── @ StringNode (location: (23,0)-(23,6))
        │   ├── flags: newline
        │   ├── opening_loc: (23,0)-(23,2) = "%\r"
        │   ├── content_loc: (23,2)-(23,5) = "abc"
        │   ├── closing_loc: (23,5)-(23,6) = "\r"
        │   └── unescaped: "abc"
        ├── @ StringNode (location: (24,0)-(26,0))
        │   ├── flags: newline
        │   ├── opening_loc: (24,0)-(25,0) = "%\n"
        │   ├── content_loc: (25,0)-(25,3) = "abc"
        │   ├── closing_loc: (25,3)-(26,0) = "\n"
        │   └── unescaped: "abc"
        ├── @ StringNode (location: (27,0)-(29,0))
        │   ├── flags: newline
        │   ├── opening_loc: (27,0)-(28,0) = "%\n"
        │   ├── content_loc: (28,0)-(28,3) = "abc"
        │   ├── closing_loc: (28,3)-(29,0) = "\n"
        │   └── unescaped: "abc"
        ├── @ StringNode (location: (30,0)-(32,0))
        │   ├── flags: newline
        │   ├── opening_loc: (30,0)-(31,0) = "%\n"
        │   ├── content_loc: (31,0)-(31,3) = "foo"
        │   ├── closing_loc: (31,3)-(32,0) = "\n"
        │   └── unescaped: "foo"
        ├── @ StringNode (location: (33,0)-(35,0))
        │   ├── flags: newline
        │   ├── opening_loc: (33,0)-(34,0) = "%q\n"
        │   ├── content_loc: (34,0)-(34,3) = "foo"
        │   ├── closing_loc: (34,3)-(35,0) = "\n"
        │   └── unescaped: "foo"
        ├── @ StringNode (location: (36,0)-(38,0))
        │   ├── flags: newline
        │   ├── opening_loc: (36,0)-(37,0) = "%Q\n"
        │   ├── content_loc: (37,0)-(37,3) = "foo"
        │   ├── closing_loc: (37,3)-(38,0) = "\n"
        │   └── unescaped: "foo"
        └── @ RegularExpressionNode (location: (39,0)-(41,0))
            ├── flags: newline, static_literal, forced_us_ascii_encoding
            ├── opening_loc: (39,0)-(40,0) = "%r\n"
            ├── content_loc: (40,0)-(40,3) = "foo"
            ├── closing_loc: (40,3)-(41,0) = "\n"
            └── unescaped: "foo"
prism-1.5.1/snapshots/next.txt000066400000000000000000000673321506127434000164260ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(28,23))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(28,23))
    ├── flags: ∅
    └── body: (length: 12)
        ├── @ CallNode (location: (1,0)-(1,12))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (1,0)-(1,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,4)-(1,12))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (1,6)-(1,10))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ NextNode (location: (1,6)-(1,10))
        │       │           ├── flags: newline
        │       │           ├── arguments: ∅
        │       │           └── keyword_loc: (1,6)-(1,10) = "next"
        │       ├── opening_loc: (1,4)-(1,5) = "{"
        │       └── closing_loc: (1,11)-(1,12) = "}"
        ├── @ CallNode (location: (3,0)-(3,26))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (3,0)-(3,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (3,4)-(3,26))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (3,6)-(3,24))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ NextNode (location: (3,6)-(3,24))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (3,11)-(3,24))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 3)
        │       │           │       ├── @ ParenthesesNode (location: (3,11)-(3,14))
        │       │           │       │   ├── flags: ∅
        │       │           │       │   ├── body:
        │       │           │       │   │   @ StatementsNode (location: (3,12)-(3,13))
        │       │           │       │   │   ├── flags: ∅
        │       │           │       │   │   └── body: (length: 1)
        │       │           │       │   │       └── @ IntegerNode (location: (3,12)-(3,13))
        │       │           │       │   │           ├── flags: newline, static_literal, decimal
        │       │           │       │   │           └── value: 1
        │       │           │       │   ├── opening_loc: (3,11)-(3,12) = "("
        │       │           │       │   └── closing_loc: (3,13)-(3,14) = ")"
        │       │           │       ├── @ ParenthesesNode (location: (3,16)-(3,19))
        │       │           │       │   ├── flags: ∅
        │       │           │       │   ├── body:
        │       │           │       │   │   @ StatementsNode (location: (3,17)-(3,18))
        │       │           │       │   │   ├── flags: ∅
        │       │           │       │   │   └── body: (length: 1)
        │       │           │       │   │       └── @ IntegerNode (location: (3,17)-(3,18))
        │       │           │       │   │           ├── flags: newline, static_literal, decimal
        │       │           │       │   │           └── value: 2
        │       │           │       │   ├── opening_loc: (3,16)-(3,17) = "("
        │       │           │       │   └── closing_loc: (3,18)-(3,19) = ")"
        │       │           │       └── @ ParenthesesNode (location: (3,21)-(3,24))
        │       │           │           ├── flags: ∅
        │       │           │           ├── body:
        │       │           │           │   @ StatementsNode (location: (3,22)-(3,23))
        │       │           │           │   ├── flags: ∅
        │       │           │           │   └── body: (length: 1)
        │       │           │           │       └── @ IntegerNode (location: (3,22)-(3,23))
        │       │           │           │           ├── flags: newline, static_literal, decimal
        │       │           │           │           └── value: 3
        │       │           │           ├── opening_loc: (3,21)-(3,22) = "("
        │       │           │           └── closing_loc: (3,23)-(3,24) = ")"
        │       │           └── keyword_loc: (3,6)-(3,10) = "next"
        │       ├── opening_loc: (3,4)-(3,5) = "{"
        │       └── closing_loc: (3,25)-(3,26) = "}"
        ├── @ CallNode (location: (5,0)-(5,14))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (5,0)-(5,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (5,4)-(5,14))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (5,6)-(5,12))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ NextNode (location: (5,6)-(5,12))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (5,11)-(5,12))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ IntegerNode (location: (5,11)-(5,12))
        │       │           │           ├── flags: static_literal, decimal
        │       │           │           └── value: 1
        │       │           └── keyword_loc: (5,6)-(5,10) = "next"
        │       ├── opening_loc: (5,4)-(5,5) = "{"
        │       └── closing_loc: (5,13)-(5,14) = "}"
        ├── @ CallNode (location: (7,0)-(8,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (7,0)-(7,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (7,4)-(8,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (7,6)-(8,1))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ NextNode (location: (7,6)-(8,1))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (7,11)-(8,1))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 3)
        │       │           │       ├── @ IntegerNode (location: (7,11)-(7,12))
        │       │           │       │   ├── flags: static_literal, decimal
        │       │           │       │   └── value: 1
        │       │           │       ├── @ IntegerNode (location: (7,14)-(7,15))
        │       │           │       │   ├── flags: static_literal, decimal
        │       │           │       │   └── value: 2
        │       │           │       └── @ IntegerNode (location: (8,0)-(8,1))
        │       │           │           ├── flags: static_literal, decimal
        │       │           │           └── value: 3
        │       │           └── keyword_loc: (7,6)-(7,10) = "next"
        │       ├── opening_loc: (7,4)-(7,5) = "{"
        │       └── closing_loc: (8,2)-(8,3) = "}"
        ├── @ CallNode (location: (10,0)-(10,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (10,0)-(10,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (10,4)-(10,20))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (10,6)-(10,18))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ NextNode (location: (10,6)-(10,18))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (10,11)-(10,18))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 3)
        │       │           │       ├── @ IntegerNode (location: (10,11)-(10,12))
        │       │           │       │   ├── flags: static_literal, decimal
        │       │           │       │   └── value: 1
        │       │           │       ├── @ IntegerNode (location: (10,14)-(10,15))
        │       │           │       │   ├── flags: static_literal, decimal
        │       │           │       │   └── value: 2
        │       │           │       └── @ IntegerNode (location: (10,17)-(10,18))
        │       │           │           ├── flags: static_literal, decimal
        │       │           │           └── value: 3
        │       │           └── keyword_loc: (10,6)-(10,10) = "next"
        │       ├── opening_loc: (10,4)-(10,5) = "{"
        │       └── closing_loc: (10,19)-(10,20) = "}"
        ├── @ CallNode (location: (12,0)-(12,22))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (12,0)-(12,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (12,4)-(12,22))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (12,6)-(12,20))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ NextNode (location: (12,6)-(12,20))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (12,11)-(12,20))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ ArrayNode (location: (12,11)-(12,20))
        │       │           │           ├── flags: static_literal
        │       │           │           ├── elements: (length: 3)
        │       │           │           │   ├── @ IntegerNode (location: (12,12)-(12,13))
        │       │           │           │   │   ├── flags: static_literal, decimal
        │       │           │           │   │   └── value: 1
        │       │           │           │   ├── @ IntegerNode (location: (12,15)-(12,16))
        │       │           │           │   │   ├── flags: static_literal, decimal
        │       │           │           │   │   └── value: 2
        │       │           │           │   └── @ IntegerNode (location: (12,18)-(12,19))
        │       │           │           │       ├── flags: static_literal, decimal
        │       │           │           │       └── value: 3
        │       │           │           ├── opening_loc: (12,11)-(12,12) = "["
        │       │           │           └── closing_loc: (12,19)-(12,20) = "]"
        │       │           └── keyword_loc: (12,6)-(12,10) = "next"
        │       ├── opening_loc: (12,4)-(12,5) = "{"
        │       └── closing_loc: (12,21)-(12,22) = "}"
        ├── @ CallNode (location: (14,0)-(17,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (14,0)-(14,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (14,4)-(17,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (14,6)-(17,1))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ NextNode (location: (14,6)-(17,1))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (14,10)-(17,1))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ ParenthesesNode (location: (14,10)-(17,1))
        │       │           │           ├── flags: multiple_statements
        │       │           │           ├── body:
        │       │           │           │   @ StatementsNode (location: (15,2)-(16,3))
        │       │           │           │   ├── flags: ∅
        │       │           │           │   └── body: (length: 2)
        │       │           │           │       ├── @ IntegerNode (location: (15,2)-(15,3))
        │       │           │           │       │   ├── flags: newline, static_literal, decimal
        │       │           │           │       │   └── value: 1
        │       │           │           │       └── @ IntegerNode (location: (16,2)-(16,3))
        │       │           │           │           ├── flags: newline, static_literal, decimal
        │       │           │           │           └── value: 2
        │       │           │           ├── opening_loc: (14,10)-(14,11) = "("
        │       │           │           └── closing_loc: (17,0)-(17,1) = ")"
        │       │           └── keyword_loc: (14,6)-(14,10) = "next"
        │       ├── opening_loc: (14,4)-(14,5) = "{"
        │       └── closing_loc: (17,2)-(17,3) = "}"
        ├── @ CallNode (location: (19,0)-(20,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (19,0)-(19,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (19,4)-(20,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (19,6)-(20,1))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 2)
        │       │       ├── @ NextNode (location: (19,6)-(19,10))
        │       │       │   ├── flags: newline
        │       │       │   ├── arguments: ∅
        │       │       │   └── keyword_loc: (19,6)-(19,10) = "next"
        │       │       └── @ IntegerNode (location: (20,0)-(20,1))
        │       │           ├── flags: newline, static_literal, decimal
        │       │           └── value: 1
        │       ├── opening_loc: (19,4)-(19,5) = "{"
        │       └── closing_loc: (20,2)-(20,3) = "}"
        ├── @ CallNode (location: (22,0)-(22,14))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (22,0)-(22,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (22,4)-(22,14))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (22,6)-(22,12))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ NextNode (location: (22,6)-(22,12))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (22,10)-(22,12))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ ParenthesesNode (location: (22,10)-(22,12))
        │       │           │           ├── flags: ∅
        │       │           │           ├── body: ∅
        │       │           │           ├── opening_loc: (22,10)-(22,11) = "("
        │       │           │           └── closing_loc: (22,11)-(22,12) = ")"
        │       │           └── keyword_loc: (22,6)-(22,10) = "next"
        │       ├── opening_loc: (22,4)-(22,5) = "{"
        │       └── closing_loc: (22,13)-(22,14) = "}"
        ├── @ CallNode (location: (24,0)-(24,15))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (24,0)-(24,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (24,4)-(24,15))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (24,6)-(24,13))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ NextNode (location: (24,6)-(24,13))
        │       │           ├── flags: newline
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (24,10)-(24,13))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ ParenthesesNode (location: (24,10)-(24,13))
        │       │           │           ├── flags: ∅
        │       │           │           ├── body:
        │       │           │           │   @ StatementsNode (location: (24,11)-(24,12))
        │       │           │           │   ├── flags: ∅
        │       │           │           │   └── body: (length: 1)
        │       │           │           │       └── @ IntegerNode (location: (24,11)-(24,12))
        │       │           │           │           ├── flags: newline, static_literal, decimal
        │       │           │           │           └── value: 1
        │       │           │           ├── opening_loc: (24,10)-(24,11) = "("
        │       │           │           └── closing_loc: (24,12)-(24,13) = ")"
        │       │           └── keyword_loc: (24,6)-(24,10) = "next"
        │       ├── opening_loc: (24,4)-(24,5) = "{"
        │       └── closing_loc: (24,14)-(24,15) = "}"
        ├── @ CallNode (location: (26,0)-(26,16))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (26,0)-(26,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (26,4)-(26,16))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (26,6)-(26,14))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ ParenthesesNode (location: (26,6)-(26,14))
        │       │           ├── flags: newline
        │       │           ├── body:
        │       │           │   @ StatementsNode (location: (26,7)-(26,13))
        │       │           │   ├── flags: ∅
        │       │           │   └── body: (length: 1)
        │       │           │       └── @ NextNode (location: (26,7)-(26,13))
        │       │           │           ├── flags: newline
        │       │           │           ├── arguments:
        │       │           │           │   @ ArgumentsNode (location: (26,12)-(26,13))
        │       │           │           │   ├── flags: ∅
        │       │           │           │   └── arguments: (length: 1)
        │       │           │           │       └── @ IntegerNode (location: (26,12)-(26,13))
        │       │           │           │           ├── flags: static_literal, decimal
        │       │           │           │           └── value: 1
        │       │           │           └── keyword_loc: (26,7)-(26,11) = "next"
        │       │           ├── opening_loc: (26,6)-(26,7) = "("
        │       │           └── closing_loc: (26,13)-(26,14) = ")"
        │       ├── opening_loc: (26,4)-(26,5) = "{"
        │       └── closing_loc: (26,15)-(26,16) = "}"
        └── @ CallNode (location: (28,0)-(28,23))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :tap
            ├── message_loc: (28,0)-(28,3) = "tap"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (28,4)-(28,23))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body:
                │   @ StatementsNode (location: (28,6)-(28,21))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ AndNode (location: (28,6)-(28,21))
                │           ├── flags: newline
                │           ├── left:
                │           │   @ CallNode (location: (28,6)-(28,9))
                │           │   ├── flags: variable_call, ignore_visibility
                │           │   ├── receiver: ∅
                │           │   ├── call_operator_loc: ∅
                │           │   ├── name: :foo
                │           │   ├── message_loc: (28,6)-(28,9) = "foo"
                │           │   ├── opening_loc: ∅
                │           │   ├── arguments: ∅
                │           │   ├── closing_loc: ∅
                │           │   └── block: ∅
                │           ├── right:
                │           │   @ ParenthesesNode (location: (28,13)-(28,21))
                │           │   ├── flags: ∅
                │           │   ├── body:
                │           │   │   @ StatementsNode (location: (28,14)-(28,20))
                │           │   │   ├── flags: ∅
                │           │   │   └── body: (length: 1)
                │           │   │       └── @ NextNode (location: (28,14)-(28,20))
                │           │   │           ├── flags: newline
                │           │   │           ├── arguments:
                │           │   │           │   @ ArgumentsNode (location: (28,19)-(28,20))
                │           │   │           │   ├── flags: ∅
                │           │   │           │   └── arguments: (length: 1)
                │           │   │           │       └── @ IntegerNode (location: (28,19)-(28,20))
                │           │   │           │           ├── flags: static_literal, decimal
                │           │   │           │           └── value: 1
                │           │   │           └── keyword_loc: (28,14)-(28,18) = "next"
                │           │   ├── opening_loc: (28,13)-(28,14) = "("
                │           │   └── closing_loc: (28,20)-(28,21) = ")"
                │           └── operator_loc: (28,10)-(28,12) = "&&"
                ├── opening_loc: (28,4)-(28,5) = "{"
                └── closing_loc: (28,22)-(28,23) = "}"
prism-1.5.1/snapshots/nils.txt000066400000000000000000000041221506127434000164010ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(12,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(12,11))
    ├── flags: ∅
    └── body: (length: 5)
        ├── @ NilNode (location: (1,0)-(1,3))
        │   └── flags: newline, static_literal
        ├── @ ParenthesesNode (location: (3,0)-(3,2))
        │   ├── flags: newline
        │   ├── body: ∅
        │   ├── opening_loc: (3,0)-(3,1) = "("
        │   └── closing_loc: (3,1)-(3,2) = ")"
        ├── @ ParenthesesNode (location: (5,0)-(8,1))
        │   ├── flags: newline, multiple_statements
        │   ├── body: ∅
        │   ├── opening_loc: (5,0)-(5,1) = "("
        │   └── closing_loc: (8,0)-(8,1) = ")"
        ├── @ PostExecutionNode (location: (10,0)-(10,9))
        │   ├── flags: newline
        │   ├── statements:
        │   │   @ StatementsNode (location: (10,6)-(10,7))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (10,6)-(10,7))
        │   │           ├── flags: newline, static_literal, decimal
        │   │           └── value: 1
        │   ├── keyword_loc: (10,0)-(10,3) = "END"
        │   ├── opening_loc: (10,4)-(10,5) = "{"
        │   └── closing_loc: (10,8)-(10,9) = "}"
        └── @ PreExecutionNode (location: (12,0)-(12,11))
            ├── flags: newline
            ├── statements:
            │   @ StatementsNode (location: (12,8)-(12,9))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ IntegerNode (location: (12,8)-(12,9))
            │           ├── flags: newline, static_literal, decimal
            │           └── value: 1
            ├── keyword_loc: (12,0)-(12,5) = "BEGIN"
            ├── opening_loc: (12,6)-(12,7) = "{"
            └── closing_loc: (12,10)-(12,11) = "}"
prism-1.5.1/snapshots/non_alphanumeric_methods.txt000066400000000000000000000573071506127434000225160ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(105,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(105,3))
    ├── flags: ∅
    └── body: (length: 36)
        ├── @ DefNode (location: (1,0)-(2,3))
        │   ├── flags: newline
        │   ├── name: :!
        │   ├── name_loc: (1,4)-(1,5) = "!"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (2,0)-(2,3) = "end"
        ├── @ DefNode (location: (4,0)-(5,3))
        │   ├── flags: newline
        │   ├── name: :!=
        │   ├── name_loc: (4,4)-(4,6) = "!="
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (4,0)-(4,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (5,0)-(5,3) = "end"
        ├── @ DefNode (location: (7,0)-(8,3))
        │   ├── flags: newline
        │   ├── name: :!~
        │   ├── name_loc: (7,4)-(7,6) = "!~"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (7,0)-(7,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (8,0)-(8,3) = "end"
        ├── @ DefNode (location: (10,0)-(11,3))
        │   ├── flags: newline
        │   ├── name: :%
        │   ├── name_loc: (10,4)-(10,5) = "%"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (10,0)-(10,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (11,0)-(11,3) = "end"
        ├── @ DefNode (location: (13,0)-(14,3))
        │   ├── flags: newline
        │   ├── name: :+
        │   ├── name_loc: (13,9)-(13,10) = "+"
        │   ├── receiver:
        │   │   @ SelfNode (location: (13,4)-(13,8))
        │   │   └── flags: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (13,0)-(13,3) = "def"
        │   ├── operator_loc: (13,8)-(13,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (14,0)-(14,3) = "end"
        ├── @ DefNode (location: (16,0)-(17,3))
        │   ├── flags: newline
        │   ├── name: :&
        │   ├── name_loc: (16,4)-(16,5) = "&"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (16,0)-(16,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (17,0)-(17,3) = "end"
        ├── @ DefNode (location: (19,0)-(20,3))
        │   ├── flags: newline
        │   ├── name: :*
        │   ├── name_loc: (19,4)-(19,5) = "*"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (19,0)-(19,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (20,0)-(20,3) = "end"
        ├── @ DefNode (location: (22,0)-(23,3))
        │   ├── flags: newline
        │   ├── name: :**
        │   ├── name_loc: (22,4)-(22,6) = "**"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (22,0)-(22,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (23,0)-(23,3) = "end"
        ├── @ StringNode (location: (25,0)-(25,6))
        │   ├── flags: newline
        │   ├── opening_loc: (25,0)-(25,2) = "%|"
        │   ├── content_loc: (25,2)-(25,5) = "abc"
        │   ├── closing_loc: (25,5)-(25,6) = "|"
        │   └── unescaped: "abc"
        ├── @ DefNode (location: (27,0)-(28,3))
        │   ├── flags: newline
        │   ├── name: :+
        │   ├── name_loc: (27,4)-(27,5) = "+"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (27,6)-(27,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ KeywordRestParameterNode (location: (27,6)-(27,9))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :b
        │   │   │   ├── name_loc: (27,8)-(27,9) = "b"
        │   │   │   └── operator_loc: (27,6)-(27,8) = "**"
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (27,0)-(27,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (28,0)-(28,3) = "end"
        ├── @ DefNode (location: (30,0)-(31,3))
        │   ├── flags: newline
        │   ├── name: :+
        │   ├── name_loc: (30,4)-(30,5) = "+"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (30,0)-(30,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (30,5)-(30,6) = "("
        │   ├── rparen_loc: (30,6)-(30,7) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (31,0)-(31,3) = "end"
        ├── @ DefNode (location: (33,0)-(34,3))
        │   ├── flags: newline
        │   ├── name: :+
        │   ├── name_loc: (33,4)-(33,5) = "+"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (33,6)-(33,7))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (33,6)-(33,7))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :b
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (33,0)-(33,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (34,0)-(34,3) = "end"
        ├── @ DefNode (location: (36,0)-(37,3))
        │   ├── flags: newline
        │   ├── name: :+
        │   ├── name_loc: (36,9)-(36,10) = "+"
        │   ├── receiver:
        │   │   @ SelfNode (location: (36,4)-(36,8))
        │   │   └── flags: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (36,0)-(36,3) = "def"
        │   ├── operator_loc: (36,8)-(36,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (37,0)-(37,3) = "end"
        ├── @ DefNode (location: (39,0)-(40,3))
        │   ├── flags: newline
        │   ├── name: :+
        │   ├── name_loc: (39,4)-(39,5) = "+"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (39,0)-(39,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (40,0)-(40,3) = "end"
        ├── @ DefNode (location: (42,0)-(43,3))
        │   ├── flags: newline
        │   ├── name: :+@
        │   ├── name_loc: (42,4)-(42,6) = "+@"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (42,0)-(42,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (43,0)-(43,3) = "end"
        ├── @ DefNode (location: (45,0)-(46,3))
        │   ├── flags: newline
        │   ├── name: :-
        │   ├── name_loc: (45,4)-(45,5) = "-"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (45,0)-(45,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (46,0)-(46,3) = "end"
        ├── @ DefNode (location: (48,0)-(48,11))
        │   ├── flags: newline
        │   ├── name: :-
        │   ├── name_loc: (48,6)-(48,7) = "-"
        │   ├── receiver:
        │   │   @ CallNode (location: (48,4)-(48,5))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (48,4)-(48,5) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (48,0)-(48,3) = "def"
        │   ├── operator_loc: (48,5)-(48,6) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (48,8)-(48,11) = "end"
        ├── @ DefNode (location: (50,0)-(51,3))
        │   ├── flags: newline
        │   ├── name: :-@
        │   ├── name_loc: (50,4)-(50,6) = "-@"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (50,0)-(50,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (51,0)-(51,3) = "end"
        ├── @ DefNode (location: (53,0)-(54,3))
        │   ├── flags: newline
        │   ├── name: :/
        │   ├── name_loc: (53,4)-(53,5) = "/"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (53,0)-(53,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (54,0)-(54,3) = "end"
        ├── @ DefNode (location: (56,0)-(57,3))
        │   ├── flags: newline
        │   ├── name: :<
        │   ├── name_loc: (56,4)-(56,5) = "<"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (56,0)-(56,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (57,0)-(57,3) = "end"
        ├── @ DefNode (location: (59,0)-(60,3))
        │   ├── flags: newline
        │   ├── name: :<<
        │   ├── name_loc: (59,4)-(59,6) = "<<"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (59,0)-(59,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (60,0)-(60,3) = "end"
        ├── @ DefNode (location: (62,0)-(63,3))
        │   ├── flags: newline
        │   ├── name: :<=
        │   ├── name_loc: (62,4)-(62,6) = "<="
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (62,0)-(62,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (63,0)-(63,3) = "end"
        ├── @ DefNode (location: (65,0)-(66,3))
        │   ├── flags: newline
        │   ├── name: :<=>
        │   ├── name_loc: (65,4)-(65,7) = "<=>"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (65,0)-(65,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (66,0)-(66,3) = "end"
        ├── @ DefNode (location: (68,0)-(69,3))
        │   ├── flags: newline
        │   ├── name: :==
        │   ├── name_loc: (68,4)-(68,6) = "=="
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (68,0)-(68,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (69,0)-(69,3) = "end"
        ├── @ DefNode (location: (71,0)-(72,3))
        │   ├── flags: newline
        │   ├── name: :===
        │   ├── name_loc: (71,4)-(71,7) = "==="
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (71,0)-(71,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (72,0)-(72,3) = "end"
        ├── @ DefNode (location: (74,0)-(75,3))
        │   ├── flags: newline
        │   ├── name: :=~
        │   ├── name_loc: (74,4)-(74,6) = "=~"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (74,0)-(74,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (75,0)-(75,3) = "end"
        ├── @ DefNode (location: (77,0)-(78,3))
        │   ├── flags: newline
        │   ├── name: :>
        │   ├── name_loc: (77,4)-(77,5) = ">"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (77,0)-(77,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (78,0)-(78,3) = "end"
        ├── @ DefNode (location: (80,0)-(81,3))
        │   ├── flags: newline
        │   ├── name: :>=
        │   ├── name_loc: (80,4)-(80,6) = ">="
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (80,0)-(80,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (81,0)-(81,3) = "end"
        ├── @ DefNode (location: (83,0)-(84,3))
        │   ├── flags: newline
        │   ├── name: :>>
        │   ├── name_loc: (83,4)-(83,6) = ">>"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (83,0)-(83,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (84,0)-(84,3) = "end"
        ├── @ DefNode (location: (86,0)-(87,3))
        │   ├── flags: newline
        │   ├── name: :[]
        │   ├── name_loc: (86,4)-(86,6) = "[]"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (86,0)-(86,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (87,0)-(87,3) = "end"
        ├── @ DefNode (location: (89,0)-(90,3))
        │   ├── flags: newline
        │   ├── name: :[]=
        │   ├── name_loc: (89,4)-(89,7) = "[]="
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (89,0)-(89,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (90,0)-(90,3) = "end"
        ├── @ DefNode (location: (92,0)-(93,3))
        │   ├── flags: newline
        │   ├── name: :^
        │   ├── name_loc: (92,4)-(92,5) = "^"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (92,0)-(92,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (93,0)-(93,3) = "end"
        ├── @ DefNode (location: (95,0)-(96,3))
        │   ├── flags: newline
        │   ├── name: :`
        │   ├── name_loc: (95,4)-(95,5) = "`"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (95,0)-(95,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (96,0)-(96,3) = "end"
        ├── @ DefNode (location: (98,0)-(99,3))
        │   ├── flags: newline
        │   ├── name: :`
        │   ├── name_loc: (98,9)-(98,10) = "`"
        │   ├── receiver:
        │   │   @ SelfNode (location: (98,4)-(98,8))
        │   │   └── flags: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (98,0)-(98,3) = "def"
        │   ├── operator_loc: (98,8)-(98,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (99,0)-(99,3) = "end"
        ├── @ DefNode (location: (101,0)-(102,3))
        │   ├── flags: newline
        │   ├── name: :|
        │   ├── name_loc: (101,4)-(101,5) = "|"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (101,0)-(101,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (102,0)-(102,3) = "end"
        └── @ DefNode (location: (104,0)-(105,3))
            ├── flags: newline
            ├── name: :~
            ├── name_loc: (104,4)-(104,5) = "~"
            ├── receiver: ∅
            ├── parameters: ∅
            ├── body: ∅
            ├── locals: []
            ├── def_keyword_loc: (104,0)-(104,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (105,0)-(105,3) = "end"
prism-1.5.1/snapshots/not.txt000066400000000000000000000437551506127434000162530ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(37,16))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(37,16))
    ├── flags: ∅
    └── body: (length: 10)
        ├── @ AndNode (location: (1,0)-(1,19))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ CallNode (location: (1,0)-(1,7))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (1,4)-(1,7))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (1,4)-(1,7) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (1,0)-(1,3) = "not"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── right:
        │   │   @ CallNode (location: (1,12)-(1,19))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (1,16)-(1,19))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :bar
        │   │   │   ├── message_loc: (1,16)-(1,19) = "bar"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (1,12)-(1,15) = "not"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (1,8)-(1,11) = "and"
        ├── @ CallNode (location: (3,0)-(3,16))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ AndNode (location: (3,4)-(3,15))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ CallNode (location: (3,4)-(3,7))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (3,4)-(3,7) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── right:
        │   │   │   @ CallNode (location: (3,12)-(3,15))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :bar
        │   │   │   ├── message_loc: (3,12)-(3,15) = "bar"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── operator_loc: (3,8)-(3,11) = "and"
        │   ├── call_operator_loc: ∅
        │   ├── name: :!
        │   ├── message_loc: (3,0)-(3,3) = "not"
        │   ├── opening_loc: (3,3)-(3,4) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (3,15)-(3,16) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (5,0)-(5,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (5,4)-(5,7))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (5,4)-(5,7) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :!
        │   ├── message_loc: (5,0)-(5,3) = "not"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ AndNode (location: (7,0)-(8,5))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ CallNode (location: (7,0)-(7,7))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (7,4)-(7,7))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (7,4)-(7,7) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (7,0)-(7,3) = "not"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── right:
        │   │   @ CallNode (location: (7,12)-(8,5))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (8,2)-(8,5))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :bar
        │   │   │   ├── message_loc: (8,2)-(8,5) = "bar"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (7,12)-(7,15) = "not"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (7,8)-(7,11) = "and"
        ├── @ AndNode (location: (11,0)-(13,5))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ CallNode (location: (11,0)-(11,7))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (11,4)-(11,7))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (11,4)-(11,7) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (11,0)-(11,3) = "not"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── right:
        │   │   @ CallNode (location: (12,4)-(13,5))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (13,2)-(13,5))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :bar
        │   │   │   ├── message_loc: (13,2)-(13,5) = "bar"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (12,4)-(12,7) = "not"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (11,8)-(11,11) = "and"
        ├── @ AndNode (location: (16,0)-(20,5))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ CallNode (location: (16,0)-(16,7))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (16,4)-(16,7))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (16,4)-(16,7) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (16,0)-(16,3) = "not"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── right:
        │   │   @ CallNode (location: (17,2)-(20,5))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (20,2)-(20,5))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :bar
        │   │   │   ├── message_loc: (20,2)-(20,5) = "bar"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (17,2)-(17,5) = "not"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (16,8)-(16,11) = "and"
        ├── @ CallNode (location: (22,0)-(25,1))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (22,4)-(22,7))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (22,4)-(22,7) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :!
        │   ├── message_loc: (22,0)-(22,3) = "not"
        │   ├── opening_loc: (22,3)-(22,4) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (25,0)-(25,1) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (27,0)-(33,3))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (30,0)-(30,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (30,0)-(30,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :!
        │   ├── message_loc: (27,0)-(27,3) = "not"
        │   ├── opening_loc: (27,3)-(27,4) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (33,2)-(33,3) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (35,0)-(35,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ FlipFlopNode (location: (35,4)-(35,14))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ CallNode (location: (35,4)-(35,7))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (35,4)-(35,7) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── right:
        │   │   │   @ CallNode (location: (35,11)-(35,14))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :bar
        │   │   │   ├── message_loc: (35,11)-(35,14) = "bar"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── operator_loc: (35,8)-(35,10) = ".."
        │   ├── call_operator_loc: ∅
        │   ├── name: :!
        │   ├── message_loc: (35,0)-(35,3) = "not"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (37,0)-(37,16))
            ├── flags: newline
            ├── receiver:
            │   @ ParenthesesNode (location: (37,4)-(37,16))
            │   ├── flags: ∅
            │   ├── body:
            │   │   @ StatementsNode (location: (37,5)-(37,15))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ FlipFlopNode (location: (37,5)-(37,15))
            │   │           ├── flags: newline
            │   │           ├── left:
            │   │           │   @ CallNode (location: (37,5)-(37,8))
            │   │           │   ├── flags: variable_call, ignore_visibility
            │   │           │   ├── receiver: ∅
            │   │           │   ├── call_operator_loc: ∅
            │   │           │   ├── name: :foo
            │   │           │   ├── message_loc: (37,5)-(37,8) = "foo"
            │   │           │   ├── opening_loc: ∅
            │   │           │   ├── arguments: ∅
            │   │           │   ├── closing_loc: ∅
            │   │           │   └── block: ∅
            │   │           ├── right:
            │   │           │   @ CallNode (location: (37,12)-(37,15))
            │   │           │   ├── flags: variable_call, ignore_visibility
            │   │           │   ├── receiver: ∅
            │   │           │   ├── call_operator_loc: ∅
            │   │           │   ├── name: :bar
            │   │           │   ├── message_loc: (37,12)-(37,15) = "bar"
            │   │           │   ├── opening_loc: ∅
            │   │           │   ├── arguments: ∅
            │   │           │   ├── closing_loc: ∅
            │   │           │   └── block: ∅
            │   │           └── operator_loc: (37,9)-(37,11) = ".."
            │   ├── opening_loc: (37,4)-(37,5) = "("
            │   └── closing_loc: (37,15)-(37,16) = ")"
            ├── call_operator_loc: ∅
            ├── name: :!
            ├── message_loc: (37,0)-(37,3) = "not"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/numbers.txt000066400000000000000000000161471506127434000171210ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(67,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(67,5))
    ├── flags: ∅
    └── body: (length: 34)
        ├── @ IntegerNode (location: (1,0)-(1,1))
        │   ├── flags: newline, static_literal, decimal
        │   └── value: 0
        ├── @ IntegerNode (location: (3,0)-(3,1))
        │   ├── flags: newline, static_literal, decimal
        │   └── value: 1
        ├── @ FloatNode (location: (5,0)-(5,3))
        │   ├── flags: newline, static_literal
        │   └── value: 1.0
        ├── @ IntegerNode (location: (7,0)-(7,1))
        │   ├── flags: newline, static_literal, decimal
        │   └── value: 2
        ├── @ IntegerNode (location: (9,0)-(9,3))
        │   ├── flags: newline, static_literal, binary
        │   └── value: 0
        ├── @ IntegerNode (location: (11,0)-(11,3))
        │   ├── flags: newline, static_literal, binary
        │   └── value: 1
        ├── @ IntegerNode (location: (13,0)-(13,4))
        │   ├── flags: newline, static_literal, binary
        │   └── value: 2
        ├── @ IntegerNode (location: (15,0)-(15,3))
        │   ├── flags: newline, static_literal, decimal
        │   └── value: 0
        ├── @ IntegerNode (location: (17,0)-(17,3))
        │   ├── flags: newline, static_literal, decimal
        │   └── value: 1
        ├── @ IntegerNode (location: (19,0)-(19,3))
        │   ├── flags: newline, static_literal, decimal
        │   └── value: 2
        ├── @ IntegerNode (location: (21,0)-(21,2))
        │   ├── flags: newline, static_literal, octal
        │   └── value: 0
        ├── @ IntegerNode (location: (23,0)-(23,2))
        │   ├── flags: newline, static_literal, octal
        │   └── value: 1
        ├── @ IntegerNode (location: (25,0)-(25,2))
        │   ├── flags: newline, static_literal, octal
        │   └── value: 2
        ├── @ IntegerNode (location: (27,0)-(27,3))
        │   ├── flags: newline, static_literal, octal
        │   └── value: 0
        ├── @ IntegerNode (location: (29,0)-(29,3))
        │   ├── flags: newline, static_literal, octal
        │   └── value: 1
        ├── @ IntegerNode (location: (31,0)-(31,3))
        │   ├── flags: newline, static_literal, octal
        │   └── value: 2
        ├── @ IntegerNode (location: (33,0)-(33,3))
        │   ├── flags: newline, static_literal, hexadecimal
        │   └── value: 0
        ├── @ IntegerNode (location: (35,0)-(35,3))
        │   ├── flags: newline, static_literal, hexadecimal
        │   └── value: 1
        ├── @ IntegerNode (location: (37,0)-(37,3))
        │   ├── flags: newline, static_literal, hexadecimal
        │   └── value: 2
        ├── @ ImaginaryNode (location: (39,0)-(39,2))
        │   ├── flags: newline, static_literal
        │   └── numeric:
        │       @ IntegerNode (location: (39,0)-(39,1))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ RationalNode (location: (41,0)-(41,2))
        │   ├── flags: newline, static_literal, decimal
        │   ├── numerator: 1
        │   └── denominator: 1
        ├── @ IntegerNode (location: (43,0)-(43,2))
        │   ├── flags: newline, static_literal, decimal
        │   └── value: -1
        ├── @ ImaginaryNode (location: (45,0)-(45,3))
        │   ├── flags: newline, static_literal
        │   └── numeric:
        │       @ RationalNode (location: (45,0)-(45,2))
        │       ├── flags: static_literal, decimal
        │       ├── numerator: 1
        │       └── denominator: 1
        ├── @ RationalNode (location: (47,0)-(47,4))
        │   ├── flags: newline, static_literal, decimal
        │   ├── numerator: 6
        │   └── denominator: 5
        ├── @ ImaginaryNode (location: (49,0)-(49,5))
        │   ├── flags: newline, static_literal
        │   └── numeric:
        │       @ RationalNode (location: (49,0)-(49,4))
        │       ├── flags: static_literal, decimal
        │       ├── numerator: 6
        │       └── denominator: 5
        ├── @ ImaginaryNode (location: (51,0)-(51,4))
        │   ├── flags: newline, static_literal
        │   └── numeric:
        │       @ RationalNode (location: (51,0)-(51,3))
        │       ├── flags: static_literal, decimal
        │       ├── numerator: -1
        │       └── denominator: 1
        ├── @ RationalNode (location: (53,0)-(53,5))
        │   ├── flags: newline, static_literal, decimal
        │   ├── numerator: -6
        │   └── denominator: 5
        ├── @ ImaginaryNode (location: (55,0)-(55,6))
        │   ├── flags: newline, static_literal
        │   └── numeric:
        │       @ RationalNode (location: (55,0)-(55,5))
        │       ├── flags: static_literal, decimal
        │       ├── numerator: -6
        │       └── denominator: 5
        ├── @ RationalNode (location: (57,0)-(57,4))
        │   ├── flags: newline, static_literal, octal
        │   ├── numerator: 1
        │   └── denominator: 1
        ├── @ ImaginaryNode (location: (59,0)-(59,4))
        │   ├── flags: newline, static_literal
        │   └── numeric:
        │       @ IntegerNode (location: (59,0)-(59,3))
        │       ├── flags: static_literal, octal
        │       └── value: 1
        ├── @ ImaginaryNode (location: (61,0)-(61,5))
        │   ├── flags: newline, static_literal
        │   └── numeric:
        │       @ RationalNode (location: (61,0)-(61,4))
        │       ├── flags: static_literal, octal
        │       ├── numerator: 1
        │       └── denominator: 1
        ├── @ RationalNode (location: (63,0)-(63,4))
        │   ├── flags: newline, static_literal, decimal
        │   ├── numerator: 1
        │   └── denominator: 1
        ├── @ ImaginaryNode (location: (65,0)-(65,4))
        │   ├── flags: newline, static_literal
        │   └── numeric:
        │       @ IntegerNode (location: (65,0)-(65,3))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        └── @ ImaginaryNode (location: (67,0)-(67,5))
            ├── flags: newline, static_literal
            └── numeric:
                @ RationalNode (location: (67,0)-(67,4))
                ├── flags: static_literal, binary
                ├── numerator: 1
                └── denominator: 1
prism-1.5.1/snapshots/patterns.txt000066400000000000000000012062321506127434000173030ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(224,14))
├── flags: ∅
├── locals: [:bar, :baz, :qux, :b, :a, :foo, :x, :_a]
└── statements:
    @ StatementsNode (location: (1,0)-(224,14))
    ├── flags: ∅
    └── body: (length: 190)
        ├── @ MatchRequiredNode (location: (1,0)-(1,10))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ LocalVariableTargetNode (location: (1,7)-(1,10))
        │   │   ├── flags: ∅
        │   │   ├── name: :bar
        │   │   └── depth: 0
        │   └── operator_loc: (1,4)-(1,6) = "=>"
        ├── @ MatchRequiredNode (location: (2,0)-(2,8))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (2,0)-(2,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (2,0)-(2,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ IntegerNode (location: (2,7)-(2,8))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (2,4)-(2,6) = "=>"
        ├── @ MatchRequiredNode (location: (3,0)-(3,10))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FloatNode (location: (3,7)-(3,10))
        │   │   ├── flags: static_literal
        │   │   └── value: 1.0
        │   └── operator_loc: (3,4)-(3,6) = "=>"
        ├── @ MatchRequiredNode (location: (4,0)-(4,9))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (4,0)-(4,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (4,0)-(4,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ImaginaryNode (location: (4,7)-(4,9))
        │   │   ├── flags: static_literal
        │   │   └── numeric:
        │   │       @ IntegerNode (location: (4,7)-(4,8))
        │   │       ├── flags: static_literal, decimal
        │   │       └── value: 1
        │   └── operator_loc: (4,4)-(4,6) = "=>"
        ├── @ MatchRequiredNode (location: (5,0)-(5,9))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (5,0)-(5,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (5,0)-(5,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RationalNode (location: (5,7)-(5,9))
        │   │   ├── flags: static_literal, decimal
        │   │   ├── numerator: 1
        │   │   └── denominator: 1
        │   └── operator_loc: (5,4)-(5,6) = "=>"
        ├── @ MatchRequiredNode (location: (6,0)-(6,11))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (6,0)-(6,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (6,0)-(6,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SymbolNode (location: (6,7)-(6,11))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (6,7)-(6,8) = ":"
        │   │   ├── value_loc: (6,8)-(6,11) = "foo"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (6,4)-(6,6) = "=>"
        ├── @ MatchRequiredNode (location: (7,0)-(7,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (7,0)-(7,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (7,0)-(7,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SymbolNode (location: (7,7)-(7,14))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (7,7)-(7,10) = "%s["
        │   │   ├── value_loc: (7,10)-(7,13) = "foo"
        │   │   ├── closing_loc: (7,13)-(7,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (7,4)-(7,6) = "=>"
        ├── @ MatchRequiredNode (location: (8,0)-(8,13))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (8,0)-(8,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (8,0)-(8,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SymbolNode (location: (8,7)-(8,13))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (8,7)-(8,9) = ":\""
        │   │   ├── value_loc: (8,9)-(8,12) = "foo"
        │   │   ├── closing_loc: (8,12)-(8,13) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (8,4)-(8,6) = "=>"
        ├── @ MatchRequiredNode (location: (9,0)-(9,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (9,0)-(9,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (9,0)-(9,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RegularExpressionNode (location: (9,7)-(9,12))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (9,7)-(9,8) = "/"
        │   │   ├── content_loc: (9,8)-(9,11) = "foo"
        │   │   ├── closing_loc: (9,11)-(9,12) = "/"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (9,4)-(9,6) = "=>"
        ├── @ MatchRequiredNode (location: (10,0)-(10,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (10,0)-(10,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (10,0)-(10,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ XStringNode (location: (10,7)-(10,12))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (10,7)-(10,8) = "`"
        │   │   ├── content_loc: (10,8)-(10,11) = "foo"
        │   │   ├── closing_loc: (10,11)-(10,12) = "`"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (10,4)-(10,6) = "=>"
        ├── @ MatchRequiredNode (location: (11,0)-(11,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (11,0)-(11,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (11,0)-(11,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ XStringNode (location: (11,7)-(11,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (11,7)-(11,10) = "%x["
        │   │   ├── content_loc: (11,10)-(11,13) = "foo"
        │   │   ├── closing_loc: (11,13)-(11,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (11,4)-(11,6) = "=>"
        ├── @ MatchRequiredNode (location: (12,0)-(12,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (12,0)-(12,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (12,0)-(12,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (12,7)-(12,14))
        │   │   ├── flags: static_literal
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (12,10)-(12,13))
        │   │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (12,10)-(12,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (12,7)-(12,10) = "%i["
        │   │   └── closing_loc: (12,13)-(12,14) = "]"
        │   └── operator_loc: (12,4)-(12,6) = "=>"
        ├── @ MatchRequiredNode (location: (13,0)-(13,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (13,0)-(13,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (13,0)-(13,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (13,7)-(13,14))
        │   │   ├── flags: static_literal
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (13,10)-(13,13))
        │   │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (13,10)-(13,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (13,7)-(13,10) = "%I["
        │   │   └── closing_loc: (13,13)-(13,14) = "]"
        │   └── operator_loc: (13,4)-(13,6) = "=>"
        ├── @ MatchRequiredNode (location: (14,0)-(14,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (14,0)-(14,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (14,0)-(14,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (14,7)-(14,14))
        │   │   ├── flags: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (14,10)-(14,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (14,10)-(14,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (14,7)-(14,10) = "%w["
        │   │   └── closing_loc: (14,13)-(14,14) = "]"
        │   └── operator_loc: (14,4)-(14,6) = "=>"
        ├── @ MatchRequiredNode (location: (15,0)-(15,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (15,0)-(15,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (15,0)-(15,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (15,7)-(15,14))
        │   │   ├── flags: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (15,10)-(15,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (15,10)-(15,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (15,7)-(15,10) = "%W["
        │   │   └── closing_loc: (15,13)-(15,14) = "]"
        │   └── operator_loc: (15,4)-(15,6) = "=>"
        ├── @ MatchRequiredNode (location: (16,0)-(16,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (16,0)-(16,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (16,0)-(16,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ StringNode (location: (16,7)-(16,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (16,7)-(16,10) = "%q["
        │   │   ├── content_loc: (16,10)-(16,13) = "foo"
        │   │   ├── closing_loc: (16,13)-(16,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (16,4)-(16,6) = "=>"
        ├── @ MatchRequiredNode (location: (17,0)-(17,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (17,0)-(17,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (17,0)-(17,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ StringNode (location: (17,7)-(17,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (17,7)-(17,10) = "%Q["
        │   │   ├── content_loc: (17,10)-(17,13) = "foo"
        │   │   ├── closing_loc: (17,13)-(17,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (17,4)-(17,6) = "=>"
        ├── @ MatchRequiredNode (location: (18,0)-(18,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (18,0)-(18,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (18,0)-(18,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ StringNode (location: (18,7)-(18,12))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (18,7)-(18,8) = "\""
        │   │   ├── content_loc: (18,8)-(18,11) = "foo"
        │   │   ├── closing_loc: (18,11)-(18,12) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (18,4)-(18,6) = "=>"
        ├── @ MatchRequiredNode (location: (19,0)-(19,10))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (19,0)-(19,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (19,0)-(19,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ NilNode (location: (19,7)-(19,10))
        │   │   └── flags: static_literal
        │   └── operator_loc: (19,4)-(19,6) = "=>"
        ├── @ MatchRequiredNode (location: (20,0)-(20,11))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (20,0)-(20,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (20,0)-(20,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SelfNode (location: (20,7)-(20,11))
        │   │   └── flags: ∅
        │   └── operator_loc: (20,4)-(20,6) = "=>"
        ├── @ MatchRequiredNode (location: (21,0)-(21,11))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (21,0)-(21,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (21,0)-(21,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ TrueNode (location: (21,7)-(21,11))
        │   │   └── flags: static_literal
        │   └── operator_loc: (21,4)-(21,6) = "=>"
        ├── @ MatchRequiredNode (location: (22,0)-(22,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (22,0)-(22,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (22,0)-(22,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FalseNode (location: (22,7)-(22,12))
        │   │   └── flags: static_literal
        │   └── operator_loc: (22,4)-(22,6) = "=>"
        ├── @ MatchRequiredNode (location: (23,0)-(23,15))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (23,0)-(23,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (23,0)-(23,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SourceFileNode (location: (23,7)-(23,15))
        │   │   ├── flags: ∅
        │   │   └── filepath: "patterns.txt"
        │   └── operator_loc: (23,4)-(23,6) = "=>"
        ├── @ MatchRequiredNode (location: (24,0)-(24,15))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (24,0)-(24,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (24,0)-(24,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SourceLineNode (location: (24,7)-(24,15))
        │   │   └── flags: static_literal
        │   └── operator_loc: (24,4)-(24,6) = "=>"
        ├── @ MatchRequiredNode (location: (25,0)-(25,19))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (25,0)-(25,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (25,0)-(25,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SourceEncodingNode (location: (25,7)-(25,19))
        │   │   └── flags: static_literal
        │   └── operator_loc: (25,4)-(25,6) = "=>"
        ├── @ MatchRequiredNode (location: (26,0)-(26,17))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (26,0)-(26,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (26,0)-(26,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ LambdaNode (location: (26,7)-(26,17))
        │   │   ├── flags: ∅
        │   │   ├── locals: []
        │   │   ├── operator_loc: (26,7)-(26,9) = "->"
        │   │   ├── opening_loc: (26,10)-(26,11) = "{"
        │   │   ├── closing_loc: (26,16)-(26,17) = "}"
        │   │   ├── parameters: ∅
        │   │   └── body:
        │   │       @ StatementsNode (location: (26,12)-(26,15))
        │   │       ├── flags: ∅
        │   │       └── body: (length: 1)
        │   │           └── @ LocalVariableReadNode (location: (26,12)-(26,15))
        │   │               ├── flags: newline
        │   │               ├── name: :bar
        │   │               └── depth: 1
        │   └── operator_loc: (26,4)-(26,6) = "=>"
        ├── @ MatchRequiredNode (location: (28,0)-(28,13))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (28,0)-(28,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (28,0)-(28,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (28,7)-(28,13))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (28,7)-(28,8))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (28,12)-(28,13))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   └── operator_loc: (28,9)-(28,11) = ".."
        │   └── operator_loc: (28,4)-(28,6) = "=>"
        ├── @ MatchRequiredNode (location: (29,0)-(29,17))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (29,0)-(29,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (29,0)-(29,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (29,7)-(29,17))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ FloatNode (location: (29,7)-(29,10))
        │   │   │   ├── flags: static_literal
        │   │   │   └── value: 1.0
        │   │   ├── right:
        │   │   │   @ FloatNode (location: (29,14)-(29,17))
        │   │   │   ├── flags: static_literal
        │   │   │   └── value: 1.0
        │   │   └── operator_loc: (29,11)-(29,13) = ".."
        │   └── operator_loc: (29,4)-(29,6) = "=>"
        ├── @ MatchRequiredNode (location: (30,0)-(30,15))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (30,0)-(30,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (30,0)-(30,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (30,7)-(30,15))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ ImaginaryNode (location: (30,7)-(30,9))
        │   │   │   ├── flags: static_literal
        │   │   │   └── numeric:
        │   │   │       @ IntegerNode (location: (30,7)-(30,8))
        │   │   │       ├── flags: static_literal, decimal
        │   │   │       └── value: 1
        │   │   ├── right:
        │   │   │   @ ImaginaryNode (location: (30,13)-(30,15))
        │   │   │   ├── flags: static_literal
        │   │   │   └── numeric:
        │   │   │       @ IntegerNode (location: (30,13)-(30,14))
        │   │   │       ├── flags: static_literal, decimal
        │   │   │       └── value: 1
        │   │   └── operator_loc: (30,10)-(30,12) = ".."
        │   └── operator_loc: (30,4)-(30,6) = "=>"
        ├── @ MatchRequiredNode (location: (31,0)-(31,15))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (31,0)-(31,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (31,0)-(31,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (31,7)-(31,15))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ RationalNode (location: (31,7)-(31,9))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   ├── numerator: 1
        │   │   │   └── denominator: 1
        │   │   ├── right:
        │   │   │   @ RationalNode (location: (31,13)-(31,15))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   ├── numerator: 1
        │   │   │   └── denominator: 1
        │   │   └── operator_loc: (31,10)-(31,12) = ".."
        │   └── operator_loc: (31,4)-(31,6) = "=>"
        ├── @ MatchRequiredNode (location: (32,0)-(32,19))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (32,0)-(32,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (32,0)-(32,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (32,7)-(32,19))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ SymbolNode (location: (32,7)-(32,11))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (32,7)-(32,8) = ":"
        │   │   │   ├── value_loc: (32,8)-(32,11) = "foo"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ SymbolNode (location: (32,15)-(32,19))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (32,15)-(32,16) = ":"
        │   │   │   ├── value_loc: (32,16)-(32,19) = "foo"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (32,12)-(32,14) = ".."
        │   └── operator_loc: (32,4)-(32,6) = "=>"
        ├── @ MatchRequiredNode (location: (33,0)-(33,25))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (33,0)-(33,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (33,0)-(33,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (33,7)-(33,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ SymbolNode (location: (33,7)-(33,14))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (33,7)-(33,10) = "%s["
        │   │   │   ├── value_loc: (33,10)-(33,13) = "foo"
        │   │   │   ├── closing_loc: (33,13)-(33,14) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ SymbolNode (location: (33,18)-(33,25))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (33,18)-(33,21) = "%s["
        │   │   │   ├── value_loc: (33,21)-(33,24) = "foo"
        │   │   │   ├── closing_loc: (33,24)-(33,25) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (33,15)-(33,17) = ".."
        │   └── operator_loc: (33,4)-(33,6) = "=>"
        ├── @ MatchRequiredNode (location: (34,0)-(34,23))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (34,0)-(34,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (34,0)-(34,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (34,7)-(34,23))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ SymbolNode (location: (34,7)-(34,13))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (34,7)-(34,9) = ":\""
        │   │   │   ├── value_loc: (34,9)-(34,12) = "foo"
        │   │   │   ├── closing_loc: (34,12)-(34,13) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ SymbolNode (location: (34,17)-(34,23))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (34,17)-(34,19) = ":\""
        │   │   │   ├── value_loc: (34,19)-(34,22) = "foo"
        │   │   │   ├── closing_loc: (34,22)-(34,23) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (34,14)-(34,16) = ".."
        │   └── operator_loc: (34,4)-(34,6) = "=>"
        ├── @ MatchRequiredNode (location: (35,0)-(35,21))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (35,0)-(35,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (35,0)-(35,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (35,7)-(35,21))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ RegularExpressionNode (location: (35,7)-(35,12))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (35,7)-(35,8) = "/"
        │   │   │   ├── content_loc: (35,8)-(35,11) = "foo"
        │   │   │   ├── closing_loc: (35,11)-(35,12) = "/"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ RegularExpressionNode (location: (35,16)-(35,21))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (35,16)-(35,17) = "/"
        │   │   │   ├── content_loc: (35,17)-(35,20) = "foo"
        │   │   │   ├── closing_loc: (35,20)-(35,21) = "/"
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (35,13)-(35,15) = ".."
        │   └── operator_loc: (35,4)-(35,6) = "=>"
        ├── @ MatchRequiredNode (location: (36,0)-(36,21))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (36,0)-(36,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (36,0)-(36,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (36,7)-(36,21))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ XStringNode (location: (36,7)-(36,12))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (36,7)-(36,8) = "`"
        │   │   │   ├── content_loc: (36,8)-(36,11) = "foo"
        │   │   │   ├── closing_loc: (36,11)-(36,12) = "`"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ XStringNode (location: (36,16)-(36,21))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (36,16)-(36,17) = "`"
        │   │   │   ├── content_loc: (36,17)-(36,20) = "foo"
        │   │   │   ├── closing_loc: (36,20)-(36,21) = "`"
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (36,13)-(36,15) = ".."
        │   └── operator_loc: (36,4)-(36,6) = "=>"
        ├── @ MatchRequiredNode (location: (37,0)-(37,25))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (37,0)-(37,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (37,0)-(37,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (37,7)-(37,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ XStringNode (location: (37,7)-(37,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (37,7)-(37,10) = "%x["
        │   │   │   ├── content_loc: (37,10)-(37,13) = "foo"
        │   │   │   ├── closing_loc: (37,13)-(37,14) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ XStringNode (location: (37,18)-(37,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (37,18)-(37,21) = "%x["
        │   │   │   ├── content_loc: (37,21)-(37,24) = "foo"
        │   │   │   ├── closing_loc: (37,24)-(37,25) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (37,15)-(37,17) = ".."
        │   └── operator_loc: (37,4)-(37,6) = "=>"
        ├── @ MatchRequiredNode (location: (38,0)-(38,25))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (38,0)-(38,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (38,0)-(38,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (38,7)-(38,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (38,7)-(38,14))
        │   │   │   ├── flags: static_literal
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (38,10)-(38,13))
        │   │   │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (38,10)-(38,13) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (38,7)-(38,10) = "%i["
        │   │   │   └── closing_loc: (38,13)-(38,14) = "]"
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (38,18)-(38,25))
        │   │   │   ├── flags: static_literal
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (38,21)-(38,24))
        │   │   │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (38,21)-(38,24) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (38,18)-(38,21) = "%i["
        │   │   │   └── closing_loc: (38,24)-(38,25) = "]"
        │   │   └── operator_loc: (38,15)-(38,17) = ".."
        │   └── operator_loc: (38,4)-(38,6) = "=>"
        ├── @ MatchRequiredNode (location: (39,0)-(39,25))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (39,0)-(39,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (39,0)-(39,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (39,7)-(39,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (39,7)-(39,14))
        │   │   │   ├── flags: static_literal
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (39,10)-(39,13))
        │   │   │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (39,10)-(39,13) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (39,7)-(39,10) = "%I["
        │   │   │   └── closing_loc: (39,13)-(39,14) = "]"
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (39,18)-(39,25))
        │   │   │   ├── flags: static_literal
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SymbolNode (location: (39,21)-(39,24))
        │   │   │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── value_loc: (39,21)-(39,24) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (39,18)-(39,21) = "%I["
        │   │   │   └── closing_loc: (39,24)-(39,25) = "]"
        │   │   └── operator_loc: (39,15)-(39,17) = ".."
        │   └── operator_loc: (39,4)-(39,6) = "=>"
        ├── @ MatchRequiredNode (location: (40,0)-(40,25))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (40,0)-(40,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (40,0)-(40,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (40,7)-(40,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (40,7)-(40,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (40,10)-(40,13))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (40,10)-(40,13) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (40,7)-(40,10) = "%w["
        │   │   │   └── closing_loc: (40,13)-(40,14) = "]"
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (40,18)-(40,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (40,21)-(40,24))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (40,21)-(40,24) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (40,18)-(40,21) = "%w["
        │   │   │   └── closing_loc: (40,24)-(40,25) = "]"
        │   │   └── operator_loc: (40,15)-(40,17) = ".."
        │   └── operator_loc: (40,4)-(40,6) = "=>"
        ├── @ MatchRequiredNode (location: (41,0)-(41,25))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (41,0)-(41,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (41,0)-(41,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (41,7)-(41,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ ArrayNode (location: (41,7)-(41,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (41,10)-(41,13))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (41,10)-(41,13) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (41,7)-(41,10) = "%W["
        │   │   │   └── closing_loc: (41,13)-(41,14) = "]"
        │   │   ├── right:
        │   │   │   @ ArrayNode (location: (41,18)-(41,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ StringNode (location: (41,21)-(41,24))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── content_loc: (41,21)-(41,24) = "foo"
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── unescaped: "foo"
        │   │   │   ├── opening_loc: (41,18)-(41,21) = "%W["
        │   │   │   └── closing_loc: (41,24)-(41,25) = "]"
        │   │   └── operator_loc: (41,15)-(41,17) = ".."
        │   └── operator_loc: (41,4)-(41,6) = "=>"
        ├── @ MatchRequiredNode (location: (42,0)-(42,25))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (42,0)-(42,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (42,0)-(42,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (42,7)-(42,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ StringNode (location: (42,7)-(42,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (42,7)-(42,10) = "%q["
        │   │   │   ├── content_loc: (42,10)-(42,13) = "foo"
        │   │   │   ├── closing_loc: (42,13)-(42,14) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ StringNode (location: (42,18)-(42,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (42,18)-(42,21) = "%q["
        │   │   │   ├── content_loc: (42,21)-(42,24) = "foo"
        │   │   │   ├── closing_loc: (42,24)-(42,25) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (42,15)-(42,17) = ".."
        │   └── operator_loc: (42,4)-(42,6) = "=>"
        ├── @ MatchRequiredNode (location: (43,0)-(43,25))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (43,0)-(43,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (43,0)-(43,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (43,7)-(43,25))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ StringNode (location: (43,7)-(43,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (43,7)-(43,10) = "%Q["
        │   │   │   ├── content_loc: (43,10)-(43,13) = "foo"
        │   │   │   ├── closing_loc: (43,13)-(43,14) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ StringNode (location: (43,18)-(43,25))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (43,18)-(43,21) = "%Q["
        │   │   │   ├── content_loc: (43,21)-(43,24) = "foo"
        │   │   │   ├── closing_loc: (43,24)-(43,25) = "]"
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (43,15)-(43,17) = ".."
        │   └── operator_loc: (43,4)-(43,6) = "=>"
        ├── @ MatchRequiredNode (location: (44,0)-(44,21))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (44,0)-(44,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (44,0)-(44,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (44,7)-(44,21))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ StringNode (location: (44,7)-(44,12))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (44,7)-(44,8) = "\""
        │   │   │   ├── content_loc: (44,8)-(44,11) = "foo"
        │   │   │   ├── closing_loc: (44,11)-(44,12) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   ├── right:
        │   │   │   @ StringNode (location: (44,16)-(44,21))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (44,16)-(44,17) = "\""
        │   │   │   ├── content_loc: (44,17)-(44,20) = "foo"
        │   │   │   ├── closing_loc: (44,20)-(44,21) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   └── operator_loc: (44,13)-(44,15) = ".."
        │   └── operator_loc: (44,4)-(44,6) = "=>"
        ├── @ MatchRequiredNode (location: (45,0)-(45,17))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (45,0)-(45,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (45,0)-(45,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (45,7)-(45,17))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ NilNode (location: (45,7)-(45,10))
        │   │   │   └── flags: static_literal
        │   │   ├── right:
        │   │   │   @ NilNode (location: (45,14)-(45,17))
        │   │   │   └── flags: static_literal
        │   │   └── operator_loc: (45,11)-(45,13) = ".."
        │   └── operator_loc: (45,4)-(45,6) = "=>"
        ├── @ MatchRequiredNode (location: (46,0)-(46,19))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (46,0)-(46,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (46,0)-(46,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (46,7)-(46,19))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ SelfNode (location: (46,7)-(46,11))
        │   │   │   └── flags: ∅
        │   │   ├── right:
        │   │   │   @ SelfNode (location: (46,15)-(46,19))
        │   │   │   └── flags: ∅
        │   │   └── operator_loc: (46,12)-(46,14) = ".."
        │   └── operator_loc: (46,4)-(46,6) = "=>"
        ├── @ MatchRequiredNode (location: (47,0)-(47,19))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (47,0)-(47,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (47,0)-(47,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (47,7)-(47,19))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ TrueNode (location: (47,7)-(47,11))
        │   │   │   └── flags: static_literal
        │   │   ├── right:
        │   │   │   @ TrueNode (location: (47,15)-(47,19))
        │   │   │   └── flags: static_literal
        │   │   └── operator_loc: (47,12)-(47,14) = ".."
        │   └── operator_loc: (47,4)-(47,6) = "=>"
        ├── @ MatchRequiredNode (location: (48,0)-(48,21))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (48,0)-(48,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (48,0)-(48,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (48,7)-(48,21))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ FalseNode (location: (48,7)-(48,12))
        │   │   │   └── flags: static_literal
        │   │   ├── right:
        │   │   │   @ FalseNode (location: (48,16)-(48,21))
        │   │   │   └── flags: static_literal
        │   │   └── operator_loc: (48,13)-(48,15) = ".."
        │   └── operator_loc: (48,4)-(48,6) = "=>"
        ├── @ MatchRequiredNode (location: (49,0)-(49,27))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (49,0)-(49,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (49,0)-(49,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (49,7)-(49,27))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ SourceFileNode (location: (49,7)-(49,15))
        │   │   │   ├── flags: ∅
        │   │   │   └── filepath: "patterns.txt"
        │   │   ├── right:
        │   │   │   @ SourceFileNode (location: (49,19)-(49,27))
        │   │   │   ├── flags: ∅
        │   │   │   └── filepath: "patterns.txt"
        │   │   └── operator_loc: (49,16)-(49,18) = ".."
        │   └── operator_loc: (49,4)-(49,6) = "=>"
        ├── @ MatchRequiredNode (location: (50,0)-(50,27))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (50,0)-(50,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (50,0)-(50,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (50,7)-(50,27))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ SourceLineNode (location: (50,7)-(50,15))
        │   │   │   └── flags: static_literal
        │   │   ├── right:
        │   │   │   @ SourceLineNode (location: (50,19)-(50,27))
        │   │   │   └── flags: static_literal
        │   │   └── operator_loc: (50,16)-(50,18) = ".."
        │   └── operator_loc: (50,4)-(50,6) = "=>"
        ├── @ MatchRequiredNode (location: (51,0)-(51,35))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (51,0)-(51,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (51,0)-(51,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (51,7)-(51,35))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ SourceEncodingNode (location: (51,7)-(51,19))
        │   │   │   └── flags: static_literal
        │   │   ├── right:
        │   │   │   @ SourceEncodingNode (location: (51,23)-(51,35))
        │   │   │   └── flags: static_literal
        │   │   └── operator_loc: (51,20)-(51,22) = ".."
        │   └── operator_loc: (51,4)-(51,6) = "=>"
        ├── @ MatchRequiredNode (location: (52,0)-(52,31))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (52,0)-(52,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (52,0)-(52,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RangeNode (location: (52,7)-(52,31))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ LambdaNode (location: (52,7)-(52,17))
        │   │   │   ├── flags: ∅
        │   │   │   ├── locals: []
        │   │   │   ├── operator_loc: (52,7)-(52,9) = "->"
        │   │   │   ├── opening_loc: (52,10)-(52,11) = "{"
        │   │   │   ├── closing_loc: (52,16)-(52,17) = "}"
        │   │   │   ├── parameters: ∅
        │   │   │   └── body:
        │   │   │       @ StatementsNode (location: (52,12)-(52,15))
        │   │   │       ├── flags: ∅
        │   │   │       └── body: (length: 1)
        │   │   │           └── @ LocalVariableReadNode (location: (52,12)-(52,15))
        │   │   │               ├── flags: newline
        │   │   │               ├── name: :bar
        │   │   │               └── depth: 1
        │   │   ├── right:
        │   │   │   @ LambdaNode (location: (52,21)-(52,31))
        │   │   │   ├── flags: ∅
        │   │   │   ├── locals: []
        │   │   │   ├── operator_loc: (52,21)-(52,23) = "->"
        │   │   │   ├── opening_loc: (52,24)-(52,25) = "{"
        │   │   │   ├── closing_loc: (52,30)-(52,31) = "}"
        │   │   │   ├── parameters: ∅
        │   │   │   └── body:
        │   │   │       @ StatementsNode (location: (52,26)-(52,29))
        │   │   │       ├── flags: ∅
        │   │   │       └── body: (length: 1)
        │   │   │           └── @ LocalVariableReadNode (location: (52,26)-(52,29))
        │   │   │               ├── flags: newline
        │   │   │               ├── name: :bar
        │   │   │               └── depth: 1
        │   │   └── operator_loc: (52,18)-(52,20) = ".."
        │   └── operator_loc: (52,4)-(52,6) = "=>"
        ├── @ LocalVariableWriteNode (location: (54,0)-(54,7))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── depth: 0
        │   ├── name_loc: (54,0)-(54,3) = "bar"
        │   ├── value:
        │   │   @ IntegerNode (location: (54,6)-(54,7))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (54,4)-(54,5) = "="
        ├── @ MatchRequiredNode (location: (54,9)-(54,20))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (54,9)-(54,12))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (54,9)-(54,12) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (54,16)-(54,20))
        │   │   ├── flags: ∅
        │   │   ├── variable:
        │   │   │   @ LocalVariableReadNode (location: (54,17)-(54,20))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   └── operator_loc: (54,16)-(54,17) = "^"
        │   └── operator_loc: (54,13)-(54,15) = "=>"
        ├── @ MatchRequiredNode (location: (55,0)-(55,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (55,0)-(55,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (55,0)-(55,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (55,7)-(55,12))
        │   │   ├── flags: ∅
        │   │   ├── variable:
        │   │   │   @ InstanceVariableReadNode (location: (55,8)-(55,12))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :@bar
        │   │   └── operator_loc: (55,7)-(55,8) = "^"
        │   └── operator_loc: (55,4)-(55,6) = "=>"
        ├── @ MatchRequiredNode (location: (56,0)-(56,13))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (56,0)-(56,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (56,0)-(56,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (56,7)-(56,13))
        │   │   ├── flags: ∅
        │   │   ├── variable:
        │   │   │   @ ClassVariableReadNode (location: (56,8)-(56,13))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :@@bar
        │   │   └── operator_loc: (56,7)-(56,8) = "^"
        │   └── operator_loc: (56,4)-(56,6) = "=>"
        ├── @ MatchRequiredNode (location: (57,0)-(57,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (57,0)-(57,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (57,0)-(57,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ PinnedVariableNode (location: (57,7)-(57,12))
        │   │   ├── flags: ∅
        │   │   ├── variable:
        │   │   │   @ GlobalVariableReadNode (location: (57,8)-(57,12))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :$bar
        │   │   └── operator_loc: (57,7)-(57,8) = "^"
        │   └── operator_loc: (57,4)-(57,6) = "=>"
        ├── @ MatchRequiredNode (location: (59,0)-(59,11))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (59,0)-(59,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (59,0)-(59,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (59,7)-(59,11))
        │   │   ├── flags: ∅
        │   │   ├── expression:
        │   │   │   @ IntegerNode (location: (59,9)-(59,10))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── operator_loc: (59,7)-(59,8) = "^"
        │   │   ├── lparen_loc: (59,8)-(59,9) = "("
        │   │   └── rparen_loc: (59,10)-(59,11) = ")"
        │   └── operator_loc: (59,4)-(59,6) = "=>"
        ├── @ MatchRequiredNode (location: (60,0)-(60,13))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (60,0)-(60,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (60,0)-(60,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (60,7)-(60,13))
        │   │   ├── flags: ∅
        │   │   ├── expression:
        │   │   │   @ NilNode (location: (60,9)-(60,12))
        │   │   │   └── flags: static_literal
        │   │   ├── operator_loc: (60,7)-(60,8) = "^"
        │   │   ├── lparen_loc: (60,8)-(60,9) = "("
        │   │   └── rparen_loc: (60,12)-(60,13) = ")"
        │   └── operator_loc: (60,4)-(60,6) = "=>"
        ├── @ MatchRequiredNode (location: (61,0)-(61,23))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (61,0)-(61,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (61,0)-(61,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (61,7)-(61,23))
        │   │   ├── flags: ∅
        │   │   ├── expression:
        │   │   │   @ CallNode (location: (61,9)-(61,22))
        │   │   │   ├── flags: ∅
        │   │   │   ├── receiver:
        │   │   │   │   @ StringNode (location: (61,9)-(61,14))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── opening_loc: (61,9)-(61,10) = "\""
        │   │   │   │   ├── content_loc: (61,10)-(61,13) = "bar"
        │   │   │   │   ├── closing_loc: (61,13)-(61,14) = "\""
        │   │   │   │   └── unescaped: "bar"
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :+
        │   │   │   ├── message_loc: (61,15)-(61,16) = "+"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (61,17)-(61,22))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ StringNode (location: (61,17)-(61,22))
        │   │   │   │           ├── flags: ∅
        │   │   │   │           ├── opening_loc: (61,17)-(61,18) = "\""
        │   │   │   │           ├── content_loc: (61,18)-(61,21) = "baz"
        │   │   │   │           ├── closing_loc: (61,21)-(61,22) = "\""
        │   │   │   │           └── unescaped: "baz"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── operator_loc: (61,7)-(61,8) = "^"
        │   │   ├── lparen_loc: (61,8)-(61,9) = "("
        │   │   └── rparen_loc: (61,22)-(61,23) = ")"
        │   └── operator_loc: (61,4)-(61,6) = "=>"
        ├── @ MatchRequiredNode (location: (63,0)-(63,10))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (63,0)-(63,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (63,0)-(63,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ConstantReadNode (location: (63,7)-(63,10))
        │   │   ├── flags: ∅
        │   │   └── name: :Foo
        │   └── operator_loc: (63,4)-(63,6) = "=>"
        ├── @ MatchRequiredNode (location: (64,0)-(64,20))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (64,0)-(64,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (64,0)-(64,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ConstantPathNode (location: (64,7)-(64,20))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantPathNode (location: (64,7)-(64,15))
        │   │   │   ├── flags: ∅
        │   │   │   ├── parent:
        │   │   │   │   @ ConstantReadNode (location: (64,7)-(64,10))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :Foo
        │   │   │   ├── name: :Bar
        │   │   │   ├── delimiter_loc: (64,10)-(64,12) = "::"
        │   │   │   └── name_loc: (64,12)-(64,15) = "Bar"
        │   │   ├── name: :Baz
        │   │   ├── delimiter_loc: (64,15)-(64,17) = "::"
        │   │   └── name_loc: (64,17)-(64,20) = "Baz"
        │   └── operator_loc: (64,4)-(64,6) = "=>"
        ├── @ MatchRequiredNode (location: (65,0)-(65,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (65,0)-(65,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (65,0)-(65,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ConstantPathNode (location: (65,7)-(65,12))
        │   │   ├── flags: ∅
        │   │   ├── parent: ∅
        │   │   ├── name: :Foo
        │   │   ├── delimiter_loc: (65,7)-(65,9) = "::"
        │   │   └── name_loc: (65,9)-(65,12) = "Foo"
        │   └── operator_loc: (65,4)-(65,6) = "=>"
        ├── @ MatchRequiredNode (location: (66,0)-(66,22))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (66,0)-(66,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (66,0)-(66,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ConstantPathNode (location: (66,7)-(66,22))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantPathNode (location: (66,7)-(66,17))
        │   │   │   ├── flags: ∅
        │   │   │   ├── parent:
        │   │   │   │   @ ConstantPathNode (location: (66,7)-(66,12))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── parent: ∅
        │   │   │   │   ├── name: :Foo
        │   │   │   │   ├── delimiter_loc: (66,7)-(66,9) = "::"
        │   │   │   │   └── name_loc: (66,9)-(66,12) = "Foo"
        │   │   │   ├── name: :Bar
        │   │   │   ├── delimiter_loc: (66,12)-(66,14) = "::"
        │   │   │   └── name_loc: (66,14)-(66,17) = "Bar"
        │   │   ├── name: :Baz
        │   │   ├── delimiter_loc: (66,17)-(66,19) = "::"
        │   │   └── name_loc: (66,19)-(66,22) = "Baz"
        │   └── operator_loc: (66,4)-(66,6) = "=>"
        ├── @ MatchRequiredNode (location: (68,0)-(68,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (68,0)-(68,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (68,0)-(68,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (68,7)-(68,12))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (68,7)-(68,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (68,10)-(68,11) = "("
        │   │   └── closing_loc: (68,11)-(68,12) = ")"
        │   └── operator_loc: (68,4)-(68,6) = "=>"
        ├── @ MatchRequiredNode (location: (69,0)-(69,13))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (69,0)-(69,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (69,0)-(69,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (69,7)-(69,13))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (69,7)-(69,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ IntegerNode (location: (69,11)-(69,12))
        │   │   │       ├── flags: static_literal, decimal
        │   │   │       └── value: 1
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (69,10)-(69,11) = "("
        │   │   └── closing_loc: (69,12)-(69,13) = ")"
        │   └── operator_loc: (69,4)-(69,6) = "=>"
        ├── @ MatchRequiredNode (location: (70,0)-(70,19))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (70,0)-(70,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (70,0)-(70,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (70,7)-(70,19))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (70,7)-(70,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 3)
        │   │   │   ├── @ IntegerNode (location: (70,11)-(70,12))
        │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   └── value: 1
        │   │   │   ├── @ IntegerNode (location: (70,14)-(70,15))
        │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   └── value: 2
        │   │   │   └── @ IntegerNode (location: (70,17)-(70,18))
        │   │   │       ├── flags: static_literal, decimal
        │   │   │       └── value: 3
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (70,10)-(70,11) = "("
        │   │   └── closing_loc: (70,18)-(70,19) = ")"
        │   └── operator_loc: (70,4)-(70,6) = "=>"
        ├── @ MatchRequiredNode (location: (71,0)-(71,15))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (71,0)-(71,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (71,0)-(71,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (71,7)-(71,15))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (71,7)-(71,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (71,11)-(71,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (71,10)-(71,11) = "("
        │   │   └── closing_loc: (71,14)-(71,15) = ")"
        │   └── operator_loc: (71,4)-(71,6) = "=>"
        ├── @ MatchRequiredNode (location: (72,0)-(72,21))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (72,0)-(72,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (72,0)-(72,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (72,7)-(72,21))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (72,7)-(72,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (72,11)-(72,15))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (72,11)-(72,12) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (72,12)-(72,15))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (72,17)-(72,20))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (72,10)-(72,11) = "("
        │   │   └── closing_loc: (72,20)-(72,21) = ")"
        │   └── operator_loc: (72,4)-(72,6) = "=>"
        ├── @ MatchRequiredNode (location: (73,0)-(73,21))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (73,0)-(73,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (73,0)-(73,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (73,7)-(73,21))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (73,7)-(73,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (73,11)-(73,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (73,16)-(73,20))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (73,16)-(73,17) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (73,17)-(73,20))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (73,10)-(73,11) = "("
        │   │   └── closing_loc: (73,20)-(73,21) = ")"
        │   └── operator_loc: (73,4)-(73,6) = "=>"
        ├── @ MatchRequiredNode (location: (74,0)-(74,27))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (74,0)-(74,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (74,0)-(74,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (74,7)-(74,27))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (74,7)-(74,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (74,11)-(74,15))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (74,11)-(74,12) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (74,12)-(74,15))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (74,17)-(74,20))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (74,22)-(74,26))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (74,22)-(74,23) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (74,23)-(74,26))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (74,10)-(74,11) = "("
        │   │   └── closing_loc: (74,26)-(74,27) = ")"
        │   └── operator_loc: (74,4)-(74,6) = "=>"
        ├── @ MatchRequiredNode (location: (76,0)-(76,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (76,0)-(76,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (76,0)-(76,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (76,7)-(76,12))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (76,7)-(76,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (76,10)-(76,11) = "["
        │   │   └── closing_loc: (76,11)-(76,12) = "]"
        │   └── operator_loc: (76,4)-(76,6) = "=>"
        ├── @ MatchRequiredNode (location: (77,0)-(77,13))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (77,0)-(77,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (77,0)-(77,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (77,7)-(77,13))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (77,7)-(77,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ IntegerNode (location: (77,11)-(77,12))
        │   │   │       ├── flags: static_literal, decimal
        │   │   │       └── value: 1
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (77,10)-(77,11) = "["
        │   │   └── closing_loc: (77,12)-(77,13) = "]"
        │   └── operator_loc: (77,4)-(77,6) = "=>"
        ├── @ MatchRequiredNode (location: (78,0)-(78,19))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (78,0)-(78,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (78,0)-(78,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (78,7)-(78,19))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (78,7)-(78,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 3)
        │   │   │   ├── @ IntegerNode (location: (78,11)-(78,12))
        │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   └── value: 1
        │   │   │   ├── @ IntegerNode (location: (78,14)-(78,15))
        │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   └── value: 2
        │   │   │   └── @ IntegerNode (location: (78,17)-(78,18))
        │   │   │       ├── flags: static_literal, decimal
        │   │   │       └── value: 3
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (78,10)-(78,11) = "["
        │   │   └── closing_loc: (78,18)-(78,19) = "]"
        │   └── operator_loc: (78,4)-(78,6) = "=>"
        ├── @ MatchRequiredNode (location: (79,0)-(79,17))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (79,0)-(79,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (79,0)-(79,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (79,7)-(79,17))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (79,7)-(79,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ ArrayPatternNode (location: (79,11)-(79,16))
        │   │   │       ├── flags: ∅
        │   │   │       ├── constant:
        │   │   │       │   @ ConstantReadNode (location: (79,11)-(79,14))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   └── name: :Foo
        │   │   │       ├── requireds: (length: 0)
        │   │   │       ├── rest: ∅
        │   │   │       ├── posts: (length: 0)
        │   │   │       ├── opening_loc: (79,14)-(79,15) = "["
        │   │   │       └── closing_loc: (79,15)-(79,16) = "]"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (79,10)-(79,11) = "["
        │   │   └── closing_loc: (79,16)-(79,17) = "]"
        │   └── operator_loc: (79,4)-(79,6) = "=>"
        ├── @ MatchRequiredNode (location: (80,0)-(80,15))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (80,0)-(80,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (80,0)-(80,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (80,7)-(80,15))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (80,7)-(80,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (80,11)-(80,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (80,10)-(80,11) = "["
        │   │   └── closing_loc: (80,14)-(80,15) = "]"
        │   └── operator_loc: (80,4)-(80,6) = "=>"
        ├── @ MatchRequiredNode (location: (81,0)-(81,21))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (81,0)-(81,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (81,0)-(81,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (81,7)-(81,21))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (81,7)-(81,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (81,11)-(81,15))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (81,11)-(81,12) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (81,12)-(81,15))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (81,17)-(81,20))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (81,10)-(81,11) = "["
        │   │   └── closing_loc: (81,20)-(81,21) = "]"
        │   └── operator_loc: (81,4)-(81,6) = "=>"
        ├── @ MatchRequiredNode (location: (82,0)-(82,21))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (82,0)-(82,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (82,0)-(82,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (82,7)-(82,21))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (82,7)-(82,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (82,11)-(82,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (82,16)-(82,20))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (82,16)-(82,17) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (82,17)-(82,20))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (82,10)-(82,11) = "["
        │   │   └── closing_loc: (82,20)-(82,21) = "]"
        │   └── operator_loc: (82,4)-(82,6) = "=>"
        ├── @ MatchRequiredNode (location: (83,0)-(83,27))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (83,0)-(83,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (83,0)-(83,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (83,7)-(83,27))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (83,7)-(83,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Foo
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (83,11)-(83,15))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (83,11)-(83,12) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (83,12)-(83,15))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (83,17)-(83,20))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (83,22)-(83,26))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (83,22)-(83,23) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (83,23)-(83,26))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (83,10)-(83,11) = "["
        │   │   └── closing_loc: (83,26)-(83,27) = "]"
        │   └── operator_loc: (83,4)-(83,6) = "=>"
        ├── @ MatchRequiredNode (location: (85,0)-(85,11))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (85,0)-(85,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (85,0)-(85,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (85,7)-(85,11))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (85,7)-(85,11))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (85,7)-(85,8) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (85,8)-(85,11))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (85,4)-(85,6) = "=>"
        ├── @ MatchRequiredNode (location: (86,0)-(86,21))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (86,0)-(86,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (86,0)-(86,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (86,7)-(86,21))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (86,7)-(86,11))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (86,7)-(86,8) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (86,8)-(86,11))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (86,13)-(86,16))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :baz
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (86,18)-(86,21))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (86,4)-(86,6) = "=>"
        ├── @ MatchRequiredNode (location: (87,0)-(87,21))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (87,0)-(87,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (87,0)-(87,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (87,7)-(87,21))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (87,7)-(87,10))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (87,12)-(87,16))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (87,12)-(87,13) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (87,13)-(87,16))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (87,18)-(87,21))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (87,4)-(87,6) = "=>"
        ├── @ MatchRequiredNode (location: (88,0)-(88,21))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (88,0)-(88,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (88,0)-(88,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (88,7)-(88,21))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (88,7)-(88,10))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :bar
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (88,12)-(88,15))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (88,17)-(88,21))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (88,17)-(88,18) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (88,18)-(88,21))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (88,4)-(88,6) = "=>"
        ├── @ MatchRequiredNode (location: (89,0)-(89,22))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (89,0)-(89,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (89,0)-(89,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (89,7)-(89,22))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (89,7)-(89,11))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (89,7)-(89,8) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (89,8)-(89,11))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (89,13)-(89,16))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (89,18)-(89,22))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (89,18)-(89,19) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (89,19)-(89,22))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (89,4)-(89,6) = "=>"
        ├── @ MatchRequiredNode (location: (90,0)-(90,11))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (90,0)-(90,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (90,0)-(90,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (90,7)-(90,11))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (90,7)-(90,10))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ ImplicitRestNode (location: (90,10)-(90,11))
        │   │   │   └── flags: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (90,4)-(90,6) = "=>"
        ├── @ MatchRequiredNode (location: (92,0)-(92,9))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (92,0)-(92,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (92,0)-(92,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (92,7)-(92,9))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (92,7)-(92,8) = "["
        │   │   └── closing_loc: (92,8)-(92,9) = "]"
        │   └── operator_loc: (92,4)-(92,6) = "=>"
        ├── @ MatchRequiredNode (location: (93,0)-(93,17))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (93,0)-(93,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (93,0)-(93,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (93,7)-(93,17))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ ArrayPatternNode (location: (93,8)-(93,16))
        │   │   │       ├── flags: ∅
        │   │   │       ├── constant: ∅
        │   │   │       ├── requireds: (length: 1)
        │   │   │       │   └── @ ArrayPatternNode (location: (93,9)-(93,15))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       ├── constant: ∅
        │   │   │       │       ├── requireds: (length: 1)
        │   │   │       │       │   └── @ ArrayPatternNode (location: (93,10)-(93,14))
        │   │   │       │       │       ├── flags: ∅
        │   │   │       │       │       ├── constant: ∅
        │   │   │       │       │       ├── requireds: (length: 1)
        │   │   │       │       │       │   └── @ ArrayPatternNode (location: (93,11)-(93,13))
        │   │   │       │       │       │       ├── flags: ∅
        │   │   │       │       │       │       ├── constant: ∅
        │   │   │       │       │       │       ├── requireds: (length: 0)
        │   │   │       │       │       │       ├── rest: ∅
        │   │   │       │       │       │       ├── posts: (length: 0)
        │   │   │       │       │       │       ├── opening_loc: (93,11)-(93,12) = "["
        │   │   │       │       │       │       └── closing_loc: (93,12)-(93,13) = "]"
        │   │   │       │       │       ├── rest: ∅
        │   │   │       │       │       ├── posts: (length: 0)
        │   │   │       │       │       ├── opening_loc: (93,10)-(93,11) = "["
        │   │   │       │       │       └── closing_loc: (93,13)-(93,14) = "]"
        │   │   │       │       ├── rest: ∅
        │   │   │       │       ├── posts: (length: 0)
        │   │   │       │       ├── opening_loc: (93,9)-(93,10) = "["
        │   │   │       │       └── closing_loc: (93,14)-(93,15) = "]"
        │   │   │       ├── rest: ∅
        │   │   │       ├── posts: (length: 0)
        │   │   │       ├── opening_loc: (93,8)-(93,9) = "["
        │   │   │       └── closing_loc: (93,15)-(93,16) = "]"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (93,7)-(93,8) = "["
        │   │   └── closing_loc: (93,16)-(93,17) = "]"
        │   └── operator_loc: (93,4)-(93,6) = "=>"
        ├── @ MatchRequiredNode (location: (95,0)-(95,13))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (95,0)-(95,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (95,0)-(95,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (95,7)-(95,13))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (95,8)-(95,12))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (95,8)-(95,9) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (95,9)-(95,12))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (95,7)-(95,8) = "["
        │   │   └── closing_loc: (95,12)-(95,13) = "]"
        │   └── operator_loc: (95,4)-(95,6) = "=>"
        ├── @ MatchRequiredNode (location: (96,0)-(96,23))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (96,0)-(96,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (96,0)-(96,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (96,7)-(96,23))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (96,8)-(96,12))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (96,8)-(96,9) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (96,9)-(96,12))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (96,14)-(96,17))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :baz
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (96,19)-(96,22))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (96,7)-(96,8) = "["
        │   │   └── closing_loc: (96,22)-(96,23) = "]"
        │   └── operator_loc: (96,4)-(96,6) = "=>"
        ├── @ MatchRequiredNode (location: (97,0)-(97,23))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (97,0)-(97,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (97,0)-(97,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (97,7)-(97,23))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (97,8)-(97,11))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (97,13)-(97,17))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (97,13)-(97,14) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (97,14)-(97,17))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (97,19)-(97,22))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (97,7)-(97,8) = "["
        │   │   └── closing_loc: (97,22)-(97,23) = "]"
        │   └── operator_loc: (97,4)-(97,6) = "=>"
        ├── @ MatchRequiredNode (location: (98,0)-(98,23))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (98,0)-(98,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (98,0)-(98,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (98,7)-(98,23))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (98,8)-(98,11))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :bar
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (98,13)-(98,16))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (98,18)-(98,22))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (98,18)-(98,19) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (98,19)-(98,22))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (98,7)-(98,8) = "["
        │   │   └── closing_loc: (98,22)-(98,23) = "]"
        │   └── operator_loc: (98,4)-(98,6) = "=>"
        ├── @ MatchRequiredNode (location: (99,0)-(99,24))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (99,0)-(99,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (99,0)-(99,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (99,7)-(99,24))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (99,8)-(99,12))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (99,8)-(99,9) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (99,9)-(99,12))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (99,14)-(99,17))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       └── depth: 0
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (99,19)-(99,23))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (99,19)-(99,20) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (99,20)-(99,23))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :qux
        │   │   │       └── depth: 0
        │   │   ├── opening_loc: (99,7)-(99,8) = "["
        │   │   └── closing_loc: (99,23)-(99,24) = "]"
        │   └── operator_loc: (99,4)-(99,6) = "=>"
        ├── @ MatchPredicateNode (location: (101,0)-(101,10))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (101,0)-(101,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (101,0)-(101,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ LocalVariableTargetNode (location: (101,7)-(101,10))
        │   │   ├── flags: ∅
        │   │   ├── name: :bar
        │   │   └── depth: 0
        │   └── operator_loc: (101,4)-(101,6) = "in"
        ├── @ MatchPredicateNode (location: (102,0)-(102,8))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (102,0)-(102,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (102,0)-(102,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ IntegerNode (location: (102,7)-(102,8))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (102,4)-(102,6) = "in"
        ├── @ MatchPredicateNode (location: (103,0)-(103,10))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (103,0)-(103,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (103,0)-(103,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FloatNode (location: (103,7)-(103,10))
        │   │   ├── flags: static_literal
        │   │   └── value: 1.0
        │   └── operator_loc: (103,4)-(103,6) = "in"
        ├── @ MatchPredicateNode (location: (104,0)-(104,9))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (104,0)-(104,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (104,0)-(104,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ImaginaryNode (location: (104,7)-(104,9))
        │   │   ├── flags: static_literal
        │   │   └── numeric:
        │   │       @ IntegerNode (location: (104,7)-(104,8))
        │   │       ├── flags: static_literal, decimal
        │   │       └── value: 1
        │   └── operator_loc: (104,4)-(104,6) = "in"
        ├── @ MatchPredicateNode (location: (105,0)-(105,9))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (105,0)-(105,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (105,0)-(105,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RationalNode (location: (105,7)-(105,9))
        │   │   ├── flags: static_literal, decimal
        │   │   ├── numerator: 1
        │   │   └── denominator: 1
        │   └── operator_loc: (105,4)-(105,6) = "in"
        ├── @ MatchPredicateNode (location: (106,0)-(106,11))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (106,0)-(106,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (106,0)-(106,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SymbolNode (location: (106,7)-(106,11))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (106,7)-(106,8) = ":"
        │   │   ├── value_loc: (106,8)-(106,11) = "foo"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (106,4)-(106,6) = "in"
        ├── @ MatchPredicateNode (location: (107,0)-(107,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (107,0)-(107,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (107,0)-(107,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SymbolNode (location: (107,7)-(107,14))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (107,7)-(107,10) = "%s["
        │   │   ├── value_loc: (107,10)-(107,13) = "foo"
        │   │   ├── closing_loc: (107,13)-(107,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (107,4)-(107,6) = "in"
        ├── @ MatchPredicateNode (location: (108,0)-(108,13))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (108,0)-(108,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (108,0)-(108,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SymbolNode (location: (108,7)-(108,13))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (108,7)-(108,9) = ":\""
        │   │   ├── value_loc: (108,9)-(108,12) = "foo"
        │   │   ├── closing_loc: (108,12)-(108,13) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (108,4)-(108,6) = "in"
        ├── @ MatchPredicateNode (location: (109,0)-(109,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (109,0)-(109,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (109,0)-(109,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ RegularExpressionNode (location: (109,7)-(109,12))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (109,7)-(109,8) = "/"
        │   │   ├── content_loc: (109,8)-(109,11) = "foo"
        │   │   ├── closing_loc: (109,11)-(109,12) = "/"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (109,4)-(109,6) = "in"
        ├── @ MatchPredicateNode (location: (110,0)-(110,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (110,0)-(110,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (110,0)-(110,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ XStringNode (location: (110,7)-(110,12))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (110,7)-(110,8) = "`"
        │   │   ├── content_loc: (110,8)-(110,11) = "foo"
        │   │   ├── closing_loc: (110,11)-(110,12) = "`"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (110,4)-(110,6) = "in"
        ├── @ MatchPredicateNode (location: (111,0)-(111,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (111,0)-(111,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (111,0)-(111,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ XStringNode (location: (111,7)-(111,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (111,7)-(111,10) = "%x["
        │   │   ├── content_loc: (111,10)-(111,13) = "foo"
        │   │   ├── closing_loc: (111,13)-(111,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (111,4)-(111,6) = "in"
        ├── @ MatchPredicateNode (location: (112,0)-(112,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (112,0)-(112,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (112,0)-(112,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (112,7)-(112,14))
        │   │   ├── flags: static_literal
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (112,10)-(112,13))
        │   │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (112,10)-(112,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (112,7)-(112,10) = "%i["
        │   │   └── closing_loc: (112,13)-(112,14) = "]"
        │   └── operator_loc: (112,4)-(112,6) = "in"
        ├── @ MatchPredicateNode (location: (113,0)-(113,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (113,0)-(113,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (113,0)-(113,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (113,7)-(113,14))
        │   │   ├── flags: static_literal
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ SymbolNode (location: (113,10)-(113,13))
        │   │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── value_loc: (113,10)-(113,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (113,7)-(113,10) = "%I["
        │   │   └── closing_loc: (113,13)-(113,14) = "]"
        │   └── operator_loc: (113,4)-(113,6) = "in"
        ├── @ MatchPredicateNode (location: (114,0)-(114,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (114,0)-(114,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (114,0)-(114,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (114,7)-(114,14))
        │   │   ├── flags: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (114,10)-(114,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (114,10)-(114,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (114,7)-(114,10) = "%w["
        │   │   └── closing_loc: (114,13)-(114,14) = "]"
        │   └── operator_loc: (114,4)-(114,6) = "in"
        ├── @ MatchPredicateNode (location: (115,0)-(115,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (115,0)-(115,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (115,0)-(115,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayNode (location: (115,7)-(115,14))
        │   │   ├── flags: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ StringNode (location: (115,10)-(115,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (115,10)-(115,13) = "foo"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "foo"
        │   │   ├── opening_loc: (115,7)-(115,10) = "%W["
        │   │   └── closing_loc: (115,13)-(115,14) = "]"
        │   └── operator_loc: (115,4)-(115,6) = "in"
        ├── @ MatchPredicateNode (location: (116,0)-(116,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (116,0)-(116,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (116,0)-(116,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ StringNode (location: (116,7)-(116,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (116,7)-(116,10) = "%q["
        │   │   ├── content_loc: (116,10)-(116,13) = "foo"
        │   │   ├── closing_loc: (116,13)-(116,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (116,4)-(116,6) = "in"
        ├── @ MatchPredicateNode (location: (117,0)-(117,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (117,0)-(117,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (117,0)-(117,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ StringNode (location: (117,7)-(117,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (117,7)-(117,10) = "%Q["
        │   │   ├── content_loc: (117,10)-(117,13) = "foo"
        │   │   ├── closing_loc: (117,13)-(117,14) = "]"
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (117,4)-(117,6) = "in"
        ├── @ MatchPredicateNode (location: (118,0)-(118,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (118,0)-(118,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (118,0)-(118,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ StringNode (location: (118,7)-(118,12))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (118,7)-(118,8) = "\""
        │   │   ├── content_loc: (118,8)-(118,11) = "foo"
        │   │   ├── closing_loc: (118,11)-(118,12) = "\""
        │   │   └── unescaped: "foo"
        │   └── operator_loc: (118,4)-(118,6) = "in"
        ├── @ MatchPredicateNode (location: (119,0)-(119,10))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (119,0)-(119,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (119,0)-(119,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ NilNode (location: (119,7)-(119,10))
        │   │   └── flags: static_literal
        │   └── operator_loc: (119,4)-(119,6) = "in"
        ├── @ MatchPredicateNode (location: (120,0)-(120,11))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (120,0)-(120,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (120,0)-(120,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SelfNode (location: (120,7)-(120,11))
        │   │   └── flags: ∅
        │   └── operator_loc: (120,4)-(120,6) = "in"
        ├── @ MatchPredicateNode (location: (121,0)-(121,11))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (121,0)-(121,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (121,0)-(121,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ TrueNode (location: (121,7)-(121,11))
        │   │   └── flags: static_literal
        │   └── operator_loc: (121,4)-(121,6) = "in"
        ├── @ MatchPredicateNode (location: (122,0)-(122,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (122,0)-(122,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (122,0)-(122,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ FalseNode (location: (122,7)-(122,12))
        │   │   └── flags: static_literal
        │   └── operator_loc: (122,4)-(122,6) = "in"
        ├── @ MatchPredicateNode (location: (123,0)-(123,15))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (123,0)-(123,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (123,0)-(123,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SourceFileNode (location: (123,7)-(123,15))
        │   │   ├── flags: ∅
        │   │   └── filepath: "patterns.txt"
        │   └── operator_loc: (123,4)-(123,6) = "in"
        ├── @ MatchPredicateNode (location: (124,0)-(124,15))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (124,0)-(124,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (124,0)-(124,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SourceLineNode (location: (124,7)-(124,15))
        │   │   └── flags: static_literal
        │   └── operator_loc: (124,4)-(124,6) = "in"
        ├── @ MatchPredicateNode (location: (125,0)-(125,19))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (125,0)-(125,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (125,0)-(125,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ SourceEncodingNode (location: (125,7)-(125,19))
        │   │   └── flags: static_literal
        │   └── operator_loc: (125,4)-(125,6) = "in"
        ├── @ MatchPredicateNode (location: (126,0)-(126,17))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (126,0)-(126,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (126,0)-(126,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ LambdaNode (location: (126,7)-(126,17))
        │   │   ├── flags: ∅
        │   │   ├── locals: []
        │   │   ├── operator_loc: (126,7)-(126,9) = "->"
        │   │   ├── opening_loc: (126,10)-(126,11) = "{"
        │   │   ├── closing_loc: (126,16)-(126,17) = "}"
        │   │   ├── parameters: ∅
        │   │   └── body:
        │   │       @ StatementsNode (location: (126,12)-(126,15))
        │   │       ├── flags: ∅
        │   │       └── body: (length: 1)
        │   │           └── @ LocalVariableReadNode (location: (126,12)-(126,15))
        │   │               ├── flags: newline
        │   │               ├── name: :bar
        │   │               └── depth: 1
        │   └── operator_loc: (126,4)-(126,6) = "in"
        ├── @ MatchPredicateNode (location: (127,0)-(127,11))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (127,0)-(127,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (127,0)-(127,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (127,7)-(127,11))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (127,7)-(127,10))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ ImplicitRestNode (location: (127,10)-(127,11))
        │   │   │   └── flags: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (127,4)-(127,6) = "in"
        ├── @ CaseMatchNode (location: (129,0)-(129,25))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (129,5)-(129,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (129,5)-(129,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (129,10)-(129,21))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ LocalVariableTargetNode (location: (129,13)-(129,16))
        │   │       │   ├── flags: ∅
        │   │       │   ├── name: :bar
        │   │       │   └── depth: 0
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (129,10)-(129,12) = "in"
        │   │       └── then_loc: (129,17)-(129,21) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (129,0)-(129,4) = "case"
        │   └── end_keyword_loc: (129,22)-(129,25) = "end"
        ├── @ CaseMatchNode (location: (130,0)-(130,23))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (130,5)-(130,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (130,5)-(130,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (130,10)-(130,19))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IntegerNode (location: (130,13)-(130,14))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 1
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (130,10)-(130,12) = "in"
        │   │       └── then_loc: (130,15)-(130,19) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (130,0)-(130,4) = "case"
        │   └── end_keyword_loc: (130,20)-(130,23) = "end"
        ├── @ CaseMatchNode (location: (131,0)-(131,25))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (131,5)-(131,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (131,5)-(131,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (131,10)-(131,21))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ FloatNode (location: (131,13)-(131,16))
        │   │       │   ├── flags: static_literal
        │   │       │   └── value: 1.0
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (131,10)-(131,12) = "in"
        │   │       └── then_loc: (131,17)-(131,21) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (131,0)-(131,4) = "case"
        │   └── end_keyword_loc: (131,22)-(131,25) = "end"
        ├── @ CaseMatchNode (location: (132,0)-(132,24))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (132,5)-(132,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (132,5)-(132,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (132,10)-(132,20))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ImaginaryNode (location: (132,13)-(132,15))
        │   │       │   ├── flags: static_literal
        │   │       │   └── numeric:
        │   │       │       @ IntegerNode (location: (132,13)-(132,14))
        │   │       │       ├── flags: static_literal, decimal
        │   │       │       └── value: 1
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (132,10)-(132,12) = "in"
        │   │       └── then_loc: (132,16)-(132,20) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (132,0)-(132,4) = "case"
        │   └── end_keyword_loc: (132,21)-(132,24) = "end"
        ├── @ CaseMatchNode (location: (133,0)-(133,24))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (133,5)-(133,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (133,5)-(133,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (133,10)-(133,20))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ RationalNode (location: (133,13)-(133,15))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   ├── numerator: 1
        │   │       │   └── denominator: 1
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (133,10)-(133,12) = "in"
        │   │       └── then_loc: (133,16)-(133,20) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (133,0)-(133,4) = "case"
        │   └── end_keyword_loc: (133,21)-(133,24) = "end"
        ├── @ CaseMatchNode (location: (134,0)-(134,26))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (134,5)-(134,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (134,5)-(134,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (134,10)-(134,22))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ SymbolNode (location: (134,13)-(134,17))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (134,13)-(134,14) = ":"
        │   │       │   ├── value_loc: (134,14)-(134,17) = "foo"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (134,10)-(134,12) = "in"
        │   │       └── then_loc: (134,18)-(134,22) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (134,0)-(134,4) = "case"
        │   └── end_keyword_loc: (134,23)-(134,26) = "end"
        ├── @ CaseMatchNode (location: (135,0)-(135,29))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (135,5)-(135,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (135,5)-(135,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (135,10)-(135,25))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ SymbolNode (location: (135,13)-(135,20))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (135,13)-(135,16) = "%s["
        │   │       │   ├── value_loc: (135,16)-(135,19) = "foo"
        │   │       │   ├── closing_loc: (135,19)-(135,20) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (135,10)-(135,12) = "in"
        │   │       └── then_loc: (135,21)-(135,25) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (135,0)-(135,4) = "case"
        │   └── end_keyword_loc: (135,26)-(135,29) = "end"
        ├── @ CaseMatchNode (location: (136,0)-(136,28))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (136,5)-(136,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (136,5)-(136,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (136,10)-(136,24))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ SymbolNode (location: (136,13)-(136,19))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (136,13)-(136,15) = ":\""
        │   │       │   ├── value_loc: (136,15)-(136,18) = "foo"
        │   │       │   ├── closing_loc: (136,18)-(136,19) = "\""
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (136,10)-(136,12) = "in"
        │   │       └── then_loc: (136,20)-(136,24) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (136,0)-(136,4) = "case"
        │   └── end_keyword_loc: (136,25)-(136,28) = "end"
        ├── @ CaseMatchNode (location: (137,0)-(137,27))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (137,5)-(137,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (137,5)-(137,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (137,10)-(137,23))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ RegularExpressionNode (location: (137,13)-(137,18))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (137,13)-(137,14) = "/"
        │   │       │   ├── content_loc: (137,14)-(137,17) = "foo"
        │   │       │   ├── closing_loc: (137,17)-(137,18) = "/"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (137,10)-(137,12) = "in"
        │   │       └── then_loc: (137,19)-(137,23) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (137,0)-(137,4) = "case"
        │   └── end_keyword_loc: (137,24)-(137,27) = "end"
        ├── @ CaseMatchNode (location: (138,0)-(138,27))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (138,5)-(138,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (138,5)-(138,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (138,10)-(138,23))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ XStringNode (location: (138,13)-(138,18))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (138,13)-(138,14) = "`"
        │   │       │   ├── content_loc: (138,14)-(138,17) = "foo"
        │   │       │   ├── closing_loc: (138,17)-(138,18) = "`"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (138,10)-(138,12) = "in"
        │   │       └── then_loc: (138,19)-(138,23) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (138,0)-(138,4) = "case"
        │   └── end_keyword_loc: (138,24)-(138,27) = "end"
        ├── @ CaseMatchNode (location: (139,0)-(139,29))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (139,5)-(139,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (139,5)-(139,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (139,10)-(139,25))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ XStringNode (location: (139,13)-(139,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (139,13)-(139,16) = "%x["
        │   │       │   ├── content_loc: (139,16)-(139,19) = "foo"
        │   │       │   ├── closing_loc: (139,19)-(139,20) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (139,10)-(139,12) = "in"
        │   │       └── then_loc: (139,21)-(139,25) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (139,0)-(139,4) = "case"
        │   └── end_keyword_loc: (139,26)-(139,29) = "end"
        ├── @ CaseMatchNode (location: (140,0)-(140,29))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (140,5)-(140,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (140,5)-(140,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (140,10)-(140,25))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (140,13)-(140,20))
        │   │       │   ├── flags: static_literal
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ SymbolNode (location: (140,16)-(140,19))
        │   │       │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── value_loc: (140,16)-(140,19) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (140,13)-(140,16) = "%i["
        │   │       │   └── closing_loc: (140,19)-(140,20) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (140,10)-(140,12) = "in"
        │   │       └── then_loc: (140,21)-(140,25) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (140,0)-(140,4) = "case"
        │   └── end_keyword_loc: (140,26)-(140,29) = "end"
        ├── @ CaseMatchNode (location: (141,0)-(141,29))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (141,5)-(141,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (141,5)-(141,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (141,10)-(141,25))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (141,13)-(141,20))
        │   │       │   ├── flags: static_literal
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ SymbolNode (location: (141,16)-(141,19))
        │   │       │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── value_loc: (141,16)-(141,19) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (141,13)-(141,16) = "%I["
        │   │       │   └── closing_loc: (141,19)-(141,20) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (141,10)-(141,12) = "in"
        │   │       └── then_loc: (141,21)-(141,25) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (141,0)-(141,4) = "case"
        │   └── end_keyword_loc: (141,26)-(141,29) = "end"
        ├── @ CaseMatchNode (location: (142,0)-(142,29))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (142,5)-(142,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (142,5)-(142,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (142,10)-(142,25))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (142,13)-(142,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ StringNode (location: (142,16)-(142,19))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (142,16)-(142,19) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (142,13)-(142,16) = "%w["
        │   │       │   └── closing_loc: (142,19)-(142,20) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (142,10)-(142,12) = "in"
        │   │       └── then_loc: (142,21)-(142,25) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (142,0)-(142,4) = "case"
        │   └── end_keyword_loc: (142,26)-(142,29) = "end"
        ├── @ CaseMatchNode (location: (143,0)-(143,29))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (143,5)-(143,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (143,5)-(143,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (143,10)-(143,25))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (143,13)-(143,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ StringNode (location: (143,16)-(143,19))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (143,16)-(143,19) = "foo"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "foo"
        │   │       │   ├── opening_loc: (143,13)-(143,16) = "%W["
        │   │       │   └── closing_loc: (143,19)-(143,20) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (143,10)-(143,12) = "in"
        │   │       └── then_loc: (143,21)-(143,25) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (143,0)-(143,4) = "case"
        │   └── end_keyword_loc: (143,26)-(143,29) = "end"
        ├── @ CaseMatchNode (location: (144,0)-(144,29))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (144,5)-(144,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (144,5)-(144,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (144,10)-(144,25))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ StringNode (location: (144,13)-(144,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (144,13)-(144,16) = "%q["
        │   │       │   ├── content_loc: (144,16)-(144,19) = "foo"
        │   │       │   ├── closing_loc: (144,19)-(144,20) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (144,10)-(144,12) = "in"
        │   │       └── then_loc: (144,21)-(144,25) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (144,0)-(144,4) = "case"
        │   └── end_keyword_loc: (144,26)-(144,29) = "end"
        ├── @ CaseMatchNode (location: (145,0)-(145,29))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (145,5)-(145,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (145,5)-(145,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (145,10)-(145,25))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ StringNode (location: (145,13)-(145,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (145,13)-(145,16) = "%Q["
        │   │       │   ├── content_loc: (145,16)-(145,19) = "foo"
        │   │       │   ├── closing_loc: (145,19)-(145,20) = "]"
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (145,10)-(145,12) = "in"
        │   │       └── then_loc: (145,21)-(145,25) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (145,0)-(145,4) = "case"
        │   └── end_keyword_loc: (145,26)-(145,29) = "end"
        ├── @ CaseMatchNode (location: (146,0)-(146,27))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (146,5)-(146,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (146,5)-(146,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (146,10)-(146,23))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ StringNode (location: (146,13)-(146,18))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (146,13)-(146,14) = "\""
        │   │       │   ├── content_loc: (146,14)-(146,17) = "foo"
        │   │       │   ├── closing_loc: (146,17)-(146,18) = "\""
        │   │       │   └── unescaped: "foo"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (146,10)-(146,12) = "in"
        │   │       └── then_loc: (146,19)-(146,23) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (146,0)-(146,4) = "case"
        │   └── end_keyword_loc: (146,24)-(146,27) = "end"
        ├── @ CaseMatchNode (location: (147,0)-(147,25))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (147,5)-(147,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (147,5)-(147,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (147,10)-(147,21))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ NilNode (location: (147,13)-(147,16))
        │   │       │   └── flags: static_literal
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (147,10)-(147,12) = "in"
        │   │       └── then_loc: (147,17)-(147,21) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (147,0)-(147,4) = "case"
        │   └── end_keyword_loc: (147,22)-(147,25) = "end"
        ├── @ CaseMatchNode (location: (148,0)-(148,26))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (148,5)-(148,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (148,5)-(148,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (148,10)-(148,22))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ SelfNode (location: (148,13)-(148,17))
        │   │       │   └── flags: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (148,10)-(148,12) = "in"
        │   │       └── then_loc: (148,18)-(148,22) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (148,0)-(148,4) = "case"
        │   └── end_keyword_loc: (148,23)-(148,26) = "end"
        ├── @ CaseMatchNode (location: (149,0)-(149,26))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (149,5)-(149,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (149,5)-(149,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (149,10)-(149,22))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ TrueNode (location: (149,13)-(149,17))
        │   │       │   └── flags: static_literal
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (149,10)-(149,12) = "in"
        │   │       └── then_loc: (149,18)-(149,22) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (149,0)-(149,4) = "case"
        │   └── end_keyword_loc: (149,23)-(149,26) = "end"
        ├── @ CaseMatchNode (location: (150,0)-(150,27))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (150,5)-(150,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (150,5)-(150,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (150,10)-(150,23))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ FalseNode (location: (150,13)-(150,18))
        │   │       │   └── flags: static_literal
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (150,10)-(150,12) = "in"
        │   │       └── then_loc: (150,19)-(150,23) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (150,0)-(150,4) = "case"
        │   └── end_keyword_loc: (150,24)-(150,27) = "end"
        ├── @ CaseMatchNode (location: (151,0)-(151,30))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (151,5)-(151,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (151,5)-(151,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (151,10)-(151,26))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ SourceFileNode (location: (151,13)-(151,21))
        │   │       │   ├── flags: ∅
        │   │       │   └── filepath: "patterns.txt"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (151,10)-(151,12) = "in"
        │   │       └── then_loc: (151,22)-(151,26) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (151,0)-(151,4) = "case"
        │   └── end_keyword_loc: (151,27)-(151,30) = "end"
        ├── @ CaseMatchNode (location: (152,0)-(152,30))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (152,5)-(152,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (152,5)-(152,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (152,10)-(152,26))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ SourceLineNode (location: (152,13)-(152,21))
        │   │       │   └── flags: static_literal
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (152,10)-(152,12) = "in"
        │   │       └── then_loc: (152,22)-(152,26) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (152,0)-(152,4) = "case"
        │   └── end_keyword_loc: (152,27)-(152,30) = "end"
        ├── @ CaseMatchNode (location: (153,0)-(153,34))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (153,5)-(153,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (153,5)-(153,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (153,10)-(153,30))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ SourceEncodingNode (location: (153,13)-(153,25))
        │   │       │   └── flags: static_literal
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (153,10)-(153,12) = "in"
        │   │       └── then_loc: (153,26)-(153,30) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (153,0)-(153,4) = "case"
        │   └── end_keyword_loc: (153,31)-(153,34) = "end"
        ├── @ CaseMatchNode (location: (154,0)-(154,32))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (154,5)-(154,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (154,5)-(154,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (154,10)-(154,28))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ LambdaNode (location: (154,13)-(154,23))
        │   │       │   ├── flags: ∅
        │   │       │   ├── locals: []
        │   │       │   ├── operator_loc: (154,13)-(154,15) = "->"
        │   │       │   ├── opening_loc: (154,16)-(154,17) = "{"
        │   │       │   ├── closing_loc: (154,22)-(154,23) = "}"
        │   │       │   ├── parameters: ∅
        │   │       │   └── body:
        │   │       │       @ StatementsNode (location: (154,18)-(154,21))
        │   │       │       ├── flags: ∅
        │   │       │       └── body: (length: 1)
        │   │       │           └── @ LocalVariableReadNode (location: (154,18)-(154,21))
        │   │       │               ├── flags: newline
        │   │       │               ├── name: :bar
        │   │       │               └── depth: 1
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (154,10)-(154,12) = "in"
        │   │       └── then_loc: (154,24)-(154,28) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (154,0)-(154,4) = "case"
        │   └── end_keyword_loc: (154,29)-(154,32) = "end"
        ├── @ CaseMatchNode (location: (156,0)-(156,32))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (156,5)-(156,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (156,5)-(156,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (156,10)-(156,28))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (156,13)-(156,23))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (156,17)-(156,19) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (156,20)-(156,23))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (156,13)-(156,16))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ LocalVariableTargetNode (location: (156,13)-(156,16))
        │   │       │   │           ├── flags: newline
        │   │       │   │           ├── name: :bar
        │   │       │   │           └── depth: 0
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (156,10)-(156,12) = "in"
        │   │       └── then_loc: (156,24)-(156,28) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (156,0)-(156,4) = "case"
        │   └── end_keyword_loc: (156,29)-(156,32) = "end"
        ├── @ CaseMatchNode (location: (157,0)-(157,30))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (157,5)-(157,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (157,5)-(157,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (157,10)-(157,26))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (157,13)-(157,21))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (157,15)-(157,17) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (157,18)-(157,21))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (157,13)-(157,14))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ IntegerNode (location: (157,13)-(157,14))
        │   │       │   │           ├── flags: newline, static_literal, decimal
        │   │       │   │           └── value: 1
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (157,10)-(157,12) = "in"
        │   │       └── then_loc: (157,22)-(157,26) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (157,0)-(157,4) = "case"
        │   └── end_keyword_loc: (157,27)-(157,30) = "end"
        ├── @ CaseMatchNode (location: (158,0)-(158,32))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (158,5)-(158,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (158,5)-(158,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (158,10)-(158,28))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (158,13)-(158,23))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (158,17)-(158,19) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (158,20)-(158,23))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (158,13)-(158,16))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ FloatNode (location: (158,13)-(158,16))
        │   │       │   │           ├── flags: newline, static_literal
        │   │       │   │           └── value: 1.0
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (158,10)-(158,12) = "in"
        │   │       └── then_loc: (158,24)-(158,28) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (158,0)-(158,4) = "case"
        │   └── end_keyword_loc: (158,29)-(158,32) = "end"
        ├── @ CaseMatchNode (location: (159,0)-(159,31))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (159,5)-(159,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (159,5)-(159,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (159,10)-(159,27))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (159,13)-(159,22))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (159,16)-(159,18) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (159,19)-(159,22))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (159,13)-(159,15))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ImaginaryNode (location: (159,13)-(159,15))
        │   │       │   │           ├── flags: newline, static_literal
        │   │       │   │           └── numeric:
        │   │       │   │               @ IntegerNode (location: (159,13)-(159,14))
        │   │       │   │               ├── flags: static_literal, decimal
        │   │       │   │               └── value: 1
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (159,10)-(159,12) = "in"
        │   │       └── then_loc: (159,23)-(159,27) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (159,0)-(159,4) = "case"
        │   └── end_keyword_loc: (159,28)-(159,31) = "end"
        ├── @ CaseMatchNode (location: (160,0)-(160,31))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (160,5)-(160,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (160,5)-(160,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (160,10)-(160,27))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (160,13)-(160,22))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (160,16)-(160,18) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (160,19)-(160,22))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (160,13)-(160,15))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ RationalNode (location: (160,13)-(160,15))
        │   │       │   │           ├── flags: newline, static_literal, decimal
        │   │       │   │           ├── numerator: 1
        │   │       │   │           └── denominator: 1
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (160,10)-(160,12) = "in"
        │   │       └── then_loc: (160,23)-(160,27) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (160,0)-(160,4) = "case"
        │   └── end_keyword_loc: (160,28)-(160,31) = "end"
        ├── @ CaseMatchNode (location: (161,0)-(161,33))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (161,5)-(161,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (161,5)-(161,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (161,10)-(161,29))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (161,13)-(161,24))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (161,18)-(161,20) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (161,21)-(161,24))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (161,13)-(161,17))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SymbolNode (location: (161,13)-(161,17))
        │   │       │   │           ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   │       │   │           ├── opening_loc: (161,13)-(161,14) = ":"
        │   │       │   │           ├── value_loc: (161,14)-(161,17) = "foo"
        │   │       │   │           ├── closing_loc: ∅
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (161,10)-(161,12) = "in"
        │   │       └── then_loc: (161,25)-(161,29) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (161,0)-(161,4) = "case"
        │   └── end_keyword_loc: (161,30)-(161,33) = "end"
        ├── @ CaseMatchNode (location: (162,0)-(162,36))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (162,5)-(162,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (162,5)-(162,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (162,10)-(162,32))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (162,13)-(162,27))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (162,21)-(162,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (162,24)-(162,27))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (162,13)-(162,20))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SymbolNode (location: (162,13)-(162,20))
        │   │       │   │           ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   │       │   │           ├── opening_loc: (162,13)-(162,16) = "%s["
        │   │       │   │           ├── value_loc: (162,16)-(162,19) = "foo"
        │   │       │   │           ├── closing_loc: (162,19)-(162,20) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (162,10)-(162,12) = "in"
        │   │       └── then_loc: (162,28)-(162,32) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (162,0)-(162,4) = "case"
        │   └── end_keyword_loc: (162,33)-(162,36) = "end"
        ├── @ CaseMatchNode (location: (163,0)-(163,35))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (163,5)-(163,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (163,5)-(163,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (163,10)-(163,31))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (163,13)-(163,26))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (163,20)-(163,22) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (163,23)-(163,26))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (163,13)-(163,19))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SymbolNode (location: (163,13)-(163,19))
        │   │       │   │           ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   │       │   │           ├── opening_loc: (163,13)-(163,15) = ":\""
        │   │       │   │           ├── value_loc: (163,15)-(163,18) = "foo"
        │   │       │   │           ├── closing_loc: (163,18)-(163,19) = "\""
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (163,10)-(163,12) = "in"
        │   │       └── then_loc: (163,27)-(163,31) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (163,0)-(163,4) = "case"
        │   └── end_keyword_loc: (163,32)-(163,35) = "end"
        ├── @ CaseMatchNode (location: (164,0)-(164,34))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (164,5)-(164,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (164,5)-(164,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (164,10)-(164,30))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (164,13)-(164,25))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (164,19)-(164,21) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (164,22)-(164,25))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (164,13)-(164,18))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ RegularExpressionNode (location: (164,13)-(164,18))
        │   │       │   │           ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   │       │   │           ├── opening_loc: (164,13)-(164,14) = "/"
        │   │       │   │           ├── content_loc: (164,14)-(164,17) = "foo"
        │   │       │   │           ├── closing_loc: (164,17)-(164,18) = "/"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (164,10)-(164,12) = "in"
        │   │       └── then_loc: (164,26)-(164,30) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (164,0)-(164,4) = "case"
        │   └── end_keyword_loc: (164,31)-(164,34) = "end"
        ├── @ CaseMatchNode (location: (165,0)-(165,34))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (165,5)-(165,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (165,5)-(165,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (165,10)-(165,30))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (165,13)-(165,25))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (165,19)-(165,21) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (165,22)-(165,25))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (165,13)-(165,18))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ XStringNode (location: (165,13)-(165,18))
        │   │       │   │           ├── flags: newline
        │   │       │   │           ├── opening_loc: (165,13)-(165,14) = "`"
        │   │       │   │           ├── content_loc: (165,14)-(165,17) = "foo"
        │   │       │   │           ├── closing_loc: (165,17)-(165,18) = "`"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (165,10)-(165,12) = "in"
        │   │       └── then_loc: (165,26)-(165,30) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (165,0)-(165,4) = "case"
        │   └── end_keyword_loc: (165,31)-(165,34) = "end"
        ├── @ CaseMatchNode (location: (166,0)-(166,36))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (166,5)-(166,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (166,5)-(166,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (166,10)-(166,32))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (166,13)-(166,27))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (166,21)-(166,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (166,24)-(166,27))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (166,13)-(166,20))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ XStringNode (location: (166,13)-(166,20))
        │   │       │   │           ├── flags: newline
        │   │       │   │           ├── opening_loc: (166,13)-(166,16) = "%x["
        │   │       │   │           ├── content_loc: (166,16)-(166,19) = "foo"
        │   │       │   │           ├── closing_loc: (166,19)-(166,20) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (166,10)-(166,12) = "in"
        │   │       └── then_loc: (166,28)-(166,32) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (166,0)-(166,4) = "case"
        │   └── end_keyword_loc: (166,33)-(166,36) = "end"
        ├── @ CaseMatchNode (location: (167,0)-(167,36))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (167,5)-(167,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (167,5)-(167,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (167,10)-(167,32))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (167,13)-(167,27))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (167,21)-(167,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (167,24)-(167,27))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (167,13)-(167,20))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (167,13)-(167,20))
        │   │       │   │           ├── flags: newline, static_literal
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ SymbolNode (location: (167,16)-(167,19))
        │   │       │   │           │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── value_loc: (167,16)-(167,19) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (167,13)-(167,16) = "%i["
        │   │       │   │           └── closing_loc: (167,19)-(167,20) = "]"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (167,10)-(167,12) = "in"
        │   │       └── then_loc: (167,28)-(167,32) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (167,0)-(167,4) = "case"
        │   └── end_keyword_loc: (167,33)-(167,36) = "end"
        ├── @ CaseMatchNode (location: (168,0)-(168,36))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (168,5)-(168,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (168,5)-(168,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (168,10)-(168,32))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (168,13)-(168,27))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (168,21)-(168,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (168,24)-(168,27))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (168,13)-(168,20))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (168,13)-(168,20))
        │   │       │   │           ├── flags: newline, static_literal
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ SymbolNode (location: (168,16)-(168,19))
        │   │       │   │           │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── value_loc: (168,16)-(168,19) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (168,13)-(168,16) = "%I["
        │   │       │   │           └── closing_loc: (168,19)-(168,20) = "]"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (168,10)-(168,12) = "in"
        │   │       └── then_loc: (168,28)-(168,32) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (168,0)-(168,4) = "case"
        │   └── end_keyword_loc: (168,33)-(168,36) = "end"
        ├── @ CaseMatchNode (location: (169,0)-(169,36))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (169,5)-(169,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (169,5)-(169,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (169,10)-(169,32))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (169,13)-(169,27))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (169,21)-(169,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (169,24)-(169,27))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (169,13)-(169,20))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (169,13)-(169,20))
        │   │       │   │           ├── flags: newline
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ StringNode (location: (169,16)-(169,19))
        │   │       │   │           │       ├── flags: ∅
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── content_loc: (169,16)-(169,19) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (169,13)-(169,16) = "%w["
        │   │       │   │           └── closing_loc: (169,19)-(169,20) = "]"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (169,10)-(169,12) = "in"
        │   │       └── then_loc: (169,28)-(169,32) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (169,0)-(169,4) = "case"
        │   └── end_keyword_loc: (169,33)-(169,36) = "end"
        ├── @ CaseMatchNode (location: (170,0)-(170,36))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (170,5)-(170,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (170,5)-(170,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (170,10)-(170,32))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (170,13)-(170,27))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (170,21)-(170,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (170,24)-(170,27))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (170,13)-(170,20))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ ArrayNode (location: (170,13)-(170,20))
        │   │       │   │           ├── flags: newline
        │   │       │   │           ├── elements: (length: 1)
        │   │       │   │           │   └── @ StringNode (location: (170,16)-(170,19))
        │   │       │   │           │       ├── flags: ∅
        │   │       │   │           │       ├── opening_loc: ∅
        │   │       │   │           │       ├── content_loc: (170,16)-(170,19) = "foo"
        │   │       │   │           │       ├── closing_loc: ∅
        │   │       │   │           │       └── unescaped: "foo"
        │   │       │   │           ├── opening_loc: (170,13)-(170,16) = "%W["
        │   │       │   │           └── closing_loc: (170,19)-(170,20) = "]"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (170,10)-(170,12) = "in"
        │   │       └── then_loc: (170,28)-(170,32) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (170,0)-(170,4) = "case"
        │   └── end_keyword_loc: (170,33)-(170,36) = "end"
        ├── @ CaseMatchNode (location: (171,0)-(171,36))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (171,5)-(171,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (171,5)-(171,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (171,10)-(171,32))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (171,13)-(171,27))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (171,21)-(171,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (171,24)-(171,27))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (171,13)-(171,20))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ StringNode (location: (171,13)-(171,20))
        │   │       │   │           ├── flags: newline
        │   │       │   │           ├── opening_loc: (171,13)-(171,16) = "%q["
        │   │       │   │           ├── content_loc: (171,16)-(171,19) = "foo"
        │   │       │   │           ├── closing_loc: (171,19)-(171,20) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (171,10)-(171,12) = "in"
        │   │       └── then_loc: (171,28)-(171,32) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (171,0)-(171,4) = "case"
        │   └── end_keyword_loc: (171,33)-(171,36) = "end"
        ├── @ CaseMatchNode (location: (172,0)-(172,36))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (172,5)-(172,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (172,5)-(172,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (172,10)-(172,32))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (172,13)-(172,27))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (172,21)-(172,23) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (172,24)-(172,27))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (172,13)-(172,20))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ StringNode (location: (172,13)-(172,20))
        │   │       │   │           ├── flags: newline
        │   │       │   │           ├── opening_loc: (172,13)-(172,16) = "%Q["
        │   │       │   │           ├── content_loc: (172,16)-(172,19) = "foo"
        │   │       │   │           ├── closing_loc: (172,19)-(172,20) = "]"
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (172,10)-(172,12) = "in"
        │   │       └── then_loc: (172,28)-(172,32) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (172,0)-(172,4) = "case"
        │   └── end_keyword_loc: (172,33)-(172,36) = "end"
        ├── @ CaseMatchNode (location: (173,0)-(173,34))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (173,5)-(173,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (173,5)-(173,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (173,10)-(173,30))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (173,13)-(173,25))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (173,19)-(173,21) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (173,22)-(173,25))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (173,13)-(173,18))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ StringNode (location: (173,13)-(173,18))
        │   │       │   │           ├── flags: newline
        │   │       │   │           ├── opening_loc: (173,13)-(173,14) = "\""
        │   │       │   │           ├── content_loc: (173,14)-(173,17) = "foo"
        │   │       │   │           ├── closing_loc: (173,17)-(173,18) = "\""
        │   │       │   │           └── unescaped: "foo"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (173,10)-(173,12) = "in"
        │   │       └── then_loc: (173,26)-(173,30) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (173,0)-(173,4) = "case"
        │   └── end_keyword_loc: (173,31)-(173,34) = "end"
        ├── @ CaseMatchNode (location: (174,0)-(174,32))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (174,5)-(174,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (174,5)-(174,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (174,10)-(174,28))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (174,13)-(174,23))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (174,17)-(174,19) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (174,20)-(174,23))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (174,13)-(174,16))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ NilNode (location: (174,13)-(174,16))
        │   │       │   │           └── flags: newline, static_literal
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (174,10)-(174,12) = "in"
        │   │       └── then_loc: (174,24)-(174,28) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (174,0)-(174,4) = "case"
        │   └── end_keyword_loc: (174,29)-(174,32) = "end"
        ├── @ CaseMatchNode (location: (175,0)-(175,33))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (175,5)-(175,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (175,5)-(175,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (175,10)-(175,29))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (175,13)-(175,24))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (175,18)-(175,20) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (175,21)-(175,24))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (175,13)-(175,17))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SelfNode (location: (175,13)-(175,17))
        │   │       │   │           └── flags: newline
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (175,10)-(175,12) = "in"
        │   │       └── then_loc: (175,25)-(175,29) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (175,0)-(175,4) = "case"
        │   └── end_keyword_loc: (175,30)-(175,33) = "end"
        ├── @ CaseMatchNode (location: (176,0)-(176,33))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (176,5)-(176,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (176,5)-(176,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (176,10)-(176,29))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (176,13)-(176,24))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (176,18)-(176,20) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (176,21)-(176,24))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (176,13)-(176,17))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ TrueNode (location: (176,13)-(176,17))
        │   │       │   │           └── flags: newline, static_literal
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (176,10)-(176,12) = "in"
        │   │       └── then_loc: (176,25)-(176,29) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (176,0)-(176,4) = "case"
        │   └── end_keyword_loc: (176,30)-(176,33) = "end"
        ├── @ CaseMatchNode (location: (177,0)-(177,34))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (177,5)-(177,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (177,5)-(177,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (177,10)-(177,30))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (177,13)-(177,25))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (177,19)-(177,21) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (177,22)-(177,25))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (177,13)-(177,18))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ FalseNode (location: (177,13)-(177,18))
        │   │       │   │           └── flags: newline, static_literal
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (177,10)-(177,12) = "in"
        │   │       └── then_loc: (177,26)-(177,30) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (177,0)-(177,4) = "case"
        │   └── end_keyword_loc: (177,31)-(177,34) = "end"
        ├── @ CaseMatchNode (location: (178,0)-(178,37))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (178,5)-(178,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (178,5)-(178,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (178,10)-(178,33))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (178,13)-(178,28))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (178,22)-(178,24) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (178,25)-(178,28))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (178,13)-(178,21))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SourceFileNode (location: (178,13)-(178,21))
        │   │       │   │           ├── flags: newline
        │   │       │   │           └── filepath: "patterns.txt"
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (178,10)-(178,12) = "in"
        │   │       └── then_loc: (178,29)-(178,33) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (178,0)-(178,4) = "case"
        │   └── end_keyword_loc: (178,34)-(178,37) = "end"
        ├── @ CaseMatchNode (location: (179,0)-(179,37))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (179,5)-(179,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (179,5)-(179,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (179,10)-(179,33))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (179,13)-(179,28))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (179,22)-(179,24) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (179,25)-(179,28))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (179,13)-(179,21))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SourceLineNode (location: (179,13)-(179,21))
        │   │       │   │           └── flags: newline, static_literal
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (179,10)-(179,12) = "in"
        │   │       └── then_loc: (179,29)-(179,33) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (179,0)-(179,4) = "case"
        │   └── end_keyword_loc: (179,34)-(179,37) = "end"
        ├── @ CaseMatchNode (location: (180,0)-(180,41))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (180,5)-(180,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (180,5)-(180,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (180,10)-(180,37))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (180,13)-(180,32))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (180,26)-(180,28) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (180,29)-(180,32))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (180,13)-(180,25))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ SourceEncodingNode (location: (180,13)-(180,25))
        │   │       │   │           └── flags: newline, static_literal
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (180,10)-(180,12) = "in"
        │   │       └── then_loc: (180,33)-(180,37) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (180,0)-(180,4) = "case"
        │   └── end_keyword_loc: (180,38)-(180,41) = "end"
        ├── @ CaseMatchNode (location: (181,0)-(181,39))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (181,5)-(181,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (181,5)-(181,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (181,10)-(181,35))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (181,13)-(181,30))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (181,24)-(181,26) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ LocalVariableReadNode (location: (181,27)-(181,30))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :baz
        │   │       │   │   └── depth: 0
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (181,13)-(181,23))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ LambdaNode (location: (181,13)-(181,23))
        │   │       │   │           ├── flags: newline
        │   │       │   │           ├── locals: []
        │   │       │   │           ├── operator_loc: (181,13)-(181,15) = "->"
        │   │       │   │           ├── opening_loc: (181,16)-(181,17) = "{"
        │   │       │   │           ├── closing_loc: (181,22)-(181,23) = "}"
        │   │       │   │           ├── parameters: ∅
        │   │       │   │           └── body:
        │   │       │   │               @ StatementsNode (location: (181,18)-(181,21))
        │   │       │   │               ├── flags: ∅
        │   │       │   │               └── body: (length: 1)
        │   │       │   │                   └── @ LocalVariableReadNode (location: (181,18)-(181,21))
        │   │       │   │                       ├── flags: newline
        │   │       │   │                       ├── name: :bar
        │   │       │   │                       └── depth: 1
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (181,10)-(181,12) = "in"
        │   │       └── then_loc: (181,31)-(181,35) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (181,0)-(181,4) = "case"
        │   └── end_keyword_loc: (181,36)-(181,39) = "end"
        ├── @ IfNode (location: (183,0)-(184,3))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (183,0)-(183,2) = "if"
        │   ├── predicate:
        │   │   @ MatchPredicateNode (location: (183,3)-(183,10))
        │   │   ├── flags: ∅
        │   │   ├── value:
        │   │   │   @ CallNode (location: (183,3)-(183,4))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :a
        │   │   │   ├── message_loc: (183,3)-(183,4) = "a"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── pattern:
        │   │   │   @ ArrayPatternNode (location: (183,8)-(183,10))
        │   │   │   ├── flags: ∅
        │   │   │   ├── constant: ∅
        │   │   │   ├── requireds: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── opening_loc: (183,8)-(183,9) = "["
        │   │   │   └── closing_loc: (183,9)-(183,10) = "]"
        │   │   └── operator_loc: (183,5)-(183,7) = "in"
        │   ├── then_keyword_loc: ∅
        │   ├── statements: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (184,0)-(184,3) = "end"
        ├── @ MatchRequiredNode (location: (186,0)-(188,1))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (186,0)-(186,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (186,0)-(186,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (186,5)-(188,1))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (187,2)-(187,3))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :b
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (186,5)-(186,6) = "["
        │   │   └── closing_loc: (188,0)-(188,1) = "]"
        │   └── operator_loc: (186,2)-(186,4) = "=>"
        ├── @ MatchPredicateNode (location: (190,0)-(194,1))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (190,0)-(190,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (190,0)-(190,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ HashPatternNode (location: (190,7)-(194,1))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (190,7)-(190,8))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :A
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (191,2)-(193,3))
        │   │   │       ├── flags: ∅
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (191,2)-(191,6))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (191,2)-(191,5) = "bar"
        │   │   │       │   ├── closing_loc: (191,5)-(191,6) = ":"
        │   │   │       │   └── unescaped: "bar"
        │   │   │       ├── value:
        │   │   │       │   @ HashPatternNode (location: (191,7)-(193,3))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   ├── constant:
        │   │   │       │   │   @ ConstantReadNode (location: (191,7)-(191,8))
        │   │   │       │   │   ├── flags: ∅
        │   │   │       │   │   └── name: :B
        │   │   │       │   ├── elements: (length: 1)
        │   │   │       │   │   └── @ AssocNode (location: (192,4)-(192,12))
        │   │   │       │   │       ├── flags: ∅
        │   │   │       │   │       ├── key:
        │   │   │       │   │       │   @ SymbolNode (location: (192,4)-(192,10))
        │   │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   │       │   ├── opening_loc: ∅
        │   │   │       │   │       │   ├── value_loc: (192,4)-(192,9) = "value"
        │   │   │       │   │       │   ├── closing_loc: (192,9)-(192,10) = ":"
        │   │   │       │   │       │   └── unescaped: "value"
        │   │   │       │   │       ├── value:
        │   │   │       │   │       │   @ LocalVariableTargetNode (location: (192,11)-(192,12))
        │   │   │       │   │       │   ├── flags: ∅
        │   │   │       │   │       │   ├── name: :a
        │   │   │       │   │       │   └── depth: 0
        │   │   │       │   │       └── operator_loc: ∅
        │   │   │       │   ├── rest: ∅
        │   │   │       │   ├── opening_loc: (191,8)-(191,9) = "["
        │   │   │       │   └── closing_loc: (193,2)-(193,3) = "]"
        │   │   │       └── operator_loc: ∅
        │   │   ├── rest: ∅
        │   │   ├── opening_loc: (190,8)-(190,9) = "["
        │   │   └── closing_loc: (194,0)-(194,1) = "]"
        │   └── operator_loc: (190,4)-(190,6) = "in"
        ├── @ MatchPredicateNode (location: (196,0)-(196,17))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (196,0)-(196,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (196,0)-(196,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ CapturePatternNode (location: (196,7)-(196,17))
        │   │   ├── flags: ∅
        │   │   ├── value:
        │   │   │   @ LocalVariableTargetNode (location: (196,7)-(196,10))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   ├── target:
        │   │   │   @ LocalVariableTargetNode (location: (196,14)-(196,17))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :baz
        │   │   │   └── depth: 0
        │   │   └── operator_loc: (196,11)-(196,13) = "=>"
        │   └── operator_loc: (196,4)-(196,6) = "in"
        ├── @ MatchRequiredNode (location: (197,0)-(197,17))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ CallNode (location: (197,0)-(197,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (197,0)-(197,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── pattern:
        │   │   @ CapturePatternNode (location: (197,7)-(197,17))
        │   │   ├── flags: ∅
        │   │   ├── value:
        │   │   │   @ LocalVariableTargetNode (location: (197,7)-(197,10))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   ├── target:
        │   │   │   @ LocalVariableTargetNode (location: (197,14)-(197,17))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :baz
        │   │   │   └── depth: 0
        │   │   └── operator_loc: (197,11)-(197,13) = "=>"
        │   └── operator_loc: (197,4)-(197,6) = "=>"
        ├── @ MultiWriteNode (location: (199,0)-(199,20))
        │   ├── flags: newline
        │   ├── lefts: (length: 3)
        │   │   ├── @ LocalVariableTargetNode (location: (199,0)-(199,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :foo
        │   │   │   └── depth: 0
        │   │   ├── @ LocalVariableTargetNode (location: (199,5)-(199,8))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   └── @ LocalVariableTargetNode (location: (199,10)-(199,13))
        │   │       ├── flags: ∅
        │   │       ├── name: :baz
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (199,14)-(199,15) = "="
        │   └── value:
        │       @ ArrayNode (location: (199,16)-(199,20))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (199,16)-(199,17))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (199,19)-(199,20))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: ∅
        │       └── closing_loc: ∅
        ├── @ CallNode (location: (200,0)-(202,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (200,0)-(200,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (200,4)-(202,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (201,2)-(201,29))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ MatchRequiredNode (location: (201,2)-(201,29))
        │       │           ├── flags: newline
        │       │           ├── value:
        │       │           │   @ ArrayNode (location: (201,2)-(201,8))
        │       │           │   ├── flags: static_literal
        │       │           │   ├── elements: (length: 2)
        │       │           │   │   ├── @ IntegerNode (location: (201,3)-(201,4))
        │       │           │   │   │   ├── flags: static_literal, decimal
        │       │           │   │   │   └── value: 1
        │       │           │   │   └── @ IntegerNode (location: (201,6)-(201,7))
        │       │           │   │       ├── flags: static_literal, decimal
        │       │           │   │       └── value: 2
        │       │           │   ├── opening_loc: (201,2)-(201,3) = "["
        │       │           │   └── closing_loc: (201,7)-(201,8) = "]"
        │       │           ├── pattern:
        │       │           │   @ CapturePatternNode (location: (201,12)-(201,29))
        │       │           │   ├── flags: ∅
        │       │           │   ├── value:
        │       │           │   │   @ ArrayPatternNode (location: (201,12)-(201,22))
        │       │           │   │   ├── flags: ∅
        │       │           │   │   ├── constant: ∅
        │       │           │   │   ├── requireds: (length: 2)
        │       │           │   │   │   ├── @ LocalVariableTargetNode (location: (201,13)-(201,16))
        │       │           │   │   │   │   ├── flags: ∅
        │       │           │   │   │   │   ├── name: :foo
        │       │           │   │   │   │   └── depth: 1
        │       │           │   │   │   └── @ LocalVariableTargetNode (location: (201,18)-(201,21))
        │       │           │   │   │       ├── flags: ∅
        │       │           │   │   │       ├── name: :bar
        │       │           │   │   │       └── depth: 1
        │       │           │   │   ├── rest: ∅
        │       │           │   │   ├── posts: (length: 0)
        │       │           │   │   ├── opening_loc: (201,12)-(201,13) = "["
        │       │           │   │   └── closing_loc: (201,21)-(201,22) = "]"
        │       │           │   ├── target:
        │       │           │   │   @ LocalVariableTargetNode (location: (201,26)-(201,29))
        │       │           │   │   ├── flags: ∅
        │       │           │   │   ├── name: :baz
        │       │           │   │   └── depth: 1
        │       │           │   └── operator_loc: (201,23)-(201,25) = "=>"
        │       │           └── operator_loc: (201,9)-(201,11) = "=>"
        │       ├── opening_loc: (200,4)-(200,6) = "do"
        │       └── closing_loc: (202,0)-(202,3) = "end"
        ├── @ MatchRequiredNode (location: (204,0)-(204,19))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ LocalVariableReadNode (location: (204,0)-(204,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (204,7)-(204,19))
        │   │   ├── flags: ∅
        │   │   ├── constant:
        │   │   │   @ ConstantReadNode (location: (204,7)-(204,13))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :Object
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ HashPatternNode (location: (204,14)-(204,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── constant: ∅
        │   │   │       ├── elements: (length: 1)
        │   │   │       │   └── @ AssocNode (location: (204,15)-(204,17))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       ├── key:
        │   │   │       │       │   @ SymbolNode (location: (204,15)-(204,17))
        │   │   │       │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │       │   ├── opening_loc: ∅
        │   │   │       │       │   ├── value_loc: (204,15)-(204,16) = "x"
        │   │   │       │       │   ├── closing_loc: (204,16)-(204,17) = ":"
        │   │   │       │       │   └── unescaped: "x"
        │   │   │       │       ├── value:
        │   │   │       │       │   @ ImplicitNode (location: (204,15)-(204,16))
        │   │   │       │       │   ├── flags: ∅
        │   │   │       │       │   └── value:
        │   │   │       │       │       @ LocalVariableTargetNode (location: (204,15)-(204,16))
        │   │   │       │       │       ├── flags: ∅
        │   │   │       │       │       ├── name: :x
        │   │   │       │       │       └── depth: 0
        │   │   │       │       └── operator_loc: ∅
        │   │   │       ├── rest: ∅
        │   │   │       ├── opening_loc: (204,14)-(204,15) = "{"
        │   │   │       └── closing_loc: (204,17)-(204,18) = "}"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (204,13)-(204,14) = "["
        │   │   └── closing_loc: (204,18)-(204,19) = "]"
        │   └── operator_loc: (204,4)-(204,6) = "=>"
        ├── @ CallNode (location: (206,0)-(206,19))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (206,0)-(206,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: (206,1)-(206,2) = "."
        │   ├── name: :then
        │   ├── message_loc: (206,2)-(206,6) = "then"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (206,7)-(206,19))
        │       ├── flags: ∅
        │       ├── locals: [:_1]
        │       ├── parameters:
        │       │   @ NumberedParametersNode (location: (206,7)-(206,19))
        │       │   ├── flags: ∅
        │       │   └── maximum: 1
        │       ├── body:
        │       │   @ StatementsNode (location: (206,9)-(206,17))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ MatchPredicateNode (location: (206,9)-(206,17))
        │       │           ├── flags: newline
        │       │           ├── value:
        │       │           │   @ IntegerNode (location: (206,9)-(206,10))
        │       │           │   ├── flags: static_literal, decimal
        │       │           │   └── value: 1
        │       │           ├── pattern:
        │       │           │   @ PinnedVariableNode (location: (206,14)-(206,17))
        │       │           │   ├── flags: ∅
        │       │           │   ├── variable:
        │       │           │   │   @ LocalVariableReadNode (location: (206,15)-(206,17))
        │       │           │   │   ├── flags: ∅
        │       │           │   │   ├── name: :_1
        │       │           │   │   └── depth: 0
        │       │           │   └── operator_loc: (206,14)-(206,15) = "^"
        │       │           └── operator_loc: (206,11)-(206,13) = "in"
        │       ├── opening_loc: (206,7)-(206,8) = "{"
        │       └── closing_loc: (206,18)-(206,19) = "}"
        ├── @ MultiWriteNode (location: (208,0)-(211,5))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ LocalVariableTargetNode (location: (209,2)-(209,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :a
        │   │   │   └── depth: 0
        │   │   └── @ LocalVariableTargetNode (location: (210,2)-(210,3))
        │   │       ├── flags: ∅
        │   │       ├── name: :b
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (208,0)-(208,1) = "("
        │   ├── rparen_loc: (211,0)-(211,1) = ")"
        │   ├── operator_loc: (211,2)-(211,3) = "="
        │   └── value:
        │       @ CallNode (location: (211,4)-(211,5))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :c
        │       ├── message_loc: (211,4)-(211,5) = "c"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ CaseMatchNode (location: (213,0)-(213,25))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ ParenthesesNode (location: (213,5)-(213,7))
        │   │   ├── flags: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (213,5)-(213,6) = "("
        │   │   └── closing_loc: (213,6)-(213,7) = ")"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (213,9)-(213,20))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (213,12)-(213,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ LocalVariableTargetNode (location: (213,13)-(213,15))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── name: :_a
        │   │       │   │   │   └── depth: 0
        │   │       │   │   └── @ LocalVariableTargetNode (location: (213,17)-(213,19))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :_a
        │   │       │   │       └── depth: 0
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (213,12)-(213,13) = "["
        │   │       │   └── closing_loc: (213,19)-(213,20) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (213,9)-(213,11) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (213,0)-(213,4) = "case"
        │   └── end_keyword_loc: (213,22)-(213,25) = "end"
        ├── @ CaseMatchNode (location: (214,0)-(214,31))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ ParenthesesNode (location: (214,5)-(214,7))
        │   │   ├── flags: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (214,5)-(214,6) = "("
        │   │   └── closing_loc: (214,6)-(214,7) = ")"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (214,9)-(214,26))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (214,12)-(214,26))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ HashPatternNode (location: (214,13)-(214,18))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── constant: ∅
        │   │       │   │   │   ├── elements: (length: 1)
        │   │       │   │   │   │   └── @ AssocNode (location: (214,14)-(214,17))
        │   │       │   │   │   │       ├── flags: static_literal
        │   │       │   │   │   │       ├── key:
        │   │       │   │   │   │       │   @ SymbolNode (location: (214,14)-(214,16))
        │   │       │   │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   │       │   ├── opening_loc: ∅
        │   │       │   │   │   │       │   ├── value_loc: (214,14)-(214,15) = "a"
        │   │       │   │   │   │       │   ├── closing_loc: (214,15)-(214,16) = ":"
        │   │       │   │   │   │       │   └── unescaped: "a"
        │   │       │   │   │   │       ├── value:
        │   │       │   │   │   │       │   @ IntegerNode (location: (214,16)-(214,17))
        │   │       │   │   │   │       │   ├── flags: static_literal, decimal
        │   │       │   │   │   │       │   └── value: 1
        │   │       │   │   │   │       └── operator_loc: ∅
        │   │       │   │   │   ├── rest: ∅
        │   │       │   │   │   ├── opening_loc: (214,13)-(214,14) = "{"
        │   │       │   │   │   └── closing_loc: (214,17)-(214,18) = "}"
        │   │       │   │   └── @ HashPatternNode (location: (214,20)-(214,25))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── constant: ∅
        │   │       │   │       ├── elements: (length: 1)
        │   │       │   │       │   └── @ AssocNode (location: (214,21)-(214,24))
        │   │       │   │       │       ├── flags: static_literal
        │   │       │   │       │       ├── key:
        │   │       │   │       │       │   @ SymbolNode (location: (214,21)-(214,23))
        │   │       │   │       │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │       │   ├── opening_loc: ∅
        │   │       │   │       │       │   ├── value_loc: (214,21)-(214,22) = "a"
        │   │       │   │       │       │   ├── closing_loc: (214,22)-(214,23) = ":"
        │   │       │   │       │       │   └── unescaped: "a"
        │   │       │   │       │       ├── value:
        │   │       │   │       │       │   @ IntegerNode (location: (214,23)-(214,24))
        │   │       │   │       │       │   ├── flags: static_literal, decimal
        │   │       │   │       │       │   └── value: 2
        │   │       │   │       │       └── operator_loc: ∅
        │   │       │   │       ├── rest: ∅
        │   │       │   │       ├── opening_loc: (214,20)-(214,21) = "{"
        │   │       │   │       └── closing_loc: (214,24)-(214,25) = "}"
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (214,12)-(214,13) = "["
        │   │       │   └── closing_loc: (214,25)-(214,26) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (214,9)-(214,11) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (214,0)-(214,4) = "case"
        │   └── end_keyword_loc: (214,28)-(214,31) = "end"
        ├── @ MatchRequiredNode (location: (215,0)-(215,20))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ LocalVariableReadNode (location: (215,0)-(215,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (215,5)-(215,20))
        │   │   ├── flags: ∅
        │   │   ├── expression:
        │   │   │   @ HashNode (location: (215,7)-(215,19))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (215,7)-(215,8) = "{"
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ AssocNode (location: (215,8)-(215,18))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── key:
        │   │   │   │       │   @ StringNode (location: (215,8)-(215,11))
        │   │   │   │       │   ├── flags: static_literal, frozen
        │   │   │   │       │   ├── opening_loc: (215,8)-(215,9) = "'"
        │   │   │   │       │   ├── content_loc: (215,9)-(215,10) = "a"
        │   │   │   │       │   ├── closing_loc: (215,10)-(215,11) = "'"
        │   │   │   │       │   └── unescaped: "a"
        │   │   │   │       ├── value:
        │   │   │   │       │   @ StringNode (location: (215,15)-(215,18))
        │   │   │   │       │   ├── flags: ∅
        │   │   │   │       │   ├── opening_loc: (215,15)-(215,16) = "'"
        │   │   │   │       │   ├── content_loc: (215,16)-(215,17) = "b"
        │   │   │   │       │   ├── closing_loc: (215,17)-(215,18) = "'"
        │   │   │   │       │   └── unescaped: "b"
        │   │   │   │       └── operator_loc: (215,12)-(215,14) = "=>"
        │   │   │   └── closing_loc: (215,18)-(215,19) = "}"
        │   │   ├── operator_loc: (215,5)-(215,6) = "^"
        │   │   ├── lparen_loc: (215,6)-(215,7) = "("
        │   │   └── rparen_loc: (215,19)-(215,20) = ")"
        │   └── operator_loc: (215,2)-(215,4) = "=>"
        ├── @ AndNode (location: (217,0)-(217,13))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ MatchPredicateNode (location: (217,0)-(217,7))
        │   │   ├── flags: ∅
        │   │   ├── value:
        │   │   │   @ LocalVariableReadNode (location: (217,0)-(217,1))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :a
        │   │   │   └── depth: 0
        │   │   ├── pattern:
        │   │   │   @ ArrayPatternNode (location: (217,5)-(217,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── constant: ∅
        │   │   │   ├── requireds: (length: 1)
        │   │   │   │   └── @ LocalVariableTargetNode (location: (217,5)-(217,6))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :b
        │   │   │   │       └── depth: 0
        │   │   │   ├── rest:
        │   │   │   │   @ ImplicitRestNode (location: (217,6)-(217,7))
        │   │   │   │   └── flags: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── opening_loc: ∅
        │   │   │   └── closing_loc: ∅
        │   │   └── operator_loc: (217,2)-(217,4) = "in"
        │   ├── right:
        │   │   @ CallNode (location: (217,12)-(217,13))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :c
        │   │   ├── message_loc: (217,12)-(217,13) = "c"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (217,8)-(217,11) = "and"
        ├── @ OrNode (location: (218,0)-(218,12))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ MatchPredicateNode (location: (218,0)-(218,7))
        │   │   ├── flags: ∅
        │   │   ├── value:
        │   │   │   @ LocalVariableReadNode (location: (218,0)-(218,1))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :a
        │   │   │   └── depth: 0
        │   │   ├── pattern:
        │   │   │   @ ArrayPatternNode (location: (218,5)-(218,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── constant: ∅
        │   │   │   ├── requireds: (length: 1)
        │   │   │   │   └── @ LocalVariableTargetNode (location: (218,5)-(218,6))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :b
        │   │   │   │       └── depth: 0
        │   │   │   ├── rest:
        │   │   │   │   @ ImplicitRestNode (location: (218,6)-(218,7))
        │   │   │   │   └── flags: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── opening_loc: ∅
        │   │   │   └── closing_loc: ∅
        │   │   └── operator_loc: (218,2)-(218,4) = "in"
        │   ├── right:
        │   │   @ CallNode (location: (218,11)-(218,12))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :c
        │   │   ├── message_loc: (218,11)-(218,12) = "c"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (218,8)-(218,10) = "or"
        ├── @ AndNode (location: (219,0)-(219,15))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ ParenthesesNode (location: (219,0)-(219,9))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (219,1)-(219,8))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ MatchPredicateNode (location: (219,1)-(219,8))
        │   │   │           ├── flags: newline
        │   │   │           ├── value:
        │   │   │           │   @ LocalVariableReadNode (location: (219,1)-(219,2))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   ├── name: :a
        │   │   │           │   └── depth: 0
        │   │   │           ├── pattern:
        │   │   │           │   @ ArrayPatternNode (location: (219,6)-(219,8))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   ├── constant: ∅
        │   │   │           │   ├── requireds: (length: 1)
        │   │   │           │   │   └── @ LocalVariableTargetNode (location: (219,6)-(219,7))
        │   │   │           │   │       ├── flags: ∅
        │   │   │           │   │       ├── name: :b
        │   │   │           │   │       └── depth: 0
        │   │   │           │   ├── rest:
        │   │   │           │   │   @ ImplicitRestNode (location: (219,7)-(219,8))
        │   │   │           │   │   └── flags: ∅
        │   │   │           │   ├── posts: (length: 0)
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   └── closing_loc: ∅
        │   │   │           └── operator_loc: (219,3)-(219,5) = "in"
        │   │   ├── opening_loc: (219,0)-(219,1) = "("
        │   │   └── closing_loc: (219,8)-(219,9) = ")"
        │   ├── right:
        │   │   @ CallNode (location: (219,14)-(219,15))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :c
        │   │   ├── message_loc: (219,14)-(219,15) = "c"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (219,10)-(219,13) = "and"
        ├── @ OrNode (location: (220,0)-(220,14))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ ParenthesesNode (location: (220,0)-(220,9))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (220,1)-(220,8))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ MatchPredicateNode (location: (220,1)-(220,8))
        │   │   │           ├── flags: newline
        │   │   │           ├── value:
        │   │   │           │   @ LocalVariableReadNode (location: (220,1)-(220,2))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   ├── name: :a
        │   │   │           │   └── depth: 0
        │   │   │           ├── pattern:
        │   │   │           │   @ ArrayPatternNode (location: (220,6)-(220,8))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   ├── constant: ∅
        │   │   │           │   ├── requireds: (length: 1)
        │   │   │           │   │   └── @ LocalVariableTargetNode (location: (220,6)-(220,7))
        │   │   │           │   │       ├── flags: ∅
        │   │   │           │   │       ├── name: :b
        │   │   │           │   │       └── depth: 0
        │   │   │           │   ├── rest:
        │   │   │           │   │   @ ImplicitRestNode (location: (220,7)-(220,8))
        │   │   │           │   │   └── flags: ∅
        │   │   │           │   ├── posts: (length: 0)
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   └── closing_loc: ∅
        │   │   │           └── operator_loc: (220,3)-(220,5) = "in"
        │   │   ├── opening_loc: (220,0)-(220,1) = "("
        │   │   └── closing_loc: (220,8)-(220,9) = ")"
        │   ├── right:
        │   │   @ CallNode (location: (220,13)-(220,14))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :c
        │   │   ├── message_loc: (220,13)-(220,14) = "c"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (220,10)-(220,12) = "or"
        ├── @ MatchRequiredNode (location: (222,0)-(222,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ LocalVariableReadNode (location: (222,0)-(222,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :x
        │   │   └── depth: 0
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (222,5)-(222,14))
        │   │   ├── flags: ∅
        │   │   ├── expression:
        │   │   │   @ ArrayNode (location: (222,7)-(222,13))
        │   │   │   ├── flags: contains_splat
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ SplatNode (location: (222,8)-(222,12))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── operator_loc: (222,8)-(222,9) = "*"
        │   │   │   │       └── expression:
        │   │   │   │           @ CallNode (location: (222,9)-(222,12))
        │   │   │   │           ├── flags: ∅
        │   │   │   │           ├── receiver:
        │   │   │   │           │   @ LocalVariableReadNode (location: (222,9)-(222,10))
        │   │   │   │           │   ├── flags: ∅
        │   │   │   │           │   ├── name: :a
        │   │   │   │           │   └── depth: 0
        │   │   │   │           ├── call_operator_loc: (222,10)-(222,11) = "."
        │   │   │   │           ├── name: :x
        │   │   │   │           ├── message_loc: (222,11)-(222,12) = "x"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   ├── opening_loc: (222,7)-(222,8) = "["
        │   │   │   └── closing_loc: (222,12)-(222,13) = "]"
        │   │   ├── operator_loc: (222,5)-(222,6) = "^"
        │   │   ├── lparen_loc: (222,6)-(222,7) = "("
        │   │   └── rparen_loc: (222,13)-(222,14) = ")"
        │   └── operator_loc: (222,2)-(222,4) = "=>"
        ├── @ MatchRequiredNode (location: (223,0)-(223,15))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ LocalVariableReadNode (location: (223,0)-(223,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :x
        │   │   └── depth: 0
        │   ├── pattern:
        │   │   @ PinnedExpressionNode (location: (223,5)-(223,15))
        │   │   ├── flags: ∅
        │   │   ├── expression:
        │   │   │   @ ArrayNode (location: (223,7)-(223,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── elements: (length: 1)
        │   │   │   │   └── @ KeywordHashNode (location: (223,8)-(223,13))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       └── elements: (length: 1)
        │   │   │   │           └── @ AssocSplatNode (location: (223,8)-(223,13))
        │   │   │   │               ├── flags: ∅
        │   │   │   │               ├── value:
        │   │   │   │               │   @ CallNode (location: (223,10)-(223,13))
        │   │   │   │               │   ├── flags: ∅
        │   │   │   │               │   ├── receiver:
        │   │   │   │               │   │   @ LocalVariableReadNode (location: (223,10)-(223,11))
        │   │   │   │               │   │   ├── flags: ∅
        │   │   │   │               │   │   ├── name: :a
        │   │   │   │               │   │   └── depth: 0
        │   │   │   │               │   ├── call_operator_loc: (223,11)-(223,12) = "."
        │   │   │   │               │   ├── name: :x
        │   │   │   │               │   ├── message_loc: (223,12)-(223,13) = "x"
        │   │   │   │               │   ├── opening_loc: ∅
        │   │   │   │               │   ├── arguments: ∅
        │   │   │   │               │   ├── closing_loc: ∅
        │   │   │   │               │   └── block: ∅
        │   │   │   │               └── operator_loc: (223,8)-(223,10) = "**"
        │   │   │   ├── opening_loc: (223,7)-(223,8) = "["
        │   │   │   └── closing_loc: (223,13)-(223,14) = "]"
        │   │   ├── operator_loc: (223,5)-(223,6) = "^"
        │   │   ├── lparen_loc: (223,6)-(223,7) = "("
        │   │   └── rparen_loc: (223,14)-(223,15) = ")"
        │   └── operator_loc: (223,2)-(223,4) = "=>"
        └── @ MatchRequiredNode (location: (224,0)-(224,14))
            ├── flags: newline
            ├── value:
            │   @ LocalVariableReadNode (location: (224,0)-(224,1))
            │   ├── flags: ∅
            │   ├── name: :x
            │   └── depth: 0
            ├── pattern:
            │   @ PinnedExpressionNode (location: (224,5)-(224,14))
            │   ├── flags: ∅
            │   ├── expression:
            │   │   @ HashNode (location: (224,7)-(224,13))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (224,7)-(224,8) = "{"
            │   │   ├── elements: (length: 1)
            │   │   │   └── @ AssocNode (location: (224,9)-(224,11))
            │   │   │       ├── flags: ∅
            │   │   │       ├── key:
            │   │   │       │   @ SymbolNode (location: (224,9)-(224,11))
            │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │   │       │   ├── opening_loc: ∅
            │   │   │       │   ├── value_loc: (224,9)-(224,10) = "a"
            │   │   │       │   ├── closing_loc: (224,10)-(224,11) = ":"
            │   │   │       │   └── unescaped: "a"
            │   │   │       ├── value:
            │   │   │       │   @ ImplicitNode (location: (224,9)-(224,11))
            │   │   │       │   ├── flags: ∅
            │   │   │       │   └── value:
            │   │   │       │       @ LocalVariableReadNode (location: (224,9)-(224,11))
            │   │   │       │       ├── flags: ∅
            │   │   │       │       ├── name: :a
            │   │   │       │       └── depth: 0
            │   │   │       └── operator_loc: ∅
            │   │   └── closing_loc: (224,12)-(224,13) = "}"
            │   ├── operator_loc: (224,5)-(224,6) = "^"
            │   ├── lparen_loc: (224,6)-(224,7) = "("
            │   └── rparen_loc: (224,13)-(224,14) = ")"
            └── operator_loc: (224,2)-(224,4) = "=>"
prism-1.5.1/snapshots/procs.txt000066400000000000000000000634331506127434000165740ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(27,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(27,19))
    ├── flags: ∅
    └── body: (length: 10)
        ├── @ LambdaNode (location: (1,0)-(1,21))
        │   ├── flags: newline
        │   ├── locals: [:a, :b, :c, :d]
        │   ├── operator_loc: (1,0)-(1,2) = "->"
        │   ├── opening_loc: (1,16)-(1,17) = "{"
        │   ├── closing_loc: (1,20)-(1,21) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (1,3)-(1,15))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (1,4)-(1,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 1)
        │   │   │   │   └── @ RequiredParameterNode (location: (1,4)-(1,5))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       └── name: :a
        │   │   │   ├── optionals: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 0)
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── locals: (length: 3)
        │   │   │   ├── @ BlockLocalVariableNode (location: (1,7)-(1,8))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :b
        │   │   │   ├── @ BlockLocalVariableNode (location: (1,10)-(1,11))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :c
        │   │   │   └── @ BlockLocalVariableNode (location: (1,13)-(1,14))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :d
        │   │   ├── opening_loc: (1,3)-(1,4) = "("
        │   │   └── closing_loc: (1,14)-(1,15) = ")"
        │   └── body:
        │       @ StatementsNode (location: (1,18)-(1,19))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ LocalVariableReadNode (location: (1,18)-(1,19))
        │               ├── flags: newline
        │               ├── name: :b
        │               └── depth: 0
        ├── @ LambdaNode (location: (3,0)-(5,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── operator_loc: (3,0)-(3,2) = "->"
        │   ├── opening_loc: (3,3)-(3,5) = "do"
        │   ├── closing_loc: (5,0)-(5,3) = "end"
        │   ├── parameters: ∅
        │   └── body:
        │       @ BeginNode (location: (3,3)-(5,3))
        │       ├── flags: ∅
        │       ├── begin_keyword_loc: ∅
        │       ├── statements: ∅
        │       ├── rescue_clause: ∅
        │       ├── else_clause: ∅
        │       ├── ensure_clause:
        │       │   @ EnsureNode (location: (4,0)-(5,3))
        │       │   ├── flags: ∅
        │       │   ├── ensure_keyword_loc: (4,0)-(4,6) = "ensure"
        │       │   ├── statements: ∅
        │       │   └── end_keyword_loc: (5,0)-(5,3) = "end"
        │       └── end_keyword_loc: (5,0)-(5,3) = "end"
        ├── @ LambdaNode (location: (7,0)-(11,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── operator_loc: (7,0)-(7,2) = "->"
        │   ├── opening_loc: (7,3)-(7,5) = "do"
        │   ├── closing_loc: (11,0)-(11,3) = "end"
        │   ├── parameters: ∅
        │   └── body:
        │       @ BeginNode (location: (7,3)-(11,3))
        │       ├── flags: ∅
        │       ├── begin_keyword_loc: ∅
        │       ├── statements: ∅
        │       ├── rescue_clause:
        │       │   @ RescueNode (location: (8,0)-(8,6))
        │       │   ├── flags: ∅
        │       │   ├── keyword_loc: (8,0)-(8,6) = "rescue"
        │       │   ├── exceptions: (length: 0)
        │       │   ├── operator_loc: ∅
        │       │   ├── reference: ∅
        │       │   ├── then_keyword_loc: ∅
        │       │   ├── statements: ∅
        │       │   └── subsequent: ∅
        │       ├── else_clause:
        │       │   @ ElseNode (location: (9,0)-(10,6))
        │       │   ├── flags: ∅
        │       │   ├── else_keyword_loc: (9,0)-(9,4) = "else"
        │       │   ├── statements: ∅
        │       │   └── end_keyword_loc: (10,0)-(10,6) = "ensure"
        │       ├── ensure_clause:
        │       │   @ EnsureNode (location: (10,0)-(11,3))
        │       │   ├── flags: ∅
        │       │   ├── ensure_keyword_loc: (10,0)-(10,6) = "ensure"
        │       │   ├── statements: ∅
        │       │   └── end_keyword_loc: (11,0)-(11,3) = "end"
        │       └── end_keyword_loc: (11,0)-(11,3) = "end"
        ├── @ LambdaNode (location: (13,0)-(13,10))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── operator_loc: (13,0)-(13,2) = "->"
        │   ├── opening_loc: (13,3)-(13,4) = "{"
        │   ├── closing_loc: (13,9)-(13,10) = "}"
        │   ├── parameters: ∅
        │   └── body:
        │       @ StatementsNode (location: (13,5)-(13,8))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ CallNode (location: (13,5)-(13,8))
        │               ├── flags: newline, variable_call, ignore_visibility
        │               ├── receiver: ∅
        │               ├── call_operator_loc: ∅
        │               ├── name: :foo
        │               ├── message_loc: (13,5)-(13,8) = "foo"
        │               ├── opening_loc: ∅
        │               ├── arguments: ∅
        │               ├── closing_loc: ∅
        │               └── block: ∅
        ├── @ LambdaNode (location: (15,0)-(15,15))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── operator_loc: (15,0)-(15,2) = "->"
        │   ├── opening_loc: (15,3)-(15,5) = "do"
        │   ├── closing_loc: (15,12)-(15,15) = "end"
        │   ├── parameters: ∅
        │   └── body:
        │       @ StatementsNode (location: (15,7)-(15,10))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ CallNode (location: (15,7)-(15,10))
        │               ├── flags: newline, variable_call, ignore_visibility
        │               ├── receiver: ∅
        │               ├── call_operator_loc: ∅
        │               ├── name: :foo
        │               ├── message_loc: (15,7)-(15,10) = "foo"
        │               ├── opening_loc: ∅
        │               ├── arguments: ∅
        │               ├── closing_loc: ∅
        │               └── block: ∅
        ├── @ LambdaNode (location: (17,0)-(17,29))
        │   ├── flags: newline
        │   ├── locals: [:a, :b, :c, :d, :e]
        │   ├── operator_loc: (17,0)-(17,2) = "->"
        │   ├── opening_loc: (17,24)-(17,25) = "{"
        │   ├── closing_loc: (17,28)-(17,29) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (17,3)-(17,23))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (17,3)-(17,23))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 1)
        │   │   │   │   └── @ RequiredParameterNode (location: (17,3)-(17,4))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       └── name: :a
        │   │   │   ├── optionals: (length: 1)
        │   │   │   │   └── @ OptionalParameterNode (location: (17,6)-(17,11))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :b
        │   │   │   │       ├── name_loc: (17,6)-(17,7) = "b"
        │   │   │   │       ├── operator_loc: (17,8)-(17,9) = "="
        │   │   │   │       └── value:
        │   │   │   │           @ IntegerNode (location: (17,10)-(17,11))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 2)
        │   │   │   │   ├── @ RequiredKeywordParameterNode (location: (17,13)-(17,15))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   ├── name: :c
        │   │   │   │   │   └── name_loc: (17,13)-(17,15) = "c:"
        │   │   │   │   └── @ RequiredKeywordParameterNode (location: (17,17)-(17,19))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :d
        │   │   │   │       └── name_loc: (17,17)-(17,19) = "d:"
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block:
        │   │   │       @ BlockParameterNode (location: (17,21)-(17,23))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :e
        │   │   │       ├── name_loc: (17,22)-(17,23) = "e"
        │   │   │       └── operator_loc: (17,21)-(17,22) = "&"
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── body:
        │       @ StatementsNode (location: (17,26)-(17,27))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ LocalVariableReadNode (location: (17,26)-(17,27))
        │               ├── flags: newline
        │               ├── name: :a
        │               └── depth: 0
        ├── @ LambdaNode (location: (19,0)-(19,40))
        │   ├── flags: newline
        │   ├── locals: [:a, :b, :c, :d, :e, :f, :g]
        │   ├── operator_loc: (19,0)-(19,2) = "->"
        │   ├── opening_loc: (19,35)-(19,36) = "{"
        │   ├── closing_loc: (19,39)-(19,40) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (19,3)-(19,34))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (19,4)-(19,33))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 1)
        │   │   │   │   └── @ RequiredParameterNode (location: (19,4)-(19,5))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       └── name: :a
        │   │   │   ├── optionals: (length: 1)
        │   │   │   │   └── @ OptionalParameterNode (location: (19,7)-(19,12))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :b
        │   │   │   │       ├── name_loc: (19,7)-(19,8) = "b"
        │   │   │   │       ├── operator_loc: (19,9)-(19,10) = "="
        │   │   │   │       └── value:
        │   │   │   │           @ IntegerNode (location: (19,11)-(19,12))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   ├── rest:
        │   │   │   │   @ RestParameterNode (location: (19,14)-(19,16))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :c
        │   │   │   │   ├── name_loc: (19,15)-(19,16) = "c"
        │   │   │   │   └── operator_loc: (19,14)-(19,15) = "*"
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 2)
        │   │   │   │   ├── @ RequiredKeywordParameterNode (location: (19,18)-(19,20))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   ├── name: :d
        │   │   │   │   │   └── name_loc: (19,18)-(19,20) = "d:"
        │   │   │   │   └── @ RequiredKeywordParameterNode (location: (19,22)-(19,24))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :e
        │   │   │   │       └── name_loc: (19,22)-(19,24) = "e:"
        │   │   │   ├── keyword_rest:
        │   │   │   │   @ KeywordRestParameterNode (location: (19,26)-(19,29))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :f
        │   │   │   │   ├── name_loc: (19,28)-(19,29) = "f"
        │   │   │   │   └── operator_loc: (19,26)-(19,28) = "**"
        │   │   │   └── block:
        │   │   │       @ BlockParameterNode (location: (19,31)-(19,33))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :g
        │   │   │       ├── name_loc: (19,32)-(19,33) = "g"
        │   │   │       └── operator_loc: (19,31)-(19,32) = "&"
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: (19,3)-(19,4) = "("
        │   │   └── closing_loc: (19,33)-(19,34) = ")"
        │   └── body:
        │       @ StatementsNode (location: (19,37)-(19,38))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ LocalVariableReadNode (location: (19,37)-(19,38))
        │               ├── flags: newline
        │               ├── name: :a
        │               └── depth: 0
        ├── @ LambdaNode (location: (21,0)-(23,3))
        │   ├── flags: newline
        │   ├── locals: [:a, :b, :c, :d, :e, :f, :g]
        │   ├── operator_loc: (21,0)-(21,2) = "->"
        │   ├── opening_loc: (21,35)-(21,37) = "do"
        │   ├── closing_loc: (23,0)-(23,3) = "end"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (21,3)-(21,34))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (21,4)-(21,33))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 1)
        │   │   │   │   └── @ RequiredParameterNode (location: (21,4)-(21,5))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       └── name: :a
        │   │   │   ├── optionals: (length: 1)
        │   │   │   │   └── @ OptionalParameterNode (location: (21,7)-(21,12))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :b
        │   │   │   │       ├── name_loc: (21,7)-(21,8) = "b"
        │   │   │   │       ├── operator_loc: (21,9)-(21,10) = "="
        │   │   │   │       └── value:
        │   │   │   │           @ IntegerNode (location: (21,11)-(21,12))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   ├── rest:
        │   │   │   │   @ RestParameterNode (location: (21,14)-(21,16))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :c
        │   │   │   │   ├── name_loc: (21,15)-(21,16) = "c"
        │   │   │   │   └── operator_loc: (21,14)-(21,15) = "*"
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 2)
        │   │   │   │   ├── @ RequiredKeywordParameterNode (location: (21,18)-(21,20))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   ├── name: :d
        │   │   │   │   │   └── name_loc: (21,18)-(21,20) = "d:"
        │   │   │   │   └── @ RequiredKeywordParameterNode (location: (21,22)-(21,24))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :e
        │   │   │   │       └── name_loc: (21,22)-(21,24) = "e:"
        │   │   │   ├── keyword_rest:
        │   │   │   │   @ KeywordRestParameterNode (location: (21,26)-(21,29))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :f
        │   │   │   │   ├── name_loc: (21,28)-(21,29) = "f"
        │   │   │   │   └── operator_loc: (21,26)-(21,28) = "**"
        │   │   │   └── block:
        │   │   │       @ BlockParameterNode (location: (21,31)-(21,33))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :g
        │   │   │       ├── name_loc: (21,32)-(21,33) = "g"
        │   │   │       └── operator_loc: (21,31)-(21,32) = "&"
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: (21,3)-(21,4) = "("
        │   │   └── closing_loc: (21,33)-(21,34) = ")"
        │   └── body:
        │       @ StatementsNode (location: (22,2)-(22,3))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ LocalVariableReadNode (location: (22,2)-(22,3))
        │               ├── flags: newline
        │               ├── name: :a
        │               └── depth: 0
        ├── @ LambdaNode (location: (25,0)-(25,25))
        │   ├── flags: newline
        │   ├── locals: [:a]
        │   ├── operator_loc: (25,0)-(25,2) = "->"
        │   ├── opening_loc: (25,7)-(25,8) = "{"
        │   ├── closing_loc: (25,24)-(25,25) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (25,3)-(25,6))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (25,4)-(25,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 1)
        │   │   │   │   └── @ RequiredParameterNode (location: (25,4)-(25,5))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       └── name: :a
        │   │   │   ├── optionals: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 0)
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: (25,3)-(25,4) = "("
        │   │   └── closing_loc: (25,5)-(25,6) = ")"
        │   └── body:
        │       @ StatementsNode (location: (25,9)-(25,23))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ LambdaNode (location: (25,9)-(25,23))
        │               ├── flags: newline
        │               ├── locals: [:b]
        │               ├── operator_loc: (25,9)-(25,11) = "->"
        │               ├── opening_loc: (25,14)-(25,15) = "{"
        │               ├── closing_loc: (25,22)-(25,23) = "}"
        │               ├── parameters:
        │               │   @ BlockParametersNode (location: (25,12)-(25,13))
        │               │   ├── flags: ∅
        │               │   ├── parameters:
        │               │   │   @ ParametersNode (location: (25,12)-(25,13))
        │               │   │   ├── flags: ∅
        │               │   │   ├── requireds: (length: 1)
        │               │   │   │   └── @ RequiredParameterNode (location: (25,12)-(25,13))
        │               │   │   │       ├── flags: ∅
        │               │   │   │       └── name: :b
        │               │   │   ├── optionals: (length: 0)
        │               │   │   ├── rest: ∅
        │               │   │   ├── posts: (length: 0)
        │               │   │   ├── keywords: (length: 0)
        │               │   │   ├── keyword_rest: ∅
        │               │   │   └── block: ∅
        │               │   ├── locals: (length: 0)
        │               │   ├── opening_loc: ∅
        │               │   └── closing_loc: ∅
        │               └── body:
        │                   @ StatementsNode (location: (25,16)-(25,21))
        │                   ├── flags: ∅
        │                   └── body: (length: 1)
        │                       └── @ CallNode (location: (25,16)-(25,21))
        │                           ├── flags: newline
        │                           ├── receiver:
        │                           │   @ LocalVariableReadNode (location: (25,16)-(25,17))
        │                           │   ├── flags: ∅
        │                           │   ├── name: :a
        │                           │   └── depth: 1
        │                           ├── call_operator_loc: ∅
        │                           ├── name: :*
        │                           ├── message_loc: (25,18)-(25,19) = "*"
        │                           ├── opening_loc: ∅
        │                           ├── arguments:
        │                           │   @ ArgumentsNode (location: (25,20)-(25,21))
        │                           │   ├── flags: ∅
        │                           │   └── arguments: (length: 1)
        │                           │       └── @ LocalVariableReadNode (location: (25,20)-(25,21))
        │                           │           ├── flags: ∅
        │                           │           ├── name: :b
        │                           │           └── depth: 0
        │                           ├── closing_loc: ∅
        │                           └── block: ∅
        └── @ LambdaNode (location: (27,0)-(27,19))
            ├── flags: newline
            ├── locals: [:a, :b, :c]
            ├── operator_loc: (27,0)-(27,2) = "->"
            ├── opening_loc: (27,16)-(27,17) = "{"
            ├── closing_loc: (27,18)-(27,19) = "}"
            ├── parameters:
            │   @ BlockParametersNode (location: (27,3)-(27,15))
            │   ├── flags: ∅
            │   ├── parameters:
            │   │   @ ParametersNode (location: (27,4)-(27,14))
            │   │   ├── flags: ∅
            │   │   ├── requireds: (length: 1)
            │   │   │   └── @ MultiTargetNode (location: (27,4)-(27,10))
            │   │   │       ├── flags: ∅
            │   │   │       ├── lefts: (length: 2)
            │   │   │       │   ├── @ RequiredParameterNode (location: (27,5)-(27,6))
            │   │   │       │   │   ├── flags: ∅
            │   │   │       │   │   └── name: :a
            │   │   │       │   └── @ RequiredParameterNode (location: (27,8)-(27,9))
            │   │   │       │       ├── flags: ∅
            │   │   │       │       └── name: :b
            │   │   │       ├── rest: ∅
            │   │   │       ├── rights: (length: 0)
            │   │   │       ├── lparen_loc: (27,4)-(27,5) = "("
            │   │   │       └── rparen_loc: (27,9)-(27,10) = ")"
            │   │   ├── optionals: (length: 0)
            │   │   ├── rest:
            │   │   │   @ RestParameterNode (location: (27,12)-(27,14))
            │   │   │   ├── flags: ∅
            │   │   │   ├── name: :c
            │   │   │   ├── name_loc: (27,13)-(27,14) = "c"
            │   │   │   └── operator_loc: (27,12)-(27,13) = "*"
            │   │   ├── posts: (length: 0)
            │   │   ├── keywords: (length: 0)
            │   │   ├── keyword_rest: ∅
            │   │   └── block: ∅
            │   ├── locals: (length: 0)
            │   ├── opening_loc: (27,3)-(27,4) = "("
            │   └── closing_loc: (27,14)-(27,15) = ")"
            └── body: ∅
prism-1.5.1/snapshots/range_begin_open_exclusive.txt000066400000000000000000000011211506127434000230000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ RangeNode (location: (1,0)-(1,4))
            ├── flags: newline, static_literal, exclude_end
            ├── left: ∅
            ├── right:
            │   @ IntegerNode (location: (1,3)-(1,4))
            │   ├── flags: static_literal, decimal
            │   └── value: 2
            └── operator_loc: (1,0)-(1,3) = "..."
prism-1.5.1/snapshots/range_begin_open_inclusive.txt000066400000000000000000000011031506127434000227720ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ RangeNode (location: (1,0)-(1,3))
            ├── flags: newline, static_literal
            ├── left: ∅
            ├── right:
            │   @ IntegerNode (location: (1,2)-(1,3))
            │   ├── flags: static_literal, decimal
            │   └── value: 2
            └── operator_loc: (1,0)-(1,2) = ".."
prism-1.5.1/snapshots/range_beginless.txt000066400000000000000000000136061506127434000205720ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,18))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,18))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ DefNode (location: (1,0)-(1,21))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (1,4)-(1,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (1,6)-(1,15))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (1,6)-(1,15))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :x
        │   │   │       ├── name_loc: (1,6)-(1,7) = "x"
        │   │   │       ├── operator_loc: (1,8)-(1,9) = "="
        │   │   │       └── value:
        │   │   │           @ RangeNode (location: (1,10)-(1,15))
        │   │   │           ├── flags: exclude_end
        │   │   │           ├── left: ∅
        │   │   │           ├── right:
        │   │   │           │   @ StringNode (location: (1,13)-(1,15))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   ├── opening_loc: (1,13)-(1,14) = "?"
        │   │   │           │   ├── content_loc: (1,14)-(1,15) = "a"
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── unescaped: "a"
        │   │   │           └── operator_loc: (1,10)-(1,13) = "..."
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:x]
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (1,5)-(1,6) = "("
        │   ├── rparen_loc: (1,15)-(1,16) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (1,18)-(1,21) = "end"
        ├── @ DefNode (location: (3,0)-(3,20))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (3,4)-(3,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (3,6)-(3,14))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (3,6)-(3,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :x
        │   │   │       ├── name_loc: (3,6)-(3,8) = "x:"
        │   │   │       └── value:
        │   │   │           @ RangeNode (location: (3,9)-(3,14))
        │   │   │           ├── flags: exclude_end
        │   │   │           ├── left: ∅
        │   │   │           ├── right:
        │   │   │           │   @ StringNode (location: (3,12)-(3,14))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   ├── opening_loc: (3,12)-(3,13) = "?"
        │   │   │           │   ├── content_loc: (3,13)-(3,14) = "a"
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── unescaped: "a"
        │   │   │           └── operator_loc: (3,9)-(3,12) = "..."
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:x]
        │   ├── def_keyword_loc: (3,0)-(3,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (3,5)-(3,6) = "("
        │   ├── rparen_loc: (3,14)-(3,15) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (3,17)-(3,20) = "end"
        └── @ DefNode (location: (5,0)-(5,18))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (5,4)-(5,5) = "f"
            ├── receiver: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (5,8)-(5,13))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ RangeNode (location: (5,8)-(5,13))
            │           ├── flags: newline, exclude_end
            │           ├── left: ∅
            │           ├── right:
            │           │   @ SymbolNode (location: (5,11)-(5,13))
            │           │   ├── flags: static_literal, forced_us_ascii_encoding
            │           │   ├── opening_loc: (5,11)-(5,12) = ":"
            │           │   ├── value_loc: (5,12)-(5,13) = "a"
            │           │   ├── closing_loc: ∅
            │           │   └── unescaped: "a"
            │           └── operator_loc: (5,8)-(5,11) = "..."
            ├── locals: []
            ├── def_keyword_loc: (5,0)-(5,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (5,5)-(5,6) = "("
            ├── rparen_loc: (5,6)-(5,7) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (5,15)-(5,18) = "end"
prism-1.5.1/snapshots/range_end_open_exclusive.txt000066400000000000000000000011211506127434000224620ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ RangeNode (location: (1,0)-(1,4))
            ├── flags: newline, static_literal, exclude_end
            ├── left:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 2
            ├── right: ∅
            └── operator_loc: (1,1)-(1,4) = "..."
prism-1.5.1/snapshots/range_end_open_inclusive.txt000066400000000000000000000011031506127434000224540ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ RangeNode (location: (1,0)-(1,3))
            ├── flags: newline, static_literal
            ├── left:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 2
            ├── right: ∅
            └── operator_loc: (1,1)-(1,3) = ".."
prism-1.5.1/snapshots/ranges.txt000066400000000000000000000744571506127434000167350ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(51,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(51,7))
    ├── flags: ∅
    └── body: (length: 26)
        ├── @ ParenthesesNode (location: (1,0)-(1,6))
        │   ├── flags: newline
        │   ├── body:
        │   │   @ StatementsNode (location: (1,1)-(1,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ RangeNode (location: (1,1)-(1,5))
        │   │           ├── flags: newline, static_literal, exclude_end
        │   │           ├── left: ∅
        │   │           ├── right:
        │   │           │   @ IntegerNode (location: (1,4)-(1,5))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 2
        │   │           └── operator_loc: (1,1)-(1,4) = "..."
        │   ├── opening_loc: (1,0)-(1,1) = "("
        │   └── closing_loc: (1,5)-(1,6) = ")"
        ├── @ ParenthesesNode (location: (3,0)-(3,5))
        │   ├── flags: newline
        │   ├── body:
        │   │   @ StatementsNode (location: (3,1)-(3,4))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ RangeNode (location: (3,1)-(3,4))
        │   │           ├── flags: newline, static_literal
        │   │           ├── left: ∅
        │   │           ├── right:
        │   │           │   @ IntegerNode (location: (3,3)-(3,4))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 2
        │   │           └── operator_loc: (3,1)-(3,3) = ".."
        │   ├── opening_loc: (3,0)-(3,1) = "("
        │   └── closing_loc: (3,4)-(3,5) = ")"
        ├── @ CallNode (location: (5,0)-(5,12))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (5,0)-(5,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (5,4)-(5,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ParenthesesNode (location: (5,4)-(5,12))
        │   │           ├── flags: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (5,5)-(5,11))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ ParenthesesNode (location: (5,5)-(5,11))
        │   │           │           ├── flags: newline
        │   │           │           ├── body:
        │   │           │           │   @ StatementsNode (location: (5,6)-(5,10))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   └── body: (length: 1)
        │   │           │           │       └── @ RangeNode (location: (5,6)-(5,10))
        │   │           │           │           ├── flags: newline, static_literal
        │   │           │           │           ├── left:
        │   │           │           │           │   @ IntegerNode (location: (5,6)-(5,7))
        │   │           │           │           │   ├── flags: static_literal, decimal
        │   │           │           │           │   └── value: 1
        │   │           │           │           ├── right:
        │   │           │           │           │   @ IntegerNode (location: (5,9)-(5,10))
        │   │           │           │           │   ├── flags: static_literal, decimal
        │   │           │           │           │   └── value: 1
        │   │           │           │           └── operator_loc: (5,7)-(5,9) = ".."
        │   │           │           ├── opening_loc: (5,5)-(5,6) = "("
        │   │           │           └── closing_loc: (5,10)-(5,11) = ")"
        │   │           ├── opening_loc: (5,4)-(5,5) = "("
        │   │           └── closing_loc: (5,11)-(5,12) = ")"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ RangeNode (location: (7,0)-(7,5))
        │   ├── flags: newline, static_literal, exclude_end
        │   ├── left:
        │   │   @ IntegerNode (location: (7,0)-(7,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── right:
        │   │   @ IntegerNode (location: (7,4)-(7,5))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 2
        │   └── operator_loc: (7,1)-(7,4) = "..."
        ├── @ CallNode (location: (9,0)-(9,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (9,0)-(9,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (9,0)-(9,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]
        │   ├── message_loc: (9,3)-(9,9) = "[...2]"
        │   ├── opening_loc: (9,3)-(9,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (9,4)-(9,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ RangeNode (location: (9,4)-(9,8))
        │   │           ├── flags: static_literal, exclude_end
        │   │           ├── left: ∅
        │   │           ├── right:
        │   │           │   @ IntegerNode (location: (9,7)-(9,8))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 2
        │   │           └── operator_loc: (9,4)-(9,7) = "..."
        │   ├── closing_loc: (9,8)-(9,9) = "]"
        │   └── block: ∅
        ├── @ HashNode (location: (11,0)-(11,15))
        │   ├── flags: newline
        │   ├── opening_loc: (11,0)-(11,1) = "{"
        │   ├── elements: (length: 1)
        │   │   └── @ AssocNode (location: (11,2)-(11,13))
        │   │       ├── flags: ∅
        │   │       ├── key:
        │   │       │   @ SymbolNode (location: (11,2)-(11,6))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── value_loc: (11,2)-(11,5) = "foo"
        │   │       │   ├── closing_loc: (11,5)-(11,6) = ":"
        │   │       │   └── unescaped: "foo"
        │   │       ├── value:
        │   │       │   @ RangeNode (location: (11,7)-(11,13))
        │   │       │   ├── flags: exclude_end
        │   │       │   ├── left: ∅
        │   │       │   ├── right:
        │   │       │   │   @ CallNode (location: (11,10)-(11,13))
        │   │       │   │   ├── flags: variable_call, ignore_visibility
        │   │       │   │   ├── receiver: ∅
        │   │       │   │   ├── call_operator_loc: ∅
        │   │       │   │   ├── name: :bar
        │   │       │   │   ├── message_loc: (11,10)-(11,13) = "bar"
        │   │       │   │   ├── opening_loc: ∅
        │   │       │   │   ├── arguments: ∅
        │   │       │   │   ├── closing_loc: ∅
        │   │       │   │   └── block: ∅
        │   │       │   └── operator_loc: (11,7)-(11,10) = "..."
        │   │       └── operator_loc: ∅
        │   └── closing_loc: (11,14)-(11,15) = "}"
        ├── @ ParenthesesNode (location: (13,0)-(13,6))
        │   ├── flags: newline
        │   ├── body:
        │   │   @ StatementsNode (location: (13,1)-(13,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ RangeNode (location: (13,1)-(13,5))
        │   │           ├── flags: newline, static_literal, exclude_end
        │   │           ├── left:
        │   │           │   @ IntegerNode (location: (13,1)-(13,2))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 1
        │   │           ├── right: ∅
        │   │           └── operator_loc: (13,2)-(13,5) = "..."
        │   ├── opening_loc: (13,0)-(13,1) = "("
        │   └── closing_loc: (13,5)-(13,6) = ")"
        ├── @ RangeNode (location: (15,0)-(15,4))
        │   ├── flags: newline, static_literal
        │   ├── left:
        │   │   @ IntegerNode (location: (15,0)-(15,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── right:
        │   │   @ IntegerNode (location: (15,3)-(15,4))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 2
        │   └── operator_loc: (15,1)-(15,3) = ".."
        ├── @ HashNode (location: (17,0)-(17,14))
        │   ├── flags: newline
        │   ├── opening_loc: (17,0)-(17,1) = "{"
        │   ├── elements: (length: 1)
        │   │   └── @ AssocNode (location: (17,2)-(17,12))
        │   │       ├── flags: ∅
        │   │       ├── key:
        │   │       │   @ SymbolNode (location: (17,2)-(17,6))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── value_loc: (17,2)-(17,5) = "foo"
        │   │       │   ├── closing_loc: (17,5)-(17,6) = ":"
        │   │       │   └── unescaped: "foo"
        │   │       ├── value:
        │   │       │   @ RangeNode (location: (17,7)-(17,12))
        │   │       │   ├── flags: ∅
        │   │       │   ├── left: ∅
        │   │       │   ├── right:
        │   │       │   │   @ CallNode (location: (17,9)-(17,12))
        │   │       │   │   ├── flags: variable_call, ignore_visibility
        │   │       │   │   ├── receiver: ∅
        │   │       │   │   ├── call_operator_loc: ∅
        │   │       │   │   ├── name: :bar
        │   │       │   │   ├── message_loc: (17,9)-(17,12) = "bar"
        │   │       │   │   ├── opening_loc: ∅
        │   │       │   │   ├── arguments: ∅
        │   │       │   │   ├── closing_loc: ∅
        │   │       │   │   └── block: ∅
        │   │       │   └── operator_loc: (17,7)-(17,9) = ".."
        │   │       └── operator_loc: ∅
        │   └── closing_loc: (17,13)-(17,14) = "}"
        ├── @ ParenthesesNode (location: (19,0)-(19,5))
        │   ├── flags: newline
        │   ├── body:
        │   │   @ StatementsNode (location: (19,1)-(19,4))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ RangeNode (location: (19,1)-(19,4))
        │   │           ├── flags: newline, static_literal
        │   │           ├── left:
        │   │           │   @ IntegerNode (location: (19,1)-(19,2))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 1
        │   │           ├── right: ∅
        │   │           └── operator_loc: (19,2)-(19,4) = ".."
        │   ├── opening_loc: (19,0)-(19,1) = "("
        │   └── closing_loc: (19,4)-(19,5) = ")"
        ├── @ RangeNode (location: (21,0)-(21,8))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ IntegerNode (location: (21,0)-(21,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── right:
        │   │   @ RangeNode (location: (21,5)-(21,8))
        │   │   ├── flags: static_literal
        │   │   ├── left: ∅
        │   │   ├── right:
        │   │   │   @ IntegerNode (location: (21,7)-(21,8))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   └── operator_loc: (21,5)-(21,7) = ".."
        │   └── operator_loc: (21,2)-(21,4) = ".."
        ├── @ AndNode (location: (23,0)-(23,8))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ RangeNode (location: (23,0)-(23,3))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (23,0)-(23,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right: ∅
        │   │   └── operator_loc: (23,1)-(23,3) = ".."
        │   ├── right:
        │   │   @ IntegerNode (location: (23,7)-(23,8))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 2
        │   └── operator_loc: (23,4)-(23,6) = "&&"
        ├── @ CallNode (location: (25,0)-(25,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RangeNode (location: (25,0)-(25,3))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (25,0)-(25,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right: ∅
        │   │   └── operator_loc: (25,1)-(25,3) = ".."
        │   ├── call_operator_loc: ∅
        │   ├── name: :==
        │   ├── message_loc: (25,4)-(25,6) = "=="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (25,7)-(25,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (25,7)-(25,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (27,0)-(27,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RangeNode (location: (27,0)-(27,3))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (27,0)-(27,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right: ∅
        │   │   └── operator_loc: (27,1)-(27,3) = ".."
        │   ├── call_operator_loc: ∅
        │   ├── name: :!=
        │   ├── message_loc: (27,4)-(27,6) = "!="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (27,7)-(27,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (27,7)-(27,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (29,0)-(29,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RangeNode (location: (29,0)-(29,3))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (29,0)-(29,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right: ∅
        │   │   └── operator_loc: (29,1)-(29,3) = ".."
        │   ├── call_operator_loc: ∅
        │   ├── name: :===
        │   ├── message_loc: (29,4)-(29,7) = "==="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (29,8)-(29,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (29,8)-(29,9))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (31,0)-(31,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RangeNode (location: (31,0)-(31,3))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (31,0)-(31,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right: ∅
        │   │   └── operator_loc: (31,1)-(31,3) = ".."
        │   ├── call_operator_loc: ∅
        │   ├── name: :<=>
        │   ├── message_loc: (31,4)-(31,7) = "<=>"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (31,8)-(31,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (31,8)-(31,9))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (33,0)-(33,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RangeNode (location: (33,0)-(33,3))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (33,0)-(33,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right: ∅
        │   │   └── operator_loc: (33,1)-(33,3) = ".."
        │   ├── call_operator_loc: ∅
        │   ├── name: :=~
        │   ├── message_loc: (33,4)-(33,6) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (33,7)-(33,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (33,7)-(33,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (35,0)-(35,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RangeNode (location: (35,0)-(35,3))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (35,0)-(35,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right: ∅
        │   │   └── operator_loc: (35,1)-(35,3) = ".."
        │   ├── call_operator_loc: ∅
        │   ├── name: :!~
        │   ├── message_loc: (35,4)-(35,6) = "!~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (35,7)-(35,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (35,7)-(35,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (37,0)-(37,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RangeNode (location: (37,0)-(37,3))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (37,0)-(37,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right: ∅
        │   │   └── operator_loc: (37,1)-(37,3) = ".."
        │   ├── call_operator_loc: ∅
        │   ├── name: :<
        │   ├── message_loc: (37,4)-(37,5) = "<"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (37,6)-(37,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (37,6)-(37,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (39,0)-(39,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RangeNode (location: (39,0)-(39,3))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (39,0)-(39,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right: ∅
        │   │   └── operator_loc: (39,1)-(39,3) = ".."
        │   ├── call_operator_loc: ∅
        │   ├── name: :>
        │   ├── message_loc: (39,4)-(39,5) = ">"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (39,6)-(39,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (39,6)-(39,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (41,0)-(41,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RangeNode (location: (41,0)-(41,3))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (41,0)-(41,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right: ∅
        │   │   └── operator_loc: (41,1)-(41,3) = ".."
        │   ├── call_operator_loc: ∅
        │   ├── name: :<=
        │   ├── message_loc: (41,4)-(41,6) = "<="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (41,7)-(41,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (41,7)-(41,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (43,0)-(43,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RangeNode (location: (43,0)-(43,3))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (43,0)-(43,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right: ∅
        │   │   └── operator_loc: (43,1)-(43,3) = ".."
        │   ├── call_operator_loc: ∅
        │   ├── name: :>=
        │   ├── message_loc: (43,4)-(43,6) = ">="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (43,7)-(43,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (43,7)-(43,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (45,0)-(45,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RangeNode (location: (45,0)-(45,3))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (45,0)-(45,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right: ∅
        │   │   └── operator_loc: (45,1)-(45,3) = ".."
        │   ├── call_operator_loc: ∅
        │   ├── name: :<<
        │   ├── message_loc: (45,4)-(45,6) = "<<"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (45,7)-(45,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (45,7)-(45,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (47,0)-(47,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RangeNode (location: (47,0)-(47,3))
        │   │   ├── flags: static_literal
        │   │   ├── left:
        │   │   │   @ IntegerNode (location: (47,0)-(47,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── right: ∅
        │   │   └── operator_loc: (47,1)-(47,3) = ".."
        │   ├── call_operator_loc: ∅
        │   ├── name: :>>
        │   ├── message_loc: (47,4)-(47,6) = ">>"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (47,7)-(47,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (47,7)-(47,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ RangeNode (location: (49,0)-(49,7))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ IntegerNode (location: (49,0)-(49,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── right:
        │   │   @ CallNode (location: (49,4)-(49,7))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ IntegerNode (location: (49,6)-(49,7))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 2
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :+@
        │   │   ├── message_loc: (49,4)-(49,5) = "+"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (49,1)-(49,3) = ".."
        └── @ RangeNode (location: (51,0)-(51,7))
            ├── flags: newline
            ├── left:
            │   @ IntegerNode (location: (51,0)-(51,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── right:
            │   @ CallNode (location: (51,4)-(51,7))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ IntegerNode (location: (51,6)-(51,7))
            │   │   ├── flags: static_literal, decimal
            │   │   └── value: 2
            │   ├── call_operator_loc: ∅
            │   ├── name: :-@
            │   ├── message_loc: (51,4)-(51,5) = "-"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            └── operator_loc: (51,1)-(51,3) = ".."
prism-1.5.1/snapshots/regex.txt000066400000000000000000001012411506127434000165460ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(58,2))
├── flags: ∅
├── locals: [:foo, :ab, :abc, :a]
└── statements:
    @ StatementsNode (location: (1,0)-(58,2))
    ├── flags: ∅
    └── body: (length: 28)
        ├── @ CallNode (location: (1,0)-(1,9))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,4)-(1,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ RegularExpressionNode (location: (1,4)-(1,9))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (1,4)-(1,5) = "/"
        │   │           ├── content_loc: (1,5)-(1,8) = "bar"
        │   │           ├── closing_loc: (1,8)-(1,9) = "/"
        │   │           └── unescaped: "bar"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ RegularExpressionNode (location: (3,0)-(3,8))
        │   ├── flags: newline, static_literal, ignore_case, forced_us_ascii_encoding
        │   ├── opening_loc: (3,0)-(3,3) = "%r{"
        │   ├── content_loc: (3,3)-(3,6) = "abc"
        │   ├── closing_loc: (3,6)-(3,8) = "}i"
        │   └── unescaped: "abc"
        ├── @ RegularExpressionNode (location: (5,0)-(5,5))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (5,0)-(5,1) = "/"
        │   ├── content_loc: (5,1)-(5,4) = "a\\b"
        │   ├── closing_loc: (5,4)-(5,5) = "/"
        │   └── unescaped: "a\\b"
        ├── @ InterpolatedRegularExpressionNode (location: (7,0)-(7,11))
        │   ├── flags: newline
        │   ├── opening_loc: (7,0)-(7,1) = "/"
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (7,1)-(7,5))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (7,1)-(7,5) = "aaa "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "aaa "
        │   │   └── @ EmbeddedVariableNode (location: (7,5)-(7,10))
        │   │       ├── flags: ∅
        │   │       ├── operator_loc: (7,5)-(7,6) = "#"
        │   │       └── variable:
        │   │           @ GlobalVariableReadNode (location: (7,6)-(7,10))
        │   │           ├── flags: ∅
        │   │           └── name: :$bbb
        │   └── closing_loc: (7,10)-(7,11) = "/"
        ├── @ InterpolatedRegularExpressionNode (location: (9,0)-(9,16))
        │   ├── flags: newline
        │   ├── opening_loc: (9,0)-(9,1) = "/"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (9,1)-(9,5))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (9,1)-(9,5) = "aaa "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "aaa "
        │   │   ├── @ EmbeddedStatementsNode (location: (9,5)-(9,11))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (9,5)-(9,7) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (9,7)-(9,10))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (9,7)-(9,10))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :bbb
        │   │   │   │           ├── message_loc: (9,7)-(9,10) = "bbb"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── closing_loc: (9,10)-(9,11) = "}"
        │   │   └── @ StringNode (location: (9,11)-(9,15))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (9,11)-(9,15) = " ccc"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: " ccc"
        │   └── closing_loc: (9,15)-(9,16) = "/"
        ├── @ ArrayNode (location: (11,0)-(11,27))
        │   ├── flags: newline
        │   ├── elements: (length: 2)
        │   │   ├── @ MatchWriteNode (location: (11,1)-(11,21))
        │   │   │   ├── flags: ∅
        │   │   │   ├── call:
        │   │   │   │   @ CallNode (location: (11,1)-(11,21))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── receiver:
        │   │   │   │   │   @ RegularExpressionNode (location: (11,1)-(11,14))
        │   │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │   │   ├── opening_loc: (11,1)-(11,2) = "/"
        │   │   │   │   │   ├── content_loc: (11,2)-(11,13) = "(?bar)"
        │   │   │   │   │   ├── closing_loc: (11,13)-(11,14) = "/"
        │   │   │   │   │   └── unescaped: "(?bar)"
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :=~
        │   │   │   │   ├── message_loc: (11,15)-(11,17) = "=~"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments:
        │   │   │   │   │   @ ArgumentsNode (location: (11,18)-(11,21))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   └── arguments: (length: 1)
        │   │   │   │   │       └── @ CallNode (location: (11,18)-(11,21))
        │   │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │   │           ├── receiver: ∅
        │   │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │   │           ├── name: :baz
        │   │   │   │   │           ├── message_loc: (11,18)-(11,21) = "baz"
        │   │   │   │   │           ├── opening_loc: ∅
        │   │   │   │   │           ├── arguments: ∅
        │   │   │   │   │           ├── closing_loc: ∅
        │   │   │   │   │           └── block: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── targets: (length: 1)
        │   │   │       └── @ LocalVariableTargetNode (location: (11,5)-(11,8))
        │   │   │           ├── flags: ∅
        │   │   │           ├── name: :foo
        │   │   │           └── depth: 0
        │   │   └── @ LocalVariableReadNode (location: (11,23)-(11,26))
        │   │       ├── flags: ∅
        │   │       ├── name: :foo
        │   │       └── depth: 0
        │   ├── opening_loc: (11,0)-(11,1) = "["
        │   └── closing_loc: (11,26)-(11,27) = "]"
        ├── @ RegularExpressionNode (location: (13,0)-(13,6))
        │   ├── flags: newline, static_literal, ignore_case, forced_us_ascii_encoding
        │   ├── opening_loc: (13,0)-(13,1) = "/"
        │   ├── content_loc: (13,1)-(13,4) = "abc"
        │   ├── closing_loc: (13,4)-(13,6) = "/i"
        │   └── unescaped: "abc"
        ├── @ RegularExpressionNode (location: (15,0)-(15,26))
        │   ├── flags: newline, static_literal, ignore_case, forced_us_ascii_encoding
        │   ├── opening_loc: (15,0)-(15,3) = "%r/"
        │   ├── content_loc: (15,3)-(15,24) = "[a-z$._?][\\w$.?\#@~]*:"
        │   ├── closing_loc: (15,24)-(15,26) = "/i"
        │   └── unescaped: "[a-z$._?][\\w$.?\#@~]*:"
        ├── @ RegularExpressionNode (location: (17,0)-(17,37))
        │   ├── flags: newline, static_literal, ignore_case, forced_us_ascii_encoding
        │   ├── opening_loc: (17,0)-(17,3) = "%r/"
        │   ├── content_loc: (17,3)-(17,35) = "([a-z$._?][\\w$.?\#@~]*)(\\s+)(equ)"
        │   ├── closing_loc: (17,35)-(17,37) = "/i"
        │   └── unescaped: "([a-z$._?][\\w$.?\#@~]*)(\\s+)(equ)"
        ├── @ RegularExpressionNode (location: (19,0)-(19,25))
        │   ├── flags: newline, static_literal, ignore_case, forced_us_ascii_encoding
        │   ├── opening_loc: (19,0)-(19,3) = "%r/"
        │   ├── content_loc: (19,3)-(19,23) = "[a-z$._?][\\w$.?\#@~]*"
        │   ├── closing_loc: (19,23)-(19,25) = "/i"
        │   └── unescaped: "[a-z$._?][\\w$.?\#@~]*"
        ├── @ RegularExpressionNode (location: (21,0)-(24,1))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (21,0)-(21,3) = "%r("
        │   ├── content_loc: (21,3)-(24,0) = "\n(?:[\#$%_']|\\(\\)|\\(,\\)|\\[\\]|[0-9])*\n  (?:[\#$%_']+)\n"
        │   ├── closing_loc: (24,0)-(24,1) = ")"
        │   └── unescaped: "\n(?:[\#$%_']|\\(\\)|\\(,\\)|\\[\\]|[0-9])*\n  (?:[\#$%_']+)\n"
        ├── @ CallNode (location: (26,0)-(26,16))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RegularExpressionNode (location: (26,0)-(26,8))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (26,0)-(26,1) = "/"
        │   │   ├── content_loc: (26,1)-(26,7) = "(?#\\))"
        │   │   ├── closing_loc: (26,7)-(26,8) = "/"
        │   │   └── unescaped: "(?#\\))"
        │   ├── call_operator_loc: ∅
        │   ├── name: :=~
        │   ├── message_loc: (26,9)-(26,11) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (26,12)-(26,16))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (26,12)-(26,16))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (26,12)-(26,13) = "\""
        │   │           ├── content_loc: (26,13)-(26,15) = "hi"
        │   │           ├── closing_loc: (26,15)-(26,16) = "\""
        │   │           └── unescaped: "hi"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ RegularExpressionNode (location: (28,0)-(28,9))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (28,0)-(28,3) = "%r#"
        │   ├── content_loc: (28,3)-(28,8) = "pound"
        │   ├── closing_loc: (28,8)-(28,9) = "#"
        │   └── unescaped: "pound"
        ├── @ InterpolatedRegularExpressionNode (location: (30,0)-(30,13))
        │   ├── flags: newline, once
        │   ├── opening_loc: (30,0)-(30,1) = "/"
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (30,1)-(30,5))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (30,1)-(30,5) = "aaa "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "aaa "
        │   │   └── @ EmbeddedStatementsNode (location: (30,5)-(30,11))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (30,5)-(30,7) = "\#{"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (30,7)-(30,10))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (30,7)-(30,10))
        │   │       │           ├── flags: variable_call, ignore_visibility
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :bbb
        │   │       │           ├── message_loc: (30,7)-(30,10) = "bbb"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments: ∅
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       └── closing_loc: (30,10)-(30,11) = "}"
        │   └── closing_loc: (30,11)-(30,13) = "/o"
        ├── @ MatchWriteNode (location: (32,0)-(33,10))
        │   ├── flags: newline
        │   ├── call:
        │   │   @ CallNode (location: (32,0)-(33,10))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ RegularExpressionNode (location: (32,0)-(33,4))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (32,0)-(32,1) = "/"
        │   │   │   ├── content_loc: (32,1)-(33,3) = "(?)"
        │   │   │   ├── closing_loc: (33,3)-(33,4) = "/"
        │   │   │   └── unescaped: "(?)"
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :=~
        │   │   ├── message_loc: (33,5)-(33,7) = "=~"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (33,8)-(33,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ StringNode (location: (33,8)-(33,10))
        │   │   │           ├── flags: ∅
        │   │   │           ├── opening_loc: (33,8)-(33,9) = "\""
        │   │   │           ├── content_loc: (33,9)-(33,9) = ""
        │   │   │           ├── closing_loc: (33,9)-(33,10) = "\""
        │   │   │           └── unescaped: ""
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── targets: (length: 1)
        │       └── @ LocalVariableTargetNode (location: (32,0)-(33,4))
        │           ├── flags: ∅
        │           ├── name: :ab
        │           └── depth: 0
        ├── @ LocalVariableReadNode (location: (33,12)-(33,14))
        │   ├── flags: newline
        │   ├── name: :ab
        │   └── depth: 0
        ├── @ MatchWriteNode (location: (35,0)-(35,24))
        │   ├── flags: newline
        │   ├── call:
        │   │   @ CallNode (location: (35,0)-(35,24))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ RegularExpressionNode (location: (35,0)-(35,18))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (35,0)-(35,1) = "/"
        │   │   │   ├── content_loc: (35,1)-(35,17) = "(?)(?)"
        │   │   │   ├── closing_loc: (35,17)-(35,18) = "/"
        │   │   │   └── unescaped: "(?)(?)"
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :=~
        │   │   ├── message_loc: (35,19)-(35,21) = "=~"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (35,22)-(35,24))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ StringNode (location: (35,22)-(35,24))
        │   │   │           ├── flags: ∅
        │   │   │           ├── opening_loc: (35,22)-(35,23) = "\""
        │   │   │           ├── content_loc: (35,23)-(35,23) = ""
        │   │   │           ├── closing_loc: (35,23)-(35,24) = "\""
        │   │   │           └── unescaped: ""
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── targets: (length: 1)
        │       └── @ LocalVariableTargetNode (location: (35,4)-(35,7))
        │           ├── flags: ∅
        │           ├── name: :abc
        │           └── depth: 0
        ├── @ LocalVariableReadNode (location: (35,26)-(35,29))
        │   ├── flags: newline
        │   ├── name: :abc
        │   └── depth: 0
        ├── @ CallNode (location: (37,0)-(37,16))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RegularExpressionNode (location: (37,0)-(37,10))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (37,0)-(37,1) = "/"
        │   │   ├── content_loc: (37,1)-(37,9) = "(?)"
        │   │   ├── closing_loc: (37,9)-(37,10) = "/"
        │   │   └── unescaped: "(?)"
        │   ├── call_operator_loc: ∅
        │   ├── name: :=~
        │   ├── message_loc: (37,11)-(37,13) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (37,14)-(37,16))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (37,14)-(37,16))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (37,14)-(37,15) = "\""
        │   │           ├── content_loc: (37,15)-(37,15) = ""
        │   │           ├── closing_loc: (37,15)-(37,16) = "\""
        │   │           └── unescaped: ""
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ LocalVariableWriteNode (location: (39,0)-(39,5))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── depth: 0
        │   ├── name_loc: (39,0)-(39,1) = "a"
        │   ├── value:
        │   │   @ IntegerNode (location: (39,4)-(39,5))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (39,2)-(39,3) = "="
        ├── @ CallNode (location: (40,0)-(40,24))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (40,0)-(40,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (40,4)-(40,24))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (40,6)-(40,22))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ MatchWriteNode (location: (40,6)-(40,22))
        │       │           ├── flags: newline
        │       │           ├── call:
        │       │           │   @ CallNode (location: (40,6)-(40,22))
        │       │           │   ├── flags: ∅
        │       │           │   ├── receiver:
        │       │           │   │   @ RegularExpressionNode (location: (40,6)-(40,14))
        │       │           │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │       │           │   │   ├── opening_loc: (40,6)-(40,7) = "/"
        │       │           │   │   ├── content_loc: (40,7)-(40,13) = "(?)"
        │       │           │   │   ├── closing_loc: (40,13)-(40,14) = "/"
        │       │           │   │   └── unescaped: "(?)"
        │       │           │   ├── call_operator_loc: ∅
        │       │           │   ├── name: :=~
        │       │           │   ├── message_loc: (40,15)-(40,17) = "=~"
        │       │           │   ├── opening_loc: ∅
        │       │           │   ├── arguments:
        │       │           │   │   @ ArgumentsNode (location: (40,18)-(40,22))
        │       │           │   │   ├── flags: ∅
        │       │           │   │   └── arguments: (length: 1)
        │       │           │   │       └── @ CallNode (location: (40,18)-(40,22))
        │       │           │   │           ├── flags: variable_call, ignore_visibility
        │       │           │   │           ├── receiver: ∅
        │       │           │   │           ├── call_operator_loc: ∅
        │       │           │   │           ├── name: :to_s
        │       │           │   │           ├── message_loc: (40,18)-(40,22) = "to_s"
        │       │           │   │           ├── opening_loc: ∅
        │       │           │   │           ├── arguments: ∅
        │       │           │   │           ├── closing_loc: ∅
        │       │           │   │           └── block: ∅
        │       │           │   ├── closing_loc: ∅
        │       │           │   └── block: ∅
        │       │           └── targets: (length: 1)
        │       │               └── @ LocalVariableTargetNode (location: (40,10)-(40,11))
        │       │                   ├── flags: ∅
        │       │                   ├── name: :a
        │       │                   └── depth: 1
        │       ├── opening_loc: (40,4)-(40,5) = "{"
        │       └── closing_loc: (40,23)-(40,24) = "}"
        ├── @ MatchWriteNode (location: (42,0)-(42,16))
        │   ├── flags: newline
        │   ├── call:
        │   │   @ CallNode (location: (42,0)-(42,16))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ RegularExpressionNode (location: (42,0)-(42,10))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (42,0)-(42,1) = "/"
        │   │   │   ├── content_loc: (42,1)-(42,9) = "(?)"
        │   │   │   ├── closing_loc: (42,9)-(42,10) = "/"
        │   │   │   └── unescaped: "(?)"
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :=~
        │   │   ├── message_loc: (42,11)-(42,13) = "=~"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (42,14)-(42,16))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ StringNode (location: (42,14)-(42,16))
        │   │   │           ├── flags: ∅
        │   │   │           ├── opening_loc: (42,14)-(42,15) = "\""
        │   │   │           ├── content_loc: (42,15)-(42,15) = ""
        │   │   │           ├── closing_loc: (42,15)-(42,16) = "\""
        │   │   │           └── unescaped: ""
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── targets: (length: 1)
        │       └── @ LocalVariableTargetNode (location: (42,4)-(42,7))
        │           ├── flags: ∅
        │           ├── name: :foo
        │           └── depth: 0
        ├── @ CallNode (location: (43,0)-(43,16))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RegularExpressionNode (location: (43,0)-(43,10))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (43,0)-(43,1) = "/"
        │   │   ├── content_loc: (43,1)-(43,9) = "(?)"
        │   │   ├── closing_loc: (43,9)-(43,10) = "/"
        │   │   └── unescaped: "(?)"
        │   ├── call_operator_loc: ∅
        │   ├── name: :=~
        │   ├── message_loc: (43,11)-(43,13) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (43,14)-(43,16))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (43,14)-(43,16))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (43,14)-(43,15) = "\""
        │   │           ├── content_loc: (43,15)-(43,15) = ""
        │   │           ├── closing_loc: (43,15)-(43,16) = "\""
        │   │           └── unescaped: ""
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (45,0)-(45,16))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RegularExpressionNode (location: (45,0)-(45,10))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (45,0)-(45,1) = "/"
        │   │   ├── content_loc: (45,1)-(45,9) = "(?)"
        │   │   ├── closing_loc: (45,9)-(45,10) = "/"
        │   │   └── unescaped: "(?)"
        │   ├── call_operator_loc: ∅
        │   ├── name: :=~
        │   ├── message_loc: (45,11)-(45,13) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (45,14)-(45,16))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (45,14)-(45,16))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (45,14)-(45,15) = "\""
        │   │           ├── content_loc: (45,15)-(45,15) = ""
        │   │           ├── closing_loc: (45,15)-(45,16) = "\""
        │   │           └── unescaped: ""
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ DefNode (location: (46,0)-(46,32))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (46,4)-(46,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (46,8)-(46,12))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ RequiredKeywordParameterNode (location: (46,8)-(46,12))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :nil
        │   │   │       └── name_loc: (46,8)-(46,12) = "nil:"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (46,16)-(46,32))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ MatchWriteNode (location: (46,16)-(46,32))
        │   │           ├── flags: ∅
        │   │           ├── call:
        │   │           │   @ CallNode (location: (46,16)-(46,32))
        │   │           │   ├── flags: ∅
        │   │           │   ├── receiver:
        │   │           │   │   @ RegularExpressionNode (location: (46,16)-(46,26))
        │   │           │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │           │   │   ├── opening_loc: (46,16)-(46,17) = "/"
        │   │           │   │   ├── content_loc: (46,17)-(46,25) = "(?)"
        │   │           │   │   ├── closing_loc: (46,25)-(46,26) = "/"
        │   │           │   │   └── unescaped: "(?)"
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :=~
        │   │           │   ├── message_loc: (46,27)-(46,29) = "=~"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments:
        │   │           │   │   @ ArgumentsNode (location: (46,30)-(46,32))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   └── arguments: (length: 1)
        │   │           │   │       └── @ StringNode (location: (46,30)-(46,32))
        │   │           │   │           ├── flags: ∅
        │   │           │   │           ├── opening_loc: (46,30)-(46,31) = "\""
        │   │           │   │           ├── content_loc: (46,31)-(46,31) = ""
        │   │           │   │           ├── closing_loc: (46,31)-(46,32) = "\""
        │   │           │   │           └── unescaped: ""
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           └── targets: (length: 1)
        │   │               └── @ LocalVariableTargetNode (location: (46,20)-(46,23))
        │   │                   ├── flags: ∅
        │   │                   ├── name: :nil
        │   │                   └── depth: 0
        │   ├── locals: [:nil]
        │   ├── def_keyword_loc: (46,0)-(46,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (46,7)-(46,8) = "("
        │   ├── rparen_loc: (46,12)-(46,13) = ")"
        │   ├── equal_loc: (46,14)-(46,15) = "="
        │   └── end_keyword_loc: ∅
        ├── @ RegularExpressionNode (location: (48,0)-(48,10))
        │   ├── flags: newline, static_literal, extended, forced_us_ascii_encoding
        │   ├── opening_loc: (48,0)-(48,1) = "/"
        │   ├── content_loc: (48,1)-(48,8) = "(?-x:#)"
        │   ├── closing_loc: (48,8)-(48,10) = "/x"
        │   └── unescaped: "(?-x:#)"
        ├── @ RegularExpressionNode (location: (50,0)-(56,1))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (50,0)-(50,1) = "/"
        │   ├── content_loc: (50,1)-(56,0) = "a\nb\\\nc\\\nd\\\\\\\ne\\\\\nf\\\n"
        │   ├── closing_loc: (56,0)-(56,1) = "/"
        │   └── unescaped: "a\nbcd\\\\e\\\\\nf"
        └── @ RegularExpressionNode (location: (58,0)-(58,2))
            ├── flags: newline, static_literal, forced_us_ascii_encoding
            ├── opening_loc: (58,0)-(58,1) = "/"
            ├── content_loc: (58,1)-(58,1) = ""
            ├── closing_loc: (58,1)-(58,2) = "/"
            └── unescaped: ""
prism-1.5.1/snapshots/regex_char_width.txt000066400000000000000000000057231506127434000207520ustar00rootroot00000000000000@ ProgramNode (location: (2,0)-(3,6))
├── flags: ∅
├── locals: [:a, :b]
└── statements:
    @ StatementsNode (location: (2,0)-(3,6))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ MatchWriteNode (location: (2,0)-(2,36))
        │   ├── flags: newline
        │   ├── call:
        │   │   @ CallNode (location: (2,0)-(2,36))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ RegularExpressionNode (location: (2,0)-(2,22))
        │   │   │   ├── flags: static_literal
        │   │   │   ├── opening_loc: (2,0)-(2,1) = "/"
        │   │   │   ├── content_loc: (2,1)-(2,21) = "\x{E285}\xA7(?.)\x{E285}\xA9(?.)"
        │   │   │   ├── closing_loc: (2,21)-(2,22) = "/"
        │   │   │   └── unescaped: "\x{E285}\xA7(?.)\x{E285}\xA9(?.)"
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :=~
        │   │   ├── message_loc: (2,23)-(2,25) = "=~"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (2,26)-(2,36))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ StringNode (location: (2,26)-(2,36))
        │   │   │           ├── flags: ∅
        │   │   │           ├── opening_loc: (2,26)-(2,27) = "'"
        │   │   │           ├── content_loc: (2,27)-(2,35) = "\x{E285}\xA7a\x{E285}\xA9b"
        │   │   │           ├── closing_loc: (2,35)-(2,36) = "'"
        │   │   │           └── unescaped: "\x{E285}\xA7a\x{E285}\xA9b"
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── targets: (length: 2)
        │       ├── @ LocalVariableTargetNode (location: (2,7)-(2,8))
        │       │   ├── flags: ∅
        │       │   ├── name: :a
        │       │   └── depth: 0
        │       └── @ LocalVariableTargetNode (location: (2,17)-(2,18))
        │           ├── flags: ∅
        │           ├── name: :b
        │           └── depth: 0
        └── @ ArrayNode (location: (3,0)-(3,6))
            ├── flags: newline
            ├── elements: (length: 2)
            │   ├── @ LocalVariableReadNode (location: (3,1)-(3,2))
            │   │   ├── flags: ∅
            │   │   ├── name: :a
            │   │   └── depth: 0
            │   └── @ LocalVariableReadNode (location: (3,4)-(3,5))
            │       ├── flags: ∅
            │       ├── name: :b
            │       └── depth: 0
            ├── opening_loc: (3,0)-(3,1) = "["
            └── closing_loc: (3,5)-(3,6) = "]"
prism-1.5.1/snapshots/regex_escape_encoding.txt000066400000000000000000000040201506127434000217310ustar00rootroot00000000000000@ ProgramNode (location: (2,0)-(3,21))
├── flags: ∅
├── locals: [:str]
└── statements:
    @ StatementsNode (location: (2,0)-(3,21))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ LocalVariableWriteNode (location: (2,0)-(2,18))
        │   ├── flags: newline
        │   ├── name: :str
        │   ├── depth: 0
        │   ├── name_loc: (2,0)-(2,3) = "str"
        │   ├── value:
        │   │   @ StringNode (location: (2,6)-(2,18))
        │   │   ├── flags: forced_binary_encoding
        │   │   ├── opening_loc: (2,6)-(2,7) = "\""
        │   │   ├── content_loc: (2,7)-(2,17) = "hello \\xFC"
        │   │   ├── closing_loc: (2,17)-(2,18) = "\""
        │   │   └── unescaped: "hello \xFC"
        │   └── operator_loc: (2,4)-(2,5) = "="
        └── @ CallNode (location: (3,0)-(3,21))
            ├── flags: newline
            ├── receiver:
            │   @ LocalVariableReadNode (location: (3,0)-(3,3))
            │   ├── flags: ∅
            │   ├── name: :str
            │   └── depth: 0
            ├── call_operator_loc: ∅
            ├── name: :=~
            ├── message_loc: (3,4)-(3,6) = "=~"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (3,7)-(3,21))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ RegularExpressionNode (location: (3,7)-(3,21))
            │           ├── flags: static_literal, forced_utf8_encoding
            │           ├── opening_loc: (3,7)-(3,8) = "/"
            │           ├── content_loc: (3,8)-(3,20) = "hello \\u{fc}"
            │           ├── closing_loc: (3,20)-(3,21) = "/"
            │           └── unescaped: "hello \\u{fc}"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/regex_with_fake_newlines.txt000066400000000000000000000143551506127434000225040ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(41,1))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(41,1))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ RegularExpressionNode (location: (1,0)-(13,1))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (1,0)-(1,1) = "/"
        │   ├── content_loc: (1,1)-(13,0) = "\n  \\n\n  \\n\n  exit\n  \\\\n\n  \\n\\n\\n\\n\n  argh\n  \\\\\n  \\\\\\\n  foo\\nbar\n  \\f\n  ok\n"
        │   ├── closing_loc: (13,0)-(13,1) = "/"
        │   └── unescaped: "\n  \\n\n  \\n\n  exit\n  \\\\n\n  \\n\\n\\n\\n\n  argh\n  \\\\\n  \\\\  foo\\nbar\n  \\f\n  ok\n"
        ├── @ RegularExpressionNode (location: (15,0)-(27,1))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (15,0)-(15,3) = "%r{"
        │   ├── content_loc: (15,3)-(27,0) = "\n  \\n\n  \\n\n  exit\n  \\\\n\n  \\n\\n\\n\\n\n  argh\n  \\\\\n  \\\\\\\n  foo\\nbar\n  \\f\n  ok\n"
        │   ├── closing_loc: (27,0)-(27,1) = "}"
        │   └── unescaped: "\n  \\n\n  \\n\n  exit\n  \\\\n\n  \\n\\n\\n\\n\n  argh\n  \\\\\n  \\\\  foo\\nbar\n  \\f\n  ok\n"
        └── @ InterpolatedRegularExpressionNode (location: (29,0)-(41,1))
            ├── flags: newline
            ├── opening_loc: (29,0)-(29,3) = "%r{"
            ├── parts: (length: 9)
            │   ├── @ StringNode (location: (29,3)-(30,2))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (29,3)-(30,2) = "\n  "
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "\n  "
            │   ├── @ EmbeddedStatementsNode (location: (30,2)-(30,8))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (30,2)-(30,4) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (30,4)-(30,7))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ IntegerNode (location: (30,4)-(30,7))
            │   │   │           ├── flags: static_literal, decimal
            │   │   │           └── value: 123
            │   │   └── closing_loc: (30,7)-(30,8) = "}"
            │   ├── @ StringNode (location: (30,8)-(33,4))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (30,8)-(33,4) = "\\n\n  \\n\n  exit\\\\\\\n  \\\\"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "\\n\n  \\n\n  exit\\\\  \\\\"
            │   ├── @ EmbeddedStatementsNode (location: (33,4)-(33,10))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (33,4)-(33,6) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (33,6)-(33,9))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ IntegerNode (location: (33,6)-(33,9))
            │   │   │           ├── flags: static_literal, decimal
            │   │   │           └── value: 123
            │   │   └── closing_loc: (33,9)-(33,10) = "}"
            │   ├── @ StringNode (location: (33,10)-(34,4))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (33,10)-(34,4) = "n\n  \\n"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "n\n  \\n"
            │   ├── @ EmbeddedStatementsNode (location: (34,4)-(34,10))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (34,4)-(34,6) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (34,6)-(34,9))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ IntegerNode (location: (34,6)-(34,9))
            │   │   │           ├── flags: static_literal, decimal
            │   │   │           └── value: 123
            │   │   └── closing_loc: (34,9)-(34,10) = "}"
            │   ├── @ StringNode (location: (34,10)-(36,4))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (34,10)-(36,4) = "\\n\\n\\n\n  argh\\\n  \\\\"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "\\n\\n\\n\n  argh  \\\\"
            │   ├── @ EmbeddedStatementsNode (location: (36,4)-(36,10))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (36,4)-(36,6) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (36,6)-(36,9))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ IntegerNode (location: (36,6)-(36,9))
            │   │   │           ├── flags: static_literal, decimal
            │   │   │           └── value: 123
            │   │   └── closing_loc: (36,9)-(36,10) = "}"
            │   └── @ StringNode (location: (36,10)-(41,0))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (36,10)-(41,0) = "baz\\\\\n  \\\\\\\n  foo\\nbar\n  \\f\n  ok\n"
            │       ├── closing_loc: ∅
            │       └── unescaped: "baz\\\\\n  \\\\  foo\\nbar\n  \\f\n  ok\n"
            └── closing_loc: (41,0)-(41,1) = "}"
prism-1.5.1/snapshots/repeat_parameters.txt000066400000000000000000000665071506127434000211560ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(38,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(38,3))
    ├── flags: ∅
    └── body: (length: 13)
        ├── @ DefNode (location: (1,0)-(2,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (1,4)-(1,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (1,8)-(1,12))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 2)
        │   │   │   ├── @ RequiredParameterNode (location: (1,8)-(1,9))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :a
        │   │   │   └── @ RequiredParameterNode (location: (1,11)-(1,12))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :_
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :_]
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (1,7)-(1,8) = "("
        │   ├── rparen_loc: (1,12)-(1,13) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (2,0)-(2,3) = "end"
        ├── @ DefNode (location: (4,0)-(5,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (4,4)-(4,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (4,8)-(4,15))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 3)
        │   │   │   ├── @ RequiredParameterNode (location: (4,8)-(4,9))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :a
        │   │   │   ├── @ RequiredParameterNode (location: (4,11)-(4,12))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :_
        │   │   │   └── @ RequiredParameterNode (location: (4,14)-(4,15))
        │   │   │       ├── flags: repeated_parameter
        │   │   │       └── name: :_
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :_]
        │   ├── def_keyword_loc: (4,0)-(4,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (4,7)-(4,8) = "("
        │   ├── rparen_loc: (4,15)-(4,16) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (5,0)-(5,3) = "end"
        ├── @ DefNode (location: (7,0)-(8,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (7,4)-(7,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (7,8)-(7,19))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 4)
        │   │   │   ├── @ RequiredParameterNode (location: (7,8)-(7,9))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :a
        │   │   │   ├── @ RequiredParameterNode (location: (7,11)-(7,12))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :_
        │   │   │   ├── @ RequiredParameterNode (location: (7,14)-(7,15))
        │   │   │   │   ├── flags: repeated_parameter
        │   │   │   │   └── name: :_
        │   │   │   └── @ RequiredParameterNode (location: (7,17)-(7,19))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :_b
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :_, :_b]
        │   ├── def_keyword_loc: (7,0)-(7,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (7,7)-(7,8) = "("
        │   ├── rparen_loc: (7,19)-(7,20) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (8,0)-(8,3) = "end"
        ├── @ DefNode (location: (10,0)-(11,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (10,4)-(10,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (10,8)-(10,23))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 5)
        │   │   │   ├── @ RequiredParameterNode (location: (10,8)-(10,9))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :a
        │   │   │   ├── @ RequiredParameterNode (location: (10,11)-(10,12))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :_
        │   │   │   ├── @ RequiredParameterNode (location: (10,14)-(10,15))
        │   │   │   │   ├── flags: repeated_parameter
        │   │   │   │   └── name: :_
        │   │   │   ├── @ RequiredParameterNode (location: (10,17)-(10,19))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :_b
        │   │   │   └── @ RequiredParameterNode (location: (10,21)-(10,23))
        │   │   │       ├── flags: repeated_parameter
        │   │   │       └── name: :_b
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :_, :_b]
        │   ├── def_keyword_loc: (10,0)-(10,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (10,7)-(10,8) = "("
        │   ├── rparen_loc: (10,23)-(10,24) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (11,0)-(11,3) = "end"
        ├── @ DefNode (location: (13,0)-(14,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (13,4)-(13,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (13,8)-(13,35))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 3)
        │   │   │   ├── @ RequiredParameterNode (location: (13,8)-(13,9))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :a
        │   │   │   ├── @ MultiTargetNode (location: (13,11)-(13,22))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── lefts: (length: 1)
        │   │   │   │   │   └── @ RequiredParameterNode (location: (13,12)-(13,13))
        │   │   │   │   │       ├── flags: ∅
        │   │   │   │   │       └── name: :b
        │   │   │   │   ├── rest:
        │   │   │   │   │   @ SplatNode (location: (13,15)-(13,18))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   ├── operator_loc: (13,15)-(13,16) = "*"
        │   │   │   │   │   └── expression:
        │   │   │   │   │       @ RequiredParameterNode (location: (13,16)-(13,18))
        │   │   │   │   │       ├── flags: ∅
        │   │   │   │   │       └── name: :_c
        │   │   │   │   ├── rights: (length: 1)
        │   │   │   │   │   └── @ RequiredParameterNode (location: (13,20)-(13,21))
        │   │   │   │   │       ├── flags: ∅
        │   │   │   │   │       └── name: :d
        │   │   │   │   ├── lparen_loc: (13,11)-(13,12) = "("
        │   │   │   │   └── rparen_loc: (13,21)-(13,22) = ")"
        │   │   │   └── @ MultiTargetNode (location: (13,24)-(13,35))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 1)
        │   │   │       │   └── @ RequiredParameterNode (location: (13,25)-(13,26))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :e
        │   │   │       ├── rest:
        │   │   │       │   @ SplatNode (location: (13,28)-(13,31))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   ├── operator_loc: (13,28)-(13,29) = "*"
        │   │   │       │   └── expression:
        │   │   │       │       @ RequiredParameterNode (location: (13,29)-(13,31))
        │   │   │       │       ├── flags: repeated_parameter
        │   │   │       │       └── name: :_c
        │   │   │       ├── rights: (length: 1)
        │   │   │       │   └── @ RequiredParameterNode (location: (13,33)-(13,34))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :f
        │   │   │       ├── lparen_loc: (13,24)-(13,25) = "("
        │   │   │       └── rparen_loc: (13,34)-(13,35) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :b, :_c, :d, :e, :f]
        │   ├── def_keyword_loc: (13,0)-(13,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (13,7)-(13,8) = "("
        │   ├── rparen_loc: (13,35)-(13,36) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (14,0)-(14,3) = "end"
        ├── @ DefNode (location: (16,0)-(17,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (16,4)-(16,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (16,8)-(16,20))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 4)
        │   │   │   ├── @ RequiredParameterNode (location: (16,8)-(16,10))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :_a
        │   │   │   ├── @ RequiredParameterNode (location: (16,12)-(16,14))
        │   │   │   │   ├── flags: repeated_parameter
        │   │   │   │   └── name: :_a
        │   │   │   ├── @ RequiredParameterNode (location: (16,16)-(16,17))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :b
        │   │   │   └── @ RequiredParameterNode (location: (16,19)-(16,20))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :c
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:_a, :b, :c]
        │   ├── def_keyword_loc: (16,0)-(16,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (16,7)-(16,8) = "("
        │   ├── rparen_loc: (16,20)-(16,21) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (17,0)-(17,3) = "end"
        ├── @ DefNode (location: (19,0)-(20,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (19,4)-(19,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (19,8)-(19,32))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 2)
        │   │   │   ├── @ MultiTargetNode (location: (19,8)-(19,19))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── lefts: (length: 1)
        │   │   │   │   │   └── @ RequiredParameterNode (location: (19,9)-(19,10))
        │   │   │   │   │       ├── flags: ∅
        │   │   │   │   │       └── name: :a
        │   │   │   │   ├── rest:
        │   │   │   │   │   @ SplatNode (location: (19,12)-(19,15))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   ├── operator_loc: (19,12)-(19,13) = "*"
        │   │   │   │   │   └── expression:
        │   │   │   │   │       @ RequiredParameterNode (location: (19,13)-(19,15))
        │   │   │   │   │       ├── flags: ∅
        │   │   │   │   │       └── name: :_b
        │   │   │   │   ├── rights: (length: 1)
        │   │   │   │   │   └── @ RequiredParameterNode (location: (19,17)-(19,18))
        │   │   │   │   │       ├── flags: ∅
        │   │   │   │   │       └── name: :c
        │   │   │   │   ├── lparen_loc: (19,8)-(19,9) = "("
        │   │   │   │   └── rparen_loc: (19,18)-(19,19) = ")"
        │   │   │   └── @ MultiTargetNode (location: (19,21)-(19,32))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 1)
        │   │   │       │   └── @ RequiredParameterNode (location: (19,22)-(19,23))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :d
        │   │   │       ├── rest:
        │   │   │       │   @ SplatNode (location: (19,25)-(19,28))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   ├── operator_loc: (19,25)-(19,26) = "*"
        │   │   │       │   └── expression:
        │   │   │       │       @ RequiredParameterNode (location: (19,26)-(19,28))
        │   │   │       │       ├── flags: repeated_parameter
        │   │   │       │       └── name: :_b
        │   │   │       ├── rights: (length: 1)
        │   │   │       │   └── @ RequiredParameterNode (location: (19,30)-(19,31))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :e
        │   │   │       ├── lparen_loc: (19,21)-(19,22) = "("
        │   │   │       └── rparen_loc: (19,31)-(19,32) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :_b, :c, :d, :e]
        │   ├── def_keyword_loc: (19,0)-(19,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (19,7)-(19,8) = "("
        │   ├── rparen_loc: (19,32)-(19,33) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (20,0)-(20,3) = "end"
        ├── @ DefNode (location: (22,0)-(23,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (22,4)-(22,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (22,8)-(22,22))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 2)
        │   │   │   ├── @ OptionalParameterNode (location: (22,8)-(22,14))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :_a
        │   │   │   │   ├── name_loc: (22,8)-(22,10) = "_a"
        │   │   │   │   ├── operator_loc: (22,11)-(22,12) = "="
        │   │   │   │   └── value:
        │   │   │   │       @ IntegerNode (location: (22,13)-(22,14))
        │   │   │   │       ├── flags: static_literal, decimal
        │   │   │   │       └── value: 1
        │   │   │   └── @ OptionalParameterNode (location: (22,16)-(22,22))
        │   │   │       ├── flags: repeated_parameter
        │   │   │       ├── name: :_a
        │   │   │       ├── name_loc: (22,16)-(22,18) = "_a"
        │   │   │       ├── operator_loc: (22,19)-(22,20) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (22,21)-(22,22))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:_a]
        │   ├── def_keyword_loc: (22,0)-(22,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (22,7)-(22,8) = "("
        │   ├── rparen_loc: (22,22)-(22,23) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (23,0)-(23,3) = "end"
        ├── @ DefNode (location: (25,0)-(26,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (25,4)-(25,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (25,8)-(25,16))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 2)
        │   │   │   ├── @ RequiredKeywordParameterNode (location: (25,8)-(25,11))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :_a
        │   │   │   │   └── name_loc: (25,8)-(25,11) = "_a:"
        │   │   │   └── @ RequiredKeywordParameterNode (location: (25,13)-(25,16))
        │   │   │       ├── flags: repeated_parameter
        │   │   │       ├── name: :_a
        │   │   │       └── name_loc: (25,13)-(25,16) = "_a:"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:_a]
        │   ├── def_keyword_loc: (25,0)-(25,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (25,7)-(25,8) = "("
        │   ├── rparen_loc: (25,16)-(25,17) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (26,0)-(26,3) = "end"
        ├── @ DefNode (location: (28,0)-(29,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (28,4)-(28,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (28,8)-(28,20))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 2)
        │   │   │   ├── @ OptionalKeywordParameterNode (location: (28,8)-(28,13))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :_a
        │   │   │   │   ├── name_loc: (28,8)-(28,11) = "_a:"
        │   │   │   │   └── value:
        │   │   │   │       @ IntegerNode (location: (28,12)-(28,13))
        │   │   │   │       ├── flags: static_literal, decimal
        │   │   │   │       └── value: 1
        │   │   │   └── @ OptionalKeywordParameterNode (location: (28,15)-(28,20))
        │   │   │       ├── flags: repeated_parameter
        │   │   │       ├── name: :_a
        │   │   │       ├── name_loc: (28,15)-(28,18) = "_a:"
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (28,19)-(28,20))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:_a]
        │   ├── def_keyword_loc: (28,0)-(28,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (28,7)-(28,8) = "("
        │   ├── rparen_loc: (28,20)-(28,21) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (29,0)-(29,3) = "end"
        ├── @ DefNode (location: (31,0)-(32,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (31,4)-(31,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (31,8)-(31,16))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (31,8)-(31,10))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :_a
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ KeywordRestParameterNode (location: (31,12)-(31,16))
        │   │   │   ├── flags: repeated_parameter
        │   │   │   ├── name: :_a
        │   │   │   ├── name_loc: (31,14)-(31,16) = "_a"
        │   │   │   └── operator_loc: (31,12)-(31,14) = "**"
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:_a]
        │   ├── def_keyword_loc: (31,0)-(31,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (31,7)-(31,8) = "("
        │   ├── rparen_loc: (31,16)-(31,17) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (32,0)-(32,3) = "end"
        ├── @ DefNode (location: (34,0)-(35,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (34,4)-(34,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (34,8)-(34,15))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (34,8)-(34,10))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :_a
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (34,12)-(34,15))
        │   │       ├── flags: repeated_parameter
        │   │       ├── name: :_a
        │   │       ├── name_loc: (34,13)-(34,15) = "_a"
        │   │       └── operator_loc: (34,12)-(34,13) = "&"
        │   ├── body: ∅
        │   ├── locals: [:_a]
        │   ├── def_keyword_loc: (34,0)-(34,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (34,7)-(34,8) = "("
        │   ├── rparen_loc: (34,15)-(34,16) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (35,0)-(35,3) = "end"
        └── @ DefNode (location: (37,0)-(38,3))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (37,4)-(37,7) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (37,8)-(37,15))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (37,8)-(37,10))
            │   │       ├── flags: ∅
            │   │       └── name: :_a
            │   ├── optionals: (length: 0)
            │   ├── rest:
            │   │   @ RestParameterNode (location: (37,12)-(37,15))
            │   │   ├── flags: repeated_parameter
            │   │   ├── name: :_a
            │   │   ├── name_loc: (37,13)-(37,15) = "_a"
            │   │   └── operator_loc: (37,12)-(37,13) = "*"
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:_a]
            ├── def_keyword_loc: (37,0)-(37,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (37,7)-(37,8) = "("
            ├── rparen_loc: (37,15)-(37,16) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (38,0)-(38,3) = "end"
prism-1.5.1/snapshots/rescue.txt000066400000000000000000001063601506127434000167310ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(39,3))
├── flags: ∅
├── locals: [:a, :z]
└── statements:
    @ StatementsNode (location: (1,0)-(39,3))
    ├── flags: ∅
    └── body: (length: 15)
        ├── @ RescueModifierNode (location: (1,0)-(1,14))
        │   ├── flags: newline
        │   ├── expression:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── keyword_loc: (1,4)-(1,10) = "rescue"
        │   └── rescue_expression:
        │       @ NilNode (location: (1,11)-(1,14))
        │       └── flags: static_literal
        ├── @ RescueModifierNode (location: (3,0)-(4,3))
        │   ├── flags: newline
        │   ├── expression:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── keyword_loc: (3,4)-(3,10) = "rescue"
        │   └── rescue_expression:
        │       @ NilNode (location: (4,0)-(4,3))
        │       └── flags: static_literal
        ├── @ CallNode (location: (6,0)-(6,24))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (6,0)-(6,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (6,4)-(6,24))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (6,6)-(6,22))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ RescueModifierNode (location: (6,6)-(6,22))
        │       │           ├── flags: newline
        │       │           ├── expression:
        │       │           │   @ BreakNode (location: (6,6)-(6,11))
        │       │           │   ├── flags: ∅
        │       │           │   ├── arguments: ∅
        │       │           │   └── keyword_loc: (6,6)-(6,11) = "break"
        │       │           ├── keyword_loc: (6,12)-(6,18) = "rescue"
        │       │           └── rescue_expression:
        │       │               @ NilNode (location: (6,19)-(6,22))
        │       │               └── flags: static_literal
        │       ├── opening_loc: (6,4)-(6,5) = "{"
        │       └── closing_loc: (6,23)-(6,24) = "}"
        ├── @ CallNode (location: (8,0)-(8,23))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (8,0)-(8,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (8,4)-(8,23))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (8,6)-(8,21))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ RescueModifierNode (location: (8,6)-(8,21))
        │       │           ├── flags: newline
        │       │           ├── expression:
        │       │           │   @ NextNode (location: (8,6)-(8,10))
        │       │           │   ├── flags: ∅
        │       │           │   ├── arguments: ∅
        │       │           │   └── keyword_loc: (8,6)-(8,10) = "next"
        │       │           ├── keyword_loc: (8,11)-(8,17) = "rescue"
        │       │           └── rescue_expression:
        │       │               @ NilNode (location: (8,18)-(8,21))
        │       │               └── flags: static_literal
        │       ├── opening_loc: (8,4)-(8,5) = "{"
        │       └── closing_loc: (8,22)-(8,23) = "}"
        ├── @ RescueModifierNode (location: (10,0)-(10,17))
        │   ├── flags: newline
        │   ├── expression:
        │   │   @ ReturnNode (location: (10,0)-(10,6))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (10,0)-(10,6) = "return"
        │   │   └── arguments: ∅
        │   ├── keyword_loc: (10,7)-(10,13) = "rescue"
        │   └── rescue_expression:
        │       @ NilNode (location: (10,14)-(10,17))
        │       └── flags: static_literal
        ├── @ RescueModifierNode (location: (12,0)-(12,19))
        │   ├── flags: newline
        │   ├── expression:
        │   │   @ CallNode (location: (12,0)-(12,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (12,0)-(12,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── keyword_loc: (12,4)-(12,10) = "rescue"
        │   └── rescue_expression:
        │       @ OrNode (location: (12,11)-(12,19))
        │       ├── flags: ∅
        │       ├── left:
        │       │   @ NilNode (location: (12,11)-(12,14))
        │       │   └── flags: static_literal
        │       ├── right:
        │       │   @ IntegerNode (location: (12,18)-(12,19))
        │       │   ├── flags: static_literal, decimal
        │       │   └── value: 1
        │       └── operator_loc: (12,15)-(12,17) = "||"
        ├── @ RescueModifierNode (location: (14,0)-(14,22))
        │   ├── flags: newline
        │   ├── expression:
        │   │   @ CallNode (location: (14,0)-(14,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (14,0)-(14,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── keyword_loc: (14,4)-(14,10) = "rescue"
        │   └── rescue_expression:
        │       @ IfNode (location: (14,11)-(14,22))
        │       ├── flags: newline
        │       ├── if_keyword_loc: ∅
        │       ├── predicate:
        │       │   @ NilNode (location: (14,11)-(14,14))
        │       │   └── flags: static_literal
        │       ├── then_keyword_loc: (14,15)-(14,16) = "?"
        │       ├── statements:
        │       │   @ StatementsNode (location: (14,17)-(14,18))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ IntegerNode (location: (14,17)-(14,18))
        │       │           ├── flags: newline, static_literal, decimal
        │       │           └── value: 1
        │       ├── subsequent:
        │       │   @ ElseNode (location: (14,19)-(14,22))
        │       │   ├── flags: ∅
        │       │   ├── else_keyword_loc: (14,19)-(14,20) = ":"
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (14,21)-(14,22))
        │       │   │   ├── flags: ∅
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ IntegerNode (location: (14,21)-(14,22))
        │       │   │           ├── flags: newline, static_literal, decimal
        │       │   │           └── value: 2
        │       │   └── end_keyword_loc: ∅
        │       └── end_keyword_loc: ∅
        ├── @ BeginNode (location: (16,0)-(16,24))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (16,0)-(16,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (16,7)-(16,8))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (16,7)-(16,8))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (16,7)-(16,8) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (16,10)-(16,19))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (16,10)-(16,16) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ SplatNode (location: (16,17)-(16,19))
        │   │   │       ├── flags: ∅
        │   │   │       ├── operator_loc: (16,17)-(16,18) = "*"
        │   │   │       └── expression:
        │   │   │           @ CallNode (location: (16,18)-(16,19))
        │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (16,18)-(16,19) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (16,21)-(16,24) = "end"
        ├── @ CallNode (location: (18,0)-(20,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (18,0)-(18,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (18,4)-(20,3))
        │       ├── flags: ∅
        │       ├── locals: [:x]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (18,7)-(18,10))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (18,8)-(18,9))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (18,8)-(18,9))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :x
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (18,7)-(18,8) = "|"
        │       │   └── closing_loc: (18,9)-(18,10) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (19,2)-(19,40))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ RescueModifierNode (location: (19,2)-(19,40))
        │       │           ├── flags: newline
        │       │           ├── expression:
        │       │           │   @ CallNode (location: (19,2)-(19,8))
        │       │           │   ├── flags: ignore_visibility
        │       │           │   ├── receiver: ∅
        │       │           │   ├── call_operator_loc: ∅
        │       │           │   ├── name: :bar
        │       │           │   ├── message_loc: (19,2)-(19,5) = "bar"
        │       │           │   ├── opening_loc: (19,5)-(19,6) = "("
        │       │           │   ├── arguments:
        │       │           │   │   @ ArgumentsNode (location: (19,6)-(19,7))
        │       │           │   │   ├── flags: ∅
        │       │           │   │   └── arguments: (length: 1)
        │       │           │   │       └── @ CallNode (location: (19,6)-(19,7))
        │       │           │   │           ├── flags: variable_call, ignore_visibility
        │       │           │   │           ├── receiver: ∅
        │       │           │   │           ├── call_operator_loc: ∅
        │       │           │   │           ├── name: :y
        │       │           │   │           ├── message_loc: (19,6)-(19,7) = "y"
        │       │           │   │           ├── opening_loc: ∅
        │       │           │   │           ├── arguments: ∅
        │       │           │   │           ├── closing_loc: ∅
        │       │           │   │           └── block: ∅
        │       │           │   ├── closing_loc: (19,7)-(19,8) = ")"
        │       │           │   └── block: ∅
        │       │           ├── keyword_loc: (19,9)-(19,15) = "rescue"
        │       │           └── rescue_expression:
        │       │               @ CallNode (location: (19,16)-(19,40))
        │       │               ├── flags: ignore_visibility
        │       │               ├── receiver: ∅
        │       │               ├── call_operator_loc: ∅
        │       │               ├── name: :ArgumentError
        │       │               ├── message_loc: (19,16)-(19,29) = "ArgumentError"
        │       │               ├── opening_loc: ∅
        │       │               ├── arguments:
        │       │               │   @ ArgumentsNode (location: (19,30)-(19,40))
        │       │               │   ├── flags: ∅
        │       │               │   └── arguments: (length: 1)
        │       │               │       └── @ CallNode (location: (19,30)-(19,40))
        │       │               │           ├── flags: ignore_visibility
        │       │               │           ├── receiver: ∅
        │       │               │           ├── call_operator_loc: ∅
        │       │               │           ├── name: :fail
        │       │               │           ├── message_loc: (19,30)-(19,34) = "fail"
        │       │               │           ├── opening_loc: ∅
        │       │               │           ├── arguments:
        │       │               │           │   @ ArgumentsNode (location: (19,35)-(19,40))
        │       │               │           │   ├── flags: ∅
        │       │               │           │   └── arguments: (length: 1)
        │       │               │           │       └── @ StringNode (location: (19,35)-(19,40))
        │       │               │           │           ├── flags: ∅
        │       │               │           │           ├── opening_loc: (19,35)-(19,36) = "\""
        │       │               │           │           ├── content_loc: (19,36)-(19,39) = "baz"
        │       │               │           │           ├── closing_loc: (19,39)-(19,40) = "\""
        │       │               │           │           └── unescaped: "baz"
        │       │               │           ├── closing_loc: ∅
        │       │               │           └── block: ∅
        │       │               ├── closing_loc: ∅
        │       │               └── block: ∅
        │       ├── opening_loc: (18,4)-(18,6) = "do"
        │       └── closing_loc: (20,0)-(20,3) = "end"
        ├── @ IfNode (location: (22,0)-(24,3))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (22,0)-(22,2) = "if"
        │   ├── predicate:
        │   │   @ LocalVariableWriteNode (location: (22,3)-(22,21))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   ├── depth: 0
        │   │   ├── name_loc: (22,3)-(22,4) = "a"
        │   │   ├── value:
        │   │   │   @ RescueModifierNode (location: (22,7)-(22,21))
        │   │   │   ├── flags: ∅
        │   │   │   ├── expression:
        │   │   │   │   @ CallNode (location: (22,7)-(22,10))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :foo
        │   │   │   │   ├── message_loc: (22,7)-(22,10) = "foo"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── keyword_loc: (22,11)-(22,17) = "rescue"
        │   │   │   └── rescue_expression:
        │   │   │       @ NilNode (location: (22,18)-(22,21))
        │   │   │       └── flags: static_literal
        │   │   └── operator_loc: (22,5)-(22,6) = "="
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (23,2)-(23,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (23,2)-(23,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (23,2)-(23,5) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (24,0)-(24,3) = "end"
        ├── @ DefNode (location: (26,0)-(26,44))
        │   ├── flags: newline
        │   ├── name: :some_method
        │   ├── name_loc: (26,4)-(26,15) = "some_method"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (26,18)-(26,44))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ RescueModifierNode (location: (26,18)-(26,44))
        │   │           ├── flags: ∅
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (26,18)-(26,33))
        │   │           │   ├── flags: ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :other_method
        │   │           │   ├── message_loc: (26,18)-(26,30) = "other_method"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments:
        │   │           │   │   @ ArgumentsNode (location: (26,31)-(26,33))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   └── arguments: (length: 1)
        │   │           │   │       └── @ IntegerNode (location: (26,31)-(26,33))
        │   │           │   │           ├── flags: static_literal, decimal
        │   │           │   │           └── value: 42
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── keyword_loc: (26,34)-(26,40) = "rescue"
        │   │           └── rescue_expression:
        │   │               @ NilNode (location: (26,41)-(26,44))
        │   │               └── flags: static_literal
        │   ├── locals: []
        │   ├── def_keyword_loc: (26,0)-(26,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (26,16)-(26,17) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (28,0)-(31,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (28,4)-(28,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (28,0)-(31,3))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (29,2)-(29,6))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (29,2)-(29,6))
        │   │   │           ├── flags: newline, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :a
        │   │   │           ├── message_loc: (29,2)-(29,3) = "a"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (29,4)-(29,6))
        │   │   │           │   ├── flags: contains_keywords
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ KeywordHashNode (location: (29,4)-(29,6))
        │   │   │           │           ├── flags: symbol_keys
        │   │   │           │           └── elements: (length: 1)
        │   │   │           │               └── @ AssocNode (location: (29,4)-(29,6))
        │   │   │           │                   ├── flags: ∅
        │   │   │           │                   ├── key:
        │   │   │           │                   │   @ SymbolNode (location: (29,4)-(29,6))
        │   │   │           │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │           │                   │   ├── opening_loc: ∅
        │   │   │           │                   │   ├── value_loc: (29,4)-(29,5) = "b"
        │   │   │           │                   │   ├── closing_loc: (29,5)-(29,6) = ":"
        │   │   │           │                   │   └── unescaped: "b"
        │   │   │           │                   ├── value:
        │   │   │           │                   │   @ ImplicitNode (location: (29,4)-(29,6))
        │   │   │           │                   │   ├── flags: ∅
        │   │   │           │                   │   └── value:
        │   │   │           │                   │       @ CallNode (location: (29,4)-(29,6))
        │   │   │           │                   │       ├── flags: ignore_visibility
        │   │   │           │                   │       ├── receiver: ∅
        │   │   │           │                   │       ├── call_operator_loc: ∅
        │   │   │           │                   │       ├── name: :b
        │   │   │           │                   │       ├── message_loc: (29,4)-(29,5) = "b"
        │   │   │           │                   │       ├── opening_loc: ∅
        │   │   │           │                   │       ├── arguments: ∅
        │   │   │           │                   │       ├── closing_loc: ∅
        │   │   │           │                   │       └── block: ∅
        │   │   │           │                   └── operator_loc: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (30,0)-(30,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (30,0)-(30,6) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   ├── statements: ∅
        │   │   │   └── subsequent: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause: ∅
        │   │   └── end_keyword_loc: (31,0)-(31,3) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (28,0)-(28,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (31,0)-(31,3) = "end"
        ├── @ RescueModifierNode (location: (33,0)-(33,21))
        │   ├── flags: newline
        │   ├── expression:
        │   │   @ IfNode (location: (33,0)-(33,10))
        │   │   ├── flags: newline
        │   │   ├── if_keyword_loc: (33,4)-(33,6) = "if"
        │   │   ├── predicate:
        │   │   │   @ CallNode (location: (33,7)-(33,10))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :bar
        │   │   │   ├── message_loc: (33,7)-(33,10) = "bar"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (33,0)-(33,3))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (33,0)-(33,3))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :foo
        │   │   │           ├── message_loc: (33,0)-(33,3) = "foo"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── subsequent: ∅
        │   │   └── end_keyword_loc: ∅
        │   ├── keyword_loc: (33,11)-(33,17) = "rescue"
        │   └── rescue_expression:
        │       @ CallNode (location: (33,18)-(33,21))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :baz
        │       ├── message_loc: (33,18)-(33,21) = "baz"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ LocalVariableWriteNode (location: (35,0)-(35,18))
        │   ├── flags: newline
        │   ├── name: :z
        │   ├── depth: 0
        │   ├── name_loc: (35,0)-(35,1) = "z"
        │   ├── value:
        │   │   @ RescueModifierNode (location: (35,4)-(35,18))
        │   │   ├── flags: ∅
        │   │   ├── expression:
        │   │   │   @ CallNode (location: (35,4)-(35,7))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :x
        │   │   │   ├── message_loc: (35,4)-(35,5) = "x"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (35,6)-(35,7))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ CallNode (location: (35,6)-(35,7))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :y
        │   │   │   │           ├── message_loc: (35,6)-(35,7) = "y"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── keyword_loc: (35,8)-(35,14) = "rescue"
        │   │   └── rescue_expression:
        │   │       @ CallNode (location: (35,15)-(35,18))
        │   │       ├── flags: ignore_visibility
        │   │       ├── receiver: ∅
        │   │       ├── call_operator_loc: ∅
        │   │       ├── name: :c
        │   │       ├── message_loc: (35,15)-(35,16) = "c"
        │   │       ├── opening_loc: ∅
        │   │       ├── arguments:
        │   │       │   @ ArgumentsNode (location: (35,17)-(35,18))
        │   │       │   ├── flags: ∅
        │   │       │   └── arguments: (length: 1)
        │   │       │       └── @ CallNode (location: (35,17)-(35,18))
        │   │       │           ├── flags: variable_call, ignore_visibility
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :d
        │   │       │           ├── message_loc: (35,17)-(35,18) = "d"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments: ∅
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       ├── closing_loc: ∅
        │   │       └── block: ∅
        │   └── operator_loc: (35,2)-(35,3) = "="
        └── @ BeginNode (location: (37,0)-(39,3))
            ├── flags: newline
            ├── begin_keyword_loc: (37,0)-(37,5) = "begin"
            ├── statements: ∅
            ├── rescue_clause:
            │   @ RescueNode (location: (38,0)-(38,13))
            │   ├── flags: ∅
            │   ├── keyword_loc: (38,0)-(38,6) = "rescue"
            │   ├── exceptions: (length: 0)
            │   ├── operator_loc: (38,7)-(38,9) = "=>"
            │   ├── reference:
            │   │   @ IndexTargetNode (location: (38,10)-(38,13))
            │   │   ├── flags: attribute_write
            │   │   ├── receiver:
            │   │   │   @ ConstantReadNode (location: (38,10)-(38,11))
            │   │   │   ├── flags: ∅
            │   │   │   └── name: :A
            │   │   ├── opening_loc: (38,11)-(38,12) = "["
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: (38,12)-(38,13) = "]"
            │   │   └── block: ∅
            │   ├── then_keyword_loc: ∅
            │   ├── statements: ∅
            │   └── subsequent: ∅
            ├── else_clause: ∅
            ├── ensure_clause: ∅
            └── end_keyword_loc: (39,0)-(39,3) = "end"
prism-1.5.1/snapshots/rescue_modifier.txt000066400000000000000000000320441506127434000206040ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,23))
├── flags: ∅
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (1,0)-(7,23))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ IfNode (location: (1,0)-(1,15))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (1,11)-(1,13) = "if"
        │   ├── predicate:
        │   │   @ CallNode (location: (1,14)-(1,15))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :c
        │   │   ├── message_loc: (1,14)-(1,15) = "c"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (1,0)-(1,10))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ RescueModifierNode (location: (1,0)-(1,10))
        │   │           ├── flags: newline
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (1,0)-(1,1))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :a
        │   │           │   ├── message_loc: (1,0)-(1,1) = "a"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── keyword_loc: (1,2)-(1,8) = "rescue"
        │   │           └── rescue_expression:
        │   │               @ CallNode (location: (1,9)-(1,10))
        │   │               ├── flags: variable_call, ignore_visibility
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :b
        │   │               ├── message_loc: (1,9)-(1,10) = "b"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: ∅
        ├── @ IfNode (location: (3,0)-(3,19))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (3,15)-(3,17) = "if"
        │   ├── predicate:
        │   │   @ CallNode (location: (3,18)-(3,19))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :d
        │   │   ├── message_loc: (3,18)-(3,19) = "d"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (3,0)-(3,14))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableWriteNode (location: (3,0)-(3,14))
        │   │           ├── flags: newline
        │   │           ├── name: :a
        │   │           ├── depth: 0
        │   │           ├── name_loc: (3,0)-(3,1) = "a"
        │   │           ├── value:
        │   │           │   @ RescueModifierNode (location: (3,4)-(3,14))
        │   │           │   ├── flags: ∅
        │   │           │   ├── expression:
        │   │           │   │   @ CallNode (location: (3,4)-(3,5))
        │   │           │   │   ├── flags: variable_call, ignore_visibility
        │   │           │   │   ├── receiver: ∅
        │   │           │   │   ├── call_operator_loc: ∅
        │   │           │   │   ├── name: :b
        │   │           │   │   ├── message_loc: (3,4)-(3,5) = "b"
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── arguments: ∅
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── block: ∅
        │   │           │   ├── keyword_loc: (3,6)-(3,12) = "rescue"
        │   │           │   └── rescue_expression:
        │   │           │       @ CallNode (location: (3,13)-(3,14))
        │   │           │       ├── flags: variable_call, ignore_visibility
        │   │           │       ├── receiver: ∅
        │   │           │       ├── call_operator_loc: ∅
        │   │           │       ├── name: :c
        │   │           │       ├── message_loc: (3,13)-(3,14) = "c"
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── arguments: ∅
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── block: ∅
        │   │           └── operator_loc: (3,2)-(3,3) = "="
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: ∅
        ├── @ IfNode (location: (5,0)-(5,20))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (5,16)-(5,18) = "if"
        │   ├── predicate:
        │   │   @ CallNode (location: (5,19)-(5,20))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :d
        │   │   ├── message_loc: (5,19)-(5,20) = "d"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (5,0)-(5,15))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ MultiWriteNode (location: (5,0)-(5,15))
        │   │           ├── flags: newline
        │   │           ├── lefts: (length: 1)
        │   │           │   └── @ LocalVariableTargetNode (location: (5,0)-(5,1))
        │   │           │       ├── flags: ∅
        │   │           │       ├── name: :a
        │   │           │       └── depth: 0
        │   │           ├── rest:
        │   │           │   @ ImplicitRestNode (location: (5,1)-(5,2))
        │   │           │   └── flags: ∅
        │   │           ├── rights: (length: 0)
        │   │           ├── lparen_loc: ∅
        │   │           ├── rparen_loc: ∅
        │   │           ├── operator_loc: (5,3)-(5,4) = "="
        │   │           └── value:
        │   │               @ RescueModifierNode (location: (5,5)-(5,15))
        │   │               ├── flags: ∅
        │   │               ├── expression:
        │   │               │   @ CallNode (location: (5,5)-(5,6))
        │   │               │   ├── flags: variable_call, ignore_visibility
        │   │               │   ├── receiver: ∅
        │   │               │   ├── call_operator_loc: ∅
        │   │               │   ├── name: :b
        │   │               │   ├── message_loc: (5,5)-(5,6) = "b"
        │   │               │   ├── opening_loc: ∅
        │   │               │   ├── arguments: ∅
        │   │               │   ├── closing_loc: ∅
        │   │               │   └── block: ∅
        │   │               ├── keyword_loc: (5,7)-(5,13) = "rescue"
        │   │               └── rescue_expression:
        │   │                   @ CallNode (location: (5,14)-(5,15))
        │   │                   ├── flags: variable_call, ignore_visibility
        │   │                   ├── receiver: ∅
        │   │                   ├── call_operator_loc: ∅
        │   │                   ├── name: :c
        │   │                   ├── message_loc: (5,14)-(5,15) = "c"
        │   │                   ├── opening_loc: ∅
        │   │                   ├── arguments: ∅
        │   │                   ├── closing_loc: ∅
        │   │                   └── block: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: ∅
        └── @ IfNode (location: (7,0)-(7,23))
            ├── flags: newline
            ├── if_keyword_loc: (7,19)-(7,21) = "if"
            ├── predicate:
            │   @ CallNode (location: (7,22)-(7,23))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :d
            │   ├── message_loc: (7,22)-(7,23) = "d"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── then_keyword_loc: ∅
            ├── statements:
            │   @ StatementsNode (location: (7,0)-(7,18))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ DefNode (location: (7,0)-(7,18))
            │           ├── flags: newline
            │           ├── name: :a
            │           ├── name_loc: (7,4)-(7,5) = "a"
            │           ├── receiver: ∅
            │           ├── parameters: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (7,8)-(7,18))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ RescueModifierNode (location: (7,8)-(7,18))
            │           │           ├── flags: ∅
            │           │           ├── expression:
            │           │           │   @ CallNode (location: (7,8)-(7,9))
            │           │           │   ├── flags: variable_call, ignore_visibility
            │           │           │   ├── receiver: ∅
            │           │           │   ├── call_operator_loc: ∅
            │           │           │   ├── name: :b
            │           │           │   ├── message_loc: (7,8)-(7,9) = "b"
            │           │           │   ├── opening_loc: ∅
            │           │           │   ├── arguments: ∅
            │           │           │   ├── closing_loc: ∅
            │           │           │   └── block: ∅
            │           │           ├── keyword_loc: (7,10)-(7,16) = "rescue"
            │           │           └── rescue_expression:
            │           │               @ CallNode (location: (7,17)-(7,18))
            │           │               ├── flags: variable_call, ignore_visibility
            │           │               ├── receiver: ∅
            │           │               ├── call_operator_loc: ∅
            │           │               ├── name: :c
            │           │               ├── message_loc: (7,17)-(7,18) = "c"
            │           │               ├── opening_loc: ∅
            │           │               ├── arguments: ∅
            │           │               ├── closing_loc: ∅
            │           │               └── block: ∅
            │           ├── locals: []
            │           ├── def_keyword_loc: (7,0)-(7,3) = "def"
            │           ├── operator_loc: ∅
            │           ├── lparen_loc: ∅
            │           ├── rparen_loc: ∅
            │           ├── equal_loc: (7,6)-(7,7) = "="
            │           └── end_keyword_loc: ∅
            ├── subsequent: ∅
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/return.txt000066400000000000000000000320041506127434000167530ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(27,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(27,17))
    ├── flags: ∅
    └── body: (length: 12)
        ├── @ ReturnNode (location: (1,0)-(1,6))
        │   ├── flags: newline
        │   ├── keyword_loc: (1,0)-(1,6) = "return"
        │   └── arguments: ∅
        ├── @ ReturnNode (location: (3,0)-(3,20))
        │   ├── flags: newline
        │   ├── keyword_loc: (3,0)-(3,6) = "return"
        │   └── arguments:
        │       @ ArgumentsNode (location: (3,7)-(3,20))
        │       ├── flags: ∅
        │       └── arguments: (length: 3)
        │           ├── @ ParenthesesNode (location: (3,7)-(3,10))
        │           │   ├── flags: ∅
        │           │   ├── body:
        │           │   │   @ StatementsNode (location: (3,8)-(3,9))
        │           │   │   ├── flags: ∅
        │           │   │   └── body: (length: 1)
        │           │   │       └── @ IntegerNode (location: (3,8)-(3,9))
        │           │   │           ├── flags: newline, static_literal, decimal
        │           │   │           └── value: 1
        │           │   ├── opening_loc: (3,7)-(3,8) = "("
        │           │   └── closing_loc: (3,9)-(3,10) = ")"
        │           ├── @ ParenthesesNode (location: (3,12)-(3,15))
        │           │   ├── flags: ∅
        │           │   ├── body:
        │           │   │   @ StatementsNode (location: (3,13)-(3,14))
        │           │   │   ├── flags: ∅
        │           │   │   └── body: (length: 1)
        │           │   │       └── @ IntegerNode (location: (3,13)-(3,14))
        │           │   │           ├── flags: newline, static_literal, decimal
        │           │   │           └── value: 2
        │           │   ├── opening_loc: (3,12)-(3,13) = "("
        │           │   └── closing_loc: (3,14)-(3,15) = ")"
        │           └── @ ParenthesesNode (location: (3,17)-(3,20))
        │               ├── flags: ∅
        │               ├── body:
        │               │   @ StatementsNode (location: (3,18)-(3,19))
        │               │   ├── flags: ∅
        │               │   └── body: (length: 1)
        │               │       └── @ IntegerNode (location: (3,18)-(3,19))
        │               │           ├── flags: newline, static_literal, decimal
        │               │           └── value: 3
        │               ├── opening_loc: (3,17)-(3,18) = "("
        │               └── closing_loc: (3,19)-(3,20) = ")"
        ├── @ ReturnNode (location: (5,0)-(5,9))
        │   ├── flags: newline
        │   ├── keyword_loc: (5,0)-(5,6) = "return"
        │   └── arguments:
        │       @ ArgumentsNode (location: (5,7)-(5,9))
        │       ├── flags: contains_splat
        │       └── arguments: (length: 1)
        │           └── @ SplatNode (location: (5,7)-(5,9))
        │               ├── flags: ∅
        │               ├── operator_loc: (5,7)-(5,8) = "*"
        │               └── expression:
        │                   @ IntegerNode (location: (5,8)-(5,9))
        │                   ├── flags: static_literal, decimal
        │                   └── value: 1
        ├── @ ReturnNode (location: (7,0)-(7,8))
        │   ├── flags: newline
        │   ├── keyword_loc: (7,0)-(7,6) = "return"
        │   └── arguments:
        │       @ ArgumentsNode (location: (7,7)-(7,8))
        │       ├── flags: ∅
        │       └── arguments: (length: 1)
        │           └── @ IntegerNode (location: (7,7)-(7,8))
        │               ├── flags: static_literal, decimal
        │               └── value: 1
        ├── @ ReturnNode (location: (9,0)-(10,1))
        │   ├── flags: newline
        │   ├── keyword_loc: (9,0)-(9,6) = "return"
        │   └── arguments:
        │       @ ArgumentsNode (location: (9,7)-(10,1))
        │       ├── flags: ∅
        │       └── arguments: (length: 3)
        │           ├── @ IntegerNode (location: (9,7)-(9,8))
        │           │   ├── flags: static_literal, decimal
        │           │   └── value: 1
        │           ├── @ IntegerNode (location: (9,10)-(9,11))
        │           │   ├── flags: static_literal, decimal
        │           │   └── value: 2
        │           └── @ IntegerNode (location: (10,0)-(10,1))
        │               ├── flags: static_literal, decimal
        │               └── value: 3
        ├── @ ReturnNode (location: (12,0)-(12,14))
        │   ├── flags: newline
        │   ├── keyword_loc: (12,0)-(12,6) = "return"
        │   └── arguments:
        │       @ ArgumentsNode (location: (12,7)-(12,14))
        │       ├── flags: ∅
        │       └── arguments: (length: 3)
        │           ├── @ IntegerNode (location: (12,7)-(12,8))
        │           │   ├── flags: static_literal, decimal
        │           │   └── value: 1
        │           ├── @ IntegerNode (location: (12,10)-(12,11))
        │           │   ├── flags: static_literal, decimal
        │           │   └── value: 2
        │           └── @ IntegerNode (location: (12,13)-(12,14))
        │               ├── flags: static_literal, decimal
        │               └── value: 3
        ├── @ ReturnNode (location: (14,0)-(14,16))
        │   ├── flags: newline
        │   ├── keyword_loc: (14,0)-(14,6) = "return"
        │   └── arguments:
        │       @ ArgumentsNode (location: (14,7)-(14,16))
        │       ├── flags: ∅
        │       └── arguments: (length: 1)
        │           └── @ ArrayNode (location: (14,7)-(14,16))
        │               ├── flags: static_literal
        │               ├── elements: (length: 3)
        │               │   ├── @ IntegerNode (location: (14,8)-(14,9))
        │               │   │   ├── flags: static_literal, decimal
        │               │   │   └── value: 1
        │               │   ├── @ IntegerNode (location: (14,11)-(14,12))
        │               │   │   ├── flags: static_literal, decimal
        │               │   │   └── value: 2
        │               │   └── @ IntegerNode (location: (14,14)-(14,15))
        │               │       ├── flags: static_literal, decimal
        │               │       └── value: 3
        │               ├── opening_loc: (14,7)-(14,8) = "["
        │               └── closing_loc: (14,15)-(14,16) = "]"
        ├── @ ReturnNode (location: (16,0)-(19,1))
        │   ├── flags: newline
        │   ├── keyword_loc: (16,0)-(16,6) = "return"
        │   └── arguments:
        │       @ ArgumentsNode (location: (16,6)-(19,1))
        │       ├── flags: ∅
        │       └── arguments: (length: 1)
        │           └── @ ParenthesesNode (location: (16,6)-(19,1))
        │               ├── flags: multiple_statements
        │               ├── body:
        │               │   @ StatementsNode (location: (17,2)-(18,3))
        │               │   ├── flags: ∅
        │               │   └── body: (length: 2)
        │               │       ├── @ IntegerNode (location: (17,2)-(17,3))
        │               │       │   ├── flags: newline, static_literal, decimal
        │               │       │   └── value: 1
        │               │       └── @ IntegerNode (location: (18,2)-(18,3))
        │               │           ├── flags: newline, static_literal, decimal
        │               │           └── value: 2
        │               ├── opening_loc: (16,6)-(16,7) = "("
        │               └── closing_loc: (19,0)-(19,1) = ")"
        ├── @ ReturnNode (location: (21,0)-(21,8))
        │   ├── flags: newline
        │   ├── keyword_loc: (21,0)-(21,6) = "return"
        │   └── arguments:
        │       @ ArgumentsNode (location: (21,6)-(21,8))
        │       ├── flags: ∅
        │       └── arguments: (length: 1)
        │           └── @ ParenthesesNode (location: (21,6)-(21,8))
        │               ├── flags: ∅
        │               ├── body: ∅
        │               ├── opening_loc: (21,6)-(21,7) = "("
        │               └── closing_loc: (21,7)-(21,8) = ")"
        ├── @ ReturnNode (location: (23,0)-(23,9))
        │   ├── flags: newline
        │   ├── keyword_loc: (23,0)-(23,6) = "return"
        │   └── arguments:
        │       @ ArgumentsNode (location: (23,6)-(23,9))
        │       ├── flags: ∅
        │       └── arguments: (length: 1)
        │           └── @ ParenthesesNode (location: (23,6)-(23,9))
        │               ├── flags: ∅
        │               ├── body:
        │               │   @ StatementsNode (location: (23,7)-(23,8))
        │               │   ├── flags: ∅
        │               │   └── body: (length: 1)
        │               │       └── @ IntegerNode (location: (23,7)-(23,8))
        │               │           ├── flags: newline, static_literal, decimal
        │               │           └── value: 1
        │               ├── opening_loc: (23,6)-(23,7) = "("
        │               └── closing_loc: (23,8)-(23,9) = ")"
        ├── @ ParenthesesNode (location: (25,0)-(25,10))
        │   ├── flags: newline
        │   ├── body:
        │   │   @ StatementsNode (location: (25,1)-(25,9))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ ReturnNode (location: (25,1)-(25,9))
        │   │           ├── flags: newline
        │   │           ├── keyword_loc: (25,1)-(25,7) = "return"
        │   │           └── arguments:
        │   │               @ ArgumentsNode (location: (25,8)-(25,9))
        │   │               ├── flags: ∅
        │   │               └── arguments: (length: 1)
        │   │                   └── @ IntegerNode (location: (25,8)-(25,9))
        │   │                       ├── flags: static_literal, decimal
        │   │                       └── value: 1
        │   ├── opening_loc: (25,0)-(25,1) = "("
        │   └── closing_loc: (25,9)-(25,10) = ")"
        └── @ AndNode (location: (27,0)-(27,17))
            ├── flags: newline
            ├── left:
            │   @ CallNode (location: (27,0)-(27,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (27,0)-(27,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── right:
            │   @ ParenthesesNode (location: (27,7)-(27,17))
            │   ├── flags: ∅
            │   ├── body:
            │   │   @ StatementsNode (location: (27,8)-(27,16))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ ReturnNode (location: (27,8)-(27,16))
            │   │           ├── flags: newline
            │   │           ├── keyword_loc: (27,8)-(27,14) = "return"
            │   │           └── arguments:
            │   │               @ ArgumentsNode (location: (27,15)-(27,16))
            │   │               ├── flags: ∅
            │   │               └── arguments: (length: 1)
            │   │                   └── @ IntegerNode (location: (27,15)-(27,16))
            │   │                       ├── flags: static_literal, decimal
            │   │                       └── value: 1
            │   ├── opening_loc: (27,7)-(27,8) = "("
            │   └── closing_loc: (27,16)-(27,17) = ")"
            └── operator_loc: (27,4)-(27,6) = "&&"
prism-1.5.1/snapshots/seattlerb/000077500000000000000000000000001506127434000166615ustar00rootroot00000000000000prism-1.5.1/snapshots/seattlerb/BEGIN.txt000066400000000000000000000015121506127434000202450ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ PreExecutionNode (location: (1,0)-(1,12))
            ├── flags: newline
            ├── statements:
            │   @ StatementsNode (location: (1,8)-(1,10))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ IntegerNode (location: (1,8)-(1,10))
            │           ├── flags: newline, static_literal, decimal
            │           └── value: 42
            ├── keyword_loc: (1,0)-(1,5) = "BEGIN"
            ├── opening_loc: (1,6)-(1,7) = "{"
            └── closing_loc: (1,11)-(1,12) = "}"
prism-1.5.1/snapshots/seattlerb/TestRubyParserShared.txt000066400000000000000000000570451506127434000235220ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(92,1))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(92,1))
    ├── flags: ∅
    └── body: (length: 16)
        ├── @ ArrayNode (location: (1,0)-(4,1))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 0)
        │   ├── opening_loc: (1,0)-(1,3) = "%I["
        │   └── closing_loc: (4,0)-(4,1) = "]"
        ├── @ ArrayNode (location: (6,0)-(9,1))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 2)
        │   │   ├── @ SymbolNode (location: (7,0)-(7,5))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── value_loc: (7,0)-(7,5) = "line2"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "line2"
        │   │   └── @ SymbolNode (location: (8,0)-(8,5))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: ∅
        │   │       ├── value_loc: (8,0)-(8,5) = "line3"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "line3"
        │   ├── opening_loc: (6,0)-(6,3) = "%I["
        │   └── closing_loc: (9,0)-(9,1) = "]"
        ├── @ ArrayNode (location: (11,0)-(14,1))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 0)
        │   ├── opening_loc: (11,0)-(11,3) = "%W["
        │   └── closing_loc: (14,0)-(14,1) = "]"
        ├── @ ArrayNode (location: (16,0)-(19,1))
        │   ├── flags: newline
        │   ├── elements: (length: 2)
        │   │   ├── @ StringNode (location: (17,0)-(17,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (17,0)-(17,5) = "line2"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "line2"
        │   │   └── @ StringNode (location: (18,0)-(18,5))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (18,0)-(18,5) = "line3"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "line3"
        │   ├── opening_loc: (16,0)-(16,3) = "%W["
        │   └── closing_loc: (19,0)-(19,1) = "]"
        ├── @ ArrayNode (location: (21,0)-(24,1))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 0)
        │   ├── opening_loc: (21,0)-(21,3) = "%i["
        │   └── closing_loc: (24,0)-(24,1) = "]"
        ├── @ ArrayNode (location: (26,0)-(29,1))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 2)
        │   │   ├── @ SymbolNode (location: (27,0)-(27,5))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── value_loc: (27,0)-(27,5) = "line2"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "line2"
        │   │   └── @ SymbolNode (location: (28,0)-(28,5))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: ∅
        │   │       ├── value_loc: (28,0)-(28,5) = "line3"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "line3"
        │   ├── opening_loc: (26,0)-(26,3) = "%i["
        │   └── closing_loc: (29,0)-(29,1) = "]"
        ├── @ RegularExpressionNode (location: (31,0)-(34,1))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (31,0)-(31,3) = "%r["
        │   ├── content_loc: (31,3)-(34,0) = "\n\n\n"
        │   ├── closing_loc: (34,0)-(34,1) = "]"
        │   └── unescaped: "\n\n\n"
        ├── @ ArrayNode (location: (36,0)-(39,1))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 0)
        │   ├── opening_loc: (36,0)-(36,3) = "%w["
        │   └── closing_loc: (39,0)-(39,1) = "]"
        ├── @ ArrayNode (location: (41,0)-(44,1))
        │   ├── flags: newline
        │   ├── elements: (length: 2)
        │   │   ├── @ StringNode (location: (42,0)-(42,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (42,0)-(42,5) = "line2"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "line2"
        │   │   └── @ StringNode (location: (43,0)-(43,5))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (43,0)-(43,5) = "line3"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "line3"
        │   ├── opening_loc: (41,0)-(41,3) = "%w["
        │   └── closing_loc: (44,0)-(44,1) = "]"
        ├── @ ArrayNode (location: (46,0)-(49,1))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 2)
        │   │   ├── @ SymbolNode (location: (47,0)-(47,6))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (47,0)-(47,1) = ":"
        │   │   │   ├── value_loc: (47,1)-(47,6) = "line2"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "line2"
        │   │   └── @ SymbolNode (location: (48,0)-(48,6))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: (48,0)-(48,1) = ":"
        │   │       ├── value_loc: (48,1)-(48,6) = "line3"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "line3"
        │   ├── opening_loc: (46,0)-(46,1) = "["
        │   └── closing_loc: (49,0)-(49,1) = "]"
        ├── @ ClassNode (location: (51,0)-(56,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (51,0)-(51,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (51,6)-(51,7))
        │   │   ├── flags: ∅
        │   │   └── name: :X
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (52,2)-(55,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ DefNode (location: (52,2)-(55,5))
        │   │           ├── flags: newline
        │   │           ├── name: :y
        │   │           ├── name_loc: (52,11)-(52,12) = "y"
        │   │           ├── receiver:
        │   │           │   @ SelfNode (location: (52,6)-(52,10))
        │   │           │   └── flags: ∅
        │   │           ├── parameters:
        │   │           │   @ ParametersNode (location: (52,13)-(53,9))
        │   │           │   ├── flags: ∅
        │   │           │   ├── requireds: (length: 2)
        │   │           │   │   ├── @ RequiredParameterNode (location: (52,13)-(52,14))
        │   │           │   │   │   ├── flags: ∅
        │   │           │   │   │   └── name: :a
        │   │           │   │   └── @ RequiredParameterNode (location: (53,8)-(53,9))
        │   │           │   │       ├── flags: ∅
        │   │           │   │       └── name: :b
        │   │           │   ├── optionals: (length: 0)
        │   │           │   ├── rest: ∅
        │   │           │   ├── posts: (length: 0)
        │   │           │   ├── keywords: (length: 0)
        │   │           │   ├── keyword_rest: ∅
        │   │           │   └── block: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (54,4)-(54,9))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (54,4)-(54,9))
        │   │           │           ├── flags: newline
        │   │           │           ├── receiver:
        │   │           │           │   @ LocalVariableReadNode (location: (54,4)-(54,5))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   ├── name: :a
        │   │           │           │   └── depth: 0
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :+
        │   │           │           ├── message_loc: (54,6)-(54,7) = "+"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (54,8)-(54,9))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ LocalVariableReadNode (location: (54,8)-(54,9))
        │   │           │           │           ├── flags: ∅
        │   │           │           │           ├── name: :b
        │   │           │           │           └── depth: 0
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── locals: [:a, :b]
        │   │           ├── def_keyword_loc: (52,2)-(52,5) = "def"
        │   │           ├── operator_loc: (52,10)-(52,11) = "."
        │   │           ├── lparen_loc: (52,12)-(52,13) = "("
        │   │           ├── rparen_loc: (53,9)-(53,10) = ")"
        │   │           ├── equal_loc: ∅
        │   │           └── end_keyword_loc: (55,2)-(55,5) = "end"
        │   ├── end_keyword_loc: (56,0)-(56,3) = "end"
        │   └── name: :X
        ├── @ ClassNode (location: (59,0)-(63,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (59,0)-(59,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (59,6)-(59,7))
        │   │   ├── flags: ∅
        │   │   └── name: :X
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (60,2)-(62,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ ClassNode (location: (60,2)-(62,5))
        │   │           ├── flags: newline
        │   │           ├── locals: []
        │   │           ├── class_keyword_loc: (60,2)-(60,7) = "class"
        │   │           ├── constant_path:
        │   │           │   @ ConstantReadNode (location: (60,8)-(60,9))
        │   │           │   ├── flags: ∅
        │   │           │   └── name: :Y
        │   │           ├── inheritance_operator_loc: ∅
        │   │           ├── superclass: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (61,4)-(61,10))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ ConstantWriteNode (location: (61,4)-(61,10))
        │   │           │           ├── flags: newline
        │   │           │           ├── name: :Z
        │   │           │           ├── name_loc: (61,4)-(61,5) = "Z"
        │   │           │           ├── value:
        │   │           │           │   @ IntegerNode (location: (61,8)-(61,10))
        │   │           │           │   ├── flags: static_literal, decimal
        │   │           │           │   └── value: 42
        │   │           │           └── operator_loc: (61,6)-(61,7) = "="
        │   │           ├── end_keyword_loc: (62,2)-(62,5) = "end"
        │   │           └── name: :Y
        │   ├── end_keyword_loc: (63,0)-(63,3) = "end"
        │   └── name: :X
        ├── @ ClassNode (location: (66,0)-(71,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (66,0)-(66,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (66,6)-(66,7))
        │   │   ├── flags: ∅
        │   │   └── name: :X
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (67,2)-(70,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ DefNode (location: (67,2)-(70,5))
        │   │           ├── flags: newline
        │   │           ├── name: :y
        │   │           ├── name_loc: (67,6)-(67,7) = "y"
        │   │           ├── receiver: ∅
        │   │           ├── parameters:
        │   │           │   @ ParametersNode (location: (67,8)-(68,9))
        │   │           │   ├── flags: ∅
        │   │           │   ├── requireds: (length: 2)
        │   │           │   │   ├── @ RequiredParameterNode (location: (67,8)-(67,9))
        │   │           │   │   │   ├── flags: ∅
        │   │           │   │   │   └── name: :a
        │   │           │   │   └── @ RequiredParameterNode (location: (68,8)-(68,9))
        │   │           │   │       ├── flags: ∅
        │   │           │   │       └── name: :b
        │   │           │   ├── optionals: (length: 0)
        │   │           │   ├── rest: ∅
        │   │           │   ├── posts: (length: 0)
        │   │           │   ├── keywords: (length: 0)
        │   │           │   ├── keyword_rest: ∅
        │   │           │   └── block: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (69,4)-(69,9))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (69,4)-(69,9))
        │   │           │           ├── flags: newline
        │   │           │           ├── receiver:
        │   │           │           │   @ LocalVariableReadNode (location: (69,4)-(69,5))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   ├── name: :a
        │   │           │           │   └── depth: 0
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :+
        │   │           │           ├── message_loc: (69,6)-(69,7) = "+"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (69,8)-(69,9))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ LocalVariableReadNode (location: (69,8)-(69,9))
        │   │           │           │           ├── flags: ∅
        │   │           │           │           ├── name: :b
        │   │           │           │           └── depth: 0
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── locals: [:a, :b]
        │   │           ├── def_keyword_loc: (67,2)-(67,5) = "def"
        │   │           ├── operator_loc: ∅
        │   │           ├── lparen_loc: (67,7)-(67,8) = "("
        │   │           ├── rparen_loc: (68,9)-(68,10) = ")"
        │   │           ├── equal_loc: ∅
        │   │           └── end_keyword_loc: (70,2)-(70,5) = "end"
        │   ├── end_keyword_loc: (71,0)-(71,3) = "end"
        │   └── name: :X
        ├── @ ModuleNode (location: (74,0)-(79,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── module_keyword_loc: (74,0)-(74,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (74,7)-(74,8))
        │   │   ├── flags: ∅
        │   │   └── name: :X
        │   ├── body:
        │   │   @ StatementsNode (location: (75,2)-(78,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ ConstantWriteNode (location: (75,2)-(78,3))
        │   │           ├── flags: newline
        │   │           ├── name: :X
        │   │           ├── name_loc: (75,2)-(75,3) = "X"
        │   │           ├── value:
        │   │           │   @ ArrayNode (location: (75,6)-(78,3))
        │   │           │   ├── flags: static_literal
        │   │           │   ├── elements: (length: 2)
        │   │           │   │   ├── @ SymbolNode (location: (76,4)-(76,10))
        │   │           │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │           │   │   │   ├── opening_loc: (76,4)-(76,5) = ":"
        │   │           │   │   │   ├── value_loc: (76,5)-(76,10) = "line3"
        │   │           │   │   │   ├── closing_loc: ∅
        │   │           │   │   │   └── unescaped: "line3"
        │   │           │   │   └── @ SymbolNode (location: (77,4)-(77,10))
        │   │           │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │           │   │       ├── opening_loc: (77,4)-(77,5) = ":"
        │   │           │   │       ├── value_loc: (77,5)-(77,10) = "line4"
        │   │           │   │       ├── closing_loc: ∅
        │   │           │   │       └── unescaped: "line4"
        │   │           │   ├── opening_loc: (75,6)-(75,7) = "["
        │   │           │   └── closing_loc: (78,2)-(78,3) = "]"
        │   │           └── operator_loc: (75,4)-(75,5) = "="
        │   ├── end_keyword_loc: (79,0)-(79,3) = "end"
        │   └── name: :X
        ├── @ ModuleNode (location: (82,0)-(86,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── module_keyword_loc: (82,0)-(82,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (82,7)-(82,8))
        │   │   ├── flags: ∅
        │   │   └── name: :X
        │   ├── body:
        │   │   @ StatementsNode (location: (83,2)-(85,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ ModuleNode (location: (83,2)-(85,5))
        │   │           ├── flags: newline
        │   │           ├── locals: []
        │   │           ├── module_keyword_loc: (83,2)-(83,8) = "module"
        │   │           ├── constant_path:
        │   │           │   @ ConstantReadNode (location: (83,9)-(83,10))
        │   │           │   ├── flags: ∅
        │   │           │   └── name: :Y
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (84,4)-(84,10))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ ConstantWriteNode (location: (84,4)-(84,10))
        │   │           │           ├── flags: newline
        │   │           │           ├── name: :Z
        │   │           │           ├── name_loc: (84,4)-(84,5) = "Z"
        │   │           │           ├── value:
        │   │           │           │   @ IntegerNode (location: (84,8)-(84,10))
        │   │           │           │   ├── flags: static_literal, decimal
        │   │           │           │   └── value: 42
        │   │           │           └── operator_loc: (84,6)-(84,7) = "="
        │   │           ├── end_keyword_loc: (85,2)-(85,5) = "end"
        │   │           └── name: :Y
        │   ├── end_keyword_loc: (86,0)-(86,3) = "end"
        │   └── name: :X
        └── @ CallNode (location: (89,0)-(92,1))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :x
            ├── message_loc: (89,0)-(89,1) = "x"
            ├── opening_loc: (89,1)-(89,2) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (90,0)-(91,6))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ SymbolNode (location: (90,0)-(90,6))
            │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   ├── opening_loc: (90,0)-(90,1) = ":"
            │       │   ├── value_loc: (90,1)-(90,6) = "line2"
            │       │   ├── closing_loc: ∅
            │       │   └── unescaped: "line2"
            │       └── @ SymbolNode (location: (91,0)-(91,6))
            │           ├── flags: static_literal, forced_us_ascii_encoding
            │           ├── opening_loc: (91,0)-(91,1) = ":"
            │           ├── value_loc: (91,1)-(91,6) = "line3"
            │           ├── closing_loc: ∅
            │           └── unescaped: "line3"
            ├── closing_loc: (92,0)-(92,1) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/__ENCODING__.txt000066400000000000000000000005031506127434000214020ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ SourceEncodingNode (location: (1,0)-(1,12))
            └── flags: newline, static_literal
prism-1.5.1/snapshots/seattlerb/alias_gvar_backref.txt000066400000000000000000000013271506127434000232120ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,15))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ AliasGlobalVariableNode (location: (1,0)-(1,15))
            ├── flags: newline
            ├── new_name:
            │   @ GlobalVariableReadNode (location: (1,6)-(1,12))
            │   ├── flags: ∅
            │   └── name: :$MATCH
            ├── old_name:
            │   @ BackReferenceReadNode (location: (1,13)-(1,15))
            │   ├── flags: ∅
            │   └── name: :$&
            └── keyword_loc: (1,0)-(1,5) = "alias"
prism-1.5.1/snapshots/seattlerb/alias_resword.txt000066400000000000000000000020631506127434000222610ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ AliasMethodNode (location: (1,0)-(1,12))
            ├── flags: newline
            ├── new_name:
            │   @ SymbolNode (location: (1,6)-(1,8))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: ∅
            │   ├── value_loc: (1,6)-(1,8) = "in"
            │   ├── closing_loc: ∅
            │   └── unescaped: "in"
            ├── old_name:
            │   @ SymbolNode (location: (1,9)-(1,12))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: ∅
            │   ├── value_loc: (1,9)-(1,12) = "out"
            │   ├── closing_loc: ∅
            │   └── unescaped: "out"
            └── keyword_loc: (1,0)-(1,5) = "alias"
prism-1.5.1/snapshots/seattlerb/and_multi.txt000066400000000000000000000027171506127434000214050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ AndNode (location: (1,0)-(3,4))
            ├── flags: newline
            ├── left:
            │   @ AndNode (location: (1,0)-(2,9))
            │   ├── flags: ∅
            │   ├── left:
            │   │   @ TrueNode (location: (1,0)-(1,4))
            │   │   └── flags: static_literal
            │   ├── right:
            │   │   @ CallNode (location: (2,0)-(2,9))
            │   │   ├── flags: ∅
            │   │   ├── receiver:
            │   │   │   @ FalseNode (location: (2,4)-(2,9))
            │   │   │   └── flags: static_literal
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :!
            │   │   ├── message_loc: (2,0)-(2,3) = "not"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   └── operator_loc: (1,5)-(1,8) = "and"
            ├── right:
            │   @ TrueNode (location: (3,0)-(3,4))
            │   └── flags: static_literal
            └── operator_loc: (2,10)-(2,13) = "and"
prism-1.5.1/snapshots/seattlerb/aref_args_assocs.txt000066400000000000000000000024531506127434000227320ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ArrayNode (location: (1,0)-(1,8))
            ├── flags: newline
            ├── elements: (length: 1)
            │   └── @ KeywordHashNode (location: (1,1)-(1,7))
            │       ├── flags: ∅
            │       └── elements: (length: 1)
            │           └── @ AssocNode (location: (1,1)-(1,7))
            │               ├── flags: static_literal
            │               ├── key:
            │               │   @ IntegerNode (location: (1,1)-(1,2))
            │               │   ├── flags: static_literal, decimal
            │               │   └── value: 1
            │               ├── value:
            │               │   @ IntegerNode (location: (1,6)-(1,7))
            │               │   ├── flags: static_literal, decimal
            │               │   └── value: 2
            │               └── operator_loc: (1,3)-(1,5) = "=>"
            ├── opening_loc: (1,0)-(1,1) = "["
            └── closing_loc: (1,7)-(1,8) = "]"
prism-1.5.1/snapshots/seattlerb/aref_args_lit_assocs.txt000066400000000000000000000027411506127434000236020ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,11))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ArrayNode (location: (1,0)-(1,11))
            ├── flags: newline
            ├── elements: (length: 2)
            │   ├── @ IntegerNode (location: (1,1)-(1,2))
            │   │   ├── flags: static_literal, decimal
            │   │   └── value: 1
            │   └── @ KeywordHashNode (location: (1,4)-(1,10))
            │       ├── flags: ∅
            │       └── elements: (length: 1)
            │           └── @ AssocNode (location: (1,4)-(1,10))
            │               ├── flags: static_literal
            │               ├── key:
            │               │   @ IntegerNode (location: (1,4)-(1,5))
            │               │   ├── flags: static_literal, decimal
            │               │   └── value: 2
            │               ├── value:
            │               │   @ IntegerNode (location: (1,9)-(1,10))
            │               │   ├── flags: static_literal, decimal
            │               │   └── value: 3
            │               └── operator_loc: (1,6)-(1,8) = "=>"
            ├── opening_loc: (1,0)-(1,1) = "["
            └── closing_loc: (1,10)-(1,11) = "]"
prism-1.5.1/snapshots/seattlerb/args_kw_block.txt000066400000000000000000000037341506127434000222400ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,20))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,20))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,20))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (1,4)-(1,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,14))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 1)
            │   │   └── @ OptionalKeywordParameterNode (location: (1,6)-(1,10))
            │   │       ├── flags: ∅
            │   │       ├── name: :a
            │   │       ├── name_loc: (1,6)-(1,8) = "a:"
            │   │       └── value:
            │   │           @ IntegerNode (location: (1,9)-(1,10))
            │   │           ├── flags: static_literal, decimal
            │   │           └── value: 1
            │   ├── keyword_rest: ∅
            │   └── block:
            │       @ BlockParameterNode (location: (1,12)-(1,14))
            │       ├── flags: ∅
            │       ├── name: :b
            │       ├── name_loc: (1,13)-(1,14) = "b"
            │       └── operator_loc: (1,12)-(1,13) = "&"
            ├── body: ∅
            ├── locals: [:a, :b]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,14)-(1,15) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,17)-(1,20) = "end"
prism-1.5.1/snapshots/seattlerb/array_line_breaks.txt000066400000000000000000000024541506127434000231030ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,1))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,1))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ ArrayNode (location: (1,0)-(3,4))
        │   ├── flags: newline
        │   ├── elements: (length: 2)
        │   │   ├── @ StringNode (location: (2,0)-(2,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (2,0)-(2,1) = "'"
        │   │   │   ├── content_loc: (2,1)-(2,2) = "a"
        │   │   │   ├── closing_loc: (2,2)-(2,3) = "'"
        │   │   │   └── unescaped: "a"
        │   │   └── @ StringNode (location: (3,0)-(3,3))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (3,0)-(3,1) = "'"
        │   │       ├── content_loc: (3,1)-(3,2) = "b"
        │   │       ├── closing_loc: (3,2)-(3,3) = "'"
        │   │       └── unescaped: "b"
        │   ├── opening_loc: (1,0)-(1,1) = "["
        │   └── closing_loc: (3,3)-(3,4) = "]"
        └── @ IntegerNode (location: (4,0)-(4,1))
            ├── flags: newline, static_literal, decimal
            └── value: 1
prism-1.5.1/snapshots/seattlerb/array_lits_trailing_calls.txt000066400000000000000000000031041506127434000246400ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,4))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(1,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ArrayNode (location: (1,0)-(1,4))
        │   │   ├── flags: static_literal
        │   │   ├── elements: (length: 0)
        │   │   ├── opening_loc: (1,0)-(1,3) = "%w["
        │   │   └── closing_loc: (1,3)-(1,4) = "]"
        │   ├── call_operator_loc: (1,4)-(1,5) = "."
        │   ├── name: :b
        │   ├── message_loc: (1,5)-(1,6) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (3,0)-(3,4))
            ├── flags: newline
            ├── receiver:
            │   @ ArrayNode (location: (3,0)-(3,2))
            │   ├── flags: static_literal
            │   ├── elements: (length: 0)
            │   ├── opening_loc: (3,0)-(3,1) = "["
            │   └── closing_loc: (3,1)-(3,2) = "]"
            ├── call_operator_loc: (3,2)-(3,3) = "."
            ├── name: :b
            ├── message_loc: (3,3)-(3,4) = "b"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/assoc__bare.txt000066400000000000000000000034601506127434000216650ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ HashNode (location: (1,0)-(1,6))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "{"
            ├── elements: (length: 1)
            │   └── @ AssocNode (location: (1,2)-(1,4))
            │       ├── flags: ∅
            │       ├── key:
            │       │   @ SymbolNode (location: (1,2)-(1,4))
            │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   ├── opening_loc: ∅
            │       │   ├── value_loc: (1,2)-(1,3) = "y"
            │       │   ├── closing_loc: (1,3)-(1,4) = ":"
            │       │   └── unescaped: "y"
            │       ├── value:
            │       │   @ ImplicitNode (location: (1,2)-(1,4))
            │       │   ├── flags: ∅
            │       │   └── value:
            │       │       @ CallNode (location: (1,2)-(1,4))
            │       │       ├── flags: ignore_visibility
            │       │       ├── receiver: ∅
            │       │       ├── call_operator_loc: ∅
            │       │       ├── name: :y
            │       │       ├── message_loc: (1,2)-(1,3) = "y"
            │       │       ├── opening_loc: ∅
            │       │       ├── arguments: ∅
            │       │       ├── closing_loc: ∅
            │       │       └── block: ∅
            │       └── operator_loc: ∅
            └── closing_loc: (1,5)-(1,6) = "}"
prism-1.5.1/snapshots/seattlerb/assoc_label.txt000066400000000000000000000037041506127434000216750ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,6))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: (1,1)-(1,2) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,5))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 1)
            │       └── @ KeywordHashNode (location: (1,2)-(1,5))
            │           ├── flags: symbol_keys
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (1,2)-(1,5))
            │                   ├── flags: static_literal
            │                   ├── key:
            │                   │   @ SymbolNode (location: (1,2)-(1,4))
            │                   │   ├── flags: static_literal, forced_us_ascii_encoding
            │                   │   ├── opening_loc: ∅
            │                   │   ├── value_loc: (1,2)-(1,3) = "b"
            │                   │   ├── closing_loc: (1,3)-(1,4) = ":"
            │                   │   └── unescaped: "b"
            │                   ├── value:
            │                   │   @ IntegerNode (location: (1,4)-(1,5))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 1
            │                   └── operator_loc: ∅
            ├── closing_loc: (1,5)-(1,6) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/attr_asgn_colon_id.txt000066400000000000000000000021131506127434000232470ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,8))
            ├── flags: newline, attribute_write
            ├── receiver:
            │   @ ConstantReadNode (location: (1,0)-(1,1))
            │   ├── flags: ∅
            │   └── name: :A
            ├── call_operator_loc: (1,1)-(1,3) = "::"
            ├── name: :b=
            ├── message_loc: (1,3)-(1,4) = "b"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,7)-(1,8))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,7)-(1,8))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/attrasgn_array_arg.txt000066400000000000000000000042751506127434000233040ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,13))
            ├── flags: newline, attribute_write
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :[]=
            ├── message_loc: (1,1)-(1,9) = "[[1, 2]]"
            ├── opening_loc: (1,1)-(1,2) = "["
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,13))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ ArrayNode (location: (1,2)-(1,8))
            │       │   ├── flags: static_literal
            │       │   ├── elements: (length: 2)
            │       │   │   ├── @ IntegerNode (location: (1,3)-(1,4))
            │       │   │   │   ├── flags: static_literal, decimal
            │       │   │   │   └── value: 1
            │       │   │   └── @ IntegerNode (location: (1,6)-(1,7))
            │       │   │       ├── flags: static_literal, decimal
            │       │   │       └── value: 2
            │       │   ├── opening_loc: (1,2)-(1,3) = "["
            │       │   └── closing_loc: (1,7)-(1,8) = "]"
            │       └── @ IntegerNode (location: (1,12)-(1,13))
            │           ├── flags: static_literal, decimal
            │           └── value: 3
            ├── closing_loc: (1,8)-(1,9) = "]"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/attrasgn_array_lhs.txt000066400000000000000000000117351506127434000233200ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,42))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,42))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,42))
            ├── flags: newline, attribute_write
            ├── receiver:
            │   @ ArrayNode (location: (1,0)-(1,12))
            │   ├── flags: static_literal
            │   ├── elements: (length: 4)
            │   │   ├── @ IntegerNode (location: (1,1)-(1,2))
            │   │   │   ├── flags: static_literal, decimal
            │   │   │   └── value: 1
            │   │   ├── @ IntegerNode (location: (1,4)-(1,5))
            │   │   │   ├── flags: static_literal, decimal
            │   │   │   └── value: 2
            │   │   ├── @ IntegerNode (location: (1,7)-(1,8))
            │   │   │   ├── flags: static_literal, decimal
            │   │   │   └── value: 3
            │   │   └── @ IntegerNode (location: (1,10)-(1,11))
            │   │       ├── flags: static_literal, decimal
            │   │       └── value: 4
            │   ├── opening_loc: (1,0)-(1,1) = "["
            │   └── closing_loc: (1,11)-(1,12) = "]"
            ├── call_operator_loc: ∅
            ├── name: :[]=
            ├── message_loc: (1,12)-(1,24) = "[from .. to]"
            ├── opening_loc: (1,12)-(1,13) = "["
            ├── arguments:
            │   @ ArgumentsNode (location: (1,13)-(1,42))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ RangeNode (location: (1,13)-(1,23))
            │       │   ├── flags: ∅
            │       │   ├── left:
            │       │   │   @ CallNode (location: (1,13)-(1,17))
            │       │   │   ├── flags: variable_call, ignore_visibility
            │       │   │   ├── receiver: ∅
            │       │   │   ├── call_operator_loc: ∅
            │       │   │   ├── name: :from
            │       │   │   ├── message_loc: (1,13)-(1,17) = "from"
            │       │   │   ├── opening_loc: ∅
            │       │   │   ├── arguments: ∅
            │       │   │   ├── closing_loc: ∅
            │       │   │   └── block: ∅
            │       │   ├── right:
            │       │   │   @ CallNode (location: (1,21)-(1,23))
            │       │   │   ├── flags: variable_call, ignore_visibility
            │       │   │   ├── receiver: ∅
            │       │   │   ├── call_operator_loc: ∅
            │       │   │   ├── name: :to
            │       │   │   ├── message_loc: (1,21)-(1,23) = "to"
            │       │   │   ├── opening_loc: ∅
            │       │   │   ├── arguments: ∅
            │       │   │   ├── closing_loc: ∅
            │       │   │   └── block: ∅
            │       │   └── operator_loc: (1,18)-(1,20) = ".."
            │       └── @ ArrayNode (location: (1,27)-(1,42))
            │           ├── flags: ∅
            │           ├── elements: (length: 3)
            │           │   ├── @ StringNode (location: (1,28)-(1,31))
            │           │   │   ├── flags: ∅
            │           │   │   ├── opening_loc: (1,28)-(1,29) = "\""
            │           │   │   ├── content_loc: (1,29)-(1,30) = "a"
            │           │   │   ├── closing_loc: (1,30)-(1,31) = "\""
            │           │   │   └── unescaped: "a"
            │           │   ├── @ StringNode (location: (1,33)-(1,36))
            │           │   │   ├── flags: ∅
            │           │   │   ├── opening_loc: (1,33)-(1,34) = "\""
            │           │   │   ├── content_loc: (1,34)-(1,35) = "b"
            │           │   │   ├── closing_loc: (1,35)-(1,36) = "\""
            │           │   │   └── unescaped: "b"
            │           │   └── @ StringNode (location: (1,38)-(1,41))
            │           │       ├── flags: ∅
            │           │       ├── opening_loc: (1,38)-(1,39) = "\""
            │           │       ├── content_loc: (1,39)-(1,40) = "c"
            │           │       ├── closing_loc: (1,40)-(1,41) = "\""
            │           │       └── unescaped: "c"
            │           ├── opening_loc: (1,27)-(1,28) = "["
            │           └── closing_loc: (1,41)-(1,42) = "]"
            ├── closing_loc: (1,23)-(1,24) = "]"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/attrasgn_primary_dot_constant.txt000066400000000000000000000026431506127434000255740ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,7))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,7))
            ├── flags: newline, attribute_write
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (1,1)-(1,2) = "."
            ├── name: :B=
            ├── message_loc: (1,2)-(1,3) = "B"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,6)-(1,7))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,6)-(1,7))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/backticks_interpolation_line.txt000066400000000000000000000046521506127434000253450ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,8))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :x
            ├── message_loc: (1,0)-(1,1) = "x"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,8))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ InterpolatedXStringNode (location: (1,2)-(1,8))
            │           ├── flags: ∅
            │           ├── opening_loc: (1,2)-(1,3) = "`"
            │           ├── parts: (length: 1)
            │           │   └── @ EmbeddedStatementsNode (location: (1,3)-(1,7))
            │           │       ├── flags: ∅
            │           │       ├── opening_loc: (1,3)-(1,5) = "\#{"
            │           │       ├── statements:
            │           │       │   @ StatementsNode (location: (1,5)-(1,6))
            │           │       │   ├── flags: ∅
            │           │       │   └── body: (length: 1)
            │           │       │       └── @ CallNode (location: (1,5)-(1,6))
            │           │       │           ├── flags: variable_call, ignore_visibility
            │           │       │           ├── receiver: ∅
            │           │       │           ├── call_operator_loc: ∅
            │           │       │           ├── name: :y
            │           │       │           ├── message_loc: (1,5)-(1,6) = "y"
            │           │       │           ├── opening_loc: ∅
            │           │       │           ├── arguments: ∅
            │           │       │           ├── closing_loc: ∅
            │           │       │           └── block: ∅
            │           │       └── closing_loc: (1,6)-(1,7) = "}"
            │           └── closing_loc: (1,7)-(1,8) = "`"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/bang_eq.txt000066400000000000000000000020731506127434000210200ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,6))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :!=
            ├── message_loc: (1,2)-(1,4) = "!="
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,5)-(1,6))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,5)-(1,6))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/bdot2.txt000066400000000000000000000033241506127434000204360ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ RangeNode (location: (1,0)-(1,4))
        │   ├── flags: newline, static_literal
        │   ├── left: ∅
        │   ├── right:
        │   │   @ IntegerNode (location: (1,2)-(1,4))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 10
        │   └── operator_loc: (1,0)-(1,2) = ".."
        ├── @ RangeNode (location: (2,2)-(2,5))
        │   ├── flags: newline
        │   ├── left: ∅
        │   ├── right:
        │   │   @ CallNode (location: (2,4)-(2,5))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (2,4)-(2,5) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (2,2)-(2,4) = ".."
        └── @ CallNode (location: (3,2)-(3,3))
            ├── flags: newline, variable_call, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :c
            ├── message_loc: (3,2)-(3,3) = "c"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/bdot3.txt000066400000000000000000000033601506127434000204370ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ RangeNode (location: (1,0)-(1,5))
        │   ├── flags: newline, static_literal, exclude_end
        │   ├── left: ∅
        │   ├── right:
        │   │   @ IntegerNode (location: (1,3)-(1,5))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 10
        │   └── operator_loc: (1,0)-(1,3) = "..."
        ├── @ RangeNode (location: (2,2)-(2,6))
        │   ├── flags: newline, exclude_end
        │   ├── left: ∅
        │   ├── right:
        │   │   @ CallNode (location: (2,5)-(2,6))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (2,5)-(2,6) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (2,2)-(2,5) = "..."
        └── @ CallNode (location: (3,2)-(3,3))
            ├── flags: newline, variable_call, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :c
            ├── message_loc: (3,2)-(3,3) = "c"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/begin_ensure_no_bodies.txt000066400000000000000000000015161506127434000241130ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ BeginNode (location: (1,0)-(3,3))
            ├── flags: newline
            ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
            ├── statements: ∅
            ├── rescue_clause: ∅
            ├── else_clause: ∅
            ├── ensure_clause:
            │   @ EnsureNode (location: (2,0)-(3,3))
            │   ├── flags: ∅
            │   ├── ensure_keyword_loc: (2,0)-(2,6) = "ensure"
            │   ├── statements: ∅
            │   └── end_keyword_loc: (3,0)-(3,3) = "end"
            └── end_keyword_loc: (3,0)-(3,3) = "end"
prism-1.5.1/snapshots/seattlerb/begin_rescue_else_ensure_bodies.txt000066400000000000000000000056421506127434000260010ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(9,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(9,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ BeginNode (location: (1,0)-(9,3))
            ├── flags: newline
            ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
            ├── statements:
            │   @ StatementsNode (location: (2,2)-(2,3))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ IntegerNode (location: (2,2)-(2,3))
            │           ├── flags: newline, static_literal, decimal
            │           └── value: 1
            ├── rescue_clause:
            │   @ RescueNode (location: (3,0)-(4,3))
            │   ├── flags: ∅
            │   ├── keyword_loc: (3,0)-(3,6) = "rescue"
            │   ├── exceptions: (length: 0)
            │   ├── operator_loc: ∅
            │   ├── reference: ∅
            │   ├── then_keyword_loc: ∅
            │   ├── statements:
            │   │   @ StatementsNode (location: (4,2)-(4,3))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ IntegerNode (location: (4,2)-(4,3))
            │   │           ├── flags: newline, static_literal, decimal
            │   │           └── value: 2
            │   └── subsequent: ∅
            ├── else_clause:
            │   @ ElseNode (location: (5,0)-(7,6))
            │   ├── flags: ∅
            │   ├── else_keyword_loc: (5,0)-(5,4) = "else"
            │   ├── statements:
            │   │   @ StatementsNode (location: (6,2)-(6,3))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ IntegerNode (location: (6,2)-(6,3))
            │   │           ├── flags: newline, static_literal, decimal
            │   │           └── value: 3
            │   └── end_keyword_loc: (7,0)-(7,6) = "ensure"
            ├── ensure_clause:
            │   @ EnsureNode (location: (7,0)-(9,3))
            │   ├── flags: ∅
            │   ├── ensure_keyword_loc: (7,0)-(7,6) = "ensure"
            │   ├── statements:
            │   │   @ StatementsNode (location: (8,2)-(8,3))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ IntegerNode (location: (8,2)-(8,3))
            │   │           ├── flags: newline, static_literal, decimal
            │   │           └── value: 4
            │   └── end_keyword_loc: (9,0)-(9,3) = "end"
            └── end_keyword_loc: (9,0)-(9,3) = "end"
prism-1.5.1/snapshots/seattlerb/begin_rescue_else_ensure_no_bodies.txt000066400000000000000000000030121506127434000264620ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(9,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(9,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ BeginNode (location: (1,0)-(9,3))
            ├── flags: newline
            ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
            ├── statements: ∅
            ├── rescue_clause:
            │   @ RescueNode (location: (3,0)-(3,6))
            │   ├── flags: ∅
            │   ├── keyword_loc: (3,0)-(3,6) = "rescue"
            │   ├── exceptions: (length: 0)
            │   ├── operator_loc: ∅
            │   ├── reference: ∅
            │   ├── then_keyword_loc: ∅
            │   ├── statements: ∅
            │   └── subsequent: ∅
            ├── else_clause:
            │   @ ElseNode (location: (5,0)-(7,6))
            │   ├── flags: ∅
            │   ├── else_keyword_loc: (5,0)-(5,4) = "else"
            │   ├── statements: ∅
            │   └── end_keyword_loc: (7,0)-(7,6) = "ensure"
            ├── ensure_clause:
            │   @ EnsureNode (location: (7,0)-(9,3))
            │   ├── flags: ∅
            │   ├── ensure_keyword_loc: (7,0)-(7,6) = "ensure"
            │   ├── statements: ∅
            │   └── end_keyword_loc: (9,0)-(9,3) = "end"
            └── end_keyword_loc: (9,0)-(9,3) = "end"
prism-1.5.1/snapshots/seattlerb/begin_rescue_ensure_no_bodies.txt000066400000000000000000000023771506127434000254670ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ BeginNode (location: (1,0)-(4,3))
            ├── flags: newline
            ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
            ├── statements: ∅
            ├── rescue_clause:
            │   @ RescueNode (location: (2,0)-(2,6))
            │   ├── flags: ∅
            │   ├── keyword_loc: (2,0)-(2,6) = "rescue"
            │   ├── exceptions: (length: 0)
            │   ├── operator_loc: ∅
            │   ├── reference: ∅
            │   ├── then_keyword_loc: ∅
            │   ├── statements: ∅
            │   └── subsequent: ∅
            ├── else_clause: ∅
            ├── ensure_clause:
            │   @ EnsureNode (location: (3,0)-(4,3))
            │   ├── flags: ∅
            │   ├── ensure_keyword_loc: (3,0)-(3,6) = "ensure"
            │   ├── statements: ∅
            │   └── end_keyword_loc: (4,0)-(4,3) = "end"
            └── end_keyword_loc: (4,0)-(4,3) = "end"
prism-1.5.1/snapshots/seattlerb/block_arg__bare.txt000066400000000000000000000027231506127434000225010ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,13))
            ├── flags: newline
            ├── name: :x
            ├── name_loc: (1,4)-(1,5) = "x"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,7))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block:
            │       @ BlockParameterNode (location: (1,6)-(1,7))
            │       ├── flags: ∅
            │       ├── name: ∅
            │       ├── name_loc: ∅
            │       └── operator_loc: (1,6)-(1,7) = "&"
            ├── body: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,7)-(1,8) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,10)-(1,13) = "end"
prism-1.5.1/snapshots/seattlerb/block_arg_kwsplat.txt000066400000000000000000000041151506127434000231130ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,11))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,11))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,11))
                ├── flags: ∅
                ├── locals: [:b]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,9))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,8))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest:
                │   │   │   @ KeywordRestParameterNode (location: (1,5)-(1,8))
                │   │   │   ├── flags: ∅
                │   │   │   ├── name: :b
                │   │   │   ├── name_loc: (1,7)-(1,8) = "b"
                │   │   │   └── operator_loc: (1,5)-(1,7) = "**"
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,8)-(1,9) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,10)-(1,11) = "}"
prism-1.5.1/snapshots/seattlerb/block_arg_opt_arg_block.txt000066400000000000000000000061731506127434000242410ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,21))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,21))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,21))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,21))
                ├── flags: ∅
                ├── locals: [:b, :c, :d, :e]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,19))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,18))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :b
                │   │   ├── optionals: (length: 1)
                │   │   │   └── @ OptionalParameterNode (location: (1,8)-(1,11))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :c
                │   │   │       ├── name_loc: (1,8)-(1,9) = "c"
                │   │   │       ├── operator_loc: (1,9)-(1,10) = "="
                │   │   │       └── value:
                │   │   │           @ IntegerNode (location: (1,10)-(1,11))
                │   │   │           ├── flags: static_literal, decimal
                │   │   │           └── value: 1
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,13)-(1,14))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :d
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block:
                │   │       @ BlockParameterNode (location: (1,16)-(1,18))
                │   │       ├── flags: ∅
                │   │       ├── name: :e
                │   │       ├── name_loc: (1,17)-(1,18) = "e"
                │   │       └── operator_loc: (1,16)-(1,17) = "&"
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,18)-(1,19) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,20)-(1,21) = "}"
prism-1.5.1/snapshots/seattlerb/block_arg_opt_splat.txt000066400000000000000000000056571506127434000234470ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,20))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,20))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,20))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,20))
                ├── flags: ∅
                ├── locals: [:b, :c, :d]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,18))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,17))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :b
                │   │   ├── optionals: (length: 1)
                │   │   │   └── @ OptionalParameterNode (location: (1,8)-(1,13))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :c
                │   │   │       ├── name_loc: (1,8)-(1,9) = "c"
                │   │   │       ├── operator_loc: (1,10)-(1,11) = "="
                │   │   │       └── value:
                │   │   │           @ IntegerNode (location: (1,12)-(1,13))
                │   │   │           ├── flags: static_literal, decimal
                │   │   │           └── value: 1
                │   │   ├── rest:
                │   │   │   @ RestParameterNode (location: (1,15)-(1,17))
                │   │   │   ├── flags: ∅
                │   │   │   ├── name: :d
                │   │   │   ├── name_loc: (1,16)-(1,17) = "d"
                │   │   │   └── operator_loc: (1,15)-(1,16) = "*"
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,17)-(1,18) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,19)-(1,20) = "}"
prism-1.5.1/snapshots/seattlerb/block_arg_opt_splat_arg_block_omfg.txt000066400000000000000000000067171506127434000264600ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,25))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,25))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,25))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,25))
                ├── flags: ∅
                ├── locals: [:b, :c, :d, :e, :f]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,23))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,22))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :b
                │   │   ├── optionals: (length: 1)
                │   │   │   └── @ OptionalParameterNode (location: (1,8)-(1,11))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :c
                │   │   │       ├── name_loc: (1,8)-(1,9) = "c"
                │   │   │       ├── operator_loc: (1,9)-(1,10) = "="
                │   │   │       └── value:
                │   │   │           @ IntegerNode (location: (1,10)-(1,11))
                │   │   │           ├── flags: static_literal, decimal
                │   │   │           └── value: 1
                │   │   ├── rest:
                │   │   │   @ RestParameterNode (location: (1,13)-(1,15))
                │   │   │   ├── flags: ∅
                │   │   │   ├── name: :d
                │   │   │   ├── name_loc: (1,14)-(1,15) = "d"
                │   │   │   └── operator_loc: (1,13)-(1,14) = "*"
                │   │   ├── posts: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,17)-(1,18))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :e
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block:
                │   │       @ BlockParameterNode (location: (1,20)-(1,22))
                │   │       ├── flags: ∅
                │   │       ├── name: :f
                │   │       ├── name_loc: (1,21)-(1,22) = "f"
                │   │       └── operator_loc: (1,20)-(1,21) = "&"
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,22)-(1,23) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,24)-(1,25) = "}"
prism-1.5.1/snapshots/seattlerb/block_arg_optional.txt000066400000000000000000000046041506127434000232560ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,13))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,13))
                ├── flags: ∅
                ├── locals: [:b]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,11))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,10))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 1)
                │   │   │   └── @ OptionalParameterNode (location: (1,5)-(1,10))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :b
                │   │   │       ├── name_loc: (1,5)-(1,6) = "b"
                │   │   │       ├── operator_loc: (1,7)-(1,8) = "="
                │   │   │       └── value:
                │   │   │           @ IntegerNode (location: (1,9)-(1,10))
                │   │   │           ├── flags: static_literal, decimal
                │   │   │           └── value: 1
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,10)-(1,11) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,12)-(1,13) = "}"
prism-1.5.1/snapshots/seattlerb/block_arg_scope.txt000066400000000000000000000042201506127434000225340ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,12))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,12))
                ├── flags: ∅
                ├── locals: [:b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,10))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,6))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :b
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 1)
                │   │   └── @ BlockLocalVariableNode (location: (1,8)-(1,9))
                │   │       ├── flags: ∅
                │   │       └── name: :c
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,9)-(1,10) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,11)-(1,12) = "}"
prism-1.5.1/snapshots/seattlerb/block_arg_scope2.txt000066400000000000000000000045321506127434000226240ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,14))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,14))
                ├── flags: ∅
                ├── locals: [:b, :c, :d]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,3)-(1,12))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,4)-(1,5))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,4)-(1,5))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :b
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 2)
                │   │   ├── @ BlockLocalVariableNode (location: (1,7)-(1,8))
                │   │   │   ├── flags: ∅
                │   │   │   └── name: :c
                │   │   └── @ BlockLocalVariableNode (location: (1,10)-(1,11))
                │   │       ├── flags: ∅
                │   │       └── name: :d
                │   ├── opening_loc: (1,3)-(1,4) = "|"
                │   └── closing_loc: (1,11)-(1,12) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,13)-(1,14) = "}"
prism-1.5.1/snapshots/seattlerb/block_arg_splat_arg.txt000066400000000000000000000047651506127434000234150ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,16))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,16))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,16))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,16))
                ├── flags: ∅
                ├── locals: [:b, :c, :d]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,14))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,13))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :b
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest:
                │   │   │   @ RestParameterNode (location: (1,8)-(1,10))
                │   │   │   ├── flags: ∅
                │   │   │   ├── name: :c
                │   │   │   ├── name_loc: (1,9)-(1,10) = "c"
                │   │   │   └── operator_loc: (1,8)-(1,9) = "*"
                │   │   ├── posts: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,12)-(1,13))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :d
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,13)-(1,14) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,15)-(1,16) = "}"
prism-1.5.1/snapshots/seattlerb/block_args_kwargs.txt000066400000000000000000000047601506127434000231150ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,23))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,23))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,23))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,23))
                ├── flags: ∅
                ├── locals: [:kwargs]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,14))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,13))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest:
                │   │   │   @ KeywordRestParameterNode (location: (1,5)-(1,13))
                │   │   │   ├── flags: ∅
                │   │   │   ├── name: :kwargs
                │   │   │   ├── name_loc: (1,7)-(1,13) = "kwargs"
                │   │   │   └── operator_loc: (1,5)-(1,7) = "**"
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,13)-(1,14) = "|"
                ├── body:
                │   @ StatementsNode (location: (1,15)-(1,21))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ LocalVariableReadNode (location: (1,15)-(1,21))
                │           ├── flags: newline
                │           ├── name: :kwargs
                │           └── depth: 0
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,22)-(1,23) = "}"
prism-1.5.1/snapshots/seattlerb/block_args_no_kwargs.txt000066400000000000000000000040401506127434000236000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,13))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,13))
                ├── flags: ∅
                ├── locals: []
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,11))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,10))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest:
                │   │   │   @ NoKeywordsParameterNode (location: (1,5)-(1,10))
                │   │   │   ├── flags: ∅
                │   │   │   ├── operator_loc: (1,5)-(1,7) = "**"
                │   │   │   └── keyword_loc: (1,7)-(1,10) = "nil"
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,10)-(1,11) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,12)-(1,13) = "}"
prism-1.5.1/snapshots/seattlerb/block_args_opt1.txt000066400000000000000000000071631506127434000225020ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,24))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,24))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,24))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,24))
                ├── flags: ∅
                ├── locals: [:a, :b]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,15))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,14))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :a
                │   │   ├── optionals: (length: 1)
                │   │   │   └── @ OptionalParameterNode (location: (1,8)-(1,14))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :b
                │   │   │       ├── name_loc: (1,8)-(1,9) = "b"
                │   │   │       ├── operator_loc: (1,10)-(1,11) = "="
                │   │   │       └── value:
                │   │   │           @ IntegerNode (location: (1,12)-(1,14))
                │   │   │           ├── flags: static_literal, decimal
                │   │   │           └── value: 42
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,14)-(1,15) = "|"
                ├── body:
                │   @ StatementsNode (location: (1,16)-(1,22))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ ArrayNode (location: (1,16)-(1,22))
                │           ├── flags: newline
                │           ├── elements: (length: 2)
                │           │   ├── @ LocalVariableReadNode (location: (1,17)-(1,18))
                │           │   │   ├── flags: ∅
                │           │   │   ├── name: :a
                │           │   │   └── depth: 0
                │           │   └── @ LocalVariableReadNode (location: (1,20)-(1,21))
                │           │       ├── flags: ∅
                │           │       ├── name: :b
                │           │       └── depth: 0
                │           ├── opening_loc: (1,16)-(1,17) = "["
                │           └── closing_loc: (1,21)-(1,22) = "]"
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,23)-(1,24) = "}"
prism-1.5.1/snapshots/seattlerb/block_args_opt2.txt000066400000000000000000000060411506127434000224750ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,18))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,18))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,18))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,18))
                ├── flags: ∅
                ├── locals: [:b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,16))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,6)-(1,14))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 2)
                │   │   │   ├── @ OptionalParameterNode (location: (1,6)-(1,9))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   ├── name: :b
                │   │   │   │   ├── name_loc: (1,6)-(1,7) = "b"
                │   │   │   │   ├── operator_loc: (1,7)-(1,8) = "="
                │   │   │   │   └── value:
                │   │   │   │       @ IntegerNode (location: (1,8)-(1,9))
                │   │   │   │       ├── flags: static_literal, decimal
                │   │   │   │       └── value: 1
                │   │   │   └── @ OptionalParameterNode (location: (1,11)-(1,14))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :c
                │   │   │       ├── name_loc: (1,11)-(1,12) = "c"
                │   │   │       ├── operator_loc: (1,12)-(1,13) = "="
                │   │   │       └── value:
                │   │   │           @ IntegerNode (location: (1,13)-(1,14))
                │   │   │           ├── flags: static_literal, decimal
                │   │   │           └── value: 2
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,15)-(1,16) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,17)-(1,18) = "}"
prism-1.5.1/snapshots/seattlerb/block_args_opt2_2.txt000066400000000000000000000110541506127434000227160ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,35))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,35))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,35))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,35))
                ├── flags: ∅
                ├── locals: [:a, :b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,23))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,22))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :a
                │   │   ├── optionals: (length: 2)
                │   │   │   ├── @ OptionalParameterNode (location: (1,8)-(1,14))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   ├── name: :b
                │   │   │   │   ├── name_loc: (1,8)-(1,9) = "b"
                │   │   │   │   ├── operator_loc: (1,10)-(1,11) = "="
                │   │   │   │   └── value:
                │   │   │   │       @ IntegerNode (location: (1,12)-(1,14))
                │   │   │   │       ├── flags: static_literal, decimal
                │   │   │   │       └── value: 42
                │   │   │   └── @ OptionalParameterNode (location: (1,16)-(1,22))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :c
                │   │   │       ├── name_loc: (1,16)-(1,17) = "c"
                │   │   │       ├── operator_loc: (1,18)-(1,19) = "="
                │   │   │       └── value:
                │   │   │           @ IntegerNode (location: (1,20)-(1,22))
                │   │   │           ├── flags: static_literal, decimal
                │   │   │           └── value: 24
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,22)-(1,23) = "|"
                ├── body:
                │   @ StatementsNode (location: (1,24)-(1,33))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ ArrayNode (location: (1,24)-(1,33))
                │           ├── flags: newline
                │           ├── elements: (length: 3)
                │           │   ├── @ LocalVariableReadNode (location: (1,25)-(1,26))
                │           │   │   ├── flags: ∅
                │           │   │   ├── name: :a
                │           │   │   └── depth: 0
                │           │   ├── @ LocalVariableReadNode (location: (1,28)-(1,29))
                │           │   │   ├── flags: ∅
                │           │   │   ├── name: :b
                │           │   │   └── depth: 0
                │           │   └── @ LocalVariableReadNode (location: (1,31)-(1,32))
                │           │       ├── flags: ∅
                │           │       ├── name: :c
                │           │       └── depth: 0
                │           ├── opening_loc: (1,24)-(1,25) = "["
                │           └── closing_loc: (1,32)-(1,33) = "]"
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,34)-(1,35) = "}"
prism-1.5.1/snapshots/seattlerb/block_args_opt3.txt000066400000000000000000000122201506127434000224720ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,42))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,42))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,42))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,42))
                ├── flags: ∅
                ├── locals: [:a, :b, :c, :d]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,27))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,26))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :a
                │   │   ├── optionals: (length: 2)
                │   │   │   ├── @ OptionalParameterNode (location: (1,8)-(1,14))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   ├── name: :b
                │   │   │   │   ├── name_loc: (1,8)-(1,9) = "b"
                │   │   │   │   ├── operator_loc: (1,10)-(1,11) = "="
                │   │   │   │   └── value:
                │   │   │   │       @ IntegerNode (location: (1,12)-(1,14))
                │   │   │   │       ├── flags: static_literal, decimal
                │   │   │   │       └── value: 42
                │   │   │   └── @ OptionalParameterNode (location: (1,16)-(1,22))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :c
                │   │   │       ├── name_loc: (1,16)-(1,17) = "c"
                │   │   │       ├── operator_loc: (1,18)-(1,19) = "="
                │   │   │       └── value:
                │   │   │           @ IntegerNode (location: (1,20)-(1,22))
                │   │   │           ├── flags: static_literal, decimal
                │   │   │           └── value: 24
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block:
                │   │       @ BlockParameterNode (location: (1,24)-(1,26))
                │   │       ├── flags: ∅
                │   │       ├── name: :d
                │   │       ├── name_loc: (1,25)-(1,26) = "d"
                │   │       └── operator_loc: (1,24)-(1,25) = "&"
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,26)-(1,27) = "|"
                ├── body:
                │   @ StatementsNode (location: (1,28)-(1,40))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ ArrayNode (location: (1,28)-(1,40))
                │           ├── flags: newline
                │           ├── elements: (length: 4)
                │           │   ├── @ LocalVariableReadNode (location: (1,29)-(1,30))
                │           │   │   ├── flags: ∅
                │           │   │   ├── name: :a
                │           │   │   └── depth: 0
                │           │   ├── @ LocalVariableReadNode (location: (1,32)-(1,33))
                │           │   │   ├── flags: ∅
                │           │   │   ├── name: :b
                │           │   │   └── depth: 0
                │           │   ├── @ LocalVariableReadNode (location: (1,35)-(1,36))
                │           │   │   ├── flags: ∅
                │           │   │   ├── name: :c
                │           │   │   └── depth: 0
                │           │   └── @ LocalVariableReadNode (location: (1,38)-(1,39))
                │           │       ├── flags: ∅
                │           │       ├── name: :d
                │           │       └── depth: 0
                │           ├── opening_loc: (1,28)-(1,29) = "["
                │           └── closing_loc: (1,39)-(1,40) = "]"
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,41)-(1,42) = "}"
prism-1.5.1/snapshots/seattlerb/block_call_defn_call_block_call.txt000066400000000000000000000107111506127434000256430ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,11))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(3,4))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (1,0)-(1,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(3,4))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ DefNode (location: (1,2)-(3,4))
        │   │           ├── flags: ∅
        │   │           ├── name: :b
        │   │           ├── name_loc: (1,6)-(1,7) = "b"
        │   │           ├── receiver: ∅
        │   │           ├── parameters:
        │   │           │   @ ParametersNode (location: (1,8)-(1,9))
        │   │           │   ├── flags: ∅
        │   │           │   ├── requireds: (length: 1)
        │   │           │   │   └── @ RequiredParameterNode (location: (1,8)-(1,9))
        │   │           │   │       ├── flags: ∅
        │   │           │   │       └── name: :c
        │   │           │   ├── optionals: (length: 0)
        │   │           │   ├── rest: ∅
        │   │           │   ├── posts: (length: 0)
        │   │           │   ├── keywords: (length: 0)
        │   │           │   ├── keyword_rest: ∅
        │   │           │   └── block: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (2,1)-(2,2))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (2,1)-(2,2))
        │   │           │           ├── flags: newline, variable_call, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :d
        │   │           │           ├── message_loc: (2,1)-(2,2) = "d"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── locals: [:c]
        │   │           ├── def_keyword_loc: (1,2)-(1,5) = "def"
        │   │           ├── operator_loc: ∅
        │   │           ├── lparen_loc: (1,7)-(1,8) = "("
        │   │           ├── rparen_loc: (1,9)-(1,10) = ")"
        │   │           ├── equal_loc: ∅
        │   │           └── end_keyword_loc: (3,1)-(3,4) = "end"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (4,1)-(4,11))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (4,1)-(4,2))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :e
            │   ├── message_loc: (4,1)-(4,2) = "e"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (4,2)-(4,3) = "."
            ├── name: :f
            ├── message_loc: (4,3)-(4,4) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (4,5)-(4,11))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (4,5)-(4,7) = "do"
                └── closing_loc: (4,8)-(4,11) = "end"
prism-1.5.1/snapshots/seattlerb/block_call_dot_op2_brace_block.txt000066400000000000000000000132561506127434000254520ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,31))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,31))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,31))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,16))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ CallNode (location: (1,0)-(1,1))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :a
            │   │   ├── message_loc: (1,0)-(1,1) = "a"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── call_operator_loc: (1,1)-(1,2) = "."
            │   ├── name: :b
            │   ├── message_loc: (1,2)-(1,3) = "b"
            │   ├── opening_loc: ∅
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (1,4)-(1,7))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 1)
            │   │       └── @ CallNode (location: (1,4)-(1,7))
            │   │           ├── flags: ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :c
            │   │           ├── message_loc: (1,4)-(1,5) = "c"
            │   │           ├── opening_loc: (1,5)-(1,6) = "("
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: (1,6)-(1,7) = ")"
            │   │           └── block: ∅
            │   ├── closing_loc: ∅
            │   └── block:
            │       @ BlockNode (location: (1,8)-(1,16))
            │       ├── flags: ∅
            │       ├── locals: []
            │       ├── parameters: ∅
            │       ├── body:
            │       │   @ StatementsNode (location: (1,11)-(1,12))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ CallNode (location: (1,11)-(1,12))
            │       │           ├── flags: newline, variable_call, ignore_visibility
            │       │           ├── receiver: ∅
            │       │           ├── call_operator_loc: ∅
            │       │           ├── name: :d
            │       │           ├── message_loc: (1,11)-(1,12) = "d"
            │       │           ├── opening_loc: ∅
            │       │           ├── arguments: ∅
            │       │           ├── closing_loc: ∅
            │       │           └── block: ∅
            │       ├── opening_loc: (1,8)-(1,10) = "do"
            │       └── closing_loc: (1,13)-(1,16) = "end"
            ├── call_operator_loc: (1,16)-(1,17) = "."
            ├── name: :e
            ├── message_loc: (1,17)-(1,18) = "e"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,19)-(1,31))
                ├── flags: ∅
                ├── locals: [:f]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,22)-(1,25))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,23)-(1,24))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,23)-(1,24))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :f
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,22)-(1,23) = "|"
                │   └── closing_loc: (1,24)-(1,25) = "|"
                ├── body:
                │   @ StatementsNode (location: (1,26)-(1,27))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ CallNode (location: (1,26)-(1,27))
                │           ├── flags: newline, variable_call, ignore_visibility
                │           ├── receiver: ∅
                │           ├── call_operator_loc: ∅
                │           ├── name: :g
                │           ├── message_loc: (1,26)-(1,27) = "g"
                │           ├── opening_loc: ∅
                │           ├── arguments: ∅
                │           ├── closing_loc: ∅
                │           └── block: ∅
                ├── opening_loc: (1,19)-(1,21) = "do"
                └── closing_loc: (1,28)-(1,31) = "end"
prism-1.5.1/snapshots/seattlerb/block_call_dot_op2_cmd_args_do_block.txt000066400000000000000000000145741506127434000266430ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,33))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,33))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,33))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,16))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ CallNode (location: (1,0)-(1,1))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :a
            │   │   ├── message_loc: (1,0)-(1,1) = "a"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── call_operator_loc: (1,1)-(1,2) = "."
            │   ├── name: :b
            │   ├── message_loc: (1,2)-(1,3) = "b"
            │   ├── opening_loc: ∅
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (1,4)-(1,7))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 1)
            │   │       └── @ CallNode (location: (1,4)-(1,7))
            │   │           ├── flags: ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :c
            │   │           ├── message_loc: (1,4)-(1,5) = "c"
            │   │           ├── opening_loc: (1,5)-(1,6) = "("
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: (1,6)-(1,7) = ")"
            │   │           └── block: ∅
            │   ├── closing_loc: ∅
            │   └── block:
            │       @ BlockNode (location: (1,8)-(1,16))
            │       ├── flags: ∅
            │       ├── locals: []
            │       ├── parameters: ∅
            │       ├── body:
            │       │   @ StatementsNode (location: (1,11)-(1,12))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ CallNode (location: (1,11)-(1,12))
            │       │           ├── flags: newline, variable_call, ignore_visibility
            │       │           ├── receiver: ∅
            │       │           ├── call_operator_loc: ∅
            │       │           ├── name: :d
            │       │           ├── message_loc: (1,11)-(1,12) = "d"
            │       │           ├── opening_loc: ∅
            │       │           ├── arguments: ∅
            │       │           ├── closing_loc: ∅
            │       │           └── block: ∅
            │       ├── opening_loc: (1,8)-(1,10) = "do"
            │       └── closing_loc: (1,13)-(1,16) = "end"
            ├── call_operator_loc: (1,16)-(1,17) = "."
            ├── name: :e
            ├── message_loc: (1,17)-(1,18) = "e"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,19)-(1,20))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ CallNode (location: (1,19)-(1,20))
            │           ├── flags: variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :f
            │           ├── message_loc: (1,19)-(1,20) = "f"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,21)-(1,33))
                ├── flags: ∅
                ├── locals: [:g]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,24)-(1,27))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,25)-(1,26))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,25)-(1,26))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :g
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,24)-(1,25) = "|"
                │   └── closing_loc: (1,26)-(1,27) = "|"
                ├── body:
                │   @ StatementsNode (location: (1,28)-(1,29))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ CallNode (location: (1,28)-(1,29))
                │           ├── flags: newline, variable_call, ignore_visibility
                │           ├── receiver: ∅
                │           ├── call_operator_loc: ∅
                │           ├── name: :h
                │           ├── message_loc: (1,28)-(1,29) = "h"
                │           ├── opening_loc: ∅
                │           ├── arguments: ∅
                │           ├── closing_loc: ∅
                │           └── block: ∅
                ├── opening_loc: (1,21)-(1,23) = "do"
                └── closing_loc: (1,30)-(1,33) = "end"
prism-1.5.1/snapshots/seattlerb/block_call_operation_colon.txt000066400000000000000000000053361506127434000247700ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,15))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,15))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,12))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ CallNode (location: (1,0)-(1,1))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :a
            │   │   ├── message_loc: (1,0)-(1,1) = "a"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── call_operator_loc: (1,1)-(1,2) = "."
            │   ├── name: :b
            │   ├── message_loc: (1,2)-(1,3) = "b"
            │   ├── opening_loc: ∅
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (1,4)-(1,5))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 1)
            │   │       └── @ CallNode (location: (1,4)-(1,5))
            │   │           ├── flags: variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :c
            │   │           ├── message_loc: (1,4)-(1,5) = "c"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   ├── closing_loc: ∅
            │   └── block:
            │       @ BlockNode (location: (1,6)-(1,12))
            │       ├── flags: ∅
            │       ├── locals: []
            │       ├── parameters: ∅
            │       ├── body: ∅
            │       ├── opening_loc: (1,6)-(1,8) = "do"
            │       └── closing_loc: (1,9)-(1,12) = "end"
            ├── call_operator_loc: (1,12)-(1,14) = "::"
            ├── name: :d
            ├── message_loc: (1,14)-(1,15) = "d"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/block_call_operation_dot.txt000066400000000000000000000053351506127434000244430ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,14))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,12))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ CallNode (location: (1,0)-(1,1))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :a
            │   │   ├── message_loc: (1,0)-(1,1) = "a"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── call_operator_loc: (1,1)-(1,2) = "."
            │   ├── name: :b
            │   ├── message_loc: (1,2)-(1,3) = "b"
            │   ├── opening_loc: ∅
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (1,4)-(1,5))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 1)
            │   │       └── @ CallNode (location: (1,4)-(1,5))
            │   │           ├── flags: variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :c
            │   │           ├── message_loc: (1,4)-(1,5) = "c"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   ├── closing_loc: ∅
            │   └── block:
            │       @ BlockNode (location: (1,6)-(1,12))
            │       ├── flags: ∅
            │       ├── locals: []
            │       ├── parameters: ∅
            │       ├── body: ∅
            │       ├── opening_loc: (1,6)-(1,8) = "do"
            │       └── closing_loc: (1,9)-(1,12) = "end"
            ├── call_operator_loc: (1,12)-(1,13) = "."
            ├── name: :d
            ├── message_loc: (1,13)-(1,14) = "d"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/block_call_paren_call_block_call.txt000066400000000000000000000062571506127434000260460ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,10))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(1,5))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (1,0)-(1,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(1,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ParenthesesNode (location: (1,2)-(1,5))
        │   │           ├── flags: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (1,3)-(1,4))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (1,3)-(1,4))
        │   │           │           ├── flags: newline, variable_call, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :b
        │   │           │           ├── message_loc: (1,3)-(1,4) = "b"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── opening_loc: (1,2)-(1,3) = "("
        │   │           └── closing_loc: (1,4)-(1,5) = ")"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (2,0)-(2,10))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (2,0)-(2,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :c
            │   ├── message_loc: (2,0)-(2,1) = "c"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (2,1)-(2,2) = "."
            ├── name: :d
            ├── message_loc: (2,2)-(2,3) = "d"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (2,4)-(2,10))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (2,4)-(2,6) = "do"
                └── closing_loc: (2,7)-(2,10) = "end"
prism-1.5.1/snapshots/seattlerb/block_command_operation_colon.txt000066400000000000000000000050261506127434000254670ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,17))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,11))
            │   ├── flags: ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (1,2)-(1,4))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 1)
            │   │       └── @ SymbolNode (location: (1,2)-(1,4))
            │   │           ├── flags: static_literal, forced_us_ascii_encoding
            │   │           ├── opening_loc: (1,2)-(1,3) = ":"
            │   │           ├── value_loc: (1,3)-(1,4) = "b"
            │   │           ├── closing_loc: ∅
            │   │           └── unescaped: "b"
            │   ├── closing_loc: ∅
            │   └── block:
            │       @ BlockNode (location: (1,5)-(1,11))
            │       ├── flags: ∅
            │       ├── locals: []
            │       ├── parameters: ∅
            │       ├── body: ∅
            │       ├── opening_loc: (1,5)-(1,7) = "do"
            │       └── closing_loc: (1,8)-(1,11) = "end"
            ├── call_operator_loc: (1,11)-(1,13) = "::"
            ├── name: :c
            ├── message_loc: (1,13)-(1,14) = "c"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,15)-(1,17))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ SymbolNode (location: (1,15)-(1,17))
            │           ├── flags: static_literal, forced_us_ascii_encoding
            │           ├── opening_loc: (1,15)-(1,16) = ":"
            │           ├── value_loc: (1,16)-(1,17) = "d"
            │           ├── closing_loc: ∅
            │           └── unescaped: "d"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/block_command_operation_dot.txt000066400000000000000000000050251506127434000251420ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,16))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,16))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,16))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,11))
            │   ├── flags: ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (1,2)-(1,4))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 1)
            │   │       └── @ SymbolNode (location: (1,2)-(1,4))
            │   │           ├── flags: static_literal, forced_us_ascii_encoding
            │   │           ├── opening_loc: (1,2)-(1,3) = ":"
            │   │           ├── value_loc: (1,3)-(1,4) = "b"
            │   │           ├── closing_loc: ∅
            │   │           └── unescaped: "b"
            │   ├── closing_loc: ∅
            │   └── block:
            │       @ BlockNode (location: (1,5)-(1,11))
            │       ├── flags: ∅
            │       ├── locals: []
            │       ├── parameters: ∅
            │       ├── body: ∅
            │       ├── opening_loc: (1,5)-(1,7) = "do"
            │       └── closing_loc: (1,8)-(1,11) = "end"
            ├── call_operator_loc: (1,11)-(1,12) = "."
            ├── name: :c
            ├── message_loc: (1,12)-(1,13) = "c"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,14)-(1,16))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ SymbolNode (location: (1,14)-(1,16))
            │           ├── flags: static_literal, forced_us_ascii_encoding
            │           ├── opening_loc: (1,14)-(1,15) = ":"
            │           ├── value_loc: (1,15)-(1,16) = "d"
            │           ├── closing_loc: ∅
            │           └── unescaped: "d"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/block_decomp_anon_splat_arg.txt000066400000000000000000000054101506127434000251120ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,14))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,14))
                ├── flags: ∅
                ├── locals: [:a]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,12))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,11))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ MultiTargetNode (location: (1,5)-(1,11))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 0)
                │   │   │       ├── rest:
                │   │   │       │   @ SplatNode (location: (1,6)-(1,7))
                │   │   │       │   ├── flags: ∅
                │   │   │       │   ├── operator_loc: (1,6)-(1,7) = "*"
                │   │   │       │   └── expression: ∅
                │   │   │       ├── rights: (length: 1)
                │   │   │       │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :a
                │   │   │       ├── lparen_loc: (1,5)-(1,6) = "("
                │   │   │       └── rparen_loc: (1,10)-(1,11) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,11)-(1,12) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,13)-(1,14) = "}"
prism-1.5.1/snapshots/seattlerb/block_decomp_arg_splat.txt000066400000000000000000000054111506127434000241000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,14))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,14))
                ├── flags: ∅
                ├── locals: [:b]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,12))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,11))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ MultiTargetNode (location: (1,5)-(1,11))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 1)
                │   │   │       │   └── @ RequiredParameterNode (location: (1,6)-(1,7))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :b
                │   │   │       ├── rest:
                │   │   │       │   @ SplatNode (location: (1,9)-(1,10))
                │   │   │       │   ├── flags: ∅
                │   │   │       │   ├── operator_loc: (1,9)-(1,10) = "*"
                │   │   │       │   └── expression: ∅
                │   │   │       ├── rights: (length: 0)
                │   │   │       ├── lparen_loc: (1,5)-(1,6) = "("
                │   │   │       └── rparen_loc: (1,10)-(1,11) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,11)-(1,12) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,13)-(1,14) = "}"
prism-1.5.1/snapshots/seattlerb/block_decomp_arg_splat_arg.txt000066400000000000000000000063471506127434000247420ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,18))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,18))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,18))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,18))
                ├── flags: ∅
                ├── locals: [:a, :b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,16))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,15))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ MultiTargetNode (location: (1,5)-(1,15))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 1)
                │   │   │       │   └── @ RequiredParameterNode (location: (1,6)-(1,7))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :a
                │   │   │       ├── rest:
                │   │   │       │   @ SplatNode (location: (1,9)-(1,11))
                │   │   │       │   ├── flags: ∅
                │   │   │       │   ├── operator_loc: (1,9)-(1,10) = "*"
                │   │   │       │   └── expression:
                │   │   │       │       @ RequiredParameterNode (location: (1,10)-(1,11))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :b
                │   │   │       ├── rights: (length: 1)
                │   │   │       │   └── @ RequiredParameterNode (location: (1,13)-(1,14))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :c
                │   │   │       ├── lparen_loc: (1,5)-(1,6) = "("
                │   │   │       └── rparen_loc: (1,14)-(1,15) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,15)-(1,16) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,17)-(1,18) = "}"
prism-1.5.1/snapshots/seattlerb/block_decomp_splat.txt000066400000000000000000000053701506127434000232530ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,12))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,12))
                ├── flags: ∅
                ├── locals: [:a]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,10))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,9))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ MultiTargetNode (location: (1,5)-(1,9))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 0)
                │   │   │       ├── rest:
                │   │   │       │   @ SplatNode (location: (1,6)-(1,8))
                │   │   │       │   ├── flags: ∅
                │   │   │       │   ├── operator_loc: (1,6)-(1,7) = "*"
                │   │   │       │   └── expression:
                │   │   │       │       @ RequiredParameterNode (location: (1,7)-(1,8))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :a
                │   │   │       ├── rights: (length: 0)
                │   │   │       ├── lparen_loc: (1,5)-(1,6) = "("
                │   │   │       └── rparen_loc: (1,8)-(1,9) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,9)-(1,10) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,11)-(1,12) = "}"
prism-1.5.1/snapshots/seattlerb/block_kw.txt000066400000000000000000000045051506127434000212210ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,15))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,15))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :blah
            ├── message_loc: (1,0)-(1,4) = "blah"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,5)-(1,15))
                ├── flags: ∅
                ├── locals: [:k]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,7)-(1,13))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,8)-(1,12))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 1)
                │   │   │   └── @ OptionalKeywordParameterNode (location: (1,8)-(1,12))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :k
                │   │   │       ├── name_loc: (1,8)-(1,10) = "k:"
                │   │   │       └── value:
                │   │   │           @ IntegerNode (location: (1,10)-(1,12))
                │   │   │           ├── flags: static_literal, decimal
                │   │   │           └── value: 42
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,7)-(1,8) = "|"
                │   └── closing_loc: (1,12)-(1,13) = "|"
                ├── body: ∅
                ├── opening_loc: (1,5)-(1,6) = "{"
                └── closing_loc: (1,14)-(1,15) = "}"
prism-1.5.1/snapshots/seattlerb/block_kw__required.txt000066400000000000000000000040561506127434000232610ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,16))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,16))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,16))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :blah
            ├── message_loc: (1,0)-(1,4) = "blah"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,5)-(1,16))
                ├── flags: ∅
                ├── locals: [:k]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,8)-(1,12))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,9)-(1,11))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 1)
                │   │   │   └── @ RequiredKeywordParameterNode (location: (1,9)-(1,11))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :k
                │   │   │       └── name_loc: (1,9)-(1,11) = "k:"
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,8)-(1,9) = "|"
                │   └── closing_loc: (1,11)-(1,12) = "|"
                ├── body: ∅
                ├── opening_loc: (1,5)-(1,7) = "do"
                └── closing_loc: (1,13)-(1,16) = "end"
prism-1.5.1/snapshots/seattlerb/block_kwarg_lvar.txt000066400000000000000000000057231506127434000227420ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,20))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,20))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,20))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :bl
            ├── message_loc: (1,0)-(1,2) = "bl"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,3)-(1,20))
                ├── flags: ∅
                ├── locals: [:kw]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,5)-(1,15))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,6)-(1,14))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 1)
                │   │   │   └── @ OptionalKeywordParameterNode (location: (1,6)-(1,14))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :kw
                │   │   │       ├── name_loc: (1,6)-(1,9) = "kw:"
                │   │   │       └── value:
                │   │   │           @ SymbolNode (location: (1,10)-(1,14))
                │   │   │           ├── flags: static_literal, forced_us_ascii_encoding
                │   │   │           ├── opening_loc: (1,10)-(1,11) = ":"
                │   │   │           ├── value_loc: (1,11)-(1,14) = "val"
                │   │   │           ├── closing_loc: ∅
                │   │   │           └── unescaped: "val"
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,5)-(1,6) = "|"
                │   └── closing_loc: (1,14)-(1,15) = "|"
                ├── body:
                │   @ StatementsNode (location: (1,16)-(1,18))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ LocalVariableReadNode (location: (1,16)-(1,18))
                │           ├── flags: newline
                │           ├── name: :kw
                │           └── depth: 0
                ├── opening_loc: (1,3)-(1,4) = "{"
                └── closing_loc: (1,19)-(1,20) = "}"
prism-1.5.1/snapshots/seattlerb/block_kwarg_lvar_multiple.txt000066400000000000000000000074731506127434000246610ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,33))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,33))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,33))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :bl
            ├── message_loc: (1,0)-(1,2) = "bl"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,3)-(1,33))
                ├── flags: ∅
                ├── locals: [:kw, :kw2]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,5)-(1,28))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,6)-(1,26))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 2)
                │   │   │   ├── @ OptionalKeywordParameterNode (location: (1,6)-(1,14))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   ├── name: :kw
                │   │   │   │   ├── name_loc: (1,6)-(1,9) = "kw:"
                │   │   │   │   └── value:
                │   │   │   │       @ SymbolNode (location: (1,10)-(1,14))
                │   │   │   │       ├── flags: static_literal, forced_us_ascii_encoding
                │   │   │   │       ├── opening_loc: (1,10)-(1,11) = ":"
                │   │   │   │       ├── value_loc: (1,11)-(1,14) = "val"
                │   │   │   │       ├── closing_loc: ∅
                │   │   │   │       └── unescaped: "val"
                │   │   │   └── @ OptionalKeywordParameterNode (location: (1,16)-(1,26))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :kw2
                │   │   │       ├── name_loc: (1,16)-(1,20) = "kw2:"
                │   │   │       └── value:
                │   │   │           @ SymbolNode (location: (1,21)-(1,26))
                │   │   │           ├── flags: static_literal, forced_us_ascii_encoding
                │   │   │           ├── opening_loc: (1,21)-(1,22) = ":"
                │   │   │           ├── value_loc: (1,22)-(1,26) = "val2"
                │   │   │           ├── closing_loc: ∅
                │   │   │           └── unescaped: "val2"
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,5)-(1,6) = "|"
                │   └── closing_loc: (1,27)-(1,28) = "|"
                ├── body:
                │   @ StatementsNode (location: (1,29)-(1,31))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ LocalVariableReadNode (location: (1,29)-(1,31))
                │           ├── flags: newline
                │           ├── name: :kw
                │           └── depth: 0
                ├── opening_loc: (1,3)-(1,4) = "{"
                └── closing_loc: (1,32)-(1,33) = "}"
prism-1.5.1/snapshots/seattlerb/block_opt_arg.txt000066400000000000000000000051301506127434000222260ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,14))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,14))
                ├── flags: ∅
                ├── locals: [:b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,12))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,11))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 1)
                │   │   │   └── @ OptionalParameterNode (location: (1,5)-(1,8))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :b
                │   │   │       ├── name_loc: (1,5)-(1,6) = "b"
                │   │   │       ├── operator_loc: (1,6)-(1,7) = "="
                │   │   │       └── value:
                │   │   │           @ IntegerNode (location: (1,7)-(1,8))
                │   │   │           ├── flags: static_literal, decimal
                │   │   │           └── value: 1
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,10)-(1,11))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :c
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,11)-(1,12) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,13)-(1,14) = "}"
prism-1.5.1/snapshots/seattlerb/block_opt_splat.txt000066400000000000000000000053301506127434000226020ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,17))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,17))
                ├── flags: ∅
                ├── locals: [:b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,15))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,14))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 1)
                │   │   │   └── @ OptionalParameterNode (location: (1,5)-(1,10))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :b
                │   │   │       ├── name_loc: (1,5)-(1,6) = "b"
                │   │   │       ├── operator_loc: (1,7)-(1,8) = "="
                │   │   │       └── value:
                │   │   │           @ IntegerNode (location: (1,9)-(1,10))
                │   │   │           ├── flags: static_literal, decimal
                │   │   │           └── value: 1
                │   │   ├── rest:
                │   │   │   @ RestParameterNode (location: (1,12)-(1,14))
                │   │   │   ├── flags: ∅
                │   │   │   ├── name: :c
                │   │   │   ├── name_loc: (1,13)-(1,14) = "c"
                │   │   │   └── operator_loc: (1,12)-(1,13) = "*"
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,14)-(1,15) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,16)-(1,17) = "}"
prism-1.5.1/snapshots/seattlerb/block_opt_splat_arg_block_omfg.txt000066400000000000000000000063671506127434000256300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,22))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,22))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,22))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,22))
                ├── flags: ∅
                ├── locals: [:b, :c, :d, :e]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,20))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,19))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 1)
                │   │   │   └── @ OptionalParameterNode (location: (1,5)-(1,8))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :b
                │   │   │       ├── name_loc: (1,5)-(1,6) = "b"
                │   │   │       ├── operator_loc: (1,6)-(1,7) = "="
                │   │   │       └── value:
                │   │   │           @ IntegerNode (location: (1,7)-(1,8))
                │   │   │           ├── flags: static_literal, decimal
                │   │   │           └── value: 1
                │   │   ├── rest:
                │   │   │   @ RestParameterNode (location: (1,10)-(1,12))
                │   │   │   ├── flags: ∅
                │   │   │   ├── name: :c
                │   │   │   ├── name_loc: (1,11)-(1,12) = "c"
                │   │   │   └── operator_loc: (1,10)-(1,11) = "*"
                │   │   ├── posts: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,14)-(1,15))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :d
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block:
                │   │       @ BlockParameterNode (location: (1,17)-(1,19))
                │   │       ├── flags: ∅
                │   │       ├── name: :e
                │   │       ├── name_loc: (1,18)-(1,19) = "e"
                │   │       └── operator_loc: (1,17)-(1,18) = "&"
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,19)-(1,20) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,21)-(1,22) = "}"
prism-1.5.1/snapshots/seattlerb/block_optarg.txt000066400000000000000000000052061506127434000220730ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,14))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,14))
                ├── flags: ∅
                ├── locals: [:b]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,12))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,11))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 1)
                │   │   │   └── @ OptionalParameterNode (location: (1,5)-(1,11))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :b
                │   │   │       ├── name_loc: (1,5)-(1,6) = "b"
                │   │   │       ├── operator_loc: (1,7)-(1,8) = "="
                │   │   │       └── value:
                │   │   │           @ SymbolNode (location: (1,9)-(1,11))
                │   │   │           ├── flags: static_literal, forced_us_ascii_encoding
                │   │   │           ├── opening_loc: (1,9)-(1,10) = ":"
                │   │   │           ├── value_loc: (1,10)-(1,11) = "c"
                │   │   │           ├── closing_loc: ∅
                │   │   │           └── unescaped: "c"
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,11)-(1,12) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,13)-(1,14) = "}"
prism-1.5.1/snapshots/seattlerb/block_paren_splat.txt000066400000000000000000000057631506127434000231170ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,15))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,15))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,15))
                ├── flags: ∅
                ├── locals: [:b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,13))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,12))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ MultiTargetNode (location: (1,5)-(1,12))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 1)
                │   │   │       │   └── @ RequiredParameterNode (location: (1,6)-(1,7))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :b
                │   │   │       ├── rest:
                │   │   │       │   @ SplatNode (location: (1,9)-(1,11))
                │   │   │       │   ├── flags: ∅
                │   │   │       │   ├── operator_loc: (1,9)-(1,10) = "*"
                │   │   │       │   └── expression:
                │   │   │       │       @ RequiredParameterNode (location: (1,10)-(1,11))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :c
                │   │   │       ├── rights: (length: 0)
                │   │   │       ├── lparen_loc: (1,5)-(1,6) = "("
                │   │   │       └── rparen_loc: (1,11)-(1,12) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,12)-(1,13) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,14)-(1,15) = "}"
prism-1.5.1/snapshots/seattlerb/block_reg_optarg.txt000066400000000000000000000055361506127434000227360ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,17))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,17))
                ├── flags: ∅
                ├── locals: [:b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,15))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,14))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :b
                │   │   ├── optionals: (length: 1)
                │   │   │   └── @ OptionalParameterNode (location: (1,8)-(1,14))
                │   │   │       ├── flags: ∅
                │   │   │       ├── name: :c
                │   │   │       ├── name_loc: (1,8)-(1,9) = "c"
                │   │   │       ├── operator_loc: (1,10)-(1,11) = "="
                │   │   │       └── value:
                │   │   │           @ SymbolNode (location: (1,12)-(1,14))
                │   │   │           ├── flags: static_literal, forced_us_ascii_encoding
                │   │   │           ├── opening_loc: (1,12)-(1,13) = ":"
                │   │   │           ├── value_loc: (1,13)-(1,14) = "d"
                │   │   │           ├── closing_loc: ∅
                │   │   │           └── unescaped: "d"
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,14)-(1,15) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,16)-(1,17) = "}"
prism-1.5.1/snapshots/seattlerb/block_return.txt000066400000000000000000000070641506127434000221220ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,27))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,27))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ReturnNode (location: (1,0)-(1,27))
            ├── flags: newline
            ├── keyword_loc: (1,0)-(1,6) = "return"
            └── arguments:
                @ ArgumentsNode (location: (1,7)-(1,27))
                ├── flags: ∅
                └── arguments: (length: 1)
                    └── @ CallNode (location: (1,7)-(1,27))
                        ├── flags: ignore_visibility
                        ├── receiver: ∅
                        ├── call_operator_loc: ∅
                        ├── name: :foo
                        ├── message_loc: (1,7)-(1,10) = "foo"
                        ├── opening_loc: ∅
                        ├── arguments:
                        │   @ ArgumentsNode (location: (1,11)-(1,14))
                        │   ├── flags: ∅
                        │   └── arguments: (length: 1)
                        │       └── @ CallNode (location: (1,11)-(1,14))
                        │           ├── flags: variable_call, ignore_visibility
                        │           ├── receiver: ∅
                        │           ├── call_operator_loc: ∅
                        │           ├── name: :arg
                        │           ├── message_loc: (1,11)-(1,14) = "arg"
                        │           ├── opening_loc: ∅
                        │           ├── arguments: ∅
                        │           ├── closing_loc: ∅
                        │           └── block: ∅
                        ├── closing_loc: ∅
                        └── block:
                            @ BlockNode (location: (1,15)-(1,27))
                            ├── flags: ∅
                            ├── locals: [:bar]
                            ├── parameters:
                            │   @ BlockParametersNode (location: (1,18)-(1,23))
                            │   ├── flags: ∅
                            │   ├── parameters:
                            │   │   @ ParametersNode (location: (1,19)-(1,22))
                            │   │   ├── flags: ∅
                            │   │   ├── requireds: (length: 1)
                            │   │   │   └── @ RequiredParameterNode (location: (1,19)-(1,22))
                            │   │   │       ├── flags: ∅
                            │   │   │       └── name: :bar
                            │   │   ├── optionals: (length: 0)
                            │   │   ├── rest: ∅
                            │   │   ├── posts: (length: 0)
                            │   │   ├── keywords: (length: 0)
                            │   │   ├── keyword_rest: ∅
                            │   │   └── block: ∅
                            │   ├── locals: (length: 0)
                            │   ├── opening_loc: (1,18)-(1,19) = "|"
                            │   └── closing_loc: (1,22)-(1,23) = "|"
                            ├── body: ∅
                            ├── opening_loc: (1,15)-(1,17) = "do"
                            └── closing_loc: (1,24)-(1,27) = "end"
prism-1.5.1/snapshots/seattlerb/block_scope.txt000066400000000000000000000026771506127434000217210ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,10))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,10))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,10))
                ├── flags: ∅
                ├── locals: [:b]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,8))
                │   ├── flags: ∅
                │   ├── parameters: ∅
                │   ├── locals: (length: 1)
                │   │   └── @ BlockLocalVariableNode (location: (1,6)-(1,7))
                │   │       ├── flags: ∅
                │   │       └── name: :b
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,7)-(1,8) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,9)-(1,10) = "}"
prism-1.5.1/snapshots/seattlerb/block_splat_reg.txt000066400000000000000000000044361506127434000225630ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,13))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,13))
                ├── flags: ∅
                ├── locals: [:b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,11))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,10))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest:
                │   │   │   @ RestParameterNode (location: (1,5)-(1,7))
                │   │   │   ├── flags: ∅
                │   │   │   ├── name: :b
                │   │   │   ├── name_loc: (1,6)-(1,7) = "b"
                │   │   │   └── operator_loc: (1,5)-(1,6) = "*"
                │   │   ├── posts: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :c
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,10)-(1,11) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,12)-(1,13) = "}"
prism-1.5.1/snapshots/seattlerb/bug169.txt000066400000000000000000000025511506127434000204420ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,7))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,7))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :m
            ├── message_loc: (1,0)-(1,1) = "m"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,4))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ ParenthesesNode (location: (1,2)-(1,4))
            │           ├── flags: ∅
            │           ├── body: ∅
            │           ├── opening_loc: (1,2)-(1,3) = "("
            │           └── closing_loc: (1,3)-(1,4) = ")"
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,5)-(1,7))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (1,5)-(1,6) = "{"
                └── closing_loc: (1,6)-(1,7) = "}"
prism-1.5.1/snapshots/seattlerb/bug179.txt000066400000000000000000000027261506127434000204470ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,9))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :p
            ├── message_loc: (1,0)-(1,1) = "p"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,9))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ RangeNode (location: (1,2)-(1,9))
            │           ├── flags: ∅
            │           ├── left:
            │           │   @ ParenthesesNode (location: (1,2)-(1,4))
            │           │   ├── flags: ∅
            │           │   ├── body: ∅
            │           │   ├── opening_loc: (1,2)-(1,3) = "("
            │           │   └── closing_loc: (1,3)-(1,4) = ")"
            │           ├── right:
            │           │   @ NilNode (location: (1,6)-(1,9))
            │           │   └── flags: static_literal
            │           └── operator_loc: (1,4)-(1,6) = ".."
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/bug190.txt000066400000000000000000000010451506127434000204310ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ RegularExpressionNode (location: (1,0)-(1,6))
            ├── flags: newline, static_literal, forced_us_ascii_encoding
            ├── opening_loc: (1,0)-(1,3) = "%r'"
            ├── content_loc: (1,3)-(1,5) = "\\'"
            ├── closing_loc: (1,5)-(1,6) = "'"
            └── unescaped: "'"
prism-1.5.1/snapshots/seattlerb/bug191.txt000066400000000000000000000116561506127434000204430ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,9))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ IfNode (location: (1,0)-(1,9))
        │   ├── flags: newline
        │   ├── if_keyword_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (1,0)-(1,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (1,0)-(1,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: (1,2)-(1,3) = "?"
        │   ├── statements:
        │   │   @ StatementsNode (location: (1,4)-(1,6))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ StringNode (location: (1,4)-(1,6))
        │   │           ├── flags: newline
        │   │           ├── opening_loc: (1,4)-(1,5) = "\""
        │   │           ├── content_loc: (1,5)-(1,5) = ""
        │   │           ├── closing_loc: (1,5)-(1,6) = "\""
        │   │           └── unescaped: ""
        │   ├── subsequent:
        │   │   @ ElseNode (location: (1,6)-(1,9))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (1,6)-(1,7) = ":"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (1,8)-(1,9))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (1,8)-(1,9))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (1,8)-(1,9) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── end_keyword_loc: ∅
        │   └── end_keyword_loc: ∅
        └── @ IfNode (location: (3,0)-(3,9))
            ├── flags: newline
            ├── if_keyword_loc: ∅
            ├── predicate:
            │   @ CallNode (location: (3,0)-(3,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (3,0)-(3,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── then_keyword_loc: (3,2)-(3,3) = "?"
            ├── statements:
            │   @ StatementsNode (location: (3,4)-(3,6))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ StringNode (location: (3,4)-(3,6))
            │           ├── flags: newline
            │           ├── opening_loc: (3,4)-(3,5) = "'"
            │           ├── content_loc: (3,5)-(3,5) = ""
            │           ├── closing_loc: (3,5)-(3,6) = "'"
            │           └── unescaped: ""
            ├── subsequent:
            │   @ ElseNode (location: (3,6)-(3,9))
            │   ├── flags: ∅
            │   ├── else_keyword_loc: (3,6)-(3,7) = ":"
            │   ├── statements:
            │   │   @ StatementsNode (location: (3,8)-(3,9))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (3,8)-(3,9))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :b
            │   │           ├── message_loc: (3,8)-(3,9) = "b"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── end_keyword_loc: ∅
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/seattlerb/bug202.txt000066400000000000000000000021501506127434000204210ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,10))
├── flags: ∅
├── locals: [:测试]
└── statements:
    @ StatementsNode (location: (1,0)-(2,10))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ GlobalVariableWriteNode (location: (1,0)-(1,11))
        │   ├── flags: newline
        │   ├── name: :$测试
        │   ├── name_loc: (1,0)-(1,7) = "$测试"
        │   ├── value:
        │   │   @ IntegerNode (location: (1,10)-(1,11))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (1,8)-(1,9) = "="
        └── @ LocalVariableWriteNode (location: (2,0)-(2,10))
            ├── flags: newline
            ├── name: :测试
            ├── depth: 0
            ├── name_loc: (2,0)-(2,6) = "测试"
            ├── value:
            │   @ IntegerNode (location: (2,9)-(2,10))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            └── operator_loc: (2,7)-(2,8) = "="
prism-1.5.1/snapshots/seattlerb/bug236.txt000066400000000000000000000076061506127434000204430ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,6))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(1,7))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :x
        │   ├── message_loc: (1,0)-(1,1) = "x"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,1)-(1,7))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (1,2)-(1,6))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (1,3)-(1,5))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (1,3)-(1,4))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ ImplicitRestNode (location: (1,4)-(1,5))
        │       │   │   │   └── flags: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (1,2)-(1,3) = "|"
        │       │   └── closing_loc: (1,5)-(1,6) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (1,1)-(1,2) = "{"
        │       └── closing_loc: (1,6)-(1,7) = "}"
        └── @ CallNode (location: (3,0)-(3,6))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :x
            ├── message_loc: (3,0)-(3,1) = "x"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (3,1)-(3,6))
                ├── flags: ∅
                ├── locals: [:a]
                ├── parameters:
                │   @ BlockParametersNode (location: (3,2)-(3,5))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (3,3)-(3,4))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (3,3)-(3,4))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :a
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (3,2)-(3,3) = "|"
                │   └── closing_loc: (3,4)-(3,5) = "|"
                ├── body: ∅
                ├── opening_loc: (3,1)-(3,2) = "{"
                └── closing_loc: (3,5)-(3,6) = "}"
prism-1.5.1/snapshots/seattlerb/bug290.txt000066400000000000000000000024211506127434000204310ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ BeginNode (location: (1,0)-(3,3))
            ├── flags: newline
            ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
            ├── statements:
            │   @ StatementsNode (location: (2,2)-(2,5))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (2,2)-(2,5))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :foo
            │           ├── message_loc: (2,2)-(2,5) = "foo"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── rescue_clause: ∅
            ├── else_clause: ∅
            ├── ensure_clause: ∅
            └── end_keyword_loc: (3,0)-(3,3) = "end"
prism-1.5.1/snapshots/seattlerb/bug_187.txt000066400000000000000000000071771506127434000206120ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(3,3))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :private
            ├── message_loc: (1,0)-(1,7) = "private"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,8)-(3,3))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ DefNode (location: (1,8)-(3,3))
            │           ├── flags: ∅
            │           ├── name: :f
            │           ├── name_loc: (1,12)-(1,13) = "f"
            │           ├── receiver: ∅
            │           ├── parameters: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (2,0)-(2,10))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ CallNode (location: (2,0)-(2,10))
            │           │           ├── flags: newline
            │           │           ├── receiver:
            │           │           │   @ CallNode (location: (2,0)-(2,1))
            │           │           │   ├── flags: variable_call, ignore_visibility
            │           │           │   ├── receiver: ∅
            │           │           │   ├── call_operator_loc: ∅
            │           │           │   ├── name: :a
            │           │           │   ├── message_loc: (2,0)-(2,1) = "a"
            │           │           │   ├── opening_loc: ∅
            │           │           │   ├── arguments: ∅
            │           │           │   ├── closing_loc: ∅
            │           │           │   └── block: ∅
            │           │           ├── call_operator_loc: (2,1)-(2,2) = "."
            │           │           ├── name: :b
            │           │           ├── message_loc: (2,2)-(2,3) = "b"
            │           │           ├── opening_loc: ∅
            │           │           ├── arguments: ∅
            │           │           ├── closing_loc: ∅
            │           │           └── block:
            │           │               @ BlockNode (location: (2,4)-(2,10))
            │           │               ├── flags: ∅
            │           │               ├── locals: []
            │           │               ├── parameters: ∅
            │           │               ├── body: ∅
            │           │               ├── opening_loc: (2,4)-(2,6) = "do"
            │           │               └── closing_loc: (2,7)-(2,10) = "end"
            │           ├── locals: []
            │           ├── def_keyword_loc: (1,8)-(1,11) = "def"
            │           ├── operator_loc: ∅
            │           ├── lparen_loc: ∅
            │           ├── rparen_loc: ∅
            │           ├── equal_loc: ∅
            │           └── end_keyword_loc: (3,0)-(3,3) = "end"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/bug_215.txt000066400000000000000000000014211506127434000205640ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ UndefNode (location: (1,0)-(1,13))
            ├── flags: newline
            ├── names: (length: 1)
            │   └── @ SymbolNode (location: (1,6)-(1,13))
            │       ├── flags: static_literal, forced_us_ascii_encoding
            │       ├── opening_loc: (1,6)-(1,9) = "%s("
            │       ├── value_loc: (1,9)-(1,12) = "foo"
            │       ├── closing_loc: (1,12)-(1,13) = ")"
            │       └── unescaped: "foo"
            └── keyword_loc: (1,0)-(1,5) = "undef"
prism-1.5.1/snapshots/seattlerb/bug_249.txt000066400000000000000000000146521506127434000206050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,28))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,28))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(4,28))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :mount
            ├── message_loc: (1,0)-(1,5) = "mount"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,6)-(4,28))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 2)
            │       ├── @ CallNode (location: (1,6)-(4,9))
            │       │   ├── flags: ∅
            │       │   ├── receiver:
            │       │   │   @ ParenthesesNode (location: (1,6)-(4,5))
            │       │   │   ├── flags: ∅
            │       │   │   ├── body:
            │       │   │   │   @ StatementsNode (location: (1,7)-(4,4))
            │       │   │   │   ├── flags: ∅
            │       │   │   │   └── body: (length: 1)
            │       │   │   │       └── @ CallNode (location: (1,7)-(4,4))
            │       │   │   │           ├── flags: newline
            │       │   │   │           ├── receiver:
            │       │   │   │           │   @ ConstantReadNode (location: (1,7)-(1,12))
            │       │   │   │           │   ├── flags: ∅
            │       │   │   │           │   └── name: :Class
            │       │   │   │           ├── call_operator_loc: (1,12)-(1,13) = "."
            │       │   │   │           ├── name: :new
            │       │   │   │           ├── message_loc: (1,13)-(1,16) = "new"
            │       │   │   │           ├── opening_loc: ∅
            │       │   │   │           ├── arguments: ∅
            │       │   │   │           ├── closing_loc: ∅
            │       │   │   │           └── block:
            │       │   │   │               @ BlockNode (location: (1,17)-(4,4))
            │       │   │   │               ├── flags: ∅
            │       │   │   │               ├── locals: []
            │       │   │   │               ├── parameters: ∅
            │       │   │   │               ├── body:
            │       │   │   │               │   @ StatementsNode (location: (2,0)-(3,3))
            │       │   │   │               │   ├── flags: ∅
            │       │   │   │               │   └── body: (length: 1)
            │       │   │   │               │       └── @ DefNode (location: (2,0)-(3,3))
            │       │   │   │               │           ├── flags: newline
            │       │   │   │               │           ├── name: :initialize
            │       │   │   │               │           ├── name_loc: (2,4)-(2,14) = "initialize"
            │       │   │   │               │           ├── receiver: ∅
            │       │   │   │               │           ├── parameters: ∅
            │       │   │   │               │           ├── body: ∅
            │       │   │   │               │           ├── locals: []
            │       │   │   │               │           ├── def_keyword_loc: (2,0)-(2,3) = "def"
            │       │   │   │               │           ├── operator_loc: ∅
            │       │   │   │               │           ├── lparen_loc: ∅
            │       │   │   │               │           ├── rparen_loc: ∅
            │       │   │   │               │           ├── equal_loc: ∅
            │       │   │   │               │           └── end_keyword_loc: (3,0)-(3,3) = "end"
            │       │   │   │               ├── opening_loc: (1,17)-(1,19) = "do"
            │       │   │   │               └── closing_loc: (4,1)-(4,4) = "end"
            │       │   │   ├── opening_loc: (1,6)-(1,7) = "("
            │       │   │   └── closing_loc: (4,4)-(4,5) = ")"
            │       │   ├── call_operator_loc: (4,5)-(4,6) = "."
            │       │   ├── name: :new
            │       │   ├── message_loc: (4,6)-(4,9) = "new"
            │       │   ├── opening_loc: ∅
            │       │   ├── arguments: ∅
            │       │   ├── closing_loc: ∅
            │       │   └── block: ∅
            │       └── @ KeywordHashNode (location: (4,11)-(4,28))
            │           ├── flags: symbol_keys
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (4,11)-(4,28))
            │                   ├── flags: ∅
            │                   ├── key:
            │                   │   @ SymbolNode (location: (4,11)-(4,14))
            │                   │   ├── flags: static_literal, forced_us_ascii_encoding
            │                   │   ├── opening_loc: (4,11)-(4,12) = ":"
            │                   │   ├── value_loc: (4,12)-(4,14) = "at"
            │                   │   ├── closing_loc: ∅
            │                   │   └── unescaped: "at"
            │                   ├── value:
            │                   │   @ StringNode (location: (4,18)-(4,28))
            │                   │   ├── flags: ∅
            │                   │   ├── opening_loc: (4,18)-(4,19) = "'"
            │                   │   ├── content_loc: (4,19)-(4,27) = "endpoint"
            │                   │   ├── closing_loc: (4,27)-(4,28) = "'"
            │                   │   └── unescaped: "endpoint"
            │                   └── operator_loc: (4,15)-(4,17) = "=>"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/bug_and.txt000066400000000000000000000022741506127434000210260ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,11))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ AndNode (location: (1,0)-(2,4))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ TrueNode (location: (1,0)-(1,4))
        │   │   └── flags: static_literal
        │   ├── right:
        │   │   @ TrueNode (location: (2,0)-(2,4))
        │   │   └── flags: static_literal
        │   └── operator_loc: (1,5)-(1,8) = "and"
        └── @ AndNode (location: (4,0)-(4,11))
            ├── flags: newline
            ├── left:
            │   @ TrueNode (location: (4,0)-(4,4))
            │   └── flags: static_literal
            ├── right:
            │   @ ArrayNode (location: (4,9)-(4,11))
            │   ├── flags: static_literal
            │   ├── elements: (length: 0)
            │   ├── opening_loc: (4,9)-(4,10) = "["
            │   └── closing_loc: (4,10)-(4,11) = "]"
            └── operator_loc: (4,5)-(4,8) = "and"
prism-1.5.1/snapshots/seattlerb/bug_args__19.txt000066400000000000000000000067341506127434000216750ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,16))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,16))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,16))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,16))
                ├── flags: ∅
                ├── locals: [:a, :b]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,12))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,11))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ MultiTargetNode (location: (1,5)-(1,11))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 2)
                │   │   │       │   ├── @ RequiredParameterNode (location: (1,6)-(1,7))
                │   │   │       │   │   ├── flags: ∅
                │   │   │       │   │   └── name: :a
                │   │   │       │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :b
                │   │   │       ├── rest: ∅
                │   │   │       ├── rights: (length: 0)
                │   │   │       ├── lparen_loc: (1,5)-(1,6) = "("
                │   │   │       └── rparen_loc: (1,10)-(1,11) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,11)-(1,12) = "|"
                ├── body:
                │   @ StatementsNode (location: (1,13)-(1,14))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ CallNode (location: (1,13)-(1,14))
                │           ├── flags: newline, variable_call, ignore_visibility
                │           ├── receiver: ∅
                │           ├── call_operator_loc: ∅
                │           ├── name: :d
                │           ├── message_loc: (1,13)-(1,14) = "d"
                │           ├── opening_loc: ∅
                │           ├── arguments: ∅
                │           ├── closing_loc: ∅
                │           └── block: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,15)-(1,16) = "}"
prism-1.5.1/snapshots/seattlerb/bug_args_masgn.txt000066400000000000000000000057031506127434000224050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,17))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,17))
                ├── flags: ∅
                ├── locals: [:a, :b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,15))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,14))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 2)
                │   │   │   ├── @ MultiTargetNode (location: (1,5)-(1,11))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   ├── lefts: (length: 2)
                │   │   │   │   │   ├── @ RequiredParameterNode (location: (1,6)-(1,7))
                │   │   │   │   │   │   ├── flags: ∅
                │   │   │   │   │   │   └── name: :a
                │   │   │   │   │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
                │   │   │   │   │       ├── flags: ∅
                │   │   │   │   │       └── name: :b
                │   │   │   │   ├── rest: ∅
                │   │   │   │   ├── rights: (length: 0)
                │   │   │   │   ├── lparen_loc: (1,5)-(1,6) = "("
                │   │   │   │   └── rparen_loc: (1,10)-(1,11) = ")"
                │   │   │   └── @ RequiredParameterNode (location: (1,13)-(1,14))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :c
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,14)-(1,15) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,16)-(1,17) = "}"
prism-1.5.1/snapshots/seattlerb/bug_args_masgn2.txt000066400000000000000000000075271506127434000224750ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,22))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,22))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,22))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,22))
                ├── flags: ∅
                ├── locals: [:a, :b, :c, :d]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,20))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,19))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 2)
                │   │   │   ├── @ MultiTargetNode (location: (1,5)-(1,16))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   ├── lefts: (length: 2)
                │   │   │   │   │   ├── @ MultiTargetNode (location: (1,6)-(1,12))
                │   │   │   │   │   │   ├── flags: ∅
                │   │   │   │   │   │   ├── lefts: (length: 2)
                │   │   │   │   │   │   │   ├── @ RequiredParameterNode (location: (1,7)-(1,8))
                │   │   │   │   │   │   │   │   ├── flags: ∅
                │   │   │   │   │   │   │   │   └── name: :a
                │   │   │   │   │   │   │   └── @ RequiredParameterNode (location: (1,10)-(1,11))
                │   │   │   │   │   │   │       ├── flags: ∅
                │   │   │   │   │   │   │       └── name: :b
                │   │   │   │   │   │   ├── rest: ∅
                │   │   │   │   │   │   ├── rights: (length: 0)
                │   │   │   │   │   │   ├── lparen_loc: (1,6)-(1,7) = "("
                │   │   │   │   │   │   └── rparen_loc: (1,11)-(1,12) = ")"
                │   │   │   │   │   └── @ RequiredParameterNode (location: (1,14)-(1,15))
                │   │   │   │   │       ├── flags: ∅
                │   │   │   │   │       └── name: :c
                │   │   │   │   ├── rest: ∅
                │   │   │   │   ├── rights: (length: 0)
                │   │   │   │   ├── lparen_loc: (1,5)-(1,6) = "("
                │   │   │   │   └── rparen_loc: (1,15)-(1,16) = ")"
                │   │   │   └── @ RequiredParameterNode (location: (1,18)-(1,19))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :d
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,19)-(1,20) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,21)-(1,22) = "}"
prism-1.5.1/snapshots/seattlerb/bug_args_masgn_outer_parens__19.txt000066400000000000000000000071251506127434000256430ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,19))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,19))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,19))
                ├── flags: ∅
                ├── locals: [:k, :v, :i]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,17))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,16))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ MultiTargetNode (location: (1,5)-(1,16))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 2)
                │   │   │       │   ├── @ MultiTargetNode (location: (1,6)-(1,12))
                │   │   │       │   │   ├── flags: ∅
                │   │   │       │   │   ├── lefts: (length: 2)
                │   │   │       │   │   │   ├── @ RequiredParameterNode (location: (1,7)-(1,8))
                │   │   │       │   │   │   │   ├── flags: ∅
                │   │   │       │   │   │   │   └── name: :k
                │   │   │       │   │   │   └── @ RequiredParameterNode (location: (1,10)-(1,11))
                │   │   │       │   │   │       ├── flags: ∅
                │   │   │       │   │   │       └── name: :v
                │   │   │       │   │   ├── rest: ∅
                │   │   │       │   │   ├── rights: (length: 0)
                │   │   │       │   │   ├── lparen_loc: (1,6)-(1,7) = "("
                │   │   │       │   │   └── rparen_loc: (1,11)-(1,12) = ")"
                │   │   │       │   └── @ RequiredParameterNode (location: (1,14)-(1,15))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :i
                │   │   │       ├── rest: ∅
                │   │   │       ├── rights: (length: 0)
                │   │   │       ├── lparen_loc: (1,5)-(1,6) = "("
                │   │   │       └── rparen_loc: (1,15)-(1,16) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,16)-(1,17) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,18)-(1,19) = "}"
prism-1.5.1/snapshots/seattlerb/bug_call_arglist_parens.txt000066400000000000000000000157101506127434000242730ustar00rootroot00000000000000@ ProgramNode (location: (1,6)-(11,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,6)-(11,9))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ DefNode (location: (1,6)-(3,9))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (1,10)-(1,11) = "f"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (2,8)-(2,17))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (2,8)-(2,17))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :g
        │   │           ├── message_loc: (2,8)-(2,9) = "g"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (2,10)-(2,17))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 2)
        │   │           │       ├── @ ParenthesesNode (location: (2,10)-(2,14))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── body:
        │   │           │       │   │   @ StatementsNode (location: (2,12)-(2,13))
        │   │           │       │   │   ├── flags: ∅
        │   │           │       │   │   └── body: (length: 1)
        │   │           │       │   │       └── @ IntegerNode (location: (2,12)-(2,13))
        │   │           │       │   │           ├── flags: newline, static_literal, decimal
        │   │           │       │   │           └── value: 1
        │   │           │       │   ├── opening_loc: (2,10)-(2,11) = "("
        │   │           │       │   └── closing_loc: (2,13)-(2,14) = ")"
        │   │           │       └── @ IntegerNode (location: (2,16)-(2,17))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 2
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,6)-(1,9) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (3,6)-(3,9) = "end"
        ├── @ DefNode (location: (6,6)-(8,9))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (6,10)-(6,11) = "f"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (7,8)-(7,16))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (7,8)-(7,16))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :g
        │   │           ├── message_loc: (7,8)-(7,9) = "g"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (7,10)-(7,16))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 2)
        │   │           │       ├── @ ParenthesesNode (location: (7,10)-(7,13))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── body:
        │   │           │       │   │   @ StatementsNode (location: (7,11)-(7,12))
        │   │           │       │   │   ├── flags: ∅
        │   │           │       │   │   └── body: (length: 1)
        │   │           │       │   │       └── @ IntegerNode (location: (7,11)-(7,12))
        │   │           │       │   │           ├── flags: newline, static_literal, decimal
        │   │           │       │   │           └── value: 1
        │   │           │       │   ├── opening_loc: (7,10)-(7,11) = "("
        │   │           │       │   └── closing_loc: (7,12)-(7,13) = ")"
        │   │           │       └── @ IntegerNode (location: (7,15)-(7,16))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 2
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (6,6)-(6,9) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (6,11)-(6,12) = "("
        │   ├── rparen_loc: (6,12)-(6,13) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (8,6)-(8,9) = "end"
        └── @ CallNode (location: (11,0)-(11,9))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :g
            ├── message_loc: (11,0)-(11,1) = "g"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (11,2)-(11,9))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ ParenthesesNode (location: (11,2)-(11,6))
            │       │   ├── flags: ∅
            │       │   ├── body:
            │       │   │   @ StatementsNode (location: (11,4)-(11,5))
            │       │   │   ├── flags: ∅
            │       │   │   └── body: (length: 1)
            │       │   │       └── @ IntegerNode (location: (11,4)-(11,5))
            │       │   │           ├── flags: newline, static_literal, decimal
            │       │   │           └── value: 1
            │       │   ├── opening_loc: (11,2)-(11,3) = "("
            │       │   └── closing_loc: (11,5)-(11,6) = ")"
            │       └── @ IntegerNode (location: (11,8)-(11,9))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/bug_case_when_regexp.txt000066400000000000000000000032231506127434000235650ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,26))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,26))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseNode (location: (1,0)-(1,26))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "x"
            │   ├── closing_loc: ∅
            │   └── unescaped: "x"
            ├── conditions: (length: 1)
            │   └── @ WhenNode (location: (1,9)-(1,22))
            │       ├── flags: ∅
            │       ├── keyword_loc: (1,9)-(1,13) = "when"
            │       ├── conditions: (length: 1)
            │       │   └── @ RegularExpressionNode (location: (1,14)-(1,17))
            │       │       ├── flags: static_literal, forced_us_ascii_encoding
            │       │       ├── opening_loc: (1,14)-(1,15) = "/"
            │       │       ├── content_loc: (1,15)-(1,16) = "x"
            │       │       ├── closing_loc: (1,16)-(1,17) = "/"
            │       │       └── unescaped: "x"
            │       ├── then_keyword_loc: (1,18)-(1,22) = "then"
            │       └── statements: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,23)-(1,26) = "end"
prism-1.5.1/snapshots/seattlerb/bug_comma.txt000066400000000000000000000043241506127434000213560ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,24))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,24))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ IfNode (location: (1,0)-(1,24))
            ├── flags: newline
            ├── if_keyword_loc: (1,0)-(1,2) = "if"
            ├── predicate:
            │   @ CallNode (location: (1,3)-(1,15))
            │   ├── flags: ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :test
            │   ├── message_loc: (1,3)-(1,7) = "test"
            │   ├── opening_loc: ∅
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (1,8)-(1,15))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 2)
            │   │       ├── @ StringNode (location: (1,8)-(1,10))
            │   │       │   ├── flags: ∅
            │   │       │   ├── opening_loc: (1,8)-(1,9) = "?"
            │   │       │   ├── content_loc: (1,9)-(1,10) = "d"
            │   │       │   ├── closing_loc: ∅
            │   │       │   └── unescaped: "d"
            │   │       └── @ CallNode (location: (1,12)-(1,15))
            │   │           ├── flags: variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :dir
            │   │           ├── message_loc: (1,12)-(1,15) = "dir"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── then_keyword_loc: (1,16)-(1,20) = "then"
            ├── statements: ∅
            ├── subsequent: ∅
            └── end_keyword_loc: (1,21)-(1,24) = "end"
prism-1.5.1/snapshots/seattlerb/bug_cond_pct.txt000066400000000000000000000025051506127434000220520ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,28))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,28))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseNode (location: (1,0)-(1,28))
            ├── flags: newline
            ├── predicate: ∅
            ├── conditions: (length: 1)
            │   └── @ WhenNode (location: (1,6)-(1,23))
            │       ├── flags: ∅
            │       ├── keyword_loc: (1,6)-(1,10) = "when"
            │       ├── conditions: (length: 1)
            │       │   └── @ RegularExpressionNode (location: (1,11)-(1,23))
            │       │       ├── flags: static_literal, forced_us_ascii_encoding
            │       │       ├── opening_loc: (1,11)-(1,14) = "%r%"
            │       │       ├── content_loc: (1,14)-(1,22) = "blahblah"
            │       │       ├── closing_loc: (1,22)-(1,23) = "%"
            │       │       └── unescaped: "blahblah"
            │       ├── then_keyword_loc: ∅
            │       └── statements: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,25)-(1,28) = "end"
prism-1.5.1/snapshots/seattlerb/bug_hash_args.txt000066400000000000000000000044511506127434000222220ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,19))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,19))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :foo
            ├── message_loc: (1,0)-(1,3) = "foo"
            ├── opening_loc: (1,3)-(1,4) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,18))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 2)
            │       ├── @ SymbolNode (location: (1,4)-(1,8))
            │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   ├── opening_loc: (1,4)-(1,5) = ":"
            │       │   ├── value_loc: (1,5)-(1,8) = "bar"
            │       │   ├── closing_loc: ∅
            │       │   └── unescaped: "bar"
            │       └── @ KeywordHashNode (location: (1,10)-(1,18))
            │           ├── flags: symbol_keys
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (1,10)-(1,18))
            │                   ├── flags: static_literal
            │                   ├── key:
            │                   │   @ SymbolNode (location: (1,10)-(1,14))
            │                   │   ├── flags: static_literal, forced_us_ascii_encoding
            │                   │   ├── opening_loc: ∅
            │                   │   ├── value_loc: (1,10)-(1,13) = "baz"
            │                   │   ├── closing_loc: (1,13)-(1,14) = ":"
            │                   │   └── unescaped: "baz"
            │                   ├── value:
            │                   │   @ NilNode (location: (1,15)-(1,18))
            │                   │   └── flags: static_literal
            │                   └── operator_loc: ∅
            ├── closing_loc: (1,18)-(1,19) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/bug_hash_args_trailing_comma.txt000066400000000000000000000044511506127434000252670ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,20))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,20))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,20))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :foo
            ├── message_loc: (1,0)-(1,3) = "foo"
            ├── opening_loc: (1,3)-(1,4) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,18))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 2)
            │       ├── @ SymbolNode (location: (1,4)-(1,8))
            │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   ├── opening_loc: (1,4)-(1,5) = ":"
            │       │   ├── value_loc: (1,5)-(1,8) = "bar"
            │       │   ├── closing_loc: ∅
            │       │   └── unescaped: "bar"
            │       └── @ KeywordHashNode (location: (1,10)-(1,18))
            │           ├── flags: symbol_keys
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (1,10)-(1,18))
            │                   ├── flags: static_literal
            │                   ├── key:
            │                   │   @ SymbolNode (location: (1,10)-(1,14))
            │                   │   ├── flags: static_literal, forced_us_ascii_encoding
            │                   │   ├── opening_loc: ∅
            │                   │   ├── value_loc: (1,10)-(1,13) = "baz"
            │                   │   ├── closing_loc: (1,13)-(1,14) = ":"
            │                   │   └── unescaped: "baz"
            │                   ├── value:
            │                   │   @ NilNode (location: (1,15)-(1,18))
            │                   │   └── flags: static_literal
            │                   └── operator_loc: ∅
            ├── closing_loc: (1,19)-(1,20) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/bug_hash_interp_array.txt000066400000000000000000000032551506127434000237660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ HashNode (location: (1,0)-(1,13))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "{"
            ├── elements: (length: 1)
            │   └── @ AssocNode (location: (1,2)-(1,11))
            │       ├── flags: ∅
            │       ├── key:
            │       │   @ InterpolatedSymbolNode (location: (1,2)-(1,8))
            │       │   ├── flags: ∅
            │       │   ├── opening_loc: (1,2)-(1,3) = "\""
            │       │   ├── parts: (length: 1)
            │       │   │   └── @ EmbeddedStatementsNode (location: (1,3)-(1,6))
            │       │   │       ├── flags: ∅
            │       │   │       ├── opening_loc: (1,3)-(1,5) = "\#{"
            │       │   │       ├── statements: ∅
            │       │   │       └── closing_loc: (1,5)-(1,6) = "}"
            │       │   └── closing_loc: (1,6)-(1,8) = "\":"
            │       ├── value:
            │       │   @ ArrayNode (location: (1,9)-(1,11))
            │       │   ├── flags: static_literal
            │       │   ├── elements: (length: 0)
            │       │   ├── opening_loc: (1,9)-(1,10) = "["
            │       │   └── closing_loc: (1,10)-(1,11) = "]"
            │       └── operator_loc: ∅
            └── closing_loc: (1,12)-(1,13) = "}"
prism-1.5.1/snapshots/seattlerb/bug_masgn_right.txt000066400000000000000000000056571506127434000225760ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,17))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,17))
                ├── flags: ∅
                ├── locals: [:a, :b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,15))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,14))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 2)
                │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   └── name: :a
                │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,14))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 2)
                │   │   │       │   ├── @ RequiredParameterNode (location: (1,9)-(1,10))
                │   │   │       │   │   ├── flags: ∅
                │   │   │       │   │   └── name: :b
                │   │   │       │   └── @ RequiredParameterNode (location: (1,12)-(1,13))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :c
                │   │   │       ├── rest: ∅
                │   │   │       ├── rights: (length: 0)
                │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
                │   │   │       └── rparen_loc: (1,13)-(1,14) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,14)-(1,15) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,16)-(1,17) = "}"
prism-1.5.1/snapshots/seattlerb/bug_not_parens.txt000066400000000000000000000021331506127434000224260ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,6))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,4)-(1,5))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,4)-(1,5) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :!
            ├── message_loc: (1,0)-(1,3) = "not"
            ├── opening_loc: (1,3)-(1,4) = "("
            ├── arguments: ∅
            ├── closing_loc: (1,5)-(1,6) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/bug_op_asgn_rescue.txt000066400000000000000000000026151506127434000232570ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,18))
├── flags: ∅
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (1,0)-(1,18))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LocalVariableOrWriteNode (location: (1,0)-(1,18))
            ├── flags: newline
            ├── name_loc: (1,0)-(1,1) = "a"
            ├── operator_loc: (1,2)-(1,5) = "||="
            ├── value:
            │   @ RescueModifierNode (location: (1,6)-(1,18))
            │   ├── flags: ∅
            │   ├── expression:
            │   │   @ CallNode (location: (1,6)-(1,7))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :b
            │   │   ├── message_loc: (1,6)-(1,7) = "b"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── keyword_loc: (1,8)-(1,14) = "rescue"
            │   └── rescue_expression:
            │       @ NilNode (location: (1,15)-(1,18))
            │       └── flags: static_literal
            ├── name: :a
            └── depth: 0
prism-1.5.1/snapshots/seattlerb/call_and.txt000066400000000000000000000020711506127434000211570ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,5))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :&
            ├── message_loc: (1,2)-(1,3) = "&"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,5))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,4)-(1,5))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_arg_assoc.txt000066400000000000000000000036201506127434000223570ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,10))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,10))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: (1,1)-(1,2) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,9))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 2)
            │       ├── @ IntegerNode (location: (1,2)-(1,3))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 1
            │       └── @ KeywordHashNode (location: (1,5)-(1,9))
            │           ├── flags: ∅
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (1,5)-(1,9))
            │                   ├── flags: static_literal
            │                   ├── key:
            │                   │   @ IntegerNode (location: (1,5)-(1,6))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 2
            │                   ├── value:
            │                   │   @ IntegerNode (location: (1,8)-(1,9))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 3
            │                   └── operator_loc: (1,6)-(1,8) = "=>"
            ├── closing_loc: (1,9)-(1,10) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_arg_assoc_kwsplat.txt000066400000000000000000000052331506127434000241260ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,16))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,16))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,16))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: (1,1)-(1,2) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,15))
            │   ├── flags: contains_keywords, contains_keyword_splat
            │   └── arguments: (length: 2)
            │       ├── @ IntegerNode (location: (1,2)-(1,3))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 1
            │       └── @ KeywordHashNode (location: (1,5)-(1,15))
            │           ├── flags: ∅
            │           └── elements: (length: 2)
            │               ├── @ AssocNode (location: (1,5)-(1,10))
            │               │   ├── flags: static_literal
            │               │   ├── key:
            │               │   │   @ SymbolNode (location: (1,5)-(1,8))
            │               │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │               │   │   ├── opening_loc: ∅
            │               │   │   ├── value_loc: (1,5)-(1,7) = "kw"
            │               │   │   ├── closing_loc: (1,7)-(1,8) = ":"
            │               │   │   └── unescaped: "kw"
            │               │   ├── value:
            │               │   │   @ IntegerNode (location: (1,9)-(1,10))
            │               │   │   ├── flags: static_literal, decimal
            │               │   │   └── value: 2
            │               │   └── operator_loc: ∅
            │               └── @ AssocSplatNode (location: (1,12)-(1,15))
            │                   ├── flags: ∅
            │                   ├── value:
            │                   │   @ IntegerNode (location: (1,14)-(1,15))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 3
            │                   └── operator_loc: (1,12)-(1,14) = "**"
            ├── closing_loc: (1,15)-(1,16) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_arg_kwsplat.txt000066400000000000000000000040431506127434000227340ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,9))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: (1,1)-(1,2) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,8))
            │   ├── flags: contains_keywords, contains_keyword_splat
            │   └── arguments: (length: 2)
            │       ├── @ CallNode (location: (1,2)-(1,3))
            │       │   ├── flags: variable_call, ignore_visibility
            │       │   ├── receiver: ∅
            │       │   ├── call_operator_loc: ∅
            │       │   ├── name: :b
            │       │   ├── message_loc: (1,2)-(1,3) = "b"
            │       │   ├── opening_loc: ∅
            │       │   ├── arguments: ∅
            │       │   ├── closing_loc: ∅
            │       │   └── block: ∅
            │       └── @ KeywordHashNode (location: (1,5)-(1,8))
            │           ├── flags: ∅
            │           └── elements: (length: 1)
            │               └── @ AssocSplatNode (location: (1,5)-(1,8))
            │                   ├── flags: ∅
            │                   ├── value:
            │                   │   @ IntegerNode (location: (1,7)-(1,8))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 1
            │                   └── operator_loc: (1,5)-(1,7) = "**"
            ├── closing_loc: (1,8)-(1,9) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_args_assoc_quoted.txt000066400000000000000000000160361506127434000241300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,8))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ CallNode (location: (1,0)-(1,11))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :x
        │   ├── message_loc: (1,0)-(1,1) = "x"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(1,11))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (1,2)-(1,11))
        │   │           ├── flags: ∅
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (1,2)-(1,11))
        │   │                   ├── flags: ∅
        │   │                   ├── key:
        │   │                   │   @ InterpolatedSymbolNode (location: (1,2)-(1,9))
        │   │                   │   ├── flags: ∅
        │   │                   │   ├── opening_loc: (1,2)-(1,3) = "\""
        │   │                   │   ├── parts: (length: 1)
        │   │                   │   │   └── @ EmbeddedStatementsNode (location: (1,3)-(1,7))
        │   │                   │   │       ├── flags: ∅
        │   │                   │   │       ├── opening_loc: (1,3)-(1,5) = "\#{"
        │   │                   │   │       ├── statements:
        │   │                   │   │       │   @ StatementsNode (location: (1,5)-(1,6))
        │   │                   │   │       │   ├── flags: ∅
        │   │                   │   │       │   └── body: (length: 1)
        │   │                   │   │       │       └── @ CallNode (location: (1,5)-(1,6))
        │   │                   │   │       │           ├── flags: variable_call, ignore_visibility
        │   │                   │   │       │           ├── receiver: ∅
        │   │                   │   │       │           ├── call_operator_loc: ∅
        │   │                   │   │       │           ├── name: :k
        │   │                   │   │       │           ├── message_loc: (1,5)-(1,6) = "k"
        │   │                   │   │       │           ├── opening_loc: ∅
        │   │                   │   │       │           ├── arguments: ∅
        │   │                   │   │       │           ├── closing_loc: ∅
        │   │                   │   │       │           └── block: ∅
        │   │                   │   │       └── closing_loc: (1,6)-(1,7) = "}"
        │   │                   │   └── closing_loc: (1,7)-(1,9) = "\":"
        │   │                   ├── value:
        │   │                   │   @ IntegerNode (location: (1,9)-(1,11))
        │   │                   │   ├── flags: static_literal, decimal
        │   │                   │   └── value: 42
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :x
        │   ├── message_loc: (3,0)-(3,1) = "x"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,2)-(3,8))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (3,2)-(3,8))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (3,2)-(3,8))
        │   │                   ├── flags: static_literal
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (3,2)-(3,6))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: (3,2)-(3,3) = "\""
        │   │                   │   ├── value_loc: (3,3)-(3,4) = "k"
        │   │                   │   ├── closing_loc: (3,4)-(3,6) = "\":"
        │   │                   │   └── unescaped: "k"
        │   │                   ├── value:
        │   │                   │   @ IntegerNode (location: (3,6)-(3,8))
        │   │                   │   ├── flags: static_literal, decimal
        │   │                   │   └── value: 42
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (5,0)-(5,8))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :x
            ├── message_loc: (5,0)-(5,1) = "x"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (5,2)-(5,8))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 1)
            │       └── @ KeywordHashNode (location: (5,2)-(5,8))
            │           ├── flags: symbol_keys
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (5,2)-(5,8))
            │                   ├── flags: static_literal
            │                   ├── key:
            │                   │   @ SymbolNode (location: (5,2)-(5,6))
            │                   │   ├── flags: static_literal, forced_us_ascii_encoding
            │                   │   ├── opening_loc: (5,2)-(5,3) = "'"
            │                   │   ├── value_loc: (5,3)-(5,4) = "k"
            │                   │   ├── closing_loc: (5,4)-(5,6) = "':"
            │                   │   └── unescaped: "k"
            │                   ├── value:
            │                   │   @ IntegerNode (location: (5,6)-(5,8))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 42
            │                   └── operator_loc: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_args_assoc_trailing_comma.txt000066400000000000000000000036211506127434000256100ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,11))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,11))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: (1,1)-(1,2) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,9))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 2)
            │       ├── @ IntegerNode (location: (1,2)-(1,3))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 1
            │       └── @ KeywordHashNode (location: (1,5)-(1,9))
            │           ├── flags: ∅
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (1,5)-(1,9))
            │                   ├── flags: static_literal
            │                   ├── key:
            │                   │   @ IntegerNode (location: (1,5)-(1,6))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 2
            │                   ├── value:
            │                   │   @ IntegerNode (location: (1,8)-(1,9))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 3
            │                   └── operator_loc: (1,6)-(1,8) = "=>"
            ├── closing_loc: (1,10)-(1,11) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_args_command.txt000066400000000000000000000054101506127434000230470ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,9))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (1,1)-(1,2) = "."
            ├── name: :b
            ├── message_loc: (1,2)-(1,3) = "b"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,9))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ CallNode (location: (1,4)-(1,9))
            │           ├── flags: ∅
            │           ├── receiver:
            │           │   @ CallNode (location: (1,4)-(1,5))
            │           │   ├── flags: variable_call, ignore_visibility
            │           │   ├── receiver: ∅
            │           │   ├── call_operator_loc: ∅
            │           │   ├── name: :c
            │           │   ├── message_loc: (1,4)-(1,5) = "c"
            │           │   ├── opening_loc: ∅
            │           │   ├── arguments: ∅
            │           │   ├── closing_loc: ∅
            │           │   └── block: ∅
            │           ├── call_operator_loc: (1,5)-(1,6) = "."
            │           ├── name: :d
            │           ├── message_loc: (1,6)-(1,7) = "d"
            │           ├── opening_loc: ∅
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,8)-(1,9))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 1)
            │           │       └── @ IntegerNode (location: (1,8)-(1,9))
            │           │           ├── flags: static_literal, decimal
            │           │           └── value: 1
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_array_arg.txt000066400000000000000000000041341506127434000223660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,13))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :==
            ├── message_loc: (1,2)-(1,4) = "=="
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,5)-(1,13))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ ArrayNode (location: (1,5)-(1,13))
            │           ├── flags: static_literal
            │           ├── elements: (length: 2)
            │           │   ├── @ SymbolNode (location: (1,6)-(1,8))
            │           │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │           │   │   ├── opening_loc: (1,6)-(1,7) = ":"
            │           │   │   ├── value_loc: (1,7)-(1,8) = "b"
            │           │   │   ├── closing_loc: ∅
            │           │   │   └── unescaped: "b"
            │           │   └── @ SymbolNode (location: (1,10)-(1,12))
            │           │       ├── flags: static_literal, forced_us_ascii_encoding
            │           │       ├── opening_loc: (1,10)-(1,11) = ":"
            │           │       ├── value_loc: (1,11)-(1,12) = "c"
            │           │       ├── closing_loc: ∅
            │           │       └── unescaped: "c"
            │           ├── opening_loc: (1,5)-(1,6) = "["
            │           └── closing_loc: (1,12)-(1,13) = "]"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_array_block_call.txt000066400000000000000000000045101506127434000237000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,19))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,19))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,19))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ ArrayNode (location: (1,2)-(1,19))
            │           ├── flags: ∅
            │           ├── elements: (length: 2)
            │           │   ├── @ NilNode (location: (1,4)-(1,7))
            │           │   │   └── flags: static_literal
            │           │   └── @ CallNode (location: (1,9)-(1,17))
            │           │       ├── flags: ignore_visibility
            │           │       ├── receiver: ∅
            │           │       ├── call_operator_loc: ∅
            │           │       ├── name: :b
            │           │       ├── message_loc: (1,9)-(1,10) = "b"
            │           │       ├── opening_loc: ∅
            │           │       ├── arguments: ∅
            │           │       ├── closing_loc: ∅
            │           │       └── block:
            │           │           @ BlockNode (location: (1,11)-(1,17))
            │           │           ├── flags: ∅
            │           │           ├── locals: []
            │           │           ├── parameters: ∅
            │           │           ├── body: ∅
            │           │           ├── opening_loc: (1,11)-(1,13) = "do"
            │           │           └── closing_loc: (1,14)-(1,17) = "end"
            │           ├── opening_loc: (1,2)-(1,3) = "["
            │           └── closing_loc: (1,18)-(1,19) = "]"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_array_lambda_block_call.txt000066400000000000000000000045401506127434000252030ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(2,3))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,11))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ ArrayNode (location: (1,2)-(1,11))
            │           ├── flags: ∅
            │           ├── elements: (length: 1)
            │           │   └── @ LambdaNode (location: (1,3)-(1,10))
            │           │       ├── flags: ∅
            │           │       ├── locals: []
            │           │       ├── operator_loc: (1,3)-(1,5) = "->"
            │           │       ├── opening_loc: (1,8)-(1,9) = "{"
            │           │       ├── closing_loc: (1,9)-(1,10) = "}"
            │           │       ├── parameters:
            │           │       │   @ BlockParametersNode (location: (1,5)-(1,7))
            │           │       │   ├── flags: ∅
            │           │       │   ├── parameters: ∅
            │           │       │   ├── locals: (length: 0)
            │           │       │   ├── opening_loc: (1,5)-(1,6) = "("
            │           │       │   └── closing_loc: (1,6)-(1,7) = ")"
            │           │       └── body: ∅
            │           ├── opening_loc: (1,2)-(1,3) = "["
            │           └── closing_loc: (1,10)-(1,11) = "]"
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,12)-(2,3))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (1,12)-(1,14) = "do"
                └── closing_loc: (2,0)-(2,3) = "end"
prism-1.5.1/snapshots/seattlerb/call_array_lit_inline_hash.txt000066400000000000000000000055741506127434000247570ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,16))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,16))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,16))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: (1,1)-(1,2) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,15))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ ArrayNode (location: (1,2)-(1,15))
            │           ├── flags: ∅
            │           ├── elements: (length: 2)
            │           │   ├── @ SymbolNode (location: (1,3)-(1,5))
            │           │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │           │   │   ├── opening_loc: (1,3)-(1,4) = ":"
            │           │   │   ├── value_loc: (1,4)-(1,5) = "b"
            │           │   │   ├── closing_loc: ∅
            │           │   │   └── unescaped: "b"
            │           │   └── @ KeywordHashNode (location: (1,7)-(1,14))
            │           │       ├── flags: symbol_keys
            │           │       └── elements: (length: 1)
            │           │           └── @ AssocNode (location: (1,7)-(1,14))
            │           │               ├── flags: static_literal
            │           │               ├── key:
            │           │               │   @ SymbolNode (location: (1,7)-(1,9))
            │           │               │   ├── flags: static_literal, forced_us_ascii_encoding
            │           │               │   ├── opening_loc: (1,7)-(1,8) = ":"
            │           │               │   ├── value_loc: (1,8)-(1,9) = "c"
            │           │               │   ├── closing_loc: ∅
            │           │               │   └── unescaped: "c"
            │           │               ├── value:
            │           │               │   @ IntegerNode (location: (1,13)-(1,14))
            │           │               │   ├── flags: static_literal, decimal
            │           │               │   └── value: 1
            │           │               └── operator_loc: (1,10)-(1,12) = "=>"
            │           ├── opening_loc: (1,2)-(1,3) = "["
            │           └── closing_loc: (1,14)-(1,15) = "]"
            ├── closing_loc: (1,15)-(1,16) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_assoc.txt000066400000000000000000000033221506127434000215250ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,7))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,7))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: (1,1)-(1,2) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,6))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 1)
            │       └── @ KeywordHashNode (location: (1,2)-(1,6))
            │           ├── flags: ∅
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (1,2)-(1,6))
            │                   ├── flags: static_literal
            │                   ├── key:
            │                   │   @ IntegerNode (location: (1,2)-(1,3))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 2
            │                   ├── value:
            │                   │   @ IntegerNode (location: (1,5)-(1,6))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 3
            │                   └── operator_loc: (1,3)-(1,5) = "=>"
            ├── closing_loc: (1,6)-(1,7) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_assoc_new.txt000066400000000000000000000037041506127434000224020ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,6))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: (1,1)-(1,2) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,5))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 1)
            │       └── @ KeywordHashNode (location: (1,2)-(1,5))
            │           ├── flags: symbol_keys
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (1,2)-(1,5))
            │                   ├── flags: static_literal
            │                   ├── key:
            │                   │   @ SymbolNode (location: (1,2)-(1,4))
            │                   │   ├── flags: static_literal, forced_us_ascii_encoding
            │                   │   ├── opening_loc: ∅
            │                   │   ├── value_loc: (1,2)-(1,3) = "a"
            │                   │   ├── closing_loc: (1,3)-(1,4) = ":"
            │                   │   └── unescaped: "a"
            │                   ├── value:
            │                   │   @ IntegerNode (location: (1,4)-(1,5))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 3
            │                   └── operator_loc: ∅
            ├── closing_loc: (1,5)-(1,6) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_assoc_new_if_multiline.txt000066400000000000000000000102651506127434000251420ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(5,4))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: (1,1)-(1,2) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(5,3))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 1)
            │       └── @ KeywordHashNode (location: (1,2)-(5,3))
            │           ├── flags: symbol_keys
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (1,2)-(5,3))
            │                   ├── flags: ∅
            │                   ├── key:
            │                   │   @ SymbolNode (location: (1,2)-(1,4))
            │                   │   ├── flags: static_literal, forced_us_ascii_encoding
            │                   │   ├── opening_loc: ∅
            │                   │   ├── value_loc: (1,2)-(1,3) = "b"
            │                   │   ├── closing_loc: (1,3)-(1,4) = ":"
            │                   │   └── unescaped: "b"
            │                   ├── value:
            │                   │   @ IfNode (location: (1,5)-(5,3))
            │                   │   ├── flags: newline
            │                   │   ├── if_keyword_loc: (1,5)-(1,7) = "if"
            │                   │   ├── predicate:
            │                   │   │   @ SymbolNode (location: (1,8)-(1,10))
            │                   │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │                   │   │   ├── opening_loc: (1,8)-(1,9) = ":"
            │                   │   │   ├── value_loc: (1,9)-(1,10) = "c"
            │                   │   │   ├── closing_loc: ∅
            │                   │   │   └── unescaped: "c"
            │                   │   ├── then_keyword_loc: ∅
            │                   │   ├── statements:
            │                   │   │   @ StatementsNode (location: (2,0)-(2,1))
            │                   │   │   ├── flags: ∅
            │                   │   │   └── body: (length: 1)
            │                   │   │       └── @ IntegerNode (location: (2,0)-(2,1))
            │                   │   │           ├── flags: newline, static_literal, decimal
            │                   │   │           └── value: 1
            │                   │   ├── subsequent:
            │                   │   │   @ ElseNode (location: (3,0)-(5,3))
            │                   │   │   ├── flags: ∅
            │                   │   │   ├── else_keyword_loc: (3,0)-(3,4) = "else"
            │                   │   │   ├── statements:
            │                   │   │   │   @ StatementsNode (location: (4,0)-(4,1))
            │                   │   │   │   ├── flags: ∅
            │                   │   │   │   └── body: (length: 1)
            │                   │   │   │       └── @ IntegerNode (location: (4,0)-(4,1))
            │                   │   │   │           ├── flags: newline, static_literal, decimal
            │                   │   │   │           └── value: 2
            │                   │   │   └── end_keyword_loc: (5,0)-(5,3) = "end"
            │                   │   └── end_keyword_loc: (5,0)-(5,3) = "end"
            │                   └── operator_loc: ∅
            ├── closing_loc: (5,3)-(5,4) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_assoc_trailing_comma.txt000066400000000000000000000033221506127434000245720ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,8))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: (1,1)-(1,2) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,6))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 1)
            │       └── @ KeywordHashNode (location: (1,2)-(1,6))
            │           ├── flags: ∅
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (1,2)-(1,6))
            │                   ├── flags: static_literal
            │                   ├── key:
            │                   │   @ IntegerNode (location: (1,2)-(1,3))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 1
            │                   ├── value:
            │                   │   @ IntegerNode (location: (1,5)-(1,6))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 2
            │                   └── operator_loc: (1,3)-(1,5) = "=>"
            ├── closing_loc: (1,7)-(1,8) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_bang_command_call.txt000066400000000000000000000036621506127434000240240ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,7))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,7))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,2)-(1,7))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ CallNode (location: (1,2)-(1,3))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :a
            │   │   ├── message_loc: (1,2)-(1,3) = "a"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── call_operator_loc: (1,3)-(1,4) = "."
            │   ├── name: :b
            │   ├── message_loc: (1,4)-(1,5) = "b"
            │   ├── opening_loc: ∅
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (1,6)-(1,7))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 1)
            │   │       └── @ IntegerNode (location: (1,6)-(1,7))
            │   │           ├── flags: static_literal, decimal
            │   │           └── value: 1
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :!
            ├── message_loc: (1,0)-(1,1) = "!"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_bang_squiggle.txt000066400000000000000000000020731506127434000232260ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,6))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :!~
            ├── message_loc: (1,2)-(1,4) = "!~"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,5)-(1,6))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,5)-(1,6))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_begin_call_block_call.txt000066400000000000000000000065141506127434000246470ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(3,3))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(3,3))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ BeginNode (location: (1,2)-(3,3))
            │           ├── flags: ∅
            │           ├── begin_keyword_loc: (1,2)-(1,7) = "begin"
            │           ├── statements:
            │           │   @ StatementsNode (location: (2,0)-(2,10))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ CallNode (location: (2,0)-(2,10))
            │           │           ├── flags: newline
            │           │           ├── receiver:
            │           │           │   @ CallNode (location: (2,0)-(2,1))
            │           │           │   ├── flags: variable_call, ignore_visibility
            │           │           │   ├── receiver: ∅
            │           │           │   ├── call_operator_loc: ∅
            │           │           │   ├── name: :b
            │           │           │   ├── message_loc: (2,0)-(2,1) = "b"
            │           │           │   ├── opening_loc: ∅
            │           │           │   ├── arguments: ∅
            │           │           │   ├── closing_loc: ∅
            │           │           │   └── block: ∅
            │           │           ├── call_operator_loc: (2,1)-(2,2) = "."
            │           │           ├── name: :c
            │           │           ├── message_loc: (2,2)-(2,3) = "c"
            │           │           ├── opening_loc: ∅
            │           │           ├── arguments: ∅
            │           │           ├── closing_loc: ∅
            │           │           └── block:
            │           │               @ BlockNode (location: (2,4)-(2,10))
            │           │               ├── flags: ∅
            │           │               ├── locals: []
            │           │               ├── parameters: ∅
            │           │               ├── body: ∅
            │           │               ├── opening_loc: (2,4)-(2,6) = "do"
            │           │               └── closing_loc: (2,7)-(2,10) = "end"
            │           ├── rescue_clause: ∅
            │           ├── else_clause: ∅
            │           ├── ensure_clause: ∅
            │           └── end_keyword_loc: (3,0)-(3,3) = "end"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_block_arg_named.txt000066400000000000000000000025311506127434000235050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,7))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,7))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :x
            ├── message_loc: (1,0)-(1,1) = "x"
            ├── opening_loc: (1,1)-(1,2) = "("
            ├── arguments: ∅
            ├── closing_loc: (1,6)-(1,7) = ")"
            └── block:
                @ BlockArgumentNode (location: (1,2)-(1,6))
                ├── flags: ∅
                ├── expression:
                │   @ CallNode (location: (1,3)-(1,6))
                │   ├── flags: variable_call, ignore_visibility
                │   ├── receiver: ∅
                │   ├── call_operator_loc: ∅
                │   ├── name: :blk
                │   ├── message_loc: (1,3)-(1,6) = "blk"
                │   ├── opening_loc: ∅
                │   ├── arguments: ∅
                │   ├── closing_loc: ∅
                │   └── block: ∅
                └── operator_loc: (1,2)-(1,3) = "&"
prism-1.5.1/snapshots/seattlerb/call_carat.txt000066400000000000000000000020711506127434000215070ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,5))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :^
            ├── message_loc: (1,2)-(1,3) = "^"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,5))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,4)-(1,5))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_colon2.txt000066400000000000000000000013631506127434000216140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,4))
            ├── flags: newline
            ├── receiver:
            │   @ ConstantReadNode (location: (1,0)-(1,1))
            │   ├── flags: ∅
            │   └── name: :A
            ├── call_operator_loc: (1,1)-(1,3) = "::"
            ├── name: :b
            ├── message_loc: (1,3)-(1,4) = "b"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_colon_parens.txt000066400000000000000000000014231506127434000230770ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,5))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: (1,1)-(1,3) = "::"
            ├── name: :call
            ├── message_loc: ∅
            ├── opening_loc: (1,3)-(1,4) = "("
            ├── arguments: ∅
            ├── closing_loc: (1,4)-(1,5) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_div.txt000066400000000000000000000020711506127434000211770ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,5))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :/
            ├── message_loc: (1,2)-(1,3) = "/"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,5))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,4)-(1,5))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_dot_parens.txt000066400000000000000000000014221506127434000225520ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,4))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: (1,1)-(1,2) = "."
            ├── name: :call
            ├── message_loc: ∅
            ├── opening_loc: (1,2)-(1,3) = "("
            ├── arguments: ∅
            ├── closing_loc: (1,3)-(1,4) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_env.txt000066400000000000000000000021231506127434000212030ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,7))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,7))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (1,1)-(1,2) = "."
            ├── name: :happy
            ├── message_loc: (1,2)-(1,7) = "happy"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_eq3.txt000066400000000000000000000020751506127434000211110ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,7))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,7))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :===
            ├── message_loc: (1,2)-(1,5) = "==="
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,6)-(1,7))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,6)-(1,7))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_gt.txt000066400000000000000000000020711506127434000210270ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,5))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :>
            ├── message_loc: (1,2)-(1,3) = ">"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,5))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,4)-(1,5))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_kwsplat.txt000066400000000000000000000027311506127434000221050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,6))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: (1,1)-(1,2) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,5))
            │   ├── flags: contains_keywords, contains_keyword_splat
            │   └── arguments: (length: 1)
            │       └── @ KeywordHashNode (location: (1,2)-(1,5))
            │           ├── flags: ∅
            │           └── elements: (length: 1)
            │               └── @ AssocSplatNode (location: (1,2)-(1,5))
            │                   ├── flags: ∅
            │                   ├── value:
            │                   │   @ IntegerNode (location: (1,4)-(1,5))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 1
            │                   └── operator_loc: (1,2)-(1,4) = "**"
            ├── closing_loc: (1,5)-(1,6) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_leading_dots.txt000066400000000000000000000031261506127434000230530ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,2))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,2))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(3,2))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(2,2))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ CallNode (location: (1,0)-(1,1))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :a
            │   │   ├── message_loc: (1,0)-(1,1) = "a"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── call_operator_loc: (2,0)-(2,1) = "."
            │   ├── name: :b
            │   ├── message_loc: (2,1)-(2,2) = "b"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (3,0)-(3,1) = "."
            ├── name: :c
            ├── message_loc: (3,1)-(3,2) = "c"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_leading_dots_comment.txt000066400000000000000000000031261506127434000245750ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,2))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,2))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(4,2))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(2,2))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ CallNode (location: (1,0)-(1,1))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :a
            │   │   ├── message_loc: (1,0)-(1,1) = "a"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── call_operator_loc: (2,0)-(2,1) = "."
            │   ├── name: :b
            │   ├── message_loc: (2,1)-(2,2) = "b"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (4,0)-(4,1) = "."
            ├── name: :d
            ├── message_loc: (4,1)-(4,2) = "d"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_lt.txt000066400000000000000000000020711506127434000210340ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,5))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :<
            ├── message_loc: (1,2)-(1,3) = "<"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,5))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,4)-(1,5))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_lte.txt000066400000000000000000000020731506127434000212030ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,6))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :<=
            ├── message_loc: (1,2)-(1,4) = "<="
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,5)-(1,6))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,5)-(1,6))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_not.txt000066400000000000000000000013661506127434000212230ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,6))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,4)-(1,6))
            │   ├── flags: static_literal, decimal
            │   └── value: 42
            ├── call_operator_loc: ∅
            ├── name: :!
            ├── message_loc: (1,0)-(1,3) = "not"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_pipe.txt000066400000000000000000000020711506127434000213520ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,5))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :|
            ├── message_loc: (1,2)-(1,3) = "|"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,5))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,4)-(1,5))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_rshift.txt000066400000000000000000000020731506127434000217160ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,6))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :>>
            ├── message_loc: (1,2)-(1,4) = ">>"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,5)-(1,6))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,5)-(1,6))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_self_brackets.txt000066400000000000000000000020571506127434000232300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,7))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,7))
            ├── flags: newline, ignore_visibility
            ├── receiver:
            │   @ SelfNode (location: (1,0)-(1,4))
            │   └── flags: ∅
            ├── call_operator_loc: ∅
            ├── name: :[]
            ├── message_loc: (1,4)-(1,7) = "[1]"
            ├── opening_loc: (1,4)-(1,5) = "["
            ├── arguments:
            │   @ ArgumentsNode (location: (1,5)-(1,6))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,5)-(1,6))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: (1,6)-(1,7) = "]"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_spaceship.txt000066400000000000000000000020751506127434000224000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,7))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,7))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :<=>
            ├── message_loc: (1,2)-(1,5) = "<=>"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,6)-(1,7))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,6)-(1,7))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_stabby_do_end_with_block.txt000066400000000000000000000044311506127434000254200ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,22))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,22))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,22))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,13))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ LambdaNode (location: (1,2)-(1,13))
            │           ├── flags: ∅
            │           ├── locals: []
            │           ├── operator_loc: (1,2)-(1,4) = "->"
            │           ├── opening_loc: (1,5)-(1,7) = "do"
            │           ├── closing_loc: (1,10)-(1,13) = "end"
            │           ├── parameters: ∅
            │           └── body:
            │               @ StatementsNode (location: (1,8)-(1,9))
            │               ├── flags: ∅
            │               └── body: (length: 1)
            │                   └── @ IntegerNode (location: (1,8)-(1,9))
            │                       ├── flags: newline, static_literal, decimal
            │                       └── value: 1
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,14)-(1,22))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body:
                │   @ StatementsNode (location: (1,17)-(1,18))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ IntegerNode (location: (1,17)-(1,18))
                │           ├── flags: newline, static_literal, decimal
                │           └── value: 2
                ├── opening_loc: (1,14)-(1,16) = "do"
                └── closing_loc: (1,19)-(1,22) = "end"
prism-1.5.1/snapshots/seattlerb/call_stabby_with_braces_block.txt000066400000000000000000000044251506127434000254320ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,19))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,19))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,10))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ LambdaNode (location: (1,2)-(1,10))
            │           ├── flags: ∅
            │           ├── locals: []
            │           ├── operator_loc: (1,2)-(1,4) = "->"
            │           ├── opening_loc: (1,5)-(1,6) = "{"
            │           ├── closing_loc: (1,9)-(1,10) = "}"
            │           ├── parameters: ∅
            │           └── body:
            │               @ StatementsNode (location: (1,7)-(1,8))
            │               ├── flags: ∅
            │               └── body: (length: 1)
            │                   └── @ IntegerNode (location: (1,7)-(1,8))
            │                       ├── flags: newline, static_literal, decimal
            │                       └── value: 1
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,11)-(1,19))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body:
                │   @ StatementsNode (location: (1,14)-(1,15))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ IntegerNode (location: (1,14)-(1,15))
                │           ├── flags: newline, static_literal, decimal
                │           └── value: 2
                ├── opening_loc: (1,11)-(1,13) = "do"
                └── closing_loc: (1,16)-(1,19) = "end"
prism-1.5.1/snapshots/seattlerb/call_star.txt000066400000000000000000000020711506127434000213660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,5))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :*
            ├── message_loc: (1,2)-(1,3) = "*"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,5))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,4)-(1,5))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_star2.txt000066400000000000000000000020731506127434000214520ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,6))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :**
            ├── message_loc: (1,2)-(1,4) = "**"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,5)-(1,6))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,5)-(1,6))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_trailing_comma.txt000066400000000000000000000017241506127434000234060ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,5))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: (1,1)-(1,2) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,3))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,2)-(1,3))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: (1,4)-(1,5) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_trailing_dots.txt000066400000000000000000000031261506127434000232610ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,1))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,1))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(3,1))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(2,1))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ CallNode (location: (1,0)-(1,1))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :a
            │   │   ├── message_loc: (1,0)-(1,1) = "a"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── call_operator_loc: (1,1)-(1,2) = "."
            │   ├── name: :b
            │   ├── message_loc: (2,0)-(2,1) = "b"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (2,1)-(2,2) = "."
            ├── name: :c
            ├── message_loc: (3,0)-(3,1) = "c"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/call_unary_bang.txt000066400000000000000000000013631506127434000225450ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,2))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,2))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,2))
            ├── flags: newline
            ├── receiver:
            │   @ IntegerNode (location: (1,1)-(1,2))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── call_operator_loc: ∅
            ├── name: :!
            ├── message_loc: (1,0)-(1,1) = "!"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/case_in.txt000066400000000000000000002076651506127434000210430ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(111,3))
├── flags: ∅
├── locals: [:b, :_, :lhs, :x, :rhs, :c, :e]
└── statements:
    @ StatementsNode (location: (1,0)-(111,3))
    ├── flags: ∅
    └── body: (length: 28)
        ├── @ CaseMatchNode (location: (1,0)-(3,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (1,5)-(1,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (1,5)-(1,6) = ":"
        │   │   ├── value_loc: (1,6)-(1,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2,0)-(2,8))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (2,4)-(2,8))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (2,4)-(2,8))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (2,4)-(2,8))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: (2,4)-(2,5) = "\""
        │   │       │   │       │   ├── value_loc: (2,5)-(2,6) = "b"
        │   │       │   │       │   ├── closing_loc: (2,6)-(2,8) = "\":"
        │   │       │   │       │   └── unescaped: "b"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ ImplicitNode (location: (2,5)-(2,6))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── value:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (2,5)-(2,6))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :b
        │   │       │   │       │       └── depth: 0
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (2,0)-(2,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (3,0)-(3,3) = "end"
        ├── @ CaseMatchNode (location: (5,0)-(7,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (5,5)-(5,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (5,5)-(5,6) = ":"
        │   │   ├── value_loc: (5,6)-(5,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (6,0)-(6,10))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (6,3)-(6,10))
        │   │       │   ├── flags: static_literal
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ SymbolNode (location: (6,6)-(6,7))
        │   │       │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   ├── value_loc: (6,6)-(6,7) = "a"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "a"
        │   │       │   │   └── @ SymbolNode (location: (6,8)-(6,9))
        │   │       │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── value_loc: (6,8)-(6,9) = "b"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "b"
        │   │       │   ├── opening_loc: (6,3)-(6,6) = "%I["
        │   │       │   └── closing_loc: (6,9)-(6,10) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (6,0)-(6,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (5,0)-(5,4) = "case"
        │   └── end_keyword_loc: (7,0)-(7,3) = "end"
        ├── @ CaseMatchNode (location: (9,0)-(11,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (9,5)-(9,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (9,5)-(9,6) = ":"
        │   │   ├── value_loc: (9,6)-(9,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (10,0)-(10,10))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (10,3)-(10,10))
        │   │       │   ├── flags: ∅
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ StringNode (location: (10,6)-(10,7))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   ├── content_loc: (10,6)-(10,7) = "a"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "a"
        │   │       │   │   └── @ StringNode (location: (10,8)-(10,9))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (10,8)-(10,9) = "b"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "b"
        │   │       │   ├── opening_loc: (10,3)-(10,6) = "%W["
        │   │       │   └── closing_loc: (10,9)-(10,10) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (10,0)-(10,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (9,0)-(9,4) = "case"
        │   └── end_keyword_loc: (11,0)-(11,3) = "end"
        ├── @ CaseMatchNode (location: (13,0)-(15,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (13,5)-(13,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (13,5)-(13,6) = ":"
        │   │   ├── value_loc: (13,6)-(13,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (14,0)-(14,10))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (14,3)-(14,10))
        │   │       │   ├── flags: static_literal
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ SymbolNode (location: (14,6)-(14,7))
        │   │       │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   ├── value_loc: (14,6)-(14,7) = "a"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "a"
        │   │       │   │   └── @ SymbolNode (location: (14,8)-(14,9))
        │   │       │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── value_loc: (14,8)-(14,9) = "b"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "b"
        │   │       │   ├── opening_loc: (14,3)-(14,6) = "%i["
        │   │       │   └── closing_loc: (14,9)-(14,10) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (14,0)-(14,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (13,0)-(13,4) = "case"
        │   └── end_keyword_loc: (15,0)-(15,3) = "end"
        ├── @ CaseMatchNode (location: (17,0)-(19,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (17,5)-(17,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (17,5)-(17,6) = ":"
        │   │   ├── value_loc: (17,6)-(17,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (18,0)-(18,10))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayNode (location: (18,3)-(18,10))
        │   │       │   ├── flags: ∅
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ StringNode (location: (18,6)-(18,7))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   ├── content_loc: (18,6)-(18,7) = "a"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "a"
        │   │       │   │   └── @ StringNode (location: (18,8)-(18,9))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (18,8)-(18,9) = "b"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "b"
        │   │       │   ├── opening_loc: (18,3)-(18,6) = "%w["
        │   │       │   └── closing_loc: (18,9)-(18,10) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (18,0)-(18,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (17,0)-(17,4) = "case"
        │   └── end_keyword_loc: (19,0)-(19,3) = "end"
        ├── @ CaseMatchNode (location: (21,0)-(23,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (21,5)-(21,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (21,5)-(21,6) = ":"
        │   │   ├── value_loc: (21,6)-(21,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (22,0)-(22,10))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ParenthesesNode (location: (22,3)-(22,10))
        │   │       │   ├── flags: ∅
        │   │       │   ├── body:
        │   │       │   │   @ RangeNode (location: (22,4)-(22,9))
        │   │       │   │   ├── flags: static_literal, exclude_end
        │   │       │   │   ├── left: ∅
        │   │       │   │   ├── right:
        │   │       │   │   │   @ IntegerNode (location: (22,7)-(22,9))
        │   │       │   │   │   ├── flags: static_literal, decimal
        │   │       │   │   │   └── value: 10
        │   │       │   │   └── operator_loc: (22,4)-(22,7) = "..."
        │   │       │   ├── opening_loc: (22,3)-(22,4) = "("
        │   │       │   └── closing_loc: (22,9)-(22,10) = ")"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (22,0)-(22,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (21,0)-(21,4) = "case"
        │   └── end_keyword_loc: (23,0)-(23,3) = "end"
        ├── @ CaseMatchNode (location: (25,0)-(27,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (25,5)-(25,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (25,5)-(25,6) = ":"
        │   │   ├── value_loc: (25,6)-(25,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (26,0)-(26,9))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ParenthesesNode (location: (26,3)-(26,9))
        │   │       │   ├── flags: ∅
        │   │       │   ├── body:
        │   │       │   │   @ RangeNode (location: (26,4)-(26,8))
        │   │       │   │   ├── flags: static_literal
        │   │       │   │   ├── left: ∅
        │   │       │   │   ├── right:
        │   │       │   │   │   @ IntegerNode (location: (26,6)-(26,8))
        │   │       │   │   │   ├── flags: static_literal, decimal
        │   │       │   │   │   └── value: 10
        │   │       │   │   └── operator_loc: (26,4)-(26,6) = ".."
        │   │       │   ├── opening_loc: (26,3)-(26,4) = "("
        │   │       │   └── closing_loc: (26,8)-(26,9) = ")"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (26,0)-(26,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (25,0)-(25,4) = "case"
        │   └── end_keyword_loc: (27,0)-(27,3) = "end"
        ├── @ CaseMatchNode (location: (29,0)-(31,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (29,5)-(29,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (29,5)-(29,6) = ":"
        │   │   ├── value_loc: (29,6)-(29,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (30,0)-(30,9))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ParenthesesNode (location: (30,3)-(30,9))
        │   │       │   ├── flags: ∅
        │   │       │   ├── body:
        │   │       │   │   @ RangeNode (location: (30,4)-(30,8))
        │   │       │   │   ├── flags: static_literal, exclude_end
        │   │       │   │   ├── left:
        │   │       │   │   │   @ IntegerNode (location: (30,4)-(30,5))
        │   │       │   │   │   ├── flags: static_literal, decimal
        │   │       │   │   │   └── value: 1
        │   │       │   │   ├── right: ∅
        │   │       │   │   └── operator_loc: (30,5)-(30,8) = "..."
        │   │       │   ├── opening_loc: (30,3)-(30,4) = "("
        │   │       │   └── closing_loc: (30,8)-(30,9) = ")"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (30,0)-(30,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (29,0)-(29,4) = "case"
        │   └── end_keyword_loc: (31,0)-(31,3) = "end"
        ├── @ CaseMatchNode (location: (33,0)-(35,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (33,5)-(33,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (33,5)-(33,6) = ":"
        │   │   ├── value_loc: (33,6)-(33,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (34,0)-(34,10))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ParenthesesNode (location: (34,3)-(34,10))
        │   │       │   ├── flags: ∅
        │   │       │   ├── body:
        │   │       │   │   @ RangeNode (location: (34,4)-(34,9))
        │   │       │   │   ├── flags: static_literal, exclude_end
        │   │       │   │   ├── left:
        │   │       │   │   │   @ IntegerNode (location: (34,4)-(34,5))
        │   │       │   │   │   ├── flags: static_literal, decimal
        │   │       │   │   │   └── value: 1
        │   │       │   │   ├── right:
        │   │       │   │   │   @ IntegerNode (location: (34,8)-(34,9))
        │   │       │   │   │   ├── flags: static_literal, decimal
        │   │       │   │   │   └── value: 3
        │   │       │   │   └── operator_loc: (34,5)-(34,8) = "..."
        │   │       │   ├── opening_loc: (34,3)-(34,4) = "("
        │   │       │   └── closing_loc: (34,9)-(34,10) = ")"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (34,0)-(34,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (33,0)-(33,4) = "case"
        │   └── end_keyword_loc: (35,0)-(35,3) = "end"
        ├── @ CaseMatchNode (location: (37,0)-(39,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (37,5)-(37,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (37,5)-(37,6) = ":"
        │   │   ├── value_loc: (37,6)-(37,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (38,0)-(38,7))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ParenthesesNode (location: (38,3)-(38,7))
        │   │       │   ├── flags: ∅
        │   │       │   ├── body:
        │   │       │   │   @ IntegerNode (location: (38,4)-(38,6))
        │   │       │   │   ├── flags: static_literal, decimal
        │   │       │   │   └── value: 42
        │   │       │   ├── opening_loc: (38,3)-(38,4) = "("
        │   │       │   └── closing_loc: (38,6)-(38,7) = ")"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (38,0)-(38,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (37,0)-(37,4) = "case"
        │   └── end_keyword_loc: (39,0)-(39,3) = "end"
        ├── @ CaseMatchNode (location: (41,0)-(43,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (41,5)-(41,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (41,5)-(41,6) = ":"
        │   │   ├── value_loc: (41,6)-(41,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (42,0)-(42,8))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (42,3)-(42,8))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 0)
        │   │       │   ├── rest:
        │   │       │   │   @ NoKeywordsParameterNode (location: (42,3)-(42,8))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (42,3)-(42,5) = "**"
        │   │       │   │   └── keyword_loc: (42,5)-(42,8) = "nil"
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (42,0)-(42,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (41,0)-(41,4) = "case"
        │   └── end_keyword_loc: (43,0)-(43,3) = "end"
        ├── @ CaseMatchNode (location: (45,0)-(47,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (45,5)-(45,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (45,5)-(45,6) = ":"
        │   │   ├── value_loc: (45,6)-(45,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (46,0)-(46,11))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ RegularExpressionNode (location: (46,3)-(46,11))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (46,3)-(46,4) = "/"
        │   │       │   ├── content_loc: (46,4)-(46,10) = "regexp"
        │   │       │   ├── closing_loc: (46,10)-(46,11) = "/"
        │   │       │   └── unescaped: "regexp"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (46,0)-(46,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (45,0)-(45,4) = "case"
        │   └── end_keyword_loc: (47,0)-(47,3) = "end"
        ├── @ CaseMatchNode (location: (49,0)-(51,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (49,5)-(49,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (49,5)-(49,6) = ":"
        │   │   ├── value_loc: (49,6)-(49,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (50,0)-(50,13))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (50,3)-(50,13))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ SymbolNode (location: (50,3)-(50,5))
        │   │       │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       ├── opening_loc: (50,3)-(50,4) = ":"
        │   │       │   │       ├── value_loc: (50,4)-(50,5) = "b"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "b"
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (50,7)-(50,9))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (50,7)-(50,8) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (50,8)-(50,9))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :_
        │   │       │   │       └── depth: 0
        │   │       │   ├── posts: (length: 1)
        │   │       │   │   └── @ SymbolNode (location: (50,11)-(50,13))
        │   │       │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       ├── opening_loc: (50,11)-(50,12) = ":"
        │   │       │   │       ├── value_loc: (50,12)-(50,13) = "c"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "c"
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (50,0)-(50,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (49,0)-(49,4) = "case"
        │   └── end_keyword_loc: (51,0)-(51,3) = "end"
        ├── @ CaseMatchNode (location: (53,0)-(55,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (53,5)-(53,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (53,5)-(53,6) = ":"
        │   │   ├── value_loc: (53,6)-(53,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (54,0)-(54,11))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (54,3)-(54,11))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ SymbolNode (location: (54,3)-(54,5))
        │   │       │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   ├── opening_loc: (54,3)-(54,4) = ":"
        │   │       │   │   │   ├── value_loc: (54,4)-(54,5) = "b"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "b"
        │   │       │   │   └── @ ArrayPatternNode (location: (54,7)-(54,11))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── constant: ∅
        │   │       │   │       ├── requireds: (length: 1)
        │   │       │   │       │   └── @ SymbolNode (location: (54,8)-(54,10))
        │   │       │   │       │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │       ├── opening_loc: (54,8)-(54,9) = ":"
        │   │       │   │       │       ├── value_loc: (54,9)-(54,10) = "c"
        │   │       │   │       │       ├── closing_loc: ∅
        │   │       │   │       │       └── unescaped: "c"
        │   │       │   │       ├── rest: ∅
        │   │       │   │       ├── posts: (length: 0)
        │   │       │   │       ├── opening_loc: (54,7)-(54,8) = "["
        │   │       │   │       └── closing_loc: (54,10)-(54,11) = "]"
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (54,0)-(54,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (53,0)-(53,4) = "case"
        │   └── end_keyword_loc: (55,0)-(55,3) = "end"
        ├── @ CaseMatchNode (location: (57,0)-(59,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (57,5)-(57,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (57,5)-(57,6) = ":"
        │   │   ├── value_loc: (57,6)-(57,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (58,0)-(58,11))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (58,3)-(58,11))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (58,3)-(58,9))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :Symbol
        │   │       │   ├── requireds: (length: 0)
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (58,9)-(58,10) = "("
        │   │       │   └── closing_loc: (58,10)-(58,11) = ")"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (58,0)-(58,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (57,0)-(57,4) = "case"
        │   └── end_keyword_loc: (59,0)-(59,3) = "end"
        ├── @ CaseMatchNode (location: (61,0)-(63,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (61,5)-(61,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (61,5)-(61,6) = ":"
        │   │   ├── value_loc: (61,6)-(61,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (62,0)-(62,24))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ FindPatternNode (location: (62,3)-(62,24))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (62,3)-(62,9))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :Symbol
        │   │       │   ├── left:
        │   │       │   │   @ SplatNode (location: (62,10)-(62,14))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (62,10)-(62,11) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (62,11)-(62,14))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :lhs
        │   │       │   │       └── depth: 0
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ LocalVariableTargetNode (location: (62,16)-(62,17))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :x
        │   │       │   │       └── depth: 0
        │   │       │   ├── right:
        │   │       │   │   @ SplatNode (location: (62,19)-(62,23))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (62,19)-(62,20) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (62,20)-(62,23))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :rhs
        │   │       │   │       └── depth: 0
        │   │       │   ├── opening_loc: (62,9)-(62,10) = "("
        │   │       │   └── closing_loc: (62,23)-(62,24) = ")"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (62,0)-(62,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (61,0)-(61,4) = "case"
        │   └── end_keyword_loc: (63,0)-(63,3) = "end"
        ├── @ CaseMatchNode (location: (65,0)-(67,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (65,5)-(65,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (65,5)-(65,6) = ":"
        │   │   ├── value_loc: (65,6)-(65,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (66,0)-(66,24))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ FindPatternNode (location: (66,3)-(66,24))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (66,3)-(66,9))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :Symbol
        │   │       │   ├── left:
        │   │       │   │   @ SplatNode (location: (66,10)-(66,14))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (66,10)-(66,11) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (66,11)-(66,14))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :lhs
        │   │       │   │       └── depth: 0
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ LocalVariableTargetNode (location: (66,16)-(66,17))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :x
        │   │       │   │       └── depth: 0
        │   │       │   ├── right:
        │   │       │   │   @ SplatNode (location: (66,19)-(66,23))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (66,19)-(66,20) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (66,20)-(66,23))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :rhs
        │   │       │   │       └── depth: 0
        │   │       │   ├── opening_loc: (66,9)-(66,10) = "["
        │   │       │   └── closing_loc: (66,23)-(66,24) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (66,0)-(66,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (65,0)-(65,4) = "case"
        │   └── end_keyword_loc: (67,0)-(67,3) = "end"
        ├── @ CaseMatchNode (location: (69,0)-(71,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (69,5)-(69,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (69,5)-(69,6) = ":"
        │   │   ├── value_loc: (69,6)-(69,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (70,0)-(70,22))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (70,3)-(70,22))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ LambdaNode (location: (70,4)-(70,18))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── locals: [:b]
        │   │       │   │   │   ├── operator_loc: (70,4)-(70,6) = "->"
        │   │       │   │   │   ├── opening_loc: (70,10)-(70,11) = "{"
        │   │       │   │   │   ├── closing_loc: (70,17)-(70,18) = "}"
        │   │       │   │   │   ├── parameters:
        │   │       │   │   │   │   @ BlockParametersNode (location: (70,6)-(70,9))
        │   │       │   │   │   │   ├── flags: ∅
        │   │       │   │   │   │   ├── parameters:
        │   │       │   │   │   │   │   @ ParametersNode (location: (70,7)-(70,8))
        │   │       │   │   │   │   │   ├── flags: ∅
        │   │       │   │   │   │   │   ├── requireds: (length: 1)
        │   │       │   │   │   │   │   │   └── @ RequiredParameterNode (location: (70,7)-(70,8))
        │   │       │   │   │   │   │   │       ├── flags: ∅
        │   │       │   │   │   │   │   │       └── name: :b
        │   │       │   │   │   │   │   ├── optionals: (length: 0)
        │   │       │   │   │   │   │   ├── rest: ∅
        │   │       │   │   │   │   │   ├── posts: (length: 0)
        │   │       │   │   │   │   │   ├── keywords: (length: 0)
        │   │       │   │   │   │   │   ├── keyword_rest: ∅
        │   │       │   │   │   │   │   └── block: ∅
        │   │       │   │   │   │   ├── locals: (length: 0)
        │   │       │   │   │   │   ├── opening_loc: (70,6)-(70,7) = "("
        │   │       │   │   │   │   └── closing_loc: (70,8)-(70,9) = ")"
        │   │       │   │   │   └── body:
        │   │       │   │   │       @ StatementsNode (location: (70,12)-(70,16))
        │   │       │   │   │       ├── flags: ∅
        │   │       │   │   │       └── body: (length: 1)
        │   │       │   │   │           └── @ TrueNode (location: (70,12)-(70,16))
        │   │       │   │   │               └── flags: newline, static_literal
        │   │       │   │   └── @ LocalVariableTargetNode (location: (70,20)-(70,21))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :c
        │   │       │   │       └── depth: 0
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (70,3)-(70,4) = "["
        │   │       │   └── closing_loc: (70,21)-(70,22) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (70,0)-(70,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (69,0)-(69,4) = "case"
        │   └── end_keyword_loc: (71,0)-(71,3) = "end"
        ├── @ CaseMatchNode (location: (73,0)-(75,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (73,5)-(73,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (73,5)-(73,6) = ":"
        │   │   ├── value_loc: (73,6)-(73,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (74,0)-(74,28))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (74,3)-(74,28))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 4)
        │   │       │   │   ├── @ SymbolNode (location: (74,4)-(74,6))
        │   │       │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   ├── opening_loc: (74,4)-(74,5) = ":"
        │   │       │   │   │   ├── value_loc: (74,5)-(74,6) = "a"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "a"
        │   │       │   │   ├── @ LocalVariableTargetNode (location: (74,8)-(74,9))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── name: :b
        │   │       │   │   │   └── depth: 0
        │   │       │   │   ├── @ LocalVariableTargetNode (location: (74,11)-(74,12))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── name: :c
        │   │       │   │   │   └── depth: 0
        │   │       │   │   └── @ ArrayPatternNode (location: (74,14)-(74,27))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── constant: ∅
        │   │       │   │       ├── requireds: (length: 1)
        │   │       │   │       │   └── @ SymbolNode (location: (74,15)-(74,17))
        │   │       │   │       │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │       ├── opening_loc: (74,15)-(74,16) = ":"
        │   │       │   │       │       ├── value_loc: (74,16)-(74,17) = "d"
        │   │       │   │       │       ├── closing_loc: ∅
        │   │       │   │       │       └── unescaped: "d"
        │   │       │   │       ├── rest:
        │   │       │   │       │   @ SplatNode (location: (74,19)-(74,21))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   ├── operator_loc: (74,19)-(74,20) = "*"
        │   │       │   │       │   └── expression:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (74,20)-(74,21))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :e
        │   │       │   │       │       └── depth: 0
        │   │       │   │       ├── posts: (length: 1)
        │   │       │   │       │   └── @ NilNode (location: (74,23)-(74,26))
        │   │       │   │       │       └── flags: static_literal
        │   │       │   │       ├── opening_loc: (74,14)-(74,15) = "["
        │   │       │   │       └── closing_loc: (74,26)-(74,27) = "]"
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (74,3)-(74,4) = "["
        │   │       │   └── closing_loc: (74,27)-(74,28) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (74,0)-(74,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (73,0)-(73,4) = "case"
        │   └── end_keyword_loc: (75,0)-(75,3) = "end"
        ├── @ CaseMatchNode (location: (77,0)-(79,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (77,5)-(77,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (77,5)-(77,6) = ":"
        │   │   ├── value_loc: (77,6)-(77,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (78,0)-(78,12))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (78,3)-(78,12))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ ConstantReadNode (location: (78,4)-(78,5))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       └── name: :A
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (78,7)-(78,8))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (78,7)-(78,8) = "*"
        │   │       │   │   └── expression: ∅
        │   │       │   ├── posts: (length: 1)
        │   │       │   │   └── @ ConstantReadNode (location: (78,10)-(78,11))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       └── name: :B
        │   │       │   ├── opening_loc: (78,3)-(78,4) = "["
        │   │       │   └── closing_loc: (78,11)-(78,12) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (78,0)-(78,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (77,0)-(77,4) = "case"
        │   └── end_keyword_loc: (79,0)-(79,3) = "end"
        ├── @ CaseMatchNode (location: (81,0)-(83,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (81,5)-(81,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (81,5)-(81,6) = ":"
        │   │   ├── value_loc: (81,6)-(81,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (82,0)-(82,22))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (82,3)-(82,22))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ ArrayPatternNode (location: (82,4)-(82,11))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── constant: ∅
        │   │       │   │   │   ├── requireds: (length: 2)
        │   │       │   │   │   │   ├── @ SymbolNode (location: (82,5)-(82,7))
        │   │       │   │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   │   │   ├── opening_loc: (82,5)-(82,6) = ":"
        │   │       │   │   │   │   │   ├── value_loc: (82,6)-(82,7) = "b"
        │   │       │   │   │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   │   │   └── unescaped: "b"
        │   │       │   │   │   │   └── @ LocalVariableTargetNode (location: (82,9)-(82,10))
        │   │       │   │   │   │       ├── flags: ∅
        │   │       │   │   │   │       ├── name: :c
        │   │       │   │   │   │       └── depth: 0
        │   │       │   │   │   ├── rest: ∅
        │   │       │   │   │   ├── posts: (length: 0)
        │   │       │   │   │   ├── opening_loc: (82,4)-(82,5) = "["
        │   │       │   │   │   └── closing_loc: (82,10)-(82,11) = "]"
        │   │       │   │   └── @ ArrayPatternNode (location: (82,13)-(82,21))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── constant: ∅
        │   │       │   │       ├── requireds: (length: 2)
        │   │       │   │       │   ├── @ SymbolNode (location: (82,14)-(82,16))
        │   │       │   │       │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   │   ├── opening_loc: (82,14)-(82,15) = ":"
        │   │       │   │       │   │   ├── value_loc: (82,15)-(82,16) = "d"
        │   │       │   │       │   │   ├── closing_loc: ∅
        │   │       │   │       │   │   └── unescaped: "d"
        │   │       │   │       │   └── @ PinnedVariableNode (location: (82,18)-(82,20))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── variable:
        │   │       │   │       │       │   @ LocalVariableReadNode (location: (82,19)-(82,20))
        │   │       │   │       │       │   ├── flags: ∅
        │   │       │   │       │       │   ├── name: :e
        │   │       │   │       │       │   └── depth: 0
        │   │       │   │       │       └── operator_loc: (82,18)-(82,19) = "^"
        │   │       │   │       ├── rest: ∅
        │   │       │   │       ├── posts: (length: 0)
        │   │       │   │       ├── opening_loc: (82,13)-(82,14) = "["
        │   │       │   │       └── closing_loc: (82,20)-(82,21) = "]"
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (82,3)-(82,4) = "["
        │   │       │   └── closing_loc: (82,21)-(82,22) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (82,0)-(82,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (81,0)-(81,4) = "case"
        │   └── end_keyword_loc: (83,0)-(83,3) = "end"
        ├── @ CaseMatchNode (location: (85,0)-(87,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (85,5)-(85,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (85,5)-(85,6) = ":"
        │   │   ├── value_loc: (85,6)-(85,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (86,0)-(86,5))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (86,3)-(86,5))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 0)
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (86,3)-(86,4) = "["
        │   │       │   └── closing_loc: (86,4)-(86,5) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (86,0)-(86,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (85,0)-(85,4) = "case"
        │   └── end_keyword_loc: (87,0)-(87,3) = "end"
        ├── @ CaseMatchNode (location: (89,0)-(91,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (89,5)-(89,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (89,5)-(89,6) = ":"
        │   │   ├── value_loc: (89,6)-(89,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (90,0)-(90,9))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (90,3)-(90,9))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ PinnedExpressionNode (location: (90,4)-(90,8))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── expression:
        │   │       │   │       │   @ CallNode (location: (90,6)-(90,7))
        │   │       │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   │       │   ├── receiver: ∅
        │   │       │   │       │   ├── call_operator_loc: ∅
        │   │       │   │       │   ├── name: :a
        │   │       │   │       │   ├── message_loc: (90,6)-(90,7) = "a"
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── arguments: ∅
        │   │       │   │       │   ├── closing_loc: ∅
        │   │       │   │       │   └── block: ∅
        │   │       │   │       ├── operator_loc: (90,4)-(90,5) = "^"
        │   │       │   │       ├── lparen_loc: (90,5)-(90,6) = "("
        │   │       │   │       └── rparen_loc: (90,7)-(90,8) = ")"
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (90,3)-(90,4) = "["
        │   │       │   └── closing_loc: (90,8)-(90,9) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (90,0)-(90,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (89,0)-(89,4) = "case"
        │   └── end_keyword_loc: (91,0)-(91,3) = "end"
        ├── @ CaseMatchNode (location: (93,0)-(95,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (93,5)-(93,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (93,5)-(93,6) = ":"
        │   │   ├── value_loc: (93,6)-(93,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (94,0)-(94,19))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (94,3)-(94,19))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 3)
        │   │       │   │   ├── @ PinnedVariableNode (location: (94,4)-(94,7))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── variable:
        │   │       │   │   │   │   @ InstanceVariableReadNode (location: (94,5)-(94,7))
        │   │       │   │   │   │   ├── flags: ∅
        │   │       │   │   │   │   └── name: :@a
        │   │       │   │   │   └── operator_loc: (94,4)-(94,5) = "^"
        │   │       │   │   ├── @ PinnedVariableNode (location: (94,9)-(94,12))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── variable:
        │   │       │   │   │   │   @ GlobalVariableReadNode (location: (94,10)-(94,12))
        │   │       │   │   │   │   ├── flags: ∅
        │   │       │   │   │   │   └── name: :$b
        │   │       │   │   │   └── operator_loc: (94,9)-(94,10) = "^"
        │   │       │   │   └── @ PinnedVariableNode (location: (94,14)-(94,18))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── variable:
        │   │       │   │       │   @ ClassVariableReadNode (location: (94,15)-(94,18))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── name: :@@c
        │   │       │   │       └── operator_loc: (94,14)-(94,15) = "^"
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (94,3)-(94,4) = "["
        │   │       │   └── closing_loc: (94,18)-(94,19) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (94,0)-(94,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (93,0)-(93,4) = "case"
        │   └── end_keyword_loc: (95,0)-(95,3) = "end"
        ├── @ CaseMatchNode (location: (97,0)-(99,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (97,5)-(97,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (97,5)-(97,6) = ":"
        │   │   ├── value_loc: (97,6)-(97,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (98,0)-(98,12))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ XStringNode (location: (98,3)-(98,12))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (98,3)-(98,4) = "`"
        │   │       │   ├── content_loc: (98,4)-(98,11) = "echo hi"
        │   │       │   ├── closing_loc: (98,11)-(98,12) = "`"
        │   │       │   └── unescaped: "echo hi"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (98,0)-(98,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (97,0)-(97,4) = "case"
        │   └── end_keyword_loc: (99,0)-(99,3) = "end"
        ├── @ CaseMatchNode (location: (101,0)-(103,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (101,5)-(101,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (101,5)-(101,6) = ":"
        │   │   ├── value_loc: (101,6)-(101,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (102,0)-(102,16))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (102,3)-(102,16))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 3)
        │   │       │   │   ├── @ NilNode (location: (102,3)-(102,6))
        │   │       │   │   │   └── flags: static_literal
        │   │       │   │   ├── @ NilNode (location: (102,8)-(102,11))
        │   │       │   │   │   └── flags: static_literal
        │   │       │   │   └── @ NilNode (location: (102,13)-(102,16))
        │   │       │   │       └── flags: static_literal
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (102,0)-(102,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (101,0)-(101,4) = "case"
        │   └── end_keyword_loc: (103,0)-(103,3) = "end"
        ├── @ CaseMatchNode (location: (105,0)-(107,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ SymbolNode (location: (105,5)-(105,7))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (105,5)-(105,6) = ":"
        │   │   ├── value_loc: (105,6)-(105,7) = "a"
        │   │   ├── closing_loc: ∅
        │   │   └── unescaped: "a"
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (106,0)-(106,11))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (106,3)-(106,11))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (106,5)-(106,9))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (106,5)-(106,9))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: (106,5)-(106,6) = "\""
        │   │       │   │       │   ├── value_loc: (106,6)-(106,7) = "b"
        │   │       │   │       │   ├── closing_loc: (106,7)-(106,9) = "\":"
        │   │       │   │       │   └── unescaped: "b"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ ImplicitNode (location: (106,6)-(106,7))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── value:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (106,6)-(106,7))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :b
        │   │       │   │       │       └── depth: 0
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: (106,3)-(106,4) = "{"
        │   │       │   └── closing_loc: (106,10)-(106,11) = "}"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (106,0)-(106,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (105,0)-(105,4) = "case"
        │   └── end_keyword_loc: (107,0)-(107,3) = "end"
        └── @ CaseMatchNode (location: (109,0)-(111,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (109,5)-(109,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (109,5)-(109,6) = ":"
            │   ├── value_loc: (109,6)-(109,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (110,0)-(110,5))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ HashPatternNode (location: (110,3)-(110,5))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── elements: (length: 0)
            │       │   ├── rest: ∅
            │       │   ├── opening_loc: (110,3)-(110,4) = "{"
            │       │   └── closing_loc: (110,4)-(110,5) = "}"
            │       ├── statements: ∅
            │       ├── in_loc: (110,0)-(110,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (109,0)-(109,4) = "case"
            └── end_keyword_loc: (111,0)-(111,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_31.txt000066400000000000000000000062701506127434000213330ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: [:c]
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(4,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(3,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ArrayPatternNode (location: (2,3)-(2,11))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── requireds: (length: 1)
            │       │   │   └── @ SymbolNode (location: (2,4)-(2,6))
            │       │   │       ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │       ├── opening_loc: (2,4)-(2,5) = ":"
            │       │   │       ├── value_loc: (2,5)-(2,6) = "b"
            │       │   │       ├── closing_loc: ∅
            │       │   │       └── unescaped: "b"
            │       │   ├── rest:
            │       │   │   @ SplatNode (location: (2,8)-(2,10))
            │       │   │   ├── flags: ∅
            │       │   │   ├── operator_loc: (2,8)-(2,9) = "*"
            │       │   │   └── expression:
            │       │   │       @ LocalVariableTargetNode (location: (2,9)-(2,10))
            │       │   │       ├── flags: ∅
            │       │   │       ├── name: :c
            │       │   │       └── depth: 0
            │       │   ├── posts: (length: 0)
            │       │   ├── opening_loc: (2,3)-(2,4) = "["
            │       │   └── closing_loc: (2,10)-(2,11) = "]"
            │       ├── statements:
            │       │   @ StatementsNode (location: (3,2)-(3,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (3,2)-(3,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (3,2)-(3,3) = ":"
            │       │           ├── value_loc: (3,3)-(3,4) = "d"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "d"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (4,0)-(4,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_37.txt000066400000000000000000000101621506127434000213340ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(4,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(3,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ HashPatternNode (location: (2,3)-(2,19))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── elements: (length: 1)
            │       │   │   └── @ AssocNode (location: (2,5)-(2,17))
            │       │   │       ├── flags: ∅
            │       │   │       ├── key:
            │       │   │       │   @ SymbolNode (location: (2,5)-(2,7))
            │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │       │   ├── opening_loc: ∅
            │       │   │       │   ├── value_loc: (2,5)-(2,6) = "b"
            │       │   │       │   ├── closing_loc: (2,6)-(2,7) = ":"
            │       │   │       │   └── unescaped: "b"
            │       │   │       ├── value:
            │       │   │       │   @ ArrayPatternNode (location: (2,8)-(2,17))
            │       │   │       │   ├── flags: ∅
            │       │   │       │   ├── constant: ∅
            │       │   │       │   ├── requireds: (length: 1)
            │       │   │       │   │   └── @ ConstantReadNode (location: (2,9)-(2,13))
            │       │   │       │   │       ├── flags: ∅
            │       │   │       │   │       └── name: :Hash
            │       │   │       │   ├── rest:
            │       │   │       │   │   @ SplatNode (location: (2,15)-(2,16))
            │       │   │       │   │   ├── flags: ∅
            │       │   │       │   │   ├── operator_loc: (2,15)-(2,16) = "*"
            │       │   │       │   │   └── expression: ∅
            │       │   │       │   ├── posts: (length: 0)
            │       │   │       │   ├── opening_loc: (2,8)-(2,9) = "["
            │       │   │       │   └── closing_loc: (2,16)-(2,17) = "]"
            │       │   │       └── operator_loc: ∅
            │       │   ├── rest: ∅
            │       │   ├── opening_loc: (2,3)-(2,4) = "{"
            │       │   └── closing_loc: (2,18)-(2,19) = "}"
            │       ├── statements:
            │       │   @ StatementsNode (location: (3,2)-(3,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (3,2)-(3,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (3,2)-(3,3) = ":"
            │       │           ├── value_loc: (3,3)-(3,4) = "c"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "c"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (4,0)-(4,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_42.txt000066400000000000000000000055761506127434000213450ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: [:_]
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(3,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(2,18))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ArrayPatternNode (location: (2,3)-(2,9))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── requireds: (length: 1)
            │       │   │   └── @ SymbolNode (location: (2,3)-(2,5))
            │       │   │       ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │       ├── opening_loc: (2,3)-(2,4) = ":"
            │       │   │       ├── value_loc: (2,4)-(2,5) = "b"
            │       │   │       ├── closing_loc: ∅
            │       │   │       └── unescaped: "b"
            │       │   ├── rest:
            │       │   │   @ SplatNode (location: (2,7)-(2,9))
            │       │   │   ├── flags: ∅
            │       │   │   ├── operator_loc: (2,7)-(2,8) = "*"
            │       │   │   └── expression:
            │       │   │       @ LocalVariableTargetNode (location: (2,8)-(2,9))
            │       │   │       ├── flags: ∅
            │       │   │       ├── name: :_
            │       │   │       └── depth: 0
            │       │   ├── posts: (length: 0)
            │       │   ├── opening_loc: ∅
            │       │   └── closing_loc: ∅
            │       ├── statements:
            │       │   @ StatementsNode (location: (2,15)-(2,18))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ NilNode (location: (2,15)-(2,18))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: (2,10)-(2,14) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (3,0)-(3,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_42_2.txt000066400000000000000000000052151506127434000215540ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: [:list]
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(3,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(2,20))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ArrayPatternNode (location: (2,3)-(2,11))
            │       │   ├── flags: ∅
            │       │   ├── constant:
            │       │   │   @ ConstantReadNode (location: (2,3)-(2,4))
            │       │   │   ├── flags: ∅
            │       │   │   └── name: :A
            │       │   ├── requireds: (length: 0)
            │       │   ├── rest:
            │       │   │   @ SplatNode (location: (2,5)-(2,10))
            │       │   │   ├── flags: ∅
            │       │   │   ├── operator_loc: (2,5)-(2,6) = "*"
            │       │   │   └── expression:
            │       │   │       @ LocalVariableTargetNode (location: (2,6)-(2,10))
            │       │   │       ├── flags: ∅
            │       │   │       ├── name: :list
            │       │   │       └── depth: 0
            │       │   ├── posts: (length: 0)
            │       │   ├── opening_loc: (2,4)-(2,5) = "("
            │       │   └── closing_loc: (2,10)-(2,11) = ")"
            │       ├── statements:
            │       │   @ StatementsNode (location: (2,17)-(2,20))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ NilNode (location: (2,17)-(2,20))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: (2,12)-(2,16) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (3,0)-(3,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_47.txt000066400000000000000000000066201506127434000213410ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(4,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(3,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ArrayPatternNode (location: (2,3)-(2,14))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── requireds: (length: 0)
            │       │   ├── rest:
            │       │   │   @ SplatNode (location: (2,4)-(2,5))
            │       │   │   ├── flags: ∅
            │       │   │   ├── operator_loc: (2,4)-(2,5) = "*"
            │       │   │   └── expression: ∅
            │       │   ├── posts: (length: 2)
            │       │   │   ├── @ SymbolNode (location: (2,7)-(2,9))
            │       │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │   │   ├── opening_loc: (2,7)-(2,8) = ":"
            │       │   │   │   ├── value_loc: (2,8)-(2,9) = "b"
            │       │   │   │   ├── closing_loc: ∅
            │       │   │   │   └── unescaped: "b"
            │       │   │   └── @ SymbolNode (location: (2,11)-(2,13))
            │       │   │       ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │       ├── opening_loc: (2,11)-(2,12) = ":"
            │       │   │       ├── value_loc: (2,12)-(2,13) = "c"
            │       │   │       ├── closing_loc: ∅
            │       │   │       └── unescaped: "c"
            │       │   ├── opening_loc: (2,3)-(2,4) = "["
            │       │   └── closing_loc: (2,13)-(2,14) = "]"
            │       ├── statements:
            │       │   @ StatementsNode (location: (3,2)-(3,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (3,2)-(3,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (3,2)-(3,3) = ":"
            │       │           ├── value_loc: (3,3)-(3,4) = "d"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "d"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (4,0)-(4,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_67.txt000066400000000000000000000037241506127434000213450ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(3,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(2,15))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ RangeNode (location: (2,3)-(2,6))
            │       │   ├── flags: static_literal
            │       │   ├── left:
            │       │   │   @ IntegerNode (location: (2,3)-(2,4))
            │       │   │   ├── flags: static_literal, decimal
            │       │   │   └── value: 1
            │       │   ├── right: ∅
            │       │   └── operator_loc: (2,4)-(2,6) = ".."
            │       ├── statements:
            │       │   @ StatementsNode (location: (2,12)-(2,15))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ NilNode (location: (2,12)-(2,15))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: (2,7)-(2,11) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (3,0)-(3,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_86.txt000066400000000000000000000065361506127434000213520ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(3,3))
            ├── flags: newline
            ├── predicate:
            │   @ ArrayNode (location: (1,5)-(1,13))
            │   ├── flags: static_literal
            │   ├── elements: (length: 2)
            │   │   ├── @ SymbolNode (location: (1,6)-(1,8))
            │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │   │   ├── opening_loc: (1,6)-(1,7) = ":"
            │   │   │   ├── value_loc: (1,7)-(1,8) = "a"
            │   │   │   ├── closing_loc: ∅
            │   │   │   └── unescaped: "a"
            │   │   └── @ SymbolNode (location: (1,10)-(1,12))
            │   │       ├── flags: static_literal, forced_us_ascii_encoding
            │   │       ├── opening_loc: (1,10)-(1,11) = ":"
            │   │       ├── value_loc: (1,11)-(1,12) = "b"
            │   │       ├── closing_loc: ∅
            │   │       └── unescaped: "b"
            │   ├── opening_loc: (1,5)-(1,6) = "["
            │   └── closing_loc: (1,12)-(1,13) = "]"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(2,25))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ArrayPatternNode (location: (2,3)-(2,16))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── requireds: (length: 1)
            │       │   │   └── @ ConstantPathNode (location: (2,3)-(2,13))
            │       │   │       ├── flags: ∅
            │       │   │       ├── parent: ∅
            │       │   │       ├── name: :NilClass
            │       │   │       ├── delimiter_loc: (2,3)-(2,5) = "::"
            │       │   │       └── name_loc: (2,5)-(2,13) = "NilClass"
            │       │   ├── rest:
            │       │   │   @ SplatNode (location: (2,15)-(2,16))
            │       │   │   ├── flags: ∅
            │       │   │   ├── operator_loc: (2,15)-(2,16) = "*"
            │       │   │   └── expression: ∅
            │       │   ├── posts: (length: 0)
            │       │   ├── opening_loc: ∅
            │       │   └── closing_loc: ∅
            │       ├── statements:
            │       │   @ StatementsNode (location: (2,22)-(2,25))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ NilNode (location: (2,22)-(2,25))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: (2,17)-(2,21) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (3,0)-(3,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_86_2.txt000066400000000000000000000065321506127434000215670ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(3,3))
            ├── flags: newline
            ├── predicate:
            │   @ ArrayNode (location: (1,5)-(1,13))
            │   ├── flags: static_literal
            │   ├── elements: (length: 2)
            │   │   ├── @ SymbolNode (location: (1,6)-(1,8))
            │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │   │   ├── opening_loc: (1,6)-(1,7) = ":"
            │   │   │   ├── value_loc: (1,7)-(1,8) = "a"
            │   │   │   ├── closing_loc: ∅
            │   │   │   └── unescaped: "a"
            │   │   └── @ SymbolNode (location: (1,10)-(1,12))
            │   │       ├── flags: static_literal, forced_us_ascii_encoding
            │   │       ├── opening_loc: (1,10)-(1,11) = ":"
            │   │       ├── value_loc: (1,11)-(1,12) = "b"
            │   │       ├── closing_loc: ∅
            │   │       └── unescaped: "b"
            │   ├── opening_loc: (1,5)-(1,6) = "["
            │   └── closing_loc: (1,12)-(1,13) = "]"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(2,25))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ArrayPatternNode (location: (2,3)-(2,16))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── requireds: (length: 0)
            │       │   ├── rest:
            │       │   │   @ SplatNode (location: (2,3)-(2,4))
            │       │   │   ├── flags: ∅
            │       │   │   ├── operator_loc: (2,3)-(2,4) = "*"
            │       │   │   └── expression: ∅
            │       │   ├── posts: (length: 1)
            │       │   │   └── @ ConstantPathNode (location: (2,6)-(2,16))
            │       │   │       ├── flags: ∅
            │       │   │       ├── parent: ∅
            │       │   │       ├── name: :NilClass
            │       │   │       ├── delimiter_loc: (2,6)-(2,8) = "::"
            │       │   │       └── name_loc: (2,8)-(2,16) = "NilClass"
            │       │   ├── opening_loc: ∅
            │       │   └── closing_loc: ∅
            │       ├── statements:
            │       │   @ StatementsNode (location: (2,22)-(2,25))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ NilNode (location: (2,22)-(2,25))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: (2,17)-(2,21) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (3,0)-(3,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_array_pat_const.txt000066400000000000000000000052441506127434000243000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: [:c]
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(4,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(3,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ArrayPatternNode (location: (2,3)-(2,7))
            │       │   ├── flags: ∅
            │       │   ├── constant:
            │       │   │   @ ConstantReadNode (location: (2,3)-(2,4))
            │       │   │   ├── flags: ∅
            │       │   │   └── name: :B
            │       │   ├── requireds: (length: 1)
            │       │   │   └── @ LocalVariableTargetNode (location: (2,5)-(2,6))
            │       │   │       ├── flags: ∅
            │       │   │       ├── name: :c
            │       │   │       └── depth: 0
            │       │   ├── rest: ∅
            │       │   ├── posts: (length: 0)
            │       │   ├── opening_loc: (2,4)-(2,5) = "["
            │       │   └── closing_loc: (2,6)-(2,7) = "]"
            │       ├── statements:
            │       │   @ StatementsNode (location: (3,2)-(3,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (3,2)-(3,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (3,2)-(3,3) = ":"
            │       │           ├── value_loc: (3,3)-(3,4) = "d"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "d"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (4,0)-(4,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_array_pat_const2.txt000066400000000000000000000060731506127434000243630ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: [:d]
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(4,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(3,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ArrayPatternNode (location: (2,3)-(2,10))
            │       │   ├── flags: ∅
            │       │   ├── constant:
            │       │   │   @ ConstantPathNode (location: (2,3)-(2,7))
            │       │   │   ├── flags: ∅
            │       │   │   ├── parent:
            │       │   │   │   @ ConstantReadNode (location: (2,3)-(2,4))
            │       │   │   │   ├── flags: ∅
            │       │   │   │   └── name: :B
            │       │   │   ├── name: :C
            │       │   │   ├── delimiter_loc: (2,4)-(2,6) = "::"
            │       │   │   └── name_loc: (2,6)-(2,7) = "C"
            │       │   ├── requireds: (length: 1)
            │       │   │   └── @ LocalVariableTargetNode (location: (2,8)-(2,9))
            │       │   │       ├── flags: ∅
            │       │   │       ├── name: :d
            │       │   │       └── depth: 0
            │       │   ├── rest: ∅
            │       │   ├── posts: (length: 0)
            │       │   ├── opening_loc: (2,7)-(2,8) = "["
            │       │   └── closing_loc: (2,9)-(2,10) = "]"
            │       ├── statements:
            │       │   @ StatementsNode (location: (3,2)-(3,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (3,2)-(3,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (3,2)-(3,3) = ":"
            │       │           ├── value_loc: (3,3)-(3,4) = "e"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "e"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (4,0)-(4,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_array_pat_paren_assign.txt000066400000000000000000000063471506127434000256300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: [:d]
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(4,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(3,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ArrayPatternNode (location: (2,3)-(2,12))
            │       │   ├── flags: ∅
            │       │   ├── constant:
            │       │   │   @ ConstantReadNode (location: (2,3)-(2,4))
            │       │   │   ├── flags: ∅
            │       │   │   └── name: :B
            │       │   ├── requireds: (length: 1)
            │       │   │   └── @ CapturePatternNode (location: (2,5)-(2,11))
            │       │   │       ├── flags: ∅
            │       │   │       ├── value:
            │       │   │       │   @ ConstantReadNode (location: (2,5)-(2,6))
            │       │   │       │   ├── flags: ∅
            │       │   │       │   └── name: :C
            │       │   │       ├── target:
            │       │   │       │   @ LocalVariableTargetNode (location: (2,10)-(2,11))
            │       │   │       │   ├── flags: ∅
            │       │   │       │   ├── name: :d
            │       │   │       │   └── depth: 0
            │       │   │       └── operator_loc: (2,7)-(2,9) = "=>"
            │       │   ├── rest: ∅
            │       │   ├── posts: (length: 0)
            │       │   ├── opening_loc: (2,4)-(2,5) = "("
            │       │   └── closing_loc: (2,11)-(2,12) = ")"
            │       ├── statements:
            │       │   @ StatementsNode (location: (3,2)-(3,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (3,2)-(3,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (3,2)-(3,3) = ":"
            │       │           ├── value_loc: (3,3)-(3,4) = "d"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "d"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (4,0)-(4,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_const.txt000066400000000000000000000033601506127434000222330ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(4,3))
            ├── flags: newline
            ├── predicate:
            │   @ ConstantReadNode (location: (1,5)-(1,10))
            │   ├── flags: ∅
            │   └── name: :Array
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(3,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ConstantReadNode (location: (2,3)-(2,8))
            │       │   ├── flags: ∅
            │       │   └── name: :Class
            │       ├── statements:
            │       │   @ StatementsNode (location: (3,2)-(3,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (3,2)-(3,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (3,2)-(3,3) = ":"
            │       │           ├── value_loc: (3,3)-(3,4) = "b"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "b"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (4,0)-(4,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_else.txt000066400000000000000000000051101506127434000220300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(6,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(6,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(6,3))
            ├── flags: newline
            ├── predicate:
            │   @ ConstantReadNode (location: (1,5)-(1,10))
            │   ├── flags: ∅
            │   └── name: :Array
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(3,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ConstantReadNode (location: (2,3)-(2,8))
            │       │   ├── flags: ∅
            │       │   └── name: :Class
            │       ├── statements:
            │       │   @ StatementsNode (location: (3,2)-(3,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (3,2)-(3,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (3,2)-(3,3) = ":"
            │       │           ├── value_loc: (3,3)-(3,4) = "b"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "b"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause:
            │   @ ElseNode (location: (4,0)-(6,3))
            │   ├── flags: ∅
            │   ├── else_keyword_loc: (4,0)-(4,4) = "else"
            │   ├── statements:
            │   │   @ StatementsNode (location: (5,2)-(5,4))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ SymbolNode (location: (5,2)-(5,4))
            │   │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │   │           ├── opening_loc: (5,2)-(5,3) = ":"
            │   │           ├── value_loc: (5,3)-(5,4) = "c"
            │   │           ├── closing_loc: ∅
            │   │           └── unescaped: "c"
            │   └── end_keyword_loc: (6,0)-(6,3) = "end"
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (6,0)-(6,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_find.txt000066400000000000000000000060541506127434000220300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: [:a, :b]
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(3,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,2)-(2,15))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ FindPatternNode (location: (2,5)-(2,15))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── left:
            │       │   │   @ SplatNode (location: (2,5)-(2,7))
            │       │   │   ├── flags: ∅
            │       │   │   ├── operator_loc: (2,5)-(2,6) = "*"
            │       │   │   └── expression:
            │       │   │       @ LocalVariableTargetNode (location: (2,6)-(2,7))
            │       │   │       ├── flags: ∅
            │       │   │       ├── name: :a
            │       │   │       └── depth: 0
            │       │   ├── requireds: (length: 1)
            │       │   │   └── @ SymbolNode (location: (2,9)-(2,11))
            │       │   │       ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │       ├── opening_loc: (2,9)-(2,10) = ":"
            │       │   │       ├── value_loc: (2,10)-(2,11) = "+"
            │       │   │       ├── closing_loc: ∅
            │       │   │       └── unescaped: "+"
            │       │   ├── right:
            │       │   │   @ SplatNode (location: (2,13)-(2,15))
            │       │   │   ├── flags: ∅
            │       │   │   ├── operator_loc: (2,13)-(2,14) = "*"
            │       │   │   └── expression:
            │       │   │       @ LocalVariableTargetNode (location: (2,14)-(2,15))
            │       │   │       ├── flags: ∅
            │       │   │       ├── name: :b
            │       │   │       └── depth: 0
            │       │   ├── opening_loc: ∅
            │       │   └── closing_loc: ∅
            │       ├── statements: ∅
            │       ├── in_loc: (2,2)-(2,4) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (3,0)-(3,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_find_array.txt000066400000000000000000000055251506127434000232300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: [:c]
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(3,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(2,16))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ FindPatternNode (location: (2,3)-(2,16))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── left:
            │       │   │   @ SplatNode (location: (2,4)-(2,5))
            │       │   │   ├── flags: ∅
            │       │   │   ├── operator_loc: (2,4)-(2,5) = "*"
            │       │   │   └── expression: ∅
            │       │   ├── requireds: (length: 2)
            │       │   │   ├── @ SymbolNode (location: (2,7)-(2,9))
            │       │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │   │   ├── opening_loc: (2,7)-(2,8) = ":"
            │       │   │   │   ├── value_loc: (2,8)-(2,9) = "b"
            │       │   │   │   ├── closing_loc: ∅
            │       │   │   │   └── unescaped: "b"
            │       │   │   └── @ LocalVariableTargetNode (location: (2,11)-(2,12))
            │       │   │       ├── flags: ∅
            │       │   │       ├── name: :c
            │       │   │       └── depth: 0
            │       │   ├── right:
            │       │   │   @ SplatNode (location: (2,14)-(2,15))
            │       │   │   ├── flags: ∅
            │       │   │   ├── operator_loc: (2,14)-(2,15) = "*"
            │       │   │   └── expression: ∅
            │       │   ├── opening_loc: (2,3)-(2,4) = "["
            │       │   └── closing_loc: (2,15)-(2,16) = "]"
            │       ├── statements: ∅
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (3,0)-(3,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_hash_pat.txt000066400000000000000000000113501506127434000226720ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(4,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(3,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ HashPatternNode (location: (2,3)-(2,21))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── elements: (length: 2)
            │       │   │   ├── @ AssocNode (location: (2,5)-(2,11))
            │       │   │   │   ├── flags: ∅
            │       │   │   │   ├── key:
            │       │   │   │   │   @ SymbolNode (location: (2,5)-(2,7))
            │       │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │   │   │   ├── opening_loc: ∅
            │       │   │   │   │   ├── value_loc: (2,5)-(2,6) = "b"
            │       │   │   │   │   ├── closing_loc: (2,6)-(2,7) = ":"
            │       │   │   │   │   └── unescaped: "b"
            │       │   │   │   ├── value:
            │       │   │   │   │   @ StringNode (location: (2,8)-(2,11))
            │       │   │   │   │   ├── flags: ∅
            │       │   │   │   │   ├── opening_loc: (2,8)-(2,9) = "'"
            │       │   │   │   │   ├── content_loc: (2,9)-(2,10) = "c"
            │       │   │   │   │   ├── closing_loc: (2,10)-(2,11) = "'"
            │       │   │   │   │   └── unescaped: "c"
            │       │   │   │   └── operator_loc: ∅
            │       │   │   └── @ AssocNode (location: (2,13)-(2,19))
            │       │   │       ├── flags: ∅
            │       │   │       ├── key:
            │       │   │       │   @ SymbolNode (location: (2,13)-(2,15))
            │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │       │   ├── opening_loc: ∅
            │       │   │       │   ├── value_loc: (2,13)-(2,14) = "d"
            │       │   │       │   ├── closing_loc: (2,14)-(2,15) = ":"
            │       │   │       │   └── unescaped: "d"
            │       │   │       ├── value:
            │       │   │       │   @ StringNode (location: (2,16)-(2,19))
            │       │   │       │   ├── flags: ∅
            │       │   │       │   ├── opening_loc: (2,16)-(2,17) = "\""
            │       │   │       │   ├── content_loc: (2,17)-(2,18) = "e"
            │       │   │       │   ├── closing_loc: (2,18)-(2,19) = "\""
            │       │   │       │   └── unescaped: "e"
            │       │   │       └── operator_loc: ∅
            │       │   ├── rest: ∅
            │       │   ├── opening_loc: (2,3)-(2,4) = "{"
            │       │   └── closing_loc: (2,20)-(2,21) = "}"
            │       ├── statements:
            │       │   @ StatementsNode (location: (3,2)-(3,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (3,2)-(3,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (3,2)-(3,3) = ":"
            │       │           ├── value_loc: (3,3)-(3,4) = "f"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "f"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: (2,22)-(2,26) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (4,0)-(4,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_hash_pat_assign.txt000066400000000000000000000150041506127434000242360ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: [:x, :f]
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(4,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(3,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ HashPatternNode (location: (2,3)-(2,34))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── elements: (length: 3)
            │       │   │   ├── @ AssocNode (location: (2,5)-(2,20))
            │       │   │   │   ├── flags: ∅
            │       │   │   │   ├── key:
            │       │   │   │   │   @ SymbolNode (location: (2,5)-(2,7))
            │       │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │   │   │   ├── opening_loc: ∅
            │       │   │   │   │   ├── value_loc: (2,5)-(2,6) = "b"
            │       │   │   │   │   ├── closing_loc: (2,6)-(2,7) = ":"
            │       │   │   │   │   └── unescaped: "b"
            │       │   │   │   ├── value:
            │       │   │   │   │   @ CapturePatternNode (location: (2,8)-(2,20))
            │       │   │   │   │   ├── flags: ∅
            │       │   │   │   │   ├── value:
            │       │   │   │   │   │   @ ConstantReadNode (location: (2,8)-(2,15))
            │       │   │   │   │   │   ├── flags: ∅
            │       │   │   │   │   │   └── name: :Integer
            │       │   │   │   │   ├── target:
            │       │   │   │   │   │   @ LocalVariableTargetNode (location: (2,19)-(2,20))
            │       │   │   │   │   │   ├── flags: ∅
            │       │   │   │   │   │   ├── name: :x
            │       │   │   │   │   │   └── depth: 0
            │       │   │   │   │   └── operator_loc: (2,16)-(2,18) = "=>"
            │       │   │   │   └── operator_loc: ∅
            │       │   │   ├── @ AssocNode (location: (2,22)-(2,28))
            │       │   │   │   ├── flags: ∅
            │       │   │   │   ├── key:
            │       │   │   │   │   @ SymbolNode (location: (2,22)-(2,24))
            │       │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │   │   │   ├── opening_loc: ∅
            │       │   │   │   │   ├── value_loc: (2,22)-(2,23) = "d"
            │       │   │   │   │   ├── closing_loc: (2,23)-(2,24) = ":"
            │       │   │   │   │   └── unescaped: "d"
            │       │   │   │   ├── value:
            │       │   │   │   │   @ StringNode (location: (2,25)-(2,28))
            │       │   │   │   │   ├── flags: ∅
            │       │   │   │   │   ├── opening_loc: (2,25)-(2,26) = "\""
            │       │   │   │   │   ├── content_loc: (2,26)-(2,27) = "e"
            │       │   │   │   │   ├── closing_loc: (2,27)-(2,28) = "\""
            │       │   │   │   │   └── unescaped: "e"
            │       │   │   │   └── operator_loc: ∅
            │       │   │   └── @ AssocNode (location: (2,30)-(2,32))
            │       │   │       ├── flags: ∅
            │       │   │       ├── key:
            │       │   │       │   @ SymbolNode (location: (2,30)-(2,32))
            │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │       │   ├── opening_loc: ∅
            │       │   │       │   ├── value_loc: (2,30)-(2,31) = "f"
            │       │   │       │   ├── closing_loc: (2,31)-(2,32) = ":"
            │       │   │       │   └── unescaped: "f"
            │       │   │       ├── value:
            │       │   │       │   @ ImplicitNode (location: (2,30)-(2,31))
            │       │   │       │   ├── flags: ∅
            │       │   │       │   └── value:
            │       │   │       │       @ LocalVariableTargetNode (location: (2,30)-(2,31))
            │       │   │       │       ├── flags: ∅
            │       │   │       │       ├── name: :f
            │       │   │       │       └── depth: 0
            │       │   │       └── operator_loc: ∅
            │       │   ├── rest: ∅
            │       │   ├── opening_loc: (2,3)-(2,4) = "{"
            │       │   └── closing_loc: (2,33)-(2,34) = "}"
            │       ├── statements:
            │       │   @ StatementsNode (location: (3,2)-(3,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (3,2)-(3,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (3,2)-(3,3) = ":"
            │       │           ├── value_loc: (3,3)-(3,4) = "g"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "g"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: (2,35)-(2,39) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (4,0)-(4,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_hash_pat_paren_assign.txt000066400000000000000000000065671506127434000254410ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(4,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(3,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ HashPatternNode (location: (2,3)-(2,11))
            │       │   ├── flags: ∅
            │       │   ├── constant:
            │       │   │   @ ConstantReadNode (location: (2,3)-(2,4))
            │       │   │   ├── flags: ∅
            │       │   │   └── name: :B
            │       │   ├── elements: (length: 1)
            │       │   │   └── @ AssocNode (location: (2,5)-(2,10))
            │       │   │       ├── flags: static_literal
            │       │   │       ├── key:
            │       │   │       │   @ SymbolNode (location: (2,5)-(2,7))
            │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │       │   ├── opening_loc: ∅
            │       │   │       │   ├── value_loc: (2,5)-(2,6) = "a"
            │       │   │       │   ├── closing_loc: (2,6)-(2,7) = ":"
            │       │   │       │   └── unescaped: "a"
            │       │   │       ├── value:
            │       │   │       │   @ IntegerNode (location: (2,8)-(2,10))
            │       │   │       │   ├── flags: static_literal, decimal
            │       │   │       │   └── value: 42
            │       │   │       └── operator_loc: ∅
            │       │   ├── rest: ∅
            │       │   ├── opening_loc: (2,4)-(2,5) = "("
            │       │   └── closing_loc: (2,10)-(2,11) = ")"
            │       ├── statements:
            │       │   @ StatementsNode (location: (3,2)-(3,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (3,2)-(3,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (3,2)-(3,3) = ":"
            │       │           ├── value_loc: (3,3)-(3,4) = "d"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "d"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (4,0)-(4,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_hash_pat_paren_true.txt000066400000000000000000000061531506127434000251230ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(4,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(3,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ HashPatternNode (location: (2,3)-(2,10))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── elements: (length: 1)
            │       │   │   └── @ AssocNode (location: (2,3)-(2,10))
            │       │   │       ├── flags: static_literal
            │       │   │       ├── key:
            │       │   │       │   @ SymbolNode (location: (2,3)-(2,5))
            │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │       │   ├── opening_loc: ∅
            │       │   │       │   ├── value_loc: (2,3)-(2,4) = "b"
            │       │   │       │   ├── closing_loc: (2,4)-(2,5) = ":"
            │       │   │       │   └── unescaped: "b"
            │       │   │       ├── value:
            │       │   │       │   @ TrueNode (location: (2,6)-(2,10))
            │       │   │       │   └── flags: static_literal
            │       │   │       └── operator_loc: ∅
            │       │   ├── rest: ∅
            │       │   ├── opening_loc: ∅
            │       │   └── closing_loc: ∅
            │       ├── statements:
            │       │   @ StatementsNode (location: (3,2)-(3,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (3,2)-(3,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (3,2)-(3,3) = ":"
            │       │           ├── value_loc: (3,3)-(3,4) = "c"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "c"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: (2,11)-(2,15) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (4,0)-(4,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_hash_pat_rest.txt000066400000000000000000000074041506127434000237340ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: [:c, :rest]
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(3,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(2,23))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ HashPatternNode (location: (2,3)-(2,15))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── elements: (length: 1)
            │       │   │   └── @ AssocNode (location: (2,3)-(2,7))
            │       │   │       ├── flags: ∅
            │       │   │       ├── key:
            │       │   │       │   @ SymbolNode (location: (2,3)-(2,5))
            │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │       │   ├── opening_loc: ∅
            │       │   │       │   ├── value_loc: (2,3)-(2,4) = "b"
            │       │   │       │   ├── closing_loc: (2,4)-(2,5) = ":"
            │       │   │       │   └── unescaped: "b"
            │       │   │       ├── value:
            │       │   │       │   @ LocalVariableTargetNode (location: (2,6)-(2,7))
            │       │   │       │   ├── flags: ∅
            │       │   │       │   ├── name: :c
            │       │   │       │   └── depth: 0
            │       │   │       └── operator_loc: ∅
            │       │   ├── rest:
            │       │   │   @ AssocSplatNode (location: (2,9)-(2,15))
            │       │   │   ├── flags: ∅
            │       │   │   ├── value:
            │       │   │   │   @ LocalVariableTargetNode (location: (2,11)-(2,15))
            │       │   │   │   ├── flags: ∅
            │       │   │   │   ├── name: :rest
            │       │   │   │   └── depth: 0
            │       │   │   └── operator_loc: (2,9)-(2,11) = "**"
            │       │   ├── opening_loc: ∅
            │       │   └── closing_loc: ∅
            │       ├── statements:
            │       │   @ StatementsNode (location: (2,21)-(2,23))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (2,21)-(2,23))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (2,21)-(2,22) = ":"
            │       │           ├── value_loc: (2,22)-(2,23) = "d"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "d"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: (2,16)-(2,20) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (3,0)-(3,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_hash_pat_rest_solo.txt000066400000000000000000000052721506127434000247710ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: [:rest]
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(3,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(2,17))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ HashPatternNode (location: (2,3)-(2,9))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── elements: (length: 0)
            │       │   ├── rest:
            │       │   │   @ AssocSplatNode (location: (2,3)-(2,9))
            │       │   │   ├── flags: ∅
            │       │   │   ├── value:
            │       │   │   │   @ LocalVariableTargetNode (location: (2,5)-(2,9))
            │       │   │   │   ├── flags: ∅
            │       │   │   │   ├── name: :rest
            │       │   │   │   └── depth: 0
            │       │   │   └── operator_loc: (2,3)-(2,5) = "**"
            │       │   ├── opening_loc: ∅
            │       │   └── closing_loc: ∅
            │       ├── statements:
            │       │   @ StatementsNode (location: (2,15)-(2,17))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (2,15)-(2,17))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (2,15)-(2,16) = ":"
            │       │           ├── value_loc: (2,16)-(2,17) = "d"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "d"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: (2,10)-(2,14) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (3,0)-(3,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_if_unless_post_mod.txt000066400000000000000000000113071506127434000250000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(6,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(6,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(6,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 2)
            │   ├── @ InNode (location: (2,0)-(3,4))
            │   │   ├── flags: ∅
            │   │   ├── pattern:
            │   │   │   @ IfNode (location: (2,3)-(2,12))
            │   │   │   ├── flags: newline
            │   │   │   ├── if_keyword_loc: (2,5)-(2,7) = "if"
            │   │   │   ├── predicate:
            │   │   │   │   @ TrueNode (location: (2,8)-(2,12))
            │   │   │   │   └── flags: static_literal
            │   │   │   ├── then_keyword_loc: ∅
            │   │   │   ├── statements:
            │   │   │   │   @ StatementsNode (location: (2,3)-(2,4))
            │   │   │   │   ├── flags: ∅
            │   │   │   │   └── body: (length: 1)
            │   │   │   │       └── @ ConstantReadNode (location: (2,3)-(2,4))
            │   │   │   │           ├── flags: newline
            │   │   │   │           └── name: :A
            │   │   │   ├── subsequent: ∅
            │   │   │   └── end_keyword_loc: ∅
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (3,2)-(3,4))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ SymbolNode (location: (3,2)-(3,4))
            │   │   │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │   │   │           ├── opening_loc: (3,2)-(3,3) = ":"
            │   │   │           ├── value_loc: (3,3)-(3,4) = "C"
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── unescaped: "C"
            │   │   ├── in_loc: (2,0)-(2,2) = "in"
            │   │   └── then_loc: ∅
            │   └── @ InNode (location: (4,0)-(5,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ UnlessNode (location: (4,3)-(4,17))
            │       │   ├── flags: newline
            │       │   ├── keyword_loc: (4,5)-(4,11) = "unless"
            │       │   ├── predicate:
            │       │   │   @ FalseNode (location: (4,12)-(4,17))
            │       │   │   └── flags: static_literal
            │       │   ├── then_keyword_loc: ∅
            │       │   ├── statements:
            │       │   │   @ StatementsNode (location: (4,3)-(4,4))
            │       │   │   ├── flags: ∅
            │       │   │   └── body: (length: 1)
            │       │   │       └── @ ConstantReadNode (location: (4,3)-(4,4))
            │       │   │           ├── flags: newline
            │       │   │           └── name: :D
            │       │   ├── else_clause: ∅
            │       │   └── end_keyword_loc: ∅
            │       ├── statements:
            │       │   @ StatementsNode (location: (5,2)-(5,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (5,2)-(5,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (5,2)-(5,3) = ":"
            │       │           ├── value_loc: (5,3)-(5,4) = "E"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "E"
            │       ├── in_loc: (4,0)-(4,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (6,0)-(6,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_multiple.txt000066400000000000000000000074021506127434000227410ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(6,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(6,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(6,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 2)
            │   ├── @ InNode (location: (2,0)-(3,4))
            │   │   ├── flags: ∅
            │   │   ├── pattern:
            │   │   │   @ ConstantPathNode (location: (2,3)-(2,7))
            │   │   │   ├── flags: ∅
            │   │   │   ├── parent:
            │   │   │   │   @ ConstantReadNode (location: (2,3)-(2,4))
            │   │   │   │   ├── flags: ∅
            │   │   │   │   └── name: :A
            │   │   │   ├── name: :B
            │   │   │   ├── delimiter_loc: (2,4)-(2,6) = "::"
            │   │   │   └── name_loc: (2,6)-(2,7) = "B"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (3,2)-(3,4))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ SymbolNode (location: (3,2)-(3,4))
            │   │   │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │   │   │           ├── opening_loc: (3,2)-(3,3) = ":"
            │   │   │           ├── value_loc: (3,3)-(3,4) = "C"
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── unescaped: "C"
            │   │   ├── in_loc: (2,0)-(2,2) = "in"
            │   │   └── then_loc: ∅
            │   └── @ InNode (location: (4,0)-(5,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ConstantPathNode (location: (4,3)-(4,7))
            │       │   ├── flags: ∅
            │       │   ├── parent:
            │       │   │   @ ConstantReadNode (location: (4,3)-(4,4))
            │       │   │   ├── flags: ∅
            │       │   │   └── name: :D
            │       │   ├── name: :E
            │       │   ├── delimiter_loc: (4,4)-(4,6) = "::"
            │       │   └── name_loc: (4,6)-(4,7) = "E"
            │       ├── statements:
            │       │   @ StatementsNode (location: (5,2)-(5,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (5,2)-(5,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (5,2)-(5,3) = ":"
            │       │           ├── value_loc: (5,3)-(5,4) = "F"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "F"
            │       ├── in_loc: (4,0)-(4,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (6,0)-(6,3) = "end"
prism-1.5.1/snapshots/seattlerb/case_in_or.txt000066400000000000000000000046251506127434000215320ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(4,3))
            ├── flags: newline
            ├── predicate:
            │   @ SymbolNode (location: (1,5)-(1,7))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,5)-(1,6) = ":"
            │   ├── value_loc: (1,6)-(1,7) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,0)-(3,4))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ AlternationPatternNode (location: (2,3)-(2,8))
            │       │   ├── flags: ∅
            │       │   ├── left:
            │       │   │   @ ConstantReadNode (location: (2,3)-(2,4))
            │       │   │   ├── flags: ∅
            │       │   │   └── name: :B
            │       │   ├── right:
            │       │   │   @ ConstantReadNode (location: (2,7)-(2,8))
            │       │   │   ├── flags: ∅
            │       │   │   └── name: :C
            │       │   └── operator_loc: (2,5)-(2,6) = "|"
            │       ├── statements:
            │       │   @ StatementsNode (location: (3,2)-(3,4))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ SymbolNode (location: (3,2)-(3,4))
            │       │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │           ├── opening_loc: (3,2)-(3,3) = ":"
            │       │           ├── value_loc: (3,3)-(3,4) = "d"
            │       │           ├── closing_loc: ∅
            │       │           └── unescaped: "d"
            │       ├── in_loc: (2,0)-(2,2) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (4,0)-(4,3) = "end"
prism-1.5.1/snapshots/seattlerb/class_comments.txt000066400000000000000000000032441506127434000224370ustar00rootroot00000000000000@ ProgramNode (location: (4,0)-(9,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (4,0)-(9,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ClassNode (location: (4,0)-(9,3))
            ├── flags: newline
            ├── locals: []
            ├── class_keyword_loc: (4,0)-(4,5) = "class"
            ├── constant_path:
            │   @ ConstantReadNode (location: (4,6)-(4,7))
            │   ├── flags: ∅
            │   └── name: :X
            ├── inheritance_operator_loc: ∅
            ├── superclass: ∅
            ├── body:
            │   @ StatementsNode (location: (6,2)-(8,5))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ DefNode (location: (6,2)-(8,5))
            │           ├── flags: newline
            │           ├── name: :blah
            │           ├── name_loc: (6,6)-(6,10) = "blah"
            │           ├── receiver: ∅
            │           ├── parameters: ∅
            │           ├── body: ∅
            │           ├── locals: []
            │           ├── def_keyword_loc: (6,2)-(6,5) = "def"
            │           ├── operator_loc: ∅
            │           ├── lparen_loc: ∅
            │           ├── rparen_loc: ∅
            │           ├── equal_loc: ∅
            │           └── end_keyword_loc: (8,2)-(8,5) = "end"
            ├── end_keyword_loc: (9,0)-(9,3) = "end"
            └── name: :X
prism-1.5.1/snapshots/seattlerb/cond_unary_minus.txt000066400000000000000000000013161506127434000227770ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,10))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ IfNode (location: (1,0)-(1,10))
            ├── flags: newline
            ├── if_keyword_loc: (1,0)-(1,2) = "if"
            ├── predicate:
            │   @ IntegerNode (location: (1,3)-(1,5))
            │   ├── flags: static_literal, decimal
            │   └── value: -1
            ├── then_keyword_loc: ∅
            ├── statements: ∅
            ├── subsequent: ∅
            └── end_keyword_loc: (1,7)-(1,10) = "end"
prism-1.5.1/snapshots/seattlerb/const_2_op_asgn_or2.txt000066400000000000000000000022561506127434000232660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ConstantPathOrWriteNode (location: (1,0)-(1,12))
            ├── flags: newline
            ├── target:
            │   @ ConstantPathNode (location: (1,0)-(1,6))
            │   ├── flags: ∅
            │   ├── parent:
            │   │   @ ConstantPathNode (location: (1,0)-(1,3))
            │   │   ├── flags: ∅
            │   │   ├── parent: ∅
            │   │   ├── name: :X
            │   │   ├── delimiter_loc: (1,0)-(1,2) = "::"
            │   │   └── name_loc: (1,2)-(1,3) = "X"
            │   ├── name: :Y
            │   ├── delimiter_loc: (1,3)-(1,5) = "::"
            │   └── name_loc: (1,5)-(1,6) = "Y"
            ├── operator_loc: (1,7)-(1,10) = "||="
            └── value:
                @ IntegerNode (location: (1,11)-(1,12))
                ├── flags: static_literal, decimal
                └── value: 1
prism-1.5.1/snapshots/seattlerb/const_3_op_asgn_or.txt000066400000000000000000000015411506127434000232010ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ConstantPathOrWriteNode (location: (1,0)-(1,9))
            ├── flags: newline
            ├── target:
            │   @ ConstantPathNode (location: (1,0)-(1,3))
            │   ├── flags: ∅
            │   ├── parent: ∅
            │   ├── name: :X
            │   ├── delimiter_loc: (1,0)-(1,2) = "::"
            │   └── name_loc: (1,2)-(1,3) = "X"
            ├── operator_loc: (1,4)-(1,7) = "||="
            └── value:
                @ IntegerNode (location: (1,8)-(1,9))
                ├── flags: static_literal, decimal
                └── value: 1
prism-1.5.1/snapshots/seattlerb/const_op_asgn_and1.txt000066400000000000000000000016351506127434000231660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ConstantPathOperatorWriteNode (location: (1,0)-(1,8))
            ├── flags: newline
            ├── target:
            │   @ ConstantPathNode (location: (1,0)-(1,3))
            │   ├── flags: ∅
            │   ├── parent: ∅
            │   ├── name: :X
            │   ├── delimiter_loc: (1,0)-(1,2) = "::"
            │   └── name_loc: (1,2)-(1,3) = "X"
            ├── binary_operator_loc: (1,4)-(1,6) = "&="
            ├── value:
            │   @ IntegerNode (location: (1,7)-(1,8))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            └── binary_operator: :&
prism-1.5.1/snapshots/seattlerb/const_op_asgn_and2.txt000066400000000000000000000015421506127434000231640ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ConstantPathAndWriteNode (location: (1,0)-(1,9))
            ├── flags: newline
            ├── target:
            │   @ ConstantPathNode (location: (1,0)-(1,3))
            │   ├── flags: ∅
            │   ├── parent: ∅
            │   ├── name: :X
            │   ├── delimiter_loc: (1,0)-(1,2) = "::"
            │   └── name_loc: (1,2)-(1,3) = "X"
            ├── operator_loc: (1,4)-(1,7) = "&&="
            └── value:
                @ IntegerNode (location: (1,8)-(1,9))
                ├── flags: static_literal, decimal
                └── value: 1
prism-1.5.1/snapshots/seattlerb/const_op_asgn_or.txt000066400000000000000000000017741506127434000227670ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,10))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ConstantPathOrWriteNode (location: (1,0)-(1,10))
            ├── flags: newline
            ├── target:
            │   @ ConstantPathNode (location: (1,0)-(1,4))
            │   ├── flags: ∅
            │   ├── parent:
            │   │   @ ConstantReadNode (location: (1,0)-(1,1))
            │   │   ├── flags: ∅
            │   │   └── name: :X
            │   ├── name: :Y
            │   ├── delimiter_loc: (1,1)-(1,3) = "::"
            │   └── name_loc: (1,3)-(1,4) = "Y"
            ├── operator_loc: (1,5)-(1,8) = "||="
            └── value:
                @ IntegerNode (location: (1,9)-(1,10))
                ├── flags: static_literal, decimal
                └── value: 1
prism-1.5.1/snapshots/seattlerb/defined_eh_parens.txt000066400000000000000000000012111506127434000230370ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefinedNode (location: (1,0)-(1,12))
            ├── flags: newline
            ├── lparen_loc: (1,8)-(1,9) = "("
            ├── value:
            │   @ IntegerNode (location: (1,9)-(1,11))
            │   ├── flags: static_literal, decimal
            │   └── value: 42
            ├── rparen_loc: (1,11)-(1,12) = ")"
            └── keyword_loc: (1,0)-(1,8) = "defined?"
prism-1.5.1/snapshots/seattlerb/defn_arg_asplat_arg.txt000066400000000000000000000035461506127434000233740ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,29))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,29))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,29))
            ├── flags: newline
            ├── name: :call
            ├── name_loc: (1,4)-(1,8) = "call"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,9)-(1,24))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (1,9)-(1,15))
            │   │       ├── flags: ∅
            │   │       └── name: :interp
            │   ├── optionals: (length: 0)
            │   ├── rest:
            │   │   @ RestParameterNode (location: (1,17)-(1,18))
            │   │   ├── flags: ∅
            │   │   ├── name: ∅
            │   │   ├── name_loc: ∅
            │   │   └── operator_loc: (1,17)-(1,18) = "*"
            │   ├── posts: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (1,20)-(1,24))
            │   │       ├── flags: ∅
            │   │       └── name: :args
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:interp, :args]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,8)-(1,9) = "("
            ├── rparen_loc: (1,24)-(1,25) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,26)-(1,29) = "end"
prism-1.5.1/snapshots/seattlerb/defn_arg_forward_args.txt000066400000000000000000000055441506127434000237370ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,29))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,29))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,29))
            ├── flags: newline
            ├── name: :a
            ├── name_loc: (1,4)-(1,5) = "a"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,12))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (1,6)-(1,7))
            │   │       ├── flags: ∅
            │   │       └── name: :x
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ ForwardingParameterNode (location: (1,9)-(1,12))
            │   │   └── flags: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,15)-(1,24))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,15)-(1,24))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :b
            │           ├── message_loc: (1,15)-(1,16) = "b"
            │           ├── opening_loc: (1,16)-(1,17) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,17)-(1,23))
            │           │   ├── flags: contains_forwarding
            │           │   └── arguments: (length: 2)
            │           │       ├── @ LocalVariableReadNode (location: (1,17)-(1,18))
            │           │       │   ├── flags: ∅
            │           │       │   ├── name: :x
            │           │       │   └── depth: 0
            │           │       └── @ ForwardingArgumentsNode (location: (1,20)-(1,23))
            │           │           └── flags: ∅
            │           ├── closing_loc: (1,23)-(1,24) = ")"
            │           └── block: ∅
            ├── locals: [:x]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,12)-(1,13) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,26)-(1,29) = "end"
prism-1.5.1/snapshots/seattlerb/defn_args_forward_args.txt000066400000000000000000000073111506127434000241140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,41))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,41))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,41))
            ├── flags: newline
            ├── name: :a
            ├── name_loc: (1,4)-(1,5) = "a"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,18))
            │   ├── flags: ∅
            │   ├── requireds: (length: 3)
            │   │   ├── @ RequiredParameterNode (location: (1,6)-(1,7))
            │   │   │   ├── flags: ∅
            │   │   │   └── name: :x
            │   │   ├── @ RequiredParameterNode (location: (1,9)-(1,10))
            │   │   │   ├── flags: ∅
            │   │   │   └── name: :y
            │   │   └── @ RequiredParameterNode (location: (1,12)-(1,13))
            │   │       ├── flags: ∅
            │   │       └── name: :z
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ ForwardingParameterNode (location: (1,15)-(1,18))
            │   │   └── flags: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,21)-(1,36))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,21)-(1,36))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :b
            │           ├── message_loc: (1,21)-(1,22) = "b"
            │           ├── opening_loc: (1,22)-(1,23) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,23)-(1,35))
            │           │   ├── flags: contains_forwarding
            │           │   └── arguments: (length: 3)
            │           │       ├── @ SymbolNode (location: (1,23)-(1,27))
            │           │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │           │       │   ├── opening_loc: (1,23)-(1,24) = ":"
            │           │       │   ├── value_loc: (1,24)-(1,27) = "get"
            │           │       │   ├── closing_loc: ∅
            │           │       │   └── unescaped: "get"
            │           │       ├── @ LocalVariableReadNode (location: (1,29)-(1,30))
            │           │       │   ├── flags: ∅
            │           │       │   ├── name: :z
            │           │       │   └── depth: 0
            │           │       └── @ ForwardingArgumentsNode (location: (1,32)-(1,35))
            │           │           └── flags: ∅
            │           ├── closing_loc: (1,35)-(1,36) = ")"
            │           └── block: ∅
            ├── locals: [:x, :y, :z]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,18)-(1,19) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,38)-(1,41) = "end"
prism-1.5.1/snapshots/seattlerb/defn_comments.txt000066400000000000000000000014261506127434000222460ustar00rootroot00000000000000@ ProgramNode (location: (4,0)-(5,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (4,0)-(5,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (4,0)-(5,3))
            ├── flags: newline
            ├── name: :blah
            ├── name_loc: (4,4)-(4,8) = "blah"
            ├── receiver: ∅
            ├── parameters: ∅
            ├── body: ∅
            ├── locals: []
            ├── def_keyword_loc: (4,0)-(4,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (5,0)-(5,3) = "end"
prism-1.5.1/snapshots/seattlerb/defn_endless_command.txt000066400000000000000000000036301506127434000235530ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,33))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,33))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,33))
            ├── flags: newline
            ├── name: :some_method
            ├── name_loc: (1,4)-(1,15) = "some_method"
            ├── receiver: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (1,18)-(1,33))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,18)-(1,33))
            │           ├── flags: ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :other_method
            │           ├── message_loc: (1,18)-(1,30) = "other_method"
            │           ├── opening_loc: ∅
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,31)-(1,33))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 1)
            │           │       └── @ IntegerNode (location: (1,31)-(1,33))
            │           │           ├── flags: static_literal, decimal
            │           │           └── value: 42
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: (1,16)-(1,17) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/seattlerb/defn_endless_command_rescue.txt000066400000000000000000000047401506127434000251240ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,43))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,43))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,43))
            ├── flags: newline
            ├── name: :some_method
            ├── name_loc: (1,4)-(1,15) = "some_method"
            ├── receiver: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (1,18)-(1,43))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ RescueModifierNode (location: (1,18)-(1,43))
            │           ├── flags: ∅
            │           ├── expression:
            │           │   @ CallNode (location: (1,18)-(1,33))
            │           │   ├── flags: ignore_visibility
            │           │   ├── receiver: ∅
            │           │   ├── call_operator_loc: ∅
            │           │   ├── name: :other_method
            │           │   ├── message_loc: (1,18)-(1,30) = "other_method"
            │           │   ├── opening_loc: ∅
            │           │   ├── arguments:
            │           │   │   @ ArgumentsNode (location: (1,31)-(1,33))
            │           │   │   ├── flags: ∅
            │           │   │   └── arguments: (length: 1)
            │           │   │       └── @ IntegerNode (location: (1,31)-(1,33))
            │           │   │           ├── flags: static_literal, decimal
            │           │   │           └── value: 42
            │           │   ├── closing_loc: ∅
            │           │   └── block: ∅
            │           ├── keyword_loc: (1,34)-(1,40) = "rescue"
            │           └── rescue_expression:
            │               @ IntegerNode (location: (1,41)-(1,43))
            │               ├── flags: static_literal, decimal
            │               └── value: 24
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: (1,16)-(1,17) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/seattlerb/defn_forward_args.txt000066400000000000000000000046241506127434000231040ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,23))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,23))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,23))
            ├── flags: newline
            ├── name: :a
            ├── name_loc: (1,4)-(1,5) = "a"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,9))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ ForwardingParameterNode (location: (1,6)-(1,9))
            │   │   └── flags: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,12)-(1,18))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,12)-(1,18))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :b
            │           ├── message_loc: (1,12)-(1,13) = "b"
            │           ├── opening_loc: (1,13)-(1,14) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,14)-(1,17))
            │           │   ├── flags: contains_forwarding
            │           │   └── arguments: (length: 1)
            │           │       └── @ ForwardingArgumentsNode (location: (1,14)-(1,17))
            │           │           └── flags: ∅
            │           ├── closing_loc: (1,17)-(1,18) = ")"
            │           └── block: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,9)-(1,10) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,20)-(1,23) = "end"
prism-1.5.1/snapshots/seattlerb/defn_forward_args__no_parens.txt000066400000000000000000000045441506127434000253100ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(3,3))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (1,4)-(1,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,9))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ ForwardingParameterNode (location: (1,6)-(1,9))
            │   │   └── flags: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (2,2)-(2,8))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (2,2)-(2,8))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :m
            │           ├── message_loc: (2,2)-(2,3) = "m"
            │           ├── opening_loc: (2,3)-(2,4) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (2,4)-(2,7))
            │           │   ├── flags: contains_forwarding
            │           │   └── arguments: (length: 1)
            │           │       └── @ ForwardingArgumentsNode (location: (2,4)-(2,7))
            │           │           └── flags: ∅
            │           ├── closing_loc: (2,7)-(2,8) = ")"
            │           └── block: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (3,0)-(3,3) = "end"
prism-1.5.1/snapshots/seattlerb/defn_kwarg_env.txt000066400000000000000000000065301506127434000224050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,45))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,45))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,45))
            ├── flags: newline
            ├── name: :test
            ├── name_loc: (1,4)-(1,8) = "test"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,9)-(1,18))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ KeywordRestParameterNode (location: (1,9)-(1,18))
            │   │   ├── flags: ∅
            │   │   ├── name: :testing
            │   │   ├── name_loc: (1,11)-(1,18) = "testing"
            │   │   └── operator_loc: (1,9)-(1,11) = "**"
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,20)-(1,41))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,20)-(1,41))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :test_splat
            │           ├── message_loc: (1,20)-(1,30) = "test_splat"
            │           ├── opening_loc: (1,30)-(1,31) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,31)-(1,40))
            │           │   ├── flags: contains_keywords, contains_keyword_splat
            │           │   └── arguments: (length: 1)
            │           │       └── @ KeywordHashNode (location: (1,31)-(1,40))
            │           │           ├── flags: ∅
            │           │           └── elements: (length: 1)
            │           │               └── @ AssocSplatNode (location: (1,31)-(1,40))
            │           │                   ├── flags: ∅
            │           │                   ├── value:
            │           │                   │   @ LocalVariableReadNode (location: (1,33)-(1,40))
            │           │                   │   ├── flags: ∅
            │           │                   │   ├── name: :testing
            │           │                   │   └── depth: 0
            │           │                   └── operator_loc: (1,31)-(1,33) = "**"
            │           ├── closing_loc: (1,40)-(1,41) = ")"
            │           └── block: ∅
            ├── locals: [:testing]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,8)-(1,9) = "("
            ├── rparen_loc: (1,18)-(1,19) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,42)-(1,45) = "end"
prism-1.5.1/snapshots/seattlerb/defn_kwarg_kwarg.txt000066400000000000000000000045761506127434000227400ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,24))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,24))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,24))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (1,4)-(1,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,19))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (1,6)-(1,7))
            │   │       ├── flags: ∅
            │   │       └── name: :a
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 2)
            │   │   ├── @ OptionalKeywordParameterNode (location: (1,9)-(1,13))
            │   │   │   ├── flags: ∅
            │   │   │   ├── name: :b
            │   │   │   ├── name_loc: (1,9)-(1,11) = "b:"
            │   │   │   └── value:
            │   │   │       @ IntegerNode (location: (1,12)-(1,13))
            │   │   │       ├── flags: static_literal, decimal
            │   │   │       └── value: 1
            │   │   └── @ OptionalKeywordParameterNode (location: (1,15)-(1,19))
            │   │       ├── flags: ∅
            │   │       ├── name: :c
            │   │       ├── name_loc: (1,15)-(1,17) = "c:"
            │   │       └── value:
            │   │           @ IntegerNode (location: (1,18)-(1,19))
            │   │           ├── flags: static_literal, decimal
            │   │           └── value: 2
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:a, :b, :c]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,19)-(1,20) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,21)-(1,24) = "end"
prism-1.5.1/snapshots/seattlerb/defn_kwarg_kwsplat.txt000066400000000000000000000037551506127434000233100ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,20))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,20))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,20))
            ├── flags: newline
            ├── name: :a
            ├── name_loc: (1,4)-(1,5) = "a"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,15))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 1)
            │   │   └── @ OptionalKeywordParameterNode (location: (1,6)-(1,10))
            │   │       ├── flags: ∅
            │   │       ├── name: :b
            │   │       ├── name_loc: (1,6)-(1,8) = "b:"
            │   │       └── value:
            │   │           @ IntegerNode (location: (1,9)-(1,10))
            │   │           ├── flags: static_literal, decimal
            │   │           └── value: 1
            │   ├── keyword_rest:
            │   │   @ KeywordRestParameterNode (location: (1,12)-(1,15))
            │   │   ├── flags: ∅
            │   │   ├── name: :c
            │   │   ├── name_loc: (1,14)-(1,15) = "c"
            │   │   └── operator_loc: (1,12)-(1,14) = "**"
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:b, :c]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,15)-(1,16) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,17)-(1,20) = "end"
prism-1.5.1/snapshots/seattlerb/defn_kwarg_kwsplat_anon.txt000066400000000000000000000037321506127434000243160ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,19))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,19))
            ├── flags: newline
            ├── name: :a
            ├── name_loc: (1,4)-(1,5) = "a"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,14))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 1)
            │   │   └── @ OptionalKeywordParameterNode (location: (1,6)-(1,10))
            │   │       ├── flags: ∅
            │   │       ├── name: :b
            │   │       ├── name_loc: (1,6)-(1,8) = "b:"
            │   │       └── value:
            │   │           @ IntegerNode (location: (1,9)-(1,10))
            │   │           ├── flags: static_literal, decimal
            │   │           └── value: 1
            │   ├── keyword_rest:
            │   │   @ KeywordRestParameterNode (location: (1,12)-(1,14))
            │   │   ├── flags: ∅
            │   │   ├── name: ∅
            │   │   ├── name_loc: ∅
            │   │   └── operator_loc: (1,12)-(1,14) = "**"
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:b]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,14)-(1,15) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,16)-(1,19) = "end"
prism-1.5.1/snapshots/seattlerb/defn_kwarg_lvar.txt000066400000000000000000000044431506127434000225620ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,26))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,26))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,26))
            ├── flags: newline
            ├── name: :fun
            ├── name_loc: (1,4)-(1,7) = "fun"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,8)-(1,16))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 1)
            │   │   └── @ OptionalKeywordParameterNode (location: (1,8)-(1,16))
            │   │       ├── flags: ∅
            │   │       ├── name: :kw
            │   │       ├── name_loc: (1,8)-(1,11) = "kw:"
            │   │       └── value:
            │   │           @ SymbolNode (location: (1,12)-(1,16))
            │   │           ├── flags: static_literal, forced_us_ascii_encoding
            │   │           ├── opening_loc: (1,12)-(1,13) = ":"
            │   │           ├── value_loc: (1,13)-(1,16) = "val"
            │   │           ├── closing_loc: ∅
            │   │           └── unescaped: "val"
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,19)-(1,21))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ LocalVariableReadNode (location: (1,19)-(1,21))
            │           ├── flags: newline
            │           ├── name: :kw
            │           └── depth: 0
            ├── locals: [:kw]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,7)-(1,8) = "("
            ├── rparen_loc: (1,16)-(1,17) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,23)-(1,26) = "end"
prism-1.5.1/snapshots/seattlerb/defn_kwarg_no_parens.txt000066400000000000000000000032401506127434000235740ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(2,3))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (1,4)-(1,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,10))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 1)
            │   │   └── @ OptionalKeywordParameterNode (location: (1,6)-(1,10))
            │   │       ├── flags: ∅
            │   │       ├── name: :a
            │   │       ├── name_loc: (1,6)-(1,8) = "a:"
            │   │       └── value:
            │   │           @ IntegerNode (location: (1,9)-(1,10))
            │   │           ├── flags: static_literal, decimal
            │   │           └── value: 1
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:a]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (2,0)-(2,3) = "end"
prism-1.5.1/snapshots/seattlerb/defn_kwarg_val.txt000066400000000000000000000035731506127434000224030ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,17))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (1,4)-(1,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,12))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (1,6)-(1,7))
            │   │       ├── flags: ∅
            │   │       └── name: :a
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 1)
            │   │   └── @ OptionalKeywordParameterNode (location: (1,9)-(1,12))
            │   │       ├── flags: ∅
            │   │       ├── name: :b
            │   │       ├── name_loc: (1,9)-(1,11) = "b:"
            │   │       └── value:
            │   │           @ IntegerNode (location: (1,11)-(1,12))
            │   │           ├── flags: static_literal, decimal
            │   │           └── value: 1
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:a, :b]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,12)-(1,13) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,14)-(1,17) = "end"
prism-1.5.1/snapshots/seattlerb/defn_no_kwargs.txt000066400000000000000000000027171506127434000224170ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,17))
            ├── flags: newline
            ├── name: :x
            ├── name_loc: (1,4)-(1,5) = "x"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,11))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ NoKeywordsParameterNode (location: (1,6)-(1,11))
            │   │   ├── flags: ∅
            │   │   ├── operator_loc: (1,6)-(1,8) = "**"
            │   │   └── keyword_loc: (1,8)-(1,11) = "nil"
            │   └── block: ∅
            ├── body: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,11)-(1,12) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,14)-(1,17) = "end"
prism-1.5.1/snapshots/seattlerb/defn_oneliner.txt000066400000000000000000000051071506127434000222340ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,27))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,27))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,27))
            ├── flags: newline
            ├── name: :exec
            ├── name_loc: (1,4)-(1,8) = "exec"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,9)-(1,12))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (1,9)-(1,12))
            │   │       ├── flags: ∅
            │   │       └── name: :cmd
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,16)-(1,27))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,16)-(1,27))
            │           ├── flags: ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :system
            │           ├── message_loc: (1,16)-(1,22) = "system"
            │           ├── opening_loc: (1,22)-(1,23) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,23)-(1,26))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 1)
            │           │       └── @ LocalVariableReadNode (location: (1,23)-(1,26))
            │           │           ├── flags: ∅
            │           │           ├── name: :cmd
            │           │           └── depth: 0
            │           ├── closing_loc: (1,26)-(1,27) = ")"
            │           └── block: ∅
            ├── locals: [:cmd]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,8)-(1,9) = "("
            ├── rparen_loc: (1,12)-(1,13) = ")"
            ├── equal_loc: (1,14)-(1,15) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/seattlerb/defn_oneliner_eq2.txt000066400000000000000000000055301506127434000230030ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ClassNode (location: (1,0)-(3,3))
            ├── flags: newline
            ├── locals: []
            ├── class_keyword_loc: (1,0)-(1,5) = "class"
            ├── constant_path:
            │   @ ConstantReadNode (location: (1,6)-(1,7))
            │   ├── flags: ∅
            │   └── name: :X
            ├── inheritance_operator_loc: ∅
            ├── superclass: ∅
            ├── body:
            │   @ StatementsNode (location: (2,2)-(2,16))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ DefNode (location: (2,2)-(2,16))
            │           ├── flags: newline
            │           ├── name: :==
            │           ├── name_loc: (2,6)-(2,8) = "=="
            │           ├── receiver: ∅
            │           ├── parameters:
            │           │   @ ParametersNode (location: (2,9)-(2,10))
            │           │   ├── flags: ∅
            │           │   ├── requireds: (length: 1)
            │           │   │   └── @ RequiredParameterNode (location: (2,9)-(2,10))
            │           │   │       ├── flags: ∅
            │           │   │       └── name: :o
            │           │   ├── optionals: (length: 0)
            │           │   ├── rest: ∅
            │           │   ├── posts: (length: 0)
            │           │   ├── keywords: (length: 0)
            │           │   ├── keyword_rest: ∅
            │           │   └── block: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (2,14)-(2,16))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ IntegerNode (location: (2,14)-(2,16))
            │           │           ├── flags: static_literal, decimal
            │           │           └── value: 42
            │           ├── locals: [:o]
            │           ├── def_keyword_loc: (2,2)-(2,5) = "def"
            │           ├── operator_loc: ∅
            │           ├── lparen_loc: (2,8)-(2,9) = "("
            │           ├── rparen_loc: (2,10)-(2,11) = ")"
            │           ├── equal_loc: (2,12)-(2,13) = "="
            │           └── end_keyword_loc: ∅
            ├── end_keyword_loc: (3,0)-(3,3) = "end"
            └── name: :X
prism-1.5.1/snapshots/seattlerb/defn_oneliner_noargs.txt000066400000000000000000000027541506127434000236120ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,17))
            ├── flags: newline
            ├── name: :exec
            ├── name_loc: (1,4)-(1,8) = "exec"
            ├── receiver: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (1,11)-(1,17))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,11)-(1,17))
            │           ├── flags: variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :system
            │           ├── message_loc: (1,11)-(1,17) = "system"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: (1,9)-(1,10) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/seattlerb/defn_oneliner_noargs_parentheses.txt000066400000000000000000000030121506127434000261770ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,19))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,19))
            ├── flags: newline
            ├── name: :exec
            ├── name_loc: (1,4)-(1,8) = "exec"
            ├── receiver: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (1,13)-(1,19))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,13)-(1,19))
            │           ├── flags: variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :system
            │           ├── message_loc: (1,13)-(1,19) = "system"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,8)-(1,9) = "("
            ├── rparen_loc: (1,9)-(1,10) = ")"
            ├── equal_loc: (1,11)-(1,12) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/seattlerb/defn_oneliner_rescue.txt000066400000000000000000000236301506127434000236030ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(13,38))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(13,38))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ DefNode (location: (1,0)-(5,3))
        │   ├── flags: newline
        │   ├── name: :exec
        │   ├── name_loc: (1,4)-(1,8) = "exec"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (1,9)-(1,12))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (1,9)-(1,12))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :cmd
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (1,0)-(5,3))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (2,2)-(2,13))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (2,2)-(2,13))
        │   │   │           ├── flags: newline, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :system
        │   │   │           ├── message_loc: (2,2)-(2,8) = "system"
        │   │   │           ├── opening_loc: (2,8)-(2,9) = "("
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (2,9)-(2,12))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ LocalVariableReadNode (location: (2,9)-(2,12))
        │   │   │           │           ├── flags: ∅
        │   │   │           │           ├── name: :cmd
        │   │   │           │           └── depth: 0
        │   │   │           ├── closing_loc: (2,12)-(2,13) = ")"
        │   │   │           └── block: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (3,0)-(4,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (3,0)-(3,6) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (4,2)-(4,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ NilNode (location: (4,2)-(4,5))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   └── subsequent: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause: ∅
        │   │   └── end_keyword_loc: (5,0)-(5,3) = "end"
        │   ├── locals: [:cmd]
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (1,8)-(1,9) = "("
        │   ├── rparen_loc: (1,12)-(1,13) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (5,0)-(5,3) = "end"
        ├── @ DefNode (location: (8,0)-(10,3))
        │   ├── flags: newline
        │   ├── name: :exec
        │   ├── name_loc: (8,4)-(8,8) = "exec"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (8,9)-(8,12))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (8,9)-(8,12))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :cmd
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (9,2)-(9,24))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ RescueModifierNode (location: (9,2)-(9,24))
        │   │           ├── flags: newline
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (9,2)-(9,13))
        │   │           │   ├── flags: ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :system
        │   │           │   ├── message_loc: (9,2)-(9,8) = "system"
        │   │           │   ├── opening_loc: (9,8)-(9,9) = "("
        │   │           │   ├── arguments:
        │   │           │   │   @ ArgumentsNode (location: (9,9)-(9,12))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   └── arguments: (length: 1)
        │   │           │   │       └── @ LocalVariableReadNode (location: (9,9)-(9,12))
        │   │           │   │           ├── flags: ∅
        │   │           │   │           ├── name: :cmd
        │   │           │   │           └── depth: 0
        │   │           │   ├── closing_loc: (9,12)-(9,13) = ")"
        │   │           │   └── block: ∅
        │   │           ├── keyword_loc: (9,14)-(9,20) = "rescue"
        │   │           └── rescue_expression:
        │   │               @ NilNode (location: (9,21)-(9,24))
        │   │               └── flags: static_literal
        │   ├── locals: [:cmd]
        │   ├── def_keyword_loc: (8,0)-(8,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (8,8)-(8,9) = "("
        │   ├── rparen_loc: (8,12)-(8,13) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (10,0)-(10,3) = "end"
        └── @ DefNode (location: (13,0)-(13,38))
            ├── flags: newline
            ├── name: :exec
            ├── name_loc: (13,4)-(13,8) = "exec"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (13,9)-(13,12))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (13,9)-(13,12))
            │   │       ├── flags: ∅
            │   │       └── name: :cmd
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (13,16)-(13,38))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ RescueModifierNode (location: (13,16)-(13,38))
            │           ├── flags: ∅
            │           ├── expression:
            │           │   @ CallNode (location: (13,16)-(13,27))
            │           │   ├── flags: ignore_visibility
            │           │   ├── receiver: ∅
            │           │   ├── call_operator_loc: ∅
            │           │   ├── name: :system
            │           │   ├── message_loc: (13,16)-(13,22) = "system"
            │           │   ├── opening_loc: (13,22)-(13,23) = "("
            │           │   ├── arguments:
            │           │   │   @ ArgumentsNode (location: (13,23)-(13,26))
            │           │   │   ├── flags: ∅
            │           │   │   └── arguments: (length: 1)
            │           │   │       └── @ LocalVariableReadNode (location: (13,23)-(13,26))
            │           │   │           ├── flags: ∅
            │           │   │           ├── name: :cmd
            │           │   │           └── depth: 0
            │           │   ├── closing_loc: (13,26)-(13,27) = ")"
            │           │   └── block: ∅
            │           ├── keyword_loc: (13,28)-(13,34) = "rescue"
            │           └── rescue_expression:
            │               @ NilNode (location: (13,35)-(13,38))
            │               └── flags: static_literal
            ├── locals: [:cmd]
            ├── def_keyword_loc: (13,0)-(13,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (13,8)-(13,9) = "("
            ├── rparen_loc: (13,12)-(13,13) = ")"
            ├── equal_loc: (13,14)-(13,15) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/seattlerb/defn_opt_last_arg.txt000066400000000000000000000032511506127434000230750ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(2,3))
            ├── flags: newline
            ├── name: :m
            ├── name_loc: (1,4)-(1,5) = "m"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,17))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 1)
            │   │   └── @ OptionalParameterNode (location: (1,6)-(1,17))
            │   │       ├── flags: ∅
            │   │       ├── name: :arg
            │   │       ├── name_loc: (1,6)-(1,9) = "arg"
            │   │       ├── operator_loc: (1,10)-(1,11) = "="
            │   │       └── value:
            │   │           @ FalseNode (location: (1,12)-(1,17))
            │   │           └── flags: static_literal
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:arg]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (2,0)-(2,3) = "end"
prism-1.5.1/snapshots/seattlerb/defn_opt_reg.txt000066400000000000000000000035711506127434000220630ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,19))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,19))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (1,4)-(1,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,14))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 1)
            │   │   └── @ OptionalParameterNode (location: (1,6)-(1,11))
            │   │       ├── flags: ∅
            │   │       ├── name: :a
            │   │       ├── name_loc: (1,6)-(1,7) = "a"
            │   │       ├── operator_loc: (1,7)-(1,8) = "="
            │   │       └── value:
            │   │           @ NilNode (location: (1,8)-(1,11))
            │   │           └── flags: static_literal
            │   ├── rest: ∅
            │   ├── posts: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (1,13)-(1,14))
            │   │       ├── flags: ∅
            │   │       └── name: :b
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:a, :b]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,14)-(1,15) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,16)-(1,19) = "end"
prism-1.5.1/snapshots/seattlerb/defn_opt_splat_arg.txt000066400000000000000000000043351506127434000232610ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,24))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,24))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,24))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (1,4)-(1,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,7)-(1,19))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 1)
            │   │   └── @ OptionalParameterNode (location: (1,7)-(1,12))
            │   │       ├── flags: ∅
            │   │       ├── name: :a
            │   │       ├── name_loc: (1,7)-(1,8) = "a"
            │   │       ├── operator_loc: (1,9)-(1,10) = "="
            │   │       └── value:
            │   │           @ IntegerNode (location: (1,11)-(1,12))
            │   │           ├── flags: static_literal, decimal
            │   │           └── value: 1
            │   ├── rest:
            │   │   @ RestParameterNode (location: (1,14)-(1,16))
            │   │   ├── flags: ∅
            │   │   ├── name: :b
            │   │   ├── name_loc: (1,15)-(1,16) = "b"
            │   │   └── operator_loc: (1,14)-(1,15) = "*"
            │   ├── posts: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (1,18)-(1,19))
            │   │       ├── flags: ∅
            │   │       └── name: :c
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:a, :b, :c]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,6)-(1,7) = "("
            ├── rparen_loc: (1,19)-(1,20) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,21)-(1,24) = "end"
prism-1.5.1/snapshots/seattlerb/defn_powarg.txt000066400000000000000000000030011506127434000217070ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,17))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (1,4)-(1,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,12))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ KeywordRestParameterNode (location: (1,6)-(1,12))
            │   │   ├── flags: ∅
            │   │   ├── name: :opts
            │   │   ├── name_loc: (1,8)-(1,12) = "opts"
            │   │   └── operator_loc: (1,6)-(1,8) = "**"
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:opts]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,12)-(1,13) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,14)-(1,17) = "end"
prism-1.5.1/snapshots/seattlerb/defn_reg_opt_reg.txt000066400000000000000000000045301506127434000227140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,23))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,23))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,23))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (1,4)-(1,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,18))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (1,6)-(1,7))
            │   │       ├── flags: ∅
            │   │       └── name: :a
            │   ├── optionals: (length: 1)
            │   │   └── @ OptionalParameterNode (location: (1,9)-(1,15))
            │   │       ├── flags: ∅
            │   │       ├── name: :b
            │   │       ├── name_loc: (1,9)-(1,10) = "b"
            │   │       ├── operator_loc: (1,11)-(1,12) = "="
            │   │       └── value:
            │   │           @ SymbolNode (location: (1,13)-(1,15))
            │   │           ├── flags: static_literal, forced_us_ascii_encoding
            │   │           ├── opening_loc: (1,13)-(1,14) = ":"
            │   │           ├── value_loc: (1,14)-(1,15) = "c"
            │   │           ├── closing_loc: ∅
            │   │           └── unescaped: "c"
            │   ├── rest: ∅
            │   ├── posts: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (1,17)-(1,18))
            │   │       ├── flags: ∅
            │   │       └── name: :d
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:a, :b, :d]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,18)-(1,19) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,20)-(1,23) = "end"
prism-1.5.1/snapshots/seattlerb/defn_splat_arg.txt000066400000000000000000000032241506127434000223730ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,15))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,15))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (1,4)-(1,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,10))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest:
            │   │   @ RestParameterNode (location: (1,6)-(1,7))
            │   │   ├── flags: ∅
            │   │   ├── name: ∅
            │   │   ├── name_loc: ∅
            │   │   └── operator_loc: (1,6)-(1,7) = "*"
            │   ├── posts: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
            │   │       ├── flags: ∅
            │   │       └── name: :a
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:a]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,10)-(1,11) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,12)-(1,15) = "end"
prism-1.5.1/snapshots/seattlerb/defn_unary_not.txt000066400000000000000000000020521506127434000224330ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,17))
            ├── flags: newline
            ├── name: :!
            ├── name_loc: (1,4)-(1,6) = "!@"
            ├── receiver: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (1,8)-(1,12))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ TrueNode (location: (1,8)-(1,12))
            │           └── flags: newline, static_literal
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,14)-(1,17) = "end"
prism-1.5.1/snapshots/seattlerb/defns_reserved.txt000066400000000000000000000016061506127434000224230ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,20))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,20))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,20))
            ├── flags: newline
            ├── name: :return
            ├── name_loc: (1,9)-(1,15) = "return"
            ├── receiver:
            │   @ SelfNode (location: (1,4)-(1,8))
            │   └── flags: ∅
            ├── parameters: ∅
            ├── body: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: (1,8)-(1,9) = "."
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,17)-(1,20) = "end"
prism-1.5.1/snapshots/seattlerb/defs_as_arg_with_do_block_inside.txt000066400000000000000000000074141506127434000261070ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,30))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,30))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,30))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :p
            ├── message_loc: (1,0)-(1,1) = "p"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,30))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ DefNode (location: (1,2)-(1,30))
            │           ├── flags: ∅
            │           ├── name: :b
            │           ├── name_loc: (1,11)-(1,12) = "b"
            │           ├── receiver:
            │           │   @ SelfNode (location: (1,6)-(1,10))
            │           │   └── flags: ∅
            │           ├── parameters: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (1,14)-(1,25))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ CallNode (location: (1,14)-(1,25))
            │           │           ├── flags: newline
            │           │           ├── receiver:
            │           │           │   @ CallNode (location: (1,14)-(1,15))
            │           │           │   ├── flags: variable_call, ignore_visibility
            │           │           │   ├── receiver: ∅
            │           │           │   ├── call_operator_loc: ∅
            │           │           │   ├── name: :x
            │           │           │   ├── message_loc: (1,14)-(1,15) = "x"
            │           │           │   ├── opening_loc: ∅
            │           │           │   ├── arguments: ∅
            │           │           │   ├── closing_loc: ∅
            │           │           │   └── block: ∅
            │           │           ├── call_operator_loc: (1,15)-(1,16) = "."
            │           │           ├── name: :y
            │           │           ├── message_loc: (1,16)-(1,17) = "y"
            │           │           ├── opening_loc: ∅
            │           │           ├── arguments: ∅
            │           │           ├── closing_loc: ∅
            │           │           └── block:
            │           │               @ BlockNode (location: (1,18)-(1,25))
            │           │               ├── flags: ∅
            │           │               ├── locals: []
            │           │               ├── parameters: ∅
            │           │               ├── body: ∅
            │           │               ├── opening_loc: (1,18)-(1,20) = "do"
            │           │               └── closing_loc: (1,22)-(1,25) = "end"
            │           ├── locals: []
            │           ├── def_keyword_loc: (1,2)-(1,5) = "def"
            │           ├── operator_loc: (1,10)-(1,11) = "."
            │           ├── lparen_loc: ∅
            │           ├── rparen_loc: ∅
            │           ├── equal_loc: ∅
            │           └── end_keyword_loc: (1,27)-(1,30) = "end"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/defs_comments.txt000066400000000000000000000015751506127434000222600ustar00rootroot00000000000000@ ProgramNode (location: (4,0)-(5,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (4,0)-(5,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (4,0)-(5,3))
            ├── flags: newline
            ├── name: :blah
            ├── name_loc: (4,9)-(4,13) = "blah"
            ├── receiver:
            │   @ SelfNode (location: (4,4)-(4,8))
            │   └── flags: ∅
            ├── parameters: ∅
            ├── body: ∅
            ├── locals: []
            ├── def_keyword_loc: (4,0)-(4,3) = "def"
            ├── operator_loc: (4,8)-(4,9) = "."
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (5,0)-(5,3) = "end"
prism-1.5.1/snapshots/seattlerb/defs_endless_command.txt000066400000000000000000000046041506127434000235620ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,35))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,35))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,35))
            ├── flags: newline
            ├── name: :some_method
            ├── name_loc: (1,6)-(1,17) = "some_method"
            ├── receiver:
            │   @ CallNode (location: (1,4)-(1,5))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :x
            │   ├── message_loc: (1,4)-(1,5) = "x"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (1,20)-(1,35))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,20)-(1,35))
            │           ├── flags: ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :other_method
            │           ├── message_loc: (1,20)-(1,32) = "other_method"
            │           ├── opening_loc: ∅
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,33)-(1,35))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 1)
            │           │       └── @ IntegerNode (location: (1,33)-(1,35))
            │           │           ├── flags: static_literal, decimal
            │           │           └── value: 42
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: (1,5)-(1,6) = "."
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: (1,18)-(1,19) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/seattlerb/defs_endless_command_rescue.txt000066400000000000000000000057141506127434000251330ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,45))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,45))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,45))
            ├── flags: newline
            ├── name: :some_method
            ├── name_loc: (1,6)-(1,17) = "some_method"
            ├── receiver:
            │   @ CallNode (location: (1,4)-(1,5))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :x
            │   ├── message_loc: (1,4)-(1,5) = "x"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (1,20)-(1,45))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ RescueModifierNode (location: (1,20)-(1,45))
            │           ├── flags: ∅
            │           ├── expression:
            │           │   @ CallNode (location: (1,20)-(1,35))
            │           │   ├── flags: ignore_visibility
            │           │   ├── receiver: ∅
            │           │   ├── call_operator_loc: ∅
            │           │   ├── name: :other_method
            │           │   ├── message_loc: (1,20)-(1,32) = "other_method"
            │           │   ├── opening_loc: ∅
            │           │   ├── arguments:
            │           │   │   @ ArgumentsNode (location: (1,33)-(1,35))
            │           │   │   ├── flags: ∅
            │           │   │   └── arguments: (length: 1)
            │           │   │       └── @ IntegerNode (location: (1,33)-(1,35))
            │           │   │           ├── flags: static_literal, decimal
            │           │   │           └── value: 42
            │           │   ├── closing_loc: ∅
            │           │   └── block: ∅
            │           ├── keyword_loc: (1,36)-(1,42) = "rescue"
            │           └── rescue_expression:
            │               @ IntegerNode (location: (1,43)-(1,45))
            │               ├── flags: static_literal, decimal
            │               └── value: 24
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: (1,5)-(1,6) = "."
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: (1,18)-(1,19) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/seattlerb/defs_kwarg.txt000066400000000000000000000034141506127434000215400ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(2,3))
            ├── flags: newline
            ├── name: :a
            ├── name_loc: (1,9)-(1,10) = "a"
            ├── receiver:
            │   @ SelfNode (location: (1,4)-(1,8))
            │   └── flags: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,11)-(1,15))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 1)
            │   │   └── @ OptionalKeywordParameterNode (location: (1,11)-(1,15))
            │   │       ├── flags: ∅
            │   │       ├── name: :b
            │   │       ├── name_loc: (1,11)-(1,13) = "b:"
            │   │       └── value:
            │   │           @ IntegerNode (location: (1,14)-(1,15))
            │   │           ├── flags: static_literal, decimal
            │   │           └── value: 1
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:b]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: (1,8)-(1,9) = "."
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (2,0)-(2,3) = "end"
prism-1.5.1/snapshots/seattlerb/defs_oneliner.txt000066400000000000000000000052621506127434000222430ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,32))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,32))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,32))
            ├── flags: newline
            ├── name: :exec
            ├── name_loc: (1,9)-(1,13) = "exec"
            ├── receiver:
            │   @ SelfNode (location: (1,4)-(1,8))
            │   └── flags: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,14)-(1,17))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (1,14)-(1,17))
            │   │       ├── flags: ∅
            │   │       └── name: :cmd
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,21)-(1,32))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,21)-(1,32))
            │           ├── flags: ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :system
            │           ├── message_loc: (1,21)-(1,27) = "system"
            │           ├── opening_loc: (1,27)-(1,28) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,28)-(1,31))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 1)
            │           │       └── @ LocalVariableReadNode (location: (1,28)-(1,31))
            │           │           ├── flags: ∅
            │           │           ├── name: :cmd
            │           │           └── depth: 0
            │           ├── closing_loc: (1,31)-(1,32) = ")"
            │           └── block: ∅
            ├── locals: [:cmd]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: (1,8)-(1,9) = "."
            ├── lparen_loc: (1,13)-(1,14) = "("
            ├── rparen_loc: (1,17)-(1,18) = ")"
            ├── equal_loc: (1,19)-(1,20) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/seattlerb/defs_oneliner_eq2.txt000066400000000000000000000057431506127434000230160ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ClassNode (location: (1,0)-(3,3))
            ├── flags: newline
            ├── locals: []
            ├── class_keyword_loc: (1,0)-(1,5) = "class"
            ├── constant_path:
            │   @ ConstantReadNode (location: (1,6)-(1,7))
            │   ├── flags: ∅
            │   └── name: :X
            ├── inheritance_operator_loc: ∅
            ├── superclass: ∅
            ├── body:
            │   @ StatementsNode (location: (2,2)-(2,21))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ DefNode (location: (2,2)-(2,21))
            │           ├── flags: newline
            │           ├── name: :==
            │           ├── name_loc: (2,11)-(2,13) = "=="
            │           ├── receiver:
            │           │   @ SelfNode (location: (2,6)-(2,10))
            │           │   └── flags: ∅
            │           ├── parameters:
            │           │   @ ParametersNode (location: (2,14)-(2,15))
            │           │   ├── flags: ∅
            │           │   ├── requireds: (length: 1)
            │           │   │   └── @ RequiredParameterNode (location: (2,14)-(2,15))
            │           │   │       ├── flags: ∅
            │           │   │       └── name: :o
            │           │   ├── optionals: (length: 0)
            │           │   ├── rest: ∅
            │           │   ├── posts: (length: 0)
            │           │   ├── keywords: (length: 0)
            │           │   ├── keyword_rest: ∅
            │           │   └── block: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (2,19)-(2,21))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ IntegerNode (location: (2,19)-(2,21))
            │           │           ├── flags: static_literal, decimal
            │           │           └── value: 42
            │           ├── locals: [:o]
            │           ├── def_keyword_loc: (2,2)-(2,5) = "def"
            │           ├── operator_loc: (2,10)-(2,11) = "."
            │           ├── lparen_loc: (2,13)-(2,14) = "("
            │           ├── rparen_loc: (2,15)-(2,16) = ")"
            │           ├── equal_loc: (2,17)-(2,18) = "="
            │           └── end_keyword_loc: ∅
            ├── end_keyword_loc: (3,0)-(3,3) = "end"
            └── name: :X
prism-1.5.1/snapshots/seattlerb/defs_oneliner_rescue.txt000066400000000000000000000243451506127434000236140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(13,43))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(13,43))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ DefNode (location: (1,0)-(5,3))
        │   ├── flags: newline
        │   ├── name: :exec
        │   ├── name_loc: (1,9)-(1,13) = "exec"
        │   ├── receiver:
        │   │   @ SelfNode (location: (1,4)-(1,8))
        │   │   └── flags: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (1,14)-(1,17))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (1,14)-(1,17))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :cmd
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (1,0)-(5,3))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (2,2)-(2,13))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (2,2)-(2,13))
        │   │   │           ├── flags: newline, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :system
        │   │   │           ├── message_loc: (2,2)-(2,8) = "system"
        │   │   │           ├── opening_loc: (2,8)-(2,9) = "("
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (2,9)-(2,12))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ LocalVariableReadNode (location: (2,9)-(2,12))
        │   │   │           │           ├── flags: ∅
        │   │   │           │           ├── name: :cmd
        │   │   │           │           └── depth: 0
        │   │   │           ├── closing_loc: (2,12)-(2,13) = ")"
        │   │   │           └── block: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (3,0)-(4,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (3,0)-(3,6) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (4,2)-(4,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ NilNode (location: (4,2)-(4,5))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   └── subsequent: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause: ∅
        │   │   └── end_keyword_loc: (5,0)-(5,3) = "end"
        │   ├── locals: [:cmd]
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: (1,8)-(1,9) = "."
        │   ├── lparen_loc: (1,13)-(1,14) = "("
        │   ├── rparen_loc: (1,17)-(1,18) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (5,0)-(5,3) = "end"
        ├── @ DefNode (location: (8,0)-(10,3))
        │   ├── flags: newline
        │   ├── name: :exec
        │   ├── name_loc: (8,9)-(8,13) = "exec"
        │   ├── receiver:
        │   │   @ SelfNode (location: (8,4)-(8,8))
        │   │   └── flags: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (8,14)-(8,17))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (8,14)-(8,17))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :cmd
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (9,2)-(9,24))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ RescueModifierNode (location: (9,2)-(9,24))
        │   │           ├── flags: newline
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (9,2)-(9,13))
        │   │           │   ├── flags: ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :system
        │   │           │   ├── message_loc: (9,2)-(9,8) = "system"
        │   │           │   ├── opening_loc: (9,8)-(9,9) = "("
        │   │           │   ├── arguments:
        │   │           │   │   @ ArgumentsNode (location: (9,9)-(9,12))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   └── arguments: (length: 1)
        │   │           │   │       └── @ LocalVariableReadNode (location: (9,9)-(9,12))
        │   │           │   │           ├── flags: ∅
        │   │           │   │           ├── name: :cmd
        │   │           │   │           └── depth: 0
        │   │           │   ├── closing_loc: (9,12)-(9,13) = ")"
        │   │           │   └── block: ∅
        │   │           ├── keyword_loc: (9,14)-(9,20) = "rescue"
        │   │           └── rescue_expression:
        │   │               @ NilNode (location: (9,21)-(9,24))
        │   │               └── flags: static_literal
        │   ├── locals: [:cmd]
        │   ├── def_keyword_loc: (8,0)-(8,3) = "def"
        │   ├── operator_loc: (8,8)-(8,9) = "."
        │   ├── lparen_loc: (8,13)-(8,14) = "("
        │   ├── rparen_loc: (8,17)-(8,18) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (10,0)-(10,3) = "end"
        └── @ DefNode (location: (13,0)-(13,43))
            ├── flags: newline
            ├── name: :exec
            ├── name_loc: (13,9)-(13,13) = "exec"
            ├── receiver:
            │   @ SelfNode (location: (13,4)-(13,8))
            │   └── flags: ∅
            ├── parameters:
            │   @ ParametersNode (location: (13,14)-(13,17))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (13,14)-(13,17))
            │   │       ├── flags: ∅
            │   │       └── name: :cmd
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (13,21)-(13,43))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ RescueModifierNode (location: (13,21)-(13,43))
            │           ├── flags: ∅
            │           ├── expression:
            │           │   @ CallNode (location: (13,21)-(13,32))
            │           │   ├── flags: ignore_visibility
            │           │   ├── receiver: ∅
            │           │   ├── call_operator_loc: ∅
            │           │   ├── name: :system
            │           │   ├── message_loc: (13,21)-(13,27) = "system"
            │           │   ├── opening_loc: (13,27)-(13,28) = "("
            │           │   ├── arguments:
            │           │   │   @ ArgumentsNode (location: (13,28)-(13,31))
            │           │   │   ├── flags: ∅
            │           │   │   └── arguments: (length: 1)
            │           │   │       └── @ LocalVariableReadNode (location: (13,28)-(13,31))
            │           │   │           ├── flags: ∅
            │           │   │           ├── name: :cmd
            │           │   │           └── depth: 0
            │           │   ├── closing_loc: (13,31)-(13,32) = ")"
            │           │   └── block: ∅
            │           ├── keyword_loc: (13,33)-(13,39) = "rescue"
            │           └── rescue_expression:
            │               @ NilNode (location: (13,40)-(13,43))
            │               └── flags: static_literal
            ├── locals: [:cmd]
            ├── def_keyword_loc: (13,0)-(13,3) = "def"
            ├── operator_loc: (13,8)-(13,9) = "."
            ├── lparen_loc: (13,13)-(13,14) = "("
            ├── rparen_loc: (13,17)-(13,18) = ")"
            ├── equal_loc: (13,19)-(13,20) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/seattlerb/difficult0_.txt000066400000000000000000000111541506127434000216140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(4,8))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :p
            ├── message_loc: (1,0)-(1,1) = "p"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(4,8))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ CallNode (location: (1,2)-(4,8))
            │           ├── flags: ∅
            │           ├── receiver:
            │           │   @ CallNode (location: (1,2)-(4,4))
            │           │   ├── flags: ∅
            │           │   ├── receiver:
            │           │   │   @ StringNode (location: (1,2)-(1,8))
            │           │   │   ├── flags: ∅
            │           │   │   ├── opening_loc: (1,2)-(1,8) = "<<-END"
            │           │   │   ├── content_loc: (2,0)-(3,0) = "  a\n"
            │           │   │   ├── closing_loc: (3,0)-(4,0) = "  END\n"
            │           │   │   └── unescaped: "  a\n"
            │           │   ├── call_operator_loc: ∅
            │           │   ├── name: :+
            │           │   ├── message_loc: (1,8)-(1,9) = "+"
            │           │   ├── opening_loc: ∅
            │           │   ├── arguments:
            │           │   │   @ ArgumentsNode (location: (1,9)-(4,4))
            │           │   │   ├── flags: ∅
            │           │   │   └── arguments: (length: 1)
            │           │   │       └── @ InterpolatedStringNode (location: (1,9)-(4,4))
            │           │   │           ├── flags: static_literal
            │           │   │           ├── opening_loc: (1,9)-(1,10) = "'"
            │           │   │           ├── parts: (length: 2)
            │           │   │           │   ├── @ StringNode (location: (1,10)-(2,0))
            │           │   │           │   │   ├── flags: static_literal, frozen
            │           │   │           │   │   ├── opening_loc: ∅
            │           │   │           │   │   ├── content_loc: (1,10)-(2,0) = "b\n"
            │           │   │           │   │   ├── closing_loc: ∅
            │           │   │           │   │   └── unescaped: "b\n"
            │           │   │           │   └── @ StringNode (location: (4,0)-(4,3))
            │           │   │           │       ├── flags: static_literal, frozen
            │           │   │           │       ├── opening_loc: ∅
            │           │   │           │       ├── content_loc: (4,0)-(4,3) = "  c"
            │           │   │           │       ├── closing_loc: ∅
            │           │   │           │       └── unescaped: "  c"
            │           │   │           └── closing_loc: (4,3)-(4,4) = "'"
            │           │   ├── closing_loc: ∅
            │           │   └── block: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :+
            │           ├── message_loc: (4,4)-(4,5) = "+"
            │           ├── opening_loc: ∅
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (4,5)-(4,8))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 1)
            │           │       └── @ StringNode (location: (4,5)-(4,8))
            │           │           ├── flags: ∅
            │           │           ├── opening_loc: (4,5)-(4,6) = "'"
            │           │           ├── content_loc: (4,6)-(4,7) = "d"
            │           │           ├── closing_loc: (4,7)-(4,8) = "'"
            │           │           └── unescaped: "d"
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/difficult1_line_numbers.txt000066400000000000000000000411121506127434000242150ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(12,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(12,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ IfNode (location: (1,0)-(12,3))
            ├── flags: newline
            ├── if_keyword_loc: (1,0)-(1,2) = "if"
            ├── predicate:
            │   @ TrueNode (location: (1,3)-(1,7))
            │   └── flags: static_literal
            ├── then_keyword_loc: ∅
            ├── statements:
            │   @ StatementsNode (location: (2,2)-(11,11))
            │   ├── flags: ∅
            │   └── body: (length: 10)
            │       ├── @ CallNode (location: (2,2)-(2,5))
            │       │   ├── flags: newline, ignore_visibility
            │       │   ├── receiver: ∅
            │       │   ├── call_operator_loc: ∅
            │       │   ├── name: :p
            │       │   ├── message_loc: (2,2)-(2,3) = "p"
            │       │   ├── opening_loc: ∅
            │       │   ├── arguments:
            │       │   │   @ ArgumentsNode (location: (2,4)-(2,5))
            │       │   │   ├── flags: ∅
            │       │   │   └── arguments: (length: 1)
            │       │   │       └── @ IntegerNode (location: (2,4)-(2,5))
            │       │   │           ├── flags: static_literal, decimal
            │       │   │           └── value: 1
            │       │   ├── closing_loc: ∅
            │       │   └── block: ∅
            │       ├── @ CallNode (location: (3,2)-(3,7))
            │       │   ├── flags: newline
            │       │   ├── receiver:
            │       │   │   @ CallNode (location: (3,2)-(3,3))
            │       │   │   ├── flags: variable_call, ignore_visibility
            │       │   │   ├── receiver: ∅
            │       │   │   ├── call_operator_loc: ∅
            │       │   │   ├── name: :a
            │       │   │   ├── message_loc: (3,2)-(3,3) = "a"
            │       │   │   ├── opening_loc: ∅
            │       │   │   ├── arguments: ∅
            │       │   │   ├── closing_loc: ∅
            │       │   │   └── block: ∅
            │       │   ├── call_operator_loc: (3,3)-(3,4) = "."
            │       │   ├── name: :b
            │       │   ├── message_loc: (3,4)-(3,5) = "b"
            │       │   ├── opening_loc: ∅
            │       │   ├── arguments:
            │       │   │   @ ArgumentsNode (location: (3,6)-(3,7))
            │       │   │   ├── flags: ∅
            │       │   │   └── arguments: (length: 1)
            │       │   │       └── @ IntegerNode (location: (3,6)-(3,7))
            │       │   │           ├── flags: static_literal, decimal
            │       │   │           └── value: 2
            │       │   ├── closing_loc: ∅
            │       │   └── block: ∅
            │       ├── @ CallNode (location: (4,2)-(4,10))
            │       │   ├── flags: newline
            │       │   ├── receiver:
            │       │   │   @ CallNode (location: (4,2)-(4,3))
            │       │   │   ├── flags: variable_call, ignore_visibility
            │       │   │   ├── receiver: ∅
            │       │   │   ├── call_operator_loc: ∅
            │       │   │   ├── name: :c
            │       │   │   ├── message_loc: (4,2)-(4,3) = "c"
            │       │   │   ├── opening_loc: ∅
            │       │   │   ├── arguments: ∅
            │       │   │   ├── closing_loc: ∅
            │       │   │   └── block: ∅
            │       │   ├── call_operator_loc: (4,3)-(4,4) = "."
            │       │   ├── name: :d
            │       │   ├── message_loc: (4,4)-(4,5) = "d"
            │       │   ├── opening_loc: ∅
            │       │   ├── arguments:
            │       │   │   @ ArgumentsNode (location: (4,6)-(4,10))
            │       │   │   ├── flags: ∅
            │       │   │   └── arguments: (length: 2)
            │       │   │       ├── @ IntegerNode (location: (4,6)-(4,7))
            │       │   │       │   ├── flags: static_literal, decimal
            │       │   │       │   └── value: 3
            │       │   │       └── @ IntegerNode (location: (4,9)-(4,10))
            │       │   │           ├── flags: static_literal, decimal
            │       │   │           └── value: 4
            │       │   ├── closing_loc: ∅
            │       │   └── block: ∅
            │       ├── @ CallNode (location: (5,2)-(5,7))
            │       │   ├── flags: newline
            │       │   ├── receiver:
            │       │   │   @ CallNode (location: (5,2)-(5,3))
            │       │   │   ├── flags: variable_call, ignore_visibility
            │       │   │   ├── receiver: ∅
            │       │   │   ├── call_operator_loc: ∅
            │       │   │   ├── name: :e
            │       │   │   ├── message_loc: (5,2)-(5,3) = "e"
            │       │   │   ├── opening_loc: ∅
            │       │   │   ├── arguments: ∅
            │       │   │   ├── closing_loc: ∅
            │       │   │   └── block: ∅
            │       │   ├── call_operator_loc: (5,3)-(5,4) = "."
            │       │   ├── name: :f
            │       │   ├── message_loc: (5,4)-(5,5) = "f"
            │       │   ├── opening_loc: ∅
            │       │   ├── arguments:
            │       │   │   @ ArgumentsNode (location: (5,6)-(5,7))
            │       │   │   ├── flags: ∅
            │       │   │   └── arguments: (length: 1)
            │       │   │       └── @ IntegerNode (location: (5,6)-(5,7))
            │       │   │           ├── flags: static_literal, decimal
            │       │   │           └── value: 5
            │       │   ├── closing_loc: ∅
            │       │   └── block: ∅
            │       ├── @ CallNode (location: (6,2)-(6,10))
            │       │   ├── flags: newline
            │       │   ├── receiver:
            │       │   │   @ CallNode (location: (6,2)-(6,3))
            │       │   │   ├── flags: variable_call, ignore_visibility
            │       │   │   ├── receiver: ∅
            │       │   │   ├── call_operator_loc: ∅
            │       │   │   ├── name: :g
            │       │   │   ├── message_loc: (6,2)-(6,3) = "g"
            │       │   │   ├── opening_loc: ∅
            │       │   │   ├── arguments: ∅
            │       │   │   ├── closing_loc: ∅
            │       │   │   └── block: ∅
            │       │   ├── call_operator_loc: (6,3)-(6,4) = "."
            │       │   ├── name: :h
            │       │   ├── message_loc: (6,4)-(6,5) = "h"
            │       │   ├── opening_loc: ∅
            │       │   ├── arguments:
            │       │   │   @ ArgumentsNode (location: (6,6)-(6,10))
            │       │   │   ├── flags: ∅
            │       │   │   └── arguments: (length: 2)
            │       │   │       ├── @ IntegerNode (location: (6,6)-(6,7))
            │       │   │       │   ├── flags: static_literal, decimal
            │       │   │       │   └── value: 6
            │       │   │       └── @ IntegerNode (location: (6,9)-(6,10))
            │       │   │           ├── flags: static_literal, decimal
            │       │   │           └── value: 7
            │       │   ├── closing_loc: ∅
            │       │   └── block: ∅
            │       ├── @ CallNode (location: (7,2)-(7,6))
            │       │   ├── flags: newline, ignore_visibility
            │       │   ├── receiver: ∅
            │       │   ├── call_operator_loc: ∅
            │       │   ├── name: :p
            │       │   ├── message_loc: (7,2)-(7,3) = "p"
            │       │   ├── opening_loc: (7,3)-(7,4) = "("
            │       │   ├── arguments:
            │       │   │   @ ArgumentsNode (location: (7,4)-(7,5))
            │       │   │   ├── flags: ∅
            │       │   │   └── arguments: (length: 1)
            │       │   │       └── @ IntegerNode (location: (7,4)-(7,5))
            │       │   │           ├── flags: static_literal, decimal
            │       │   │           └── value: 1
            │       │   ├── closing_loc: (7,5)-(7,6) = ")"
            │       │   └── block: ∅
            │       ├── @ CallNode (location: (8,2)-(8,8))
            │       │   ├── flags: newline
            │       │   ├── receiver:
            │       │   │   @ CallNode (location: (8,2)-(8,3))
            │       │   │   ├── flags: variable_call, ignore_visibility
            │       │   │   ├── receiver: ∅
            │       │   │   ├── call_operator_loc: ∅
            │       │   │   ├── name: :a
            │       │   │   ├── message_loc: (8,2)-(8,3) = "a"
            │       │   │   ├── opening_loc: ∅
            │       │   │   ├── arguments: ∅
            │       │   │   ├── closing_loc: ∅
            │       │   │   └── block: ∅
            │       │   ├── call_operator_loc: (8,3)-(8,4) = "."
            │       │   ├── name: :b
            │       │   ├── message_loc: (8,4)-(8,5) = "b"
            │       │   ├── opening_loc: (8,5)-(8,6) = "("
            │       │   ├── arguments:
            │       │   │   @ ArgumentsNode (location: (8,6)-(8,7))
            │       │   │   ├── flags: ∅
            │       │   │   └── arguments: (length: 1)
            │       │   │       └── @ IntegerNode (location: (8,6)-(8,7))
            │       │   │           ├── flags: static_literal, decimal
            │       │   │           └── value: 2
            │       │   ├── closing_loc: (8,7)-(8,8) = ")"
            │       │   └── block: ∅
            │       ├── @ CallNode (location: (9,2)-(9,11))
            │       │   ├── flags: newline
            │       │   ├── receiver:
            │       │   │   @ CallNode (location: (9,2)-(9,3))
            │       │   │   ├── flags: variable_call, ignore_visibility
            │       │   │   ├── receiver: ∅
            │       │   │   ├── call_operator_loc: ∅
            │       │   │   ├── name: :c
            │       │   │   ├── message_loc: (9,2)-(9,3) = "c"
            │       │   │   ├── opening_loc: ∅
            │       │   │   ├── arguments: ∅
            │       │   │   ├── closing_loc: ∅
            │       │   │   └── block: ∅
            │       │   ├── call_operator_loc: (9,3)-(9,4) = "."
            │       │   ├── name: :d
            │       │   ├── message_loc: (9,4)-(9,5) = "d"
            │       │   ├── opening_loc: (9,5)-(9,6) = "("
            │       │   ├── arguments:
            │       │   │   @ ArgumentsNode (location: (9,6)-(9,10))
            │       │   │   ├── flags: ∅
            │       │   │   └── arguments: (length: 2)
            │       │   │       ├── @ IntegerNode (location: (9,6)-(9,7))
            │       │   │       │   ├── flags: static_literal, decimal
            │       │   │       │   └── value: 3
            │       │   │       └── @ IntegerNode (location: (9,9)-(9,10))
            │       │   │           ├── flags: static_literal, decimal
            │       │   │           └── value: 4
            │       │   ├── closing_loc: (9,10)-(9,11) = ")"
            │       │   └── block: ∅
            │       ├── @ CallNode (location: (10,2)-(10,8))
            │       │   ├── flags: newline
            │       │   ├── receiver:
            │       │   │   @ CallNode (location: (10,2)-(10,3))
            │       │   │   ├── flags: variable_call, ignore_visibility
            │       │   │   ├── receiver: ∅
            │       │   │   ├── call_operator_loc: ∅
            │       │   │   ├── name: :e
            │       │   │   ├── message_loc: (10,2)-(10,3) = "e"
            │       │   │   ├── opening_loc: ∅
            │       │   │   ├── arguments: ∅
            │       │   │   ├── closing_loc: ∅
            │       │   │   └── block: ∅
            │       │   ├── call_operator_loc: (10,3)-(10,4) = "."
            │       │   ├── name: :f
            │       │   ├── message_loc: (10,4)-(10,5) = "f"
            │       │   ├── opening_loc: (10,5)-(10,6) = "("
            │       │   ├── arguments:
            │       │   │   @ ArgumentsNode (location: (10,6)-(10,7))
            │       │   │   ├── flags: ∅
            │       │   │   └── arguments: (length: 1)
            │       │   │       └── @ IntegerNode (location: (10,6)-(10,7))
            │       │   │           ├── flags: static_literal, decimal
            │       │   │           └── value: 5
            │       │   ├── closing_loc: (10,7)-(10,8) = ")"
            │       │   └── block: ∅
            │       └── @ CallNode (location: (11,2)-(11,11))
            │           ├── flags: newline
            │           ├── receiver:
            │           │   @ CallNode (location: (11,2)-(11,3))
            │           │   ├── flags: variable_call, ignore_visibility
            │           │   ├── receiver: ∅
            │           │   ├── call_operator_loc: ∅
            │           │   ├── name: :g
            │           │   ├── message_loc: (11,2)-(11,3) = "g"
            │           │   ├── opening_loc: ∅
            │           │   ├── arguments: ∅
            │           │   ├── closing_loc: ∅
            │           │   └── block: ∅
            │           ├── call_operator_loc: (11,3)-(11,4) = "."
            │           ├── name: :h
            │           ├── message_loc: (11,4)-(11,5) = "h"
            │           ├── opening_loc: (11,5)-(11,6) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (11,6)-(11,10))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 2)
            │           │       ├── @ IntegerNode (location: (11,6)-(11,7))
            │           │       │   ├── flags: static_literal, decimal
            │           │       │   └── value: 6
            │           │       └── @ IntegerNode (location: (11,9)-(11,10))
            │           │           ├── flags: static_literal, decimal
            │           │           └── value: 7
            │           ├── closing_loc: (11,10)-(11,11) = ")"
            │           └── block: ∅
            ├── subsequent: ∅
            └── end_keyword_loc: (12,0)-(12,3) = "end"
prism-1.5.1/snapshots/seattlerb/difficult1_line_numbers2.txt000066400000000000000000000114701506127434000243030ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,1))
├── flags: ∅
├── locals: [:b, :c]
└── statements:
    @ StatementsNode (location: (1,0)-(7,1))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ IfNode (location: (1,0)-(6,3))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (1,0)-(1,2) = "if"
        │   ├── predicate:
        │   │   @ TrueNode (location: (1,3)-(1,7))
        │   │   └── flags: static_literal
        │   ├── then_keyword_loc: (1,8)-(1,12) = "then"
        │   ├── statements:
        │   │   @ StatementsNode (location: (2,2)-(5,6))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 4)
        │   │       ├── @ CallNode (location: (2,2)-(2,8))
        │   │       │   ├── flags: newline, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :p
        │   │       │   ├── message_loc: (2,2)-(2,3) = "p"
        │   │       │   ├── opening_loc: (2,3)-(2,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (2,4)-(2,7))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ StringNode (location: (2,4)-(2,7))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── opening_loc: (2,4)-(2,5) = "\""
        │   │       │   │           ├── content_loc: (2,5)-(2,6) = "a"
        │   │       │   │           ├── closing_loc: (2,6)-(2,7) = "\""
        │   │       │   │           └── unescaped: "a"
        │   │       │   ├── closing_loc: (2,7)-(2,8) = ")"
        │   │       │   └── block: ∅
        │   │       ├── @ LocalVariableWriteNode (location: (3,2)-(3,7))
        │   │       │   ├── flags: newline
        │   │       │   ├── name: :b
        │   │       │   ├── depth: 0
        │   │       │   ├── name_loc: (3,2)-(3,3) = "b"
        │   │       │   ├── value:
        │   │       │   │   @ IntegerNode (location: (3,6)-(3,7))
        │   │       │   │   ├── flags: static_literal, decimal
        │   │       │   │   └── value: 1
        │   │       │   └── operator_loc: (3,4)-(3,5) = "="
        │   │       ├── @ CallNode (location: (4,2)-(4,5))
        │   │       │   ├── flags: newline, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :p
        │   │       │   ├── message_loc: (4,2)-(4,3) = "p"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (4,4)-(4,5))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ LocalVariableReadNode (location: (4,4)-(4,5))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── name: :b
        │   │       │   │           └── depth: 0
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ LocalVariableWriteNode (location: (5,2)-(5,6))
        │   │           ├── flags: newline
        │   │           ├── name: :c
        │   │           ├── depth: 0
        │   │           ├── name_loc: (5,2)-(5,3) = "c"
        │   │           ├── value:
        │   │           │   @ IntegerNode (location: (5,5)-(5,6))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 1
        │   │           └── operator_loc: (5,4)-(5,5) = "="
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (6,0)-(6,3) = "end"
        └── @ CallNode (location: (7,0)-(7,1))
            ├── flags: newline, variable_call, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (7,0)-(7,1) = "a"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/difficult2_.txt000066400000000000000000000106551506127434000216230ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,6))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ IfNode (location: (1,0)-(1,13))
        │   ├── flags: newline
        │   ├── if_keyword_loc: ∅
        │   ├── predicate:
        │   │   @ IntegerNode (location: (1,0)-(1,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── then_keyword_loc: (1,2)-(1,3) = "?"
        │   ├── statements:
        │   │   @ StatementsNode (location: (1,4)-(1,9))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (1,4)-(1,9))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (1,4)-(1,5) = "b"
        │   │           ├── opening_loc: (1,5)-(1,6) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (1,6)-(1,8))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ StringNode (location: (1,6)-(1,8))
        │   │           │           ├── flags: ∅
        │   │           │           ├── opening_loc: (1,6)-(1,7) = "'"
        │   │           │           ├── content_loc: (1,7)-(1,7) = ""
        │   │           │           ├── closing_loc: (1,7)-(1,8) = "'"
        │   │           │           └── unescaped: ""
        │   │           ├── closing_loc: (1,8)-(1,9) = ")"
        │   │           └── block: ∅
        │   ├── subsequent:
        │   │   @ ElseNode (location: (1,10)-(1,13))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (1,10)-(1,11) = ":"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (1,12)-(1,13))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ IntegerNode (location: (1,12)-(1,13))
        │   │   │           ├── flags: newline, static_literal, decimal
        │   │   │           └── value: 2
        │   │   └── end_keyword_loc: ∅
        │   └── end_keyword_loc: ∅
        └── @ CallNode (location: (2,0)-(2,6))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (2,0)-(2,1) = "a"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (2,2)-(2,6))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 1)
            │       └── @ KeywordHashNode (location: (2,2)-(2,6))
            │           ├── flags: symbol_keys
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (2,2)-(2,6))
            │                   ├── flags: static_literal
            │                   ├── key:
            │                   │   @ SymbolNode (location: (2,2)-(2,4))
            │                   │   ├── flags: static_literal, forced_us_ascii_encoding
            │                   │   ├── opening_loc: ∅
            │                   │   ├── value_loc: (2,2)-(2,3) = "d"
            │                   │   ├── closing_loc: (2,3)-(2,4) = ":"
            │                   │   └── unescaped: "d"
            │                   ├── value:
            │                   │   @ IntegerNode (location: (2,5)-(2,6))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 3
            │                   └── operator_loc: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/difficult3_.txt000066400000000000000000000063161506127434000216230ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,18))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,18))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,18))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,18))
                ├── flags: ∅
                ├── locals: [:a, :b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,16))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,15))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 2)
                │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   └── name: :a
                │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,15))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 1)
                │   │   │       │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :b
                │   │   │       ├── rest:
                │   │   │       │   @ SplatNode (location: (1,12)-(1,14))
                │   │   │       │   ├── flags: ∅
                │   │   │       │   ├── operator_loc: (1,12)-(1,13) = "*"
                │   │   │       │   └── expression:
                │   │   │       │       @ RequiredParameterNode (location: (1,13)-(1,14))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :c
                │   │   │       ├── rights: (length: 0)
                │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
                │   │   │       └── rparen_loc: (1,14)-(1,15) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,15)-(1,16) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,17)-(1,18) = "}"
prism-1.5.1/snapshots/seattlerb/difficult3_2.txt000066400000000000000000000044361506127434000217060ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,13))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,13))
                ├── flags: ∅
                ├── locals: [:a, :b]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,11))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,10))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest:
                │   │   │   @ RestParameterNode (location: (1,5)-(1,7))
                │   │   │   ├── flags: ∅
                │   │   │   ├── name: :a
                │   │   │   ├── name_loc: (1,6)-(1,7) = "a"
                │   │   │   └── operator_loc: (1,5)-(1,6) = "*"
                │   │   ├── posts: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :b
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,10)-(1,11) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,12)-(1,13) = "}"
prism-1.5.1/snapshots/seattlerb/difficult3_3.txt000066400000000000000000000051511506127434000217020ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,17))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,17))
                ├── flags: ∅
                ├── locals: [:a, :b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,15))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,14))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 0)
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest:
                │   │   │   @ RestParameterNode (location: (1,5)-(1,7))
                │   │   │   ├── flags: ∅
                │   │   │   ├── name: :a
                │   │   │   ├── name_loc: (1,6)-(1,7) = "a"
                │   │   │   └── operator_loc: (1,5)-(1,6) = "*"
                │   │   ├── posts: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :b
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block:
                │   │       @ BlockParameterNode (location: (1,12)-(1,14))
                │   │       ├── flags: ∅
                │   │       ├── name: :c
                │   │       ├── name_loc: (1,13)-(1,14) = "c"
                │   │       └── operator_loc: (1,12)-(1,13) = "&"
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,14)-(1,15) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,16)-(1,17) = "}"
prism-1.5.1/snapshots/seattlerb/difficult3_4.txt000066400000000000000000000044651506127434000217120ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LocalVariableWriteNode (location: (1,0)-(1,17))
            ├── flags: newline
            ├── name: :a
            ├── depth: 0
            ├── name_loc: (1,0)-(1,1) = "a"
            ├── value:
            │   @ IfNode (location: (1,2)-(1,17))
            │   ├── flags: newline
            │   ├── if_keyword_loc: ∅
            │   ├── predicate:
            │   │   @ CallNode (location: (1,2)-(1,3))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :b
            │   │   ├── message_loc: (1,2)-(1,3) = "b"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── then_keyword_loc: (1,4)-(1,5) = "?"
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,6)-(1,10))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ TrueNode (location: (1,6)-(1,10))
            │   │           └── flags: newline, static_literal
            │   ├── subsequent:
            │   │   @ ElseNode (location: (1,10)-(1,17))
            │   │   ├── flags: ∅
            │   │   ├── else_keyword_loc: (1,10)-(1,11) = ":"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (1,12)-(1,17))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ FalseNode (location: (1,12)-(1,17))
            │   │   │           └── flags: newline, static_literal
            │   │   └── end_keyword_loc: ∅
            │   └── end_keyword_loc: ∅
            └── operator_loc: (1,1)-(1,2) = "="
prism-1.5.1/snapshots/seattlerb/difficult3_5.txt000066400000000000000000000056701506127434000217120ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,19))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,19))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,19))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ LambdaNode (location: (1,2)-(1,19))
            │           ├── flags: ∅
            │           ├── locals: []
            │           ├── operator_loc: (1,2)-(1,4) = "->"
            │           ├── opening_loc: (1,7)-(1,8) = "{"
            │           ├── closing_loc: (1,18)-(1,19) = "}"
            │           ├── parameters:
            │           │   @ BlockParametersNode (location: (1,4)-(1,6))
            │           │   ├── flags: ∅
            │           │   ├── parameters: ∅
            │           │   ├── locals: (length: 0)
            │           │   ├── opening_loc: (1,4)-(1,5) = "("
            │           │   └── closing_loc: (1,5)-(1,6) = ")"
            │           └── body:
            │               @ StatementsNode (location: (1,9)-(1,17))
            │               ├── flags: ∅
            │               └── body: (length: 1)
            │                   └── @ CallNode (location: (1,9)-(1,17))
            │                       ├── flags: newline, ignore_visibility
            │                       ├── receiver: ∅
            │                       ├── call_operator_loc: ∅
            │                       ├── name: :g
            │                       ├── message_loc: (1,9)-(1,10) = "g"
            │                       ├── opening_loc: ∅
            │                       ├── arguments: ∅
            │                       ├── closing_loc: ∅
            │                       └── block:
            │                           @ BlockNode (location: (1,11)-(1,17))
            │                           ├── flags: ∅
            │                           ├── locals: []
            │                           ├── parameters: ∅
            │                           ├── body: ∅
            │                           ├── opening_loc: (1,11)-(1,13) = "do"
            │                           └── closing_loc: (1,14)-(1,17) = "end"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/difficult3__10.txt000066400000000000000000000063151506127434000221220ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,18))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,18))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,18))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,18))
                ├── flags: ∅
                ├── locals: [:a, :b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,16))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,15))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 2)
                │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   └── name: :a
                │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,15))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 0)
                │   │   │       ├── rest:
                │   │   │       │   @ SplatNode (location: (1,9)-(1,11))
                │   │   │       │   ├── flags: ∅
                │   │   │       │   ├── operator_loc: (1,9)-(1,10) = "*"
                │   │   │       │   └── expression:
                │   │   │       │       @ RequiredParameterNode (location: (1,10)-(1,11))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :b
                │   │   │       ├── rights: (length: 1)
                │   │   │       │   └── @ RequiredParameterNode (location: (1,13)-(1,14))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :c
                │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
                │   │   │       └── rparen_loc: (1,14)-(1,15) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,15)-(1,16) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,17)-(1,18) = "}"
prism-1.5.1/snapshots/seattlerb/difficult3__11.txt000066400000000000000000000053571506127434000221300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,14))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,14))
                ├── flags: ∅
                ├── locals: [:a]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,12))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,11))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 2)
                │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   └── name: :a
                │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,11))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 0)
                │   │   │       ├── rest:
                │   │   │       │   @ SplatNode (location: (1,9)-(1,10))
                │   │   │       │   ├── flags: ∅
                │   │   │       │   ├── operator_loc: (1,9)-(1,10) = "*"
                │   │   │       │   └── expression: ∅
                │   │   │       ├── rights: (length: 0)
                │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
                │   │   │       └── rparen_loc: (1,10)-(1,11) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,11)-(1,12) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,13)-(1,14) = "}"
prism-1.5.1/snapshots/seattlerb/difficult3__12.txt000066400000000000000000000057431506127434000221300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,17))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,17))
                ├── flags: ∅
                ├── locals: [:a, :b]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,15))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,14))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 2)
                │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   └── name: :a
                │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,14))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 0)
                │   │   │       ├── rest:
                │   │   │       │   @ SplatNode (location: (1,9)-(1,10))
                │   │   │       │   ├── flags: ∅
                │   │   │       │   ├── operator_loc: (1,9)-(1,10) = "*"
                │   │   │       │   └── expression: ∅
                │   │   │       ├── rights: (length: 1)
                │   │   │       │   └── @ RequiredParameterNode (location: (1,12)-(1,13))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :b
                │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
                │   │   │       └── rparen_loc: (1,13)-(1,14) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,14)-(1,15) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,16)-(1,17) = "}"
prism-1.5.1/snapshots/seattlerb/difficult3__6.txt000066400000000000000000000067021506127434000220470ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,21))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,21))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,21))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,21))
                ├── flags: ∅
                ├── locals: [:a, :b, :c, :d]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,19))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,18))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 2)
                │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   └── name: :a
                │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,18))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 1)
                │   │   │       │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :b
                │   │   │       ├── rest:
                │   │   │       │   @ SplatNode (location: (1,12)-(1,14))
                │   │   │       │   ├── flags: ∅
                │   │   │       │   ├── operator_loc: (1,12)-(1,13) = "*"
                │   │   │       │   └── expression:
                │   │   │       │       @ RequiredParameterNode (location: (1,13)-(1,14))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :c
                │   │   │       ├── rights: (length: 1)
                │   │   │       │   └── @ RequiredParameterNode (location: (1,16)-(1,17))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :d
                │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
                │   │   │       └── rparen_loc: (1,17)-(1,18) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,18)-(1,19) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,20)-(1,21) = "}"
prism-1.5.1/snapshots/seattlerb/difficult3__7.txt000066400000000000000000000057441506127434000220550ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,17))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,17))
                ├── flags: ∅
                ├── locals: [:a, :b]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,15))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,14))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 2)
                │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   └── name: :a
                │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,14))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 1)
                │   │   │       │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :b
                │   │   │       ├── rest:
                │   │   │       │   @ SplatNode (location: (1,12)-(1,13))
                │   │   │       │   ├── flags: ∅
                │   │   │       │   ├── operator_loc: (1,12)-(1,13) = "*"
                │   │   │       │   └── expression: ∅
                │   │   │       ├── rights: (length: 0)
                │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
                │   │   │       └── rparen_loc: (1,13)-(1,14) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,14)-(1,15) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,16)-(1,17) = "}"
prism-1.5.1/snapshots/seattlerb/difficult3__8.txt000066400000000000000000000063301506127434000220460ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,20))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,20))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,20))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,20))
                ├── flags: ∅
                ├── locals: [:a, :b, :c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,18))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,17))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 2)
                │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   └── name: :a
                │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,17))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 1)
                │   │   │       │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :b
                │   │   │       ├── rest:
                │   │   │       │   @ SplatNode (location: (1,12)-(1,13))
                │   │   │       │   ├── flags: ∅
                │   │   │       │   ├── operator_loc: (1,12)-(1,13) = "*"
                │   │   │       │   └── expression: ∅
                │   │   │       ├── rights: (length: 1)
                │   │   │       │   └── @ RequiredParameterNode (location: (1,15)-(1,16))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :c
                │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
                │   │   │       └── rparen_loc: (1,16)-(1,17) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,17)-(1,18) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,19)-(1,20) = "}"
prism-1.5.1/snapshots/seattlerb/difficult3__9.txt000066400000000000000000000057311506127434000220530ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,15))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,15))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,15))
                ├── flags: ∅
                ├── locals: [:a, :b]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,4)-(1,13))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,5)-(1,12))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 2)
                │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   └── name: :a
                │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,12))
                │   │   │       ├── flags: ∅
                │   │   │       ├── lefts: (length: 0)
                │   │   │       ├── rest:
                │   │   │       │   @ SplatNode (location: (1,9)-(1,11))
                │   │   │       │   ├── flags: ∅
                │   │   │       │   ├── operator_loc: (1,9)-(1,10) = "*"
                │   │   │       │   └── expression:
                │   │   │       │       @ RequiredParameterNode (location: (1,10)-(1,11))
                │   │   │       │       ├── flags: ∅
                │   │   │       │       └── name: :b
                │   │   │       ├── rights: (length: 0)
                │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
                │   │   │       └── rparen_loc: (1,11)-(1,12) = ")"
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,4)-(1,5) = "|"
                │   └── closing_loc: (1,12)-(1,13) = "|"
                ├── body: ∅
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,14)-(1,15) = "}"
prism-1.5.1/snapshots/seattlerb/difficult4__leading_dots.txt000066400000000000000000000021131506127434000243270ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,2))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,2))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(2,2))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (2,0)-(2,1) = "."
            ├── name: :b
            ├── message_loc: (2,1)-(2,2) = "b"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/difficult4__leading_dots2.txt000066400000000000000000000013341506127434000244150ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,3))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ IntegerNode (location: (1,0)-(1,1))
        │   ├── flags: newline, static_literal, decimal
        │   └── value: 1
        └── @ RangeNode (location: (2,0)-(2,3))
            ├── flags: newline, static_literal
            ├── left: ∅
            ├── right:
            │   @ IntegerNode (location: (2,2)-(2,3))
            │   ├── flags: static_literal, decimal
            │   └── value: 3
            └── operator_loc: (2,0)-(2,2) = ".."
prism-1.5.1/snapshots/seattlerb/difficult6_.txt000066400000000000000000000075541506127434000216330ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,25))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,25))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LambdaNode (location: (1,0)-(1,25))
            ├── flags: newline
            ├── locals: [:a, :b]
            ├── operator_loc: (1,0)-(1,2) = "->"
            ├── opening_loc: (1,13)-(1,14) = "{"
            ├── closing_loc: (1,24)-(1,25) = "}"
            ├── parameters:
            │   @ BlockParametersNode (location: (1,2)-(1,12))
            │   ├── flags: ∅
            │   ├── parameters:
            │   │   @ ParametersNode (location: (1,3)-(1,11))
            │   │   ├── flags: ∅
            │   │   ├── requireds: (length: 1)
            │   │   │   └── @ RequiredParameterNode (location: (1,3)-(1,4))
            │   │   │       ├── flags: ∅
            │   │   │       └── name: :a
            │   │   ├── optionals: (length: 1)
            │   │   │   └── @ OptionalParameterNode (location: (1,6)-(1,11))
            │   │   │       ├── flags: ∅
            │   │   │       ├── name: :b
            │   │   │       ├── name_loc: (1,6)-(1,7) = "b"
            │   │   │       ├── operator_loc: (1,7)-(1,8) = "="
            │   │   │       └── value:
            │   │   │           @ NilNode (location: (1,8)-(1,11))
            │   │   │           └── flags: static_literal
            │   │   ├── rest: ∅
            │   │   ├── posts: (length: 0)
            │   │   ├── keywords: (length: 0)
            │   │   ├── keyword_rest: ∅
            │   │   └── block: ∅
            │   ├── locals: (length: 0)
            │   ├── opening_loc: (1,2)-(1,3) = "("
            │   └── closing_loc: (1,11)-(1,12) = ")"
            └── body:
                @ StatementsNode (location: (1,15)-(1,23))
                ├── flags: ∅
                └── body: (length: 1)
                    └── @ CallNode (location: (1,15)-(1,23))
                        ├── flags: newline, ignore_visibility
                        ├── receiver: ∅
                        ├── call_operator_loc: ∅
                        ├── name: :p
                        ├── message_loc: (1,15)-(1,16) = "p"
                        ├── opening_loc: ∅
                        ├── arguments:
                        │   @ ArgumentsNode (location: (1,17)-(1,23))
                        │   ├── flags: ∅
                        │   └── arguments: (length: 1)
                        │       └── @ ArrayNode (location: (1,17)-(1,23))
                        │           ├── flags: ∅
                        │           ├── elements: (length: 2)
                        │           │   ├── @ LocalVariableReadNode (location: (1,18)-(1,19))
                        │           │   │   ├── flags: ∅
                        │           │   │   ├── name: :a
                        │           │   │   └── depth: 0
                        │           │   └── @ LocalVariableReadNode (location: (1,21)-(1,22))
                        │           │       ├── flags: ∅
                        │           │       ├── name: :b
                        │           │       └── depth: 0
                        │           ├── opening_loc: (1,17)-(1,18) = "["
                        │           └── closing_loc: (1,22)-(1,23) = "]"
                        ├── closing_loc: ∅
                        └── block: ∅
prism-1.5.1/snapshots/seattlerb/difficult6__7.txt000066400000000000000000000057531506127434000220600ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,11))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,11))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (1,1)-(1,2) = "."
            ├── name: :b
            ├── message_loc: (1,2)-(1,3) = "b"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,7))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ ParenthesesNode (location: (1,4)-(1,7))
            │           ├── flags: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (1,5)-(1,6))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ IntegerNode (location: (1,5)-(1,6))
            │           │           ├── flags: newline, static_literal, decimal
            │           │           └── value: 1
            │           ├── opening_loc: (1,4)-(1,5) = "("
            │           └── closing_loc: (1,6)-(1,7) = ")"
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,8)-(1,11))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body:
                │   @ StatementsNode (location: (1,9)-(1,10))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ CallNode (location: (1,9)-(1,10))
                │           ├── flags: newline, variable_call, ignore_visibility
                │           ├── receiver: ∅
                │           ├── call_operator_loc: ∅
                │           ├── name: :c
                │           ├── message_loc: (1,9)-(1,10) = "c"
                │           ├── opening_loc: ∅
                │           ├── arguments: ∅
                │           ├── closing_loc: ∅
                │           └── block: ∅
                ├── opening_loc: (1,8)-(1,9) = "{"
                └── closing_loc: (1,10)-(1,11) = "}"
prism-1.5.1/snapshots/seattlerb/difficult6__8.txt000066400000000000000000000057601506127434000220570ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,12))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (1,1)-(1,3) = "::"
            ├── name: :b
            ├── message_loc: (1,3)-(1,4) = "b"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,5)-(1,8))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ ParenthesesNode (location: (1,5)-(1,8))
            │           ├── flags: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (1,6)-(1,7))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ IntegerNode (location: (1,6)-(1,7))
            │           │           ├── flags: newline, static_literal, decimal
            │           │           └── value: 1
            │           ├── opening_loc: (1,5)-(1,6) = "("
            │           └── closing_loc: (1,7)-(1,8) = ")"
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,9)-(1,12))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body:
                │   @ StatementsNode (location: (1,10)-(1,11))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ CallNode (location: (1,10)-(1,11))
                │           ├── flags: newline, variable_call, ignore_visibility
                │           ├── receiver: ∅
                │           ├── call_operator_loc: ∅
                │           ├── name: :c
                │           ├── message_loc: (1,10)-(1,11) = "c"
                │           ├── opening_loc: ∅
                │           ├── arguments: ∅
                │           ├── closing_loc: ∅
                │           └── block: ∅
                ├── opening_loc: (1,9)-(1,10) = "{"
                └── closing_loc: (1,11)-(1,12) = "}"
prism-1.5.1/snapshots/seattlerb/difficult7_.txt000066400000000000000000000165141506127434000216300ustar00rootroot00000000000000@ ProgramNode (location: (1,6)-(4,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,6)-(4,7))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ HashNode (location: (1,6)-(4,7))
            ├── flags: newline
            ├── opening_loc: (1,6)-(1,7) = "{"
            ├── elements: (length: 2)
            │   ├── @ AssocNode (location: (2,8)-(2,33))
            │   │   ├── flags: ∅
            │   │   ├── key:
            │   │   │   @ SymbolNode (location: (2,8)-(2,10))
            │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │   │   ├── opening_loc: ∅
            │   │   │   ├── value_loc: (2,8)-(2,9) = "a"
            │   │   │   ├── closing_loc: (2,9)-(2,10) = ":"
            │   │   │   └── unescaped: "a"
            │   │   ├── value:
            │   │   │   @ CallNode (location: (2,11)-(2,33))
            │   │   │   ├── flags: ignore_visibility
            │   │   │   ├── receiver: ∅
            │   │   │   ├── call_operator_loc: ∅
            │   │   │   ├── name: :lambda
            │   │   │   ├── message_loc: (2,11)-(2,17) = "lambda"
            │   │   │   ├── opening_loc: ∅
            │   │   │   ├── arguments: ∅
            │   │   │   ├── closing_loc: ∅
            │   │   │   └── block:
            │   │   │       @ BlockNode (location: (2,18)-(2,33))
            │   │   │       ├── flags: ∅
            │   │   │       ├── locals: []
            │   │   │       ├── parameters: ∅
            │   │   │       ├── body:
            │   │   │       │   @ StatementsNode (location: (2,20)-(2,31))
            │   │   │       │   ├── flags: ∅
            │   │   │       │   └── body: (length: 1)
            │   │   │       │       └── @ IfNode (location: (2,20)-(2,31))
            │   │   │       │           ├── flags: newline
            │   │   │       │           ├── if_keyword_loc: ∅
            │   │   │       │           ├── predicate:
            │   │   │       │           │   @ CallNode (location: (2,20)-(2,21))
            │   │   │       │           │   ├── flags: variable_call, ignore_visibility
            │   │   │       │           │   ├── receiver: ∅
            │   │   │       │           │   ├── call_operator_loc: ∅
            │   │   │       │           │   ├── name: :b
            │   │   │       │           │   ├── message_loc: (2,20)-(2,21) = "b"
            │   │   │       │           │   ├── opening_loc: ∅
            │   │   │       │           │   ├── arguments: ∅
            │   │   │       │           │   ├── closing_loc: ∅
            │   │   │       │           │   └── block: ∅
            │   │   │       │           ├── then_keyword_loc: (2,22)-(2,23) = "?"
            │   │   │       │           ├── statements:
            │   │   │       │           │   @ StatementsNode (location: (2,24)-(2,27))
            │   │   │       │           │   ├── flags: ∅
            │   │   │       │           │   └── body: (length: 1)
            │   │   │       │           │       └── @ CallNode (location: (2,24)-(2,27))
            │   │   │       │           │           ├── flags: newline, ignore_visibility
            │   │   │       │           │           ├── receiver: ∅
            │   │   │       │           │           ├── call_operator_loc: ∅
            │   │   │       │           │           ├── name: :c
            │   │   │       │           │           ├── message_loc: (2,24)-(2,25) = "c"
            │   │   │       │           │           ├── opening_loc: (2,25)-(2,26) = "("
            │   │   │       │           │           ├── arguments: ∅
            │   │   │       │           │           ├── closing_loc: (2,26)-(2,27) = ")"
            │   │   │       │           │           └── block: ∅
            │   │   │       │           ├── subsequent:
            │   │   │       │           │   @ ElseNode (location: (2,28)-(2,31))
            │   │   │       │           │   ├── flags: ∅
            │   │   │       │           │   ├── else_keyword_loc: (2,28)-(2,29) = ":"
            │   │   │       │           │   ├── statements:
            │   │   │       │           │   │   @ StatementsNode (location: (2,30)-(2,31))
            │   │   │       │           │   │   ├── flags: ∅
            │   │   │       │           │   │   └── body: (length: 1)
            │   │   │       │           │   │       └── @ CallNode (location: (2,30)-(2,31))
            │   │   │       │           │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │   │       │           │   │           ├── receiver: ∅
            │   │   │       │           │   │           ├── call_operator_loc: ∅
            │   │   │       │           │   │           ├── name: :d
            │   │   │       │           │   │           ├── message_loc: (2,30)-(2,31) = "d"
            │   │   │       │           │   │           ├── opening_loc: ∅
            │   │   │       │           │   │           ├── arguments: ∅
            │   │   │       │           │   │           ├── closing_loc: ∅
            │   │   │       │           │   │           └── block: ∅
            │   │   │       │           │   └── end_keyword_loc: ∅
            │   │   │       │           └── end_keyword_loc: ∅
            │   │   │       ├── opening_loc: (2,18)-(2,19) = "{"
            │   │   │       └── closing_loc: (2,32)-(2,33) = "}"
            │   │   └── operator_loc: ∅
            │   └── @ AssocNode (location: (3,8)-(3,14))
            │       ├── flags: static_literal
            │       ├── key:
            │       │   @ SymbolNode (location: (3,8)-(3,10))
            │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   ├── opening_loc: ∅
            │       │   ├── value_loc: (3,8)-(3,9) = "e"
            │       │   ├── closing_loc: (3,9)-(3,10) = ":"
            │       │   └── unescaped: "e"
            │       ├── value:
            │       │   @ NilNode (location: (3,11)-(3,14))
            │       │   └── flags: static_literal
            │       └── operator_loc: ∅
            └── closing_loc: (4,6)-(4,7) = "}"
prism-1.5.1/snapshots/seattlerb/do_bug.txt000066400000000000000000000062551506127434000206710ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(1,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (1,0)-(1,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(1,3))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (1,2)-(1,3))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (2,0)-(4,3))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (2,0)-(2,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (2,0)-(2,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (2,1)-(2,2) = "."
            ├── name: :b
            ├── message_loc: (2,2)-(2,3) = "b"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (2,4)-(4,3))
                ├── flags: ∅
                ├── locals: [:c]
                ├── parameters:
                │   @ BlockParametersNode (location: (2,7)-(2,10))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (2,8)-(2,9))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (2,8)-(2,9))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :c
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (2,7)-(2,8) = "|"
                │   └── closing_loc: (2,9)-(2,10) = "|"
                ├── body: ∅
                ├── opening_loc: (2,4)-(2,6) = "do"
                └── closing_loc: (4,0)-(4,3) = "end"
prism-1.5.1/snapshots/seattlerb/do_lambda.txt000066400000000000000000000015541506127434000213310ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,11))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LambdaNode (location: (1,0)-(1,11))
            ├── flags: newline
            ├── locals: []
            ├── operator_loc: (1,0)-(1,2) = "->"
            ├── opening_loc: (1,5)-(1,7) = "do"
            ├── closing_loc: (1,8)-(1,11) = "end"
            ├── parameters:
            │   @ BlockParametersNode (location: (1,2)-(1,4))
            │   ├── flags: ∅
            │   ├── parameters: ∅
            │   ├── locals: (length: 0)
            │   ├── opening_loc: (1,2)-(1,3) = "("
            │   └── closing_loc: (1,3)-(1,4) = ")"
            └── body: ∅
prism-1.5.1/snapshots/seattlerb/dot2_nil__26.txt000066400000000000000000000015751506127434000216120ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ RangeNode (location: (1,0)-(1,3))
            ├── flags: newline
            ├── left:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── right: ∅
            └── operator_loc: (1,1)-(1,3) = ".."
prism-1.5.1/snapshots/seattlerb/dot3_nil__26.txt000066400000000000000000000016131506127434000216040ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ RangeNode (location: (1,0)-(1,4))
            ├── flags: newline, exclude_end
            ├── left:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── right: ∅
            └── operator_loc: (1,1)-(1,4) = "..."
prism-1.5.1/snapshots/seattlerb/dstr_evstr.txt000066400000000000000000000047551506127434000216340ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,12))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "\""
            ├── parts: (length: 2)
            │   ├── @ EmbeddedStatementsNode (location: (1,1)-(1,7))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (1,1)-(1,3) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (1,3)-(1,6))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ StringNode (location: (1,3)-(1,6))
            │   │   │           ├── flags: static_literal, frozen
            │   │   │           ├── opening_loc: (1,3)-(1,4) = "'"
            │   │   │           ├── content_loc: (1,4)-(1,5) = "a"
            │   │   │           ├── closing_loc: (1,5)-(1,6) = "'"
            │   │   │           └── unescaped: "a"
            │   │   └── closing_loc: (1,6)-(1,7) = "}"
            │   └── @ EmbeddedStatementsNode (location: (1,7)-(1,11))
            │       ├── flags: ∅
            │       ├── opening_loc: (1,7)-(1,9) = "\#{"
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,9)-(1,10))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ CallNode (location: (1,9)-(1,10))
            │       │           ├── flags: variable_call, ignore_visibility
            │       │           ├── receiver: ∅
            │       │           ├── call_operator_loc: ∅
            │       │           ├── name: :b
            │       │           ├── message_loc: (1,9)-(1,10) = "b"
            │       │           ├── opening_loc: ∅
            │       │           ├── arguments: ∅
            │       │           ├── closing_loc: ∅
            │       │           └── block: ∅
            │       └── closing_loc: (1,10)-(1,11) = "}"
            └── closing_loc: (1,11)-(1,12) = "\""
prism-1.5.1/snapshots/seattlerb/dstr_evstr_empty_end.txt000066400000000000000000000031071506127434000236660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,11))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedSymbolNode (location: (1,0)-(1,11))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,2) = ":\""
            ├── parts: (length: 1)
            │   └── @ EmbeddedStatementsNode (location: (1,2)-(1,10))
            │       ├── flags: ∅
            │       ├── opening_loc: (1,2)-(1,4) = "\#{"
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,4)-(1,9))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ CallNode (location: (1,4)-(1,9))
            │       │           ├── flags: variable_call, ignore_visibility
            │       │           ├── receiver: ∅
            │       │           ├── call_operator_loc: ∅
            │       │           ├── name: :field
            │       │           ├── message_loc: (1,4)-(1,9) = "field"
            │       │           ├── opening_loc: ∅
            │       │           ├── arguments: ∅
            │       │           ├── closing_loc: ∅
            │       │           └── block: ∅
            │       └── closing_loc: (1,9)-(1,10) = "}"
            └── closing_loc: (1,10)-(1,11) = "\""
prism-1.5.1/snapshots/seattlerb/dstr_lex_state.txt000066400000000000000000000044251506127434000224530ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,8))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "\""
            ├── parts: (length: 1)
            │   └── @ EmbeddedStatementsNode (location: (1,1)-(1,7))
            │       ├── flags: ∅
            │       ├── opening_loc: (1,1)-(1,3) = "\#{"
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,3)-(1,6))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ CallNode (location: (1,3)-(1,6))
            │       │           ├── flags: ignore_visibility
            │       │           ├── receiver: ∅
            │       │           ├── call_operator_loc: ∅
            │       │           ├── name: :p
            │       │           ├── message_loc: (1,3)-(1,4) = "p"
            │       │           ├── opening_loc: ∅
            │       │           ├── arguments:
            │       │           │   @ ArgumentsNode (location: (1,4)-(1,6))
            │       │           │   ├── flags: ∅
            │       │           │   └── arguments: (length: 1)
            │       │           │       └── @ SymbolNode (location: (1,4)-(1,6))
            │       │           │           ├── flags: static_literal, forced_us_ascii_encoding
            │       │           │           ├── opening_loc: (1,4)-(1,5) = ":"
            │       │           │           ├── value_loc: (1,5)-(1,6) = "a"
            │       │           │           ├── closing_loc: ∅
            │       │           │           └── unescaped: "a"
            │       │           ├── closing_loc: ∅
            │       │           └── block: ∅
            │       └── closing_loc: (1,6)-(1,7) = "}"
            └── closing_loc: (1,7)-(1,8) = "\""
prism-1.5.1/snapshots/seattlerb/dstr_str.txt000066400000000000000000000033421506127434000212700ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,10))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,10))
            ├── flags: newline, static_literal, mutable
            ├── opening_loc: (1,0)-(1,1) = "\""
            ├── parts: (length: 2)
            │   ├── @ EmbeddedStatementsNode (location: (1,1)-(1,7))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (1,1)-(1,3) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (1,3)-(1,6))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ StringNode (location: (1,3)-(1,6))
            │   │   │           ├── flags: static_literal, frozen
            │   │   │           ├── opening_loc: (1,3)-(1,4) = "'"
            │   │   │           ├── content_loc: (1,4)-(1,5) = "a"
            │   │   │           ├── closing_loc: (1,5)-(1,6) = "'"
            │   │   │           └── unescaped: "a"
            │   │   └── closing_loc: (1,6)-(1,7) = "}"
            │   └── @ StringNode (location: (1,7)-(1,9))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (1,7)-(1,9) = " b"
            │       ├── closing_loc: ∅
            │       └── unescaped: " b"
            └── closing_loc: (1,9)-(1,10) = "\""
prism-1.5.1/snapshots/seattlerb/dsym_esc_to_sym.txt000066400000000000000000000010571506127434000226250ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ SymbolNode (location: (1,0)-(1,17))
            ├── flags: newline, static_literal, forced_utf8_encoding
            ├── opening_loc: (1,0)-(1,2) = ":\""
            ├── value_loc: (1,2)-(1,16) = "Variet\\303\\240"
            ├── closing_loc: (1,16)-(1,17) = "\""
            └── unescaped: "Varietà"
prism-1.5.1/snapshots/seattlerb/dsym_to_sym.txt000066400000000000000000000040341506127434000217710ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,13))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ AliasMethodNode (location: (1,0)-(1,17))
        │   ├── flags: newline
        │   ├── new_name:
        │   │   @ SymbolNode (location: (1,6)-(1,11))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (1,6)-(1,8) = ":\""
        │   │   ├── value_loc: (1,8)-(1,10) = "<<"
        │   │   ├── closing_loc: (1,10)-(1,11) = "\""
        │   │   └── unescaped: "<<"
        │   ├── old_name:
        │   │   @ SymbolNode (location: (1,12)-(1,17))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (1,12)-(1,14) = ":\""
        │   │   ├── value_loc: (1,14)-(1,16) = ">>"
        │   │   ├── closing_loc: (1,16)-(1,17) = "\""
        │   │   └── unescaped: ">>"
        │   └── keyword_loc: (1,0)-(1,5) = "alias"
        └── @ AliasMethodNode (location: (3,0)-(3,13))
            ├── flags: newline
            ├── new_name:
            │   @ SymbolNode (location: (3,6)-(3,9))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (3,6)-(3,7) = ":"
            │   ├── value_loc: (3,7)-(3,9) = "<<"
            │   ├── closing_loc: ∅
            │   └── unescaped: "<<"
            ├── old_name:
            │   @ SymbolNode (location: (3,10)-(3,13))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (3,10)-(3,11) = ":"
            │   ├── value_loc: (3,11)-(3,13) = ">>"
            │   ├── closing_loc: ∅
            │   └── unescaped: ">>"
            └── keyword_loc: (3,0)-(3,5) = "alias"
prism-1.5.1/snapshots/seattlerb/eq_begin_line_numbers.txt000066400000000000000000000007721506127434000237430ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(6,1))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(6,1))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ IntegerNode (location: (1,0)-(1,1))
        │   ├── flags: newline, static_literal, decimal
        │   └── value: 1
        └── @ IntegerNode (location: (6,0)-(6,1))
            ├── flags: newline, static_literal, decimal
            └── value: 2
prism-1.5.1/snapshots/seattlerb/eq_begin_why_wont_people_use_their_spacebar.txt000066400000000000000000000053111506127434000304040ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(3,8))
            ├── flags: newline, attribute_write
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :h
            │   ├── message_loc: (1,0)-(1,1) = "h"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :[]=
            ├── message_loc: (1,1)-(1,4) = "[k]"
            ├── opening_loc: (1,1)-(1,2) = "["
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(3,8))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ CallNode (location: (1,2)-(1,3))
            │       │   ├── flags: variable_call, ignore_visibility
            │       │   ├── receiver: ∅
            │       │   ├── call_operator_loc: ∅
            │       │   ├── name: :k
            │       │   ├── message_loc: (1,2)-(1,3) = "k"
            │       │   ├── opening_loc: ∅
            │       │   ├── arguments: ∅
            │       │   ├── closing_loc: ∅
            │       │   └── block: ∅
            │       └── @ BeginNode (location: (1,5)-(3,8))
            │           ├── flags: ∅
            │           ├── begin_keyword_loc: (1,5)-(1,10) = "begin"
            │           ├── statements:
            │           │   @ StatementsNode (location: (2,7)-(2,9))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ IntegerNode (location: (2,7)-(2,9))
            │           │           ├── flags: newline, static_literal, decimal
            │           │           └── value: 42
            │           ├── rescue_clause: ∅
            │           ├── else_clause: ∅
            │           ├── ensure_clause: ∅
            │           └── end_keyword_loc: (3,5)-(3,8) = "end"
            ├── closing_loc: (1,3)-(1,4) = "]"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/evstr_evstr.txt000066400000000000000000000053131506127434000220120ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,10))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,10))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "\""
            ├── parts: (length: 2)
            │   ├── @ EmbeddedStatementsNode (location: (1,1)-(1,5))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (1,1)-(1,3) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (1,3)-(1,4))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ CallNode (location: (1,3)-(1,4))
            │   │   │           ├── flags: variable_call, ignore_visibility
            │   │   │           ├── receiver: ∅
            │   │   │           ├── call_operator_loc: ∅
            │   │   │           ├── name: :a
            │   │   │           ├── message_loc: (1,3)-(1,4) = "a"
            │   │   │           ├── opening_loc: ∅
            │   │   │           ├── arguments: ∅
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── block: ∅
            │   │   └── closing_loc: (1,4)-(1,5) = "}"
            │   └── @ EmbeddedStatementsNode (location: (1,5)-(1,9))
            │       ├── flags: ∅
            │       ├── opening_loc: (1,5)-(1,7) = "\#{"
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,7)-(1,8))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ CallNode (location: (1,7)-(1,8))
            │       │           ├── flags: variable_call, ignore_visibility
            │       │           ├── receiver: ∅
            │       │           ├── call_operator_loc: ∅
            │       │           ├── name: :b
            │       │           ├── message_loc: (1,7)-(1,8) = "b"
            │       │           ├── opening_loc: ∅
            │       │           ├── arguments: ∅
            │       │           ├── closing_loc: ∅
            │       │           └── block: ∅
            │       └── closing_loc: (1,8)-(1,9) = "}"
            └── closing_loc: (1,9)-(1,10) = "\""
prism-1.5.1/snapshots/seattlerb/evstr_str.txt000066400000000000000000000036521506127434000214630ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,8))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "\""
            ├── parts: (length: 2)
            │   ├── @ EmbeddedStatementsNode (location: (1,1)-(1,5))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (1,1)-(1,3) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (1,3)-(1,4))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ CallNode (location: (1,3)-(1,4))
            │   │   │           ├── flags: variable_call, ignore_visibility
            │   │   │           ├── receiver: ∅
            │   │   │           ├── call_operator_loc: ∅
            │   │   │           ├── name: :a
            │   │   │           ├── message_loc: (1,3)-(1,4) = "a"
            │   │   │           ├── opening_loc: ∅
            │   │   │           ├── arguments: ∅
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── block: ∅
            │   │   └── closing_loc: (1,4)-(1,5) = "}"
            │   └── @ StringNode (location: (1,5)-(1,7))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (1,5)-(1,7) = " b"
            │       ├── closing_loc: ∅
            │       └── unescaped: " b"
            └── closing_loc: (1,7)-(1,8) = "\""
prism-1.5.1/snapshots/seattlerb/expr_not_bang.txt000066400000000000000000000035041506127434000222510ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,5))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,2)-(1,5))
            │   ├── flags: ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,2)-(1,3) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (1,4)-(1,5))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 1)
            │   │       └── @ CallNode (location: (1,4)-(1,5))
            │   │           ├── flags: variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :b
            │   │           ├── message_loc: (1,4)-(1,5) = "b"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :!
            ├── message_loc: (1,0)-(1,1) = "!"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/f_kw.txt000066400000000000000000000032461506127434000203550ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,15))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,15))
            ├── flags: newline
            ├── name: :x
            ├── name_loc: (1,4)-(1,5) = "x"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,10))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 1)
            │   │   └── @ OptionalKeywordParameterNode (location: (1,6)-(1,10))
            │   │       ├── flags: ∅
            │   │       ├── name: :k
            │   │       ├── name_loc: (1,6)-(1,8) = "k:"
            │   │       └── value:
            │   │           @ IntegerNode (location: (1,8)-(1,10))
            │   │           ├── flags: static_literal, decimal
            │   │           └── value: 42
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:k]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,12)-(1,15) = "end"
prism-1.5.1/snapshots/seattlerb/f_kw__required.txt000066400000000000000000000026631506127434000224160ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,13))
            ├── flags: newline
            ├── name: :x
            ├── name_loc: (1,4)-(1,5) = "x"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,8))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 1)
            │   │   └── @ RequiredKeywordParameterNode (location: (1,6)-(1,8))
            │   │       ├── flags: ∅
            │   │       ├── name: :k
            │   │       └── name_loc: (1,6)-(1,8) = "k:"
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:k]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,10)-(1,13) = "end"
prism-1.5.1/snapshots/seattlerb/flip2_env_lvar.txt000066400000000000000000000035461506127434000223420ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,16))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,16))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ IfNode (location: (1,0)-(1,16))
            ├── flags: newline
            ├── if_keyword_loc: (1,0)-(1,2) = "if"
            ├── predicate:
            │   @ FlipFlopNode (location: (1,3)-(1,7))
            │   ├── flags: ∅
            │   ├── left:
            │   │   @ CallNode (location: (1,3)-(1,4))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :a
            │   │   ├── message_loc: (1,3)-(1,4) = "a"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── right:
            │   │   @ CallNode (location: (1,6)-(1,7))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :b
            │   │   ├── message_loc: (1,6)-(1,7) = "b"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   └── operator_loc: (1,4)-(1,6) = ".."
            ├── then_keyword_loc: (1,8)-(1,12) = "then"
            ├── statements: ∅
            ├── subsequent: ∅
            └── end_keyword_loc: (1,13)-(1,16) = "end"
prism-1.5.1/snapshots/seattlerb/float_with_if_modifier.txt000066400000000000000000000017161506127434000241230ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,10))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ IfNode (location: (1,0)-(1,10))
            ├── flags: newline
            ├── if_keyword_loc: (1,3)-(1,5) = "if"
            ├── predicate:
            │   @ TrueNode (location: (1,6)-(1,10))
            │   └── flags: static_literal
            ├── then_keyword_loc: ∅
            ├── statements:
            │   @ StatementsNode (location: (1,0)-(1,3))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ FloatNode (location: (1,0)-(1,3))
            │           ├── flags: newline, static_literal
            │           └── value: 1.0
            ├── subsequent: ∅
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/seattlerb/heredoc__backslash_dos_format.txt000066400000000000000000000015511506127434000254240ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: [:str]
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LocalVariableWriteNode (location: (1,0)-(1,12))
            ├── flags: newline
            ├── name: :str
            ├── depth: 0
            ├── name_loc: (1,0)-(1,3) = "str"
            ├── value:
            │   @ StringNode (location: (1,6)-(1,12))
            │   ├── flags: ∅
            │   ├── opening_loc: (1,6)-(1,12) = "<<-XXX"
            │   ├── content_loc: (2,0)-(4,0) = "before\\\r\nafter\r\n"
            │   ├── closing_loc: (4,0)-(5,0) = "XXX\r\n"
            │   └── unescaped: "beforeafter\n"
            └── operator_loc: (1,4)-(1,5) = "="
prism-1.5.1/snapshots/seattlerb/heredoc_backslash_nl.txt000066400000000000000000000016731506127434000235460ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,7))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ StringNode (location: (1,0)-(3,1))
        │   ├── flags: newline
        │   ├── opening_loc: (1,0)-(1,1) = "\""
        │   ├── content_loc: (1,1)-(3,0) = "  why would someone do this? \\\n  blah\n"
        │   ├── closing_loc: (3,0)-(3,1) = "\""
        │   └── unescaped: "  why would someone do this?   blah\n"
        └── @ StringNode (location: (5,0)-(5,7))
            ├── flags: newline
            ├── opening_loc: (5,0)-(5,7) = "<<-DESC"
            ├── content_loc: (6,0)-(8,0) = "  why would someone do this? \\\n  blah\n"
            ├── closing_loc: (8,0)-(9,0) = "DESC\n"
            └── unescaped: "  why would someone do this?   blah\n"
prism-1.5.1/snapshots/seattlerb/heredoc_bad_hex_escape.txt000066400000000000000000000015331506127434000240270ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: [:s]
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LocalVariableWriteNode (location: (1,0)-(1,9))
            ├── flags: newline
            ├── name: :s
            ├── depth: 0
            ├── name_loc: (1,0)-(1,1) = "s"
            ├── value:
            │   @ StringNode (location: (1,4)-(1,9))
            │   ├── flags: forced_utf8_encoding
            │   ├── opening_loc: (1,4)-(1,9) = "<
            ├── message_loc: (1,3)-(1,4) = ">"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,5)-(1,6))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,5)-(1,6))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/safe_call_rhs_newline.txt000066400000000000000000000027631506127434000237400ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: [:c]
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LocalVariableWriteNode (location: (1,0)-(1,8))
            ├── flags: newline
            ├── name: :c
            ├── depth: 0
            ├── name_loc: (1,0)-(1,1) = "c"
            ├── value:
            │   @ CallNode (location: (1,4)-(1,8))
            │   ├── flags: safe_navigation
            │   ├── receiver:
            │   │   @ CallNode (location: (1,4)-(1,5))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :a
            │   │   ├── message_loc: (1,4)-(1,5) = "a"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── call_operator_loc: (1,5)-(1,7) = "&."
            │   ├── name: :b
            │   ├── message_loc: (1,7)-(1,8) = "b"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            └── operator_loc: (1,2)-(1,3) = "="
prism-1.5.1/snapshots/seattlerb/safe_calls.txt000066400000000000000000000037331506127434000215240ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,10))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,10))
            ├── flags: newline, safe_navigation
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,4))
            │   ├── flags: safe_navigation
            │   ├── receiver:
            │   │   @ CallNode (location: (1,0)-(1,1))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :a
            │   │   ├── message_loc: (1,0)-(1,1) = "a"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── call_operator_loc: (1,1)-(1,3) = "&."
            │   ├── name: :b
            │   ├── message_loc: (1,3)-(1,4) = "b"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (1,4)-(1,6) = "&."
            ├── name: :c
            ├── message_loc: (1,6)-(1,7) = "c"
            ├── opening_loc: (1,7)-(1,8) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (1,8)-(1,9))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,8)-(1,9))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: (1,9)-(1,10) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/safe_op_asgn.txt000066400000000000000000000036531506127434000220550ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,11))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallOperatorWriteNode (location: (1,0)-(1,11))
            ├── flags: newline, safe_navigation
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (1,1)-(1,3) = "&."
            ├── message_loc: (1,3)-(1,4) = "b"
            ├── read_name: :b
            ├── write_name: :b=
            ├── binary_operator: :+
            ├── binary_operator_loc: (1,5)-(1,7) = "+="
            └── value:
                @ CallNode (location: (1,8)-(1,11))
                ├── flags: ignore_visibility
                ├── receiver: ∅
                ├── call_operator_loc: ∅
                ├── name: :x
                ├── message_loc: (1,8)-(1,9) = "x"
                ├── opening_loc: ∅
                ├── arguments:
                │   @ ArgumentsNode (location: (1,10)-(1,11))
                │   ├── flags: ∅
                │   └── arguments: (length: 1)
                │       └── @ IntegerNode (location: (1,10)-(1,11))
                │           ├── flags: static_literal, decimal
                │           └── value: 1
                ├── closing_loc: ∅
                └── block: ∅
prism-1.5.1/snapshots/seattlerb/safe_op_asgn2.txt000066400000000000000000000030361506127434000221320ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,1))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,1))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallOrWriteNode (location: (1,0)-(2,1))
            ├── flags: newline, safe_navigation
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (1,1)-(1,3) = "&."
            ├── message_loc: (1,3)-(1,4) = "b"
            ├── read_name: :b
            ├── write_name: :b=
            ├── operator_loc: (1,5)-(1,8) = "||="
            └── value:
                @ CallNode (location: (2,0)-(2,1))
                ├── flags: variable_call, ignore_visibility
                ├── receiver: ∅
                ├── call_operator_loc: ∅
                ├── name: :x
                ├── message_loc: (2,0)-(2,1) = "x"
                ├── opening_loc: ∅
                ├── arguments: ∅
                ├── closing_loc: ∅
                └── block: ∅
prism-1.5.1/snapshots/seattlerb/slashy_newlines_within_string.txt000066400000000000000000000054111506127434000256020ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(6,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(6,5))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(4,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :puts
        │   ├── message_loc: (1,0)-(1,4) = "puts"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,5)-(4,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (1,5)-(4,8))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (1,5)-(1,6) = "\""
        │   │           ├── content_loc: (1,6)-(4,7) = "hello\\\n my\\\n dear\\\n friend"
        │   │           ├── closing_loc: (4,7)-(4,8) = "\""
        │   │           └── unescaped: "hello my dear friend"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (6,0)-(6,5))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (6,0)-(6,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (6,0)-(6,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :+
            ├── message_loc: (6,2)-(6,3) = "+"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (6,4)-(6,5))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ CallNode (location: (6,4)-(6,5))
            │           ├── flags: variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :b
            │           ├── message_loc: (6,4)-(6,5) = "b"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/stabby_arg_no_paren.txt000066400000000000000000000027451506127434000234300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LambdaNode (location: (1,0)-(1,5))
            ├── flags: newline
            ├── locals: [:a]
            ├── operator_loc: (1,0)-(1,2) = "->"
            ├── opening_loc: (1,3)-(1,4) = "{"
            ├── closing_loc: (1,4)-(1,5) = "}"
            ├── parameters:
            │   @ BlockParametersNode (location: (1,2)-(1,3))
            │   ├── flags: ∅
            │   ├── parameters:
            │   │   @ ParametersNode (location: (1,2)-(1,3))
            │   │   ├── flags: ∅
            │   │   ├── requireds: (length: 1)
            │   │   │   └── @ RequiredParameterNode (location: (1,2)-(1,3))
            │   │   │       ├── flags: ∅
            │   │   │       └── name: :a
            │   │   ├── optionals: (length: 0)
            │   │   ├── rest: ∅
            │   │   ├── posts: (length: 0)
            │   │   ├── keywords: (length: 0)
            │   │   ├── keyword_rest: ∅
            │   │   └── block: ∅
            │   ├── locals: (length: 0)
            │   ├── opening_loc: ∅
            │   └── closing_loc: ∅
            └── body: ∅
prism-1.5.1/snapshots/seattlerb/stabby_arg_opt_splat_arg_block_omfg.txt000066400000000000000000000056601506127434000266460ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,23))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,23))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LambdaNode (location: (1,0)-(1,23))
            ├── flags: newline
            ├── locals: [:b, :c, :d, :e, :f]
            ├── operator_loc: (1,0)-(1,2) = "->"
            ├── opening_loc: (1,21)-(1,22) = "{"
            ├── closing_loc: (1,22)-(1,23) = "}"
            ├── parameters:
            │   @ BlockParametersNode (location: (1,2)-(1,21))
            │   ├── flags: ∅
            │   ├── parameters:
            │   │   @ ParametersNode (location: (1,3)-(1,20))
            │   │   ├── flags: ∅
            │   │   ├── requireds: (length: 1)
            │   │   │   └── @ RequiredParameterNode (location: (1,3)-(1,4))
            │   │   │       ├── flags: ∅
            │   │   │       └── name: :b
            │   │   ├── optionals: (length: 1)
            │   │   │   └── @ OptionalParameterNode (location: (1,6)-(1,9))
            │   │   │       ├── flags: ∅
            │   │   │       ├── name: :c
            │   │   │       ├── name_loc: (1,6)-(1,7) = "c"
            │   │   │       ├── operator_loc: (1,7)-(1,8) = "="
            │   │   │       └── value:
            │   │   │           @ IntegerNode (location: (1,8)-(1,9))
            │   │   │           ├── flags: static_literal, decimal
            │   │   │           └── value: 1
            │   │   ├── rest:
            │   │   │   @ RestParameterNode (location: (1,11)-(1,13))
            │   │   │   ├── flags: ∅
            │   │   │   ├── name: :d
            │   │   │   ├── name_loc: (1,12)-(1,13) = "d"
            │   │   │   └── operator_loc: (1,11)-(1,12) = "*"
            │   │   ├── posts: (length: 1)
            │   │   │   └── @ RequiredParameterNode (location: (1,15)-(1,16))
            │   │   │       ├── flags: ∅
            │   │   │       └── name: :e
            │   │   ├── keywords: (length: 0)
            │   │   ├── keyword_rest: ∅
            │   │   └── block:
            │   │       @ BlockParameterNode (location: (1,18)-(1,20))
            │   │       ├── flags: ∅
            │   │       ├── name: :f
            │   │       ├── name_loc: (1,19)-(1,20) = "f"
            │   │       └── operator_loc: (1,18)-(1,19) = "&"
            │   ├── locals: (length: 0)
            │   ├── opening_loc: (1,2)-(1,3) = "("
            │   └── closing_loc: (1,20)-(1,21) = ")"
            └── body: ∅
prism-1.5.1/snapshots/seattlerb/stabby_block_iter_call.txt000066400000000000000000000072111506127434000240770ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(4,3))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :x
            ├── message_loc: (1,0)-(1,1) = "x"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(4,3))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ LambdaNode (location: (1,2)-(4,3))
            │           ├── flags: ∅
            │           ├── locals: []
            │           ├── operator_loc: (1,2)-(1,4) = "->"
            │           ├── opening_loc: (1,8)-(1,10) = "do"
            │           ├── closing_loc: (4,0)-(4,3) = "end"
            │           ├── parameters:
            │           │   @ BlockParametersNode (location: (1,5)-(1,7))
            │           │   ├── flags: ∅
            │           │   ├── parameters: ∅
            │           │   ├── locals: (length: 0)
            │           │   ├── opening_loc: (1,5)-(1,6) = "("
            │           │   └── closing_loc: (1,6)-(1,7) = ")"
            │           └── body:
            │               @ StatementsNode (location: (2,0)-(3,3))
            │               ├── flags: ∅
            │               └── body: (length: 1)
            │                   └── @ CallNode (location: (2,0)-(3,3))
            │                       ├── flags: newline
            │                       ├── receiver:
            │                       │   @ CallNode (location: (2,0)-(2,1))
            │                       │   ├── flags: variable_call, ignore_visibility
            │                       │   ├── receiver: ∅
            │                       │   ├── call_operator_loc: ∅
            │                       │   ├── name: :a
            │                       │   ├── message_loc: (2,0)-(2,1) = "a"
            │                       │   ├── opening_loc: ∅
            │                       │   ├── arguments: ∅
            │                       │   ├── closing_loc: ∅
            │                       │   └── block: ∅
            │                       ├── call_operator_loc: (2,1)-(2,2) = "."
            │                       ├── name: :b
            │                       ├── message_loc: (2,2)-(2,3) = "b"
            │                       ├── opening_loc: ∅
            │                       ├── arguments: ∅
            │                       ├── closing_loc: ∅
            │                       └── block:
            │                           @ BlockNode (location: (2,4)-(3,3))
            │                           ├── flags: ∅
            │                           ├── locals: []
            │                           ├── parameters: ∅
            │                           ├── body: ∅
            │                           ├── opening_loc: (2,4)-(2,6) = "do"
            │                           └── closing_loc: (3,0)-(3,3) = "end"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/stabby_block_iter_call_no_target_with_arg.txt000066400000000000000000000066521506127434000300350ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(4,3))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :x
            ├── message_loc: (1,0)-(1,1) = "x"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(4,3))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ LambdaNode (location: (1,2)-(4,3))
            │           ├── flags: ∅
            │           ├── locals: []
            │           ├── operator_loc: (1,2)-(1,4) = "->"
            │           ├── opening_loc: (1,8)-(1,10) = "do"
            │           ├── closing_loc: (4,0)-(4,3) = "end"
            │           ├── parameters:
            │           │   @ BlockParametersNode (location: (1,5)-(1,7))
            │           │   ├── flags: ∅
            │           │   ├── parameters: ∅
            │           │   ├── locals: (length: 0)
            │           │   ├── opening_loc: (1,5)-(1,6) = "("
            │           │   └── closing_loc: (1,6)-(1,7) = ")"
            │           └── body:
            │               @ StatementsNode (location: (2,0)-(3,3))
            │               ├── flags: ∅
            │               └── body: (length: 1)
            │                   └── @ CallNode (location: (2,0)-(3,3))
            │                       ├── flags: newline, ignore_visibility
            │                       ├── receiver: ∅
            │                       ├── call_operator_loc: ∅
            │                       ├── name: :a
            │                       ├── message_loc: (2,0)-(2,1) = "a"
            │                       ├── opening_loc: (2,1)-(2,2) = "("
            │                       ├── arguments:
            │                       │   @ ArgumentsNode (location: (2,2)-(2,3))
            │                       │   ├── flags: ∅
            │                       │   └── arguments: (length: 1)
            │                       │       └── @ IntegerNode (location: (2,2)-(2,3))
            │                       │           ├── flags: static_literal, decimal
            │                       │           └── value: 1
            │                       ├── closing_loc: (2,3)-(2,4) = ")"
            │                       └── block:
            │                           @ BlockNode (location: (2,5)-(3,3))
            │                           ├── flags: ∅
            │                           ├── locals: []
            │                           ├── parameters: ∅
            │                           ├── body: ∅
            │                           ├── opening_loc: (2,5)-(2,7) = "do"
            │                           └── closing_loc: (3,0)-(3,3) = "end"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/stabby_block_kw.txt000066400000000000000000000035401506127434000225630ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LambdaNode (location: (1,0)-(1,13))
            ├── flags: newline
            ├── locals: [:k]
            ├── operator_loc: (1,0)-(1,2) = "->"
            ├── opening_loc: (1,10)-(1,11) = "{"
            ├── closing_loc: (1,12)-(1,13) = "}"
            ├── parameters:
            │   @ BlockParametersNode (location: (1,3)-(1,9))
            │   ├── flags: ∅
            │   ├── parameters:
            │   │   @ ParametersNode (location: (1,4)-(1,8))
            │   │   ├── flags: ∅
            │   │   ├── requireds: (length: 0)
            │   │   ├── optionals: (length: 0)
            │   │   ├── rest: ∅
            │   │   ├── posts: (length: 0)
            │   │   ├── keywords: (length: 1)
            │   │   │   └── @ OptionalKeywordParameterNode (location: (1,4)-(1,8))
            │   │   │       ├── flags: ∅
            │   │   │       ├── name: :k
            │   │   │       ├── name_loc: (1,4)-(1,6) = "k:"
            │   │   │       └── value:
            │   │   │           @ IntegerNode (location: (1,6)-(1,8))
            │   │   │           ├── flags: static_literal, decimal
            │   │   │           └── value: 42
            │   │   ├── keyword_rest: ∅
            │   │   └── block: ∅
            │   ├── locals: (length: 0)
            │   ├── opening_loc: (1,3)-(1,4) = "("
            │   └── closing_loc: (1,8)-(1,9) = ")"
            └── body: ∅
prism-1.5.1/snapshots/seattlerb/stabby_block_kw__required.txt000066400000000000000000000031261506127434000246220ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,11))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LambdaNode (location: (1,0)-(1,11))
            ├── flags: newline
            ├── locals: [:k]
            ├── operator_loc: (1,0)-(1,2) = "->"
            ├── opening_loc: (1,8)-(1,9) = "{"
            ├── closing_loc: (1,10)-(1,11) = "}"
            ├── parameters:
            │   @ BlockParametersNode (location: (1,3)-(1,7))
            │   ├── flags: ∅
            │   ├── parameters:
            │   │   @ ParametersNode (location: (1,4)-(1,6))
            │   │   ├── flags: ∅
            │   │   ├── requireds: (length: 0)
            │   │   ├── optionals: (length: 0)
            │   │   ├── rest: ∅
            │   │   ├── posts: (length: 0)
            │   │   ├── keywords: (length: 1)
            │   │   │   └── @ RequiredKeywordParameterNode (location: (1,4)-(1,6))
            │   │   │       ├── flags: ∅
            │   │   │       ├── name: :k
            │   │   │       └── name_loc: (1,4)-(1,6) = "k:"
            │   │   ├── keyword_rest: ∅
            │   │   └── block: ∅
            │   ├── locals: (length: 0)
            │   ├── opening_loc: (1,3)-(1,4) = "("
            │   └── closing_loc: (1,6)-(1,7) = ")"
            └── body: ∅
prism-1.5.1/snapshots/seattlerb/stabby_proc_scope.txt000066400000000000000000000032761506127434000231320ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,11))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LambdaNode (location: (1,0)-(1,11))
            ├── flags: newline
            ├── locals: [:a, :b]
            ├── operator_loc: (1,0)-(1,2) = "->"
            ├── opening_loc: (1,9)-(1,10) = "{"
            ├── closing_loc: (1,10)-(1,11) = "}"
            ├── parameters:
            │   @ BlockParametersNode (location: (1,2)-(1,8))
            │   ├── flags: ∅
            │   ├── parameters:
            │   │   @ ParametersNode (location: (1,3)-(1,4))
            │   │   ├── flags: ∅
            │   │   ├── requireds: (length: 1)
            │   │   │   └── @ RequiredParameterNode (location: (1,3)-(1,4))
            │   │   │       ├── flags: ∅
            │   │   │       └── name: :a
            │   │   ├── optionals: (length: 0)
            │   │   ├── rest: ∅
            │   │   ├── posts: (length: 0)
            │   │   ├── keywords: (length: 0)
            │   │   ├── keyword_rest: ∅
            │   │   └── block: ∅
            │   ├── locals: (length: 1)
            │   │   └── @ BlockLocalVariableNode (location: (1,6)-(1,7))
            │   │       ├── flags: ∅
            │   │       └── name: :b
            │   ├── opening_loc: (1,2)-(1,3) = "("
            │   └── closing_loc: (1,7)-(1,8) = ")"
            └── body: ∅
prism-1.5.1/snapshots/seattlerb/str_backslashes.txt000066400000000000000000000033301506127434000225740ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,204))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,204))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,204))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :x
            ├── message_loc: (1,0)-(1,1) = "x"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,204))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ StringNode (location: (1,2)-(1,204))
            │           ├── flags: ∅
            │           ├── opening_loc: (1,2)-(1,3) = "'"
            │           ├── content_loc: (1,3)-(1,203) = "\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n"
            │           ├── closing_loc: (1,203)-(1,204) = "'"
            │           └── unescaped: "\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/str_double_double_escaped_newline.txt000066400000000000000000000031231506127434000263220ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(1,7))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (1,0)-(1,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(1,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (1,2)-(1,7))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (1,2)-(1,3) = "\""
        │   │           ├── content_loc: (1,3)-(1,6) = "\\\\n"
        │   │           ├── closing_loc: (1,6)-(1,7) = "\""
        │   │           └── unescaped: "\\n"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (1,8)-(1,9))
            ├── flags: newline, variable_call, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :b
            ├── message_loc: (1,8)-(1,9) = "b"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/str_double_escaped_newline.txt000066400000000000000000000031201506127434000247650ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(1,6))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (1,0)-(1,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(1,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (1,2)-(1,6))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (1,2)-(1,3) = "\""
        │   │           ├── content_loc: (1,3)-(1,5) = "\\n"
        │   │           ├── closing_loc: (1,5)-(1,6) = "\""
        │   │           └── unescaped: "\n"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (1,7)-(1,8))
            ├── flags: newline, variable_call, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :b
            ├── message_loc: (1,7)-(1,8) = "b"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/str_double_newline.txt000066400000000000000000000031171506127434000233070ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,3))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(2,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (1,0)-(1,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(2,1))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (1,2)-(2,1))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (1,2)-(1,3) = "\""
        │   │           ├── content_loc: (1,3)-(2,0) = "\n"
        │   │           ├── closing_loc: (2,0)-(2,1) = "\""
        │   │           └── unescaped: "\n"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (2,2)-(2,3))
            ├── flags: newline, variable_call, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :b
            ├── message_loc: (2,2)-(2,3) = "b"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/str_evstr.txt000066400000000000000000000036221506127434000214600ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,8))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "\""
            ├── parts: (length: 2)
            │   ├── @ StringNode (location: (1,1)-(1,3))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (1,1)-(1,3) = "a "
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "a "
            │   └── @ EmbeddedStatementsNode (location: (1,3)-(1,7))
            │       ├── flags: ∅
            │       ├── opening_loc: (1,3)-(1,5) = "\#{"
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,5)-(1,6))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ CallNode (location: (1,5)-(1,6))
            │       │           ├── flags: variable_call, ignore_visibility
            │       │           ├── receiver: ∅
            │       │           ├── call_operator_loc: ∅
            │       │           ├── name: :b
            │       │           ├── message_loc: (1,5)-(1,6) = "b"
            │       │           ├── opening_loc: ∅
            │       │           ├── arguments: ∅
            │       │           ├── closing_loc: ∅
            │       │           └── block: ∅
            │       └── closing_loc: (1,6)-(1,7) = "}"
            └── closing_loc: (1,7)-(1,8) = "\""
prism-1.5.1/snapshots/seattlerb/str_evstr_escape.txt000066400000000000000000000044521506127434000230020ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,16))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,16))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,16))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "\""
            ├── parts: (length: 3)
            │   ├── @ StringNode (location: (1,1)-(1,3))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (1,1)-(1,3) = "a "
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "a "
            │   ├── @ EmbeddedStatementsNode (location: (1,3)-(1,7))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (1,3)-(1,5) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (1,5)-(1,6))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ CallNode (location: (1,5)-(1,6))
            │   │   │           ├── flags: variable_call, ignore_visibility
            │   │   │           ├── receiver: ∅
            │   │   │           ├── call_operator_loc: ∅
            │   │   │           ├── name: :b
            │   │   │           ├── message_loc: (1,5)-(1,6) = "b"
            │   │   │           ├── opening_loc: ∅
            │   │   │           ├── arguments: ∅
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── block: ∅
            │   │   └── closing_loc: (1,6)-(1,7) = "}"
            │   └── @ StringNode (location: (1,7)-(1,15))
            │       ├── flags: static_literal, forced_utf8_encoding, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (1,7)-(1,15) = "\\302\\275"
            │       ├── closing_loc: ∅
            │       └── unescaped: "½"
            └── closing_loc: (1,15)-(1,16) = "\""
prism-1.5.1/snapshots/seattlerb/str_heredoc_interp.txt000066400000000000000000000036741506127434000233160ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,4))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,4) = "<<\"\""
            ├── parts: (length: 2)
            │   ├── @ EmbeddedStatementsNode (location: (2,0)-(2,4))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (2,0)-(2,2) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (2,2)-(2,3))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ CallNode (location: (2,2)-(2,3))
            │   │   │           ├── flags: variable_call, ignore_visibility
            │   │   │           ├── receiver: ∅
            │   │   │           ├── call_operator_loc: ∅
            │   │   │           ├── name: :x
            │   │   │           ├── message_loc: (2,2)-(2,3) = "x"
            │   │   │           ├── opening_loc: ∅
            │   │   │           ├── arguments: ∅
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── block: ∅
            │   │   └── closing_loc: (2,3)-(2,4) = "}"
            │   └── @ StringNode (location: (2,4)-(4,0))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (2,4)-(4,0) = "\nblah2\n"
            │       ├── closing_loc: ∅
            │       └── unescaped: "\nblah2\n"
            └── closing_loc: (4,0)-(5,0) = "\n"
prism-1.5.1/snapshots/seattlerb/str_interp_ternary_or_label.txt000066400000000000000000000207471506127434000252300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,23))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,23))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,23))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "\""
            ├── parts: (length: 1)
            │   └── @ EmbeddedStatementsNode (location: (1,1)-(1,22))
            │       ├── flags: ∅
            │       ├── opening_loc: (1,1)-(1,3) = "\#{"
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,3)-(1,21))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ IfNode (location: (1,3)-(1,21))
            │       │           ├── flags: ∅
            │       │           ├── if_keyword_loc: ∅
            │       │           ├── predicate:
            │       │           │   @ CallNode (location: (1,3)-(1,7))
            │       │           │   ├── flags: ∅
            │       │           │   ├── receiver:
            │       │           │   │   @ CallNode (location: (1,3)-(1,4))
            │       │           │   │   ├── flags: variable_call, ignore_visibility
            │       │           │   │   ├── receiver: ∅
            │       │           │   │   ├── call_operator_loc: ∅
            │       │           │   │   ├── name: :a
            │       │           │   │   ├── message_loc: (1,3)-(1,4) = "a"
            │       │           │   │   ├── opening_loc: ∅
            │       │           │   │   ├── arguments: ∅
            │       │           │   │   ├── closing_loc: ∅
            │       │           │   │   └── block: ∅
            │       │           │   ├── call_operator_loc: (1,4)-(1,5) = "."
            │       │           │   ├── name: :b?
            │       │           │   ├── message_loc: (1,5)-(1,7) = "b?"
            │       │           │   ├── opening_loc: ∅
            │       │           │   ├── arguments: ∅
            │       │           │   ├── closing_loc: ∅
            │       │           │   └── block: ∅
            │       │           ├── then_keyword_loc: (1,8)-(1,9) = "?"
            │       │           ├── statements:
            │       │           │   @ StatementsNode (location: (1,10)-(1,17))
            │       │           │   ├── flags: ∅
            │       │           │   └── body: (length: 1)
            │       │           │       └── @ CallNode (location: (1,10)-(1,17))
            │       │           │           ├── flags: newline
            │       │           │           ├── receiver:
            │       │           │           │   @ CallNode (location: (1,10)-(1,14))
            │       │           │           │   ├── flags: ∅
            │       │           │           │   ├── receiver:
            │       │           │           │   │   @ StringNode (location: (1,10)-(1,12))
            │       │           │           │   │   ├── flags: ∅
            │       │           │           │   │   ├── opening_loc: (1,10)-(1,11) = "\""
            │       │           │           │   │   ├── content_loc: (1,11)-(1,11) = ""
            │       │           │           │   │   ├── closing_loc: (1,11)-(1,12) = "\""
            │       │           │           │   │   └── unescaped: ""
            │       │           │           │   ├── call_operator_loc: ∅
            │       │           │           │   ├── name: :+
            │       │           │           │   ├── message_loc: (1,12)-(1,13) = "+"
            │       │           │           │   ├── opening_loc: ∅
            │       │           │           │   ├── arguments:
            │       │           │           │   │   @ ArgumentsNode (location: (1,13)-(1,14))
            │       │           │           │   │   ├── flags: ∅
            │       │           │           │   │   └── arguments: (length: 1)
            │       │           │           │   │       └── @ CallNode (location: (1,13)-(1,14))
            │       │           │           │   │           ├── flags: variable_call, ignore_visibility
            │       │           │           │   │           ├── receiver: ∅
            │       │           │           │   │           ├── call_operator_loc: ∅
            │       │           │           │   │           ├── name: :a
            │       │           │           │   │           ├── message_loc: (1,13)-(1,14) = "a"
            │       │           │           │   │           ├── opening_loc: ∅
            │       │           │           │   │           ├── arguments: ∅
            │       │           │           │   │           ├── closing_loc: ∅
            │       │           │           │   │           └── block: ∅
            │       │           │           │   ├── closing_loc: ∅
            │       │           │           │   └── block: ∅
            │       │           │           ├── call_operator_loc: ∅
            │       │           │           ├── name: :+
            │       │           │           ├── message_loc: (1,14)-(1,15) = "+"
            │       │           │           ├── opening_loc: ∅
            │       │           │           ├── arguments:
            │       │           │           │   @ ArgumentsNode (location: (1,15)-(1,17))
            │       │           │           │   ├── flags: ∅
            │       │           │           │   └── arguments: (length: 1)
            │       │           │           │       └── @ StringNode (location: (1,15)-(1,17))
            │       │           │           │           ├── flags: ∅
            │       │           │           │           ├── opening_loc: (1,15)-(1,16) = "\""
            │       │           │           │           ├── content_loc: (1,16)-(1,16) = ""
            │       │           │           │           ├── closing_loc: (1,16)-(1,17) = "\""
            │       │           │           │           └── unescaped: ""
            │       │           │           ├── closing_loc: ∅
            │       │           │           └── block: ∅
            │       │           ├── subsequent:
            │       │           │   @ ElseNode (location: (1,17)-(1,21))
            │       │           │   ├── flags: ∅
            │       │           │   ├── else_keyword_loc: (1,17)-(1,18) = ":"
            │       │           │   ├── statements:
            │       │           │   │   @ StatementsNode (location: (1,19)-(1,21))
            │       │           │   │   ├── flags: ∅
            │       │           │   │   └── body: (length: 1)
            │       │           │   │       └── @ StringNode (location: (1,19)-(1,21))
            │       │           │   │           ├── flags: newline
            │       │           │   │           ├── opening_loc: (1,19)-(1,20) = "\""
            │       │           │   │           ├── content_loc: (1,20)-(1,20) = ""
            │       │           │   │           ├── closing_loc: (1,20)-(1,21) = "\""
            │       │           │   │           └── unescaped: ""
            │       │           │   └── end_keyword_loc: ∅
            │       │           └── end_keyword_loc: ∅
            │       └── closing_loc: (1,21)-(1,22) = "}"
            └── closing_loc: (1,22)-(1,23) = "\""
prism-1.5.1/snapshots/seattlerb/str_lit_concat_bad_encodings.txt000066400000000000000000000026331506127434000252740ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,66))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,66))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(2,66))
            ├── flags: newline, static_literal
            ├── opening_loc: ∅
            ├── parts: (length: 2)
            │   ├── @ StringNode (location: (1,0)-(1,62))
            │   │   ├── flags: static_literal, forced_utf8_encoding, frozen
            │   │   ├── opening_loc: (1,0)-(1,1) = "\""
            │   │   ├── content_loc: (1,1)-(1,61) = "\\xE3\\xD3\\x8B\\xE3\\x83\\xBC\\x83\\xE3\\x83\\xE3\\x82\\xB3\\xA3\\x82\\x99"
            │   │   ├── closing_loc: (1,61)-(1,62) = "\""
            │   │   └── unescaped: "\xE3Ӌー\x83\xE3\x83コ\xA3\x82\x99"
            │   └── @ StringNode (location: (2,8)-(2,66))
            │       ├── flags: static_literal, forced_utf8_encoding, frozen
            │       ├── opening_loc: (2,8)-(2,9) = "\""
            │       ├── content_loc: (2,9)-(2,65) = "\\xE3\\x83\\xB3\\xE3\\x83\\x8F\\xE3\\x82\\x9A\\xC3\\xBD;foo@bar.com"
            │       ├── closing_loc: (2,65)-(2,66) = "\""
            │       └── unescaped: "ンãƒã‚šÃ½;foo@bar.com"
            └── closing_loc: ∅
prism-1.5.1/snapshots/seattlerb/str_newline_hash_line_number.txt000066400000000000000000000012451506127434000253370ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,1))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,1))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ StringNode (location: (1,0)-(1,11))
        │   ├── flags: newline
        │   ├── opening_loc: (1,0)-(1,1) = "\""
        │   ├── content_loc: (1,1)-(1,10) = "\\n\\n\\n\\n#"
        │   ├── closing_loc: (1,10)-(1,11) = "\""
        │   └── unescaped: "\n\n\n\n#"
        └── @ IntegerNode (location: (2,0)-(2,1))
            ├── flags: newline, static_literal, decimal
            └── value: 1
prism-1.5.1/snapshots/seattlerb/str_pct_Q_nested.txt000066400000000000000000000044701506127434000227270ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,26))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,26))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,26))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,3) = "%Q["
            ├── parts: (length: 3)
            │   ├── @ StringNode (location: (1,3)-(1,11))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (1,3)-(1,11) = "before ["
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "before ["
            │   ├── @ EmbeddedStatementsNode (location: (1,11)-(1,18))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (1,11)-(1,13) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (1,13)-(1,17))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ CallNode (location: (1,13)-(1,17))
            │   │   │           ├── flags: variable_call, ignore_visibility
            │   │   │           ├── receiver: ∅
            │   │   │           ├── call_operator_loc: ∅
            │   │   │           ├── name: :nest
            │   │   │           ├── message_loc: (1,13)-(1,17) = "nest"
            │   │   │           ├── opening_loc: ∅
            │   │   │           ├── arguments: ∅
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── block: ∅
            │   │   └── closing_loc: (1,17)-(1,18) = "}"
            │   └── @ StringNode (location: (1,18)-(1,25))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (1,18)-(1,25) = "] after"
            │       ├── closing_loc: ∅
            │       └── unescaped: "] after"
            └── closing_loc: (1,25)-(1,26) = "]"
prism-1.5.1/snapshots/seattlerb/str_pct_nested_nested.txt000066400000000000000000000056571506127434000240210ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,20))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,20))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,20))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,2) = "%{"
            ├── parts: (length: 3)
            │   ├── @ StringNode (location: (1,2)-(1,5))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (1,2)-(1,5) = " { "
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: " { "
            │   ├── @ EmbeddedStatementsNode (location: (1,5)-(1,16))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (1,5)-(1,7) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (1,8)-(1,14))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ InterpolatedStringNode (location: (1,8)-(1,14))
            │   │   │           ├── flags: ∅
            │   │   │           ├── opening_loc: (1,8)-(1,9) = "\""
            │   │   │           ├── parts: (length: 1)
            │   │   │           │   └── @ EmbeddedStatementsNode (location: (1,9)-(1,13))
            │   │   │           │       ├── flags: ∅
            │   │   │           │       ├── opening_loc: (1,9)-(1,11) = "\#{"
            │   │   │           │       ├── statements:
            │   │   │           │       │   @ StatementsNode (location: (1,11)-(1,12))
            │   │   │           │       │   ├── flags: ∅
            │   │   │           │       │   └── body: (length: 1)
            │   │   │           │       │       └── @ IntegerNode (location: (1,11)-(1,12))
            │   │   │           │       │           ├── flags: static_literal, decimal
            │   │   │           │       │           └── value: 1
            │   │   │           │       └── closing_loc: (1,12)-(1,13) = "}"
            │   │   │           └── closing_loc: (1,13)-(1,14) = "\""
            │   │   └── closing_loc: (1,15)-(1,16) = "}"
            │   └── @ StringNode (location: (1,16)-(1,19))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (1,16)-(1,19) = " } "
            │       ├── closing_loc: ∅
            │       └── unescaped: " } "
            └── closing_loc: (1,19)-(1,20) = "}"
prism-1.5.1/snapshots/seattlerb/str_pct_q.txt000066400000000000000000000007661506127434000214310ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ StringNode (location: (1,0)-(1,9))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,3) = "%q{"
            ├── content_loc: (1,3)-(1,8) = "a b c"
            ├── closing_loc: (1,8)-(1,9) = "}"
            └── unescaped: "a b c"
prism-1.5.1/snapshots/seattlerb/str_single_double_escaped_newline.txt000066400000000000000000000031211506127434000263270ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(1,7))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (1,0)-(1,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(1,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (1,2)-(1,7))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (1,2)-(1,3) = "'"
        │   │           ├── content_loc: (1,3)-(1,6) = "\\\\n"
        │   │           ├── closing_loc: (1,6)-(1,7) = "'"
        │   │           └── unescaped: "\\n"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (1,8)-(1,9))
            ├── flags: newline, variable_call, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :b
            ├── message_loc: (1,8)-(1,9) = "b"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/str_single_escaped_newline.txt000066400000000000000000000031171506127434000250020ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(1,6))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (1,0)-(1,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(1,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (1,2)-(1,6))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (1,2)-(1,3) = "'"
        │   │           ├── content_loc: (1,3)-(1,5) = "\\n"
        │   │           ├── closing_loc: (1,5)-(1,6) = "'"
        │   │           └── unescaped: "\\n"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (1,7)-(1,8))
            ├── flags: newline, variable_call, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :b
            ├── message_loc: (1,7)-(1,8) = "b"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/str_single_newline.txt000066400000000000000000000031151506127434000233140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,3))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(2,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (1,0)-(1,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(2,1))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (1,2)-(2,1))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (1,2)-(1,3) = "'"
        │   │           ├── content_loc: (1,3)-(2,0) = "\n"
        │   │           ├── closing_loc: (2,0)-(2,1) = "'"
        │   │           └── unescaped: "\n"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (2,2)-(2,3))
            ├── flags: newline, variable_call, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :b
            ├── message_loc: (2,2)-(2,3) = "b"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/str_str.txt000066400000000000000000000033221506127434000211220ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,10))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,10))
            ├── flags: newline, static_literal, mutable
            ├── opening_loc: (1,0)-(1,1) = "\""
            ├── parts: (length: 2)
            │   ├── @ StringNode (location: (1,1)-(1,3))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (1,1)-(1,3) = "a "
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "a "
            │   └── @ EmbeddedStatementsNode (location: (1,3)-(1,9))
            │       ├── flags: ∅
            │       ├── opening_loc: (1,3)-(1,5) = "\#{"
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,5)-(1,8))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ StringNode (location: (1,5)-(1,8))
            │       │           ├── flags: static_literal, frozen
            │       │           ├── opening_loc: (1,5)-(1,6) = "'"
            │       │           ├── content_loc: (1,6)-(1,7) = "b"
            │       │           ├── closing_loc: (1,7)-(1,8) = "'"
            │       │           └── unescaped: "b"
            │       └── closing_loc: (1,8)-(1,9) = "}"
            └── closing_loc: (1,9)-(1,10) = "\""
prism-1.5.1/snapshots/seattlerb/str_str_str.txt000066400000000000000000000041001506127434000220050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,12))
            ├── flags: newline, static_literal, mutable
            ├── opening_loc: (1,0)-(1,1) = "\""
            ├── parts: (length: 3)
            │   ├── @ StringNode (location: (1,1)-(1,3))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (1,1)-(1,3) = "a "
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "a "
            │   ├── @ EmbeddedStatementsNode (location: (1,3)-(1,9))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (1,3)-(1,5) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (1,5)-(1,8))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ StringNode (location: (1,5)-(1,8))
            │   │   │           ├── flags: static_literal, frozen
            │   │   │           ├── opening_loc: (1,5)-(1,6) = "'"
            │   │   │           ├── content_loc: (1,6)-(1,7) = "b"
            │   │   │           ├── closing_loc: (1,7)-(1,8) = "'"
            │   │   │           └── unescaped: "b"
            │   │   └── closing_loc: (1,8)-(1,9) = "}"
            │   └── @ StringNode (location: (1,9)-(1,11))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (1,9)-(1,11) = " c"
            │       ├── closing_loc: ∅
            │       └── unescaped: " c"
            └── closing_loc: (1,11)-(1,12) = "\""
prism-1.5.1/snapshots/seattlerb/super_arg.txt000066400000000000000000000014711506127434000214140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ SuperNode (location: (1,0)-(1,8))
            ├── flags: newline
            ├── keyword_loc: (1,0)-(1,5) = "super"
            ├── lparen_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,6)-(1,8))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,6)-(1,8))
            │           ├── flags: static_literal, decimal
            │           └── value: 42
            ├── rparen_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/symbol_empty.txt000066400000000000000000000010231506127434000221410ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ SymbolNode (location: (1,0)-(1,3))
            ├── flags: newline, static_literal, forced_us_ascii_encoding
            ├── opening_loc: (1,0)-(1,2) = ":'"
            ├── value_loc: (1,2)-(1,2) = ""
            ├── closing_loc: (1,2)-(1,3) = "'"
            └── unescaped: ""
prism-1.5.1/snapshots/seattlerb/symbol_list.txt000066400000000000000000000071311506127434000217640ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ArrayNode (location: (1,0)-(1,13))
            ├── flags: newline
            ├── elements: (length: 2)
            │   ├── @ InterpolatedSymbolNode (location: (1,3)-(1,7))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: ∅
            │   │   ├── parts: (length: 1)
            │   │   │   └── @ EmbeddedStatementsNode (location: (1,3)-(1,7))
            │   │   │       ├── flags: ∅
            │   │   │       ├── opening_loc: (1,3)-(1,5) = "\#{"
            │   │   │       ├── statements:
            │   │   │       │   @ StatementsNode (location: (1,5)-(1,6))
            │   │   │       │   ├── flags: ∅
            │   │   │       │   └── body: (length: 1)
            │   │   │       │       └── @ CallNode (location: (1,5)-(1,6))
            │   │   │       │           ├── flags: variable_call, ignore_visibility
            │   │   │       │           ├── receiver: ∅
            │   │   │       │           ├── call_operator_loc: ∅
            │   │   │       │           ├── name: :a
            │   │   │       │           ├── message_loc: (1,5)-(1,6) = "a"
            │   │   │       │           ├── opening_loc: ∅
            │   │   │       │           ├── arguments: ∅
            │   │   │       │           ├── closing_loc: ∅
            │   │   │       │           └── block: ∅
            │   │   │       └── closing_loc: (1,6)-(1,7) = "}"
            │   │   └── closing_loc: ∅
            │   └── @ InterpolatedSymbolNode (location: (1,8)-(1,12))
            │       ├── flags: ∅
            │       ├── opening_loc: ∅
            │       ├── parts: (length: 1)
            │       │   └── @ EmbeddedStatementsNode (location: (1,8)-(1,12))
            │       │       ├── flags: ∅
            │       │       ├── opening_loc: (1,8)-(1,10) = "\#{"
            │       │       ├── statements:
            │       │       │   @ StatementsNode (location: (1,10)-(1,11))
            │       │       │   ├── flags: ∅
            │       │       │   └── body: (length: 1)
            │       │       │       └── @ CallNode (location: (1,10)-(1,11))
            │       │       │           ├── flags: variable_call, ignore_visibility
            │       │       │           ├── receiver: ∅
            │       │       │           ├── call_operator_loc: ∅
            │       │       │           ├── name: :b
            │       │       │           ├── message_loc: (1,10)-(1,11) = "b"
            │       │       │           ├── opening_loc: ∅
            │       │       │           ├── arguments: ∅
            │       │       │           ├── closing_loc: ∅
            │       │       │           └── block: ∅
            │       │       └── closing_loc: (1,11)-(1,12) = "}"
            │       └── closing_loc: ∅
            ├── opening_loc: (1,0)-(1,3) = "%I["
            └── closing_loc: (1,12)-(1,13) = "]"
prism-1.5.1/snapshots/seattlerb/symbols.txt000066400000000000000000000030001506127434000211030ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ArrayNode (location: (1,0)-(1,9))
            ├── flags: newline, static_literal
            ├── elements: (length: 3)
            │   ├── @ SymbolNode (location: (1,3)-(1,4))
            │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │   ├── opening_loc: ∅
            │   │   ├── value_loc: (1,3)-(1,4) = "a"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "a"
            │   ├── @ SymbolNode (location: (1,5)-(1,6))
            │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │   ├── opening_loc: ∅
            │   │   ├── value_loc: (1,5)-(1,6) = "b"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "b"
            │   └── @ SymbolNode (location: (1,7)-(1,8))
            │       ├── flags: static_literal, forced_us_ascii_encoding
            │       ├── opening_loc: ∅
            │       ├── value_loc: (1,7)-(1,8) = "c"
            │       ├── closing_loc: ∅
            │       └── unescaped: "c"
            ├── opening_loc: (1,0)-(1,3) = "%i("
            └── closing_loc: (1,8)-(1,9) = ")"
prism-1.5.1/snapshots/seattlerb/symbols_empty.txt000066400000000000000000000007171506127434000223350ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ArrayNode (location: (1,0)-(1,4))
            ├── flags: newline, static_literal
            ├── elements: (length: 0)
            ├── opening_loc: (1,0)-(1,3) = "%i("
            └── closing_loc: (1,3)-(1,4) = ")"
prism-1.5.1/snapshots/seattlerb/symbols_empty_space.txt000066400000000000000000000007171506127434000235100ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ArrayNode (location: (1,0)-(1,5))
            ├── flags: newline, static_literal
            ├── elements: (length: 0)
            ├── opening_loc: (1,0)-(1,3) = "%i("
            └── closing_loc: (1,4)-(1,5) = ")"
prism-1.5.1/snapshots/seattlerb/symbols_interp.txt000066400000000000000000000030311506127434000224700ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,15))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ArrayNode (location: (1,0)-(1,15))
            ├── flags: newline, static_literal
            ├── elements: (length: 3)
            │   ├── @ SymbolNode (location: (1,3)-(1,4))
            │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │   ├── opening_loc: ∅
            │   │   ├── value_loc: (1,3)-(1,4) = "a"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "a"
            │   ├── @ SymbolNode (location: (1,5)-(1,12))
            │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │   ├── opening_loc: ∅
            │   │   ├── value_loc: (1,5)-(1,12) = "b\#{1+1}"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "b\#{1+1}"
            │   └── @ SymbolNode (location: (1,13)-(1,14))
            │       ├── flags: static_literal, forced_us_ascii_encoding
            │       ├── opening_loc: ∅
            │       ├── value_loc: (1,13)-(1,14) = "c"
            │       ├── closing_loc: ∅
            │       └── unescaped: "c"
            ├── opening_loc: (1,0)-(1,3) = "%i("
            └── closing_loc: (1,14)-(1,15) = ")"
prism-1.5.1/snapshots/seattlerb/thingy.txt000066400000000000000000000052551506127434000207330ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,7))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(1,6))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :f
        │   │   ├── message_loc: (1,0)-(1,1) = "f"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (1,1)-(1,2) = "."
        │   ├── name: :call
        │   ├── message_loc: ∅
        │   ├── opening_loc: (1,2)-(1,3) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,3)-(1,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (1,3)-(1,5))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 42
        │   ├── closing_loc: (1,5)-(1,6) = ")"
        │   └── block: ∅
        └── @ CallNode (location: (3,0)-(3,7))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (3,0)-(3,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :f
            │   ├── message_loc: (3,0)-(3,1) = "f"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (3,1)-(3,3) = "::"
            ├── name: :call
            ├── message_loc: ∅
            ├── opening_loc: (3,3)-(3,4) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (3,4)-(3,6))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (3,4)-(3,6))
            │           ├── flags: static_literal, decimal
            │           └── value: 42
            ├── closing_loc: (3,6)-(3,7) = ")"
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/uminus_float.txt000066400000000000000000000005311506127434000221260ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ FloatNode (location: (1,0)-(1,4))
            ├── flags: newline, static_literal
            └── value: -0.0
prism-1.5.1/snapshots/seattlerb/unary_minus.txt000066400000000000000000000020761506127434000220000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,2))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,2))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,2))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,1)-(1,2))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,1)-(1,2) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :-@
            ├── message_loc: (1,0)-(1,1) = "-"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/unary_plus.txt000066400000000000000000000020761506127434000216300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,2))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,2))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,2))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,1)-(1,2))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,1)-(1,2) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :+@
            ├── message_loc: (1,0)-(1,1) = "+"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/unary_plus_on_literal.txt000066400000000000000000000016531506127434000240400ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,3))
            ├── flags: newline
            ├── receiver:
            │   @ SymbolNode (location: (1,1)-(1,3))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (1,1)-(1,2) = ":"
            │   ├── value_loc: (1,2)-(1,3) = "a"
            │   ├── closing_loc: ∅
            │   └── unescaped: "a"
            ├── call_operator_loc: ∅
            ├── name: :+@
            ├── message_loc: (1,0)-(1,1) = "+"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/unary_tilde.txt000066400000000000000000000020751506127434000217450ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,2))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,2))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,2))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,1)-(1,2))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,1)-(1,2) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :~
            ├── message_loc: (1,0)-(1,1) = "~"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/utf8_bom.txt000066400000000000000000000016701506127434000211510ustar00rootroot00000000000000@ ProgramNode (location: (2,0)-(2,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (2,0)-(2,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (2,0)-(2,3))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :p
            ├── message_loc: (2,0)-(2,1) = "p"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (2,2)-(2,3))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (2,2)-(2,3))
            │           ├── flags: static_literal, decimal
            │           └── value: 0
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/seattlerb/when_splat.txt000066400000000000000000000043671506127434000216000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,25))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,25))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseNode (location: (1,0)-(1,25))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (1,5)-(1,6))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,5)-(1,6) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ WhenNode (location: (1,8)-(1,20))
            │       ├── flags: ∅
            │       ├── keyword_loc: (1,8)-(1,12) = "when"
            │       ├── conditions: (length: 1)
            │       │   └── @ SplatNode (location: (1,13)-(1,15))
            │       │       ├── flags: ∅
            │       │       ├── operator_loc: (1,13)-(1,14) = "*"
            │       │       └── expression:
            │       │           @ CallNode (location: (1,14)-(1,15))
            │       │           ├── flags: variable_call, ignore_visibility
            │       │           ├── receiver: ∅
            │       │           ├── call_operator_loc: ∅
            │       │           ├── name: :b
            │       │           ├── message_loc: (1,14)-(1,15) = "b"
            │       │           ├── opening_loc: ∅
            │       │           ├── arguments: ∅
            │       │           ├── closing_loc: ∅
            │       │           └── block: ∅
            │       ├── then_keyword_loc: (1,16)-(1,20) = "then"
            │       └── statements: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,22)-(1,25) = "end"
prism-1.5.1/snapshots/seattlerb/words_interp.txt000066400000000000000000000035771506127434000221550ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ArrayNode (location: (1,0)-(1,9))
            ├── flags: newline
            ├── elements: (length: 1)
            │   └── @ InterpolatedStringNode (location: (1,3)-(1,8))
            │       ├── flags: ∅
            │       ├── opening_loc: ∅
            │       ├── parts: (length: 2)
            │       │   ├── @ EmbeddedStatementsNode (location: (1,3)-(1,7))
            │       │   │   ├── flags: ∅
            │       │   │   ├── opening_loc: (1,3)-(1,5) = "\#{"
            │       │   │   ├── statements:
            │       │   │   │   @ StatementsNode (location: (1,5)-(1,6))
            │       │   │   │   ├── flags: ∅
            │       │   │   │   └── body: (length: 1)
            │       │   │   │       └── @ IntegerNode (location: (1,5)-(1,6))
            │       │   │   │           ├── flags: static_literal, decimal
            │       │   │   │           └── value: 1
            │       │   │   └── closing_loc: (1,6)-(1,7) = "}"
            │       │   └── @ StringNode (location: (1,7)-(1,8))
            │       │       ├── flags: static_literal, frozen
            │       │       ├── opening_loc: ∅
            │       │       ├── content_loc: (1,7)-(1,8) = "b"
            │       │       ├── closing_loc: ∅
            │       │       └── unescaped: "b"
            │       └── closing_loc: ∅
            ├── opening_loc: (1,0)-(1,3) = "%W("
            └── closing_loc: (1,8)-(1,9) = ")"
prism-1.5.1/snapshots/single_method_call_with_bang.txt000066400000000000000000000011701506127434000232720ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,4))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :foo!
            ├── message_loc: (1,0)-(1,4) = "foo!"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/single_quote_heredocs.txt000066400000000000000000000011031506127434000220020ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ StringNode (location: (1,0)-(1,8))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,8) = "<<-'EOS'"
            ├── content_loc: (2,0)-(3,0) = "    cd L:\\Work\\MG3710IQPro\\Develop\n"
            ├── closing_loc: (3,0)-(4,0) = "EOS\n"
            └── unescaped: "    cd L:\\Work\\MG3710IQPro\\Develop\n"
prism-1.5.1/snapshots/spanning_heredoc.txt000066400000000000000000000630241506127434000207500ustar00rootroot00000000000000@ ProgramNode (location: (4,0)-(63,2))
├── flags: ∅
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (4,0)-(63,2))
    ├── flags: ∅
    └── body: (length: 14)
        ├── @ CallNode (location: (4,0)-(7,7))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :pp
        │   ├── message_loc: (4,0)-(4,2) = "pp"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (4,3)-(7,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (4,3)-(7,7))
        │   │           ├── flags: ∅
        │   │           ├── receiver:
        │   │           │   @ StringNode (location: (4,3)-(4,7))
        │   │           │   ├── flags: ∅
        │   │           │   ├── opening_loc: (4,3)-(4,7) = "<<-A"
        │   │           │   ├── content_loc: (5,0)-(6,0) = "a\n"
        │   │           │   ├── closing_loc: (6,0)-(7,0) = "A\n"
        │   │           │   └── unescaped: "a\n"
        │   │           ├── call_operator_loc: (4,7)-(4,8) = "."
        │   │           ├── name: :gsub
        │   │           ├── message_loc: (4,8)-(4,12) = "gsub"
        │   │           ├── opening_loc: (4,12)-(4,13) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (4,13)-(7,6))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 2)
        │   │           │       ├── @ InterpolatedRegularExpressionNode (location: (4,13)-(7,2))
        │   │           │       │   ├── flags: static_literal
        │   │           │       │   ├── opening_loc: (4,13)-(4,14) = "/"
        │   │           │       │   ├── parts: (length: 2)
        │   │           │       │   │   ├── @ StringNode (location: (4,14)-(4,16))
        │   │           │       │   │   │   ├── flags: static_literal, frozen
        │   │           │       │   │   │   ├── opening_loc: ∅
        │   │           │       │   │   │   ├── content_loc: (4,14)-(4,16) = "b\\"
        │   │           │       │   │   │   ├── closing_loc: ∅
        │   │           │       │   │   │   └── unescaped: "b"
        │   │           │       │   │   └── @ StringNode (location: (7,0)-(7,1))
        │   │           │       │   │       ├── flags: static_literal, frozen
        │   │           │       │   │       ├── opening_loc: ∅
        │   │           │       │   │       ├── content_loc: (7,0)-(7,1) = "b"
        │   │           │       │   │       ├── closing_loc: ∅
        │   │           │       │   │       └── unescaped: "b"
        │   │           │       │   └── closing_loc: (7,1)-(7,2) = "/"
        │   │           │       └── @ StringNode (location: (7,4)-(7,6))
        │   │           │           ├── flags: ∅
        │   │           │           ├── opening_loc: (7,4)-(7,5) = "\""
        │   │           │           ├── content_loc: (7,5)-(7,5) = ""
        │   │           │           ├── closing_loc: (7,5)-(7,6) = "\""
        │   │           │           └── unescaped: ""
        │   │           ├── closing_loc: (7,6)-(7,7) = ")"
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (10,0)-(13,2))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :pp
        │   ├── message_loc: (10,0)-(10,2) = "pp"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (10,3)-(13,2))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ StringNode (location: (10,3)-(10,7))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (10,3)-(10,7) = "<<-A"
        │   │       │   ├── content_loc: (11,0)-(12,0) = "c\n"
        │   │       │   ├── closing_loc: (12,0)-(13,0) = "A\n"
        │   │       │   └── unescaped: "c\n"
        │   │       └── @ InterpolatedStringNode (location: (10,9)-(13,2))
        │   │           ├── flags: static_literal
        │   │           ├── opening_loc: (10,9)-(10,10) = "\""
        │   │           ├── parts: (length: 2)
        │   │           │   ├── @ StringNode (location: (10,10)-(10,12))
        │   │           │   │   ├── flags: static_literal, frozen
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (10,10)-(10,12) = "d\\"
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "d"
        │   │           │   └── @ StringNode (location: (13,0)-(13,1))
        │   │           │       ├── flags: static_literal, frozen
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (13,0)-(13,1) = "d"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "d"
        │   │           └── closing_loc: (13,1)-(13,2) = "\""
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (16,0)-(19,2))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :pp
        │   ├── message_loc: (16,0)-(16,2) = "pp"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (16,3)-(19,2))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ StringNode (location: (16,3)-(16,7))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (16,3)-(16,7) = "<<-A"
        │   │       │   ├── content_loc: (17,0)-(18,0) = "e\n"
        │   │       │   ├── closing_loc: (18,0)-(19,0) = "A\n"
        │   │       │   └── unescaped: "e\n"
        │   │       └── @ InterpolatedStringNode (location: (16,9)-(19,2))
        │   │           ├── flags: static_literal
        │   │           ├── opening_loc: (16,9)-(16,12) = "%q["
        │   │           ├── parts: (length: 2)
        │   │           │   ├── @ StringNode (location: (16,12)-(16,14))
        │   │           │   │   ├── flags: static_literal, frozen
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (16,12)-(16,14) = "f\\"
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "f\\\n"
        │   │           │   └── @ StringNode (location: (19,0)-(19,1))
        │   │           │       ├── flags: static_literal, frozen
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (19,0)-(19,1) = "f"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "f"
        │   │           └── closing_loc: (19,1)-(19,2) = "]"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (22,0)-(25,2))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :pp
        │   ├── message_loc: (22,0)-(22,2) = "pp"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (22,3)-(25,2))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ StringNode (location: (22,3)-(22,7))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (22,3)-(22,7) = "<<-A"
        │   │       │   ├── content_loc: (23,0)-(24,0) = "g\n"
        │   │       │   ├── closing_loc: (24,0)-(25,0) = "A\n"
        │   │       │   └── unescaped: "g\n"
        │   │       └── @ InterpolatedStringNode (location: (22,9)-(25,2))
        │   │           ├── flags: static_literal
        │   │           ├── opening_loc: (22,9)-(22,12) = "%Q["
        │   │           ├── parts: (length: 2)
        │   │           │   ├── @ StringNode (location: (22,12)-(22,14))
        │   │           │   │   ├── flags: static_literal, frozen
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (22,12)-(22,14) = "h\\"
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "h"
        │   │           │   └── @ StringNode (location: (25,0)-(25,1))
        │   │           │       ├── flags: static_literal, frozen
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (25,0)-(25,1) = "h"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "h"
        │   │           └── closing_loc: (25,1)-(25,2) = "]"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (28,0)-(31,2))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :pp
        │   ├── message_loc: (28,0)-(28,2) = "pp"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (28,3)-(31,2))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ StringNode (location: (28,3)-(28,7))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (28,3)-(28,7) = "<<-A"
        │   │       │   ├── content_loc: (29,0)-(30,0) = "i\n"
        │   │       │   ├── closing_loc: (30,0)-(31,0) = "A\n"
        │   │       │   └── unescaped: "i\n"
        │   │       └── @ ArrayNode (location: (28,9)-(31,2))
        │   │           ├── flags: ∅
        │   │           ├── elements: (length: 2)
        │   │           │   ├── @ StringNode (location: (28,12)-(28,14))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (28,12)-(28,14) = "j\\"
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "j\n"
        │   │           │   └── @ StringNode (location: (31,0)-(31,1))
        │   │           │       ├── flags: ∅
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (31,0)-(31,1) = "j"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "j"
        │   │           ├── opening_loc: (28,9)-(28,12) = "%w["
        │   │           └── closing_loc: (31,1)-(31,2) = "]"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (35,0)-(38,2))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :pp
        │   ├── message_loc: (35,0)-(35,2) = "pp"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (35,3)-(38,2))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ StringNode (location: (35,3)-(35,7))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (35,3)-(35,7) = "<<-A"
        │   │       │   ├── content_loc: (36,0)-(37,0) = "k\n"
        │   │       │   ├── closing_loc: (37,0)-(38,0) = "A\n"
        │   │       │   └── unescaped: "k\n"
        │   │       └── @ ArrayNode (location: (35,9)-(38,2))
        │   │           ├── flags: static_literal
        │   │           ├── elements: (length: 1)
        │   │           │   └── @ InterpolatedStringNode (location: (35,12)-(38,1))
        │   │           │       ├── flags: static_literal
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── parts: (length: 2)
        │   │           │       │   ├── @ StringNode (location: (35,12)-(35,14))
        │   │           │       │   │   ├── flags: static_literal, frozen
        │   │           │       │   │   ├── opening_loc: ∅
        │   │           │       │   │   ├── content_loc: (35,12)-(35,14) = "l\\"
        │   │           │       │   │   ├── closing_loc: ∅
        │   │           │       │   │   └── unescaped: "l\n"
        │   │           │       │   └── @ StringNode (location: (38,0)-(38,1))
        │   │           │       │       ├── flags: static_literal, frozen
        │   │           │       │       ├── opening_loc: ∅
        │   │           │       │       ├── content_loc: (38,0)-(38,1) = "l"
        │   │           │       │       ├── closing_loc: ∅
        │   │           │       │       └── unescaped: "l"
        │   │           │       └── closing_loc: ∅
        │   │           ├── opening_loc: (35,9)-(35,12) = "%W["
        │   │           └── closing_loc: (38,1)-(38,2) = "]"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (41,0)-(44,2))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :pp
        │   ├── message_loc: (41,0)-(41,2) = "pp"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (41,3)-(44,2))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ StringNode (location: (41,3)-(41,7))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (41,3)-(41,7) = "<<-A"
        │   │       │   ├── content_loc: (42,0)-(43,0) = "m\n"
        │   │       │   ├── closing_loc: (43,0)-(44,0) = "A\n"
        │   │       │   └── unescaped: "m\n"
        │   │       └── @ ArrayNode (location: (41,9)-(44,2))
        │   │           ├── flags: static_literal
        │   │           ├── elements: (length: 2)
        │   │           │   ├── @ SymbolNode (location: (41,12)-(41,14))
        │   │           │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── value_loc: (41,12)-(41,14) = "n\\"
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "n\n"
        │   │           │   └── @ SymbolNode (location: (44,0)-(44,1))
        │   │           │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── value_loc: (44,0)-(44,1) = "n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "n"
        │   │           ├── opening_loc: (41,9)-(41,12) = "%i["
        │   │           └── closing_loc: (44,1)-(44,2) = "]"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (48,0)-(51,2))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :pp
        │   ├── message_loc: (48,0)-(48,2) = "pp"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (48,3)-(51,2))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ StringNode (location: (48,3)-(48,7))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (48,3)-(48,7) = "<<-A"
        │   │       │   ├── content_loc: (49,0)-(50,0) = "o\n"
        │   │       │   ├── closing_loc: (50,0)-(51,0) = "A\n"
        │   │       │   └── unescaped: "o\n"
        │   │       └── @ ArrayNode (location: (48,9)-(51,2))
        │   │           ├── flags: static_literal
        │   │           ├── elements: (length: 1)
        │   │           │   └── @ InterpolatedSymbolNode (location: (48,12)-(48,14))
        │   │           │       ├── flags: static_literal
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── parts: (length: 2)
        │   │           │       │   ├── @ StringNode (location: (48,12)-(48,14))
        │   │           │       │   │   ├── flags: static_literal, frozen
        │   │           │       │   │   ├── opening_loc: ∅
        │   │           │       │   │   ├── content_loc: (48,12)-(48,14) = "p\\"
        │   │           │       │   │   ├── closing_loc: ∅
        │   │           │       │   │   └── unescaped: "p\n"
        │   │           │       │   └── @ StringNode (location: (48,12)-(48,14))
        │   │           │       │       ├── flags: static_literal, frozen
        │   │           │       │       ├── opening_loc: ∅
        │   │           │       │       ├── content_loc: (48,12)-(48,14) = "p\\"
        │   │           │       │       ├── closing_loc: ∅
        │   │           │       │       └── unescaped: "p"
        │   │           │       └── closing_loc: ∅
        │   │           ├── opening_loc: (48,9)-(48,12) = "%I["
        │   │           └── closing_loc: (51,1)-(51,2) = "]"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ StringNode (location: (53,0)-(53,3))
        │   ├── flags: newline
        │   ├── opening_loc: (53,0)-(53,3) = "<)"
        │   │   │   └── closing_loc: (55,6)-(55,7) = "/"
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :=~
        │   │   ├── message_loc: (55,8)-(55,10) = "=~"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (55,11)-(55,13))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ StringNode (location: (55,11)-(55,13))
        │   │   │           ├── flags: ∅
        │   │   │           ├── opening_loc: (55,11)-(55,12) = "'"
        │   │   │           ├── content_loc: (55,12)-(55,12) = ""
        │   │   │           ├── closing_loc: (55,12)-(55,13) = "'"
        │   │   │           └── unescaped: ""
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── targets: (length: 1)
        │       └── @ LocalVariableTargetNode (location: (53,5)-(55,7))
        │           ├── flags: ∅
        │           ├── name: :a
        │           └── depth: 0
        ├── @ StringNode (location: (57,0)-(57,3))
        │   ├── flags: newline
        │   ├── opening_loc: (57,0)-(57,3) = "<="
        ├── @ SymbolNode (location: (88,0)-(88,3))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (88,0)-(88,1) = ":"
        │   ├── value_loc: (88,1)-(88,3) = ">>"
        │   ├── closing_loc: ∅
        │   └── unescaped: ">>"
        ├── @ SymbolNode (location: (90,0)-(90,2))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (90,0)-(90,1) = ":"
        │   ├── value_loc: (90,1)-(90,2) = ">"
        │   ├── closing_loc: ∅
        │   └── unescaped: ">"
        ├── @ SymbolNode (location: (92,0)-(92,4))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (92,0)-(92,1) = ":"
        │   ├── value_loc: (92,1)-(92,4) = "<=>"
        │   ├── closing_loc: ∅
        │   └── unescaped: "<=>"
        ├── @ SymbolNode (location: (94,0)-(94,3))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (94,0)-(94,1) = ":"
        │   ├── value_loc: (94,1)-(94,3) = "<="
        │   ├── closing_loc: ∅
        │   └── unescaped: "<="
        ├── @ SymbolNode (location: (96,0)-(96,3))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (96,0)-(96,1) = ":"
        │   ├── value_loc: (96,1)-(96,3) = "<<"
        │   ├── closing_loc: ∅
        │   └── unescaped: "<<"
        ├── @ SymbolNode (location: (98,0)-(98,2))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (98,0)-(98,1) = ":"
        │   ├── value_loc: (98,1)-(98,2) = "<"
        │   ├── closing_loc: ∅
        │   └── unescaped: "<"
        ├── @ SymbolNode (location: (100,0)-(100,9))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (100,0)-(100,1) = ":"
        │   ├── value_loc: (100,1)-(100,9) = "__LINE__"
        │   ├── closing_loc: ∅
        │   └── unescaped: "__LINE__"
        ├── @ SymbolNode (location: (102,0)-(102,9))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (102,0)-(102,1) = ":"
        │   ├── value_loc: (102,1)-(102,9) = "__FILE__"
        │   ├── closing_loc: ∅
        │   └── unescaped: "__FILE__"
        └── @ SymbolNode (location: (104,0)-(104,13))
            ├── flags: newline, static_literal, forced_us_ascii_encoding
            ├── opening_loc: (104,0)-(104,1) = ":"
            ├── value_loc: (104,1)-(104,13) = "__ENCODING__"
            ├── closing_loc: ∅
            └── unescaped: "__ENCODING__"
prism-1.5.1/snapshots/ternary_operator.txt000066400000000000000000000434201506127434000210370ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(15,12))
├── flags: ∅
├── locals: [:_a]
└── statements:
    @ StatementsNode (location: (1,0)-(15,12))
    ├── flags: ∅
    └── body: (length: 8)
        ├── @ IfNode (location: (1,0)-(1,9))
        │   ├── flags: newline
        │   ├── if_keyword_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (1,0)-(1,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (1,0)-(1,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: (1,2)-(1,3) = "?"
        │   ├── statements:
        │   │   @ StatementsNode (location: (1,4)-(1,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (1,4)-(1,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (1,4)-(1,5) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── subsequent:
        │   │   @ ElseNode (location: (1,6)-(1,9))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (1,6)-(1,7) = ":"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (1,8)-(1,9))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (1,8)-(1,9))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :c
        │   │   │           ├── message_loc: (1,8)-(1,9) = "c"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── end_keyword_loc: ∅
        │   └── end_keyword_loc: ∅
        ├── @ IfNode (location: (3,0)-(3,27))
        │   ├── flags: newline
        │   ├── if_keyword_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (3,0)-(3,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (3,0)-(3,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: (3,2)-(3,3) = "?"
        │   ├── statements:
        │   │   @ StatementsNode (location: (3,4)-(3,14))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ DefinedNode (location: (3,4)-(3,14))
        │   │           ├── flags: newline
        │   │           ├── lparen_loc: ∅
        │   │           ├── value:
        │   │           │   @ CallNode (location: (3,13)-(3,14))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :b
        │   │           │   ├── message_loc: (3,13)-(3,14) = "b"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── rparen_loc: ∅
        │   │           └── keyword_loc: (3,4)-(3,12) = "defined?"
        │   ├── subsequent:
        │   │   @ ElseNode (location: (3,15)-(3,27))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (3,15)-(3,16) = ":"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (3,17)-(3,27))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ DefinedNode (location: (3,17)-(3,27))
        │   │   │           ├── flags: newline
        │   │   │           ├── lparen_loc: ∅
        │   │   │           ├── value:
        │   │   │           │   @ CallNode (location: (3,26)-(3,27))
        │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── name: :c
        │   │   │           │   ├── message_loc: (3,26)-(3,27) = "c"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── block: ∅
        │   │   │           ├── rparen_loc: ∅
        │   │   │           └── keyword_loc: (3,17)-(3,25) = "defined?"
        │   │   └── end_keyword_loc: ∅
        │   └── end_keyword_loc: ∅
        ├── @ IfNode (location: (5,0)-(5,15))
        │   ├── flags: newline
        │   ├── if_keyword_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (5,0)-(5,6))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :empty?
        │   │   ├── message_loc: (5,0)-(5,6) = "empty?"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: (5,6)-(5,7) = "?"
        │   ├── statements:
        │   │   @ StatementsNode (location: (5,7)-(5,11))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ TrueNode (location: (5,7)-(5,11))
        │   │           └── flags: newline, static_literal
        │   ├── subsequent:
        │   │   @ ElseNode (location: (5,11)-(5,15))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (5,11)-(5,12) = ":"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (5,12)-(5,15))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ NilNode (location: (5,12)-(5,15))
        │   │   │           └── flags: newline, static_literal
        │   │   └── end_keyword_loc: ∅
        │   └── end_keyword_loc: ∅
        ├── @ IfNode (location: (7,0)-(7,16))
        │   ├── flags: newline
        │   ├── if_keyword_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (7,0)-(7,6))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :empty?
        │   │   ├── message_loc: (7,0)-(7,6) = "empty?"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: (7,6)-(7,7) = "?"
        │   ├── statements:
        │   │   @ StatementsNode (location: (7,7)-(7,12))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ FalseNode (location: (7,7)-(7,12))
        │   │           └── flags: newline, static_literal
        │   ├── subsequent:
        │   │   @ ElseNode (location: (7,12)-(7,16))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (7,12)-(7,13) = ":"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (7,13)-(7,16))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ NilNode (location: (7,13)-(7,16))
        │   │   │           └── flags: newline, static_literal
        │   │   └── end_keyword_loc: ∅
        │   └── end_keyword_loc: ∅
        ├── @ IfNode (location: (9,0)-(9,14))
        │   ├── flags: newline
        │   ├── if_keyword_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (9,0)-(9,6))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :empty?
        │   │   ├── message_loc: (9,0)-(9,6) = "empty?"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: (9,6)-(9,7) = "?"
        │   ├── statements:
        │   │   @ StatementsNode (location: (9,7)-(9,10))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ NilNode (location: (9,7)-(9,10))
        │   │           └── flags: newline, static_literal
        │   ├── subsequent:
        │   │   @ ElseNode (location: (9,10)-(9,14))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (9,10)-(9,11) = ":"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (9,11)-(9,14))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ NilNode (location: (9,11)-(9,14))
        │   │   │           └── flags: newline, static_literal
        │   │   └── end_keyword_loc: ∅
        │   └── end_keyword_loc: ∅
        ├── @ IfNode (location: (11,0)-(11,10))
        │   ├── flags: newline
        │   ├── if_keyword_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (11,0)-(11,2))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a?
        │   │   ├── message_loc: (11,0)-(11,2) = "a?"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: (11,2)-(11,3) = "?"
        │   ├── statements:
        │   │   @ StatementsNode (location: (11,3)-(11,6))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ NilNode (location: (11,3)-(11,6))
        │   │           └── flags: newline, static_literal
        │   ├── subsequent:
        │   │   @ ElseNode (location: (11,6)-(11,10))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (11,6)-(11,7) = ":"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (11,7)-(11,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ NilNode (location: (11,7)-(11,10))
        │   │   │           └── flags: newline, static_literal
        │   │   └── end_keyword_loc: ∅
        │   └── end_keyword_loc: ∅
        ├── @ IfNode (location: (13,0)-(13,14))
        │   ├── flags: newline
        │   ├── if_keyword_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (13,0)-(13,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (13,0)-(13,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: (13,2)-(13,3) = "?"
        │   ├── statements:
        │   │   @ StatementsNode (location: (13,3)-(13,7))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (13,3)-(13,7))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :var1
        │   │           ├── message_loc: (13,3)-(13,7) = "var1"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── subsequent:
        │   │   @ ElseNode (location: (13,8)-(13,14))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (13,8)-(13,9) = ":"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (13,10)-(13,14))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (13,10)-(13,14))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :var2
        │   │   │           ├── message_loc: (13,10)-(13,14) = "var2"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── end_keyword_loc: ∅
        │   └── end_keyword_loc: ∅
        └── @ IfNode (location: (15,0)-(15,12))
            ├── flags: newline
            ├── if_keyword_loc: ∅
            ├── predicate:
            │   @ CallNode (location: (15,0)-(15,4))
            │   ├── flags: ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :nil?
            │   ├── message_loc: (15,0)-(15,4) = "nil?"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── then_keyword_loc: (15,4)-(15,5) = "?"
            ├── statements:
            │   @ StatementsNode (location: (15,5)-(15,10))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ LocalVariableWriteNode (location: (15,5)-(15,10))
            │           ├── flags: newline
            │           ├── name: :_a
            │           ├── depth: 0
            │           ├── name_loc: (15,5)-(15,7) = "_a"
            │           ├── value:
            │           │   @ IntegerNode (location: (15,9)-(15,10))
            │           │   ├── flags: static_literal, decimal
            │           │   └── value: 2
            │           └── operator_loc: (15,8)-(15,9) = "="
            ├── subsequent:
            │   @ ElseNode (location: (15,10)-(15,12))
            │   ├── flags: ∅
            │   ├── else_keyword_loc: (15,10)-(15,11) = ":"
            │   ├── statements:
            │   │   @ StatementsNode (location: (15,11)-(15,12))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ IntegerNode (location: (15,11)-(15,12))
            │   │           ├── flags: newline, static_literal, decimal
            │   │           └── value: 1
            │   └── end_keyword_loc: ∅
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/tilde_heredocs.txt000066400000000000000000000611651506127434000204230ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(94,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(94,6))
    ├── flags: ∅
    └── body: (length: 19)
        ├── @ InterpolatedStringNode (location: (1,0)-(1,6))
        │   ├── flags: newline
        │   ├── opening_loc: (1,0)-(1,6) = "<<~EOF"
        │   ├── parts: (length: 4)
        │   │   ├── @ StringNode (location: (2,0)-(3,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (2,0)-(3,0) = "  a\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "  a\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (3,0)-(3,4))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (3,0)-(3,2) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (3,2)-(3,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (3,2)-(3,3))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   └── closing_loc: (3,3)-(3,4) = "}"
        │   │   ├── @ StringNode (location: (3,4)-(4,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (3,4)-(4,0) = "\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   └── @ StringNode (location: (4,0)-(5,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (4,0)-(5,0) = "  a\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "  a\n"
        │   └── closing_loc: (5,0)-(6,0) = "EOF\n"
        ├── @ StringNode (location: (7,0)-(7,6))
        │   ├── flags: newline
        │   ├── opening_loc: (7,0)-(7,6) = "<<~EOF"
        │   ├── content_loc: (8,0)-(9,0) = "  a\n"
        │   ├── closing_loc: (9,0)-(10,0) = "EOF\n"
        │   └── unescaped: "a\n"
        ├── @ InterpolatedStringNode (location: (11,0)-(11,6))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (11,0)-(11,6) = "<<~EOF"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (12,0)-(13,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (12,0)-(13,0) = "\ta\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\ta\n"
        │   │   ├── @ StringNode (location: (13,0)-(14,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (13,0)-(14,0) = "  b\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "b\n"
        │   │   └── @ StringNode (location: (14,0)-(15,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (14,0)-(15,0) = "\t\tc\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\t\tc\n"
        │   └── closing_loc: (15,0)-(16,0) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (17,0)-(17,6))
        │   ├── flags: newline
        │   ├── opening_loc: (17,0)-(17,6) = "<<~EOF"
        │   ├── parts: (length: 2)
        │   │   ├── @ EmbeddedStatementsNode (location: (18,2)-(18,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (18,2)-(18,4) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (18,4)-(18,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (18,4)-(18,5))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   └── closing_loc: (18,5)-(18,6) = "}"
        │   │   └── @ StringNode (location: (18,6)-(19,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (18,6)-(19,0) = " a\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: " a\n"
        │   └── closing_loc: (19,0)-(20,0) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (21,0)-(21,6))
        │   ├── flags: newline
        │   ├── opening_loc: (21,0)-(21,6) = "<<~EOF"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (22,0)-(22,4))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (22,0)-(22,4) = "  a "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a "
        │   │   ├── @ EmbeddedStatementsNode (location: (22,4)-(22,8))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (22,4)-(22,6) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (22,6)-(22,7))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (22,6)-(22,7))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   └── closing_loc: (22,7)-(22,8) = "}"
        │   │   └── @ StringNode (location: (22,8)-(23,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (22,8)-(23,0) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (23,0)-(24,0) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (25,0)-(25,6))
        │   ├── flags: newline
        │   ├── opening_loc: (25,0)-(25,6) = "<<~EOF"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (26,0)-(27,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (26,0)-(27,0) = "  a\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: " a\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (27,1)-(27,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (27,1)-(27,3) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (27,3)-(27,4))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (27,3)-(27,4))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   └── closing_loc: (27,4)-(27,5) = "}"
        │   │   └── @ StringNode (location: (27,5)-(28,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (27,5)-(28,0) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (28,0)-(29,0) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (30,0)-(30,6))
        │   ├── flags: newline
        │   ├── opening_loc: (30,0)-(30,6) = "<<~EOF"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (31,0)-(32,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (31,0)-(32,0) = "  a\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (32,2)-(32,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (32,2)-(32,4) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (32,4)-(32,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (32,4)-(32,5))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   └── closing_loc: (32,5)-(32,6) = "}"
        │   │   └── @ StringNode (location: (32,6)-(33,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (32,6)-(33,0) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (33,0)-(34,0) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (35,0)-(35,6))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (35,0)-(35,6) = "<<~EOF"
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (36,0)-(37,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (36,0)-(37,0) = "  a\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n"
        │   │   └── @ StringNode (location: (37,0)-(38,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (37,0)-(38,0) = "  b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "b\n"
        │   └── closing_loc: (38,0)-(39,0) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (40,0)-(40,6))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (40,0)-(40,6) = "<<~EOF"
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (41,0)-(42,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (41,0)-(42,0) = "  a\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n"
        │   │   └── @ StringNode (location: (42,0)-(43,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (42,0)-(43,0) = "   b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: " b\n"
        │   └── closing_loc: (43,0)-(44,0) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (45,0)-(45,6))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (45,0)-(45,6) = "<<~EOF"
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (46,0)-(47,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (46,0)-(47,0) = "\t\t\ta\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\ta\n"
        │   │   └── @ StringNode (location: (47,0)-(48,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (47,0)-(48,0) = "\t\tb\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "b\n"
        │   └── closing_loc: (48,0)-(49,0) = "EOF\n"
        ├── @ StringNode (location: (50,0)-(50,8))
        │   ├── flags: newline
        │   ├── opening_loc: (50,0)-(50,8) = "<<~'EOF'"
        │   ├── content_loc: (51,0)-(52,0) = "  a \#{1}\n"
        │   ├── closing_loc: (52,0)-(53,0) = "EOF\n"
        │   └── unescaped: "a \#{1}\n"
        ├── @ InterpolatedStringNode (location: (54,0)-(54,6))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (54,0)-(54,6) = "<<~EOF"
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (55,0)-(56,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (55,0)-(56,0) = "\ta\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n"
        │   │   └── @ StringNode (location: (56,0)-(57,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (56,0)-(57,0) = "\t b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: " b\n"
        │   └── closing_loc: (57,0)-(58,0) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (59,0)-(59,6))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (59,0)-(59,6) = "<<~EOF"
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (60,0)-(61,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (60,0)-(61,0) = "\t a\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: " a\n"
        │   │   └── @ StringNode (location: (61,0)-(62,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (61,0)-(62,0) = "\tb\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "b\n"
        │   └── closing_loc: (62,0)-(63,0) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (64,0)-(64,6))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (64,0)-(64,6) = "<<~EOF"
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (65,0)-(66,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (65,0)-(66,0) = "  \ta\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n"
        │   │   └── @ StringNode (location: (66,0)-(67,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (66,0)-(67,0) = "        b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "b\n"
        │   └── closing_loc: (67,0)-(68,0) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (69,0)-(69,6))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (69,0)-(69,6) = "<<~EOF"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (70,0)-(71,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (70,0)-(71,0) = "  a\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n"
        │   │   ├── @ StringNode (location: (71,0)-(72,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (71,0)-(72,0) = "\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   └── @ StringNode (location: (72,0)-(73,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (72,0)-(73,0) = "  b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "b\n"
        │   └── closing_loc: (73,0)-(74,0) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (75,0)-(75,6))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (75,0)-(75,6) = "<<~EOF"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (76,0)-(77,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (76,0)-(77,0) = "  a\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n"
        │   │   ├── @ StringNode (location: (77,0)-(78,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (77,0)-(78,0) = "\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   └── @ StringNode (location: (78,0)-(79,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (78,0)-(79,0) = "  b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "b\n"
        │   └── closing_loc: (79,0)-(80,0) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (81,0)-(81,6))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (81,0)-(81,6) = "<<~EOF"
        │   ├── parts: (length: 5)
        │   │   ├── @ StringNode (location: (82,0)-(83,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (82,0)-(83,0) = "  a\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n"
        │   │   ├── @ StringNode (location: (83,0)-(84,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (83,0)-(84,0) = "\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   ├── @ StringNode (location: (84,0)-(85,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (84,0)-(85,0) = "\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   ├── @ StringNode (location: (85,0)-(86,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (85,0)-(86,0) = "\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   └── @ StringNode (location: (86,0)-(87,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (86,0)-(87,0) = "  b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "b\n"
        │   └── closing_loc: (87,0)-(88,0) = "EOF\n"
        ├── @ InterpolatedStringNode (location: (89,0)-(89,6))
        │   ├── flags: newline
        │   ├── opening_loc: (89,0)-(89,6) = "<<~EOF"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (90,0)-(91,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (90,0)-(91,0) = "\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (91,2)-(91,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (91,2)-(91,4) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (91,4)-(91,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (91,4)-(91,5))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   └── closing_loc: (91,5)-(91,6) = "}"
        │   │   └── @ StringNode (location: (91,6)-(92,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (91,6)-(92,0) = "a\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\n"
        │   └── closing_loc: (92,0)-(93,0) = "    EOF\n"
        └── @ InterpolatedStringNode (location: (94,0)-(94,6))
            ├── flags: newline
            ├── opening_loc: (94,0)-(94,6) = "<<~EOT"
            ├── parts: (length: 3)
            │   ├── @ EmbeddedStatementsNode (location: (95,2)-(95,6))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (95,2)-(95,4) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (95,4)-(95,5))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ IntegerNode (location: (95,4)-(95,5))
            │   │   │           ├── flags: static_literal, decimal
            │   │   │           └── value: 1
            │   │   └── closing_loc: (95,5)-(95,6) = "}"
            │   ├── @ StringNode (location: (95,6)-(96,0))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (95,6)-(96,0) = "\n"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "\n"
            │   └── @ StringNode (location: (96,0)-(97,0))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (96,0)-(97,0) = "\tb\n"
            │       ├── closing_loc: ∅
            │       └── unescaped: "\tb\n"
            └── closing_loc: (97,0)-(98,0) = "EOT\n"
prism-1.5.1/snapshots/undef.txt000066400000000000000000000170541506127434000165450ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(17,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(17,14))
    ├── flags: ∅
    └── body: (length: 9)
        ├── @ UndefNode (location: (1,0)-(1,7))
        │   ├── flags: newline
        │   ├── names: (length: 1)
        │   │   └── @ SymbolNode (location: (1,6)-(1,7))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: ∅
        │   │       ├── value_loc: (1,6)-(1,7) = "a"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a"
        │   └── keyword_loc: (1,0)-(1,5) = "undef"
        ├── @ UndefNode (location: (3,0)-(3,10))
        │   ├── flags: newline
        │   ├── names: (length: 2)
        │   │   ├── @ SymbolNode (location: (3,6)-(3,7))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── value_loc: (3,6)-(3,7) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   └── @ SymbolNode (location: (3,9)-(3,10))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: ∅
        │   │       ├── value_loc: (3,9)-(3,10) = "b"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "b"
        │   └── keyword_loc: (3,0)-(3,5) = "undef"
        ├── @ UndefNode (location: (5,0)-(5,8))
        │   ├── flags: newline
        │   ├── names: (length: 1)
        │   │   └── @ SymbolNode (location: (5,6)-(5,8))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: ∅
        │   │       ├── value_loc: (5,6)-(5,8) = "if"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "if"
        │   └── keyword_loc: (5,0)-(5,5) = "undef"
        ├── @ UndefNode (location: (7,0)-(7,9))
        │   ├── flags: newline
        │   ├── names: (length: 1)
        │   │   └── @ SymbolNode (location: (7,6)-(7,9))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: ∅
        │   │       ├── value_loc: (7,6)-(7,9) = "<=>"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "<=>"
        │   └── keyword_loc: (7,0)-(7,5) = "undef"
        ├── @ UndefNode (location: (9,0)-(9,8))
        │   ├── flags: newline
        │   ├── names: (length: 1)
        │   │   └── @ SymbolNode (location: (9,6)-(9,8))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: (9,6)-(9,7) = ":"
        │   │       ├── value_loc: (9,7)-(9,8) = "a"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a"
        │   └── keyword_loc: (9,0)-(9,5) = "undef"
        ├── @ UndefNode (location: (11,0)-(11,16))
        │   ├── flags: newline
        │   ├── names: (length: 3)
        │   │   ├── @ SymbolNode (location: (11,6)-(11,8))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (11,6)-(11,7) = ":"
        │   │   │   ├── value_loc: (11,7)-(11,8) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   ├── @ SymbolNode (location: (11,10)-(11,12))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (11,10)-(11,11) = ":"
        │   │   │   ├── value_loc: (11,11)-(11,12) = "b"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "b"
        │   │   └── @ SymbolNode (location: (11,14)-(11,16))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: (11,14)-(11,15) = ":"
        │   │       ├── value_loc: (11,15)-(11,16) = "c"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "c"
        │   └── keyword_loc: (11,0)-(11,5) = "undef"
        ├── @ UndefNode (location: (13,0)-(13,12))
        │   ├── flags: newline
        │   ├── names: (length: 1)
        │   │   └── @ SymbolNode (location: (13,6)-(13,12))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: (13,6)-(13,8) = ":'"
        │   │       ├── value_loc: (13,8)-(13,11) = "abc"
        │   │       ├── closing_loc: (13,11)-(13,12) = "'"
        │   │       └── unescaped: "abc"
        │   └── keyword_loc: (13,0)-(13,5) = "undef"
        ├── @ UndefNode (location: (15,0)-(15,16))
        │   ├── flags: newline
        │   ├── names: (length: 1)
        │   │   └── @ InterpolatedSymbolNode (location: (15,6)-(15,16))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (15,6)-(15,8) = ":\""
        │   │       ├── parts: (length: 2)
        │   │       │   ├── @ StringNode (location: (15,8)-(15,11))
        │   │       │   │   ├── flags: static_literal, frozen
        │   │       │   │   ├── opening_loc: ∅
        │   │       │   │   ├── content_loc: (15,8)-(15,11) = "abc"
        │   │       │   │   ├── closing_loc: ∅
        │   │       │   │   └── unescaped: "abc"
        │   │       │   └── @ EmbeddedStatementsNode (location: (15,11)-(15,15))
        │   │       │       ├── flags: ∅
        │   │       │       ├── opening_loc: (15,11)-(15,13) = "\#{"
        │   │       │       ├── statements:
        │   │       │       │   @ StatementsNode (location: (15,13)-(15,14))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ IntegerNode (location: (15,13)-(15,14))
        │   │       │       │           ├── flags: static_literal, decimal
        │   │       │       │           └── value: 1
        │   │       │       └── closing_loc: (15,14)-(15,15) = "}"
        │   │       └── closing_loc: (15,15)-(15,16) = "\""
        │   └── keyword_loc: (15,0)-(15,5) = "undef"
        └── @ UndefNode (location: (17,0)-(17,14))
            ├── flags: newline
            ├── names: (length: 1)
            │   └── @ SymbolNode (location: (17,6)-(17,14))
            │       ├── flags: static_literal, forced_us_ascii_encoding
            │       ├── opening_loc: ∅
            │       ├── value_loc: (17,6)-(17,14) = "Constant"
            │       ├── closing_loc: ∅
            │       └── unescaped: "Constant"
            └── keyword_loc: (17,0)-(17,5) = "undef"
prism-1.5.1/snapshots/unescaping.txt000066400000000000000000000034461506127434000176000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(7,7))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ ArrayNode (location: (1,0)-(1,10))
        │   ├── flags: newline
        │   ├── elements: (length: 1)
        │   │   └── @ StringNode (location: (1,1)-(1,9))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (1,1)-(1,2) = "\""
        │   │       ├── content_loc: (1,2)-(1,8) = "\\c\#{1}"
        │   │       ├── closing_loc: (1,8)-(1,9) = "\""
        │   │       └── unescaped: "\u0003{1}"
        │   ├── opening_loc: (1,0)-(1,1) = "["
        │   └── closing_loc: (1,9)-(1,10) = "]"
        ├── @ RegularExpressionNode (location: (3,0)-(3,8))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (3,0)-(3,1) = "/"
        │   ├── content_loc: (3,1)-(3,7) = "\\c\#{1}"
        │   ├── closing_loc: (3,7)-(3,8) = "/"
        │   └── unescaped: "\\x03{1}"
        ├── @ StringNode (location: (5,0)-(5,8))
        │   ├── flags: newline
        │   ├── opening_loc: (5,0)-(5,1) = "\""
        │   ├── content_loc: (5,1)-(5,7) = "\\c\#{1}"
        │   ├── closing_loc: (5,7)-(5,8) = "\""
        │   └── unescaped: "\u0003{1}"
        └── @ StringNode (location: (7,0)-(7,7))
            ├── flags: newline
            ├── opening_loc: (7,0)-(7,7) = "<<~HERE"
            ├── content_loc: (8,0)-(9,0) = "   \\c\#{1}\n"
            ├── closing_loc: (9,0)-(10,0) = "HERE\n"
            └── unescaped: "\u0003{1}\n"
prism-1.5.1/snapshots/unless.txt000066400000000000000000000256541506127434000167620ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(14,22))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(14,22))
    ├── flags: ∅
    └── body: (length: 7)
        ├── @ UnlessNode (location: (1,0)-(1,19))
        │   ├── flags: newline
        │   ├── keyword_loc: (1,0)-(1,6) = "unless"
        │   ├── predicate:
        │   │   @ TrueNode (location: (1,7)-(1,11))
        │   │   └── flags: static_literal
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (1,13)-(1,14))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (1,13)-(1,14))
        │   │           ├── flags: newline, static_literal, decimal
        │   │           └── value: 1
        │   ├── else_clause: ∅
        │   └── end_keyword_loc: (1,16)-(1,19) = "end"
        ├── @ UnlessNode (location: (3,0)-(4,12))
        │   ├── flags: newline
        │   ├── keyword_loc: (3,0)-(3,6) = "unless"
        │   ├── predicate:
        │   │   @ TrueNode (location: (3,7)-(3,11))
        │   │   └── flags: static_literal
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (4,0)-(4,1))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (4,0)-(4,1))
        │   │           ├── flags: newline, static_literal, decimal
        │   │           └── value: 1
        │   ├── else_clause:
        │   │   @ ElseNode (location: (4,2)-(4,12))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (4,2)-(4,6) = "else"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (4,7)-(4,8))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ IntegerNode (location: (4,7)-(4,8))
        │   │   │           ├── flags: newline, static_literal, decimal
        │   │   │           └── value: 2
        │   │   └── end_keyword_loc: (4,9)-(4,12) = "end"
        │   └── end_keyword_loc: (4,9)-(4,12) = "end"
        ├── @ UnlessNode (location: (6,0)-(6,13))
        │   ├── flags: newline
        │   ├── keyword_loc: (6,2)-(6,8) = "unless"
        │   ├── predicate:
        │   │   @ TrueNode (location: (6,9)-(6,13))
        │   │   └── flags: static_literal
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (6,0)-(6,1))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (6,0)-(6,1))
        │   │           ├── flags: newline, static_literal, decimal
        │   │           └── value: 1
        │   ├── else_clause: ∅
        │   └── end_keyword_loc: ∅
        ├── @ CallNode (location: (8,0)-(8,25))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (8,0)-(8,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (8,4)-(8,25))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (8,6)-(8,23))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ UnlessNode (location: (8,6)-(8,23))
        │       │           ├── flags: newline
        │       │           ├── keyword_loc: (8,12)-(8,18) = "unless"
        │       │           ├── predicate:
        │       │           │   @ TrueNode (location: (8,19)-(8,23))
        │       │           │   └── flags: static_literal
        │       │           ├── then_keyword_loc: ∅
        │       │           ├── statements:
        │       │           │   @ StatementsNode (location: (8,6)-(8,11))
        │       │           │   ├── flags: ∅
        │       │           │   └── body: (length: 1)
        │       │           │       └── @ BreakNode (location: (8,6)-(8,11))
        │       │           │           ├── flags: newline
        │       │           │           ├── arguments: ∅
        │       │           │           └── keyword_loc: (8,6)-(8,11) = "break"
        │       │           ├── else_clause: ∅
        │       │           └── end_keyword_loc: ∅
        │       ├── opening_loc: (8,4)-(8,5) = "{"
        │       └── closing_loc: (8,24)-(8,25) = "}"
        ├── @ CallNode (location: (10,0)-(10,24))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :tap
        │   ├── message_loc: (10,0)-(10,3) = "tap"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (10,4)-(10,24))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (10,6)-(10,22))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ UnlessNode (location: (10,6)-(10,22))
        │       │           ├── flags: newline
        │       │           ├── keyword_loc: (10,11)-(10,17) = "unless"
        │       │           ├── predicate:
        │       │           │   @ TrueNode (location: (10,18)-(10,22))
        │       │           │   └── flags: static_literal
        │       │           ├── then_keyword_loc: ∅
        │       │           ├── statements:
        │       │           │   @ StatementsNode (location: (10,6)-(10,10))
        │       │           │   ├── flags: ∅
        │       │           │   └── body: (length: 1)
        │       │           │       └── @ NextNode (location: (10,6)-(10,10))
        │       │           │           ├── flags: newline
        │       │           │           ├── arguments: ∅
        │       │           │           └── keyword_loc: (10,6)-(10,10) = "next"
        │       │           ├── else_clause: ∅
        │       │           └── end_keyword_loc: ∅
        │       ├── opening_loc: (10,4)-(10,5) = "{"
        │       └── closing_loc: (10,23)-(10,24) = "}"
        ├── @ UnlessNode (location: (12,0)-(12,18))
        │   ├── flags: newline
        │   ├── keyword_loc: (12,7)-(12,13) = "unless"
        │   ├── predicate:
        │   │   @ TrueNode (location: (12,14)-(12,18))
        │   │   └── flags: static_literal
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (12,0)-(12,6))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ ReturnNode (location: (12,0)-(12,6))
        │   │           ├── flags: newline
        │   │           ├── keyword_loc: (12,0)-(12,6) = "return"
        │   │           └── arguments: ∅
        │   ├── else_clause: ∅
        │   └── end_keyword_loc: ∅
        └── @ UnlessNode (location: (14,0)-(14,22))
            ├── flags: newline
            ├── keyword_loc: (14,11)-(14,17) = "unless"
            ├── predicate:
            │   @ CallNode (location: (14,18)-(14,22))
            │   ├── flags: ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :bar?
            │   ├── message_loc: (14,18)-(14,22) = "bar?"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── then_keyword_loc: ∅
            ├── statements:
            │   @ StatementsNode (location: (14,0)-(14,10))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (14,0)-(14,10))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :foo
            │           ├── message_loc: (14,0)-(14,3) = "foo"
            │           ├── opening_loc: ∅
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (14,4)-(14,10))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 2)
            │           │       ├── @ SymbolNode (location: (14,4)-(14,6))
            │           │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │           │       │   ├── opening_loc: (14,4)-(14,5) = ":"
            │           │       │   ├── value_loc: (14,5)-(14,6) = "a"
            │           │       │   ├── closing_loc: ∅
            │           │       │   └── unescaped: "a"
            │           │       └── @ SymbolNode (location: (14,8)-(14,10))
            │           │           ├── flags: static_literal, forced_us_ascii_encoding
            │           │           ├── opening_loc: (14,8)-(14,9) = ":"
            │           │           ├── value_loc: (14,9)-(14,10) = "b"
            │           │           ├── closing_loc: ∅
            │           │           └── unescaped: "b"
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── else_clause: ∅
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/unparser/000077500000000000000000000000001506127434000165335ustar00rootroot00000000000000prism-1.5.1/snapshots/unparser/corpus/000077500000000000000000000000001506127434000200465ustar00rootroot00000000000000prism-1.5.1/snapshots/unparser/corpus/literal/000077500000000000000000000000001506127434000215025ustar00rootroot00000000000000prism-1.5.1/snapshots/unparser/corpus/literal/alias.txt000066400000000000000000000031651506127434000233410ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,15))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ AliasGlobalVariableNode (location: (1,0)-(1,15))
        │   ├── flags: newline
        │   ├── new_name:
        │   │   @ GlobalVariableReadNode (location: (1,6)-(1,10))
        │   │   ├── flags: ∅
        │   │   └── name: :$foo
        │   ├── old_name:
        │   │   @ GlobalVariableReadNode (location: (1,11)-(1,15))
        │   │   ├── flags: ∅
        │   │   └── name: :$bar
        │   └── keyword_loc: (1,0)-(1,5) = "alias"
        └── @ AliasMethodNode (location: (2,0)-(2,15))
            ├── flags: newline
            ├── new_name:
            │   @ SymbolNode (location: (2,6)-(2,10))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (2,6)-(2,7) = ":"
            │   ├── value_loc: (2,7)-(2,10) = "foo"
            │   ├── closing_loc: ∅
            │   └── unescaped: "foo"
            ├── old_name:
            │   @ SymbolNode (location: (2,11)-(2,15))
            │   ├── flags: static_literal, forced_us_ascii_encoding
            │   ├── opening_loc: (2,11)-(2,12) = ":"
            │   ├── value_loc: (2,12)-(2,15) = "bar"
            │   ├── closing_loc: ∅
            │   └── unescaped: "bar"
            └── keyword_loc: (2,0)-(2,5) = "alias"
prism-1.5.1/snapshots/unparser/corpus/literal/assignment.txt000066400000000000000000001774151506127434000244320ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(51,17))
├── flags: ∅
├── locals: [:a, :b, :foo, :c, :x]
└── statements:
    @ StatementsNode (location: (1,0)-(51,17))
    ├── flags: ∅
    └── body: (length: 43)
        ├── @ GlobalVariableWriteNode (location: (1,0)-(1,6))
        │   ├── flags: newline
        │   ├── name: :$a
        │   ├── name_loc: (1,0)-(1,2) = "$a"
        │   ├── value:
        │   │   @ IntegerNode (location: (1,5)-(1,6))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (1,3)-(1,4) = "="
        ├── @ MultiWriteNode (location: (2,0)-(2,17))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ GlobalVariableTargetNode (location: (2,1)-(2,3))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :$a
        │   │   └── @ GlobalVariableTargetNode (location: (2,5)-(2,7))
        │   │       ├── flags: ∅
        │   │       └── name: :$b
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (2,0)-(2,1) = "("
        │   ├── rparen_loc: (2,7)-(2,8) = ")"
        │   ├── operator_loc: (2,9)-(2,10) = "="
        │   └── value:
        │       @ ArrayNode (location: (2,11)-(2,17))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (2,12)-(2,13))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (2,15)-(2,16))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: (2,11)-(2,12) = "["
        │       └── closing_loc: (2,16)-(2,17) = "]"
        ├── @ MultiWriteNode (location: (3,0)-(3,13))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ MultiTargetNode (location: (3,1)-(3,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── lefts: (length: 1)
        │   │   │   │   └── @ LocalVariableTargetNode (location: (3,2)-(3,3))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :a
        │   │   │   │       └── depth: 0
        │   │   │   ├── rest:
        │   │   │   │   @ ImplicitRestNode (location: (3,3)-(3,4))
        │   │   │   │   └── flags: ∅
        │   │   │   ├── rights: (length: 0)
        │   │   │   ├── lparen_loc: (3,1)-(3,2) = "("
        │   │   │   └── rparen_loc: (3,4)-(3,5) = ")"
        │   │   └── @ LocalVariableTargetNode (location: (3,7)-(3,8))
        │   │       ├── flags: ∅
        │   │       ├── name: :b
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (3,0)-(3,1) = "("
        │   ├── rparen_loc: (3,8)-(3,9) = ")"
        │   ├── operator_loc: (3,10)-(3,11) = "="
        │   └── value:
        │       @ IntegerNode (location: (3,12)-(3,13))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ MultiWriteNode (location: (4,0)-(4,9))
        │   ├── flags: newline
        │   ├── lefts: (length: 0)
        │   ├── rest:
        │   │   @ SplatNode (location: (4,1)-(4,3))
        │   │   ├── flags: ∅
        │   │   ├── operator_loc: (4,1)-(4,2) = "*"
        │   │   └── expression:
        │   │       @ LocalVariableTargetNode (location: (4,2)-(4,3))
        │   │       ├── flags: ∅
        │   │       ├── name: :a
        │   │       └── depth: 0
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (4,0)-(4,1) = "("
        │   ├── rparen_loc: (4,3)-(4,4) = ")"
        │   ├── operator_loc: (4,5)-(4,6) = "="
        │   └── value:
        │       @ ArrayNode (location: (4,7)-(4,9))
        │       ├── flags: static_literal
        │       ├── elements: (length: 0)
        │       ├── opening_loc: (4,7)-(4,8) = "["
        │       └── closing_loc: (4,8)-(4,9) = "]"
        ├── @ MultiWriteNode (location: (5,0)-(5,15))
        │   ├── flags: newline
        │   ├── lefts: (length: 0)
        │   ├── rest:
        │   │   @ SplatNode (location: (5,1)-(5,5))
        │   │   ├── flags: ∅
        │   │   ├── operator_loc: (5,1)-(5,2) = "*"
        │   │   └── expression:
        │   │       @ LocalVariableTargetNode (location: (5,2)-(5,5))
        │   │       ├── flags: ∅
        │   │       ├── name: :foo
        │   │       └── depth: 0
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (5,0)-(5,1) = "("
        │   ├── rparen_loc: (5,5)-(5,6) = ")"
        │   ├── operator_loc: (5,7)-(5,8) = "="
        │   └── value:
        │       @ ArrayNode (location: (5,9)-(5,15))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (5,10)-(5,11))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (5,13)-(5,14))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: (5,9)-(5,10) = "["
        │       └── closing_loc: (5,14)-(5,15) = "]"
        ├── @ MultiWriteNode (location: (6,0)-(6,19))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ ClassVariableTargetNode (location: (6,1)-(6,4))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :@@a
        │   │   └── @ ClassVariableTargetNode (location: (6,6)-(6,9))
        │   │       ├── flags: ∅
        │   │       └── name: :@@b
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (6,0)-(6,1) = "("
        │   ├── rparen_loc: (6,9)-(6,10) = ")"
        │   ├── operator_loc: (6,11)-(6,12) = "="
        │   └── value:
        │       @ ArrayNode (location: (6,13)-(6,19))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (6,14)-(6,15))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (6,17)-(6,18))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: (6,13)-(6,14) = "["
        │       └── closing_loc: (6,18)-(6,19) = "]"
        ├── @ MultiWriteNode (location: (7,0)-(7,17))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ InstanceVariableTargetNode (location: (7,1)-(7,3))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :@a
        │   │   └── @ InstanceVariableTargetNode (location: (7,5)-(7,7))
        │   │       ├── flags: ∅
        │   │       └── name: :@b
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (7,0)-(7,1) = "("
        │   ├── rparen_loc: (7,7)-(7,8) = ")"
        │   ├── operator_loc: (7,9)-(7,10) = "="
        │   └── value:
        │       @ ArrayNode (location: (7,11)-(7,17))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (7,12)-(7,13))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (7,15)-(7,16))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: (7,11)-(7,12) = "["
        │       └── closing_loc: (7,16)-(7,17) = "]"
        ├── @ MultiWriteNode (location: (8,0)-(8,25))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ LocalVariableTargetNode (location: (8,1)-(8,2))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :a
        │   │   │   └── depth: 0
        │   │   └── @ MultiTargetNode (location: (8,4)-(8,10))
        │   │       ├── flags: ∅
        │   │       ├── lefts: (length: 2)
        │   │       │   ├── @ LocalVariableTargetNode (location: (8,5)-(8,6))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── name: :b
        │   │       │   │   └── depth: 0
        │   │       │   └── @ LocalVariableTargetNode (location: (8,8)-(8,9))
        │   │       │       ├── flags: ∅
        │   │       │       ├── name: :c
        │   │       │       └── depth: 0
        │   │       ├── rest: ∅
        │   │       ├── rights: (length: 0)
        │   │       ├── lparen_loc: (8,4)-(8,5) = "("
        │   │       └── rparen_loc: (8,9)-(8,10) = ")"
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (8,0)-(8,1) = "("
        │   ├── rparen_loc: (8,10)-(8,11) = ")"
        │   ├── operator_loc: (8,12)-(8,13) = "="
        │   └── value:
        │       @ ArrayNode (location: (8,14)-(8,25))
        │       ├── flags: ∅
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (8,15)-(8,16))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ ArrayNode (location: (8,18)-(8,24))
        │       │       ├── flags: static_literal
        │       │       ├── elements: (length: 2)
        │       │       │   ├── @ IntegerNode (location: (8,19)-(8,20))
        │       │       │   │   ├── flags: static_literal, decimal
        │       │       │   │   └── value: 2
        │       │       │   └── @ IntegerNode (location: (8,22)-(8,23))
        │       │       │       ├── flags: static_literal, decimal
        │       │       │       └── value: 3
        │       │       ├── opening_loc: (8,18)-(8,19) = "["
        │       │       └── closing_loc: (8,23)-(8,24) = "]"
        │       ├── opening_loc: (8,14)-(8,15) = "["
        │       └── closing_loc: (8,24)-(8,25) = "]"
        ├── @ MultiWriteNode (location: (9,0)-(9,15))
        │   ├── flags: newline
        │   ├── lefts: (length: 1)
        │   │   └── @ LocalVariableTargetNode (location: (9,1)-(9,2))
        │   │       ├── flags: ∅
        │   │       ├── name: :a
        │   │       └── depth: 0
        │   ├── rest:
        │   │   @ SplatNode (location: (9,4)-(9,5))
        │   │   ├── flags: ∅
        │   │   ├── operator_loc: (9,4)-(9,5) = "*"
        │   │   └── expression: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (9,0)-(9,1) = "("
        │   ├── rparen_loc: (9,5)-(9,6) = ")"
        │   ├── operator_loc: (9,7)-(9,8) = "="
        │   └── value:
        │       @ ArrayNode (location: (9,9)-(9,15))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (9,10)-(9,11))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (9,13)-(9,14))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: (9,9)-(9,10) = "["
        │       └── closing_loc: (9,14)-(9,15) = "]"
        ├── @ MultiWriteNode (location: (10,0)-(10,18))
        │   ├── flags: newline
        │   ├── lefts: (length: 1)
        │   │   └── @ LocalVariableTargetNode (location: (10,1)-(10,2))
        │   │       ├── flags: ∅
        │   │       ├── name: :a
        │   │       └── depth: 0
        │   ├── rest:
        │   │   @ SplatNode (location: (10,4)-(10,8))
        │   │   ├── flags: ∅
        │   │   ├── operator_loc: (10,4)-(10,5) = "*"
        │   │   └── expression:
        │   │       @ LocalVariableTargetNode (location: (10,5)-(10,8))
        │   │       ├── flags: ∅
        │   │       ├── name: :foo
        │   │       └── depth: 0
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (10,0)-(10,1) = "("
        │   ├── rparen_loc: (10,8)-(10,9) = ")"
        │   ├── operator_loc: (10,10)-(10,11) = "="
        │   └── value:
        │       @ ArrayNode (location: (10,12)-(10,18))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (10,13)-(10,14))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (10,16)-(10,17))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: (10,12)-(10,13) = "["
        │       └── closing_loc: (10,17)-(10,18) = "]"
        ├── @ MultiWriteNode (location: (11,0)-(11,15))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ LocalVariableTargetNode (location: (11,1)-(11,2))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :a
        │   │   │   └── depth: 0
        │   │   └── @ LocalVariableTargetNode (location: (11,4)-(11,5))
        │   │       ├── flags: ∅
        │   │       ├── name: :b
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (11,0)-(11,1) = "("
        │   ├── rparen_loc: (11,5)-(11,6) = ")"
        │   ├── operator_loc: (11,7)-(11,8) = "="
        │   └── value:
        │       @ ArrayNode (location: (11,9)-(11,15))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (11,10)-(11,11))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (11,13)-(11,14))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: (11,9)-(11,10) = "["
        │       └── closing_loc: (11,14)-(11,15) = "]"
        ├── @ MultiWriteNode (location: (12,0)-(12,12))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ LocalVariableTargetNode (location: (12,1)-(12,2))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :a
        │   │   │   └── depth: 0
        │   │   └── @ LocalVariableTargetNode (location: (12,4)-(12,5))
        │   │       ├── flags: ∅
        │   │       ├── name: :b
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (12,0)-(12,1) = "("
        │   ├── rparen_loc: (12,5)-(12,6) = ")"
        │   ├── operator_loc: (12,7)-(12,8) = "="
        │   └── value:
        │       @ LocalVariableReadNode (location: (12,9)-(12,12))
        │       ├── flags: ∅
        │       ├── name: :foo
        │       └── depth: 0
        ├── @ MultiWriteNode (location: (13,0)-(13,10))
        │   ├── flags: newline
        │   ├── lefts: (length: 1)
        │   │   └── @ LocalVariableTargetNode (location: (13,1)-(13,2))
        │   │       ├── flags: ∅
        │   │       ├── name: :a
        │   │       └── depth: 0
        │   ├── rest:
        │   │   @ ImplicitRestNode (location: (13,2)-(13,3))
        │   │   └── flags: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (13,0)-(13,1) = "("
        │   ├── rparen_loc: (13,3)-(13,4) = ")"
        │   ├── operator_loc: (13,5)-(13,6) = "="
        │   └── value:
        │       @ LocalVariableReadNode (location: (13,7)-(13,10))
        │       ├── flags: ∅
        │       ├── name: :foo
        │       └── depth: 0
        ├── @ MultiWriteNode (location: (14,0)-(14,23))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ CallTargetNode (location: (14,1)-(14,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── receiver:
        │   │   │   │   @ LocalVariableReadNode (location: (14,1)-(14,2))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :a
        │   │   │   │   └── depth: 0
        │   │   │   ├── call_operator_loc: (14,2)-(14,3) = "."
        │   │   │   ├── name: :foo=
        │   │   │   └── message_loc: (14,3)-(14,6) = "foo"
        │   │   └── @ CallTargetNode (location: (14,8)-(14,13))
        │   │       ├── flags: ∅
        │   │       ├── receiver:
        │   │       │   @ LocalVariableReadNode (location: (14,8)-(14,9))
        │   │       │   ├── flags: ∅
        │   │       │   ├── name: :a
        │   │       │   └── depth: 0
        │   │       ├── call_operator_loc: (14,9)-(14,10) = "."
        │   │       ├── name: :bar=
        │   │       └── message_loc: (14,10)-(14,13) = "bar"
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (14,0)-(14,1) = "("
        │   ├── rparen_loc: (14,13)-(14,14) = ")"
        │   ├── operator_loc: (14,15)-(14,16) = "="
        │   └── value:
        │       @ ArrayNode (location: (14,17)-(14,23))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (14,18)-(14,19))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (14,21)-(14,22))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: (14,17)-(14,18) = "["
        │       └── closing_loc: (14,22)-(14,23) = "]"
        ├── @ MultiWriteNode (location: (15,0)-(15,24))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ IndexTargetNode (location: (15,1)-(15,8))
        │   │   │   ├── flags: attribute_write
        │   │   │   ├── receiver:
        │   │   │   │   @ LocalVariableReadNode (location: (15,1)-(15,2))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :a
        │   │   │   │   └── depth: 0
        │   │   │   ├── opening_loc: (15,2)-(15,3) = "["
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (15,3)-(15,7))
        │   │   │   │   ├── flags: contains_splat
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ SplatNode (location: (15,3)-(15,7))
        │   │   │   │           ├── flags: ∅
        │   │   │   │           ├── operator_loc: (15,3)-(15,4) = "*"
        │   │   │   │           └── expression:
        │   │   │   │               @ LocalVariableReadNode (location: (15,4)-(15,7))
        │   │   │   │               ├── flags: ∅
        │   │   │   │               ├── name: :foo
        │   │   │   │               └── depth: 0
        │   │   │   ├── closing_loc: (15,7)-(15,8) = "]"
        │   │   │   └── block: ∅
        │   │   └── @ IndexTargetNode (location: (15,10)-(15,14))
        │   │       ├── flags: attribute_write
        │   │       ├── receiver:
        │   │       │   @ LocalVariableReadNode (location: (15,10)-(15,11))
        │   │       │   ├── flags: ∅
        │   │       │   ├── name: :a
        │   │       │   └── depth: 0
        │   │       ├── opening_loc: (15,11)-(15,12) = "["
        │   │       ├── arguments:
        │   │       │   @ ArgumentsNode (location: (15,12)-(15,13))
        │   │       │   ├── flags: ∅
        │   │       │   └── arguments: (length: 1)
        │   │       │       └── @ IntegerNode (location: (15,12)-(15,13))
        │   │       │           ├── flags: static_literal, decimal
        │   │       │           └── value: 1
        │   │       ├── closing_loc: (15,13)-(15,14) = "]"
        │   │       └── block: ∅
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (15,0)-(15,1) = "("
        │   ├── rparen_loc: (15,14)-(15,15) = ")"
        │   ├── operator_loc: (15,16)-(15,17) = "="
        │   └── value:
        │       @ ArrayNode (location: (15,18)-(15,24))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (15,19)-(15,20))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (15,22)-(15,23))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: (15,18)-(15,19) = "["
        │       └── closing_loc: (15,23)-(15,24) = "]"
        ├── @ MultiWriteNode (location: (16,0)-(16,21))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ IndexTargetNode (location: (16,1)-(16,5))
        │   │   │   ├── flags: attribute_write
        │   │   │   ├── receiver:
        │   │   │   │   @ LocalVariableReadNode (location: (16,1)-(16,2))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :a
        │   │   │   │   └── depth: 0
        │   │   │   ├── opening_loc: (16,2)-(16,3) = "["
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (16,3)-(16,4))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (16,3)-(16,4))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 0
        │   │   │   ├── closing_loc: (16,4)-(16,5) = "]"
        │   │   │   └── block: ∅
        │   │   └── @ IndexTargetNode (location: (16,7)-(16,11))
        │   │       ├── flags: attribute_write
        │   │       ├── receiver:
        │   │       │   @ LocalVariableReadNode (location: (16,7)-(16,8))
        │   │       │   ├── flags: ∅
        │   │       │   ├── name: :a
        │   │       │   └── depth: 0
        │   │       ├── opening_loc: (16,8)-(16,9) = "["
        │   │       ├── arguments:
        │   │       │   @ ArgumentsNode (location: (16,9)-(16,10))
        │   │       │   ├── flags: ∅
        │   │       │   └── arguments: (length: 1)
        │   │       │       └── @ IntegerNode (location: (16,9)-(16,10))
        │   │       │           ├── flags: static_literal, decimal
        │   │       │           └── value: 1
        │   │       ├── closing_loc: (16,10)-(16,11) = "]"
        │   │       └── block: ∅
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (16,0)-(16,1) = "("
        │   ├── rparen_loc: (16,11)-(16,12) = ")"
        │   ├── operator_loc: (16,13)-(16,14) = "="
        │   └── value:
        │       @ ArrayNode (location: (16,15)-(16,21))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (16,16)-(16,17))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (16,19)-(16,20))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: (16,15)-(16,16) = "["
        │       └── closing_loc: (16,20)-(16,21) = "]"
        ├── @ MultiWriteNode (location: (17,0)-(17,12))
        │   ├── flags: newline
        │   ├── lefts: (length: 0)
        │   ├── rest:
        │   │   @ SplatNode (location: (17,1)-(17,7))
        │   │   ├── flags: ∅
        │   │   ├── operator_loc: (17,1)-(17,2) = "*"
        │   │   └── expression:
        │   │       @ CallTargetNode (location: (17,2)-(17,7))
        │   │       ├── flags: ∅
        │   │       ├── receiver:
        │   │       │   @ LocalVariableReadNode (location: (17,2)-(17,3))
        │   │       │   ├── flags: ∅
        │   │       │   ├── name: :c
        │   │       │   └── depth: 0
        │   │       ├── call_operator_loc: (17,3)-(17,4) = "."
        │   │       ├── name: :foo=
        │   │       └── message_loc: (17,4)-(17,7) = "foo"
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (17,0)-(17,1) = "("
        │   ├── rparen_loc: (17,7)-(17,8) = ")"
        │   ├── operator_loc: (17,9)-(17,10) = "="
        │   └── value:
        │       @ IntegerNode (location: (17,11)-(17,12))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ ConstantPathWriteNode (location: (18,0)-(18,13))
        │   ├── flags: newline
        │   ├── target:
        │   │   @ ConstantPathNode (location: (18,0)-(18,5))
        │   │   ├── flags: ∅
        │   │   ├── parent: ∅
        │   │   ├── name: :Foo
        │   │   ├── delimiter_loc: (18,0)-(18,2) = "::"
        │   │   └── name_loc: (18,2)-(18,5) = "Foo"
        │   ├── operator_loc: (18,6)-(18,7) = "="
        │   └── value:
        │       @ ConstantPathNode (location: (18,8)-(18,13))
        │       ├── flags: ∅
        │       ├── parent: ∅
        │       ├── name: :Bar
        │       ├── delimiter_loc: (18,8)-(18,10) = "::"
        │       └── name_loc: (18,10)-(18,13) = "Bar"
        ├── @ ClassVariableWriteNode (location: (19,0)-(19,7))
        │   ├── flags: newline
        │   ├── name: :@@a
        │   ├── name_loc: (19,0)-(19,3) = "@@a"
        │   ├── value:
        │   │   @ IntegerNode (location: (19,6)-(19,7))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (19,4)-(19,5) = "="
        ├── @ InstanceVariableWriteNode (location: (20,0)-(20,6))
        │   ├── flags: newline
        │   ├── name: :@a
        │   ├── name_loc: (20,0)-(20,2) = "@a"
        │   ├── value:
        │   │   @ IntegerNode (location: (20,5)-(20,6))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (20,3)-(20,4) = "="
        ├── @ ConstantWriteNode (location: (21,0)-(21,9))
        │   ├── flags: newline
        │   ├── name: :CONST
        │   ├── name_loc: (21,0)-(21,5) = "CONST"
        │   ├── value:
        │   │   @ IntegerNode (location: (21,8)-(21,9))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (21,6)-(21,7) = "="
        ├── @ ConstantPathWriteNode (location: (22,0)-(22,23))
        │   ├── flags: newline
        │   ├── target:
        │   │   @ ConstantPathNode (location: (22,0)-(22,19))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantPathNode (location: (22,0)-(22,12))
        │   │   │   ├── flags: ∅
        │   │   │   ├── parent:
        │   │   │   │   @ ConstantReadNode (location: (22,0)-(22,4))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :Name
        │   │   │   ├── name: :Spaced
        │   │   │   ├── delimiter_loc: (22,4)-(22,6) = "::"
        │   │   │   └── name_loc: (22,6)-(22,12) = "Spaced"
        │   │   ├── name: :CONST
        │   │   ├── delimiter_loc: (22,12)-(22,14) = "::"
        │   │   └── name_loc: (22,14)-(22,19) = "CONST"
        │   ├── operator_loc: (22,20)-(22,21) = "="
        │   └── value:
        │       @ IntegerNode (location: (22,22)-(22,23))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ LocalVariableWriteNode (location: (23,0)-(23,16))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── depth: 0
        │   ├── name_loc: (23,0)-(23,1) = "a"
        │   ├── value:
        │   │   @ ParenthesesNode (location: (23,4)-(23,16))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (23,5)-(23,15))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ MultiWriteNode (location: (23,5)-(23,15))
        │   │   │           ├── flags: newline
        │   │   │           ├── lefts: (length: 2)
        │   │   │           │   ├── @ LocalVariableTargetNode (location: (23,6)-(23,7))
        │   │   │           │   │   ├── flags: ∅
        │   │   │           │   │   ├── name: :b
        │   │   │           │   │   └── depth: 0
        │   │   │           │   └── @ LocalVariableTargetNode (location: (23,9)-(23,10))
        │   │   │           │       ├── flags: ∅
        │   │   │           │       ├── name: :c
        │   │   │           │       └── depth: 0
        │   │   │           ├── rest: ∅
        │   │   │           ├── rights: (length: 0)
        │   │   │           ├── lparen_loc: (23,5)-(23,6) = "("
        │   │   │           ├── rparen_loc: (23,10)-(23,11) = ")"
        │   │   │           ├── operator_loc: (23,12)-(23,13) = "="
        │   │   │           └── value:
        │   │   │               @ IntegerNode (location: (23,14)-(23,15))
        │   │   │               ├── flags: static_literal, decimal
        │   │   │               └── value: 1
        │   │   ├── opening_loc: (23,4)-(23,5) = "("
        │   │   └── closing_loc: (23,15)-(23,16) = ")"
        │   └── operator_loc: (23,2)-(23,3) = "="
        ├── @ LocalVariableWriteNode (location: (24,0)-(24,5))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── depth: 0
        │   ├── name_loc: (24,0)-(24,1) = "a"
        │   ├── value:
        │   │   @ IntegerNode (location: (24,4)-(24,5))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (24,2)-(24,3) = "="
        ├── @ LocalVariableWriteNode (location: (25,0)-(25,11))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── depth: 0
        │   ├── name_loc: (25,0)-(25,3) = "foo"
        │   ├── value:
        │   │   @ CallNode (location: (25,6)-(25,11))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (25,6)-(25,9) = "foo"
        │   │   ├── opening_loc: (25,9)-(25,10) = "("
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: (25,10)-(25,11) = ")"
        │   │   └── block: ∅
        │   └── operator_loc: (25,4)-(25,5) = "="
        ├── @ CallNode (location: (26,0)-(26,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (26,0)-(26,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: (26,3)-(26,4) = "."
        │   ├── name: :[]=
        │   ├── message_loc: (26,4)-(26,7) = "[]="
        │   ├── opening_loc: (26,7)-(26,8) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (26,8)-(26,9) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (27,0)-(27,13))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (27,0)-(27,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: (27,3)-(27,4) = "."
        │   ├── name: :[]=
        │   ├── message_loc: (27,4)-(27,7) = "[]="
        │   ├── opening_loc: (27,7)-(27,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (27,8)-(27,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ IntegerNode (location: (27,8)-(27,9))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 1
        │   │       └── @ IntegerNode (location: (27,11)-(27,12))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: (27,12)-(27,13) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (28,0)-(28,11))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (28,0)-(28,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: (28,3)-(28,4) = "."
        │   ├── name: :[]=
        │   ├── message_loc: (28,4)-(28,7) = "[]="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (28,7)-(28,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ TrueNode (location: (28,7)-(28,11))
        │   │           └── flags: static_literal
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (29,0)-(29,19))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (29,0)-(29,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (29,3)-(29,11) = "[*index]"
        │   ├── opening_loc: (29,3)-(29,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (29,4)-(29,19))
        │   │   ├── flags: contains_splat
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SplatNode (location: (29,4)-(29,10))
        │   │       │   ├── flags: ∅
        │   │       │   ├── operator_loc: (29,4)-(29,5) = "*"
        │   │       │   └── expression:
        │   │       │       @ CallNode (location: (29,5)-(29,10))
        │   │       │       ├── flags: variable_call, ignore_visibility
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── name: :index
        │   │       │       ├── message_loc: (29,5)-(29,10) = "index"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── block: ∅
        │   │       └── @ CallNode (location: (29,14)-(29,19))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :value
        │   │           ├── message_loc: (29,14)-(29,19) = "value"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (29,10)-(29,11) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (30,0)-(30,17))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (30,0)-(30,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (30,3)-(30,9) = "[1..2]"
        │   ├── opening_loc: (30,3)-(30,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (30,4)-(30,17))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ RangeNode (location: (30,4)-(30,8))
        │   │       │   ├── flags: static_literal
        │   │       │   ├── left:
        │   │       │   │   @ IntegerNode (location: (30,4)-(30,5))
        │   │       │   │   ├── flags: static_literal, decimal
        │   │       │   │   └── value: 1
        │   │       │   ├── right:
        │   │       │   │   @ IntegerNode (location: (30,7)-(30,8))
        │   │       │   │   ├── flags: static_literal, decimal
        │   │       │   │   └── value: 2
        │   │       │   └── operator_loc: (30,5)-(30,7) = ".."
        │   │       └── @ CallNode (location: (30,12)-(30,17))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :value
        │   │           ├── message_loc: (30,12)-(30,17) = "value"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (30,8)-(30,9) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (31,0)-(31,9))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (31,0)-(31,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (31,3)-(31,5) = "[]"
        │   ├── opening_loc: (31,3)-(31,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (31,8)-(31,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (31,8)-(31,9))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: (31,4)-(31,5) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (32,0)-(32,17))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (32,0)-(32,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (32,3)-(32,9) = "[a, b]"
        │   ├── opening_loc: (32,3)-(32,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (32,4)-(32,17))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 3)
        │   │       ├── @ LocalVariableReadNode (location: (32,4)-(32,5))
        │   │       │   ├── flags: ∅
        │   │       │   ├── name: :a
        │   │       │   └── depth: 0
        │   │       ├── @ LocalVariableReadNode (location: (32,7)-(32,8))
        │   │       │   ├── flags: ∅
        │   │       │   ├── name: :b
        │   │       │   └── depth: 0
        │   │       └── @ CallNode (location: (32,12)-(32,17))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :value
        │   │           ├── message_loc: (32,12)-(32,17) = "value"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (32,8)-(32,9) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (33,0)-(33,18))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (33,0)-(33,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (33,3)-(33,10) = "[index]"
        │   ├── opening_loc: (33,3)-(33,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (33,4)-(33,18))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (33,4)-(33,9))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :index
        │   │       │   ├── message_loc: (33,4)-(33,9) = "index"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (33,13)-(33,18))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :value
        │   │           ├── message_loc: (33,13)-(33,18) = "value"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (33,9)-(33,10) = "]"
        │   └── block: ∅
        ├── @ LocalVariableWriteNode (location: (34,0)-(34,7))
        │   ├── flags: newline
        │   ├── name: :x
        │   ├── depth: 0
        │   ├── name_loc: (34,0)-(34,1) = "x"
        │   ├── value:
        │   │   @ StringNode (location: (34,4)-(34,7))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (34,4)-(34,6) = "%("
        │   │   ├── content_loc: (34,6)-(34,6) = ""
        │   │   ├── closing_loc: (34,6)-(34,7) = ")"
        │   │   └── unescaped: ""
        │   └── operator_loc: (34,2)-(34,3) = "="
        ├── @ CallNode (location: (35,0)-(35,7))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (35,0)-(35,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :x
        │   │   └── depth: 0
        │   ├── call_operator_loc: (35,1)-(35,2) = "."
        │   ├── name: :x=
        │   ├── message_loc: (35,2)-(35,3) = "x"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (35,4)-(35,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (35,4)-(35,7))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (35,4)-(35,6) = "%("
        │   │           ├── content_loc: (35,6)-(35,6) = ""
        │   │           ├── closing_loc: (35,6)-(35,7) = ")"
        │   │           └── unescaped: ""
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (36,0)-(36,12))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (36,0)-(36,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :x
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (36,1)-(36,6) = "[%()]"
        │   ├── opening_loc: (36,1)-(36,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (36,2)-(36,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ StringNode (location: (36,2)-(36,5))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (36,2)-(36,4) = "%("
        │   │       │   ├── content_loc: (36,4)-(36,4) = ""
        │   │       │   ├── closing_loc: (36,4)-(36,5) = ")"
        │   │       │   └── unescaped: ""
        │   │       └── @ CallNode (location: (36,9)-(36,12))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (36,9)-(36,12) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (36,5)-(36,6) = "]"
        │   └── block: ∅
        ├── @ IndexOrWriteNode (location: (37,0)-(37,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (37,0)-(37,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (37,1)-(37,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (37,2)-(37,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (37,2)-(37,5))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (37,2)-(37,4) = "%("
        │   │           ├── content_loc: (37,4)-(37,4) = ""
        │   │           ├── closing_loc: (37,4)-(37,5) = ")"
        │   │           └── unescaped: ""
        │   ├── closing_loc: (37,5)-(37,6) = "]"
        │   ├── block: ∅
        │   ├── operator_loc: (37,7)-(37,10) = "||="
        │   └── value:
        │       @ CallNode (location: (37,11)-(37,14))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (37,11)-(37,14) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ InstanceVariableOrWriteNode (location: (38,0)-(38,10))
        │   ├── flags: newline
        │   ├── name: :@a
        │   ├── name_loc: (38,0)-(38,2) = "@a"
        │   ├── operator_loc: (38,3)-(38,6) = "||="
        │   └── value:
        │       @ StringNode (location: (38,7)-(38,10))
        │       ├── flags: ∅
        │       ├── opening_loc: (38,7)-(38,9) = "%("
        │       ├── content_loc: (38,9)-(38,9) = ""
        │       ├── closing_loc: (38,9)-(38,10) = ")"
        │       └── unescaped: ""
        ├── @ LocalVariableWriteNode (location: (39,0)-(39,14))
        │   ├── flags: newline
        │   ├── name: :x
        │   ├── depth: 0
        │   ├── name_loc: (39,0)-(39,1) = "x"
        │   ├── value:
        │   │   @ InterpolatedStringNode (location: (39,4)-(39,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (39,4)-(39,14) = "<<-HEREDOC"
        │   │   ├── parts: (length: 3)
        │   │   │   ├── @ StringNode (location: (40,0)-(40,2))
        │   │   │   │   ├── flags: static_literal, frozen
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── content_loc: (40,0)-(40,2) = "  "
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── unescaped: "  "
        │   │   │   ├── @ EmbeddedStatementsNode (location: (40,2)-(40,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── opening_loc: (40,2)-(40,4) = "\#{"
        │   │   │   │   ├── statements: ∅
        │   │   │   │   └── closing_loc: (40,4)-(40,5) = "}"
        │   │   │   └── @ StringNode (location: (40,5)-(41,0))
        │   │   │       ├── flags: static_literal, frozen
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (40,5)-(41,0) = "\n"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "\n"
        │   │   └── closing_loc: (41,0)-(42,0) = "HEREDOC\n"
        │   └── operator_loc: (39,2)-(39,3) = "="
        ├── @ CallNode (location: (42,0)-(42,14))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (42,0)-(42,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :x
        │   │   └── depth: 0
        │   ├── call_operator_loc: (42,1)-(42,2) = "."
        │   ├── name: :x=
        │   ├── message_loc: (42,2)-(42,3) = "x"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (42,4)-(42,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (42,4)-(42,14))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (42,4)-(42,14) = "<<-HEREDOC"
        │   │           ├── parts: (length: 3)
        │   │           │   ├── @ StringNode (location: (43,0)-(43,2))
        │   │           │   │   ├── flags: static_literal, frozen
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (43,0)-(43,2) = "  "
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "  "
        │   │           │   ├── @ EmbeddedStatementsNode (location: (43,2)-(43,5))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── opening_loc: (43,2)-(43,4) = "\#{"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── closing_loc: (43,4)-(43,5) = "}"
        │   │           │   └── @ StringNode (location: (43,5)-(44,0))
        │   │           │       ├── flags: static_literal, frozen
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (43,5)-(44,0) = "\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "\n"
        │   │           └── closing_loc: (44,0)-(45,0) = "HEREDOC\n"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (45,0)-(45,16))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (45,0)-(45,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :x
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (45,1)-(45,3) = "[]"
        │   ├── opening_loc: (45,1)-(45,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (45,6)-(45,16))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (45,6)-(45,16))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (45,6)-(45,16) = "<<-HEREDOC"
        │   │           ├── parts: (length: 3)
        │   │           │   ├── @ StringNode (location: (46,0)-(46,2))
        │   │           │   │   ├── flags: static_literal, frozen
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (46,0)-(46,2) = "  "
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "  "
        │   │           │   ├── @ EmbeddedStatementsNode (location: (46,2)-(46,5))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── opening_loc: (46,2)-(46,4) = "\#{"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── closing_loc: (46,4)-(46,5) = "}"
        │   │           │   └── @ StringNode (location: (46,5)-(47,0))
        │   │           │       ├── flags: static_literal, frozen
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (46,5)-(47,0) = "\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "\n"
        │   │           └── closing_loc: (47,0)-(48,0) = "HEREDOC\n"
        │   ├── closing_loc: (45,2)-(45,3) = "]"
        │   └── block: ∅
        ├── @ IndexOrWriteNode (location: (48,0)-(48,21))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (48,0)-(48,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (48,1)-(48,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (48,2)-(48,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (48,2)-(48,12))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (48,2)-(48,12) = "<<-HEREDOC"
        │   │           ├── parts: (length: 3)
        │   │           │   ├── @ StringNode (location: (49,0)-(49,2))
        │   │           │   │   ├── flags: static_literal, frozen
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (49,0)-(49,2) = "  "
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "  "
        │   │           │   ├── @ EmbeddedStatementsNode (location: (49,2)-(49,5))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── opening_loc: (49,2)-(49,4) = "\#{"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── closing_loc: (49,4)-(49,5) = "}"
        │   │           │   └── @ StringNode (location: (49,5)-(50,0))
        │   │           │       ├── flags: static_literal, frozen
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (49,5)-(50,0) = "\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "\n"
        │   │           └── closing_loc: (50,0)-(51,0) = "HEREDOC\n"
        │   ├── closing_loc: (48,12)-(48,13) = "]"
        │   ├── block: ∅
        │   ├── operator_loc: (48,14)-(48,17) = "||="
        │   └── value:
        │       @ CallNode (location: (48,18)-(48,21))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (48,18)-(48,21) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        └── @ InstanceVariableOrWriteNode (location: (51,0)-(51,17))
            ├── flags: newline
            ├── name: :@a
            ├── name_loc: (51,0)-(51,2) = "@a"
            ├── operator_loc: (51,3)-(51,6) = "||="
            └── value:
                @ InterpolatedStringNode (location: (51,7)-(51,17))
                ├── flags: ∅
                ├── opening_loc: (51,7)-(51,17) = "<<-HEREDOC"
                ├── parts: (length: 3)
                │   ├── @ StringNode (location: (52,0)-(52,2))
                │   │   ├── flags: static_literal, frozen
                │   │   ├── opening_loc: ∅
                │   │   ├── content_loc: (52,0)-(52,2) = "  "
                │   │   ├── closing_loc: ∅
                │   │   └── unescaped: "  "
                │   ├── @ EmbeddedStatementsNode (location: (52,2)-(52,5))
                │   │   ├── flags: ∅
                │   │   ├── opening_loc: (52,2)-(52,4) = "\#{"
                │   │   ├── statements: ∅
                │   │   └── closing_loc: (52,4)-(52,5) = "}"
                │   └── @ StringNode (location: (52,5)-(53,0))
                │       ├── flags: static_literal, frozen
                │       ├── opening_loc: ∅
                │       ├── content_loc: (52,5)-(53,0) = "\n"
                │       ├── closing_loc: ∅
                │       └── unescaped: "\n"
                └── closing_loc: (53,0)-(54,0) = "HEREDOC\n"
prism-1.5.1/snapshots/unparser/corpus/literal/block.txt000066400000000000000000002564421506127434000233520ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(96,1))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(96,1))
    ├── flags: ∅
    └── body: (length: 30)
        ├── @ CallNode (location: (1,0)-(2,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,4)-(2,1))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (1,4)-(1,5) = "{"
        │       └── closing_loc: (2,0)-(2,1) = "}"
        ├── @ CallNode (location: (3,0)-(4,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (3,4)-(4,1))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (3,6)-(3,9))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (3,7)-(3,8))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (3,7)-(3,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (3,6)-(3,7) = "|"
        │       │   └── closing_loc: (3,8)-(3,9) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (3,4)-(3,5) = "{"
        │       └── closing_loc: (4,0)-(4,1) = "}"
        ├── @ CallNode (location: (5,0)-(6,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (5,0)-(5,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (5,4)-(6,1))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (5,6)-(5,10))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (5,7)-(5,9))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (5,7)-(5,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ ImplicitRestNode (location: (5,8)-(5,9))
        │       │   │   │   └── flags: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (5,6)-(5,7) = "|"
        │       │   └── closing_loc: (5,9)-(5,10) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (5,4)-(5,5) = "{"
        │       └── closing_loc: (6,0)-(6,1) = "}"
        ├── @ CallNode (location: (7,0)-(8,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (7,0)-(7,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (7,4)-(8,1))
        │       ├── flags: ∅
        │       ├── locals: [:a, :x]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (7,6)-(7,13))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (7,7)-(7,9))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (7,7)-(7,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ ImplicitRestNode (location: (7,8)-(7,9))
        │       │   │   │   └── flags: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 1)
        │       │   │   └── @ BlockLocalVariableNode (location: (7,11)-(7,12))
        │       │   │       ├── flags: ∅
        │       │   │       └── name: :x
        │       │   ├── opening_loc: (7,6)-(7,7) = "|"
        │       │   └── closing_loc: (7,12)-(7,13) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (7,4)-(7,5) = "{"
        │       └── closing_loc: (8,0)-(8,1) = "}"
        ├── @ CallNode (location: (9,0)-(10,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (9,0)-(9,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (9,4)-(10,1))
        │       ├── flags: ∅
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (9,6)-(9,12))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (9,7)-(9,11))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 2)
        │       │   │   │   ├── @ RequiredParameterNode (location: (9,7)-(9,8))
        │       │   │   │   │   ├── flags: ∅
        │       │   │   │   │   └── name: :a
        │       │   │   │   └── @ RequiredParameterNode (location: (9,10)-(9,11))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :b
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (9,6)-(9,7) = "|"
        │       │   └── closing_loc: (9,11)-(9,12) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (9,4)-(9,5) = "{"
        │       └── closing_loc: (10,0)-(10,1) = "}"
        ├── @ CallNode (location: (11,0)-(13,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (11,0)-(11,3) = "foo"
        │   ├── opening_loc: (11,3)-(11,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (11,4)-(11,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (11,4)-(11,5))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: (11,5)-(11,6) = ")"
        │   └── block:
        │       @ BlockNode (location: (11,7)-(13,1))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (12,2)-(12,5))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ NilNode (location: (12,2)-(12,5))
        │       │           └── flags: newline, static_literal
        │       ├── opening_loc: (11,7)-(11,8) = "{"
        │       └── closing_loc: (13,0)-(13,1) = "}"
        ├── @ CallNode (location: (14,0)-(16,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (14,0)-(14,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (14,4)-(16,1))
        │       ├── flags: ∅
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (14,6)-(14,13))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (14,7)-(14,12))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (14,7)-(14,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (14,10)-(14,12))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :b
        │       │   │   │   ├── name_loc: (14,11)-(14,12) = "b"
        │       │   │   │   └── operator_loc: (14,10)-(14,11) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (14,6)-(14,7) = "|"
        │       │   └── closing_loc: (14,12)-(14,13) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (15,2)-(15,5))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ NilNode (location: (15,2)-(15,5))
        │       │           └── flags: newline, static_literal
        │       ├── opening_loc: (14,4)-(14,5) = "{"
        │       └── closing_loc: (16,0)-(16,1) = "}"
        ├── @ CallNode (location: (17,0)-(19,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (17,0)-(17,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (17,4)-(19,1))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (17,6)-(17,12))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (17,7)-(17,11))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (17,7)-(17,8))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (17,10)-(17,11))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: ∅
        │       │   │   │   ├── name_loc: ∅
        │       │   │   │   └── operator_loc: (17,10)-(17,11) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (17,6)-(17,7) = "|"
        │       │   └── closing_loc: (17,11)-(17,12) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (18,2)-(18,5))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ NilNode (location: (18,2)-(18,5))
        │       │           └── flags: newline, static_literal
        │       ├── opening_loc: (17,4)-(17,5) = "{"
        │       └── closing_loc: (19,0)-(19,1) = "}"
        ├── @ CallNode (location: (20,0)-(22,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (20,0)-(20,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (20,4)-(22,1))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (21,2)-(21,5))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (21,2)-(21,5))
        │       │           ├── flags: newline, variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :bar
        │       │           ├── message_loc: (21,2)-(21,5) = "bar"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (20,4)-(20,5) = "{"
        │       └── closing_loc: (22,0)-(22,1) = "}"
        ├── @ CallNode (location: (23,0)-(25,1))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (23,0)-(23,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (23,0)-(23,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (23,3)-(23,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (23,4)-(23,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (23,8)-(25,1))
        │       ├── flags: ∅
        │       ├── locals: [:a, :b, :c]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (23,10)-(23,21))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (23,11)-(23,20))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 2)
        │       │   │   │   ├── @ MultiTargetNode (location: (23,11)-(23,17))
        │       │   │   │   │   ├── flags: ∅
        │       │   │   │   │   ├── lefts: (length: 2)
        │       │   │   │   │   │   ├── @ RequiredParameterNode (location: (23,12)-(23,13))
        │       │   │   │   │   │   │   ├── flags: ∅
        │       │   │   │   │   │   │   └── name: :a
        │       │   │   │   │   │   └── @ RequiredParameterNode (location: (23,15)-(23,16))
        │       │   │   │   │   │       ├── flags: ∅
        │       │   │   │   │   │       └── name: :b
        │       │   │   │   │   ├── rest: ∅
        │       │   │   │   │   ├── rights: (length: 0)
        │       │   │   │   │   ├── lparen_loc: (23,11)-(23,12) = "("
        │       │   │   │   │   └── rparen_loc: (23,16)-(23,17) = ")"
        │       │   │   │   └── @ RequiredParameterNode (location: (23,19)-(23,20))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :c
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (23,10)-(23,11) = "|"
        │       │   └── closing_loc: (23,20)-(23,21) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (24,2)-(24,3))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (24,2)-(24,3))
        │       │           ├── flags: newline, variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :d
        │       │           ├── message_loc: (24,2)-(24,3) = "d"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (23,8)-(23,9) = "{"
        │       └── closing_loc: (25,0)-(25,1) = "}"
        ├── @ CallNode (location: (26,0)-(27,1))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (26,0)-(26,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (26,0)-(26,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (26,3)-(26,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (26,4)-(26,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (26,8)-(27,1))
        │       ├── flags: ∅
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (26,10)-(26,17))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (26,11)-(26,13))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (26,11)-(26,13))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :a
        │       │   │   │   ├── name_loc: (26,12)-(26,13) = "a"
        │       │   │   │   └── operator_loc: (26,11)-(26,12) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 1)
        │       │   │   └── @ BlockLocalVariableNode (location: (26,15)-(26,16))
        │       │   │       ├── flags: ∅
        │       │   │       └── name: :b
        │       │   ├── opening_loc: (26,10)-(26,11) = "|"
        │       │   └── closing_loc: (26,16)-(26,17) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (26,8)-(26,9) = "{"
        │       └── closing_loc: (27,0)-(27,1) = "}"
        ├── @ CallNode (location: (28,0)-(29,1))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (28,0)-(28,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (28,0)-(28,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (28,3)-(28,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (28,4)-(28,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (28,8)-(29,1))
        │       ├── flags: ∅
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (28,10)-(28,16))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (28,11)-(28,12))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (28,11)-(28,12))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 1)
        │       │   │   └── @ BlockLocalVariableNode (location: (28,14)-(28,15))
        │       │   │       ├── flags: ∅
        │       │   │       └── name: :b
        │       │   ├── opening_loc: (28,10)-(28,11) = "|"
        │       │   └── closing_loc: (28,15)-(28,16) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (28,8)-(28,9) = "{"
        │       └── closing_loc: (29,0)-(29,1) = "}"
        ├── @ CallNode (location: (30,0)-(31,1))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (30,0)-(30,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (30,0)-(30,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (30,3)-(30,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (30,4)-(30,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (30,8)-(31,1))
        │       ├── flags: ∅
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (30,10)-(30,18))
        │       │   ├── flags: ∅
        │       │   ├── parameters: ∅
        │       │   ├── locals: (length: 2)
        │       │   │   ├── @ BlockLocalVariableNode (location: (30,13)-(30,14))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   └── name: :a
        │       │   │   └── @ BlockLocalVariableNode (location: (30,16)-(30,17))
        │       │   │       ├── flags: ∅
        │       │   │       └── name: :b
        │       │   ├── opening_loc: (30,10)-(30,11) = "|"
        │       │   └── closing_loc: (30,17)-(30,18) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (30,8)-(30,9) = "{"
        │       └── closing_loc: (31,0)-(31,1) = "}"
        ├── @ CallNode (location: (32,0)-(34,1))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (32,0)-(32,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (32,0)-(32,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (32,3)-(32,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (32,4)-(32,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (32,8)-(34,1))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (32,10)-(32,13))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (32,11)-(32,12))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 0)
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest:
        │       │   │   │   @ RestParameterNode (location: (32,11)-(32,12))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: ∅
        │       │   │   │   ├── name_loc: ∅
        │       │   │   │   └── operator_loc: (32,11)-(32,12) = "*"
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (32,10)-(32,11) = "|"
        │       │   └── closing_loc: (32,12)-(32,13) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (33,2)-(33,3))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (33,2)-(33,3))
        │       │           ├── flags: newline, variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :d
        │       │           ├── message_loc: (33,2)-(33,3) = "d"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (32,8)-(32,9) = "{"
        │       └── closing_loc: (34,0)-(34,1) = "}"
        ├── @ CallNode (location: (35,0)-(37,1))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (35,0)-(35,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (35,0)-(35,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (35,3)-(35,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (35,4)-(35,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (35,8)-(37,1))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (35,10)-(35,15))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (35,11)-(35,14))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ MultiTargetNode (location: (35,11)-(35,14))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── lefts: (length: 0)
        │       │   │   │       ├── rest:
        │       │   │   │       │   @ SplatNode (location: (35,12)-(35,13))
        │       │   │   │       │   ├── flags: ∅
        │       │   │   │       │   ├── operator_loc: (35,12)-(35,13) = "*"
        │       │   │   │       │   └── expression: ∅
        │       │   │   │       ├── rights: (length: 0)
        │       │   │   │       ├── lparen_loc: (35,11)-(35,12) = "("
        │       │   │   │       └── rparen_loc: (35,13)-(35,14) = ")"
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (35,10)-(35,11) = "|"
        │       │   └── closing_loc: (35,14)-(35,15) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (36,2)-(36,3))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (36,2)-(36,3))
        │       │           ├── flags: newline, variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :d
        │       │           ├── message_loc: (36,2)-(36,3) = "d"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (35,8)-(35,9) = "{"
        │       └── closing_loc: (37,0)-(37,1) = "}"
        ├── @ CallNode (location: (38,0)-(40,1))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (38,0)-(38,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (38,0)-(38,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (38,3)-(38,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (38,4)-(38,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (38,8)-(40,1))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (38,10)-(38,17))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (38,11)-(38,16))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ MultiTargetNode (location: (38,11)-(38,16))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── lefts: (length: 1)
        │       │   │   │       │   └── @ MultiTargetNode (location: (38,12)-(38,15))
        │       │   │   │       │       ├── flags: ∅
        │       │   │   │       │       ├── lefts: (length: 0)
        │       │   │   │       │       ├── rest:
        │       │   │   │       │       │   @ SplatNode (location: (38,13)-(38,14))
        │       │   │   │       │       │   ├── flags: ∅
        │       │   │   │       │       │   ├── operator_loc: (38,13)-(38,14) = "*"
        │       │   │   │       │       │   └── expression: ∅
        │       │   │   │       │       ├── rights: (length: 0)
        │       │   │   │       │       ├── lparen_loc: (38,12)-(38,13) = "("
        │       │   │   │       │       └── rparen_loc: (38,14)-(38,15) = ")"
        │       │   │   │       ├── rest: ∅
        │       │   │   │       ├── rights: (length: 0)
        │       │   │   │       ├── lparen_loc: (38,11)-(38,12) = "("
        │       │   │   │       └── rparen_loc: (38,15)-(38,16) = ")"
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (38,10)-(38,11) = "|"
        │       │   └── closing_loc: (38,16)-(38,17) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (39,2)-(39,3))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (39,2)-(39,3))
        │       │           ├── flags: newline, variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :d
        │       │           ├── message_loc: (39,2)-(39,3) = "d"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (38,8)-(38,9) = "{"
        │       └── closing_loc: (40,0)-(40,1) = "}"
        ├── @ CallNode (location: (41,0)-(43,1))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (41,0)-(41,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (41,0)-(41,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (41,3)-(41,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (41,4)-(41,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (41,8)-(43,1))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (41,10)-(41,20))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (41,11)-(41,19))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ MultiTargetNode (location: (41,11)-(41,19))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── lefts: (length: 2)
        │       │   │   │       │   ├── @ RequiredParameterNode (location: (41,12)-(41,13))
        │       │   │   │       │   │   ├── flags: ∅
        │       │   │   │       │   │   └── name: :a
        │       │   │   │       │   └── @ MultiTargetNode (location: (41,15)-(41,18))
        │       │   │   │       │       ├── flags: ∅
        │       │   │   │       │       ├── lefts: (length: 0)
        │       │   │   │       │       ├── rest:
        │       │   │   │       │       │   @ SplatNode (location: (41,16)-(41,17))
        │       │   │   │       │       │   ├── flags: ∅
        │       │   │   │       │       │   ├── operator_loc: (41,16)-(41,17) = "*"
        │       │   │   │       │       │   └── expression: ∅
        │       │   │   │       │       ├── rights: (length: 0)
        │       │   │   │       │       ├── lparen_loc: (41,15)-(41,16) = "("
        │       │   │   │       │       └── rparen_loc: (41,17)-(41,18) = ")"
        │       │   │   │       ├── rest: ∅
        │       │   │   │       ├── rights: (length: 0)
        │       │   │   │       ├── lparen_loc: (41,11)-(41,12) = "("
        │       │   │   │       └── rparen_loc: (41,18)-(41,19) = ")"
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (41,10)-(41,11) = "|"
        │       │   └── closing_loc: (41,19)-(41,20) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (42,2)-(42,3))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (42,2)-(42,3))
        │       │           ├── flags: newline, variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :d
        │       │           ├── message_loc: (42,2)-(42,3) = "d"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (41,8)-(41,9) = "{"
        │       └── closing_loc: (43,0)-(43,1) = "}"
        ├── @ CallNode (location: (44,0)-(46,1))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (44,0)-(44,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (44,0)-(44,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (44,3)-(44,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (44,4)-(44,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (44,8)-(46,1))
        │       ├── flags: ∅
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (44,10)-(44,18))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (44,11)-(44,17))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ MultiTargetNode (location: (44,11)-(44,17))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── lefts: (length: 2)
        │       │   │   │       │   ├── @ RequiredParameterNode (location: (44,12)-(44,13))
        │       │   │   │       │   │   ├── flags: ∅
        │       │   │   │       │   │   └── name: :a
        │       │   │   │       │   └── @ RequiredParameterNode (location: (44,15)-(44,16))
        │       │   │   │       │       ├── flags: ∅
        │       │   │   │       │       └── name: :b
        │       │   │   │       ├── rest: ∅
        │       │   │   │       ├── rights: (length: 0)
        │       │   │   │       ├── lparen_loc: (44,11)-(44,12) = "("
        │       │   │   │       └── rparen_loc: (44,16)-(44,17) = ")"
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (44,10)-(44,11) = "|"
        │       │   └── closing_loc: (44,17)-(44,18) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (45,2)-(45,3))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (45,2)-(45,3))
        │       │           ├── flags: newline, variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :d
        │       │           ├── message_loc: (45,2)-(45,3) = "d"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (44,8)-(44,9) = "{"
        │       └── closing_loc: (46,0)-(46,1) = "}"
        ├── @ CallNode (location: (47,0)-(48,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (47,0)-(48,1))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (47,0)-(47,3))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (47,0)-(47,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: (47,3)-(47,4) = "."
        │   │   ├── name: :bar
        │   │   ├── message_loc: (47,4)-(47,7) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (47,8)-(48,1))
        │   │       ├── flags: ∅
        │   │       ├── locals: []
        │   │       ├── parameters: ∅
        │   │       ├── body: ∅
        │   │       ├── opening_loc: (47,8)-(47,9) = "{"
        │   │       └── closing_loc: (48,0)-(48,1) = "}"
        │   ├── call_operator_loc: (48,1)-(48,2) = "."
        │   ├── name: :baz
        │   ├── message_loc: (48,2)-(48,5) = "baz"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (49,0)-(51,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (49,0)-(49,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (49,2)-(51,3))
        │       ├── flags: ∅
        │       ├── locals: [:e]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (49,2)-(51,3))
        │       │   ├── flags: ∅
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (50,0)-(50,21))
        │       │   │   ├── flags: ∅
        │       │   │   ├── keyword_loc: (50,0)-(50,6) = "rescue"
        │       │   │   ├── exceptions: (length: 1)
        │       │   │   │   └── @ ConstantReadNode (location: (50,7)-(50,16))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :Exception
        │       │   │   ├── operator_loc: (50,17)-(50,19) = "=>"
        │       │   │   ├── reference:
        │       │   │   │   @ LocalVariableTargetNode (location: (50,20)-(50,21))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :e
        │       │   │   │   └── depth: 0
        │       │   │   ├── then_keyword_loc: ∅
        │       │   │   ├── statements: ∅
        │       │   │   └── subsequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (51,0)-(51,3) = "end"
        │       ├── opening_loc: (49,2)-(49,4) = "do"
        │       └── closing_loc: (51,0)-(51,3) = "end"
        ├── @ CallNode (location: (52,0)-(56,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (52,0)-(52,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (52,2)-(56,3))
        │       ├── flags: ∅
        │       ├── locals: [:bar]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (52,2)-(56,3))
        │       │   ├── flags: ∅
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (53,2)-(53,5))
        │       │   │   ├── flags: ∅
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ CallNode (location: (53,2)-(53,5))
        │       │   │           ├── flags: newline, variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :foo
        │       │   │           ├── message_loc: (53,2)-(53,5) = "foo"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (54,0)-(55,5))
        │       │   │   ├── flags: ∅
        │       │   │   ├── keyword_loc: (54,0)-(54,6) = "rescue"
        │       │   │   ├── exceptions: (length: 1)
        │       │   │   │   └── @ ConstantReadNode (location: (54,7)-(54,16))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :Exception
        │       │   │   ├── operator_loc: (54,17)-(54,19) = "=>"
        │       │   │   ├── reference:
        │       │   │   │   @ LocalVariableTargetNode (location: (54,20)-(54,23))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :bar
        │       │   │   │   └── depth: 0
        │       │   │   ├── then_keyword_loc: ∅
        │       │   │   ├── statements:
        │       │   │   │   @ StatementsNode (location: (55,2)-(55,5))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   └── body: (length: 1)
        │       │   │   │       └── @ LocalVariableReadNode (location: (55,2)-(55,5))
        │       │   │   │           ├── flags: newline
        │       │   │   │           ├── name: :bar
        │       │   │   │           └── depth: 0
        │       │   │   └── subsequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (56,0)-(56,3) = "end"
        │       ├── opening_loc: (52,2)-(52,4) = "do"
        │       └── closing_loc: (56,0)-(56,3) = "end"
        ├── @ CallNode (location: (57,0)-(61,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (57,0)-(57,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (57,2)-(61,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (57,2)-(61,3))
        │       │   ├── flags: ∅
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (58,2)-(58,5))
        │       │   │   ├── flags: ∅
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ CallNode (location: (58,2)-(58,5))
        │       │   │           ├── flags: newline, variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (58,2)-(58,5) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (59,0)-(60,5))
        │       │   │   ├── flags: ∅
        │       │   │   ├── keyword_loc: (59,0)-(59,6) = "rescue"
        │       │   │   ├── exceptions: (length: 2)
        │       │   │   │   ├── @ ConstantReadNode (location: (59,7)-(59,16))
        │       │   │   │   │   ├── flags: ∅
        │       │   │   │   │   └── name: :SomeError
        │       │   │   │   └── @ SplatNode (location: (59,18)-(59,22))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── operator_loc: (59,18)-(59,19) = "*"
        │       │   │   │       └── expression:
        │       │   │   │           @ CallNode (location: (59,19)-(59,22))
        │       │   │   │           ├── flags: variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :bar
        │       │   │   │           ├── message_loc: (59,19)-(59,22) = "bar"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   ├── operator_loc: ∅
        │       │   │   ├── reference: ∅
        │       │   │   ├── then_keyword_loc: ∅
        │       │   │   ├── statements:
        │       │   │   │   @ StatementsNode (location: (60,2)-(60,5))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   └── body: (length: 1)
        │       │   │   │       └── @ CallNode (location: (60,2)-(60,5))
        │       │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :baz
        │       │   │   │           ├── message_loc: (60,2)-(60,5) = "baz"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   └── subsequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (61,0)-(61,3) = "end"
        │       ├── opening_loc: (57,2)-(57,4) = "do"
        │       └── closing_loc: (61,0)-(61,3) = "end"
        ├── @ CallNode (location: (62,0)-(66,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (62,0)-(62,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (62,2)-(66,3))
        │       ├── flags: ∅
        │       ├── locals: [:exception]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (62,2)-(66,3))
        │       │   ├── flags: ∅
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (63,2)-(63,5))
        │       │   │   ├── flags: ∅
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ CallNode (location: (63,2)-(63,5))
        │       │   │           ├── flags: newline, variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (63,2)-(63,5) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (64,0)-(65,5))
        │       │   │   ├── flags: ∅
        │       │   │   ├── keyword_loc: (64,0)-(64,6) = "rescue"
        │       │   │   ├── exceptions: (length: 2)
        │       │   │   │   ├── @ ConstantReadNode (location: (64,7)-(64,16))
        │       │   │   │   │   ├── flags: ∅
        │       │   │   │   │   └── name: :SomeError
        │       │   │   │   └── @ SplatNode (location: (64,18)-(64,22))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── operator_loc: (64,18)-(64,19) = "*"
        │       │   │   │       └── expression:
        │       │   │   │           @ CallNode (location: (64,19)-(64,22))
        │       │   │   │           ├── flags: variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :bar
        │       │   │   │           ├── message_loc: (64,19)-(64,22) = "bar"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   ├── operator_loc: (64,23)-(64,25) = "=>"
        │       │   │   ├── reference:
        │       │   │   │   @ LocalVariableTargetNode (location: (64,26)-(64,35))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :exception
        │       │   │   │   └── depth: 0
        │       │   │   ├── then_keyword_loc: ∅
        │       │   │   ├── statements:
        │       │   │   │   @ StatementsNode (location: (65,2)-(65,5))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   └── body: (length: 1)
        │       │   │   │       └── @ CallNode (location: (65,2)-(65,5))
        │       │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :baz
        │       │   │   │           ├── message_loc: (65,2)-(65,5) = "baz"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   └── subsequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (66,0)-(66,3) = "end"
        │       ├── opening_loc: (62,2)-(62,4) = "do"
        │       └── closing_loc: (66,0)-(66,3) = "end"
        ├── @ CallNode (location: (67,0)-(71,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (67,0)-(67,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (67,2)-(71,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (67,2)-(71,3))
        │       │   ├── flags: ∅
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (68,2)-(68,5))
        │       │   │   ├── flags: ∅
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ CallNode (location: (68,2)-(68,5))
        │       │   │           ├── flags: newline, variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (68,2)-(68,5) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (69,0)-(70,5))
        │       │   │   ├── flags: ∅
        │       │   │   ├── keyword_loc: (69,0)-(69,6) = "rescue"
        │       │   │   ├── exceptions: (length: 1)
        │       │   │   │   └── @ SplatNode (location: (69,7)-(69,11))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── operator_loc: (69,7)-(69,8) = "*"
        │       │   │   │       └── expression:
        │       │   │   │           @ CallNode (location: (69,8)-(69,11))
        │       │   │   │           ├── flags: variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :bar
        │       │   │   │           ├── message_loc: (69,8)-(69,11) = "bar"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   ├── operator_loc: ∅
        │       │   │   ├── reference: ∅
        │       │   │   ├── then_keyword_loc: ∅
        │       │   │   ├── statements:
        │       │   │   │   @ StatementsNode (location: (70,2)-(70,5))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   └── body: (length: 1)
        │       │   │   │       └── @ CallNode (location: (70,2)-(70,5))
        │       │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :baz
        │       │   │   │           ├── message_loc: (70,2)-(70,5) = "baz"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   └── subsequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (71,0)-(71,3) = "end"
        │       ├── opening_loc: (67,2)-(67,4) = "do"
        │       └── closing_loc: (71,0)-(71,3) = "end"
        ├── @ CallNode (location: (72,0)-(75,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (72,0)-(72,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (72,2)-(75,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (72,2)-(75,3))
        │       │   ├── flags: ∅
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (73,2)-(73,5))
        │       │   │   ├── flags: ∅
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ CallNode (location: (73,2)-(73,5))
        │       │   │           ├── flags: newline, variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (73,2)-(73,5) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (74,0)-(74,16))
        │       │   │   ├── flags: ∅
        │       │   │   ├── keyword_loc: (74,0)-(74,6) = "rescue"
        │       │   │   ├── exceptions: (length: 1)
        │       │   │   │   └── @ ConstantReadNode (location: (74,7)-(74,16))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :LoadError
        │       │   │   ├── operator_loc: ∅
        │       │   │   ├── reference: ∅
        │       │   │   ├── then_keyword_loc: ∅
        │       │   │   ├── statements: ∅
        │       │   │   └── subsequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (75,0)-(75,3) = "end"
        │       ├── opening_loc: (72,2)-(72,4) = "do"
        │       └── closing_loc: (75,0)-(75,3) = "end"
        ├── @ CallNode (location: (76,0)-(81,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (76,0)-(76,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (76,2)-(81,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (76,2)-(81,3))
        │       │   ├── flags: ∅
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (77,2)-(77,5))
        │       │   │   ├── flags: ∅
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ CallNode (location: (77,2)-(77,5))
        │       │   │           ├── flags: newline, variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (77,2)-(77,5) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (78,0)-(78,6))
        │       │   │   ├── flags: ∅
        │       │   │   ├── keyword_loc: (78,0)-(78,6) = "rescue"
        │       │   │   ├── exceptions: (length: 0)
        │       │   │   ├── operator_loc: ∅
        │       │   │   ├── reference: ∅
        │       │   │   ├── then_keyword_loc: ∅
        │       │   │   ├── statements: ∅
        │       │   │   └── subsequent: ∅
        │       │   ├── else_clause:
        │       │   │   @ ElseNode (location: (79,0)-(81,3))
        │       │   │   ├── flags: ∅
        │       │   │   ├── else_keyword_loc: (79,0)-(79,4) = "else"
        │       │   │   ├── statements:
        │       │   │   │   @ StatementsNode (location: (80,2)-(80,5))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   └── body: (length: 1)
        │       │   │   │       └── @ CallNode (location: (80,2)-(80,5))
        │       │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :baz
        │       │   │   │           ├── message_loc: (80,2)-(80,5) = "baz"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   └── end_keyword_loc: (81,0)-(81,3) = "end"
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (81,0)-(81,3) = "end"
        │       ├── opening_loc: (76,2)-(76,4) = "do"
        │       └── closing_loc: (81,0)-(81,3) = "end"
        ├── @ CallNode (location: (82,0)-(86,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (82,0)-(82,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (82,2)-(86,3))
        │       ├── flags: ∅
        │       ├── locals: [:exception]
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (82,2)-(86,3))
        │       │   ├── flags: ∅
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (83,2)-(83,5))
        │       │   │   ├── flags: ∅
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ CallNode (location: (83,2)-(83,5))
        │       │   │           ├── flags: newline, variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (83,2)-(83,5) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (84,0)-(85,5))
        │       │   │   ├── flags: ∅
        │       │   │   ├── keyword_loc: (84,0)-(84,6) = "rescue"
        │       │   │   ├── exceptions: (length: 1)
        │       │   │   │   └── @ SplatNode (location: (84,7)-(84,11))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── operator_loc: (84,7)-(84,8) = "*"
        │       │   │   │       └── expression:
        │       │   │   │           @ CallNode (location: (84,8)-(84,11))
        │       │   │   │           ├── flags: variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :bar
        │       │   │   │           ├── message_loc: (84,8)-(84,11) = "bar"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   ├── operator_loc: (84,12)-(84,14) = "=>"
        │       │   │   ├── reference:
        │       │   │   │   @ LocalVariableTargetNode (location: (84,15)-(84,24))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   ├── name: :exception
        │       │   │   │   └── depth: 0
        │       │   │   ├── then_keyword_loc: ∅
        │       │   │   ├── statements:
        │       │   │   │   @ StatementsNode (location: (85,2)-(85,5))
        │       │   │   │   ├── flags: ∅
        │       │   │   │   └── body: (length: 1)
        │       │   │   │       └── @ CallNode (location: (85,2)-(85,5))
        │       │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │       │   │   │           ├── receiver: ∅
        │       │   │   │           ├── call_operator_loc: ∅
        │       │   │   │           ├── name: :baz
        │       │   │   │           ├── message_loc: (85,2)-(85,5) = "baz"
        │       │   │   │           ├── opening_loc: ∅
        │       │   │   │           ├── arguments: ∅
        │       │   │   │           ├── closing_loc: ∅
        │       │   │   │           └── block: ∅
        │       │   │   └── subsequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (86,0)-(86,3) = "end"
        │       ├── opening_loc: (82,2)-(82,4) = "do"
        │       └── closing_loc: (86,0)-(86,3) = "end"
        ├── @ CallNode (location: (87,0)-(89,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (87,0)-(87,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (87,2)-(89,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (87,2)-(89,3))
        │       │   ├── flags: ∅
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements: ∅
        │       │   ├── rescue_clause: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause:
        │       │   │   @ EnsureNode (location: (88,0)-(89,3))
        │       │   │   ├── flags: ∅
        │       │   │   ├── ensure_keyword_loc: (88,0)-(88,6) = "ensure"
        │       │   │   ├── statements: ∅
        │       │   │   └── end_keyword_loc: (89,0)-(89,3) = "end"
        │       │   └── end_keyword_loc: (89,0)-(89,3) = "end"
        │       ├── opening_loc: (87,2)-(87,4) = "do"
        │       └── closing_loc: (89,0)-(89,3) = "end"
        ├── @ CallNode (location: (90,0)-(93,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (90,0)-(90,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (90,2)-(93,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (90,2)-(93,3))
        │       │   ├── flags: ∅
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (91,0)-(91,6))
        │       │   │   ├── flags: ∅
        │       │   │   ├── keyword_loc: (91,0)-(91,6) = "rescue"
        │       │   │   ├── exceptions: (length: 0)
        │       │   │   ├── operator_loc: ∅
        │       │   │   ├── reference: ∅
        │       │   │   ├── then_keyword_loc: ∅
        │       │   │   ├── statements: ∅
        │       │   │   └── subsequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause:
        │       │   │   @ EnsureNode (location: (92,0)-(93,3))
        │       │   │   ├── flags: ∅
        │       │   │   ├── ensure_keyword_loc: (92,0)-(92,6) = "ensure"
        │       │   │   ├── statements: ∅
        │       │   │   └── end_keyword_loc: (93,0)-(93,3) = "end"
        │       │   └── end_keyword_loc: (93,0)-(93,3) = "end"
        │       ├── opening_loc: (90,2)-(90,4) = "do"
        │       └── closing_loc: (93,0)-(93,3) = "end"
        └── @ CallNode (location: (94,0)-(96,1))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :bar
            ├── message_loc: (94,0)-(94,3) = "bar"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (94,4)-(96,1))
                ├── flags: ∅
                ├── locals: [:_1, :_2]
                ├── parameters:
                │   @ NumberedParametersNode (location: (94,4)-(96,1))
                │   ├── flags: ∅
                │   └── maximum: 2
                ├── body:
                │   @ StatementsNode (location: (95,2)-(95,9))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ CallNode (location: (95,2)-(95,9))
                │           ├── flags: newline
                │           ├── receiver:
                │           │   @ LocalVariableReadNode (location: (95,2)-(95,4))
                │           │   ├── flags: ∅
                │           │   ├── name: :_1
                │           │   └── depth: 0
                │           ├── call_operator_loc: ∅
                │           ├── name: :+
                │           ├── message_loc: (95,5)-(95,6) = "+"
                │           ├── opening_loc: ∅
                │           ├── arguments:
                │           │   @ ArgumentsNode (location: (95,7)-(95,9))
                │           │   ├── flags: ∅
                │           │   └── arguments: (length: 1)
                │           │       └── @ LocalVariableReadNode (location: (95,7)-(95,9))
                │           │           ├── flags: ∅
                │           │           ├── name: :_2
                │           │           └── depth: 0
                │           ├── closing_loc: ∅
                │           └── block: ∅
                ├── opening_loc: (94,4)-(94,5) = "{"
                └── closing_loc: (96,0)-(96,1) = "}"
prism-1.5.1/snapshots/unparser/corpus/literal/case.txt000066400000000000000000000714631506127434000231710ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(37,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(37,3))
    ├── flags: ∅
    └── body: (length: 8)
        ├── @ CaseNode (location: (1,0)-(6,3))
        │   ├── flags: newline
        │   ├── predicate: ∅
        │   ├── conditions: (length: 2)
        │   │   ├── @ WhenNode (location: (2,0)-(3,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (2,0)-(2,4) = "when"
        │   │   │   ├── conditions: (length: 1)
        │   │   │   │   └── @ CallNode (location: (2,5)-(2,8))
        │   │   │   │       ├── flags: variable_call, ignore_visibility
        │   │   │   │       ├── receiver: ∅
        │   │   │   │       ├── call_operator_loc: ∅
        │   │   │   │       ├── name: :bar
        │   │   │   │       ├── message_loc: (2,5)-(2,8) = "bar"
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── arguments: ∅
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── block: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   └── statements:
        │   │   │       @ StatementsNode (location: (3,2)-(3,5))
        │   │   │       ├── flags: ∅
        │   │   │       └── body: (length: 1)
        │   │   │           └── @ CallNode (location: (3,2)-(3,5))
        │   │   │               ├── flags: newline, variable_call, ignore_visibility
        │   │   │               ├── receiver: ∅
        │   │   │               ├── call_operator_loc: ∅
        │   │   │               ├── name: :baz
        │   │   │               ├── message_loc: (3,2)-(3,5) = "baz"
        │   │   │               ├── opening_loc: ∅
        │   │   │               ├── arguments: ∅
        │   │   │               ├── closing_loc: ∅
        │   │   │               └── block: ∅
        │   │   └── @ WhenNode (location: (4,0)-(5,5))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (4,0)-(4,4) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ CallNode (location: (4,5)-(4,8))
        │   │       │       ├── flags: variable_call, ignore_visibility
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── name: :baz
        │   │       │       ├── message_loc: (4,5)-(4,8) = "baz"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── block: ∅
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements:
        │   │           @ StatementsNode (location: (5,2)-(5,5))
        │   │           ├── flags: ∅
        │   │           └── body: (length: 1)
        │   │               └── @ CallNode (location: (5,2)-(5,5))
        │   │                   ├── flags: newline, variable_call, ignore_visibility
        │   │                   ├── receiver: ∅
        │   │                   ├── call_operator_loc: ∅
        │   │                   ├── name: :bar
        │   │                   ├── message_loc: (5,2)-(5,5) = "bar"
        │   │                   ├── opening_loc: ∅
        │   │                   ├── arguments: ∅
        │   │                   ├── closing_loc: ∅
        │   │                   └── block: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (6,0)-(6,3) = "end"
        ├── @ CaseNode (location: (7,0)-(11,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (7,5)-(7,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (7,5)-(7,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 2)
        │   │   ├── @ WhenNode (location: (8,0)-(8,8))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (8,0)-(8,4) = "when"
        │   │   │   ├── conditions: (length: 1)
        │   │   │   │   └── @ CallNode (location: (8,5)-(8,8))
        │   │   │   │       ├── flags: variable_call, ignore_visibility
        │   │   │   │       ├── receiver: ∅
        │   │   │   │       ├── call_operator_loc: ∅
        │   │   │   │       ├── name: :bar
        │   │   │   │       ├── message_loc: (8,5)-(8,8) = "bar"
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── arguments: ∅
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── block: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   └── statements: ∅
        │   │   └── @ WhenNode (location: (9,0)-(10,5))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (9,0)-(9,4) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ CallNode (location: (9,5)-(9,8))
        │   │       │       ├── flags: variable_call, ignore_visibility
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── name: :baz
        │   │       │       ├── message_loc: (9,5)-(9,8) = "baz"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── block: ∅
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements:
        │   │           @ StatementsNode (location: (10,2)-(10,5))
        │   │           ├── flags: ∅
        │   │           └── body: (length: 1)
        │   │               └── @ CallNode (location: (10,2)-(10,5))
        │   │                   ├── flags: newline, variable_call, ignore_visibility
        │   │                   ├── receiver: ∅
        │   │                   ├── call_operator_loc: ∅
        │   │                   ├── name: :bar
        │   │                   ├── message_loc: (10,2)-(10,5) = "bar"
        │   │                   ├── opening_loc: ∅
        │   │                   ├── arguments: ∅
        │   │                   ├── closing_loc: ∅
        │   │                   └── block: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (7,0)-(7,4) = "case"
        │   └── end_keyword_loc: (11,0)-(11,3) = "end"
        ├── @ CaseNode (location: (12,0)-(17,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (12,5)-(12,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (12,5)-(12,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 2)
        │   │   ├── @ WhenNode (location: (13,0)-(14,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (13,0)-(13,4) = "when"
        │   │   │   ├── conditions: (length: 1)
        │   │   │   │   └── @ CallNode (location: (13,5)-(13,8))
        │   │   │   │       ├── flags: variable_call, ignore_visibility
        │   │   │   │       ├── receiver: ∅
        │   │   │   │       ├── call_operator_loc: ∅
        │   │   │   │       ├── name: :bar
        │   │   │   │       ├── message_loc: (13,5)-(13,8) = "bar"
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── arguments: ∅
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── block: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   └── statements:
        │   │   │       @ StatementsNode (location: (14,2)-(14,5))
        │   │   │       ├── flags: ∅
        │   │   │       └── body: (length: 1)
        │   │   │           └── @ CallNode (location: (14,2)-(14,5))
        │   │   │               ├── flags: newline, variable_call, ignore_visibility
        │   │   │               ├── receiver: ∅
        │   │   │               ├── call_operator_loc: ∅
        │   │   │               ├── name: :baz
        │   │   │               ├── message_loc: (14,2)-(14,5) = "baz"
        │   │   │               ├── opening_loc: ∅
        │   │   │               ├── arguments: ∅
        │   │   │               ├── closing_loc: ∅
        │   │   │               └── block: ∅
        │   │   └── @ WhenNode (location: (15,0)-(16,5))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (15,0)-(15,4) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ CallNode (location: (15,5)-(15,8))
        │   │       │       ├── flags: variable_call, ignore_visibility
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── name: :baz
        │   │       │       ├── message_loc: (15,5)-(15,8) = "baz"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── block: ∅
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements:
        │   │           @ StatementsNode (location: (16,2)-(16,5))
        │   │           ├── flags: ∅
        │   │           └── body: (length: 1)
        │   │               └── @ CallNode (location: (16,2)-(16,5))
        │   │                   ├── flags: newline, variable_call, ignore_visibility
        │   │                   ├── receiver: ∅
        │   │                   ├── call_operator_loc: ∅
        │   │                   ├── name: :bar
        │   │                   ├── message_loc: (16,2)-(16,5) = "bar"
        │   │                   ├── opening_loc: ∅
        │   │                   ├── arguments: ∅
        │   │                   ├── closing_loc: ∅
        │   │                   └── block: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (12,0)-(12,4) = "case"
        │   └── end_keyword_loc: (17,0)-(17,3) = "end"
        ├── @ CaseNode (location: (18,0)-(21,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (18,5)-(18,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (18,5)-(18,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ WhenNode (location: (19,0)-(20,8))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (19,0)-(19,4) = "when"
        │   │       ├── conditions: (length: 2)
        │   │       │   ├── @ CallNode (location: (19,5)-(19,8))
        │   │       │   │   ├── flags: variable_call, ignore_visibility
        │   │       │   │   ├── receiver: ∅
        │   │       │   │   ├── call_operator_loc: ∅
        │   │       │   │   ├── name: :bar
        │   │       │   │   ├── message_loc: (19,5)-(19,8) = "bar"
        │   │       │   │   ├── opening_loc: ∅
        │   │       │   │   ├── arguments: ∅
        │   │       │   │   ├── closing_loc: ∅
        │   │       │   │   └── block: ∅
        │   │       │   └── @ CallNode (location: (19,10)-(19,13))
        │   │       │       ├── flags: variable_call, ignore_visibility
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── name: :baz
        │   │       │       ├── message_loc: (19,10)-(19,13) = "baz"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── block: ∅
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements:
        │   │           @ StatementsNode (location: (20,2)-(20,8))
        │   │           ├── flags: ∅
        │   │           └── body: (length: 1)
        │   │               └── @ SymbolNode (location: (20,2)-(20,8))
        │   │                   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   │                   ├── opening_loc: (20,2)-(20,3) = ":"
        │   │                   ├── value_loc: (20,3)-(20,8) = "other"
        │   │                   ├── closing_loc: ∅
        │   │                   └── unescaped: "other"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (18,0)-(18,4) = "case"
        │   └── end_keyword_loc: (21,0)-(21,3) = "end"
        ├── @ CaseNode (location: (22,0)-(25,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (22,5)-(22,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (22,5)-(22,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ WhenNode (location: (23,0)-(24,8))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (23,0)-(23,4) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ SplatNode (location: (23,5)-(23,9))
        │   │       │       ├── flags: ∅
        │   │       │       ├── operator_loc: (23,5)-(23,6) = "*"
        │   │       │       └── expression:
        │   │       │           @ CallNode (location: (23,6)-(23,9))
        │   │       │           ├── flags: variable_call, ignore_visibility
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :bar
        │   │       │           ├── message_loc: (23,6)-(23,9) = "bar"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments: ∅
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements:
        │   │           @ StatementsNode (location: (24,2)-(24,8))
        │   │           ├── flags: ∅
        │   │           └── body: (length: 1)
        │   │               └── @ SymbolNode (location: (24,2)-(24,8))
        │   │                   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   │                   ├── opening_loc: (24,2)-(24,3) = ":"
        │   │                   ├── value_loc: (24,3)-(24,8) = "value"
        │   │                   ├── closing_loc: ∅
        │   │                   └── unescaped: "value"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (22,0)-(22,4) = "case"
        │   └── end_keyword_loc: (25,0)-(25,3) = "end"
        ├── @ CaseNode (location: (26,0)-(31,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (26,5)-(26,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (26,5)-(26,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ WhenNode (location: (27,0)-(28,5))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (27,0)-(27,4) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ CallNode (location: (27,5)-(27,8))
        │   │       │       ├── flags: variable_call, ignore_visibility
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── name: :bar
        │   │       │       ├── message_loc: (27,5)-(27,8) = "bar"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── block: ∅
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements:
        │   │           @ StatementsNode (location: (28,2)-(28,5))
        │   │           ├── flags: ∅
        │   │           └── body: (length: 1)
        │   │               └── @ CallNode (location: (28,2)-(28,5))
        │   │                   ├── flags: newline, variable_call, ignore_visibility
        │   │                   ├── receiver: ∅
        │   │                   ├── call_operator_loc: ∅
        │   │                   ├── name: :baz
        │   │                   ├── message_loc: (28,2)-(28,5) = "baz"
        │   │                   ├── opening_loc: ∅
        │   │                   ├── arguments: ∅
        │   │                   ├── closing_loc: ∅
        │   │                   └── block: ∅
        │   ├── else_clause:
        │   │   @ ElseNode (location: (29,0)-(31,3))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (29,0)-(29,4) = "else"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (30,2)-(30,6))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ SymbolNode (location: (30,2)-(30,6))
        │   │   │           ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   │   │           ├── opening_loc: (30,2)-(30,3) = ":"
        │   │   │           ├── value_loc: (30,3)-(30,6) = "foo"
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── unescaped: "foo"
        │   │   └── end_keyword_loc: (31,0)-(31,3) = "end"
        │   ├── case_keyword_loc: (26,0)-(26,4) = "case"
        │   └── end_keyword_loc: (31,0)-(31,3) = "end"
        ├── @ CaseNode (location: (32,0)-(34,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (32,5)-(32,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (32,5)-(32,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ WhenNode (location: (33,0)-(33,15))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (33,0)-(33,4) = "when"
        │   │       ├── conditions: (length: 1)
        │   │       │   └── @ SplatNode (location: (33,5)-(33,15))
        │   │       │       ├── flags: ∅
        │   │       │       ├── operator_loc: (33,5)-(33,6) = "*"
        │   │       │       └── expression:
        │   │       │           @ CallNode (location: (33,6)-(33,15))
        │   │       │           ├── flags: ∅
        │   │       │           ├── receiver:
        │   │       │           │   @ CallNode (location: (33,6)-(33,9))
        │   │       │           │   ├── flags: variable_call, ignore_visibility
        │   │       │           │   ├── receiver: ∅
        │   │       │           │   ├── call_operator_loc: ∅
        │   │       │           │   ├── name: :bar
        │   │       │           │   ├── message_loc: (33,6)-(33,9) = "bar"
        │   │       │           │   ├── opening_loc: ∅
        │   │       │           │   ├── arguments: ∅
        │   │       │           │   ├── closing_loc: ∅
        │   │       │           │   └── block: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :|
        │   │       │           ├── message_loc: (33,10)-(33,11) = "|"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments:
        │   │       │           │   @ ArgumentsNode (location: (33,12)-(33,15))
        │   │       │           │   ├── flags: ∅
        │   │       │           │   └── arguments: (length: 1)
        │   │       │           │       └── @ CallNode (location: (33,12)-(33,15))
        │   │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │           │           ├── receiver: ∅
        │   │       │           │           ├── call_operator_loc: ∅
        │   │       │           │           ├── name: :baz
        │   │       │           │           ├── message_loc: (33,12)-(33,15) = "baz"
        │   │       │           │           ├── opening_loc: ∅
        │   │       │           │           ├── arguments: ∅
        │   │       │           │           ├── closing_loc: ∅
        │   │       │           │           └── block: ∅
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       ├── then_keyword_loc: ∅
        │   │       └── statements: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (32,0)-(32,4) = "case"
        │   └── end_keyword_loc: (34,0)-(34,3) = "end"
        └── @ CaseNode (location: (35,0)-(37,3))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (35,5)-(35,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (35,5)-(35,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ WhenNode (location: (36,0)-(36,15))
            │       ├── flags: ∅
            │       ├── keyword_loc: (36,0)-(36,4) = "when"
            │       ├── conditions: (length: 1)
            │       │   └── @ SplatNode (location: (36,5)-(36,15))
            │       │       ├── flags: ∅
            │       │       ├── operator_loc: (36,5)-(36,6) = "*"
            │       │       └── expression:
            │       │           @ CallNode (location: (36,6)-(36,15))
            │       │           ├── flags: attribute_write
            │       │           ├── receiver:
            │       │           │   @ CallNode (location: (36,6)-(36,9))
            │       │           │   ├── flags: variable_call, ignore_visibility
            │       │           │   ├── receiver: ∅
            │       │           │   ├── call_operator_loc: ∅
            │       │           │   ├── name: :bar
            │       │           │   ├── message_loc: (36,6)-(36,9) = "bar"
            │       │           │   ├── opening_loc: ∅
            │       │           │   ├── arguments: ∅
            │       │           │   ├── closing_loc: ∅
            │       │           │   └── block: ∅
            │       │           ├── call_operator_loc: (36,9)-(36,10) = "."
            │       │           ├── name: :baz=
            │       │           ├── message_loc: (36,10)-(36,13) = "baz"
            │       │           ├── opening_loc: ∅
            │       │           ├── arguments:
            │       │           │   @ ArgumentsNode (location: (36,14)-(36,15))
            │       │           │   ├── flags: ∅
            │       │           │   └── arguments: (length: 1)
            │       │           │       └── @ IntegerNode (location: (36,14)-(36,15))
            │       │           │           ├── flags: static_literal, decimal
            │       │           │           └── value: 1
            │       │           ├── closing_loc: ∅
            │       │           └── block: ∅
            │       ├── then_keyword_loc: ∅
            │       └── statements: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (35,0)-(35,4) = "case"
            └── end_keyword_loc: (37,0)-(37,3) = "end"
prism-1.5.1/snapshots/unparser/corpus/literal/class.txt000066400000000000000000000326061506127434000233570ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(35,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(35,3))
    ├── flags: ∅
    └── body: (length: 10)
        ├── @ ClassNode (location: (1,0)-(2,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (1,0)-(1,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (1,6)-(1,7))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body: ∅
        │   ├── end_keyword_loc: (2,0)-(2,3) = "end"
        │   └── name: :A
        ├── @ SingletonClassNode (location: (4,0)-(5,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (4,0)-(4,5) = "class"
        │   ├── operator_loc: (4,6)-(4,8) = "<<"
        │   ├── expression:
        │   │   @ CallNode (location: (4,9)-(4,10))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (4,9)-(4,10) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   └── end_keyword_loc: (5,0)-(5,3) = "end"
        ├── @ SingletonClassNode (location: (7,0)-(9,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (7,0)-(7,5) = "class"
        │   ├── operator_loc: (7,6)-(7,8) = "<<"
        │   ├── expression:
        │   │   @ CallNode (location: (7,9)-(7,10))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (7,9)-(7,10) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (8,2)-(8,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (8,2)-(8,3))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (8,2)-(8,3) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   └── end_keyword_loc: (9,0)-(9,3) = "end"
        ├── @ ClassNode (location: (11,0)-(12,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (11,0)-(11,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantPathNode (location: (11,6)-(11,10))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (11,6)-(11,7))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :A
        │   │   ├── name: :B
        │   │   ├── delimiter_loc: (11,7)-(11,9) = "::"
        │   │   └── name_loc: (11,9)-(11,10) = "B"
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body: ∅
        │   ├── end_keyword_loc: (12,0)-(12,3) = "end"
        │   └── name: :B
        ├── @ ClassNode (location: (14,0)-(15,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (14,0)-(14,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantPathNode (location: (14,6)-(14,13))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantPathNode (location: (14,6)-(14,10))
        │   │   │   ├── flags: ∅
        │   │   │   ├── parent:
        │   │   │   │   @ ConstantReadNode (location: (14,6)-(14,7))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :A
        │   │   │   ├── name: :B
        │   │   │   ├── delimiter_loc: (14,7)-(14,9) = "::"
        │   │   │   └── name_loc: (14,9)-(14,10) = "B"
        │   │   ├── name: :C
        │   │   ├── delimiter_loc: (14,10)-(14,12) = "::"
        │   │   └── name_loc: (14,12)-(14,13) = "C"
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body: ∅
        │   ├── end_keyword_loc: (15,0)-(15,3) = "end"
        │   └── name: :C
        ├── @ ClassNode (location: (17,0)-(18,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (17,0)-(17,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (17,6)-(17,7))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: (17,8)-(17,9) = "<"
        │   ├── superclass:
        │   │   @ ConstantReadNode (location: (17,10)-(17,11))
        │   │   ├── flags: ∅
        │   │   └── name: :B
        │   ├── body: ∅
        │   ├── end_keyword_loc: (18,0)-(18,3) = "end"
        │   └── name: :A
        ├── @ ClassNode (location: (20,0)-(21,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (20,0)-(20,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (20,6)-(20,7))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: (20,8)-(20,9) = "<"
        │   ├── superclass:
        │   │   @ ConstantPathNode (location: (20,10)-(20,14))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (20,10)-(20,11))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :B
        │   │   ├── name: :C
        │   │   ├── delimiter_loc: (20,11)-(20,13) = "::"
        │   │   └── name_loc: (20,13)-(20,14) = "C"
        │   ├── body: ∅
        │   ├── end_keyword_loc: (21,0)-(21,3) = "end"
        │   └── name: :A
        ├── @ ClassNode (location: (23,0)-(24,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (23,0)-(23,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantPathNode (location: (23,6)-(23,10))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (23,6)-(23,7))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :A
        │   │   ├── name: :B
        │   │   ├── delimiter_loc: (23,7)-(23,9) = "::"
        │   │   └── name_loc: (23,9)-(23,10) = "B"
        │   ├── inheritance_operator_loc: (23,11)-(23,12) = "<"
        │   ├── superclass:
        │   │   @ ConstantPathNode (location: (23,13)-(23,17))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (23,13)-(23,14))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :C
        │   │   ├── name: :D
        │   │   ├── delimiter_loc: (23,14)-(23,16) = "::"
        │   │   └── name_loc: (23,16)-(23,17) = "D"
        │   ├── body: ∅
        │   ├── end_keyword_loc: (24,0)-(24,3) = "end"
        │   └── name: :B
        ├── @ ClassNode (location: (26,0)-(32,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (26,0)-(26,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (26,6)-(26,7))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (27,2)-(31,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 2)
        │   │       ├── @ CallNode (location: (27,2)-(27,16))
        │   │       │   ├── flags: newline, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :include
        │   │       │   ├── message_loc: (27,2)-(27,9) = "include"
        │   │       │   ├── opening_loc: (27,9)-(27,10) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (27,10)-(27,15))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (27,10)-(27,15))
        │   │       │   │           ├── flags: ∅
        │   │       │   │           ├── receiver:
        │   │       │   │           │   @ ConstantReadNode (location: (27,10)-(27,11))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── name: :B
        │   │       │   │           ├── call_operator_loc: (27,11)-(27,12) = "."
        │   │       │   │           ├── name: :new
        │   │       │   │           ├── message_loc: (27,12)-(27,15) = "new"
        │   │       │   │           ├── opening_loc: ∅
        │   │       │   │           ├── arguments: ∅
        │   │       │   │           ├── closing_loc: ∅
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (27,15)-(27,16) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ DefNode (location: (29,2)-(31,5))
        │   │           ├── flags: newline
        │   │           ├── name: :foo
        │   │           ├── name_loc: (29,6)-(29,9) = "foo"
        │   │           ├── receiver: ∅
        │   │           ├── parameters: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (30,4)-(30,8))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ SymbolNode (location: (30,4)-(30,8))
        │   │           │           ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   │           │           ├── opening_loc: (30,4)-(30,5) = ":"
        │   │           │           ├── value_loc: (30,5)-(30,8) = "bar"
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── unescaped: "bar"
        │   │           ├── locals: []
        │   │           ├── def_keyword_loc: (29,2)-(29,5) = "def"
        │   │           ├── operator_loc: ∅
        │   │           ├── lparen_loc: ∅
        │   │           ├── rparen_loc: ∅
        │   │           ├── equal_loc: ∅
        │   │           └── end_keyword_loc: (31,2)-(31,5) = "end"
        │   ├── end_keyword_loc: (32,0)-(32,3) = "end"
        │   └── name: :A
        └── @ ClassNode (location: (34,0)-(35,3))
            ├── flags: newline
            ├── locals: []
            ├── class_keyword_loc: (34,0)-(34,5) = "class"
            ├── constant_path:
            │   @ ConstantPathNode (location: (34,6)-(34,9))
            │   ├── flags: ∅
            │   ├── parent: ∅
            │   ├── name: :A
            │   ├── delimiter_loc: (34,6)-(34,8) = "::"
            │   └── name_loc: (34,8)-(34,9) = "A"
            ├── inheritance_operator_loc: ∅
            ├── superclass: ∅
            ├── body: ∅
            ├── end_keyword_loc: (35,0)-(35,3) = "end"
            └── name: :A
prism-1.5.1/snapshots/unparser/corpus/literal/def.txt000066400000000000000000002207421506127434000230100ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(134,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(134,3))
    ├── flags: ∅
    └── body: (length: 30)
        ├── @ DefNode (location: (1,0)-(9,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (1,4)-(1,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (1,0)-(9,3))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (2,2)-(2,3))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (2,2)-(2,3))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :a
        │   │   │           ├── message_loc: (2,2)-(2,3) = "a"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (3,0)-(4,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (3,0)-(3,6) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (4,2)-(4,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (4,2)-(4,3))
        │   │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :b
        │   │   │   │           ├── message_loc: (4,2)-(4,3) = "b"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── subsequent: ∅
        │   │   ├── else_clause:
        │   │   │   @ ElseNode (location: (5,0)-(7,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── else_keyword_loc: (5,0)-(5,4) = "else"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (6,2)-(6,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (6,2)-(6,3))
        │   │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :c
        │   │   │   │           ├── message_loc: (6,2)-(6,3) = "c"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── end_keyword_loc: (7,0)-(7,6) = "ensure"
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (7,0)-(9,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── ensure_keyword_loc: (7,0)-(7,6) = "ensure"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (8,2)-(8,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (8,2)-(8,3))
        │   │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :d
        │   │   │   │           ├── message_loc: (8,2)-(8,3) = "d"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── end_keyword_loc: (9,0)-(9,3) = "end"
        │   │   └── end_keyword_loc: (9,0)-(9,3) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (9,0)-(9,3) = "end"
        ├── @ DefNode (location: (11,0)-(19,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (11,4)-(11,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (11,0)-(19,3))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (12,2)-(12,12))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ RescueModifierNode (location: (12,2)-(12,12))
        │   │   │           ├── flags: newline
        │   │   │           ├── expression:
        │   │   │           │   @ CallNode (location: (12,2)-(12,3))
        │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── name: :a
        │   │   │           │   ├── message_loc: (12,2)-(12,3) = "a"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── block: ∅
        │   │   │           ├── keyword_loc: (12,4)-(12,10) = "rescue"
        │   │   │           └── rescue_expression:
        │   │   │               @ CallNode (location: (12,11)-(12,12))
        │   │   │               ├── flags: variable_call, ignore_visibility
        │   │   │               ├── receiver: ∅
        │   │   │               ├── call_operator_loc: ∅
        │   │   │               ├── name: :b
        │   │   │               ├── message_loc: (12,11)-(12,12) = "b"
        │   │   │               ├── opening_loc: ∅
        │   │   │               ├── arguments: ∅
        │   │   │               ├── closing_loc: ∅
        │   │   │               └── block: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (13,0)-(14,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (13,0)-(13,6) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (14,2)-(14,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (14,2)-(14,3))
        │   │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :b
        │   │   │   │           ├── message_loc: (14,2)-(14,3) = "b"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── subsequent: ∅
        │   │   ├── else_clause:
        │   │   │   @ ElseNode (location: (15,0)-(17,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── else_keyword_loc: (15,0)-(15,4) = "else"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (16,2)-(16,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (16,2)-(16,3))
        │   │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :c
        │   │   │   │           ├── message_loc: (16,2)-(16,3) = "c"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── end_keyword_loc: (17,0)-(17,6) = "ensure"
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (17,0)-(19,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── ensure_keyword_loc: (17,0)-(17,6) = "ensure"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (18,2)-(18,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (18,2)-(18,3))
        │   │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :d
        │   │   │   │           ├── message_loc: (18,2)-(18,3) = "d"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── end_keyword_loc: (19,0)-(19,3) = "end"
        │   │   └── end_keyword_loc: (19,0)-(19,3) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (11,0)-(11,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (19,0)-(19,3) = "end"
        ├── @ DefNode (location: (21,0)-(22,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (21,4)-(21,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (21,8)-(21,18))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 2)
        │   │   │   ├── @ RequiredKeywordParameterNode (location: (21,8)-(21,12))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :bar
        │   │   │   │   └── name_loc: (21,8)-(21,12) = "bar:"
        │   │   │   └── @ RequiredKeywordParameterNode (location: (21,14)-(21,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       └── name_loc: (21,14)-(21,18) = "baz:"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar, :baz]
        │   ├── def_keyword_loc: (21,0)-(21,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (21,7)-(21,8) = "("
        │   ├── rparen_loc: (21,18)-(21,19) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (22,0)-(22,3) = "end"
        ├── @ DefNode (location: (24,0)-(25,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (24,4)-(24,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (24,0)-(24,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (25,0)-(25,3) = "end"
        ├── @ DefNode (location: (27,0)-(29,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (27,4)-(27,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (28,2)-(28,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (28,2)-(28,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (28,2)-(28,5) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (27,0)-(27,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (29,0)-(29,3) = "end"
        ├── @ DefNode (location: (31,0)-(37,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (31,4)-(31,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (31,0)-(37,3))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (32,2)-(32,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (32,2)-(32,5))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :foo
        │   │   │           ├── message_loc: (32,2)-(32,5) = "foo"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (33,0)-(34,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (33,0)-(33,6) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (34,2)-(34,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (34,2)-(34,5))
        │   │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :bar
        │   │   │   │           ├── message_loc: (34,2)-(34,5) = "bar"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── subsequent: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (35,0)-(37,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── ensure_keyword_loc: (35,0)-(35,6) = "ensure"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (36,2)-(36,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (36,2)-(36,5))
        │   │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :baz
        │   │   │   │           ├── message_loc: (36,2)-(36,5) = "baz"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── end_keyword_loc: (37,0)-(37,3) = "end"
        │   │   └── end_keyword_loc: (37,0)-(37,3) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (31,0)-(31,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (37,0)-(37,3) = "end"
        ├── @ DefNode (location: (39,0)-(43,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (39,4)-(39,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (39,0)-(43,3))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (40,2)-(40,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (40,2)-(40,5))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :bar
        │   │   │           ├── message_loc: (40,2)-(40,5) = "bar"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── rescue_clause: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause:
        │   │   │   @ EnsureNode (location: (41,0)-(43,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── ensure_keyword_loc: (41,0)-(41,6) = "ensure"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (42,2)-(42,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (42,2)-(42,5))
        │   │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :baz
        │   │   │   │           ├── message_loc: (42,2)-(42,5) = "baz"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── end_keyword_loc: (43,0)-(43,3) = "end"
        │   │   └── end_keyword_loc: (43,0)-(43,3) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (39,0)-(39,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (43,0)-(43,3) = "end"
        ├── @ DefNode (location: (45,0)-(49,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (45,4)-(45,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (45,0)-(49,3))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (46,2)-(46,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (46,2)-(46,5))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :bar
        │   │   │           ├── message_loc: (46,2)-(46,5) = "bar"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (47,0)-(48,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (47,0)-(47,6) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (48,2)-(48,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (48,2)-(48,5))
        │   │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :baz
        │   │   │   │           ├── message_loc: (48,2)-(48,5) = "baz"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── subsequent: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause: ∅
        │   │   └── end_keyword_loc: (49,0)-(49,3) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (45,0)-(45,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (49,0)-(49,3) = "end"
        ├── @ DefNode (location: (51,0)-(53,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (51,4)-(51,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (51,8)-(51,11))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (51,8)-(51,11))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :bar
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (52,2)-(52,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (52,2)-(52,5))
        │   │           ├── flags: newline
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (51,0)-(51,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (51,7)-(51,8) = "("
        │   ├── rparen_loc: (51,11)-(51,12) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (53,0)-(53,3) = "end"
        ├── @ DefNode (location: (55,0)-(57,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (55,4)-(55,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (55,8)-(55,16))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 2)
        │   │   │   ├── @ RequiredParameterNode (location: (55,8)-(55,11))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :bar
        │   │   │   └── @ RequiredParameterNode (location: (55,13)-(55,16))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :baz
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (56,2)-(56,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (56,2)-(56,5))
        │   │           ├── flags: newline
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar, :baz]
        │   ├── def_keyword_loc: (55,0)-(55,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (55,7)-(55,8) = "("
        │   ├── rparen_loc: (55,16)-(55,17) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (57,0)-(57,3) = "end"
        ├── @ DefNode (location: (59,0)-(61,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (59,4)-(59,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (59,8)-(59,16))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (59,8)-(59,16))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (59,8)-(59,11) = "bar"
        │   │   │       ├── operator_loc: (59,12)-(59,13) = "="
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (59,14)-(59,16))
        │   │   │           ├── flags: ∅
        │   │   │           ├── body: ∅
        │   │   │           ├── opening_loc: (59,14)-(59,15) = "("
        │   │   │           └── closing_loc: (59,15)-(59,16) = ")"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (60,2)-(60,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (60,2)-(60,5))
        │   │           ├── flags: newline
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (59,0)-(59,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (59,7)-(59,8) = "("
        │   ├── rparen_loc: (59,16)-(59,17) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (61,0)-(61,3) = "end"
        ├── @ DefNode (location: (63,0)-(64,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (63,4)-(63,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (63,8)-(63,24))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (63,8)-(63,24))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (63,8)-(63,11) = "bar"
        │   │   │       ├── operator_loc: (63,12)-(63,13) = "="
        │   │   │       └── value:
        │   │   │           @ ParenthesesNode (location: (63,14)-(63,24))
        │   │   │           ├── flags: multiple_statements
        │   │   │           ├── body:
        │   │   │           │   @ StatementsNode (location: (63,15)-(63,23))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── body: (length: 2)
        │   │   │           │       ├── @ CallNode (location: (63,15)-(63,18))
        │   │   │           │       │   ├── flags: newline, variable_call, ignore_visibility
        │   │   │           │       │   ├── receiver: ∅
        │   │   │           │       │   ├── call_operator_loc: ∅
        │   │   │           │       │   ├── name: :baz
        │   │   │           │       │   ├── message_loc: (63,15)-(63,18) = "baz"
        │   │   │           │       │   ├── opening_loc: ∅
        │   │   │           │       │   ├── arguments: ∅
        │   │   │           │       │   ├── closing_loc: ∅
        │   │   │           │       │   └── block: ∅
        │   │   │           │       └── @ NilNode (location: (63,20)-(63,23))
        │   │   │           │           └── flags: newline, static_literal
        │   │   │           ├── opening_loc: (63,14)-(63,15) = "("
        │   │   │           └── closing_loc: (63,23)-(63,24) = ")"
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (63,0)-(63,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (63,7)-(63,8) = "("
        │   ├── rparen_loc: (63,24)-(63,25) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (64,0)-(64,3) = "end"
        ├── @ DefNode (location: (66,0)-(68,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (66,4)-(66,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (66,8)-(66,18))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (66,8)-(66,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (66,8)-(66,11) = "bar"
        │   │   │       ├── operator_loc: (66,12)-(66,13) = "="
        │   │   │       └── value:
        │   │   │           @ TrueNode (location: (66,14)-(66,18))
        │   │   │           └── flags: static_literal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (67,2)-(67,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (67,2)-(67,5))
        │   │           ├── flags: newline
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (66,0)-(66,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (66,7)-(66,8) = "("
        │   ├── rparen_loc: (66,18)-(66,19) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (68,0)-(68,3) = "end"
        ├── @ DefNode (location: (70,0)-(72,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (70,4)-(70,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (70,8)-(70,23))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (70,8)-(70,11))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :bar
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (70,13)-(70,23))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       ├── name_loc: (70,13)-(70,16) = "baz"
        │   │   │       ├── operator_loc: (70,17)-(70,18) = "="
        │   │   │       └── value:
        │   │   │           @ TrueNode (location: (70,19)-(70,23))
        │   │   │           └── flags: static_literal
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (71,2)-(71,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (71,2)-(71,5))
        │   │           ├── flags: newline
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar, :baz]
        │   ├── def_keyword_loc: (70,0)-(70,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (70,7)-(70,8) = "("
        │   ├── rparen_loc: (70,23)-(70,24) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (72,0)-(72,3) = "end"
        ├── @ DefNode (location: (74,0)-(75,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (74,4)-(74,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (74,8)-(74,14))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (74,8)-(74,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (74,8)-(74,12) = "bar:"
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (74,13)-(74,14))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (74,0)-(74,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (74,7)-(74,8) = "("
        │   ├── rparen_loc: (74,14)-(74,15) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (75,0)-(75,3) = "end"
        ├── @ DefNode (location: (77,0)-(78,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (77,4)-(77,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (77,8)-(77,16))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (77,8)-(77,16))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (77,8)-(77,12) = "bar:"
        │   │   │       └── value:
        │   │   │           @ CallNode (location: (77,13)-(77,16))
        │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :baz
        │   │   │           ├── message_loc: (77,13)-(77,16) = "baz"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (77,0)-(77,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (77,7)-(77,8) = "("
        │   ├── rparen_loc: (77,16)-(77,17) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (78,0)-(78,3) = "end"
        ├── @ DefNode (location: (80,0)-(81,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (80,4)-(80,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (80,8)-(80,18))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ OptionalKeywordParameterNode (location: (80,8)-(80,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :bar
        │   │   │       ├── name_loc: (80,8)-(80,12) = "bar:"
        │   │   │       └── value:
        │   │   │           @ CallNode (location: (80,13)-(80,18))
        │   │   │           ├── flags: ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :bar
        │   │   │           ├── message_loc: (80,13)-(80,16) = "bar"
        │   │   │           ├── opening_loc: (80,16)-(80,17) = "("
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: (80,17)-(80,18) = ")"
        │   │   │           └── block: ∅
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (80,0)-(80,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (80,7)-(80,8) = "("
        │   ├── rparen_loc: (80,18)-(80,19) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (81,0)-(81,3) = "end"
        ├── @ DefNode (location: (83,0)-(85,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (83,4)-(83,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (83,8)-(83,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (83,8)-(83,9))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (83,8)-(83,9) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (84,2)-(84,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (84,2)-(84,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (84,2)-(84,5) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (83,0)-(83,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (83,7)-(83,8) = "("
        │   ├── rparen_loc: (83,9)-(83,10) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (85,0)-(85,3) = "end"
        ├── @ DefNode (location: (87,0)-(89,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (87,4)-(87,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (87,8)-(87,12))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (87,8)-(87,12))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :bar
        │   │   │   ├── name_loc: (87,9)-(87,12) = "bar"
        │   │   │   └── operator_loc: (87,8)-(87,9) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (88,2)-(88,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (88,2)-(88,5))
        │   │           ├── flags: newline
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar]
        │   ├── def_keyword_loc: (87,0)-(87,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (87,7)-(87,8) = "("
        │   ├── rparen_loc: (87,12)-(87,13) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (89,0)-(89,3) = "end"
        ├── @ DefNode (location: (91,0)-(93,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (91,4)-(91,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (91,8)-(91,17))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (91,8)-(91,11))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :bar
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (91,13)-(91,17))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :baz
        │   │   │   ├── name_loc: (91,14)-(91,17) = "baz"
        │   │   │   └── operator_loc: (91,13)-(91,14) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (92,2)-(92,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (92,2)-(92,5))
        │   │           ├── flags: newline
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar, :baz]
        │   ├── def_keyword_loc: (91,0)-(91,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (91,7)-(91,8) = "("
        │   ├── rparen_loc: (91,17)-(91,18) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (93,0)-(93,3) = "end"
        ├── @ DefNode (location: (95,0)-(97,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (95,4)-(95,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (95,8)-(95,24))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (95,8)-(95,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       ├── name_loc: (95,8)-(95,11) = "baz"
        │   │   │       ├── operator_loc: (95,12)-(95,13) = "="
        │   │   │       └── value:
        │   │   │           @ TrueNode (location: (95,14)-(95,18))
        │   │   │           └── flags: static_literal
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (95,20)-(95,24))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :bor
        │   │   │   ├── name_loc: (95,21)-(95,24) = "bor"
        │   │   │   └── operator_loc: (95,20)-(95,21) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (96,2)-(96,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (96,2)-(96,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (96,2)-(96,5) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: [:baz, :bor]
        │   ├── def_keyword_loc: (95,0)-(95,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (95,7)-(95,8) = "("
        │   ├── rparen_loc: (95,24)-(95,25) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (97,0)-(97,3) = "end"
        ├── @ DefNode (location: (99,0)-(101,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (99,4)-(99,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (99,8)-(99,32))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (99,8)-(99,18))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       ├── name_loc: (99,8)-(99,11) = "baz"
        │   │   │       ├── operator_loc: (99,12)-(99,13) = "="
        │   │   │       └── value:
        │   │   │           @ TrueNode (location: (99,14)-(99,18))
        │   │   │           └── flags: static_literal
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (99,20)-(99,24))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :bor
        │   │   │   ├── name_loc: (99,21)-(99,24) = "bor"
        │   │   │   └── operator_loc: (99,20)-(99,21) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (99,26)-(99,32))
        │   │       ├── flags: ∅
        │   │       ├── name: :block
        │   │       ├── name_loc: (99,27)-(99,32) = "block"
        │   │       └── operator_loc: (99,26)-(99,27) = "&"
        │   ├── body:
        │   │   @ StatementsNode (location: (100,2)-(100,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (100,2)-(100,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (100,2)-(100,5) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: [:baz, :bor, :block]
        │   ├── def_keyword_loc: (99,0)-(99,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (99,7)-(99,8) = "("
        │   ├── rparen_loc: (99,32)-(99,33) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (101,0)-(101,3) = "end"
        ├── @ DefNode (location: (103,0)-(105,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (103,4)-(103,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (103,8)-(103,29))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (103,8)-(103,11))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :bar
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (103,13)-(103,23))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       ├── name_loc: (103,13)-(103,16) = "baz"
        │   │   │       ├── operator_loc: (103,17)-(103,18) = "="
        │   │   │       └── value:
        │   │   │           @ TrueNode (location: (103,19)-(103,23))
        │   │   │           └── flags: static_literal
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (103,25)-(103,29))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :bor
        │   │   │   ├── name_loc: (103,26)-(103,29) = "bor"
        │   │   │   └── operator_loc: (103,25)-(103,26) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (104,2)-(104,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (104,2)-(104,5))
        │   │           ├── flags: newline
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar, :baz, :bor]
        │   ├── def_keyword_loc: (103,0)-(103,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (103,7)-(103,8) = "("
        │   ├── rparen_loc: (103,29)-(103,30) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (105,0)-(105,3) = "end"
        ├── @ DefNode (location: (107,0)-(109,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (107,4)-(107,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (107,8)-(107,14))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (107,8)-(107,14))
        │   │       ├── flags: ∅
        │   │       ├── name: :block
        │   │       ├── name_loc: (107,9)-(107,14) = "block"
        │   │       └── operator_loc: (107,8)-(107,9) = "&"
        │   ├── body:
        │   │   @ StatementsNode (location: (108,2)-(108,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (108,2)-(108,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (108,2)-(108,5) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: [:block]
        │   ├── def_keyword_loc: (107,0)-(107,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (107,7)-(107,8) = "("
        │   ├── rparen_loc: (107,14)-(107,15) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (109,0)-(109,3) = "end"
        ├── @ DefNode (location: (111,0)-(113,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (111,4)-(111,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (111,8)-(111,19))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (111,8)-(111,11))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :bar
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (111,13)-(111,19))
        │   │       ├── flags: ∅
        │   │       ├── name: :block
        │   │       ├── name_loc: (111,14)-(111,19) = "block"
        │   │       └── operator_loc: (111,13)-(111,14) = "&"
        │   ├── body:
        │   │   @ StatementsNode (location: (112,2)-(112,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (112,2)-(112,5))
        │   │           ├── flags: newline
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── locals: [:bar, :block]
        │   ├── def_keyword_loc: (111,0)-(111,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (111,7)-(111,8) = "("
        │   ├── rparen_loc: (111,19)-(111,20) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (113,0)-(113,3) = "end"
        ├── @ DefNode (location: (115,0)-(118,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (115,4)-(115,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (116,2)-(117,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 2)
        │   │       ├── @ CallNode (location: (116,2)-(116,5))
        │   │       │   ├── flags: newline, variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :bar
        │   │       │   ├── message_loc: (116,2)-(116,5) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (117,2)-(117,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :baz
        │   │           ├── message_loc: (117,2)-(117,5) = "baz"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (115,0)-(115,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (118,0)-(118,3) = "end"
        ├── @ DefNode (location: (120,0)-(121,3))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (120,4)-(120,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (120,6)-(120,11))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (120,6)-(120,11))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 1)
        │   │   │       │   └── @ MultiTargetNode (location: (120,7)-(120,10))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       ├── lefts: (length: 1)
        │   │   │       │       │   └── @ RequiredParameterNode (location: (120,8)-(120,9))
        │   │   │       │       │       ├── flags: ∅
        │   │   │       │       │       └── name: :a
        │   │   │       │       ├── rest: ∅
        │   │   │       │       ├── rights: (length: 0)
        │   │   │       │       ├── lparen_loc: (120,7)-(120,8) = "("
        │   │   │       │       └── rparen_loc: (120,9)-(120,10) = ")"
        │   │   │       ├── rest: ∅
        │   │   │       ├── rights: (length: 0)
        │   │   │       ├── lparen_loc: (120,6)-(120,7) = "("
        │   │   │       └── rparen_loc: (120,10)-(120,11) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (120,0)-(120,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (120,5)-(120,6) = "("
        │   ├── rparen_loc: (120,11)-(120,12) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (121,0)-(121,3) = "end"
        ├── @ DefNode (location: (123,0)-(124,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (123,4)-(123,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (123,8)-(123,26))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 2)
        │   │   │   ├── @ RequiredKeywordParameterNode (location: (123,8)-(123,12))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :bar
        │   │   │   │   └── name_loc: (123,8)-(123,12) = "bar:"
        │   │   │   └── @ OptionalKeywordParameterNode (location: (123,14)-(123,26))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :baz
        │   │   │       ├── name_loc: (123,14)-(123,18) = "baz:"
        │   │   │       └── value:
        │   │   │           @ StringNode (location: (123,19)-(123,26))
        │   │   │           ├── flags: ∅
        │   │   │           ├── opening_loc: (123,19)-(123,20) = "\""
        │   │   │           ├── content_loc: (123,20)-(123,25) = "value"
        │   │   │           ├── closing_loc: (123,25)-(123,26) = "\""
        │   │   │           └── unescaped: "value"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:bar, :baz]
        │   ├── def_keyword_loc: (123,0)-(123,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (123,7)-(123,8) = "("
        │   ├── rparen_loc: (123,26)-(123,27) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (124,0)-(124,3) = "end"
        ├── @ DefNode (location: (126,0)-(130,3))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (126,4)-(126,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (127,2)-(127,12))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (127,2)-(127,12))
        │   │           ├── flags: newline
        │   │           ├── opening_loc: (127,2)-(127,12) = "<<-HEREDOC"
        │   │           ├── parts: (length: 3)
        │   │           │   ├── @ StringNode (location: (128,0)-(128,4))
        │   │           │   │   ├── flags: static_literal, frozen
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (128,0)-(128,4) = "    "
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "    "
        │   │           │   ├── @ EmbeddedStatementsNode (location: (128,4)-(128,7))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── opening_loc: (128,4)-(128,6) = "\#{"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── closing_loc: (128,6)-(128,7) = "}"
        │   │           │   └── @ StringNode (location: (128,7)-(129,0))
        │   │           │       ├── flags: static_literal, frozen
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (128,7)-(129,0) = "\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "\n"
        │   │           └── closing_loc: (129,0)-(130,0) = "  HEREDOC\n"
        │   ├── locals: []
        │   ├── def_keyword_loc: (126,0)-(126,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (130,0)-(130,3) = "end"
        └── @ DefNode (location: (132,0)-(134,3))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (132,4)-(132,5) = "f"
            ├── receiver: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (133,2)-(133,5))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ StringNode (location: (133,2)-(133,5))
            │           ├── flags: newline
            │           ├── opening_loc: (133,2)-(133,4) = "%("
            │           ├── content_loc: (133,4)-(133,4) = ""
            │           ├── closing_loc: (133,4)-(133,5) = ")"
            │           └── unescaped: ""
            ├── locals: []
            ├── def_keyword_loc: (132,0)-(132,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (134,0)-(134,3) = "end"
prism-1.5.1/snapshots/unparser/corpus/literal/defined.txt000066400000000000000000000074011506127434000236430ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,27))
├── flags: ∅
├── locals: [:a, :b]
└── statements:
    @ StatementsNode (location: (1,0)-(3,27))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ DefinedNode (location: (1,0)-(1,14))
        │   ├── flags: newline
        │   ├── lparen_loc: (1,8)-(1,9) = "("
        │   ├── value:
        │   │   @ InstanceVariableReadNode (location: (1,9)-(1,13))
        │   │   ├── flags: ∅
        │   │   └── name: :@foo
        │   ├── rparen_loc: (1,13)-(1,14) = ")"
        │   └── keyword_loc: (1,0)-(1,8) = "defined?"
        ├── @ DefinedNode (location: (2,0)-(2,13))
        │   ├── flags: newline
        │   ├── lparen_loc: (2,8)-(2,9) = "("
        │   ├── value:
        │   │   @ ConstantReadNode (location: (2,9)-(2,12))
        │   │   ├── flags: ∅
        │   │   └── name: :Foo
        │   ├── rparen_loc: (2,12)-(2,13) = ")"
        │   └── keyword_loc: (2,0)-(2,8) = "defined?"
        └── @ DefinedNode (location: (3,0)-(3,27))
            ├── flags: newline
            ├── lparen_loc: (3,8)-(3,9) = "("
            ├── value:
            │   @ ParenthesesNode (location: (3,9)-(3,26))
            │   ├── flags: ∅
            │   ├── body:
            │   │   @ StatementsNode (location: (3,10)-(3,25))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ MultiWriteNode (location: (3,10)-(3,25))
            │   │           ├── flags: newline
            │   │           ├── lefts: (length: 2)
            │   │           │   ├── @ LocalVariableTargetNode (location: (3,11)-(3,12))
            │   │           │   │   ├── flags: ∅
            │   │           │   │   ├── name: :a
            │   │           │   │   └── depth: 0
            │   │           │   └── @ LocalVariableTargetNode (location: (3,14)-(3,15))
            │   │           │       ├── flags: ∅
            │   │           │       ├── name: :b
            │   │           │       └── depth: 0
            │   │           ├── rest: ∅
            │   │           ├── rights: (length: 0)
            │   │           ├── lparen_loc: (3,10)-(3,11) = "("
            │   │           ├── rparen_loc: (3,15)-(3,16) = ")"
            │   │           ├── operator_loc: (3,17)-(3,18) = "="
            │   │           └── value:
            │   │               @ ArrayNode (location: (3,19)-(3,25))
            │   │               ├── flags: static_literal
            │   │               ├── elements: (length: 2)
            │   │               │   ├── @ IntegerNode (location: (3,20)-(3,21))
            │   │               │   │   ├── flags: static_literal, decimal
            │   │               │   │   └── value: 1
            │   │               │   └── @ IntegerNode (location: (3,23)-(3,24))
            │   │               │       ├── flags: static_literal, decimal
            │   │               │       └── value: 2
            │   │               ├── opening_loc: (3,19)-(3,20) = "["
            │   │               └── closing_loc: (3,24)-(3,25) = "]"
            │   ├── opening_loc: (3,9)-(3,10) = "("
            │   └── closing_loc: (3,25)-(3,26) = ")"
            ├── rparen_loc: (3,26)-(3,27) = ")"
            └── keyword_loc: (3,0)-(3,8) = "defined?"
prism-1.5.1/snapshots/unparser/corpus/literal/defs.txt000066400000000000000000000507551506127434000232000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(40,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(40,3))
    ├── flags: ∅
    └── body: (length: 10)
        ├── @ DefNode (location: (1,0)-(2,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (1,9)-(1,12) = "foo"
        │   ├── receiver:
        │   │   @ SelfNode (location: (1,4)-(1,8))
        │   │   └── flags: ∅
        │   ├── parameters: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: (1,8)-(1,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (2,0)-(2,3) = "end"
        ├── @ DefNode (location: (4,0)-(6,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (4,9)-(4,12) = "foo"
        │   ├── receiver:
        │   │   @ SelfNode (location: (4,4)-(4,8))
        │   │   └── flags: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (5,2)-(5,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (5,2)-(5,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (5,2)-(5,5) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (4,0)-(4,3) = "def"
        │   ├── operator_loc: (4,8)-(4,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (6,0)-(6,3) = "end"
        ├── @ DefNode (location: (8,0)-(11,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (8,9)-(8,12) = "foo"
        │   ├── receiver:
        │   │   @ SelfNode (location: (8,4)-(8,8))
        │   │   └── flags: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (9,2)-(10,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 2)
        │   │       ├── @ CallNode (location: (9,2)-(9,5))
        │   │       │   ├── flags: newline, variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :bar
        │   │       │   ├── message_loc: (9,2)-(9,5) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (10,2)-(10,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :baz
        │   │           ├── message_loc: (10,2)-(10,5) = "baz"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (8,0)-(8,3) = "def"
        │   ├── operator_loc: (8,8)-(8,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (11,0)-(11,3) = "end"
        ├── @ DefNode (location: (13,0)-(15,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (13,8)-(13,11) = "bar"
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (13,4)-(13,7))
        │   │   ├── flags: ∅
        │   │   └── name: :Foo
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (14,2)-(14,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (14,2)-(14,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (14,2)-(14,5) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (13,0)-(13,3) = "def"
        │   ├── operator_loc: (13,7)-(13,8) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (15,0)-(15,3) = "end"
        ├── @ DefNode (location: (17,0)-(20,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (18,3)-(18,6) = "bar"
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (17,4)-(18,2))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ CallNode (location: (17,5)-(18,1))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (17,5)-(17,8) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block:
        │   │   │       @ BlockNode (location: (17,9)-(18,1))
        │   │   │       ├── flags: ∅
        │   │   │       ├── locals: [:bar]
        │   │   │       ├── parameters:
        │   │   │       │   @ BlockParametersNode (location: (17,11)-(17,16))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   ├── parameters:
        │   │   │       │   │   @ ParametersNode (location: (17,12)-(17,15))
        │   │   │       │   │   ├── flags: ∅
        │   │   │       │   │   ├── requireds: (length: 1)
        │   │   │       │   │   │   └── @ RequiredParameterNode (location: (17,12)-(17,15))
        │   │   │       │   │   │       ├── flags: ∅
        │   │   │       │   │   │       └── name: :bar
        │   │   │       │   │   ├── optionals: (length: 0)
        │   │   │       │   │   ├── rest: ∅
        │   │   │       │   │   ├── posts: (length: 0)
        │   │   │       │   │   ├── keywords: (length: 0)
        │   │   │       │   │   ├── keyword_rest: ∅
        │   │   │       │   │   └── block: ∅
        │   │   │       │   ├── locals: (length: 0)
        │   │   │       │   ├── opening_loc: (17,11)-(17,12) = "|"
        │   │   │       │   └── closing_loc: (17,15)-(17,16) = "|"
        │   │   │       ├── body: ∅
        │   │   │       ├── opening_loc: (17,9)-(17,10) = "{"
        │   │   │       └── closing_loc: (18,0)-(18,1) = "}"
        │   │   ├── opening_loc: (17,4)-(17,5) = "("
        │   │   └── closing_loc: (18,1)-(18,2) = ")"
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (19,2)-(19,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (19,2)-(19,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (19,2)-(19,5) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (17,0)-(17,3) = "def"
        │   ├── operator_loc: (18,2)-(18,3) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (20,0)-(20,3) = "end"
        ├── @ DefNode (location: (22,0)-(24,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (22,13)-(22,16) = "bar"
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (22,4)-(22,12))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ CallNode (location: (22,5)-(22,11))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (22,5)-(22,8) = "foo"
        │   │   │   ├── opening_loc: (22,8)-(22,9) = "("
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (22,9)-(22,10))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (22,9)-(22,10))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   ├── closing_loc: (22,10)-(22,11) = ")"
        │   │   │   └── block: ∅
        │   │   ├── opening_loc: (22,4)-(22,5) = "("
        │   │   └── closing_loc: (22,11)-(22,12) = ")"
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (23,2)-(23,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (23,2)-(23,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (23,2)-(23,5) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (22,0)-(22,3) = "def"
        │   ├── operator_loc: (22,12)-(22,13) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (24,0)-(24,3) = "end"
        ├── @ DefNode (location: (26,0)-(28,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (26,19)-(26,22) = "bar"
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (26,4)-(26,18))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ CallNode (location: (26,5)-(26,17))
        │   │   │   ├── flags: ∅
        │   │   │   ├── receiver:
        │   │   │   │   @ ConstantPathNode (location: (26,5)-(26,13))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── parent:
        │   │   │   │   │   @ ConstantReadNode (location: (26,5)-(26,8))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   └── name: :Foo
        │   │   │   │   ├── name: :Bar
        │   │   │   │   ├── delimiter_loc: (26,8)-(26,10) = "::"
        │   │   │   │   └── name_loc: (26,10)-(26,13) = "Bar"
        │   │   │   ├── call_operator_loc: (26,13)-(26,14) = "."
        │   │   │   ├── name: :baz
        │   │   │   ├── message_loc: (26,14)-(26,17) = "baz"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── opening_loc: (26,4)-(26,5) = "("
        │   │   └── closing_loc: (26,17)-(26,18) = ")"
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (27,2)-(27,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (27,2)-(27,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :baz
        │   │           ├── message_loc: (27,2)-(27,5) = "baz"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (26,0)-(26,3) = "def"
        │   ├── operator_loc: (26,18)-(26,19) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (28,0)-(28,3) = "end"
        ├── @ DefNode (location: (30,0)-(32,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (30,15)-(30,18) = "bar"
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (30,4)-(30,14))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ ConstantPathNode (location: (30,5)-(30,13))
        │   │   │   ├── flags: ∅
        │   │   │   ├── parent:
        │   │   │   │   @ ConstantReadNode (location: (30,5)-(30,8))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :Foo
        │   │   │   ├── name: :Bar
        │   │   │   ├── delimiter_loc: (30,8)-(30,10) = "::"
        │   │   │   └── name_loc: (30,10)-(30,13) = "Bar"
        │   │   ├── opening_loc: (30,4)-(30,5) = "("
        │   │   └── closing_loc: (30,13)-(30,14) = ")"
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (31,2)-(31,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (31,2)-(31,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :baz
        │   │           ├── message_loc: (31,2)-(31,5) = "baz"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (30,0)-(30,3) = "def"
        │   ├── operator_loc: (30,14)-(30,15) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (32,0)-(32,3) = "end"
        ├── @ DefNode (location: (34,0)-(36,3))
        │   ├── flags: newline
        │   ├── name: :bar
        │   ├── name_loc: (34,8)-(34,11) = "bar"
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (34,4)-(34,7))
        │   │   ├── flags: ∅
        │   │   └── name: :Foo
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (35,2)-(35,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (35,2)-(35,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :baz
        │   │           ├── message_loc: (35,2)-(35,5) = "baz"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (34,0)-(34,3) = "def"
        │   ├── operator_loc: (34,7)-(34,8) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (36,0)-(36,3) = "end"
        └── @ DefNode (location: (38,0)-(40,3))
            ├── flags: newline
            ├── name: :bar
            ├── name_loc: (38,8)-(38,11) = "bar"
            ├── receiver:
            │   @ CallNode (location: (38,4)-(38,7))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (38,4)-(38,7) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (39,2)-(39,5))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (39,2)-(39,5))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :baz
            │           ├── message_loc: (39,2)-(39,5) = "baz"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── locals: []
            ├── def_keyword_loc: (38,0)-(38,3) = "def"
            ├── operator_loc: (38,7)-(38,8) = "."
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (40,0)-(40,3) = "end"
prism-1.5.1/snapshots/unparser/corpus/literal/dstr.txt000066400000000000000000000601451506127434000232250ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(37,1))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(37,1))
    ├── flags: ∅
    └── body: (length: 11)
        ├── @ IfNode (location: (1,0)-(3,3))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (1,0)-(1,2) = "if"
        │   ├── predicate:
        │   │   @ TrueNode (location: (1,3)-(1,7))
        │   │   └── flags: static_literal
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (2,2)-(2,8))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (2,2)-(2,8))
        │   │           ├── flags: newline
        │   │           ├── opening_loc: (2,2)-(2,3) = "\""
        │   │           ├── parts: (length: 2)
        │   │           │   ├── @ EmbeddedStatementsNode (location: (2,3)-(2,6))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── opening_loc: (2,3)-(2,5) = "\#{"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── closing_loc: (2,5)-(2,6) = "}"
        │   │           │   └── @ StringNode (location: (2,6)-(2,7))
        │   │           │       ├── flags: static_literal, frozen
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (2,6)-(2,7) = "a"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "a"
        │   │           └── closing_loc: (2,7)-(2,8) = "\""
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (3,0)-(3,3) = "end"
        ├── @ IfNode (location: (4,0)-(11,3))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (4,0)-(4,2) = "if"
        │   ├── predicate:
        │   │   @ TrueNode (location: (4,3)-(4,7))
        │   │   └── flags: static_literal
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (5,2)-(10,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 2)
        │   │       ├── @ InterpolatedStringNode (location: (5,2)-(5,12))
        │   │       │   ├── flags: newline
        │   │       │   ├── opening_loc: (5,2)-(5,12) = "<<-HEREDOC"
        │   │       │   ├── parts: (length: 3)
        │   │       │   │   ├── @ StringNode (location: (6,0)-(7,0))
        │   │       │   │   │   ├── flags: static_literal, frozen
        │   │       │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   ├── content_loc: (6,0)-(7,0) = "a\n"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "a\n"
        │   │       │   │   ├── @ EmbeddedStatementsNode (location: (7,0)-(7,3))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── opening_loc: (7,0)-(7,2) = "\#{"
        │   │       │   │   │   ├── statements: ∅
        │   │       │   │   │   └── closing_loc: (7,2)-(7,3) = "}"
        │   │       │   │   └── @ StringNode (location: (7,3)-(9,0))
        │   │       │   │       ├── flags: static_literal, frozen
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (7,3)-(9,0) = "a\nb\n"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "a\nb\n"
        │   │       │   └── closing_loc: (9,0)-(10,0) = "  HEREDOC\n"
        │   │       └── @ CallNode (location: (10,2)-(10,3))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :x
        │   │           ├── message_loc: (10,2)-(10,3) = "x"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (11,0)-(11,3) = "end"
        ├── @ InterpolatedStringNode (location: (12,0)-(12,10))
        │   ├── flags: newline
        │   ├── opening_loc: (12,0)-(12,10) = "<<-HEREDOC"
        │   ├── parts: (length: 7)
        │   │   ├── @ StringNode (location: (13,0)-(14,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (13,0)-(14,0) = "\\\#{}\\\#{}\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\#{}\#{}\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (14,0)-(14,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (14,0)-(14,2) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (14,2)-(14,3) = "}"
        │   │   ├── @ StringNode (location: (14,3)-(15,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (14,3)-(15,0) = "\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (15,0)-(15,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (15,0)-(15,2) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (15,2)-(15,3) = "}"
        │   │   ├── @ StringNode (location: (15,3)-(16,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (15,3)-(16,0) = "\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (16,0)-(16,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (16,0)-(16,2) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (16,2)-(16,3) = "}"
        │   │   └── @ StringNode (location: (16,3)-(17,0))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (16,3)-(17,0) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (17,0)-(18,0) = "HEREDOC\n"
        ├── @ RescueModifierNode (location: (18,0)-(18,21))
        │   ├── flags: newline
        │   ├── expression:
        │   │   @ InterpolatedStringNode (location: (18,0)-(18,10))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (18,0)-(18,10) = "<<-HEREDOC"
        │   │   ├── parts: (length: 2)
        │   │   │   ├── @ EmbeddedStatementsNode (location: (19,0)-(19,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── opening_loc: (19,0)-(19,2) = "\#{"
        │   │   │   │   ├── statements: ∅
        │   │   │   │   └── closing_loc: (19,2)-(19,3) = "}"
        │   │   │   └── @ StringNode (location: (19,3)-(21,0))
        │   │   │       ├── flags: static_literal, frozen
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (19,3)-(21,0) = "\na\n"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "\na\n"
        │   │   └── closing_loc: (21,0)-(22,0) = "HEREDOC\n"
        │   ├── keyword_loc: (18,11)-(18,17) = "rescue"
        │   └── rescue_expression:
        │       @ NilNode (location: (18,18)-(18,21))
        │       └── flags: static_literal
        ├── @ InterpolatedStringNode (location: (22,0)-(22,6))
        │   ├── flags: newline
        │   ├── opening_loc: (22,0)-(22,1) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (22,1)-(22,2))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (22,1)-(22,2) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   └── @ EmbeddedVariableNode (location: (22,2)-(22,5))
        │   │       ├── flags: ∅
        │   │       ├── operator_loc: (22,2)-(22,3) = "#"
        │   │       └── variable:
        │   │           @ NumberedReferenceReadNode (location: (22,3)-(22,5))
        │   │           ├── flags: ∅
        │   │           └── number: 1
        │   └── closing_loc: (22,5)-(22,6) = "\""
        ├── @ InterpolatedStringNode (location: (23,0)-(23,6))
        │   ├── flags: newline
        │   ├── opening_loc: (23,0)-(23,1) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (23,1)-(23,2))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (23,1)-(23,2) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   └── @ EmbeddedVariableNode (location: (23,2)-(23,5))
        │   │       ├── flags: ∅
        │   │       ├── operator_loc: (23,2)-(23,3) = "#"
        │   │       └── variable:
        │   │           @ GlobalVariableReadNode (location: (23,3)-(23,5))
        │   │           ├── flags: ∅
        │   │           └── name: :$a
        │   └── closing_loc: (23,5)-(23,6) = "\""
        ├── @ InterpolatedStringNode (location: (24,0)-(24,6))
        │   ├── flags: newline
        │   ├── opening_loc: (24,0)-(24,1) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (24,1)-(24,2))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (24,1)-(24,2) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   └── @ EmbeddedVariableNode (location: (24,2)-(24,5))
        │   │       ├── flags: ∅
        │   │       ├── operator_loc: (24,2)-(24,3) = "#"
        │   │       └── variable:
        │   │           @ InstanceVariableReadNode (location: (24,3)-(24,5))
        │   │           ├── flags: ∅
        │   │           └── name: :@a
        │   └── closing_loc: (24,5)-(24,6) = "\""
        ├── @ InterpolatedStringNode (location: (25,0)-(25,7))
        │   ├── flags: newline
        │   ├── opening_loc: (25,0)-(25,1) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (25,1)-(25,2))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (25,1)-(25,2) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   └── @ EmbeddedVariableNode (location: (25,2)-(25,6))
        │   │       ├── flags: ∅
        │   │       ├── operator_loc: (25,2)-(25,3) = "#"
        │   │       └── variable:
        │   │           @ ClassVariableReadNode (location: (25,3)-(25,6))
        │   │           ├── flags: ∅
        │   │           └── name: :@@a
        │   └── closing_loc: (25,6)-(25,7) = "\""
        ├── @ IfNode (location: (26,0)-(30,3))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (26,0)-(26,2) = "if"
        │   ├── predicate:
        │   │   @ TrueNode (location: (26,3)-(26,7))
        │   │   └── flags: static_literal
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (27,2)-(27,19))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ ReturnNode (location: (27,2)-(27,19))
        │   │           ├── flags: newline
        │   │           ├── keyword_loc: (27,2)-(27,8) = "return"
        │   │           └── arguments:
        │   │               @ ArgumentsNode (location: (27,9)-(27,19))
        │   │               ├── flags: ∅
        │   │               └── arguments: (length: 1)
        │   │                   └── @ InterpolatedStringNode (location: (27,9)-(27,19))
        │   │                       ├── flags: ∅
        │   │                       ├── opening_loc: (27,9)-(27,19) = "<<-HEREDOC"
        │   │                       ├── parts: (length: 3)
        │   │                       │   ├── @ StringNode (location: (28,0)-(28,4))
        │   │                       │   │   ├── flags: static_literal, frozen
        │   │                       │   │   ├── opening_loc: ∅
        │   │                       │   │   ├── content_loc: (28,0)-(28,4) = "    "
        │   │                       │   │   ├── closing_loc: ∅
        │   │                       │   │   └── unescaped: "    "
        │   │                       │   ├── @ EmbeddedStatementsNode (location: (28,4)-(28,9))
        │   │                       │   │   ├── flags: ∅
        │   │                       │   │   ├── opening_loc: (28,4)-(28,6) = "\#{"
        │   │                       │   │   ├── statements:
        │   │                       │   │   │   @ StatementsNode (location: (28,6)-(28,8))
        │   │                       │   │   │   ├── flags: ∅
        │   │                       │   │   │   └── body: (length: 1)
        │   │                       │   │   │       └── @ IntegerNode (location: (28,6)-(28,8))
        │   │                       │   │   │           ├── flags: static_literal, decimal
        │   │                       │   │   │           └── value: 42
        │   │                       │   │   └── closing_loc: (28,8)-(28,9) = "}"
        │   │                       │   └── @ StringNode (location: (28,9)-(29,0))
        │   │                       │       ├── flags: static_literal, frozen
        │   │                       │       ├── opening_loc: ∅
        │   │                       │       ├── content_loc: (28,9)-(29,0) = "\n"
        │   │                       │       ├── closing_loc: ∅
        │   │                       │       └── unescaped: "\n"
        │   │                       └── closing_loc: (29,0)-(30,0) = "  HEREDOC\n"
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (30,0)-(30,3) = "end"
        ├── @ CallNode (location: (31,0)-(31,15))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (31,0)-(31,3) = "foo"
        │   ├── opening_loc: (31,3)-(31,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (31,4)-(31,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (31,4)-(31,14))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (31,4)-(31,14) = "<<-HEREDOC"
        │   │           ├── parts: (length: 3)
        │   │           │   ├── @ StringNode (location: (32,0)-(32,2))
        │   │           │   │   ├── flags: static_literal, frozen
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (32,0)-(32,2) = "  "
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "  "
        │   │           │   ├── @ EmbeddedStatementsNode (location: (32,2)-(32,8))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── opening_loc: (32,2)-(32,4) = "\#{"
        │   │           │   │   ├── statements:
        │   │           │   │   │   @ StatementsNode (location: (32,4)-(32,7))
        │   │           │   │   │   ├── flags: ∅
        │   │           │   │   │   └── body: (length: 1)
        │   │           │   │   │       └── @ CallNode (location: (32,4)-(32,7))
        │   │           │   │   │           ├── flags: variable_call, ignore_visibility
        │   │           │   │   │           ├── receiver: ∅
        │   │           │   │   │           ├── call_operator_loc: ∅
        │   │           │   │   │           ├── name: :bar
        │   │           │   │   │           ├── message_loc: (32,4)-(32,7) = "bar"
        │   │           │   │   │           ├── opening_loc: ∅
        │   │           │   │   │           ├── arguments: ∅
        │   │           │   │   │           ├── closing_loc: ∅
        │   │           │   │   │           └── block: ∅
        │   │           │   │   └── closing_loc: (32,7)-(32,8) = "}"
        │   │           │   └── @ StringNode (location: (32,8)-(33,0))
        │   │           │       ├── flags: static_literal, frozen
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (32,8)-(33,0) = "\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "\n"
        │   │           └── closing_loc: (33,0)-(34,0) = "HEREDOC\n"
        │   ├── closing_loc: (31,14)-(31,15) = ")"
        │   └── block: ∅
        └── @ CallNode (location: (34,0)-(37,1))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :foo
            ├── message_loc: (34,0)-(34,3) = "foo"
            ├── opening_loc: (34,3)-(34,4) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (34,4)-(34,14))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ InterpolatedStringNode (location: (34,4)-(34,14))
            │           ├── flags: ∅
            │           ├── opening_loc: (34,4)-(34,14) = "<<-HEREDOC"
            │           ├── parts: (length: 3)
            │           │   ├── @ StringNode (location: (35,0)-(35,2))
            │           │   │   ├── flags: static_literal, frozen
            │           │   │   ├── opening_loc: ∅
            │           │   │   ├── content_loc: (35,0)-(35,2) = "  "
            │           │   │   ├── closing_loc: ∅
            │           │   │   └── unescaped: "  "
            │           │   ├── @ EmbeddedStatementsNode (location: (35,2)-(35,8))
            │           │   │   ├── flags: ∅
            │           │   │   ├── opening_loc: (35,2)-(35,4) = "\#{"
            │           │   │   ├── statements:
            │           │   │   │   @ StatementsNode (location: (35,4)-(35,7))
            │           │   │   │   ├── flags: ∅
            │           │   │   │   └── body: (length: 1)
            │           │   │   │       └── @ CallNode (location: (35,4)-(35,7))
            │           │   │   │           ├── flags: variable_call, ignore_visibility
            │           │   │   │           ├── receiver: ∅
            │           │   │   │           ├── call_operator_loc: ∅
            │           │   │   │           ├── name: :bar
            │           │   │   │           ├── message_loc: (35,4)-(35,7) = "bar"
            │           │   │   │           ├── opening_loc: ∅
            │           │   │   │           ├── arguments: ∅
            │           │   │   │           ├── closing_loc: ∅
            │           │   │   │           └── block: ∅
            │           │   │   └── closing_loc: (35,7)-(35,8) = "}"
            │           │   └── @ StringNode (location: (35,8)-(36,0))
            │           │       ├── flags: static_literal, frozen
            │           │       ├── opening_loc: ∅
            │           │       ├── content_loc: (35,8)-(36,0) = "\n"
            │           │       ├── closing_loc: ∅
            │           │       └── unescaped: "\n"
            │           └── closing_loc: (36,0)-(37,0) = "HEREDOC\n"
            ├── closing_loc: (34,14)-(34,15) = ")"
            └── block:
                @ BlockNode (location: (34,16)-(37,1))
                ├── flags: ∅
                ├── locals: [:x]
                ├── parameters:
                │   @ BlockParametersNode (location: (34,18)-(34,21))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (34,19)-(34,20))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (34,19)-(34,20))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :x
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (34,18)-(34,19) = "|"
                │   └── closing_loc: (34,20)-(34,21) = "|"
                ├── body: ∅
                ├── opening_loc: (34,16)-(34,17) = "{"
                └── closing_loc: (37,0)-(37,1) = "}"
prism-1.5.1/snapshots/unparser/corpus/literal/empty.txt000066400000000000000000000003141506127434000233770ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,0))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,0))
    ├── flags: ∅
    └── body: (length: 0)
prism-1.5.1/snapshots/unparser/corpus/literal/empty_begin.txt000066400000000000000000000006671506127434000245560ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,2))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,2))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ParenthesesNode (location: (1,0)-(1,2))
            ├── flags: newline
            ├── body: ∅
            ├── opening_loc: (1,0)-(1,1) = "("
            └── closing_loc: (1,1)-(1,2) = ")"
prism-1.5.1/snapshots/unparser/corpus/literal/flipflop.txt000066400000000000000000000427431506127434000240700ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(10,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(10,3))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ IfNode (location: (1,0)-(3,3))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (1,0)-(1,2) = "if"
        │   ├── predicate:
        │   │   @ ParenthesesNode (location: (1,3)-(1,23))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (1,4)-(1,22))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ FlipFlopNode (location: (1,4)-(1,22))
        │   │   │           ├── flags: newline
        │   │   │           ├── left:
        │   │   │           │   @ ParenthesesNode (location: (1,4)-(1,12))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   ├── body:
        │   │   │           │   │   @ StatementsNode (location: (1,5)-(1,11))
        │   │   │           │   │   ├── flags: ∅
        │   │   │           │   │   └── body: (length: 1)
        │   │   │           │   │       └── @ CallNode (location: (1,5)-(1,11))
        │   │   │           │   │           ├── flags: newline
        │   │   │           │   │           ├── receiver:
        │   │   │           │   │           │   @ CallNode (location: (1,5)-(1,6))
        │   │   │           │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   │           │   ├── receiver: ∅
        │   │   │           │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   │           │   ├── name: :i
        │   │   │           │   │           │   ├── message_loc: (1,5)-(1,6) = "i"
        │   │   │           │   │           │   ├── opening_loc: ∅
        │   │   │           │   │           │   ├── arguments: ∅
        │   │   │           │   │           │   ├── closing_loc: ∅
        │   │   │           │   │           │   └── block: ∅
        │   │   │           │   │           ├── call_operator_loc: ∅
        │   │   │           │   │           ├── name: :==
        │   │   │           │   │           ├── message_loc: (1,7)-(1,9) = "=="
        │   │   │           │   │           ├── opening_loc: ∅
        │   │   │           │   │           ├── arguments:
        │   │   │           │   │           │   @ ArgumentsNode (location: (1,10)-(1,11))
        │   │   │           │   │           │   ├── flags: ∅
        │   │   │           │   │           │   └── arguments: (length: 1)
        │   │   │           │   │           │       └── @ IntegerNode (location: (1,10)-(1,11))
        │   │   │           │   │           │           ├── flags: static_literal, decimal
        │   │   │           │   │           │           └── value: 4
        │   │   │           │   │           ├── closing_loc: ∅
        │   │   │           │   │           └── block: ∅
        │   │   │           │   ├── opening_loc: (1,4)-(1,5) = "("
        │   │   │           │   └── closing_loc: (1,11)-(1,12) = ")"
        │   │   │           ├── right:
        │   │   │           │   @ ParenthesesNode (location: (1,14)-(1,22))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   ├── body:
        │   │   │           │   │   @ StatementsNode (location: (1,15)-(1,21))
        │   │   │           │   │   ├── flags: ∅
        │   │   │           │   │   └── body: (length: 1)
        │   │   │           │   │       └── @ CallNode (location: (1,15)-(1,21))
        │   │   │           │   │           ├── flags: newline
        │   │   │           │   │           ├── receiver:
        │   │   │           │   │           │   @ CallNode (location: (1,15)-(1,16))
        │   │   │           │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   │           │   ├── receiver: ∅
        │   │   │           │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   │           │   ├── name: :i
        │   │   │           │   │           │   ├── message_loc: (1,15)-(1,16) = "i"
        │   │   │           │   │           │   ├── opening_loc: ∅
        │   │   │           │   │           │   ├── arguments: ∅
        │   │   │           │   │           │   ├── closing_loc: ∅
        │   │   │           │   │           │   └── block: ∅
        │   │   │           │   │           ├── call_operator_loc: ∅
        │   │   │           │   │           ├── name: :==
        │   │   │           │   │           ├── message_loc: (1,17)-(1,19) = "=="
        │   │   │           │   │           ├── opening_loc: ∅
        │   │   │           │   │           ├── arguments:
        │   │   │           │   │           │   @ ArgumentsNode (location: (1,20)-(1,21))
        │   │   │           │   │           │   ├── flags: ∅
        │   │   │           │   │           │   └── arguments: (length: 1)
        │   │   │           │   │           │       └── @ IntegerNode (location: (1,20)-(1,21))
        │   │   │           │   │           │           ├── flags: static_literal, decimal
        │   │   │           │   │           │           └── value: 4
        │   │   │           │   │           ├── closing_loc: ∅
        │   │   │           │   │           └── block: ∅
        │   │   │           │   ├── opening_loc: (1,14)-(1,15) = "("
        │   │   │           │   └── closing_loc: (1,21)-(1,22) = ")"
        │   │   │           └── operator_loc: (1,12)-(1,14) = ".."
        │   │   ├── opening_loc: (1,3)-(1,4) = "("
        │   │   └── closing_loc: (1,22)-(1,23) = ")"
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (2,2)-(2,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (2,2)-(2,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :foo
        │   │           ├── message_loc: (2,2)-(2,5) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (3,0)-(3,3) = "end"
        ├── @ IfNode (location: (4,0)-(6,3))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (4,0)-(4,2) = "if"
        │   ├── predicate:
        │   │   @ ParenthesesNode (location: (4,3)-(4,24))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (4,4)-(4,23))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ FlipFlopNode (location: (4,4)-(4,23))
        │   │   │           ├── flags: newline, exclude_end
        │   │   │           ├── left:
        │   │   │           │   @ ParenthesesNode (location: (4,4)-(4,12))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   ├── body:
        │   │   │           │   │   @ StatementsNode (location: (4,5)-(4,11))
        │   │   │           │   │   ├── flags: ∅
        │   │   │           │   │   └── body: (length: 1)
        │   │   │           │   │       └── @ CallNode (location: (4,5)-(4,11))
        │   │   │           │   │           ├── flags: newline
        │   │   │           │   │           ├── receiver:
        │   │   │           │   │           │   @ CallNode (location: (4,5)-(4,6))
        │   │   │           │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   │           │   ├── receiver: ∅
        │   │   │           │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   │           │   ├── name: :i
        │   │   │           │   │           │   ├── message_loc: (4,5)-(4,6) = "i"
        │   │   │           │   │           │   ├── opening_loc: ∅
        │   │   │           │   │           │   ├── arguments: ∅
        │   │   │           │   │           │   ├── closing_loc: ∅
        │   │   │           │   │           │   └── block: ∅
        │   │   │           │   │           ├── call_operator_loc: ∅
        │   │   │           │   │           ├── name: :==
        │   │   │           │   │           ├── message_loc: (4,7)-(4,9) = "=="
        │   │   │           │   │           ├── opening_loc: ∅
        │   │   │           │   │           ├── arguments:
        │   │   │           │   │           │   @ ArgumentsNode (location: (4,10)-(4,11))
        │   │   │           │   │           │   ├── flags: ∅
        │   │   │           │   │           │   └── arguments: (length: 1)
        │   │   │           │   │           │       └── @ IntegerNode (location: (4,10)-(4,11))
        │   │   │           │   │           │           ├── flags: static_literal, decimal
        │   │   │           │   │           │           └── value: 4
        │   │   │           │   │           ├── closing_loc: ∅
        │   │   │           │   │           └── block: ∅
        │   │   │           │   ├── opening_loc: (4,4)-(4,5) = "("
        │   │   │           │   └── closing_loc: (4,11)-(4,12) = ")"
        │   │   │           ├── right:
        │   │   │           │   @ ParenthesesNode (location: (4,15)-(4,23))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   ├── body:
        │   │   │           │   │   @ StatementsNode (location: (4,16)-(4,22))
        │   │   │           │   │   ├── flags: ∅
        │   │   │           │   │   └── body: (length: 1)
        │   │   │           │   │       └── @ CallNode (location: (4,16)-(4,22))
        │   │   │           │   │           ├── flags: newline
        │   │   │           │   │           ├── receiver:
        │   │   │           │   │           │   @ CallNode (location: (4,16)-(4,17))
        │   │   │           │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   │           │   ├── receiver: ∅
        │   │   │           │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   │           │   ├── name: :i
        │   │   │           │   │           │   ├── message_loc: (4,16)-(4,17) = "i"
        │   │   │           │   │           │   ├── opening_loc: ∅
        │   │   │           │   │           │   ├── arguments: ∅
        │   │   │           │   │           │   ├── closing_loc: ∅
        │   │   │           │   │           │   └── block: ∅
        │   │   │           │   │           ├── call_operator_loc: ∅
        │   │   │           │   │           ├── name: :==
        │   │   │           │   │           ├── message_loc: (4,18)-(4,20) = "=="
        │   │   │           │   │           ├── opening_loc: ∅
        │   │   │           │   │           ├── arguments:
        │   │   │           │   │           │   @ ArgumentsNode (location: (4,21)-(4,22))
        │   │   │           │   │           │   ├── flags: ∅
        │   │   │           │   │           │   └── arguments: (length: 1)
        │   │   │           │   │           │       └── @ IntegerNode (location: (4,21)-(4,22))
        │   │   │           │   │           │           ├── flags: static_literal, decimal
        │   │   │           │   │           │           └── value: 4
        │   │   │           │   │           ├── closing_loc: ∅
        │   │   │           │   │           └── block: ∅
        │   │   │           │   ├── opening_loc: (4,15)-(4,16) = "("
        │   │   │           │   └── closing_loc: (4,22)-(4,23) = ")"
        │   │   │           └── operator_loc: (4,12)-(4,15) = "..."
        │   │   ├── opening_loc: (4,3)-(4,4) = "("
        │   │   └── closing_loc: (4,23)-(4,24) = ")"
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (5,2)-(5,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (5,2)-(5,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :foo
        │   │           ├── message_loc: (5,2)-(5,5) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (6,0)-(6,3) = "end"
        ├── @ IfNode (location: (7,0)-(8,3))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (7,0)-(7,2) = "if"
        │   ├── predicate:
        │   │   @ FlipFlopNode (location: (7,3)-(7,8))
        │   │   ├── flags: ∅
        │   │   ├── left: ∅
        │   │   ├── right:
        │   │   │   @ CallNode (location: (7,5)-(7,8))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (7,5)-(7,8) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── operator_loc: (7,3)-(7,5) = ".."
        │   ├── then_keyword_loc: ∅
        │   ├── statements: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (8,0)-(8,3) = "end"
        └── @ IfNode (location: (9,0)-(10,3))
            ├── flags: newline
            ├── if_keyword_loc: (9,0)-(9,2) = "if"
            ├── predicate:
            │   @ FlipFlopNode (location: (9,3)-(9,8))
            │   ├── flags: ∅
            │   ├── left:
            │   │   @ CallNode (location: (9,3)-(9,6))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :foo
            │   │   ├── message_loc: (9,3)-(9,6) = "foo"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── right: ∅
            │   └── operator_loc: (9,6)-(9,8) = ".."
            ├── then_keyword_loc: ∅
            ├── statements: ∅
            ├── subsequent: ∅
            └── end_keyword_loc: (10,0)-(10,3) = "end"
prism-1.5.1/snapshots/unparser/corpus/literal/for.txt000066400000000000000000000241401506127434000230320ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(12,3))
├── flags: ∅
├── locals: [:a, :b]
└── statements:
    @ StatementsNode (location: (1,0)-(12,3))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ CallNode (location: (1,0)-(3,4))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :bar
        │   ├── message_loc: (1,0)-(1,3) = "bar"
        │   ├── opening_loc: (1,3)-(1,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,4)-(3,3))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ForNode (location: (1,4)-(3,3))
        │   │           ├── flags: ∅
        │   │           ├── index:
        │   │           │   @ LocalVariableTargetNode (location: (1,8)-(1,9))
        │   │           │   ├── flags: ∅
        │   │           │   ├── name: :a
        │   │           │   └── depth: 0
        │   │           ├── collection:
        │   │           │   @ CallNode (location: (1,13)-(1,16))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :bar
        │   │           │   ├── message_loc: (1,13)-(1,16) = "bar"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (2,2)-(2,5))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (2,2)-(2,5))
        │   │           │           ├── flags: newline, variable_call, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :baz
        │   │           │           ├── message_loc: (2,2)-(2,5) = "baz"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── for_keyword_loc: (1,4)-(1,7) = "for"
        │   │           ├── in_keyword_loc: (1,10)-(1,12) = "in"
        │   │           ├── do_keyword_loc: (1,17)-(1,19) = "do"
        │   │           └── end_keyword_loc: (3,0)-(3,3) = "end"
        │   ├── closing_loc: (3,3)-(3,4) = ")"
        │   └── block: ∅
        ├── @ ForNode (location: (4,0)-(6,3))
        │   ├── flags: newline
        │   ├── index:
        │   │   @ LocalVariableTargetNode (location: (4,4)-(4,5))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── collection:
        │   │   @ CallNode (location: (4,9)-(4,12))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (4,9)-(4,12) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (5,2)-(5,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (5,2)-(5,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :baz
        │   │           ├── message_loc: (5,2)-(5,5) = "baz"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── for_keyword_loc: (4,0)-(4,3) = "for"
        │   ├── in_keyword_loc: (4,6)-(4,8) = "in"
        │   ├── do_keyword_loc: (4,13)-(4,15) = "do"
        │   └── end_keyword_loc: (6,0)-(6,3) = "end"
        ├── @ ForNode (location: (7,0)-(9,3))
        │   ├── flags: newline
        │   ├── index:
        │   │   @ MultiTargetNode (location: (7,4)-(7,11))
        │   │   ├── flags: ∅
        │   │   ├── lefts: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (7,5)-(7,6))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       └── depth: 0
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (7,8)-(7,10))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (7,8)-(7,9) = "*"
        │   │   │   └── expression:
        │   │   │       @ LocalVariableTargetNode (location: (7,9)-(7,10))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :b
        │   │   │       └── depth: 0
        │   │   ├── rights: (length: 0)
        │   │   ├── lparen_loc: (7,4)-(7,5) = "("
        │   │   └── rparen_loc: (7,10)-(7,11) = ")"
        │   ├── collection:
        │   │   @ CallNode (location: (7,15)-(7,18))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (7,15)-(7,18) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (8,2)-(8,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (8,2)-(8,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :baz
        │   │           ├── message_loc: (8,2)-(8,5) = "baz"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── for_keyword_loc: (7,0)-(7,3) = "for"
        │   ├── in_keyword_loc: (7,12)-(7,14) = "in"
        │   ├── do_keyword_loc: (7,19)-(7,21) = "do"
        │   └── end_keyword_loc: (9,0)-(9,3) = "end"
        └── @ ForNode (location: (10,0)-(12,3))
            ├── flags: newline
            ├── index:
            │   @ MultiTargetNode (location: (10,4)-(10,10))
            │   ├── flags: ∅
            │   ├── lefts: (length: 2)
            │   │   ├── @ LocalVariableTargetNode (location: (10,5)-(10,6))
            │   │   │   ├── flags: ∅
            │   │   │   ├── name: :a
            │   │   │   └── depth: 0
            │   │   └── @ LocalVariableTargetNode (location: (10,8)-(10,9))
            │   │       ├── flags: ∅
            │   │       ├── name: :b
            │   │       └── depth: 0
            │   ├── rest: ∅
            │   ├── rights: (length: 0)
            │   ├── lparen_loc: (10,4)-(10,5) = "("
            │   └── rparen_loc: (10,9)-(10,10) = ")"
            ├── collection:
            │   @ CallNode (location: (10,14)-(10,17))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :bar
            │   ├── message_loc: (10,14)-(10,17) = "bar"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── statements:
            │   @ StatementsNode (location: (11,2)-(11,5))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (11,2)-(11,5))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :baz
            │           ├── message_loc: (11,2)-(11,5) = "baz"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── for_keyword_loc: (10,0)-(10,3) = "for"
            ├── in_keyword_loc: (10,11)-(10,13) = "in"
            ├── do_keyword_loc: (10,18)-(10,20) = "do"
            └── end_keyword_loc: (12,0)-(12,3) = "end"
prism-1.5.1/snapshots/unparser/corpus/literal/hookexe.txt000066400000000000000000000052621506127434000237120ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,1))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(7,1))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ PreExecutionNode (location: (1,0)-(3,1))
        │   ├── flags: newline
        │   ├── statements:
        │   │   @ StatementsNode (location: (2,2)-(2,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (2,2)-(2,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :foo
        │   │           ├── message_loc: (2,2)-(2,5) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── keyword_loc: (1,0)-(1,5) = "BEGIN"
        │   ├── opening_loc: (1,6)-(1,7) = "{"
        │   └── closing_loc: (3,0)-(3,1) = "}"
        ├── @ CallNode (location: (4,0)-(4,3))
        │   ├── flags: newline, variable_call, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :bar
        │   ├── message_loc: (4,0)-(4,3) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ PostExecutionNode (location: (5,0)-(7,1))
            ├── flags: newline
            ├── statements:
            │   @ StatementsNode (location: (6,2)-(6,5))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (6,2)-(6,5))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :baz
            │           ├── message_loc: (6,2)-(6,5) = "baz"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── keyword_loc: (5,0)-(5,3) = "END"
            ├── opening_loc: (5,4)-(5,5) = "{"
            └── closing_loc: (7,0)-(7,1) = "}"
prism-1.5.1/snapshots/unparser/corpus/literal/if.txt000066400000000000000000000444031506127434000226460ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(36,3))
├── flags: ∅
├── locals: [:foo, :pair]
└── statements:
    @ StatementsNode (location: (1,0)-(36,3))
    ├── flags: ∅
    └── body: (length: 10)
        ├── @ IfNode (location: (1,0)-(3,3))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (1,0)-(1,2) = "if"
        │   ├── predicate:
        │   │   @ MatchLastLineNode (location: (1,3)-(1,8))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (1,3)-(1,4) = "/"
        │   │   ├── content_loc: (1,4)-(1,7) = "foo"
        │   │   ├── closing_loc: (1,7)-(1,8) = "/"
        │   │   └── unescaped: "foo"
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (2,2)-(2,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (2,2)-(2,5))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (2,2)-(2,5) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (3,0)-(3,3) = "end"
        ├── @ IfNode (location: (4,0)-(6,3))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (4,0)-(4,2) = "if"
        │   ├── predicate:
        │   │   @ IntegerNode (location: (4,3)-(4,4))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 3
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (5,2)-(5,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (5,2)-(5,3))
        │   │           ├── flags: newline, static_literal, decimal
        │   │           └── value: 9
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (6,0)-(6,3) = "end"
        ├── @ IfNode (location: (7,0)-(11,3))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (7,0)-(7,2) = "if"
        │   ├── predicate:
        │   │   @ IntegerNode (location: (7,3)-(7,4))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 4
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (8,2)-(8,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (8,2)-(8,3))
        │   │           ├── flags: newline, static_literal, decimal
        │   │           └── value: 5
        │   ├── subsequent:
        │   │   @ ElseNode (location: (9,0)-(11,3))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (9,0)-(9,4) = "else"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (10,2)-(10,3))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ IntegerNode (location: (10,2)-(10,3))
        │   │   │           ├── flags: newline, static_literal, decimal
        │   │   │           └── value: 6
        │   │   └── end_keyword_loc: (11,0)-(11,3) = "end"
        │   └── end_keyword_loc: (11,0)-(11,3) = "end"
        ├── @ UnlessNode (location: (12,0)-(14,3))
        │   ├── flags: newline
        │   ├── keyword_loc: (12,0)-(12,6) = "unless"
        │   ├── predicate:
        │   │   @ IntegerNode (location: (12,7)-(12,8))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 3
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (13,2)-(13,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ NilNode (location: (13,2)-(13,5))
        │   │           └── flags: newline, static_literal
        │   ├── else_clause: ∅
        │   └── end_keyword_loc: (14,0)-(14,3) = "end"
        ├── @ UnlessNode (location: (15,0)-(17,3))
        │   ├── flags: newline
        │   ├── keyword_loc: (15,0)-(15,6) = "unless"
        │   ├── predicate:
        │   │   @ IntegerNode (location: (15,7)-(15,8))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 3
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (16,2)-(16,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (16,2)-(16,3))
        │   │           ├── flags: newline, static_literal, decimal
        │   │           └── value: 9
        │   ├── else_clause: ∅
        │   └── end_keyword_loc: (17,0)-(17,3) = "end"
        ├── @ IfNode (location: (18,0)-(19,3))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (18,0)-(18,2) = "if"
        │   ├── predicate:
        │   │   @ CallNode (location: (18,3)-(18,6))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (18,3)-(18,6) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: ∅
        │   ├── statements: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (19,0)-(19,3) = "end"
        ├── @ ModuleNode (location: (21,0)-(23,3))
        │   ├── flags: newline
        │   ├── locals: [:foo]
        │   ├── module_keyword_loc: (21,0)-(21,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (21,7)-(21,8))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (22,2)-(22,18))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IfNode (location: (22,2)-(22,18))
        │   │           ├── flags: newline
        │   │           ├── if_keyword_loc: (22,12)-(22,14) = "if"
        │   │           ├── predicate:
        │   │           │   @ LocalVariableReadNode (location: (22,15)-(22,18))
        │   │           │   ├── flags: ∅
        │   │           │   ├── name: :foo
        │   │           │   └── depth: 0
        │   │           ├── then_keyword_loc: ∅
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (22,2)-(22,11))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ LocalVariableWriteNode (location: (22,2)-(22,11))
        │   │           │           ├── flags: newline
        │   │           │           ├── name: :foo
        │   │           │           ├── depth: 0
        │   │           │           ├── name_loc: (22,2)-(22,5) = "foo"
        │   │           │           ├── value:
        │   │           │           │   @ CallNode (location: (22,8)-(22,11))
        │   │           │           │   ├── flags: variable_call, ignore_visibility
        │   │           │           │   ├── receiver: ∅
        │   │           │           │   ├── call_operator_loc: ∅
        │   │           │           │   ├── name: :bar
        │   │           │           │   ├── message_loc: (22,8)-(22,11) = "bar"
        │   │           │           │   ├── opening_loc: ∅
        │   │           │           │   ├── arguments: ∅
        │   │           │           │   ├── closing_loc: ∅
        │   │           │           │   └── block: ∅
        │   │           │           └── operator_loc: (22,6)-(22,7) = "="
        │   │           ├── subsequent: ∅
        │   │           └── end_keyword_loc: ∅
        │   ├── end_keyword_loc: (23,0)-(23,3) = "end"
        │   └── name: :A
        ├── @ ModuleNode (location: (25,0)-(27,3))
        │   ├── flags: newline
        │   ├── locals: [:foo]
        │   ├── module_keyword_loc: (25,0)-(25,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (25,7)-(25,8))
        │   │   ├── flags: ∅
        │   │   └── name: :B
        │   ├── body:
        │   │   @ StatementsNode (location: (26,2)-(26,22))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ UnlessNode (location: (26,2)-(26,22))
        │   │           ├── flags: newline
        │   │           ├── keyword_loc: (26,12)-(26,18) = "unless"
        │   │           ├── predicate:
        │   │           │   @ LocalVariableReadNode (location: (26,19)-(26,22))
        │   │           │   ├── flags: ∅
        │   │           │   ├── name: :foo
        │   │           │   └── depth: 0
        │   │           ├── then_keyword_loc: ∅
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (26,2)-(26,11))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ LocalVariableWriteNode (location: (26,2)-(26,11))
        │   │           │           ├── flags: newline
        │   │           │           ├── name: :foo
        │   │           │           ├── depth: 0
        │   │           │           ├── name_loc: (26,2)-(26,5) = "foo"
        │   │           │           ├── value:
        │   │           │           │   @ CallNode (location: (26,8)-(26,11))
        │   │           │           │   ├── flags: variable_call, ignore_visibility
        │   │           │           │   ├── receiver: ∅
        │   │           │           │   ├── call_operator_loc: ∅
        │   │           │           │   ├── name: :bar
        │   │           │           │   ├── message_loc: (26,8)-(26,11) = "bar"
        │   │           │           │   ├── opening_loc: ∅
        │   │           │           │   ├── arguments: ∅
        │   │           │           │   ├── closing_loc: ∅
        │   │           │           │   └── block: ∅
        │   │           │           └── operator_loc: (26,6)-(26,7) = "="
        │   │           ├── else_clause: ∅
        │   │           └── end_keyword_loc: ∅
        │   ├── end_keyword_loc: (27,0)-(27,3) = "end"
        │   └── name: :B
        ├── @ UnlessNode (location: (28,0)-(30,3))
        │   ├── flags: newline
        │   ├── keyword_loc: (28,0)-(28,6) = "unless"
        │   ├── predicate:
        │   │   @ CallNode (location: (28,7)-(28,10))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (28,7)-(28,10) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (29,2)-(29,11))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableWriteNode (location: (29,2)-(29,11))
        │   │           ├── flags: newline
        │   │           ├── name: :foo
        │   │           ├── depth: 0
        │   │           ├── name_loc: (29,2)-(29,5) = "foo"
        │   │           ├── value:
        │   │           │   @ CallNode (location: (29,8)-(29,11))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :bar
        │   │           │   ├── message_loc: (29,8)-(29,11) = "bar"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           └── operator_loc: (29,6)-(29,7) = "="
        │   ├── else_clause: ∅
        │   └── end_keyword_loc: (30,0)-(30,3) = "end"
        └── @ IfNode (location: (31,0)-(36,3))
            ├── flags: newline
            ├── if_keyword_loc: (31,0)-(31,2) = "if"
            ├── predicate:
            │   @ CallNode (location: (31,3)-(33,1))
            │   ├── flags: ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (31,3)-(31,6) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block:
            │       @ BlockNode (location: (31,7)-(33,1))
            │       ├── flags: ∅
            │       ├── locals: [:pair]
            │       ├── parameters:
            │       │   @ BlockParametersNode (location: (31,9)-(31,15))
            │       │   ├── flags: ∅
            │       │   ├── parameters:
            │       │   │   @ ParametersNode (location: (31,10)-(31,14))
            │       │   │   ├── flags: ∅
            │       │   │   ├── requireds: (length: 1)
            │       │   │   │   └── @ RequiredParameterNode (location: (31,10)-(31,14))
            │       │   │   │       ├── flags: ∅
            │       │   │   │       └── name: :pair
            │       │   │   ├── optionals: (length: 0)
            │       │   │   ├── rest: ∅
            │       │   │   ├── posts: (length: 0)
            │       │   │   ├── keywords: (length: 0)
            │       │   │   ├── keyword_rest: ∅
            │       │   │   └── block: ∅
            │       │   ├── locals: (length: 0)
            │       │   ├── opening_loc: (31,9)-(31,10) = "|"
            │       │   └── closing_loc: (31,14)-(31,15) = "|"
            │       ├── body:
            │       │   @ StatementsNode (location: (32,2)-(32,6))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ LocalVariableReadNode (location: (32,2)-(32,6))
            │       │           ├── flags: newline
            │       │           ├── name: :pair
            │       │           └── depth: 0
            │       ├── opening_loc: (31,7)-(31,8) = "{"
            │       └── closing_loc: (33,0)-(33,1) = "}"
            ├── then_keyword_loc: ∅
            ├── statements:
            │   @ StatementsNode (location: (34,2)-(35,5))
            │   ├── flags: ∅
            │   └── body: (length: 2)
            │       ├── @ LocalVariableWriteNode (location: (34,2)-(34,13))
            │       │   ├── flags: newline
            │       │   ├── name: :pair
            │       │   ├── depth: 0
            │       │   ├── name_loc: (34,2)-(34,6) = "pair"
            │       │   ├── value:
            │       │   │   @ SymbolNode (location: (34,9)-(34,13))
            │       │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │   ├── opening_loc: (34,9)-(34,10) = ":"
            │       │   │   ├── value_loc: (34,10)-(34,13) = "foo"
            │       │   │   ├── closing_loc: ∅
            │       │   │   └── unescaped: "foo"
            │       │   └── operator_loc: (34,7)-(34,8) = "="
            │       └── @ LocalVariableReadNode (location: (35,2)-(35,5))
            │           ├── flags: newline
            │           ├── name: :foo
            │           └── depth: 0
            ├── subsequent: ∅
            └── end_keyword_loc: (36,0)-(36,3) = "end"
prism-1.5.1/snapshots/unparser/corpus/literal/kwbegin.txt000066400000000000000000001013051506127434000236710ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(80,3))
├── flags: ∅
├── locals: [:foo, :bar, :exception]
└── statements:
    @ StatementsNode (location: (1,0)-(80,3))
    ├── flags: ∅
    └── body: (length: 14)
        ├── @ BeginNode (location: (1,0)-(3,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
        │   ├── statements: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (2,0)-(2,6))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (2,0)-(2,6) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (3,0)-(3,3) = "end"
        ├── @ BeginNode (location: (5,0)-(7,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (5,0)-(5,5) = "begin"
        │   ├── statements: ∅
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause:
        │   │   @ EnsureNode (location: (6,0)-(7,3))
        │   │   ├── flags: ∅
        │   │   ├── ensure_keyword_loc: (6,0)-(6,6) = "ensure"
        │   │   ├── statements: ∅
        │   │   └── end_keyword_loc: (7,0)-(7,3) = "end"
        │   └── end_keyword_loc: (7,0)-(7,3) = "end"
        ├── @ BeginNode (location: (9,0)-(11,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (9,0)-(9,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (10,2)-(10,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (10,2)-(10,3))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (10,2)-(10,3) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (11,0)-(11,3) = "end"
        ├── @ BeginNode (location: (13,0)-(17,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (13,0)-(13,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (14,2)-(14,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (14,2)-(14,3))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (14,2)-(14,3) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (15,0)-(16,3))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (15,0)-(15,6) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (16,2)-(16,3))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (16,2)-(16,3))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (16,2)-(16,3) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (17,0)-(17,3) = "end"
        ├── @ BeginNode (location: (19,0)-(24,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (19,0)-(19,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (20,2)-(21,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 2)
        │   │       ├── @ CallNode (location: (20,2)-(20,3))
        │   │       │   ├── flags: newline, variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :a
        │   │       │   ├── message_loc: (20,2)-(20,3) = "a"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (21,2)-(21,3))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (21,2)-(21,3) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (22,0)-(23,3))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (22,0)-(22,6) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (23,2)-(23,3))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (23,2)-(23,3))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (23,2)-(23,3) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (24,0)-(24,3) = "end"
        ├── @ BeginNode (location: (26,0)-(28,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (26,0)-(26,5) = "begin"
        │   ├── statements: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (27,0)-(27,8))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (27,0)-(27,6) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ ConstantReadNode (location: (27,7)-(27,8))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :A
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (28,0)-(28,3) = "end"
        ├── @ BeginNode (location: (30,0)-(32,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (30,0)-(30,5) = "begin"
        │   ├── statements: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (31,0)-(31,15))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (31,0)-(31,6) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ ConstantReadNode (location: (31,7)-(31,8))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :A
        │   │   ├── operator_loc: (31,9)-(31,11) = "=>"
        │   │   ├── reference:
        │   │   │   @ LocalVariableTargetNode (location: (31,12)-(31,15))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :foo
        │   │   │   └── depth: 0
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (32,0)-(32,3) = "end"
        ├── @ BeginNode (location: (34,0)-(42,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (34,0)-(34,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (35,2)-(35,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (35,2)-(35,3))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (35,2)-(35,3) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (36,0)-(39,3))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (36,0)-(36,6) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ ConstantReadNode (location: (36,7)-(36,8))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :A
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (37,2)-(37,3))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (37,2)-(37,3))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (37,2)-(37,3) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent:
        │   │       @ RescueNode (location: (38,0)-(39,3))
        │   │       ├── flags: ∅
        │   │       ├── keyword_loc: (38,0)-(38,6) = "rescue"
        │   │       ├── exceptions: (length: 1)
        │   │       │   └── @ ConstantReadNode (location: (38,7)-(38,8))
        │   │       │       ├── flags: ∅
        │   │       │       └── name: :B
        │   │       ├── operator_loc: ∅
        │   │       ├── reference: ∅
        │   │       ├── then_keyword_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (39,2)-(39,3))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (39,2)-(39,3))
        │   │       │           ├── flags: newline, variable_call, ignore_visibility
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :c
        │   │       │           ├── message_loc: (39,2)-(39,3) = "c"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments: ∅
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause:
        │   │   @ EnsureNode (location: (40,0)-(42,3))
        │   │   ├── flags: ∅
        │   │   ├── ensure_keyword_loc: (40,0)-(40,6) = "ensure"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (41,2)-(41,3))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (41,2)-(41,3))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :d
        │   │   │           ├── message_loc: (41,2)-(41,3) = "d"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── end_keyword_loc: (42,0)-(42,3) = "end"
        │   └── end_keyword_loc: (42,0)-(42,3) = "end"
        ├── @ BeginNode (location: (44,0)-(53,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (44,0)-(44,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (45,2)-(49,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ BeginNode (location: (45,2)-(49,5))
        │   │           ├── flags: newline
        │   │           ├── begin_keyword_loc: (45,2)-(45,7) = "begin"
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (46,4)-(47,7))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 2)
        │   │           │       ├── @ LocalVariableReadNode (location: (46,4)-(46,7))
        │   │           │       │   ├── flags: newline
        │   │           │       │   ├── name: :foo
        │   │           │       │   └── depth: 0
        │   │           │       └── @ CallNode (location: (47,4)-(47,7))
        │   │           │           ├── flags: newline, variable_call, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :bar
        │   │           │           ├── message_loc: (47,4)-(47,7) = "bar"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── rescue_clause:
        │   │           │   @ RescueNode (location: (48,2)-(48,8))
        │   │           │   ├── flags: ∅
        │   │           │   ├── keyword_loc: (48,2)-(48,8) = "rescue"
        │   │           │   ├── exceptions: (length: 0)
        │   │           │   ├── operator_loc: ∅
        │   │           │   ├── reference: ∅
        │   │           │   ├── then_keyword_loc: ∅
        │   │           │   ├── statements: ∅
        │   │           │   └── subsequent: ∅
        │   │           ├── else_clause: ∅
        │   │           ├── ensure_clause: ∅
        │   │           └── end_keyword_loc: (49,2)-(49,5) = "end"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (50,0)-(52,5))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (50,0)-(50,6) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (51,2)-(52,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 2)
        │   │   │       ├── @ CallNode (location: (51,2)-(51,5))
        │   │   │       │   ├── flags: newline, variable_call, ignore_visibility
        │   │   │       │   ├── receiver: ∅
        │   │   │       │   ├── call_operator_loc: ∅
        │   │   │       │   ├── name: :baz
        │   │   │       │   ├── message_loc: (51,2)-(51,5) = "baz"
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── arguments: ∅
        │   │   │       │   ├── closing_loc: ∅
        │   │   │       │   └── block: ∅
        │   │   │       └── @ CallNode (location: (52,2)-(52,5))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :bar
        │   │   │           ├── message_loc: (52,2)-(52,5) = "bar"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (53,0)-(53,3) = "end"
        ├── @ BeginNode (location: (55,0)-(58,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (55,0)-(55,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (56,2)-(56,35))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ RescueModifierNode (location: (56,2)-(56,35))
        │   │           ├── flags: newline
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (56,2)-(56,18))
        │   │           │   ├── flags: ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :raise
        │   │           │   ├── message_loc: (56,2)-(56,7) = "raise"
        │   │           │   ├── opening_loc: (56,7)-(56,8) = "("
        │   │           │   ├── arguments:
        │   │           │   │   @ ArgumentsNode (location: (56,8)-(56,17))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   └── arguments: (length: 1)
        │   │           │   │       └── @ ConstantReadNode (location: (56,8)-(56,17))
        │   │           │   │           ├── flags: ∅
        │   │           │   │           └── name: :Exception
        │   │           │   ├── closing_loc: (56,17)-(56,18) = ")"
        │   │           │   └── block: ∅
        │   │           ├── keyword_loc: (56,19)-(56,25) = "rescue"
        │   │           └── rescue_expression:
        │   │               @ LocalVariableWriteNode (location: (56,26)-(56,35))
        │   │               ├── flags: ∅
        │   │               ├── name: :foo
        │   │               ├── depth: 0
        │   │               ├── name_loc: (56,26)-(56,29) = "foo"
        │   │               ├── value:
        │   │               │   @ CallNode (location: (56,32)-(56,35))
        │   │               │   ├── flags: variable_call, ignore_visibility
        │   │               │   ├── receiver: ∅
        │   │               │   ├── call_operator_loc: ∅
        │   │               │   ├── name: :bar
        │   │               │   ├── message_loc: (56,32)-(56,35) = "bar"
        │   │               │   ├── opening_loc: ∅
        │   │               │   ├── arguments: ∅
        │   │               │   ├── closing_loc: ∅
        │   │               │   └── block: ∅
        │   │               └── operator_loc: (56,30)-(56,31) = "="
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (57,0)-(57,16))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (57,0)-(57,6) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ ConstantReadNode (location: (57,7)-(57,16))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :Exception
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (58,0)-(58,3) = "end"
        ├── @ BeginNode (location: (60,0)-(64,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (60,0)-(60,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (61,2)-(61,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (61,2)-(61,5))
        │   │           ├── flags: newline
        │   │           ├── name: :foo
        │   │           └── depth: 0
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (62,0)-(63,5))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (62,0)-(62,6) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: (62,7)-(62,9) = "=>"
        │   │   ├── reference:
        │   │   │   @ LocalVariableTargetNode (location: (62,10)-(62,13))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (63,2)-(63,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ LocalVariableReadNode (location: (63,2)-(63,5))
        │   │   │           ├── flags: newline
        │   │   │           ├── name: :bar
        │   │   │           └── depth: 0
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (64,0)-(64,3) = "end"
        ├── @ BeginNode (location: (66,0)-(70,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (66,0)-(66,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (67,2)-(67,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (67,2)-(67,5))
        │   │           ├── flags: newline
        │   │           ├── name: :foo
        │   │           └── depth: 0
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (68,0)-(69,5))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (68,0)-(68,6) = "rescue"
        │   │   ├── exceptions: (length: 2)
        │   │   │   ├── @ ConstantReadNode (location: (68,7)-(68,16))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :Exception
        │   │   │   └── @ ConstantReadNode (location: (68,18)-(68,23))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :Other
        │   │   ├── operator_loc: (68,24)-(68,26) = "=>"
        │   │   ├── reference:
        │   │   │   @ LocalVariableTargetNode (location: (68,27)-(68,30))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (69,2)-(69,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ LocalVariableReadNode (location: (69,2)-(69,5))
        │   │   │           ├── flags: newline
        │   │   │           ├── name: :bar
        │   │   │           └── depth: 0
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (70,0)-(70,3) = "end"
        ├── @ BeginNode (location: (72,0)-(76,3))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (72,0)-(72,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (73,2)-(73,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (73,2)-(73,5))
        │   │           ├── flags: newline
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (74,0)-(75,5))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (74,0)-(74,6) = "rescue"
        │   │   ├── exceptions: (length: 2)
        │   │   │   ├── @ ConstantReadNode (location: (74,7)-(74,16))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :SomeError
        │   │   │   └── @ SplatNode (location: (74,18)-(74,22))
        │   │   │       ├── flags: ∅
        │   │   │       ├── operator_loc: (74,18)-(74,19) = "*"
        │   │   │       └── expression:
        │   │   │           @ LocalVariableReadNode (location: (74,19)-(74,22))
        │   │   │           ├── flags: ∅
        │   │   │           ├── name: :bar
        │   │   │           └── depth: 0
        │   │   ├── operator_loc: (74,23)-(74,25) = "=>"
        │   │   ├── reference:
        │   │   │   @ LocalVariableTargetNode (location: (74,26)-(74,35))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :exception
        │   │   │   └── depth: 0
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (75,2)-(75,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (75,2)-(75,5))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :baz
        │   │   │           ├── message_loc: (75,2)-(75,5) = "baz"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (76,0)-(76,3) = "end"
        └── @ SingletonClassNode (location: (78,0)-(80,3))
            ├── flags: newline
            ├── locals: []
            ├── class_keyword_loc: (78,0)-(78,5) = "class"
            ├── operator_loc: (78,6)-(78,8) = "<<"
            ├── expression:
            │   @ SelfNode (location: (78,9)-(78,13))
            │   └── flags: ∅
            ├── body:
            │   @ StatementsNode (location: (79,2)-(79,23))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ RescueModifierNode (location: (79,2)-(79,23))
            │           ├── flags: newline
            │           ├── expression:
            │           │   @ UndefNode (location: (79,2)-(79,12))
            │           │   ├── flags: ∅
            │           │   ├── names: (length: 1)
            │           │   │   └── @ SymbolNode (location: (79,8)-(79,12))
            │           │   │       ├── flags: static_literal, forced_us_ascii_encoding
            │           │   │       ├── opening_loc: (79,8)-(79,9) = ":"
            │           │   │       ├── value_loc: (79,9)-(79,12) = "bar"
            │           │   │       ├── closing_loc: ∅
            │           │   │       └── unescaped: "bar"
            │           │   └── keyword_loc: (79,2)-(79,7) = "undef"
            │           ├── keyword_loc: (79,13)-(79,19) = "rescue"
            │           └── rescue_expression:
            │               @ NilNode (location: (79,20)-(79,23))
            │               └── flags: static_literal
            └── end_keyword_loc: (80,0)-(80,3) = "end"
prism-1.5.1/snapshots/unparser/corpus/literal/lambda.txt000066400000000000000000000213261506127434000234670ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(13,1))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(13,1))
    ├── flags: ∅
    └── body: (length: 6)
        ├── @ CallNode (location: (1,0)-(2,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :lambda
        │   ├── message_loc: (1,0)-(1,6) = "lambda"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,7)-(2,1))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (1,7)-(1,8) = "{"
        │       └── closing_loc: (2,0)-(2,1) = "}"
        ├── @ CallNode (location: (3,0)-(5,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :lambda
        │   ├── message_loc: (3,0)-(3,6) = "lambda"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (3,7)-(5,1))
        │       ├── flags: ∅
        │       ├── locals: [:a, :b]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (3,9)-(3,15))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (3,10)-(3,14))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 2)
        │       │   │   │   ├── @ RequiredParameterNode (location: (3,10)-(3,11))
        │       │   │   │   │   ├── flags: ∅
        │       │   │   │   │   └── name: :a
        │       │   │   │   └── @ RequiredParameterNode (location: (3,13)-(3,14))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :b
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (3,9)-(3,10) = "|"
        │       │   └── closing_loc: (3,14)-(3,15) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (4,2)-(4,3))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ LocalVariableReadNode (location: (4,2)-(4,3))
        │       │           ├── flags: newline
        │       │           ├── name: :a
        │       │           └── depth: 0
        │       ├── opening_loc: (3,7)-(3,8) = "{"
        │       └── closing_loc: (5,0)-(5,1) = "}"
        ├── @ LambdaNode (location: (6,0)-(7,1))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── operator_loc: (6,0)-(6,2) = "->"
        │   ├── opening_loc: (6,5)-(6,6) = "{"
        │   ├── closing_loc: (7,0)-(7,1) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (6,2)-(6,4))
        │   │   ├── flags: ∅
        │   │   ├── parameters: ∅
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: (6,2)-(6,3) = "("
        │   │   └── closing_loc: (6,3)-(6,4) = ")"
        │   └── body: ∅
        ├── @ LambdaNode (location: (8,0)-(9,1))
        │   ├── flags: newline
        │   ├── locals: [:a]
        │   ├── operator_loc: (8,0)-(8,2) = "->"
        │   ├── opening_loc: (8,6)-(8,7) = "{"
        │   ├── closing_loc: (9,0)-(9,1) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (8,2)-(8,5))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (8,3)-(8,4))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 1)
        │   │   │   │   └── @ RequiredParameterNode (location: (8,3)-(8,4))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       └── name: :a
        │   │   │   ├── optionals: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 0)
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: (8,2)-(8,3) = "("
        │   │   └── closing_loc: (8,4)-(8,5) = ")"
        │   └── body: ∅
        ├── @ LambdaNode (location: (10,0)-(11,1))
        │   ├── flags: newline
        │   ├── locals: [:a, :b]
        │   ├── operator_loc: (10,0)-(10,2) = "->"
        │   ├── opening_loc: (10,9)-(10,10) = "{"
        │   ├── closing_loc: (11,0)-(11,1) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (10,2)-(10,8))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (10,3)-(10,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 2)
        │   │   │   │   ├── @ RequiredParameterNode (location: (10,3)-(10,4))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   └── name: :a
        │   │   │   │   └── @ RequiredParameterNode (location: (10,6)-(10,7))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       └── name: :b
        │   │   │   ├── optionals: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 0)
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: (10,2)-(10,3) = "("
        │   │   └── closing_loc: (10,7)-(10,8) = ")"
        │   └── body: ∅
        └── @ LambdaNode (location: (12,0)-(13,1))
            ├── flags: newline
            ├── locals: [:a, :b, :c]
            ├── operator_loc: (12,0)-(12,2) = "->"
            ├── opening_loc: (12,12)-(12,13) = "{"
            ├── closing_loc: (13,0)-(13,1) = "}"
            ├── parameters:
            │   @ BlockParametersNode (location: (12,2)-(12,11))
            │   ├── flags: ∅
            │   ├── parameters:
            │   │   @ ParametersNode (location: (12,3)-(12,7))
            │   │   ├── flags: ∅
            │   │   ├── requireds: (length: 2)
            │   │   │   ├── @ RequiredParameterNode (location: (12,3)-(12,4))
            │   │   │   │   ├── flags: ∅
            │   │   │   │   └── name: :a
            │   │   │   └── @ RequiredParameterNode (location: (12,6)-(12,7))
            │   │   │       ├── flags: ∅
            │   │   │       └── name: :b
            │   │   ├── optionals: (length: 0)
            │   │   ├── rest: ∅
            │   │   ├── posts: (length: 0)
            │   │   ├── keywords: (length: 0)
            │   │   ├── keyword_rest: ∅
            │   │   └── block: ∅
            │   ├── locals: (length: 1)
            │   │   └── @ BlockLocalVariableNode (location: (12,9)-(12,10))
            │   │       ├── flags: ∅
            │   │       └── name: :c
            │   ├── opening_loc: (12,2)-(12,3) = "("
            │   └── closing_loc: (12,10)-(12,11) = ")"
            └── body: ∅
prism-1.5.1/snapshots/unparser/corpus/literal/literal.txt000066400000000000000000002325521506127434000237100ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(91,2))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(91,2))
    ├── flags: ∅
    └── body: (length: 78)
        ├── @ HashNode (location: (1,0)-(1,38))
        │   ├── flags: newline
        │   ├── opening_loc: (1,0)-(1,1) = "{"
        │   ├── elements: (length: 2)
        │   │   ├── @ AssocNode (location: (1,2)-(1,21))
        │   │   │   ├── flags: ∅
        │   │   │   ├── key:
        │   │   │   │   @ StringNode (location: (1,2)-(1,7))
        │   │   │   │   ├── flags: static_literal, frozen
        │   │   │   │   ├── opening_loc: (1,2)-(1,3) = "\""
        │   │   │   │   ├── content_loc: (1,3)-(1,6) = "foo"
        │   │   │   │   ├── closing_loc: (1,6)-(1,7) = "\""
        │   │   │   │   └── unescaped: "foo"
        │   │   │   ├── value:
        │   │   │   │   @ InterpolatedStringNode (location: (1,11)-(1,21))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── opening_loc: (1,11)-(1,21) = "<<-HEREDOC"
        │   │   │   │   ├── parts: (length: 3)
        │   │   │   │   │   ├── @ StringNode (location: (2,0)-(2,2))
        │   │   │   │   │   │   ├── flags: static_literal, frozen
        │   │   │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   │   │   ├── content_loc: (2,0)-(2,2) = "  "
        │   │   │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   │   │   └── unescaped: "  "
        │   │   │   │   │   ├── @ EmbeddedStatementsNode (location: (2,2)-(2,5))
        │   │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   │   ├── opening_loc: (2,2)-(2,4) = "\#{"
        │   │   │   │   │   │   ├── statements: ∅
        │   │   │   │   │   │   └── closing_loc: (2,4)-(2,5) = "}"
        │   │   │   │   │   └── @ StringNode (location: (2,5)-(3,0))
        │   │   │   │   │       ├── flags: static_literal, frozen
        │   │   │   │   │       ├── opening_loc: ∅
        │   │   │   │   │       ├── content_loc: (2,5)-(3,0) = "\n"
        │   │   │   │   │       ├── closing_loc: ∅
        │   │   │   │   │       └── unescaped: "\n"
        │   │   │   │   └── closing_loc: (3,0)-(4,0) = "HEREDOC\n"
        │   │   │   └── operator_loc: (1,8)-(1,10) = "=>"
        │   │   └── @ AssocNode (location: (1,23)-(1,36))
        │   │       ├── flags: static_literal
        │   │       ├── key:
        │   │       │   @ StringNode (location: (1,23)-(1,28))
        │   │       │   ├── flags: static_literal, frozen
        │   │       │   ├── opening_loc: (1,23)-(1,24) = "\""
        │   │       │   ├── content_loc: (1,24)-(1,27) = "bar"
        │   │       │   ├── closing_loc: (1,27)-(1,28) = "\""
        │   │       │   └── unescaped: "bar"
        │   │       ├── value:
        │   │       │   @ SymbolNode (location: (1,32)-(1,36))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (1,32)-(1,33) = ":"
        │   │       │   ├── value_loc: (1,33)-(1,36) = "baz"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "baz"
        │   │       └── operator_loc: (1,29)-(1,31) = "=>"
        │   └── closing_loc: (1,37)-(1,38) = "}"
        ├── @ HashNode (location: (4,0)-(4,31))
        │   ├── flags: newline
        │   ├── opening_loc: (4,0)-(4,1) = "{"
        │   ├── elements: (length: 2)
        │   │   ├── @ AssocNode (location: (4,2)-(4,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── key:
        │   │   │   │   @ StringNode (location: (4,2)-(4,7))
        │   │   │   │   ├── flags: static_literal, frozen
        │   │   │   │   ├── opening_loc: (4,2)-(4,3) = "\""
        │   │   │   │   ├── content_loc: (4,3)-(4,6) = "foo"
        │   │   │   │   ├── closing_loc: (4,6)-(4,7) = "\""
        │   │   │   │   └── unescaped: "foo"
        │   │   │   ├── value:
        │   │   │   │   @ StringNode (location: (4,11)-(4,14))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── opening_loc: (4,11)-(4,13) = "%("
        │   │   │   │   ├── content_loc: (4,13)-(4,13) = ""
        │   │   │   │   ├── closing_loc: (4,13)-(4,14) = ")"
        │   │   │   │   └── unescaped: ""
        │   │   │   └── operator_loc: (4,8)-(4,10) = "=>"
        │   │   └── @ AssocNode (location: (4,16)-(4,29))
        │   │       ├── flags: static_literal
        │   │       ├── key:
        │   │       │   @ StringNode (location: (4,16)-(4,21))
        │   │       │   ├── flags: static_literal, frozen
        │   │       │   ├── opening_loc: (4,16)-(4,17) = "\""
        │   │       │   ├── content_loc: (4,17)-(4,20) = "bar"
        │   │       │   ├── closing_loc: (4,20)-(4,21) = "\""
        │   │       │   └── unescaped: "bar"
        │   │       ├── value:
        │   │       │   @ SymbolNode (location: (4,25)-(4,29))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (4,25)-(4,26) = ":"
        │   │       │   ├── value_loc: (4,26)-(4,29) = "baz"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "baz"
        │   │       └── operator_loc: (4,22)-(4,24) = "=>"
        │   └── closing_loc: (4,30)-(4,31) = "}"
        ├── @ ArrayNode (location: (5,0)-(5,12))
        │   ├── flags: newline
        │   ├── elements: (length: 2)
        │   │   ├── @ StringNode (location: (5,1)-(5,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (5,1)-(5,2) = "\""
        │   │   │   ├── content_loc: (5,2)-(5,5) = "foo"
        │   │   │   ├── closing_loc: (5,5)-(5,6) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   └── @ StringNode (location: (5,8)-(5,11))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (5,8)-(5,10) = "%("
        │   │       ├── content_loc: (5,10)-(5,10) = ""
        │   │       ├── closing_loc: (5,10)-(5,11) = ")"
        │   │       └── unescaped: ""
        │   ├── opening_loc: (5,0)-(5,1) = "["
        │   └── closing_loc: (5,11)-(5,12) = "]"
        ├── @ CallNode (location: (6,0)-(6,15))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (6,0)-(6,13))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (6,0)-(6,1) = "a"
        │   │   ├── opening_loc: (6,1)-(6,2) = "("
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (6,2)-(6,12))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ InterpolatedStringNode (location: (6,2)-(6,12))
        │   │   │           ├── flags: ∅
        │   │   │           ├── opening_loc: (6,2)-(6,12) = "<<-HEREDOC"
        │   │   │           ├── parts: (length: 3)
        │   │   │           │   ├── @ StringNode (location: (7,0)-(7,2))
        │   │   │           │   │   ├── flags: static_literal, frozen
        │   │   │           │   │   ├── opening_loc: ∅
        │   │   │           │   │   ├── content_loc: (7,0)-(7,2) = "  "
        │   │   │           │   │   ├── closing_loc: ∅
        │   │   │           │   │   └── unescaped: "  "
        │   │   │           │   ├── @ EmbeddedStatementsNode (location: (7,2)-(7,5))
        │   │   │           │   │   ├── flags: ∅
        │   │   │           │   │   ├── opening_loc: (7,2)-(7,4) = "\#{"
        │   │   │           │   │   ├── statements: ∅
        │   │   │           │   │   └── closing_loc: (7,4)-(7,5) = "}"
        │   │   │           │   └── @ StringNode (location: (7,5)-(8,0))
        │   │   │           │       ├── flags: static_literal, frozen
        │   │   │           │       ├── opening_loc: ∅
        │   │   │           │       ├── content_loc: (7,5)-(8,0) = "\n"
        │   │   │           │       ├── closing_loc: ∅
        │   │   │           │       └── unescaped: "\n"
        │   │   │           └── closing_loc: (8,0)-(9,0) = "HEREDOC\n"
        │   │   ├── closing_loc: (6,12)-(6,13) = ")"
        │   │   └── block: ∅
        │   ├── call_operator_loc: (6,13)-(6,14) = "."
        │   ├── name: :a
        │   ├── message_loc: (6,14)-(6,15) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (9,0)-(9,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (9,0)-(9,6))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (9,0)-(9,1) = "a"
        │   │   ├── opening_loc: (9,1)-(9,2) = "("
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (9,2)-(9,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ StringNode (location: (9,2)-(9,5))
        │   │   │           ├── flags: ∅
        │   │   │           ├── opening_loc: (9,2)-(9,4) = "%("
        │   │   │           ├── content_loc: (9,4)-(9,4) = ""
        │   │   │           ├── closing_loc: (9,4)-(9,5) = ")"
        │   │   │           └── unescaped: ""
        │   │   ├── closing_loc: (9,5)-(9,6) = ")"
        │   │   └── block: ∅
        │   ├── call_operator_loc: (9,6)-(9,7) = "."
        │   ├── name: :a
        │   ├── message_loc: (9,7)-(9,8) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ HashNode (location: (10,0)-(10,30))
        │   ├── flags: newline
        │   ├── opening_loc: (10,0)-(10,1) = "{"
        │   ├── elements: (length: 2)
        │   │   ├── @ AssocNode (location: (10,2)-(10,21))
        │   │   │   ├── flags: ∅
        │   │   │   ├── key:
        │   │   │   │   @ StringNode (location: (10,2)-(10,7))
        │   │   │   │   ├── flags: static_literal, frozen
        │   │   │   │   ├── opening_loc: (10,2)-(10,3) = "\""
        │   │   │   │   ├── content_loc: (10,3)-(10,6) = "foo"
        │   │   │   │   ├── closing_loc: (10,6)-(10,7) = "\""
        │   │   │   │   └── unescaped: "foo"
        │   │   │   ├── value:
        │   │   │   │   @ InterpolatedStringNode (location: (10,11)-(10,21))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── opening_loc: (10,11)-(10,21) = "<<-HEREDOC"
        │   │   │   │   ├── parts: (length: 3)
        │   │   │   │   │   ├── @ StringNode (location: (11,0)-(11,2))
        │   │   │   │   │   │   ├── flags: static_literal, frozen
        │   │   │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   │   │   ├── content_loc: (11,0)-(11,2) = "  "
        │   │   │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   │   │   └── unescaped: "  "
        │   │   │   │   │   ├── @ EmbeddedStatementsNode (location: (11,2)-(11,5))
        │   │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   │   ├── opening_loc: (11,2)-(11,4) = "\#{"
        │   │   │   │   │   │   ├── statements: ∅
        │   │   │   │   │   │   └── closing_loc: (11,4)-(11,5) = "}"
        │   │   │   │   │   └── @ StringNode (location: (11,5)-(12,0))
        │   │   │   │   │       ├── flags: static_literal, frozen
        │   │   │   │   │       ├── opening_loc: ∅
        │   │   │   │   │       ├── content_loc: (11,5)-(12,0) = "\n"
        │   │   │   │   │       ├── closing_loc: ∅
        │   │   │   │   │       └── unescaped: "\n"
        │   │   │   │   └── closing_loc: (12,0)-(13,0) = "HEREDOC\n"
        │   │   │   └── operator_loc: (10,8)-(10,10) = "=>"
        │   │   └── @ AssocSplatNode (location: (10,23)-(10,28))
        │   │       ├── flags: ∅
        │   │       ├── value:
        │   │       │   @ CallNode (location: (10,25)-(10,28))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :baz
        │   │       │   ├── message_loc: (10,25)-(10,28) = "baz"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── operator_loc: (10,23)-(10,25) = "**"
        │   └── closing_loc: (10,29)-(10,30) = "}"
        ├── @ HashNode (location: (13,0)-(13,23))
        │   ├── flags: newline
        │   ├── opening_loc: (13,0)-(13,1) = "{"
        │   ├── elements: (length: 2)
        │   │   ├── @ AssocNode (location: (13,2)-(13,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── key:
        │   │   │   │   @ StringNode (location: (13,2)-(13,7))
        │   │   │   │   ├── flags: static_literal, frozen
        │   │   │   │   ├── opening_loc: (13,2)-(13,3) = "\""
        │   │   │   │   ├── content_loc: (13,3)-(13,6) = "foo"
        │   │   │   │   ├── closing_loc: (13,6)-(13,7) = "\""
        │   │   │   │   └── unescaped: "foo"
        │   │   │   ├── value:
        │   │   │   │   @ StringNode (location: (13,11)-(13,14))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── opening_loc: (13,11)-(13,13) = "%("
        │   │   │   │   ├── content_loc: (13,13)-(13,13) = ""
        │   │   │   │   ├── closing_loc: (13,13)-(13,14) = ")"
        │   │   │   │   └── unescaped: ""
        │   │   │   └── operator_loc: (13,8)-(13,10) = "=>"
        │   │   └── @ AssocSplatNode (location: (13,16)-(13,21))
        │   │       ├── flags: ∅
        │   │       ├── value:
        │   │       │   @ CallNode (location: (13,18)-(13,21))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :baz
        │   │       │   ├── message_loc: (13,18)-(13,21) = "baz"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── operator_loc: (13,16)-(13,18) = "**"
        │   └── closing_loc: (13,22)-(13,23) = "}"
        ├── @ InterpolatedStringNode (location: (14,0)-(14,14))
        │   ├── flags: newline
        │   ├── opening_loc: (14,0)-(14,1) = "\""
        │   ├── parts: (length: 5)
        │   │   ├── @ EmbeddedVariableNode (location: (14,1)-(14,4))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (14,1)-(14,2) = "#"
        │   │   │   └── variable:
        │   │   │       @ InstanceVariableReadNode (location: (14,2)-(14,4))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :@a
        │   │   ├── @ StringNode (location: (14,4)-(14,5))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (14,4)-(14,5) = " "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: " "
        │   │   ├── @ EmbeddedVariableNode (location: (14,5)-(14,9))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (14,5)-(14,6) = "#"
        │   │   │   └── variable:
        │   │   │       @ ClassVariableReadNode (location: (14,6)-(14,9))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :@@a
        │   │   ├── @ StringNode (location: (14,9)-(14,10))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (14,9)-(14,10) = " "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: " "
        │   │   └── @ EmbeddedVariableNode (location: (14,10)-(14,13))
        │   │       ├── flags: ∅
        │   │       ├── operator_loc: (14,10)-(14,11) = "#"
        │   │       └── variable:
        │   │           @ GlobalVariableReadNode (location: (14,11)-(14,13))
        │   │           ├── flags: ∅
        │   │           └── name: :$a
        │   └── closing_loc: (14,13)-(14,14) = "\""
        ├── @ IntegerNode (location: (15,0)-(15,1))
        │   ├── flags: newline, static_literal, decimal
        │   └── value: 0
        ├── @ CallNode (location: (16,0)-(16,3))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (16,1)-(16,3))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: ∅
        │   ├── name: :+@
        │   ├── message_loc: (16,0)-(16,1) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ IntegerNode (location: (17,0)-(17,1))
        │   ├── flags: newline, static_literal, decimal
        │   └── value: 1
        ├── @ IntegerNode (location: (18,0)-(18,1))
        │   ├── flags: newline, static_literal, decimal
        │   └── value: 1
        ├── @ RationalNode (location: (19,0)-(19,2))
        │   ├── flags: newline, static_literal, decimal
        │   ├── numerator: 1
        │   └── denominator: 1
        ├── @ RationalNode (location: (20,0)-(20,4))
        │   ├── flags: newline, static_literal, decimal
        │   ├── numerator: 3
        │   └── denominator: 2
        ├── @ RationalNode (location: (21,0)-(21,4))
        │   ├── flags: newline, static_literal, decimal
        │   ├── numerator: 13
        │   └── denominator: 10
        ├── @ ImaginaryNode (location: (22,0)-(22,2))
        │   ├── flags: newline, static_literal
        │   └── numeric:
        │       @ IntegerNode (location: (22,0)-(22,1))
        │       ├── flags: static_literal, decimal
        │       └── value: 5
        ├── @ ImaginaryNode (location: (23,0)-(23,3))
        │   ├── flags: newline, static_literal
        │   └── numeric:
        │       @ IntegerNode (location: (23,0)-(23,2))
        │       ├── flags: static_literal, decimal
        │       └── value: -5
        ├── @ ImaginaryNode (location: (24,0)-(24,4))
        │   ├── flags: newline, static_literal
        │   └── numeric:
        │       @ FloatNode (location: (24,0)-(24,3))
        │       ├── flags: static_literal
        │       └── value: 0.6
        ├── @ ImaginaryNode (location: (25,0)-(25,5))
        │   ├── flags: newline, static_literal
        │   └── numeric:
        │       @ FloatNode (location: (25,0)-(25,4))
        │       ├── flags: static_literal
        │       └── value: -0.6
        ├── @ ImaginaryNode (location: (26,0)-(26,32))
        │   ├── flags: newline, static_literal
        │   └── numeric:
        │       @ IntegerNode (location: (26,0)-(26,31))
        │       ├── flags: static_literal, decimal
        │       └── value: 1000000000000000000000000000000
        ├── @ ImaginaryNode (location: (27,0)-(27,3))
        │   ├── flags: newline, static_literal
        │   └── numeric:
        │       @ RationalNode (location: (27,0)-(27,2))
        │       ├── flags: static_literal, decimal
        │       ├── numerator: 1
        │       └── denominator: 1
        ├── @ InterpolatedStringNode (location: (28,0)-(28,11))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: ∅
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (28,0)-(28,5))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: (28,0)-(28,1) = "\""
        │   │   │   ├── content_loc: (28,1)-(28,4) = "foo"
        │   │   │   ├── closing_loc: (28,4)-(28,5) = "\""
        │   │   │   └── unescaped: "foo"
        │   │   └── @ StringNode (location: (28,6)-(28,11))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: (28,6)-(28,7) = "\""
        │   │       ├── content_loc: (28,7)-(28,10) = "bar"
        │   │       ├── closing_loc: (28,10)-(28,11) = "\""
        │   │       └── unescaped: "bar"
        │   └── closing_loc: ∅
        ├── @ InterpolatedStringNode (location: (29,0)-(29,15))
        │   ├── flags: newline
        │   ├── opening_loc: (29,0)-(29,1) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (29,1)-(29,8))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (29,1)-(29,8) = "foobar "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foobar "
        │   │   └── @ EmbeddedStatementsNode (location: (29,8)-(29,14))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (29,8)-(29,10) = "\#{"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (29,10)-(29,13))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (29,10)-(29,13))
        │   │       │           ├── flags: variable_call, ignore_visibility
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :baz
        │   │       │           ├── message_loc: (29,10)-(29,13) = "baz"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments: ∅
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       └── closing_loc: (29,13)-(29,14) = "}"
        │   └── closing_loc: (29,14)-(29,15) = "\""
        ├── @ InterpolatedStringNode (location: (30,0)-(30,12))
        │   ├── flags: newline
        │   ├── opening_loc: (30,0)-(30,1) = "\""
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (30,1)-(30,4))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (30,1)-(30,4) = "foo"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo"
        │   │   ├── @ EmbeddedStatementsNode (location: (30,4)-(30,8))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (30,4)-(30,6) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (30,6)-(30,7))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (30,6)-(30,7))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   └── closing_loc: (30,7)-(30,8) = "}"
        │   │   └── @ StringNode (location: (30,8)-(30,11))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (30,8)-(30,11) = "bar"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "bar"
        │   └── closing_loc: (30,11)-(30,12) = "\""
        ├── @ InterpolatedStringNode (location: (31,0)-(31,9))
        │   ├── flags: newline
        │   ├── opening_loc: (31,0)-(31,1) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (31,1)-(31,5))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (31,1)-(31,5) = "\\\\\\\\"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\\\\"
        │   │   └── @ EmbeddedStatementsNode (location: (31,5)-(31,8))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (31,5)-(31,7) = "\#{"
        │   │       ├── statements: ∅
        │   │       └── closing_loc: (31,7)-(31,8) = "}"
        │   └── closing_loc: (31,8)-(31,9) = "\""
        ├── @ InterpolatedStringNode (location: (32,0)-(32,9))
        │   ├── flags: newline
        │   ├── opening_loc: (32,0)-(32,1) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ EmbeddedStatementsNode (location: (32,1)-(32,4))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (32,1)-(32,3) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (32,3)-(32,4) = "}"
        │   │   └── @ StringNode (location: (32,4)-(32,8))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (32,4)-(32,8) = "\\\#{}"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\#{}"
        │   └── closing_loc: (32,8)-(32,9) = "\""
        ├── @ InterpolatedStringNode (location: (33,0)-(33,9))
        │   ├── flags: newline
        │   ├── opening_loc: (33,0)-(33,1) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (33,1)-(33,5))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (33,1)-(33,5) = "\\\#{}"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\#{}"
        │   │   └── @ EmbeddedStatementsNode (location: (33,5)-(33,8))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (33,5)-(33,7) = "\#{"
        │   │       ├── statements: ∅
        │   │       └── closing_loc: (33,7)-(33,8) = "}"
        │   └── closing_loc: (33,8)-(33,9) = "\""
        ├── @ StringNode (location: (34,0)-(34,15))
        │   ├── flags: newline
        │   ├── opening_loc: (34,0)-(34,1) = "\""
        │   ├── content_loc: (34,1)-(34,14) = "foo\\\\\\\#{@bar}"
        │   ├── closing_loc: (34,14)-(34,15) = "\""
        │   └── unescaped: "foo\\\#{@bar}"
        ├── @ StringNode (location: (35,0)-(35,4))
        │   ├── flags: newline
        │   ├── opening_loc: (35,0)-(35,1) = "\""
        │   ├── content_loc: (35,1)-(35,3) = "\\\""
        │   ├── closing_loc: (35,3)-(35,4) = "\""
        │   └── unescaped: "\""
        ├── @ StringNode (location: (36,0)-(36,9))
        │   ├── flags: newline
        │   ├── opening_loc: (36,0)-(36,1) = "\""
        │   ├── content_loc: (36,1)-(36,8) = "foo bar"
        │   ├── closing_loc: (36,8)-(36,9) = "\""
        │   └── unescaped: "foo bar"
        ├── @ StringNode (location: (37,0)-(37,10))
        │   ├── flags: newline
        │   ├── opening_loc: (37,0)-(37,1) = "\""
        │   ├── content_loc: (37,1)-(37,9) = "foo\\nbar"
        │   ├── closing_loc: (37,9)-(37,10) = "\""
        │   └── unescaped: "foo\nbar"
        ├── @ XStringNode (location: (38,0)-(38,5))
        │   ├── flags: newline
        │   ├── opening_loc: (38,0)-(38,1) = "`"
        │   ├── content_loc: (38,1)-(38,4) = "foo"
        │   ├── closing_loc: (38,4)-(38,5) = "`"
        │   └── unescaped: "foo"
        ├── @ InterpolatedXStringNode (location: (39,0)-(39,12))
        │   ├── flags: newline
        │   ├── opening_loc: (39,0)-(39,1) = "`"
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (39,1)-(39,4))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (39,1)-(39,4) = "foo"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo"
        │   │   └── @ EmbeddedStatementsNode (location: (39,4)-(39,11))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (39,4)-(39,6) = "\#{"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (39,6)-(39,10))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ InstanceVariableReadNode (location: (39,6)-(39,10))
        │   │       │           ├── flags: ∅
        │   │       │           └── name: :@bar
        │   │       └── closing_loc: (39,10)-(39,11) = "}"
        │   └── closing_loc: (39,11)-(39,12) = "`"
        ├── @ XStringNode (location: (40,0)-(40,3))
        │   ├── flags: newline
        │   ├── opening_loc: (40,0)-(40,1) = "`"
        │   ├── content_loc: (40,1)-(40,2) = ")"
        │   ├── closing_loc: (40,2)-(40,3) = "`"
        │   └── unescaped: ")"
        ├── @ XStringNode (location: (41,0)-(41,4))
        │   ├── flags: newline
        │   ├── opening_loc: (41,0)-(41,1) = "`"
        │   ├── content_loc: (41,1)-(41,3) = "\\`"
        │   ├── closing_loc: (41,3)-(41,4) = "`"
        │   └── unescaped: "`"
        ├── @ XStringNode (location: (42,0)-(42,3))
        │   ├── flags: newline
        │   ├── opening_loc: (42,0)-(42,1) = "`"
        │   ├── content_loc: (42,1)-(42,2) = "\""
        │   ├── closing_loc: (42,2)-(42,3) = "`"
        │   └── unescaped: "\""
        ├── @ SymbolNode (location: (43,0)-(43,4))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (43,0)-(43,1) = ":"
        │   ├── value_loc: (43,1)-(43,4) = "foo"
        │   ├── closing_loc: ∅
        │   └── unescaped: "foo"
        ├── @ SymbolNode (location: (44,0)-(44,6))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (44,0)-(44,2) = ":\""
        │   ├── value_loc: (44,2)-(44,5) = "A B"
        │   ├── closing_loc: (44,5)-(44,6) = "\""
        │   └── unescaped: "A B"
        ├── @ SymbolNode (location: (45,0)-(45,4))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (45,0)-(45,1) = ":"
        │   ├── value_loc: (45,1)-(45,4) = "foo"
        │   ├── closing_loc: ∅
        │   └── unescaped: "foo"
        ├── @ SymbolNode (location: (46,0)-(46,6))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (46,0)-(46,2) = ":\""
        │   ├── value_loc: (46,2)-(46,5) = "A B"
        │   ├── closing_loc: (46,5)-(46,6) = "\""
        │   └── unescaped: "A B"
        ├── @ SymbolNode (location: (47,0)-(47,7))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (47,0)-(47,2) = ":\""
        │   ├── value_loc: (47,2)-(47,6) = "A\\\"B"
        │   ├── closing_loc: (47,6)-(47,7) = "\""
        │   └── unescaped: "A\"B"
        ├── @ SymbolNode (location: (48,0)-(48,3))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (48,0)-(48,2) = ":\""
        │   ├── value_loc: (1,0)-(1,0) = ""
        │   ├── closing_loc: (48,2)-(48,3) = "\""
        │   └── unescaped: ""
        ├── @ RegularExpressionNode (location: (49,0)-(49,5))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (49,0)-(49,1) = "/"
        │   ├── content_loc: (49,1)-(49,4) = "foo"
        │   ├── closing_loc: (49,4)-(49,5) = "/"
        │   └── unescaped: "foo"
        ├── @ RegularExpressionNode (location: (50,0)-(50,28))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (50,0)-(50,1) = "/"
        │   ├── content_loc: (50,1)-(50,27) = "[^-+',.\\/:@[:alnum:]\\[\\]]+"
        │   ├── closing_loc: (50,27)-(50,28) = "/"
        │   └── unescaped: "[^-+',./:@[:alnum:]\\[\\]]+"
        ├── @ InterpolatedRegularExpressionNode (location: (51,0)-(51,12))
        │   ├── flags: newline
        │   ├── opening_loc: (51,0)-(51,1) = "/"
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (51,1)-(51,4))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (51,1)-(51,4) = "foo"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo"
        │   │   └── @ EmbeddedStatementsNode (location: (51,4)-(51,11))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (51,4)-(51,6) = "\#{"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (51,6)-(51,10))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ InstanceVariableReadNode (location: (51,6)-(51,10))
        │   │       │           ├── flags: ∅
        │   │       │           └── name: :@bar
        │   │       └── closing_loc: (51,10)-(51,11) = "}"
        │   └── closing_loc: (51,11)-(51,12) = "/"
        ├── @ InterpolatedRegularExpressionNode (location: (52,0)-(52,15))
        │   ├── flags: newline, ignore_case, extended, multi_line
        │   ├── opening_loc: (52,0)-(52,1) = "/"
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (52,1)-(52,4))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (52,1)-(52,4) = "foo"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo"
        │   │   └── @ EmbeddedStatementsNode (location: (52,4)-(52,11))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (52,4)-(52,6) = "\#{"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (52,6)-(52,10))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ InstanceVariableReadNode (location: (52,6)-(52,10))
        │   │       │           ├── flags: ∅
        │   │       │           └── name: :@bar
        │   │       └── closing_loc: (52,10)-(52,11) = "}"
        │   └── closing_loc: (52,11)-(52,15) = "/imx"
        ├── @ InterpolatedRegularExpressionNode (location: (53,0)-(53,13))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (53,0)-(53,1) = "/"
        │   ├── parts: (length: 1)
        │   │   └── @ EmbeddedStatementsNode (location: (53,1)-(53,12))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (53,1)-(53,3) = "\#{"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (53,3)-(53,11))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ StringNode (location: (53,3)-(53,11))
        │   │       │           ├── flags: static_literal, frozen
        │   │       │           ├── opening_loc: (53,3)-(53,4) = "\""
        │   │       │           ├── content_loc: (53,4)-(53,10) = "\\u0000"
        │   │       │           ├── closing_loc: (53,10)-(53,11) = "\""
        │   │       │           └── unescaped: "\u0000"
        │   │       └── closing_loc: (53,11)-(53,12) = "}"
        │   └── closing_loc: (53,12)-(53,13) = "/"
        ├── @ RegularExpressionNode (location: (54,0)-(54,4))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (54,0)-(54,1) = "/"
        │   ├── content_loc: (54,1)-(54,3) = "\\n"
        │   ├── closing_loc: (54,3)-(54,4) = "/"
        │   └── unescaped: "\\n"
        ├── @ RegularExpressionNode (location: (55,0)-(55,4))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (55,0)-(55,1) = "/"
        │   ├── content_loc: (55,1)-(55,3) = "\\n"
        │   ├── closing_loc: (55,3)-(55,4) = "/"
        │   └── unescaped: "\\n"
        ├── @ RegularExpressionNode (location: (56,0)-(56,5))
        │   ├── flags: newline, static_literal, extended, forced_us_ascii_encoding
        │   ├── opening_loc: (56,0)-(56,1) = "/"
        │   ├── content_loc: (56,1)-(56,3) = "\\n"
        │   ├── closing_loc: (56,3)-(56,5) = "/x"
        │   └── unescaped: "\\n"
        ├── @ RegularExpressionNode (location: (57,0)-(57,7))
        │   ├── flags: newline, static_literal, extended, forced_us_ascii_encoding
        │   ├── opening_loc: (57,0)-(57,1) = "/"
        │   ├── content_loc: (57,1)-(57,5) = "\\/\\/"
        │   ├── closing_loc: (57,5)-(57,7) = "/x"
        │   └── unescaped: "//"
        ├── @ InterpolatedSymbolNode (location: (58,0)-(58,15))
        │   ├── flags: newline
        │   ├── opening_loc: (58,0)-(58,2) = ":\""
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (58,2)-(58,5))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (58,2)-(58,5) = "foo"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo"
        │   │   ├── @ EmbeddedStatementsNode (location: (58,5)-(58,11))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (58,5)-(58,7) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (58,7)-(58,10))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (58,7)-(58,10))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :bar
        │   │   │   │           ├── message_loc: (58,7)-(58,10) = "bar"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── closing_loc: (58,10)-(58,11) = "}"
        │   │   └── @ StringNode (location: (58,11)-(58,14))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (58,11)-(58,14) = "baz"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "baz"
        │   └── closing_loc: (58,14)-(58,15) = "\""
        ├── @ InterpolatedSymbolNode (location: (59,0)-(59,11))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (59,0)-(59,2) = ":\""
        │   ├── parts: (length: 1)
        │   │   └── @ EmbeddedStatementsNode (location: (59,2)-(59,10))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: (59,2)-(59,4) = "\#{"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (59,4)-(59,9))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ StringNode (location: (59,4)-(59,9))
        │   │       │           ├── flags: static_literal, frozen
        │   │       │           ├── opening_loc: (59,4)-(59,5) = "\""
        │   │       │           ├── content_loc: (59,5)-(59,8) = "foo"
        │   │       │           ├── closing_loc: (59,8)-(59,9) = "\""
        │   │       │           └── unescaped: "foo"
        │   │       └── closing_loc: (59,9)-(59,10) = "}"
        │   └── closing_loc: (59,10)-(59,11) = "\""
        ├── @ RangeNode (location: (60,0)-(60,14))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ ParenthesesNode (location: (60,0)-(60,11))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (60,1)-(60,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (60,1)-(60,10))
        │   │   │           ├── flags: newline
        │   │   │           ├── receiver:
        │   │   │           │   @ FloatNode (location: (60,1)-(60,4))
        │   │   │           │   ├── flags: static_literal
        │   │   │           │   └── value: 0.0
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :/
        │   │   │           ├── message_loc: (60,5)-(60,6) = "/"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (60,7)-(60,10))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ FloatNode (location: (60,7)-(60,10))
        │   │   │           │           ├── flags: static_literal
        │   │   │           │           └── value: 0.0
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── opening_loc: (60,0)-(60,1) = "("
        │   │   └── closing_loc: (60,10)-(60,11) = ")"
        │   ├── right:
        │   │   @ IntegerNode (location: (60,13)-(60,14))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (60,11)-(60,13) = ".."
        ├── @ RangeNode (location: (61,0)-(61,14))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ IntegerNode (location: (61,0)-(61,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── right:
        │   │   @ ParenthesesNode (location: (61,3)-(61,14))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (61,4)-(61,13))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (61,4)-(61,13))
        │   │   │           ├── flags: newline
        │   │   │           ├── receiver:
        │   │   │           │   @ FloatNode (location: (61,4)-(61,7))
        │   │   │           │   ├── flags: static_literal
        │   │   │           │   └── value: 0.0
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :/
        │   │   │           ├── message_loc: (61,8)-(61,9) = "/"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (61,10)-(61,13))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ FloatNode (location: (61,10)-(61,13))
        │   │   │           │           ├── flags: static_literal
        │   │   │           │           └── value: 0.0
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── opening_loc: (61,3)-(61,4) = "("
        │   │   └── closing_loc: (61,13)-(61,14) = ")"
        │   └── operator_loc: (61,1)-(61,3) = ".."
        ├── @ RangeNode (location: (62,0)-(62,16))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ ParenthesesNode (location: (62,0)-(62,11))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (62,1)-(62,10))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (62,1)-(62,10))
        │   │   │           ├── flags: newline
        │   │   │           ├── receiver:
        │   │   │           │   @ FloatNode (location: (62,1)-(62,4))
        │   │   │           │   ├── flags: static_literal
        │   │   │           │   └── value: 0.0
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :/
        │   │   │           ├── message_loc: (62,5)-(62,6) = "/"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (62,7)-(62,10))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ FloatNode (location: (62,7)-(62,10))
        │   │   │           │           ├── flags: static_literal
        │   │   │           │           └── value: 0.0
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── opening_loc: (62,0)-(62,1) = "("
        │   │   └── closing_loc: (62,10)-(62,11) = ")"
        │   ├── right:
        │   │   @ IntegerNode (location: (62,13)-(62,16))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 100
        │   └── operator_loc: (62,11)-(62,13) = ".."
        ├── @ FloatNode (location: (63,0)-(63,4))
        │   ├── flags: newline, static_literal
        │   └── value: -0.1
        ├── @ FloatNode (location: (64,0)-(64,3))
        │   ├── flags: newline, static_literal
        │   └── value: 0.1
        ├── @ ArrayNode (location: (65,0)-(65,6))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 2)
        │   │   ├── @ IntegerNode (location: (65,1)-(65,2))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   └── @ IntegerNode (location: (65,4)-(65,5))
        │   │       ├── flags: static_literal, decimal
        │   │       └── value: 2
        │   ├── opening_loc: (65,0)-(65,1) = "["
        │   └── closing_loc: (65,5)-(65,6) = "]"
        ├── @ ArrayNode (location: (66,0)-(66,11))
        │   ├── flags: newline
        │   ├── elements: (length: 3)
        │   │   ├── @ IntegerNode (location: (66,1)-(66,2))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── @ ParenthesesNode (location: (66,4)-(66,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── body: ∅
        │   │   │   ├── opening_loc: (66,4)-(66,5) = "("
        │   │   │   └── closing_loc: (66,5)-(66,6) = ")"
        │   │   └── @ CallNode (location: (66,8)-(66,10))
        │   │       ├── flags: variable_call, ignore_visibility
        │   │       ├── receiver: ∅
        │   │       ├── call_operator_loc: ∅
        │   │       ├── name: :n2
        │   │       ├── message_loc: (66,8)-(66,10) = "n2"
        │   │       ├── opening_loc: ∅
        │   │       ├── arguments: ∅
        │   │       ├── closing_loc: ∅
        │   │       └── block: ∅
        │   ├── opening_loc: (66,0)-(66,1) = "["
        │   └── closing_loc: (66,10)-(66,11) = "]"
        ├── @ ArrayNode (location: (67,0)-(67,3))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 1)
        │   │   └── @ IntegerNode (location: (67,1)-(67,2))
        │   │       ├── flags: static_literal, decimal
        │   │       └── value: 1
        │   ├── opening_loc: (67,0)-(67,1) = "["
        │   └── closing_loc: (67,2)-(67,3) = "]"
        ├── @ ArrayNode (location: (68,0)-(68,2))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 0)
        │   ├── opening_loc: (68,0)-(68,1) = "["
        │   └── closing_loc: (68,1)-(68,2) = "]"
        ├── @ ArrayNode (location: (69,0)-(69,10))
        │   ├── flags: newline, contains_splat
        │   ├── elements: (length: 2)
        │   │   ├── @ IntegerNode (location: (69,1)-(69,2))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   └── @ SplatNode (location: (69,4)-(69,9))
        │   │       ├── flags: ∅
        │   │       ├── operator_loc: (69,4)-(69,5) = "*"
        │   │       └── expression:
        │   │           @ InstanceVariableReadNode (location: (69,5)-(69,9))
        │   │           ├── flags: ∅
        │   │           └── name: :@foo
        │   ├── opening_loc: (69,0)-(69,1) = "["
        │   └── closing_loc: (69,9)-(69,10) = "]"
        ├── @ ArrayNode (location: (70,0)-(70,10))
        │   ├── flags: newline, contains_splat
        │   ├── elements: (length: 2)
        │   │   ├── @ SplatNode (location: (70,1)-(70,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (70,1)-(70,2) = "*"
        │   │   │   └── expression:
        │   │   │       @ InstanceVariableReadNode (location: (70,2)-(70,6))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :@foo
        │   │   └── @ IntegerNode (location: (70,8)-(70,9))
        │   │       ├── flags: static_literal, decimal
        │   │       └── value: 1
        │   ├── opening_loc: (70,0)-(70,1) = "["
        │   └── closing_loc: (70,9)-(70,10) = "]"
        ├── @ ArrayNode (location: (71,0)-(71,14))
        │   ├── flags: newline, contains_splat
        │   ├── elements: (length: 2)
        │   │   ├── @ SplatNode (location: (71,1)-(71,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (71,1)-(71,2) = "*"
        │   │   │   └── expression:
        │   │   │       @ InstanceVariableReadNode (location: (71,2)-(71,6))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :@foo
        │   │   └── @ SplatNode (location: (71,8)-(71,13))
        │   │       ├── flags: ∅
        │   │       ├── operator_loc: (71,8)-(71,9) = "*"
        │   │       └── expression:
        │   │           @ InstanceVariableReadNode (location: (71,9)-(71,13))
        │   │           ├── flags: ∅
        │   │           └── name: :@baz
        │   ├── opening_loc: (71,0)-(71,1) = "["
        │   └── closing_loc: (71,13)-(71,14) = "]"
        ├── @ HashNode (location: (72,0)-(72,2))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (72,0)-(72,1) = "{"
        │   ├── elements: (length: 0)
        │   └── closing_loc: (72,1)-(72,2) = "}"
        ├── @ HashNode (location: (73,0)-(73,12))
        │   ├── flags: newline
        │   ├── opening_loc: (73,0)-(73,1) = "{"
        │   ├── elements: (length: 1)
        │   │   └── @ AssocNode (location: (73,2)-(73,10))
        │   │       ├── flags: ∅
        │   │       ├── key:
        │   │       │   @ ParenthesesNode (location: (73,2)-(73,4))
        │   │       │   ├── flags: ∅
        │   │       │   ├── body: ∅
        │   │       │   ├── opening_loc: (73,2)-(73,3) = "("
        │   │       │   └── closing_loc: (73,3)-(73,4) = ")"
        │   │       ├── value:
        │   │       │   @ ParenthesesNode (location: (73,8)-(73,10))
        │   │       │   ├── flags: ∅
        │   │       │   ├── body: ∅
        │   │       │   ├── opening_loc: (73,8)-(73,9) = "("
        │   │       │   └── closing_loc: (73,9)-(73,10) = ")"
        │   │       └── operator_loc: (73,5)-(73,7) = "=>"
        │   └── closing_loc: (73,11)-(73,12) = "}"
        ├── @ HashNode (location: (74,0)-(74,10))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (74,0)-(74,1) = "{"
        │   ├── elements: (length: 1)
        │   │   └── @ AssocNode (location: (74,2)-(74,8))
        │   │       ├── flags: static_literal
        │   │       ├── key:
        │   │       │   @ IntegerNode (location: (74,2)-(74,3))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 1
        │   │       ├── value:
        │   │       │   @ IntegerNode (location: (74,7)-(74,8))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 2
        │   │       └── operator_loc: (74,4)-(74,6) = "=>"
        │   └── closing_loc: (74,9)-(74,10) = "}"
        ├── @ HashNode (location: (75,0)-(75,18))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (75,0)-(75,1) = "{"
        │   ├── elements: (length: 2)
        │   │   ├── @ AssocNode (location: (75,2)-(75,8))
        │   │   │   ├── flags: static_literal
        │   │   │   ├── key:
        │   │   │   │   @ IntegerNode (location: (75,2)-(75,3))
        │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   └── value: 1
        │   │   │   ├── value:
        │   │   │   │   @ IntegerNode (location: (75,7)-(75,8))
        │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   └── value: 2
        │   │   │   └── operator_loc: (75,4)-(75,6) = "=>"
        │   │   └── @ AssocNode (location: (75,10)-(75,16))
        │   │       ├── flags: static_literal
        │   │       ├── key:
        │   │       │   @ IntegerNode (location: (75,10)-(75,11))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 3
        │   │       ├── value:
        │   │       │   @ IntegerNode (location: (75,15)-(75,16))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 4
        │   │       └── operator_loc: (75,12)-(75,14) = "=>"
        │   └── closing_loc: (75,17)-(75,18) = "}"
        ├── @ HashNode (location: (76,0)-(76,27))
        │   ├── flags: newline
        │   ├── opening_loc: (76,0)-(76,1) = "{"
        │   ├── elements: (length: 2)
        │   │   ├── @ AssocNode (location: (76,2)-(76,19))
        │   │   │   ├── flags: ∅
        │   │   │   ├── key:
        │   │   │   │   @ SymbolNode (location: (76,2)-(76,4))
        │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── value_loc: (76,2)-(76,3) = "a"
        │   │   │   │   ├── closing_loc: (76,3)-(76,4) = ":"
        │   │   │   │   └── unescaped: "a"
        │   │   │   ├── value:
        │   │   │   │   @ ParenthesesNode (location: (76,5)-(76,19))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── body:
        │   │   │   │   │   @ StatementsNode (location: (76,6)-(76,18))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   └── body: (length: 1)
        │   │   │   │   │       └── @ RescueModifierNode (location: (76,6)-(76,18))
        │   │   │   │   │           ├── flags: newline
        │   │   │   │   │           ├── expression:
        │   │   │   │   │           │   @ IntegerNode (location: (76,6)-(76,7))
        │   │   │   │   │           │   ├── flags: static_literal, decimal
        │   │   │   │   │           │   └── value: 1
        │   │   │   │   │           ├── keyword_loc: (76,8)-(76,14) = "rescue"
        │   │   │   │   │           └── rescue_expression:
        │   │   │   │   │               @ CallNode (location: (76,15)-(76,18))
        │   │   │   │   │               ├── flags: variable_call, ignore_visibility
        │   │   │   │   │               ├── receiver: ∅
        │   │   │   │   │               ├── call_operator_loc: ∅
        │   │   │   │   │               ├── name: :foo
        │   │   │   │   │               ├── message_loc: (76,15)-(76,18) = "foo"
        │   │   │   │   │               ├── opening_loc: ∅
        │   │   │   │   │               ├── arguments: ∅
        │   │   │   │   │               ├── closing_loc: ∅
        │   │   │   │   │               └── block: ∅
        │   │   │   │   ├── opening_loc: (76,5)-(76,6) = "("
        │   │   │   │   └── closing_loc: (76,18)-(76,19) = ")"
        │   │   │   └── operator_loc: ∅
        │   │   └── @ AssocNode (location: (76,21)-(76,25))
        │   │       ├── flags: static_literal
        │   │       ├── key:
        │   │       │   @ SymbolNode (location: (76,21)-(76,23))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── value_loc: (76,21)-(76,22) = "b"
        │   │       │   ├── closing_loc: (76,22)-(76,23) = ":"
        │   │       │   └── unescaped: "b"
        │   │       ├── value:
        │   │       │   @ IntegerNode (location: (76,24)-(76,25))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 2
        │   │       └── operator_loc: ∅
        │   └── closing_loc: (76,26)-(76,27) = "}"
        ├── @ HashNode (location: (77,0)-(77,14))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (77,0)-(77,1) = "{"
        │   ├── elements: (length: 2)
        │   │   ├── @ AssocNode (location: (77,2)-(77,6))
        │   │   │   ├── flags: static_literal
        │   │   │   ├── key:
        │   │   │   │   @ SymbolNode (location: (77,2)-(77,4))
        │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── value_loc: (77,2)-(77,3) = "a"
        │   │   │   │   ├── closing_loc: (77,3)-(77,4) = ":"
        │   │   │   │   └── unescaped: "a"
        │   │   │   ├── value:
        │   │   │   │   @ IntegerNode (location: (77,5)-(77,6))
        │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   └── value: 1
        │   │   │   └── operator_loc: ∅
        │   │   └── @ AssocNode (location: (77,8)-(77,12))
        │   │       ├── flags: static_literal
        │   │       ├── key:
        │   │       │   @ SymbolNode (location: (77,8)-(77,10))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── value_loc: (77,8)-(77,9) = "b"
        │   │       │   ├── closing_loc: (77,9)-(77,10) = ":"
        │   │       │   └── unescaped: "b"
        │   │       ├── value:
        │   │       │   @ IntegerNode (location: (77,11)-(77,12))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 2
        │   │       └── operator_loc: ∅
        │   └── closing_loc: (77,13)-(77,14) = "}"
        ├── @ HashNode (location: (78,0)-(78,9))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (78,0)-(78,1) = "{"
        │   ├── elements: (length: 1)
        │   │   └── @ AssocNode (location: (78,2)-(78,7))
        │   │       ├── flags: static_literal
        │   │       ├── key:
        │   │       │   @ SymbolNode (location: (78,2)-(78,4))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── value_loc: (78,2)-(78,3) = "a"
        │   │       │   ├── closing_loc: (78,3)-(78,4) = ":"
        │   │       │   └── unescaped: "a"
        │   │       ├── value:
        │   │       │   @ SymbolNode (location: (78,5)-(78,7))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (78,5)-(78,6) = ":"
        │   │       │   ├── value_loc: (78,6)-(78,7) = "a"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "a"
        │   │       └── operator_loc: ∅
        │   └── closing_loc: (78,8)-(78,9) = "}"
        ├── @ HashNode (location: (79,0)-(79,15))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (79,0)-(79,1) = "{"
        │   ├── elements: (length: 1)
        │   │   └── @ AssocNode (location: (79,2)-(79,13))
        │   │       ├── flags: static_literal
        │   │       ├── key:
        │   │       │   @ SymbolNode (location: (79,2)-(79,8))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (79,2)-(79,4) = ":\""
        │   │       │   ├── value_loc: (79,4)-(79,7) = "a b"
        │   │       │   ├── closing_loc: (79,7)-(79,8) = "\""
        │   │       │   └── unescaped: "a b"
        │   │       ├── value:
        │   │       │   @ IntegerNode (location: (79,12)-(79,13))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 1
        │   │       └── operator_loc: (79,9)-(79,11) = "=>"
        │   └── closing_loc: (79,14)-(79,15) = "}"
        ├── @ HashNode (location: (80,0)-(80,12))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (80,0)-(80,1) = "{"
        │   ├── elements: (length: 1)
        │   │   └── @ AssocNode (location: (80,2)-(80,10))
        │   │       ├── flags: static_literal
        │   │       ├── key:
        │   │       │   @ SymbolNode (location: (80,2)-(80,5))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (80,2)-(80,3) = ":"
        │   │       │   ├── value_loc: (80,3)-(80,5) = "-@"
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── unescaped: "-@"
        │   │       ├── value:
        │   │       │   @ IntegerNode (location: (80,9)-(80,10))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 1
        │   │       └── operator_loc: (80,6)-(80,8) = "=>"
        │   └── closing_loc: (80,11)-(80,12) = "}"
        ├── @ InterpolatedStringNode (location: (81,0)-(82,7))
        │   ├── flags: newline
        │   ├── opening_loc: (81,0)-(81,1) = "\""
        │   ├── parts: (length: 4)
        │   │   ├── @ EmbeddedStatementsNode (location: (81,1)-(81,4))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (81,1)-(81,3) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (81,3)-(81,4) = "}"
        │   │   ├── @ StringNode (location: (81,4)-(82,0))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (81,4)-(82,0) = "\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (82,0)-(82,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (82,0)-(82,2) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (82,2)-(82,3) = "}"
        │   │   └── @ StringNode (location: (82,3)-(82,6))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (82,3)-(82,6) = "\\na"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\na"
        │   └── closing_loc: (82,6)-(82,7) = "\""
        ├── @ CallNode (location: (83,0)-(86,1))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (83,0)-(83,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (83,4)-(86,1))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (84,2)-(85,7))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ InterpolatedStringNode (location: (84,2)-(85,7))
        │       │           ├── flags: newline
        │       │           ├── opening_loc: (84,2)-(84,3) = "\""
        │       │           ├── parts: (length: 4)
        │       │           │   ├── @ EmbeddedStatementsNode (location: (84,3)-(84,6))
        │       │           │   │   ├── flags: ∅
        │       │           │   │   ├── opening_loc: (84,3)-(84,5) = "\#{"
        │       │           │   │   ├── statements: ∅
        │       │           │   │   └── closing_loc: (84,5)-(84,6) = "}"
        │       │           │   ├── @ StringNode (location: (84,6)-(85,0))
        │       │           │   │   ├── flags: static_literal, frozen
        │       │           │   │   ├── opening_loc: ∅
        │       │           │   │   ├── content_loc: (84,6)-(85,0) = "\n"
        │       │           │   │   ├── closing_loc: ∅
        │       │           │   │   └── unescaped: "\n"
        │       │           │   ├── @ EmbeddedStatementsNode (location: (85,0)-(85,3))
        │       │           │   │   ├── flags: ∅
        │       │           │   │   ├── opening_loc: (85,0)-(85,2) = "\#{"
        │       │           │   │   ├── statements: ∅
        │       │           │   │   └── closing_loc: (85,2)-(85,3) = "}"
        │       │           │   └── @ StringNode (location: (85,3)-(85,6))
        │       │           │       ├── flags: static_literal, frozen
        │       │           │       ├── opening_loc: ∅
        │       │           │       ├── content_loc: (85,3)-(85,6) = "\\na"
        │       │           │       ├── closing_loc: ∅
        │       │           │       └── unescaped: "\na"
        │       │           └── closing_loc: (85,6)-(85,7) = "\""
        │       ├── opening_loc: (83,4)-(83,5) = "{"
        │       └── closing_loc: (86,0)-(86,1) = "}"
        ├── @ SymbolNode (location: (87,0)-(88,2))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (87,0)-(87,2) = ":\""
        │   ├── value_loc: (87,2)-(88,1) = "a\\\\\nb"
        │   ├── closing_loc: (88,1)-(88,2) = "\""
        │   └── unescaped: "a\\\nb"
        └── @ InterpolatedXStringNode (location: (89,0)-(91,2))
            ├── flags: newline
            ├── opening_loc: (89,0)-(89,1) = "`"
            ├── parts: (length: 3)
            │   ├── @ StringNode (location: (89,1)-(90,0))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (89,1)-(90,0) = "  x\n"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "  x\n"
            │   ├── @ EmbeddedStatementsNode (location: (90,0)-(90,6))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (90,0)-(90,2) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (90,2)-(90,5))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ CallNode (location: (90,2)-(90,5))
            │   │   │           ├── flags: variable_call, ignore_visibility
            │   │   │           ├── receiver: ∅
            │   │   │           ├── call_operator_loc: ∅
            │   │   │           ├── name: :foo
            │   │   │           ├── message_loc: (90,2)-(90,5) = "foo"
            │   │   │           ├── opening_loc: ∅
            │   │   │           ├── arguments: ∅
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── block: ∅
            │   │   └── closing_loc: (90,5)-(90,6) = "}"
            │   └── @ StringNode (location: (90,6)-(91,1))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (90,6)-(91,1) = "\n#"
            │       ├── closing_loc: ∅
            │       └── unescaped: "\n#"
            └── closing_loc: (91,1)-(91,2) = "`"
prism-1.5.1/snapshots/unparser/corpus/literal/module.txt000066400000000000000000000147341506127434000235410ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(16,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(16,3))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ ModuleNode (location: (1,0)-(2,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── module_keyword_loc: (1,0)-(1,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (1,7)-(1,8))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── body: ∅
        │   ├── end_keyword_loc: (2,0)-(2,3) = "end"
        │   └── name: :A
        ├── @ ModuleNode (location: (4,0)-(5,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── module_keyword_loc: (4,0)-(4,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantPathNode (location: (4,7)-(4,11))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (4,7)-(4,8))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :A
        │   │   ├── name: :B
        │   │   ├── delimiter_loc: (4,8)-(4,10) = "::"
        │   │   └── name_loc: (4,10)-(4,11) = "B"
        │   ├── body: ∅
        │   ├── end_keyword_loc: (5,0)-(5,3) = "end"
        │   └── name: :B
        ├── @ ModuleNode (location: (7,0)-(8,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── module_keyword_loc: (7,0)-(7,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantPathNode (location: (7,7)-(7,14))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ ConstantPathNode (location: (7,7)-(7,11))
        │   │   │   ├── flags: ∅
        │   │   │   ├── parent:
        │   │   │   │   @ ConstantReadNode (location: (7,7)-(7,8))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── name: :A
        │   │   │   ├── name: :B
        │   │   │   ├── delimiter_loc: (7,8)-(7,10) = "::"
        │   │   │   └── name_loc: (7,10)-(7,11) = "B"
        │   │   ├── name: :C
        │   │   ├── delimiter_loc: (7,11)-(7,13) = "::"
        │   │   └── name_loc: (7,13)-(7,14) = "C"
        │   ├── body: ∅
        │   ├── end_keyword_loc: (8,0)-(8,3) = "end"
        │   └── name: :C
        └── @ ModuleNode (location: (10,0)-(16,3))
            ├── flags: newline
            ├── locals: []
            ├── module_keyword_loc: (10,0)-(10,6) = "module"
            ├── constant_path:
            │   @ ConstantReadNode (location: (10,7)-(10,8))
            │   ├── flags: ∅
            │   └── name: :A
            ├── body:
            │   @ StatementsNode (location: (11,2)-(15,5))
            │   ├── flags: ∅
            │   └── body: (length: 2)
            │       ├── @ CallNode (location: (11,2)-(11,16))
            │       │   ├── flags: newline, ignore_visibility
            │       │   ├── receiver: ∅
            │       │   ├── call_operator_loc: ∅
            │       │   ├── name: :include
            │       │   ├── message_loc: (11,2)-(11,9) = "include"
            │       │   ├── opening_loc: (11,9)-(11,10) = "("
            │       │   ├── arguments:
            │       │   │   @ ArgumentsNode (location: (11,10)-(11,15))
            │       │   │   ├── flags: ∅
            │       │   │   └── arguments: (length: 1)
            │       │   │       └── @ CallNode (location: (11,10)-(11,15))
            │       │   │           ├── flags: ∅
            │       │   │           ├── receiver:
            │       │   │           │   @ ConstantReadNode (location: (11,10)-(11,11))
            │       │   │           │   ├── flags: ∅
            │       │   │           │   └── name: :B
            │       │   │           ├── call_operator_loc: (11,11)-(11,12) = "."
            │       │   │           ├── name: :new
            │       │   │           ├── message_loc: (11,12)-(11,15) = "new"
            │       │   │           ├── opening_loc: ∅
            │       │   │           ├── arguments: ∅
            │       │   │           ├── closing_loc: ∅
            │       │   │           └── block: ∅
            │       │   ├── closing_loc: (11,15)-(11,16) = ")"
            │       │   └── block: ∅
            │       └── @ DefNode (location: (13,2)-(15,5))
            │           ├── flags: newline
            │           ├── name: :foo
            │           ├── name_loc: (13,6)-(13,9) = "foo"
            │           ├── receiver: ∅
            │           ├── parameters: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (14,4)-(14,8))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ SymbolNode (location: (14,4)-(14,8))
            │           │           ├── flags: newline, static_literal, forced_us_ascii_encoding
            │           │           ├── opening_loc: (14,4)-(14,5) = ":"
            │           │           ├── value_loc: (14,5)-(14,8) = "bar"
            │           │           ├── closing_loc: ∅
            │           │           └── unescaped: "bar"
            │           ├── locals: []
            │           ├── def_keyword_loc: (13,2)-(13,5) = "def"
            │           ├── operator_loc: ∅
            │           ├── lparen_loc: ∅
            │           ├── rparen_loc: ∅
            │           ├── equal_loc: ∅
            │           └── end_keyword_loc: (15,2)-(15,5) = "end"
            ├── end_keyword_loc: (16,0)-(16,3) = "end"
            └── name: :A
prism-1.5.1/snapshots/unparser/corpus/literal/opasgn.txt000066400000000000000000000653171506127434000235460ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(24,10))
├── flags: ∅
├── locals: [:a, :h]
└── statements:
    @ StatementsNode (location: (1,0)-(24,10))
    ├── flags: ∅
    └── body: (length: 24)
        ├── @ LocalVariableOperatorWriteNode (location: (1,0)-(1,6))
        │   ├── flags: newline
        │   ├── name_loc: (1,0)-(1,1) = "a"
        │   ├── binary_operator_loc: (1,2)-(1,4) = "+="
        │   ├── value:
        │   │   @ IntegerNode (location: (1,5)-(1,6))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 2
        │   ├── name: :a
        │   ├── binary_operator: :+
        │   └── depth: 0
        ├── @ LocalVariableOperatorWriteNode (location: (2,0)-(2,6))
        │   ├── flags: newline
        │   ├── name_loc: (2,0)-(2,1) = "a"
        │   ├── binary_operator_loc: (2,2)-(2,4) = "-="
        │   ├── value:
        │   │   @ IntegerNode (location: (2,5)-(2,6))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 2
        │   ├── name: :a
        │   ├── binary_operator: :-
        │   └── depth: 0
        ├── @ LocalVariableOperatorWriteNode (location: (3,0)-(3,7))
        │   ├── flags: newline
        │   ├── name_loc: (3,0)-(3,1) = "a"
        │   ├── binary_operator_loc: (3,2)-(3,5) = "**="
        │   ├── value:
        │   │   @ IntegerNode (location: (3,6)-(3,7))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 2
        │   ├── name: :a
        │   ├── binary_operator: :**
        │   └── depth: 0
        ├── @ LocalVariableOperatorWriteNode (location: (4,0)-(4,6))
        │   ├── flags: newline
        │   ├── name_loc: (4,0)-(4,1) = "a"
        │   ├── binary_operator_loc: (4,2)-(4,4) = "*="
        │   ├── value:
        │   │   @ IntegerNode (location: (4,5)-(4,6))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 2
        │   ├── name: :a
        │   ├── binary_operator: :*
        │   └── depth: 0
        ├── @ LocalVariableOperatorWriteNode (location: (5,0)-(5,6))
        │   ├── flags: newline
        │   ├── name_loc: (5,0)-(5,1) = "a"
        │   ├── binary_operator_loc: (5,2)-(5,4) = "/="
        │   ├── value:
        │   │   @ IntegerNode (location: (5,5)-(5,6))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 2
        │   ├── name: :a
        │   ├── binary_operator: :/
        │   └── depth: 0
        ├── @ LocalVariableAndWriteNode (location: (6,0)-(6,7))
        │   ├── flags: newline
        │   ├── name_loc: (6,0)-(6,1) = "a"
        │   ├── operator_loc: (6,2)-(6,5) = "&&="
        │   ├── value:
        │   │   @ CallNode (location: (6,6)-(6,7))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :b
        │   │   ├── message_loc: (6,6)-(6,7) = "b"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── name: :a
        │   └── depth: 0
        ├── @ LocalVariableOrWriteNode (location: (7,0)-(7,7))
        │   ├── flags: newline
        │   ├── name_loc: (7,0)-(7,1) = "a"
        │   ├── operator_loc: (7,2)-(7,5) = "||="
        │   ├── value:
        │   │   @ IntegerNode (location: (7,6)-(7,7))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 2
        │   ├── name: :a
        │   └── depth: 0
        ├── @ CallNode (location: (8,0)-(8,13))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (8,0)-(8,9))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (8,1)-(8,8))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ LocalVariableOrWriteNode (location: (8,1)-(8,8))
        │   │   │           ├── flags: newline
        │   │   │           ├── name_loc: (8,1)-(8,2) = "a"
        │   │   │           ├── operator_loc: (8,3)-(8,6) = "||="
        │   │   │           ├── value:
        │   │   │           │   @ IntegerNode (location: (8,7)-(8,8))
        │   │   │           │   ├── flags: static_literal, decimal
        │   │   │           │   └── value: 2
        │   │   │           ├── name: :a
        │   │   │           └── depth: 0
        │   │   ├── opening_loc: (8,0)-(8,1) = "("
        │   │   └── closing_loc: (8,8)-(8,9) = ")"
        │   ├── call_operator_loc: (8,9)-(8,10) = "."
        │   ├── name: :bar
        │   ├── message_loc: (8,10)-(8,13) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (9,0)-(9,17))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (9,0)-(9,10))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (9,1)-(9,9))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ LocalVariableOrWriteNode (location: (9,1)-(9,9))
        │   │   │           ├── flags: newline
        │   │   │           ├── name_loc: (9,1)-(9,2) = "h"
        │   │   │           ├── operator_loc: (9,3)-(9,6) = "||="
        │   │   │           ├── value:
        │   │   │           │   @ HashNode (location: (9,7)-(9,9))
        │   │   │           │   ├── flags: static_literal
        │   │   │           │   ├── opening_loc: (9,7)-(9,8) = "{"
        │   │   │           │   ├── elements: (length: 0)
        │   │   │           │   └── closing_loc: (9,8)-(9,9) = "}"
        │   │   │           ├── name: :h
        │   │   │           └── depth: 0
        │   │   ├── opening_loc: (9,0)-(9,1) = "("
        │   │   └── closing_loc: (9,9)-(9,10) = ")"
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (9,10)-(9,13) = "[k]"
        │   ├── opening_loc: (9,10)-(9,11) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (9,11)-(9,17))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (9,11)-(9,12))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :k
        │   │       │   ├── message_loc: (9,11)-(9,12) = "k"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (9,16)-(9,17))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :v
        │   │           ├── message_loc: (9,16)-(9,17) = "v"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (9,12)-(9,13) = "]"
        │   └── block: ∅
        ├── @ CallOperatorWriteNode (location: (10,0)-(10,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (10,0)-(10,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: (10,1)-(10,2) = "."
        │   ├── message_loc: (10,2)-(10,3) = "b"
        │   ├── read_name: :b
        │   ├── write_name: :b=
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (10,4)-(10,6) = "+="
        │   └── value:
        │       @ IntegerNode (location: (10,7)-(10,8))
        │       ├── flags: static_literal, decimal
        │       └── value: 2
        ├── @ CallOperatorWriteNode (location: (11,0)-(11,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (11,0)-(11,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: (11,1)-(11,2) = "."
        │   ├── message_loc: (11,2)-(11,3) = "b"
        │   ├── read_name: :b
        │   ├── write_name: :b=
        │   ├── binary_operator: :-
        │   ├── binary_operator_loc: (11,4)-(11,6) = "-="
        │   └── value:
        │       @ IntegerNode (location: (11,7)-(11,8))
        │       ├── flags: static_literal, decimal
        │       └── value: 2
        ├── @ CallOperatorWriteNode (location: (12,0)-(12,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (12,0)-(12,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: (12,1)-(12,2) = "."
        │   ├── message_loc: (12,2)-(12,3) = "b"
        │   ├── read_name: :b
        │   ├── write_name: :b=
        │   ├── binary_operator: :**
        │   ├── binary_operator_loc: (12,4)-(12,7) = "**="
        │   └── value:
        │       @ IntegerNode (location: (12,8)-(12,9))
        │       ├── flags: static_literal, decimal
        │       └── value: 2
        ├── @ CallOperatorWriteNode (location: (13,0)-(13,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (13,0)-(13,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: (13,1)-(13,2) = "."
        │   ├── message_loc: (13,2)-(13,3) = "b"
        │   ├── read_name: :b
        │   ├── write_name: :b=
        │   ├── binary_operator: :*
        │   ├── binary_operator_loc: (13,4)-(13,6) = "*="
        │   └── value:
        │       @ IntegerNode (location: (13,7)-(13,8))
        │       ├── flags: static_literal, decimal
        │       └── value: 2
        ├── @ CallOperatorWriteNode (location: (14,0)-(14,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (14,0)-(14,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: (14,1)-(14,2) = "."
        │   ├── message_loc: (14,2)-(14,3) = "b"
        │   ├── read_name: :b
        │   ├── write_name: :b=
        │   ├── binary_operator: :/
        │   ├── binary_operator_loc: (14,4)-(14,6) = "/="
        │   └── value:
        │       @ IntegerNode (location: (14,7)-(14,8))
        │       ├── flags: static_literal, decimal
        │       └── value: 2
        ├── @ CallAndWriteNode (location: (15,0)-(15,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (15,0)-(15,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: (15,1)-(15,2) = "."
        │   ├── message_loc: (15,2)-(15,3) = "b"
        │   ├── read_name: :b
        │   ├── write_name: :b=
        │   ├── operator_loc: (15,4)-(15,7) = "&&="
        │   └── value:
        │       @ CallNode (location: (15,8)-(15,9))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :b
        │       ├── message_loc: (15,8)-(15,9) = "b"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ CallOrWriteNode (location: (16,0)-(16,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (16,0)-(16,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: (16,1)-(16,2) = "."
        │   ├── message_loc: (16,2)-(16,3) = "b"
        │   ├── read_name: :b
        │   ├── write_name: :b=
        │   ├── operator_loc: (16,4)-(16,7) = "||="
        │   └── value:
        │       @ IntegerNode (location: (16,8)-(16,9))
        │       ├── flags: static_literal, decimal
        │       └── value: 2
        ├── @ IndexOperatorWriteNode (location: (17,0)-(17,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (17,0)-(17,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (17,1)-(17,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (17,2)-(17,3))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (17,2)-(17,3))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (17,2)-(17,3) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (17,3)-(17,4) = "]"
        │   ├── block: ∅
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (17,5)-(17,7) = "+="
        │   └── value:
        │       @ IntegerNode (location: (17,8)-(17,9))
        │       ├── flags: static_literal, decimal
        │       └── value: 2
        ├── @ IndexOperatorWriteNode (location: (18,0)-(18,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (18,0)-(18,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (18,1)-(18,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (18,2)-(18,3))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (18,2)-(18,3))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (18,2)-(18,3) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (18,3)-(18,4) = "]"
        │   ├── block: ∅
        │   ├── binary_operator: :-
        │   ├── binary_operator_loc: (18,5)-(18,7) = "-="
        │   └── value:
        │       @ IntegerNode (location: (18,8)-(18,9))
        │       ├── flags: static_literal, decimal
        │       └── value: 2
        ├── @ IndexOperatorWriteNode (location: (19,0)-(19,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (19,0)-(19,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (19,1)-(19,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (19,2)-(19,3))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (19,2)-(19,3))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (19,2)-(19,3) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (19,3)-(19,4) = "]"
        │   ├── block: ∅
        │   ├── binary_operator: :**
        │   ├── binary_operator_loc: (19,5)-(19,8) = "**="
        │   └── value:
        │       @ IntegerNode (location: (19,9)-(19,10))
        │       ├── flags: static_literal, decimal
        │       └── value: 2
        ├── @ IndexOperatorWriteNode (location: (20,0)-(20,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (20,0)-(20,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (20,1)-(20,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (20,2)-(20,3))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (20,2)-(20,3))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (20,2)-(20,3) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (20,3)-(20,4) = "]"
        │   ├── block: ∅
        │   ├── binary_operator: :*
        │   ├── binary_operator_loc: (20,5)-(20,7) = "*="
        │   └── value:
        │       @ IntegerNode (location: (20,8)-(20,9))
        │       ├── flags: static_literal, decimal
        │       └── value: 2
        ├── @ IndexOperatorWriteNode (location: (21,0)-(21,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (21,0)-(21,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (21,1)-(21,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (21,2)-(21,3))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (21,2)-(21,3))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (21,2)-(21,3) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (21,3)-(21,4) = "]"
        │   ├── block: ∅
        │   ├── binary_operator: :/
        │   ├── binary_operator_loc: (21,5)-(21,7) = "/="
        │   └── value:
        │       @ IntegerNode (location: (21,8)-(21,9))
        │       ├── flags: static_literal, decimal
        │       └── value: 2
        ├── @ IndexAndWriteNode (location: (22,0)-(22,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (22,0)-(22,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (22,1)-(22,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (22,2)-(22,3))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (22,2)-(22,3))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (22,2)-(22,3) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (22,3)-(22,4) = "]"
        │   ├── block: ∅
        │   ├── operator_loc: (22,5)-(22,8) = "&&="
        │   └── value:
        │       @ CallNode (location: (22,9)-(22,10))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :b
        │       ├── message_loc: (22,9)-(22,10) = "b"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ IndexOrWriteNode (location: (23,0)-(23,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (23,0)-(23,1))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (23,1)-(23,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (23,2)-(23,3))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (23,2)-(23,3))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (23,2)-(23,3) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (23,3)-(23,4) = "]"
        │   ├── block: ∅
        │   ├── operator_loc: (23,5)-(23,8) = "||="
        │   └── value:
        │       @ IntegerNode (location: (23,9)-(23,10))
        │       ├── flags: static_literal, decimal
        │       └── value: 2
        └── @ CallOperatorWriteNode (location: (24,0)-(24,10))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (24,0)-(24,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (24,0)-(24,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (24,3)-(24,4) = "."
            ├── message_loc: (24,4)-(24,5) = "A"
            ├── read_name: :A
            ├── write_name: :A=
            ├── binary_operator: :+
            ├── binary_operator_loc: (24,6)-(24,8) = "+="
            └── value:
                @ IntegerNode (location: (24,9)-(24,10))
                ├── flags: static_literal, decimal
                └── value: 1
prism-1.5.1/snapshots/unparser/corpus/literal/pattern.txt000066400000000000000000001036411506127434000237250ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(41,8))
├── flags: ∅
├── locals: [:a, :x, :y]
└── statements:
    @ StatementsNode (location: (1,0)-(41,8))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ CaseMatchNode (location: (1,0)-(33,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (1,5)-(1,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,5)-(1,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 15)
        │   │   ├── @ InNode (location: (2,0)-(3,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ ArrayPatternNode (location: (2,3)-(2,17))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── constant:
        │   │   │   │   │   @ ConstantReadNode (location: (2,3)-(2,4))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   └── name: :A
        │   │   │   │   ├── requireds: (length: 2)
        │   │   │   │   │   ├── @ IntegerNode (location: (2,5)-(2,6))
        │   │   │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   │   │   └── value: 1
        │   │   │   │   │   └── @ IntegerNode (location: (2,8)-(2,9))
        │   │   │   │   │       ├── flags: static_literal, decimal
        │   │   │   │   │       └── value: 2
        │   │   │   │   ├── rest:
        │   │   │   │   │   @ SplatNode (location: (2,11)-(2,13))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   ├── operator_loc: (2,11)-(2,12) = "*"
        │   │   │   │   │   └── expression:
        │   │   │   │   │       @ LocalVariableTargetNode (location: (2,12)-(2,13))
        │   │   │   │   │       ├── flags: ∅
        │   │   │   │   │       ├── name: :a
        │   │   │   │   │       └── depth: 0
        │   │   │   │   ├── posts: (length: 1)
        │   │   │   │   │   └── @ IntegerNode (location: (2,15)-(2,16))
        │   │   │   │   │       ├── flags: static_literal, decimal
        │   │   │   │   │       └── value: 3
        │   │   │   │   ├── opening_loc: (2,4)-(2,5) = "["
        │   │   │   │   └── closing_loc: (2,16)-(2,17) = "]"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (3,2)-(3,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (3,2)-(3,6))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   ├── in_loc: (2,0)-(2,2) = "in"
        │   │   │   └── then_loc: (2,18)-(2,22) = "then"
        │   │   ├── @ InNode (location: (4,0)-(5,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ ArrayPatternNode (location: (4,3)-(4,11))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── requireds: (length: 2)
        │   │   │   │   │   ├── @ IntegerNode (location: (4,4)-(4,5))
        │   │   │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   │   │   └── value: 1
        │   │   │   │   │   └── @ IntegerNode (location: (4,7)-(4,8))
        │   │   │   │   │       ├── flags: static_literal, decimal
        │   │   │   │   │       └── value: 2
        │   │   │   │   ├── rest:
        │   │   │   │   │   @ ImplicitRestNode (location: (4,8)-(4,9))
        │   │   │   │   │   └── flags: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── opening_loc: (4,3)-(4,4) = "["
        │   │   │   │   └── closing_loc: (4,10)-(4,11) = "]"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (5,2)-(5,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (5,2)-(5,3))
        │   │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :y
        │   │   │   │           ├── message_loc: (5,2)-(5,3) = "y"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   ├── in_loc: (4,0)-(4,2) = "in"
        │   │   │   └── then_loc: (4,12)-(4,16) = "then"
        │   │   ├── @ InNode (location: (6,0)-(7,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ HashPatternNode (location: (6,3)-(6,8))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── constant:
        │   │   │   │   │   @ ConstantReadNode (location: (6,3)-(6,4))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   └── name: :A
        │   │   │   │   ├── elements: (length: 1)
        │   │   │   │   │   └── @ AssocNode (location: (6,5)-(6,7))
        │   │   │   │   │       ├── flags: ∅
        │   │   │   │   │       ├── key:
        │   │   │   │   │       │   @ SymbolNode (location: (6,5)-(6,7))
        │   │   │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │   │       │   ├── opening_loc: ∅
        │   │   │   │   │       │   ├── value_loc: (6,5)-(6,6) = "x"
        │   │   │   │   │       │   ├── closing_loc: (6,6)-(6,7) = ":"
        │   │   │   │   │       │   └── unescaped: "x"
        │   │   │   │   │       ├── value:
        │   │   │   │   │       │   @ ImplicitNode (location: (6,5)-(6,6))
        │   │   │   │   │       │   ├── flags: ∅
        │   │   │   │   │       │   └── value:
        │   │   │   │   │       │       @ LocalVariableTargetNode (location: (6,5)-(6,6))
        │   │   │   │   │       │       ├── flags: ∅
        │   │   │   │   │       │       ├── name: :x
        │   │   │   │   │       │       └── depth: 0
        │   │   │   │   │       └── operator_loc: ∅
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── opening_loc: (6,4)-(6,5) = "("
        │   │   │   │   └── closing_loc: (6,7)-(6,8) = ")"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (7,2)-(7,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (7,2)-(7,6))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   ├── in_loc: (6,0)-(6,2) = "in"
        │   │   │   └── then_loc: (6,9)-(6,13) = "then"
        │   │   ├── @ InNode (location: (8,0)-(9,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ HashPatternNode (location: (8,3)-(8,8))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── elements: (length: 0)
        │   │   │   │   ├── rest:
        │   │   │   │   │   @ AssocSplatNode (location: (8,4)-(8,7))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   ├── value:
        │   │   │   │   │   │   @ LocalVariableTargetNode (location: (8,6)-(8,7))
        │   │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   │   ├── name: :a
        │   │   │   │   │   │   └── depth: 0
        │   │   │   │   │   └── operator_loc: (8,4)-(8,6) = "**"
        │   │   │   │   ├── opening_loc: (8,3)-(8,4) = "{"
        │   │   │   │   └── closing_loc: (8,7)-(8,8) = "}"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (9,2)-(9,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (9,2)-(9,6))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   ├── in_loc: (8,0)-(8,2) = "in"
        │   │   │   └── then_loc: (8,9)-(8,13) = "then"
        │   │   ├── @ InNode (location: (10,0)-(11,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ IfNode (location: (10,3)-(10,13))
        │   │   │   │   ├── flags: newline
        │   │   │   │   ├── if_keyword_loc: (10,6)-(10,8) = "if"
        │   │   │   │   ├── predicate:
        │   │   │   │   │   @ TrueNode (location: (10,9)-(10,13))
        │   │   │   │   │   └── flags: static_literal
        │   │   │   │   ├── then_keyword_loc: ∅
        │   │   │   │   ├── statements:
        │   │   │   │   │   @ StatementsNode (location: (10,3)-(10,5))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   └── body: (length: 1)
        │   │   │   │   │       └── @ HashPatternNode (location: (10,3)-(10,5))
        │   │   │   │   │           ├── flags: newline
        │   │   │   │   │           ├── constant: ∅
        │   │   │   │   │           ├── elements: (length: 0)
        │   │   │   │   │           ├── rest: ∅
        │   │   │   │   │           ├── opening_loc: (10,3)-(10,4) = "{"
        │   │   │   │   │           └── closing_loc: (10,4)-(10,5) = "}"
        │   │   │   │   ├── subsequent: ∅
        │   │   │   │   └── end_keyword_loc: ∅
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (11,2)-(11,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (11,2)-(11,6))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   ├── in_loc: (10,0)-(10,2) = "in"
        │   │   │   └── then_loc: (10,14)-(10,18) = "then"
        │   │   ├── @ InNode (location: (12,0)-(13,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ ArrayPatternNode (location: (12,3)-(12,12))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── requireds: (length: 2)
        │   │   │   │   │   ├── @ LocalVariableTargetNode (location: (12,4)-(12,5))
        │   │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   │   ├── name: :x
        │   │   │   │   │   │   └── depth: 0
        │   │   │   │   │   └── @ LocalVariableTargetNode (location: (12,7)-(12,8))
        │   │   │   │   │       ├── flags: ∅
        │   │   │   │   │       ├── name: :y
        │   │   │   │   │       └── depth: 0
        │   │   │   │   ├── rest:
        │   │   │   │   │   @ SplatNode (location: (12,10)-(12,11))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   ├── operator_loc: (12,10)-(12,11) = "*"
        │   │   │   │   │   └── expression: ∅
        │   │   │   │   ├── posts: (length: 0)
        │   │   │   │   ├── opening_loc: (12,3)-(12,4) = "["
        │   │   │   │   └── closing_loc: (12,11)-(12,12) = "]"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (13,2)-(13,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (13,2)-(13,6))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   ├── in_loc: (12,0)-(12,2) = "in"
        │   │   │   └── then_loc: (12,13)-(12,17) = "then"
        │   │   ├── @ InNode (location: (14,0)-(15,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ HashPatternNode (location: (14,3)-(14,16))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── elements: (length: 2)
        │   │   │   │   │   ├── @ AssocNode (location: (14,4)-(14,8))
        │   │   │   │   │   │   ├── flags: static_literal
        │   │   │   │   │   │   ├── key:
        │   │   │   │   │   │   │   @ SymbolNode (location: (14,4)-(14,6))
        │   │   │   │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   │   │   │   ├── value_loc: (14,4)-(14,5) = "a"
        │   │   │   │   │   │   │   ├── closing_loc: (14,5)-(14,6) = ":"
        │   │   │   │   │   │   │   └── unescaped: "a"
        │   │   │   │   │   │   ├── value:
        │   │   │   │   │   │   │   @ IntegerNode (location: (14,7)-(14,8))
        │   │   │   │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   │   │   │   └── value: 1
        │   │   │   │   │   │   └── operator_loc: ∅
        │   │   │   │   │   └── @ AssocNode (location: (14,10)-(14,15))
        │   │   │   │   │       ├── flags: static_literal
        │   │   │   │   │       ├── key:
        │   │   │   │   │       │   @ SymbolNode (location: (14,10)-(14,13))
        │   │   │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │   │       │   ├── opening_loc: ∅
        │   │   │   │   │       │   ├── value_loc: (14,10)-(14,12) = "aa"
        │   │   │   │   │       │   ├── closing_loc: (14,12)-(14,13) = ":"
        │   │   │   │   │       │   └── unescaped: "aa"
        │   │   │   │   │       ├── value:
        │   │   │   │   │       │   @ IntegerNode (location: (14,14)-(14,15))
        │   │   │   │   │       │   ├── flags: static_literal, decimal
        │   │   │   │   │       │   └── value: 2
        │   │   │   │   │       └── operator_loc: ∅
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── opening_loc: (14,3)-(14,4) = "{"
        │   │   │   │   └── closing_loc: (14,15)-(14,16) = "}"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (15,2)-(15,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (15,2)-(15,6))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   ├── in_loc: (14,0)-(14,2) = "in"
        │   │   │   └── then_loc: (14,17)-(14,21) = "then"
        │   │   ├── @ InNode (location: (16,0)-(17,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ HashPatternNode (location: (16,3)-(16,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── elements: (length: 0)
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── opening_loc: (16,3)-(16,4) = "{"
        │   │   │   │   └── closing_loc: (16,4)-(16,5) = "}"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (17,2)-(17,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (17,2)-(17,6))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   ├── in_loc: (16,0)-(16,2) = "in"
        │   │   │   └── then_loc: (16,6)-(16,10) = "then"
        │   │   ├── @ InNode (location: (18,0)-(19,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ HashPatternNode (location: (18,3)-(18,10))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── elements: (length: 0)
        │   │   │   │   ├── rest:
        │   │   │   │   │   @ NoKeywordsParameterNode (location: (18,4)-(18,9))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   ├── operator_loc: (18,4)-(18,6) = "**"
        │   │   │   │   │   └── keyword_loc: (18,6)-(18,9) = "nil"
        │   │   │   │   ├── opening_loc: (18,3)-(18,4) = "{"
        │   │   │   │   └── closing_loc: (18,9)-(18,10) = "}"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (19,2)-(19,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (19,2)-(19,6))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   ├── in_loc: (18,0)-(18,2) = "in"
        │   │   │   └── then_loc: (18,11)-(18,15) = "then"
        │   │   ├── @ InNode (location: (20,0)-(21,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ HashPatternNode (location: (20,3)-(20,11))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── elements: (length: 1)
        │   │   │   │   │   └── @ AssocNode (location: (20,4)-(20,10))
        │   │   │   │   │       ├── flags: static_literal
        │   │   │   │   │       ├── key:
        │   │   │   │   │       │   @ SymbolNode (location: (20,4)-(20,8))
        │   │   │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │   │       │   ├── opening_loc: (20,4)-(20,5) = "\""
        │   │   │   │   │       │   ├── value_loc: (20,5)-(20,6) = "a"
        │   │   │   │   │       │   ├── closing_loc: (20,6)-(20,8) = "\":"
        │   │   │   │   │       │   └── unescaped: "a"
        │   │   │   │   │       ├── value:
        │   │   │   │   │       │   @ IntegerNode (location: (20,9)-(20,10))
        │   │   │   │   │       │   ├── flags: static_literal, decimal
        │   │   │   │   │       │   └── value: 1
        │   │   │   │   │       └── operator_loc: ∅
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── opening_loc: (20,3)-(20,4) = "{"
        │   │   │   │   └── closing_loc: (20,10)-(20,11) = "}"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (21,2)-(21,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (21,2)-(21,6))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   ├── in_loc: (20,0)-(20,2) = "in"
        │   │   │   └── then_loc: (20,12)-(20,16) = "then"
        │   │   ├── @ InNode (location: (22,0)-(23,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ AlternationPatternNode (location: (22,3)-(22,8))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── left:
        │   │   │   │   │   @ IntegerNode (location: (22,3)-(22,4))
        │   │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   │   └── value: 1
        │   │   │   │   ├── right:
        │   │   │   │   │   @ IntegerNode (location: (22,7)-(22,8))
        │   │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   │   └── value: 2
        │   │   │   │   └── operator_loc: (22,5)-(22,6) = "|"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (23,2)-(23,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (23,2)-(23,6))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   ├── in_loc: (22,0)-(22,2) = "in"
        │   │   │   └── then_loc: (22,9)-(22,13) = "then"
        │   │   ├── @ InNode (location: (24,0)-(25,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ CapturePatternNode (location: (24,3)-(24,9))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── value:
        │   │   │   │   │   @ IntegerNode (location: (24,3)-(24,4))
        │   │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   │   └── value: 1
        │   │   │   │   ├── target:
        │   │   │   │   │   @ LocalVariableTargetNode (location: (24,8)-(24,9))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   ├── name: :a
        │   │   │   │   │   └── depth: 0
        │   │   │   │   └── operator_loc: (24,5)-(24,7) = "=>"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (25,2)-(25,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (25,2)-(25,6))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   ├── in_loc: (24,0)-(24,2) = "in"
        │   │   │   └── then_loc: (24,10)-(24,14) = "then"
        │   │   ├── @ InNode (location: (26,0)-(27,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ PinnedVariableNode (location: (26,3)-(26,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── variable:
        │   │   │   │   │   @ LocalVariableReadNode (location: (26,4)-(26,5))
        │   │   │   │   │   ├── flags: ∅
        │   │   │   │   │   ├── name: :x
        │   │   │   │   │   └── depth: 0
        │   │   │   │   └── operator_loc: (26,3)-(26,4) = "^"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (27,2)-(27,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ TrueNode (location: (27,2)-(27,6))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   ├── in_loc: (26,0)-(26,2) = "in"
        │   │   │   └── then_loc: (26,6)-(26,10) = "then"
        │   │   ├── @ InNode (location: (28,0)-(28,4))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ IntegerNode (location: (28,3)-(28,4))
        │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   └── value: 1
        │   │   │   ├── statements: ∅
        │   │   │   ├── in_loc: (28,0)-(28,2) = "in"
        │   │   │   └── then_loc: ∅
        │   │   └── @ InNode (location: (29,0)-(30,6))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IntegerNode (location: (29,3)-(29,4))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 2
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (30,2)-(30,6))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (30,2)-(30,6))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (29,0)-(29,2) = "in"
        │   │       └── then_loc: (29,5)-(29,9) = "then"
        │   ├── else_clause:
        │   │   @ ElseNode (location: (31,0)-(33,3))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (31,0)-(31,4) = "else"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (32,2)-(32,6))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ TrueNode (location: (32,2)-(32,6))
        │   │   │           └── flags: newline, static_literal
        │   │   └── end_keyword_loc: (33,0)-(33,3) = "end"
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (33,0)-(33,3) = "end"
        ├── @ CaseMatchNode (location: (34,0)-(36,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (34,5)-(34,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (34,5)-(34,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (35,0)-(35,17))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (35,3)-(35,17))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (35,3)-(35,4))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :A
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ IntegerNode (location: (35,5)-(35,6))
        │   │       │   │   │   ├── flags: static_literal, decimal
        │   │       │   │   │   └── value: 1
        │   │       │   │   └── @ IntegerNode (location: (35,8)-(35,9))
        │   │       │   │       ├── flags: static_literal, decimal
        │   │       │   │       └── value: 2
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (35,11)-(35,13))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (35,11)-(35,12) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (35,12)-(35,13))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :a
        │   │       │   │       └── depth: 0
        │   │       │   ├── posts: (length: 1)
        │   │       │   │   └── @ IntegerNode (location: (35,15)-(35,16))
        │   │       │   │       ├── flags: static_literal, decimal
        │   │       │   │       └── value: 3
        │   │       │   ├── opening_loc: (35,4)-(35,5) = "["
        │   │       │   └── closing_loc: (35,16)-(35,17) = "]"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (35,0)-(35,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (34,0)-(34,4) = "case"
        │   └── end_keyword_loc: (36,0)-(36,3) = "end"
        ├── @ CaseMatchNode (location: (37,0)-(40,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (37,5)-(37,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (37,5)-(37,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (38,0)-(38,4))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ConstantReadNode (location: (38,3)-(38,4))
        │   │       │   ├── flags: ∅
        │   │       │   └── name: :A
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (38,0)-(38,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause:
        │   │   @ ElseNode (location: (39,0)-(40,3))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (39,0)-(39,4) = "else"
        │   │   ├── statements: ∅
        │   │   └── end_keyword_loc: (40,0)-(40,3) = "end"
        │   ├── case_keyword_loc: (37,0)-(37,4) = "case"
        │   └── end_keyword_loc: (40,0)-(40,3) = "end"
        └── @ MatchPredicateNode (location: (41,0)-(41,8))
            ├── flags: newline
            ├── value:
            │   @ IntegerNode (location: (41,0)-(41,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── pattern:
            │   @ ArrayPatternNode (location: (41,5)-(41,8))
            │   ├── flags: ∅
            │   ├── constant: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ LocalVariableTargetNode (location: (41,6)-(41,7))
            │   │       ├── flags: ∅
            │   │       ├── name: :a
            │   │       └── depth: 0
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── opening_loc: (41,5)-(41,6) = "["
            │   └── closing_loc: (41,7)-(41,8) = "]"
            └── operator_loc: (41,2)-(41,4) = "in"
prism-1.5.1/snapshots/unparser/corpus/literal/pragma.txt000066400000000000000000000020371506127434000235140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,7))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ SourceEncodingNode (location: (1,0)-(1,12))
        │   └── flags: newline, static_literal
        ├── @ SourceFileNode (location: (2,0)-(2,8))
        │   ├── flags: newline
        │   └── filepath: "unparser/corpus/literal/pragma.txt"
        ├── @ SourceLineNode (location: (3,0)-(3,8))
        │   └── flags: newline, static_literal
        └── @ CallNode (location: (4,0)-(4,7))
            ├── flags: newline, variable_call, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :__dir__
            ├── message_loc: (4,0)-(4,7) = "__dir__"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/unparser/corpus/literal/range.txt000066400000000000000000000060121506127434000233360ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,5))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ ParenthesesNode (location: (1,0)-(1,5))
        │   ├── flags: newline
        │   ├── body:
        │   │   @ StatementsNode (location: (1,1)-(1,4))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ RangeNode (location: (1,1)-(1,4))
        │   │           ├── flags: newline, static_literal
        │   │           ├── left:
        │   │           │   @ IntegerNode (location: (1,1)-(1,2))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 1
        │   │           ├── right: ∅
        │   │           └── operator_loc: (1,2)-(1,4) = ".."
        │   ├── opening_loc: (1,0)-(1,1) = "("
        │   └── closing_loc: (1,4)-(1,5) = ")"
        ├── @ RangeNode (location: (2,0)-(2,4))
        │   ├── flags: newline, static_literal
        │   ├── left:
        │   │   @ IntegerNode (location: (2,0)-(2,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── right:
        │   │   @ IntegerNode (location: (2,3)-(2,4))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 2
        │   └── operator_loc: (2,1)-(2,3) = ".."
        ├── @ ParenthesesNode (location: (3,0)-(3,6))
        │   ├── flags: newline
        │   ├── body:
        │   │   @ StatementsNode (location: (3,1)-(3,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ RangeNode (location: (3,1)-(3,5))
        │   │           ├── flags: newline, static_literal, exclude_end
        │   │           ├── left:
        │   │           │   @ IntegerNode (location: (3,1)-(3,2))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 1
        │   │           ├── right: ∅
        │   │           └── operator_loc: (3,2)-(3,5) = "..."
        │   ├── opening_loc: (3,0)-(3,1) = "("
        │   └── closing_loc: (3,5)-(3,6) = ")"
        └── @ RangeNode (location: (4,0)-(4,5))
            ├── flags: newline, static_literal, exclude_end
            ├── left:
            │   @ IntegerNode (location: (4,0)-(4,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── right:
            │   @ IntegerNode (location: (4,4)-(4,5))
            │   ├── flags: static_literal, decimal
            │   └── value: 2
            └── operator_loc: (4,1)-(4,4) = "..."
prism-1.5.1/snapshots/unparser/corpus/literal/rescue.txt000066400000000000000000000140661506127434000235400ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,27))
├── flags: ∅
├── locals: [:x]
└── statements:
    @ StatementsNode (location: (1,0)-(3,27))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ RescueModifierNode (location: (1,0)-(1,14))
        │   ├── flags: newline
        │   ├── expression:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── keyword_loc: (1,4)-(1,10) = "rescue"
        │   └── rescue_expression:
        │       @ CallNode (location: (1,11)-(1,14))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (1,11)-(1,14) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ RescueModifierNode (location: (2,0)-(2,21))
        │   ├── flags: newline
        │   ├── expression:
        │   │   @ CallNode (location: (2,0)-(2,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (2,0)-(2,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── keyword_loc: (2,4)-(2,10) = "rescue"
        │   └── rescue_expression:
        │       @ ReturnNode (location: (2,11)-(2,21))
        │       ├── flags: ∅
        │       ├── keyword_loc: (2,11)-(2,17) = "return"
        │       └── arguments:
        │           @ ArgumentsNode (location: (2,18)-(2,21))
        │           ├── flags: ∅
        │           └── arguments: (length: 1)
        │               └── @ CallNode (location: (2,18)-(2,21))
        │                   ├── flags: variable_call, ignore_visibility
        │                   ├── receiver: ∅
        │                   ├── call_operator_loc: ∅
        │                   ├── name: :bar
        │                   ├── message_loc: (2,18)-(2,21) = "bar"
        │                   ├── opening_loc: ∅
        │                   ├── arguments: ∅
        │                   ├── closing_loc: ∅
        │                   └── block: ∅
        └── @ LocalVariableWriteNode (location: (3,0)-(3,27))
            ├── flags: newline
            ├── name: :x
            ├── depth: 0
            ├── name_loc: (3,0)-(3,1) = "x"
            ├── value:
            │   @ ParenthesesNode (location: (3,4)-(3,27))
            │   ├── flags: ∅
            │   ├── body:
            │   │   @ StatementsNode (location: (3,5)-(3,26))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ RescueModifierNode (location: (3,5)-(3,26))
            │   │           ├── flags: newline
            │   │           ├── expression:
            │   │           │   @ CallNode (location: (3,5)-(3,8))
            │   │           │   ├── flags: variable_call, ignore_visibility
            │   │           │   ├── receiver: ∅
            │   │           │   ├── call_operator_loc: ∅
            │   │           │   ├── name: :foo
            │   │           │   ├── message_loc: (3,5)-(3,8) = "foo"
            │   │           │   ├── opening_loc: ∅
            │   │           │   ├── arguments: ∅
            │   │           │   ├── closing_loc: ∅
            │   │           │   └── block: ∅
            │   │           ├── keyword_loc: (3,9)-(3,15) = "rescue"
            │   │           └── rescue_expression:
            │   │               @ ReturnNode (location: (3,16)-(3,26))
            │   │               ├── flags: ∅
            │   │               ├── keyword_loc: (3,16)-(3,22) = "return"
            │   │               └── arguments:
            │   │                   @ ArgumentsNode (location: (3,23)-(3,26))
            │   │                   ├── flags: ∅
            │   │                   └── arguments: (length: 1)
            │   │                       └── @ CallNode (location: (3,23)-(3,26))
            │   │                           ├── flags: variable_call, ignore_visibility
            │   │                           ├── receiver: ∅
            │   │                           ├── call_operator_loc: ∅
            │   │                           ├── name: :bar
            │   │                           ├── message_loc: (3,23)-(3,26) = "bar"
            │   │                           ├── opening_loc: ∅
            │   │                           ├── arguments: ∅
            │   │                           ├── closing_loc: ∅
            │   │                           └── block: ∅
            │   ├── opening_loc: (3,4)-(3,5) = "("
            │   └── closing_loc: (3,26)-(3,27) = ")"
            └── operator_loc: (3,2)-(3,3) = "="
prism-1.5.1/snapshots/unparser/corpus/literal/send.txt000066400000000000000000004004701506127434000232010ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(84,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(84,7))
    ├── flags: ∅
    └── body: (length: 62)
        ├── @ ModuleNode (location: (1,0)-(3,3))
        │   ├── flags: newline
        │   ├── locals: [:foo, :a, :_]
        │   ├── module_keyword_loc: (1,0)-(1,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (1,7)-(1,8))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (2,2)-(2,22))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableOrWriteNode (location: (2,2)-(2,22))
        │   │           ├── flags: newline
        │   │           ├── name_loc: (2,2)-(2,5) = "foo"
        │   │           ├── operator_loc: (2,6)-(2,9) = "||="
        │   │           ├── value:
        │   │           │   @ ParenthesesNode (location: (2,10)-(2,22))
        │   │           │   ├── flags: ∅
        │   │           │   ├── body:
        │   │           │   │   @ StatementsNode (location: (2,11)-(2,21))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   └── body: (length: 1)
        │   │           │   │       └── @ MultiWriteNode (location: (2,11)-(2,21))
        │   │           │   │           ├── flags: newline
        │   │           │   │           ├── lefts: (length: 2)
        │   │           │   │           │   ├── @ LocalVariableTargetNode (location: (2,12)-(2,13))
        │   │           │   │           │   │   ├── flags: ∅
        │   │           │   │           │   │   ├── name: :a
        │   │           │   │           │   │   └── depth: 0
        │   │           │   │           │   └── @ LocalVariableTargetNode (location: (2,15)-(2,16))
        │   │           │   │           │       ├── flags: ∅
        │   │           │   │           │       ├── name: :_
        │   │           │   │           │       └── depth: 0
        │   │           │   │           ├── rest: ∅
        │   │           │   │           ├── rights: (length: 0)
        │   │           │   │           ├── lparen_loc: (2,11)-(2,12) = "("
        │   │           │   │           ├── rparen_loc: (2,16)-(2,17) = ")"
        │   │           │   │           ├── operator_loc: (2,18)-(2,19) = "="
        │   │           │   │           └── value:
        │   │           │   │               @ CallNode (location: (2,20)-(2,21))
        │   │           │   │               ├── flags: variable_call, ignore_visibility
        │   │           │   │               ├── receiver: ∅
        │   │           │   │               ├── call_operator_loc: ∅
        │   │           │   │               ├── name: :b
        │   │           │   │               ├── message_loc: (2,20)-(2,21) = "b"
        │   │           │   │               ├── opening_loc: ∅
        │   │           │   │               ├── arguments: ∅
        │   │           │   │               ├── closing_loc: ∅
        │   │           │   │               └── block: ∅
        │   │           │   ├── opening_loc: (2,10)-(2,11) = "("
        │   │           │   └── closing_loc: (2,21)-(2,22) = ")"
        │   │           ├── name: :foo
        │   │           └── depth: 0
        │   ├── end_keyword_loc: (3,0)-(3,3) = "end"
        │   └── name: :A
        ├── @ ModuleNode (location: (5,0)-(8,3))
        │   ├── flags: newline
        │   ├── locals: [:local]
        │   ├── module_keyword_loc: (5,0)-(5,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (5,7)-(5,8))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (6,2)-(7,11))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 2)
        │   │       ├── @ LocalVariableWriteNode (location: (6,2)-(6,11))
        │   │       │   ├── flags: newline
        │   │       │   ├── name: :local
        │   │       │   ├── depth: 0
        │   │       │   ├── name_loc: (6,2)-(6,7) = "local"
        │   │       │   ├── value:
        │   │       │   │   @ IntegerNode (location: (6,10)-(6,11))
        │   │       │   │   ├── flags: static_literal, decimal
        │   │       │   │   └── value: 1
        │   │       │   └── operator_loc: (6,8)-(6,9) = "="
        │   │       └── @ CallNode (location: (7,2)-(7,11))
        │   │           ├── flags: newline
        │   │           ├── receiver:
        │   │           │   @ LocalVariableReadNode (location: (7,2)-(7,7))
        │   │           │   ├── flags: ∅
        │   │           │   ├── name: :local
        │   │           │   └── depth: 0
        │   │           ├── call_operator_loc: (7,7)-(7,8) = "."
        │   │           ├── name: :bar
        │   │           ├── message_loc: (7,8)-(7,11) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── end_keyword_loc: (8,0)-(8,3) = "end"
        │   └── name: :A
        ├── @ CallNode (location: (9,0)-(10,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ClassNode (location: (9,0)-(10,3))
        │   │   ├── flags: ∅
        │   │   ├── locals: []
        │   │   ├── class_keyword_loc: (9,0)-(9,5) = "class"
        │   │   ├── constant_path:
        │   │   │   @ ConstantReadNode (location: (9,6)-(9,7))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :A
        │   │   ├── inheritance_operator_loc: ∅
        │   │   ├── superclass: ∅
        │   │   ├── body: ∅
        │   │   ├── end_keyword_loc: (10,0)-(10,3) = "end"
        │   │   └── name: :A
        │   ├── call_operator_loc: (10,3)-(10,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (10,4)-(10,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (11,0)-(12,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ModuleNode (location: (11,0)-(12,3))
        │   │   ├── flags: ∅
        │   │   ├── locals: []
        │   │   ├── module_keyword_loc: (11,0)-(11,6) = "module"
        │   │   ├── constant_path:
        │   │   │   @ ConstantReadNode (location: (11,7)-(11,8))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :A
        │   │   ├── body: ∅
        │   │   ├── end_keyword_loc: (12,0)-(12,3) = "end"
        │   │   └── name: :A
        │   ├── call_operator_loc: (12,3)-(12,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (12,4)-(12,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (13,0)-(15,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ BeginNode (location: (13,0)-(15,3))
        │   │   ├── flags: ∅
        │   │   ├── begin_keyword_loc: (13,0)-(13,5) = "begin"
        │   │   ├── statements: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (14,0)-(14,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── keyword_loc: (14,0)-(14,6) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── then_keyword_loc: ∅
        │   │   │   ├── statements: ∅
        │   │   │   └── subsequent: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause: ∅
        │   │   └── end_keyword_loc: (15,0)-(15,3) = "end"
        │   ├── call_operator_loc: (15,3)-(15,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (15,4)-(15,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (16,0)-(19,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CaseNode (location: (16,0)-(19,3))
        │   │   ├── flags: ∅
        │   │   ├── predicate:
        │   │   │   @ ParenthesesNode (location: (16,5)-(17,10))
        │   │   │   ├── flags: multiple_statements
        │   │   │   ├── body:
        │   │   │   │   @ StatementsNode (location: (16,6)-(17,9))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 2)
        │   │   │   │       ├── @ DefNode (location: (16,6)-(17,3))
        │   │   │   │       │   ├── flags: newline
        │   │   │   │       │   ├── name: :foo
        │   │   │   │       │   ├── name_loc: (16,10)-(16,13) = "foo"
        │   │   │   │       │   ├── receiver: ∅
        │   │   │   │       │   ├── parameters: ∅
        │   │   │   │       │   ├── body: ∅
        │   │   │   │       │   ├── locals: []
        │   │   │   │       │   ├── def_keyword_loc: (16,6)-(16,9) = "def"
        │   │   │   │       │   ├── operator_loc: ∅
        │   │   │   │       │   ├── lparen_loc: ∅
        │   │   │   │       │   ├── rparen_loc: ∅
        │   │   │   │       │   ├── equal_loc: ∅
        │   │   │   │       │   └── end_keyword_loc: (17,0)-(17,3) = "end"
        │   │   │   │       └── @ SymbolNode (location: (17,5)-(17,9))
        │   │   │   │           ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   │   │   │           ├── opening_loc: (17,5)-(17,6) = ":"
        │   │   │   │           ├── value_loc: (17,6)-(17,9) = "bar"
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── unescaped: "bar"
        │   │   │   ├── opening_loc: (16,5)-(16,6) = "("
        │   │   │   └── closing_loc: (17,9)-(17,10) = ")"
        │   │   ├── conditions: (length: 1)
        │   │   │   └── @ WhenNode (location: (18,0)-(18,8))
        │   │   │       ├── flags: ∅
        │   │   │       ├── keyword_loc: (18,0)-(18,4) = "when"
        │   │   │       ├── conditions: (length: 1)
        │   │   │       │   └── @ CallNode (location: (18,5)-(18,8))
        │   │   │       │       ├── flags: variable_call, ignore_visibility
        │   │   │       │       ├── receiver: ∅
        │   │   │       │       ├── call_operator_loc: ∅
        │   │   │       │       ├── name: :bar
        │   │   │       │       ├── message_loc: (18,5)-(18,8) = "bar"
        │   │   │       │       ├── opening_loc: ∅
        │   │   │       │       ├── arguments: ∅
        │   │   │       │       ├── closing_loc: ∅
        │   │   │       │       └── block: ∅
        │   │   │       ├── then_keyword_loc: ∅
        │   │   │       └── statements: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── case_keyword_loc: (16,0)-(16,4) = "case"
        │   │   └── end_keyword_loc: (19,0)-(19,3) = "end"
        │   ├── call_operator_loc: (19,3)-(19,4) = "."
        │   ├── name: :baz
        │   ├── message_loc: (19,4)-(19,7) = "baz"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (20,0)-(22,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CaseNode (location: (20,0)-(22,3))
        │   │   ├── flags: ∅
        │   │   ├── predicate:
        │   │   │   @ CallNode (location: (20,5)-(20,8))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (20,5)-(20,8) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── conditions: (length: 1)
        │   │   │   └── @ WhenNode (location: (21,0)-(21,8))
        │   │   │       ├── flags: ∅
        │   │   │       ├── keyword_loc: (21,0)-(21,4) = "when"
        │   │   │       ├── conditions: (length: 1)
        │   │   │       │   └── @ CallNode (location: (21,5)-(21,8))
        │   │   │       │       ├── flags: variable_call, ignore_visibility
        │   │   │       │       ├── receiver: ∅
        │   │   │       │       ├── call_operator_loc: ∅
        │   │   │       │       ├── name: :bar
        │   │   │       │       ├── message_loc: (21,5)-(21,8) = "bar"
        │   │   │       │       ├── opening_loc: ∅
        │   │   │       │       ├── arguments: ∅
        │   │   │       │       ├── closing_loc: ∅
        │   │   │       │       └── block: ∅
        │   │   │       ├── then_keyword_loc: ∅
        │   │   │       └── statements: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── case_keyword_loc: (20,0)-(20,4) = "case"
        │   │   └── end_keyword_loc: (22,0)-(22,3) = "end"
        │   ├── call_operator_loc: (22,3)-(22,4) = "."
        │   ├── name: :baz
        │   ├── message_loc: (22,4)-(22,7) = "baz"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (23,0)-(24,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ SingletonClassNode (location: (23,0)-(24,3))
        │   │   ├── flags: ∅
        │   │   ├── locals: []
        │   │   ├── class_keyword_loc: (23,0)-(23,5) = "class"
        │   │   ├── operator_loc: (23,6)-(23,8) = "<<"
        │   │   ├── expression:
        │   │   │   @ SelfNode (location: (23,9)-(23,13))
        │   │   │   └── flags: ∅
        │   │   ├── body: ∅
        │   │   └── end_keyword_loc: (24,0)-(24,3) = "end"
        │   ├── call_operator_loc: (24,3)-(24,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (24,4)-(24,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (25,0)-(26,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ DefNode (location: (25,0)-(26,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   ├── name_loc: (25,9)-(25,12) = "foo"
        │   │   ├── receiver:
        │   │   │   @ SelfNode (location: (25,4)-(25,8))
        │   │   │   └── flags: ∅
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── locals: []
        │   │   ├── def_keyword_loc: (25,0)-(25,3) = "def"
        │   │   ├── operator_loc: (25,8)-(25,9) = "."
        │   │   ├── lparen_loc: ∅
        │   │   ├── rparen_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── end_keyword_loc: (26,0)-(26,3) = "end"
        │   ├── call_operator_loc: (26,3)-(26,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (26,4)-(26,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (27,0)-(28,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ DefNode (location: (27,0)-(28,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   ├── name_loc: (27,4)-(27,7) = "foo"
        │   │   ├── receiver: ∅
        │   │   ├── parameters: ∅
        │   │   ├── body: ∅
        │   │   ├── locals: []
        │   │   ├── def_keyword_loc: (27,0)-(27,3) = "def"
        │   │   ├── operator_loc: ∅
        │   │   ├── lparen_loc: ∅
        │   │   ├── rparen_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── end_keyword_loc: (28,0)-(28,3) = "end"
        │   ├── call_operator_loc: (28,3)-(28,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (28,4)-(28,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (29,0)-(30,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ UntilNode (location: (29,0)-(30,3))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (29,0)-(29,5) = "until"
        │   │   ├── do_keyword_loc: ∅
        │   │   ├── closing_loc: (30,0)-(30,3) = "end"
        │   │   ├── predicate:
        │   │   │   @ CallNode (location: (29,6)-(29,9))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (29,6)-(29,9) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── statements: ∅
        │   ├── call_operator_loc: (30,3)-(30,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (30,4)-(30,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (31,0)-(32,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ WhileNode (location: (31,0)-(32,3))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (31,0)-(31,5) = "while"
        │   │   ├── do_keyword_loc: ∅
        │   │   ├── closing_loc: (32,0)-(32,3) = "end"
        │   │   ├── predicate:
        │   │   │   @ CallNode (location: (31,6)-(31,9))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (31,6)-(31,9) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── statements: ∅
        │   ├── call_operator_loc: (32,3)-(32,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (32,4)-(32,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (33,0)-(34,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (33,0)-(34,1))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :loop
        │   │   ├── message_loc: (33,0)-(33,4) = "loop"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (33,5)-(34,1))
        │   │       ├── flags: ∅
        │   │       ├── locals: []
        │   │       ├── parameters: ∅
        │   │       ├── body: ∅
        │   │       ├── opening_loc: (33,5)-(33,6) = "{"
        │   │       └── closing_loc: (34,0)-(34,1) = "}"
        │   ├── call_operator_loc: (34,1)-(34,2) = "."
        │   ├── name: :bar
        │   ├── message_loc: (34,2)-(34,5) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (35,0)-(36,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IfNode (location: (35,0)-(36,3))
        │   │   ├── flags: newline
        │   │   ├── if_keyword_loc: (35,0)-(35,2) = "if"
        │   │   ├── predicate:
        │   │   │   @ CallNode (location: (35,3)-(35,6))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (35,3)-(35,6) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements: ∅
        │   │   ├── subsequent: ∅
        │   │   └── end_keyword_loc: (36,0)-(36,3) = "end"
        │   ├── call_operator_loc: (36,3)-(36,4) = "."
        │   ├── name: :baz
        │   ├── message_loc: (36,4)-(36,7) = "baz"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (37,0)-(37,19))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (37,0)-(37,15))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (37,1)-(37,14))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (37,1)-(37,14))
        │   │   │           ├── flags: newline
        │   │   │           ├── receiver:
        │   │   │           │   @ RegularExpressionNode (location: (37,1)-(37,6))
        │   │   │           │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │           │   ├── opening_loc: (37,1)-(37,2) = "/"
        │   │   │           │   ├── content_loc: (37,2)-(37,5) = "bar"
        │   │   │           │   ├── closing_loc: (37,5)-(37,6) = "/"
        │   │   │           │   └── unescaped: "bar"
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :=~
        │   │   │           ├── message_loc: (37,7)-(37,9) = "=~"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (37,10)-(37,14))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ SymbolNode (location: (37,10)-(37,14))
        │   │   │           │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │           │           ├── opening_loc: (37,10)-(37,11) = ":"
        │   │   │           │           ├── value_loc: (37,11)-(37,14) = "foo"
        │   │   │           │           ├── closing_loc: ∅
        │   │   │           │           └── unescaped: "foo"
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── opening_loc: (37,0)-(37,1) = "("
        │   │   └── closing_loc: (37,14)-(37,15) = ")"
        │   ├── call_operator_loc: (37,15)-(37,16) = "."
        │   ├── name: :foo
        │   ├── message_loc: (37,16)-(37,19) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (38,0)-(38,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (38,0)-(38,6))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (38,1)-(38,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ RangeNode (location: (38,1)-(38,5))
        │   │   │           ├── flags: newline, static_literal
        │   │   │           ├── left:
        │   │   │           │   @ IntegerNode (location: (38,1)-(38,2))
        │   │   │           │   ├── flags: static_literal, decimal
        │   │   │           │   └── value: 1
        │   │   │           ├── right:
        │   │   │           │   @ IntegerNode (location: (38,4)-(38,5))
        │   │   │           │   ├── flags: static_literal, decimal
        │   │   │           │   └── value: 2
        │   │   │           └── operator_loc: (38,2)-(38,4) = ".."
        │   │   ├── opening_loc: (38,0)-(38,1) = "("
        │   │   └── closing_loc: (38,5)-(38,6) = ")"
        │   ├── call_operator_loc: (38,6)-(38,7) = "."
        │   ├── name: :max
        │   ├── message_loc: (38,7)-(38,10) = "max"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (39,0)-(39,18))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (39,0)-(39,14))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (39,1)-(39,13))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (39,1)-(39,13))
        │   │   │           ├── flags: newline
        │   │   │           ├── receiver:
        │   │   │           │   @ CallNode (location: (39,1)-(39,4))
        │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── name: :foo
        │   │   │           │   ├── message_loc: (39,1)-(39,4) = "foo"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── block: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :=~
        │   │   │           ├── message_loc: (39,5)-(39,7) = "=~"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (39,8)-(39,13))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ RegularExpressionNode (location: (39,8)-(39,13))
        │   │   │           │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │           │           ├── opening_loc: (39,8)-(39,9) = "/"
        │   │   │           │           ├── content_loc: (39,9)-(39,12) = "bar"
        │   │   │           │           ├── closing_loc: (39,12)-(39,13) = "/"
        │   │   │           │           └── unescaped: "bar"
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── opening_loc: (39,0)-(39,1) = "("
        │   │   └── closing_loc: (39,13)-(39,14) = ")"
        │   ├── call_operator_loc: (39,14)-(39,15) = "."
        │   ├── name: :foo
        │   ├── message_loc: (39,15)-(39,18) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (40,0)-(40,13))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RegularExpressionNode (location: (40,0)-(40,5))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (40,0)-(40,1) = "/"
        │   │   ├── content_loc: (40,1)-(40,4) = "bar"
        │   │   ├── closing_loc: (40,4)-(40,5) = "/"
        │   │   └── unescaped: "bar"
        │   ├── call_operator_loc: ∅
        │   ├── name: :=~
        │   ├── message_loc: (40,6)-(40,8) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (40,9)-(40,13))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (40,9)-(40,13))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (40,9)-(40,10) = ":"
        │   │           ├── value_loc: (40,10)-(40,13) = "foo"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "foo"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (41,0)-(41,12))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ RegularExpressionNode (location: (41,0)-(41,5))
        │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   ├── opening_loc: (41,0)-(41,1) = "/"
        │   │   ├── content_loc: (41,1)-(41,4) = "bar"
        │   │   ├── closing_loc: (41,4)-(41,5) = "/"
        │   │   └── unescaped: "bar"
        │   ├── call_operator_loc: ∅
        │   ├── name: :=~
        │   ├── message_loc: (41,6)-(41,8) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (41,9)-(41,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (41,9)-(41,12))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :foo
        │   │           ├── message_loc: (41,9)-(41,12) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ RangeNode (location: (42,0)-(42,8))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ IntegerNode (location: (42,0)-(42,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── right:
        │   │   @ CallNode (location: (42,3)-(42,8))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ IntegerNode (location: (42,3)-(42,4))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 2
        │   │   ├── call_operator_loc: (42,4)-(42,5) = "."
        │   │   ├── name: :max
        │   │   ├── message_loc: (42,5)-(42,8) = "max"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (42,1)-(42,3) = ".."
        ├── @ CallNode (location: (43,0)-(43,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (43,0)-(43,1))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── call_operator_loc: (43,1)-(43,2) = "."
        │   ├── name: :foo
        │   ├── message_loc: (43,2)-(43,5) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (44,0)-(44,5))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :FOO
        │   ├── message_loc: (44,0)-(44,3) = "FOO"
        │   ├── opening_loc: (44,3)-(44,4) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (44,4)-(44,5) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (45,0)-(45,4))
        │   ├── flags: newline, safe_navigation
        │   ├── receiver:
        │   │   @ CallNode (location: (45,0)-(45,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (45,0)-(45,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (45,1)-(45,3) = "&."
        │   ├── name: :b
        │   ├── message_loc: (45,3)-(45,4) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (46,0)-(46,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (46,0)-(46,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (46,0)-(46,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (46,1)-(46,2) = "."
        │   ├── name: :foo
        │   ├── message_loc: (46,2)-(46,5) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (47,0)-(47,3))
        │   ├── flags: newline, variable_call, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (47,0)-(47,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (48,0)-(48,18))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (48,0)-(48,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (48,0)-(48,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :<<
        │   ├── message_loc: (48,4)-(48,6) = "<<"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (48,7)-(48,18))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ParenthesesNode (location: (48,7)-(48,18))
        │   │           ├── flags: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (48,8)-(48,17))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (48,8)-(48,17))
        │   │           │           ├── flags: newline
        │   │           │           ├── receiver:
        │   │           │           │   @ CallNode (location: (48,8)-(48,11))
        │   │           │           │   ├── flags: variable_call, ignore_visibility
        │   │           │           │   ├── receiver: ∅
        │   │           │           │   ├── call_operator_loc: ∅
        │   │           │           │   ├── name: :bar
        │   │           │           │   ├── message_loc: (48,8)-(48,11) = "bar"
        │   │           │           │   ├── opening_loc: ∅
        │   │           │           │   ├── arguments: ∅
        │   │           │           │   ├── closing_loc: ∅
        │   │           │           │   └── block: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :*
        │   │           │           ├── message_loc: (48,12)-(48,13) = "*"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (48,14)-(48,17))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ CallNode (location: (48,14)-(48,17))
        │   │           │           │           ├── flags: variable_call, ignore_visibility
        │   │           │           │           ├── receiver: ∅
        │   │           │           │           ├── call_operator_loc: ∅
        │   │           │           │           ├── name: :baz
        │   │           │           │           ├── message_loc: (48,14)-(48,17) = "baz"
        │   │           │           │           ├── opening_loc: ∅
        │   │           │           │           ├── arguments: ∅
        │   │           │           │           ├── closing_loc: ∅
        │   │           │           │           └── block: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── opening_loc: (48,7)-(48,8) = "("
        │   │           └── closing_loc: (48,17)-(48,18) = ")"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (49,0)-(49,12))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (49,0)-(49,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (49,0)-(49,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :=~
        │   ├── message_loc: (49,4)-(49,6) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (49,7)-(49,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ RegularExpressionNode (location: (49,7)-(49,12))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (49,7)-(49,8) = "/"
        │   │           ├── content_loc: (49,8)-(49,11) = "bar"
        │   │           ├── closing_loc: (49,11)-(49,12) = "/"
        │   │           └── unescaped: "bar"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (50,0)-(50,18))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (50,0)-(50,3) = "foo"
        │   ├── opening_loc: (50,3)-(50,4) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (50,17)-(50,18) = ")"
        │   └── block:
        │       @ BlockArgumentNode (location: (50,4)-(50,17))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ ParenthesesNode (location: (50,5)-(50,17))
        │       │   ├── flags: ∅
        │       │   ├── body:
        │       │   │   @ StatementsNode (location: (50,6)-(50,16))
        │       │   │   ├── flags: ∅
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ OrNode (location: (50,6)-(50,16))
        │       │   │           ├── flags: newline
        │       │   │           ├── left:
        │       │   │           │   @ CallNode (location: (50,6)-(50,9))
        │       │   │           │   ├── flags: variable_call, ignore_visibility
        │       │   │           │   ├── receiver: ∅
        │       │   │           │   ├── call_operator_loc: ∅
        │       │   │           │   ├── name: :foo
        │       │   │           │   ├── message_loc: (50,6)-(50,9) = "foo"
        │       │   │           │   ├── opening_loc: ∅
        │       │   │           │   ├── arguments: ∅
        │       │   │           │   ├── closing_loc: ∅
        │       │   │           │   └── block: ∅
        │       │   │           ├── right:
        │       │   │           │   @ CallNode (location: (50,13)-(50,16))
        │       │   │           │   ├── flags: variable_call, ignore_visibility
        │       │   │           │   ├── receiver: ∅
        │       │   │           │   ├── call_operator_loc: ∅
        │       │   │           │   ├── name: :bar
        │       │   │           │   ├── message_loc: (50,13)-(50,16) = "bar"
        │       │   │           │   ├── opening_loc: ∅
        │       │   │           │   ├── arguments: ∅
        │       │   │           │   ├── closing_loc: ∅
        │       │   │           │   └── block: ∅
        │       │   │           └── operator_loc: (50,10)-(50,12) = "||"
        │       │   ├── opening_loc: (50,5)-(50,6) = "("
        │       │   └── closing_loc: (50,16)-(50,17) = ")"
        │       └── operator_loc: (50,4)-(50,5) = "&"
        ├── @ CallNode (location: (51,0)-(51,11))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (51,0)-(51,3) = "foo"
        │   ├── opening_loc: (51,3)-(51,4) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (51,10)-(51,11) = ")"
        │   └── block:
        │       @ BlockArgumentNode (location: (51,4)-(51,10))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (51,5)-(51,10))
        │       │   ├── flags: variable_call, ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :block
        │       │   ├── message_loc: (51,5)-(51,10) = "block"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       └── operator_loc: (51,4)-(51,5) = "&"
        ├── @ CallNode (location: (52,0)-(52,18))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (52,0)-(52,3) = "foo"
        │   ├── opening_loc: (52,3)-(52,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (52,4)-(52,9))
        │   │   ├── flags: contains_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (52,4)-(52,9))
        │   │           ├── flags: ∅
        │   │           ├── operator_loc: (52,4)-(52,5) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (52,5)-(52,9))
        │   │               ├── flags: variable_call, ignore_visibility
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :args
        │   │               ├── message_loc: (52,5)-(52,9) = "args"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── closing_loc: (52,17)-(52,18) = ")"
        │   └── block:
        │       @ BlockArgumentNode (location: (52,11)-(52,17))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (52,12)-(52,17))
        │       │   ├── flags: variable_call, ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :block
        │       │   ├── message_loc: (52,12)-(52,17) = "block"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       └── operator_loc: (52,11)-(52,12) = "&"
        ├── @ CallNode (location: (53,0)-(53,15))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (53,0)-(53,3) = "foo"
        │   ├── opening_loc: (53,3)-(53,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (53,4)-(53,14))
        │   │   ├── flags: contains_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (53,4)-(53,14))
        │   │           ├── flags: ∅
        │   │           ├── operator_loc: (53,4)-(53,5) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (53,5)-(53,14))
        │   │               ├── flags: variable_call, ignore_visibility
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :arguments
        │   │               ├── message_loc: (53,5)-(53,14) = "arguments"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── closing_loc: (53,14)-(53,15) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (54,0)-(54,9))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (54,0)-(54,3) = "foo"
        │   ├── opening_loc: (54,3)-(54,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (54,4)-(54,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ IntegerNode (location: (54,4)-(54,5))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 1
        │   │       └── @ IntegerNode (location: (54,7)-(54,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: (54,8)-(54,9) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (55,0)-(55,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (55,0)-(55,3) = "foo"
        │   ├── opening_loc: (55,3)-(55,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (55,4)-(55,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (55,4)-(55,7))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (55,4)-(55,7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (55,7)-(55,8) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (56,0)-(56,15))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (56,0)-(56,3) = "foo"
        │   ├── opening_loc: (56,3)-(56,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (56,4)-(56,14))
        │   │   ├── flags: contains_splat
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (56,4)-(56,7))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :bar
        │   │       │   ├── message_loc: (56,4)-(56,7) = "bar"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ SplatNode (location: (56,9)-(56,14))
        │   │           ├── flags: ∅
        │   │           ├── operator_loc: (56,9)-(56,10) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (56,10)-(56,14))
        │   │               ├── flags: variable_call, ignore_visibility
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :args
        │   │               ├── message_loc: (56,10)-(56,14) = "args"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── closing_loc: (56,14)-(56,15) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (57,0)-(57,17))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (57,0)-(57,3) = "foo"
        │   ├── opening_loc: (57,3)-(57,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (57,4)-(57,16))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (57,4)-(57,16))
        │   │           ├── flags: ∅
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (57,4)-(57,7))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :foo
        │   │           │   ├── message_loc: (57,4)-(57,7) = "foo"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :=~
        │   │           ├── message_loc: (57,8)-(57,10) = "=~"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (57,11)-(57,16))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ RegularExpressionNode (location: (57,11)-(57,16))
        │   │           │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           │           ├── opening_loc: (57,11)-(57,12) = "/"
        │   │           │           ├── content_loc: (57,12)-(57,15) = "bar"
        │   │           │           ├── closing_loc: (57,15)-(57,16) = "/"
        │   │           │           └── unescaped: "bar"
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (57,16)-(57,17) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (58,0)-(58,13))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (58,0)-(58,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (58,0)-(58,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (58,3)-(58,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (58,4)-(58,7) = "bar"
        │   ├── opening_loc: (58,7)-(58,8) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (58,12)-(58,13) = ")"
        │   └── block:
        │       @ BlockArgumentNode (location: (58,8)-(58,12))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (58,9)-(58,12))
        │       │   ├── flags: variable_call, ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :baz
        │       │   ├── message_loc: (58,9)-(58,12) = "baz"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       └── operator_loc: (58,8)-(58,9) = "&"
        ├── @ CallNode (location: (59,0)-(59,26))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (59,0)-(59,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (59,0)-(59,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (59,3)-(59,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (59,4)-(59,7) = "bar"
        │   ├── opening_loc: (59,7)-(59,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (59,8)-(59,25))
        │   │   ├── flags: contains_splat, contains_multiple_splats
        │   │   └── arguments: (length: 3)
        │   │       ├── @ SplatNode (location: (59,8)-(59,13))
        │   │       │   ├── flags: ∅
        │   │       │   ├── operator_loc: (59,8)-(59,9) = "*"
        │   │       │   └── expression:
        │   │       │       @ CallNode (location: (59,9)-(59,13))
        │   │       │       ├── flags: variable_call, ignore_visibility
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── name: :arga
        │   │       │       ├── message_loc: (59,9)-(59,13) = "arga"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── block: ∅
        │   │       ├── @ CallNode (location: (59,15)-(59,18))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :foo
        │   │       │   ├── message_loc: (59,15)-(59,18) = "foo"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ SplatNode (location: (59,20)-(59,25))
        │   │           ├── flags: ∅
        │   │           ├── operator_loc: (59,20)-(59,21) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (59,21)-(59,25))
        │   │               ├── flags: variable_call, ignore_visibility
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :argb
        │   │               ├── message_loc: (59,21)-(59,25) = "argb"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── closing_loc: (59,25)-(59,26) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (60,0)-(60,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (60,0)-(60,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (60,0)-(60,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (60,3)-(60,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (60,4)-(60,7) = "bar"
        │   ├── opening_loc: (60,7)-(60,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (60,8)-(60,13))
        │   │   ├── flags: contains_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (60,8)-(60,13))
        │   │           ├── flags: ∅
        │   │           ├── operator_loc: (60,8)-(60,9) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (60,9)-(60,13))
        │   │               ├── flags: variable_call, ignore_visibility
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :args
        │   │               ├── message_loc: (60,9)-(60,13) = "args"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── closing_loc: (60,13)-(60,14) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (61,0)-(61,19))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (61,0)-(61,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (61,0)-(61,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (61,3)-(61,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (61,4)-(61,7) = "bar"
        │   ├── opening_loc: (61,7)-(61,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (61,8)-(61,18))
        │   │   ├── flags: contains_splat
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SplatNode (location: (61,8)-(61,13))
        │   │       │   ├── flags: ∅
        │   │       │   ├── operator_loc: (61,8)-(61,9) = "*"
        │   │       │   └── expression:
        │   │       │       @ CallNode (location: (61,9)-(61,13))
        │   │       │       ├── flags: variable_call, ignore_visibility
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── name: :args
        │   │       │       ├── message_loc: (61,9)-(61,13) = "args"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── block: ∅
        │   │       └── @ CallNode (location: (61,15)-(61,18))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :foo
        │   │           ├── message_loc: (61,15)-(61,18) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (61,18)-(61,19) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (62,0)-(62,19))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (62,0)-(62,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (62,0)-(62,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (62,3)-(62,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (62,4)-(62,7) = "bar"
        │   ├── opening_loc: (62,7)-(62,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (62,8)-(62,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (62,8)-(62,12))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (62,8)-(62,9) = ":"
        │   │           ├── value_loc: (62,9)-(62,12) = "baz"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "baz"
        │   ├── closing_loc: (62,18)-(62,19) = ")"
        │   └── block:
        │       @ BlockArgumentNode (location: (62,14)-(62,18))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (62,15)-(62,18))
        │       │   ├── flags: variable_call, ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :baz
        │       │   ├── message_loc: (62,15)-(62,18) = "baz"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       └── operator_loc: (62,14)-(62,15) = "&"
        ├── @ CallNode (location: (63,0)-(63,17))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (63,0)-(63,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (63,0)-(63,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (63,3)-(63,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (63,4)-(63,7) = "bar"
        │   ├── opening_loc: (63,7)-(63,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (63,8)-(63,16))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (63,8)-(63,16))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (63,8)-(63,16))
        │   │                   ├── flags: ∅
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (63,8)-(63,12))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (63,8)-(63,11) = "baz"
        │   │                   │   ├── closing_loc: (63,11)-(63,12) = ":"
        │   │                   │   └── unescaped: "baz"
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (63,13)-(63,16))
        │   │                   │   ├── flags: variable_call, ignore_visibility
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── name: :boz
        │   │                   │   ├── message_loc: (63,13)-(63,16) = "boz"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── block: ∅
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (63,16)-(63,17) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (64,0)-(64,26))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (64,0)-(64,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (64,0)-(64,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (64,3)-(64,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (64,4)-(64,7) = "bar"
        │   ├── opening_loc: (64,7)-(64,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (64,8)-(64,25))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (64,8)-(64,11))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :foo
        │   │       │   ├── message_loc: (64,8)-(64,11) = "foo"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ KeywordHashNode (location: (64,13)-(64,25))
        │   │           ├── flags: ∅
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (64,13)-(64,25))
        │   │                   ├── flags: ∅
        │   │                   ├── key:
        │   │                   │   @ StringNode (location: (64,13)-(64,18))
        │   │                   │   ├── flags: static_literal, frozen
        │   │                   │   ├── opening_loc: (64,13)-(64,14) = "\""
        │   │                   │   ├── content_loc: (64,14)-(64,17) = "baz"
        │   │                   │   ├── closing_loc: (64,17)-(64,18) = "\""
        │   │                   │   └── unescaped: "baz"
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (64,22)-(64,25))
        │   │                   │   ├── flags: variable_call, ignore_visibility
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── name: :boz
        │   │                   │   ├── message_loc: (64,22)-(64,25) = "boz"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── block: ∅
        │   │                   └── operator_loc: (64,19)-(64,21) = "=>"
        │   ├── closing_loc: (64,25)-(64,26) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (65,0)-(65,19))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (65,0)-(65,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (65,0)-(65,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (65,3)-(65,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (65,4)-(65,7) = "bar"
        │   ├── opening_loc: (65,7)-(65,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (65,8)-(65,18))
        │   │   ├── flags: contains_splat
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (65,8)-(65,11))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :foo
        │   │       │   ├── message_loc: (65,8)-(65,11) = "foo"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ SplatNode (location: (65,13)-(65,18))
        │   │           ├── flags: ∅
        │   │           ├── operator_loc: (65,13)-(65,14) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (65,14)-(65,18))
        │   │               ├── flags: variable_call, ignore_visibility
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :args
        │   │               ├── message_loc: (65,14)-(65,18) = "args"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── closing_loc: (65,18)-(65,19) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (66,0)-(66,27))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (66,0)-(66,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (66,0)-(66,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (66,3)-(66,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (66,4)-(66,7) = "bar"
        │   ├── opening_loc: (66,7)-(66,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (66,8)-(66,18))
        │   │   ├── flags: contains_splat
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (66,8)-(66,11))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :foo
        │   │       │   ├── message_loc: (66,8)-(66,11) = "foo"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ SplatNode (location: (66,13)-(66,18))
        │   │           ├── flags: ∅
        │   │           ├── operator_loc: (66,13)-(66,14) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (66,14)-(66,18))
        │   │               ├── flags: variable_call, ignore_visibility
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :args
        │   │               ├── message_loc: (66,14)-(66,18) = "args"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── closing_loc: (66,26)-(66,27) = ")"
        │   └── block:
        │       @ BlockArgumentNode (location: (66,20)-(66,26))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (66,21)-(66,26))
        │       │   ├── flags: variable_call, ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :block
        │       │   ├── message_loc: (66,21)-(66,26) = "block"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       └── operator_loc: (66,20)-(66,21) = "&"
        ├── @ CallNode (location: (67,0)-(67,16))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (67,0)-(67,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (67,0)-(67,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (67,3)-(67,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (67,4)-(67,7) = "bar"
        │   ├── opening_loc: (67,7)-(67,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (67,8)-(67,15))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (67,8)-(67,11))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :foo
        │   │       │   ├── message_loc: (67,8)-(67,11) = "foo"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ HashNode (location: (67,13)-(67,15))
        │   │           ├── flags: static_literal
        │   │           ├── opening_loc: (67,13)-(67,14) = "{"
        │   │           ├── elements: (length: 0)
        │   │           └── closing_loc: (67,14)-(67,15) = "}"
        │   ├── closing_loc: (67,15)-(67,16) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (68,0)-(68,26))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (68,0)-(68,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (68,0)-(68,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (68,3)-(68,4) = "."
        │   ├── name: :bar
        │   ├── message_loc: (68,4)-(68,7) = "bar"
        │   ├── opening_loc: (68,7)-(68,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (68,8)-(68,25))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ HashNode (location: (68,8)-(68,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (68,8)-(68,9) = "{"
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (68,10)-(68,18))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (68,10)-(68,14))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (68,10)-(68,13) = "foo"
        │   │       │   │       │   ├── closing_loc: (68,13)-(68,14) = ":"
        │   │       │   │       │   └── unescaped: "foo"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ CallNode (location: (68,15)-(68,18))
        │   │       │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   │       │   ├── receiver: ∅
        │   │       │   │       │   ├── call_operator_loc: ∅
        │   │       │   │       │   ├── name: :boz
        │   │       │   │       │   ├── message_loc: (68,15)-(68,18) = "boz"
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── arguments: ∅
        │   │       │   │       │   ├── closing_loc: ∅
        │   │       │   │       │   └── block: ∅
        │   │       │   │       └── operator_loc: ∅
        │   │       │   └── closing_loc: (68,19)-(68,20) = "}"
        │   │       └── @ CallNode (location: (68,22)-(68,25))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :boz
        │   │           ├── message_loc: (68,22)-(68,25) = "boz"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (68,25)-(68,26) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (69,0)-(69,12))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ CallNode (location: (69,0)-(69,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (69,0)-(69,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (69,3)-(69,4) = "."
        │   ├── name: :bar=
        │   ├── message_loc: (69,4)-(69,7) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (69,8)-(69,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (69,8)-(69,12))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (69,8)-(69,9) = ":"
        │   │           ├── value_loc: (69,9)-(69,12) = "baz"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "baz"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (70,0)-(70,9))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (70,0)-(70,3) = "foo"
        │   ├── opening_loc: (70,3)-(70,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (70,4)-(70,8))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (70,4)-(70,8))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (70,4)-(70,8))
        │   │                   ├── flags: ∅
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (70,4)-(70,6))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (70,4)-(70,5) = "a"
        │   │                   │   ├── closing_loc: (70,5)-(70,6) = ":"
        │   │                   │   └── unescaped: "a"
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (70,7)-(70,8))
        │   │                   │   ├── flags: variable_call, ignore_visibility
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── name: :b
        │   │                   │   ├── message_loc: (70,7)-(70,8) = "b"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── block: ∅
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (70,8)-(70,9) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (71,0)-(71,11))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (71,0)-(71,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (71,0)-(71,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (71,3)-(71,4) = "."
        │   ├── name: :&
        │   ├── message_loc: (71,4)-(71,5) = "&"
        │   ├── opening_loc: (71,5)-(71,6) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (71,6)-(71,10))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (71,6)-(71,10))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (71,6)-(71,10))
        │   │                   ├── flags: ∅
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (71,6)-(71,8))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (71,6)-(71,7) = "a"
        │   │                   │   ├── closing_loc: (71,7)-(71,8) = ":"
        │   │                   │   └── unescaped: "a"
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (71,9)-(71,10))
        │   │                   │   ├── flags: variable_call, ignore_visibility
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── name: :b
        │   │                   │   ├── message_loc: (71,9)-(71,10) = "b"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── block: ∅
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: (71,10)-(71,11) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (72,0)-(72,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (72,0)-(72,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (72,0)-(72,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (72,3)-(72,4) = "."
        │   ├── name: :&
        │   ├── message_loc: (72,4)-(72,5) = "&"
        │   ├── opening_loc: (72,5)-(72,6) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (72,6)-(72,9))
        │   │   ├── flags: contains_keywords, contains_keyword_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (72,6)-(72,9))
        │   │           ├── flags: ∅
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocSplatNode (location: (72,6)-(72,9))
        │   │                   ├── flags: ∅
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (72,8)-(72,9))
        │   │                   │   ├── flags: variable_call, ignore_visibility
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── name: :a
        │   │                   │   ├── message_loc: (72,8)-(72,9) = "a"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── block: ∅
        │   │                   └── operator_loc: (72,6)-(72,8) = "**"
        │   ├── closing_loc: (72,9)-(72,10) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (73,0)-(73,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (73,0)-(73,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (73,0)-(73,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]
        │   ├── message_loc: (73,3)-(73,9) = "[*baz]"
        │   ├── opening_loc: (73,3)-(73,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (73,4)-(73,8))
        │   │   ├── flags: contains_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (73,4)-(73,8))
        │   │           ├── flags: ∅
        │   │           ├── operator_loc: (73,4)-(73,5) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (73,5)-(73,8))
        │   │               ├── flags: variable_call, ignore_visibility
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── name: :baz
        │   │               ├── message_loc: (73,5)-(73,8) = "baz"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               └── block: ∅
        │   ├── closing_loc: (73,8)-(73,9) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (74,0)-(74,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (74,0)-(74,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (74,0)-(74,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]
        │   ├── message_loc: (74,3)-(74,9) = "[1, 2]"
        │   ├── opening_loc: (74,3)-(74,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (74,4)-(74,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ IntegerNode (location: (74,4)-(74,5))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 1
        │   │       └── @ IntegerNode (location: (74,7)-(74,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: (74,8)-(74,9) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (75,0)-(75,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (75,0)-(75,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (75,0)-(75,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]
        │   ├── message_loc: (75,3)-(75,5) = "[]"
        │   ├── opening_loc: (75,3)-(75,4) = "["
        │   ├── arguments: ∅
        │   ├── closing_loc: (75,4)-(75,5) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (76,0)-(76,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver:
        │   │   @ SelfNode (location: (76,0)-(76,4))
        │   │   └── flags: ∅
        │   ├── call_operator_loc: (76,4)-(76,5) = "."
        │   ├── name: :foo
        │   ├── message_loc: (76,5)-(76,8) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (77,0)-(77,13))
        │   ├── flags: newline, attribute_write, ignore_visibility
        │   ├── receiver:
        │   │   @ SelfNode (location: (77,0)-(77,4))
        │   │   └── flags: ∅
        │   ├── call_operator_loc: (77,4)-(77,5) = "."
        │   ├── name: :foo=
        │   ├── message_loc: (77,5)-(77,8) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (77,9)-(77,13))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ SymbolNode (location: (77,9)-(77,13))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (77,9)-(77,10) = ":"
        │   │           ├── value_loc: (77,10)-(77,13) = "bar"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "bar"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (78,0)-(78,17))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (78,0)-(78,7))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (78,1)-(78,6))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (78,1)-(78,6))
        │   │   │           ├── flags: newline
        │   │   │           ├── receiver:
        │   │   │           │   @ CallNode (location: (78,1)-(78,2))
        │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── name: :a
        │   │   │           │   ├── message_loc: (78,1)-(78,2) = "a"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── block: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :+
        │   │   │           ├── message_loc: (78,3)-(78,4) = "+"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (78,5)-(78,6))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ CallNode (location: (78,5)-(78,6))
        │   │   │           │           ├── flags: variable_call, ignore_visibility
        │   │   │           │           ├── receiver: ∅
        │   │   │           │           ├── call_operator_loc: ∅
        │   │   │           │           ├── name: :b
        │   │   │           │           ├── message_loc: (78,5)-(78,6) = "b"
        │   │   │           │           ├── opening_loc: ∅
        │   │   │           │           ├── arguments: ∅
        │   │   │           │           ├── closing_loc: ∅
        │   │   │           │           └── block: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── opening_loc: (78,0)-(78,1) = "("
        │   │   └── closing_loc: (78,6)-(78,7) = ")"
        │   ├── call_operator_loc: ∅
        │   ├── name: :/
        │   ├── message_loc: (78,8)-(78,9) = "/"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (78,10)-(78,17))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ParenthesesNode (location: (78,10)-(78,17))
        │   │           ├── flags: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (78,11)-(78,16))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (78,11)-(78,16))
        │   │           │           ├── flags: newline
        │   │           │           ├── receiver:
        │   │           │           │   @ CallNode (location: (78,11)-(78,12))
        │   │           │           │   ├── flags: variable_call, ignore_visibility
        │   │           │           │   ├── receiver: ∅
        │   │           │           │   ├── call_operator_loc: ∅
        │   │           │           │   ├── name: :c
        │   │           │           │   ├── message_loc: (78,11)-(78,12) = "c"
        │   │           │           │   ├── opening_loc: ∅
        │   │           │           │   ├── arguments: ∅
        │   │           │           │   ├── closing_loc: ∅
        │   │           │           │   └── block: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :-
        │   │           │           ├── message_loc: (78,13)-(78,14) = "-"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (78,15)-(78,16))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ CallNode (location: (78,15)-(78,16))
        │   │           │           │           ├── flags: variable_call, ignore_visibility
        │   │           │           │           ├── receiver: ∅
        │   │           │           │           ├── call_operator_loc: ∅
        │   │           │           │           ├── name: :d
        │   │           │           │           ├── message_loc: (78,15)-(78,16) = "d"
        │   │           │           │           ├── opening_loc: ∅
        │   │           │           │           ├── arguments: ∅
        │   │           │           │           ├── closing_loc: ∅
        │   │           │           │           └── block: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── opening_loc: (78,10)-(78,11) = "("
        │   │           └── closing_loc: (78,16)-(78,17) = ")"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (79,0)-(79,19))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (79,0)-(79,7))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (79,1)-(79,6))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (79,1)-(79,6))
        │   │   │           ├── flags: newline
        │   │   │           ├── receiver:
        │   │   │           │   @ CallNode (location: (79,1)-(79,2))
        │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── name: :a
        │   │   │           │   ├── message_loc: (79,1)-(79,2) = "a"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── block: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :+
        │   │   │           ├── message_loc: (79,3)-(79,4) = "+"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (79,5)-(79,6))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ CallNode (location: (79,5)-(79,6))
        │   │   │           │           ├── flags: variable_call, ignore_visibility
        │   │   │           │           ├── receiver: ∅
        │   │   │           │           ├── call_operator_loc: ∅
        │   │   │           │           ├── name: :b
        │   │   │           │           ├── message_loc: (79,5)-(79,6) = "b"
        │   │   │           │           ├── opening_loc: ∅
        │   │   │           │           ├── arguments: ∅
        │   │   │           │           ├── closing_loc: ∅
        │   │   │           │           └── block: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── opening_loc: (79,0)-(79,1) = "("
        │   │   └── closing_loc: (79,6)-(79,7) = ")"
        │   ├── call_operator_loc: ∅
        │   ├── name: :/
        │   ├── message_loc: (79,8)-(79,9) = "/"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (79,10)-(79,19))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (79,10)-(79,19))
        │   │           ├── flags: ∅
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (79,10)-(79,11))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :c
        │   │           │   ├── message_loc: (79,10)-(79,11) = "c"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: (79,11)-(79,12) = "."
        │   │           ├── name: :-
        │   │           ├── message_loc: (79,12)-(79,13) = "-"
        │   │           ├── opening_loc: (79,13)-(79,14) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (79,14)-(79,18))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 2)
        │   │           │       ├── @ CallNode (location: (79,14)-(79,15))
        │   │           │       │   ├── flags: variable_call, ignore_visibility
        │   │           │       │   ├── receiver: ∅
        │   │           │       │   ├── call_operator_loc: ∅
        │   │           │       │   ├── name: :e
        │   │           │       │   ├── message_loc: (79,14)-(79,15) = "e"
        │   │           │       │   ├── opening_loc: ∅
        │   │           │       │   ├── arguments: ∅
        │   │           │       │   ├── closing_loc: ∅
        │   │           │       │   └── block: ∅
        │   │           │       └── @ CallNode (location: (79,17)-(79,18))
        │   │           │           ├── flags: variable_call, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :f
        │   │           │           ├── message_loc: (79,17)-(79,18) = "f"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── closing_loc: (79,18)-(79,19) = ")"
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (80,0)-(80,17))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (80,0)-(80,7))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (80,1)-(80,6))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (80,1)-(80,6))
        │   │   │           ├── flags: newline
        │   │   │           ├── receiver:
        │   │   │           │   @ CallNode (location: (80,1)-(80,2))
        │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── name: :a
        │   │   │           │   ├── message_loc: (80,1)-(80,2) = "a"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── block: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :+
        │   │   │           ├── message_loc: (80,3)-(80,4) = "+"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (80,5)-(80,6))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ CallNode (location: (80,5)-(80,6))
        │   │   │           │           ├── flags: variable_call, ignore_visibility
        │   │   │           │           ├── receiver: ∅
        │   │   │           │           ├── call_operator_loc: ∅
        │   │   │           │           ├── name: :b
        │   │   │           │           ├── message_loc: (80,5)-(80,6) = "b"
        │   │   │           │           ├── opening_loc: ∅
        │   │   │           │           ├── arguments: ∅
        │   │   │           │           ├── closing_loc: ∅
        │   │   │           │           └── block: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── opening_loc: (80,0)-(80,1) = "("
        │   │   └── closing_loc: (80,6)-(80,7) = ")"
        │   ├── call_operator_loc: ∅
        │   ├── name: :/
        │   ├── message_loc: (80,8)-(80,9) = "/"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (80,10)-(80,17))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (80,10)-(80,17))
        │   │           ├── flags: ∅
        │   │           ├── receiver:
        │   │           │   @ CallNode (location: (80,10)-(80,11))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :c
        │   │           │   ├── message_loc: (80,10)-(80,11) = "c"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── call_operator_loc: (80,11)-(80,12) = "."
        │   │           ├── name: :-
        │   │           ├── message_loc: (80,12)-(80,13) = "-"
        │   │           ├── opening_loc: (80,13)-(80,14) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (80,14)-(80,16))
        │   │           │   ├── flags: contains_splat
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ SplatNode (location: (80,14)-(80,16))
        │   │           │           ├── flags: ∅
        │   │           │           ├── operator_loc: (80,14)-(80,15) = "*"
        │   │           │           └── expression:
        │   │           │               @ CallNode (location: (80,15)-(80,16))
        │   │           │               ├── flags: variable_call, ignore_visibility
        │   │           │               ├── receiver: ∅
        │   │           │               ├── call_operator_loc: ∅
        │   │           │               ├── name: :f
        │   │           │               ├── message_loc: (80,15)-(80,16) = "f"
        │   │           │               ├── opening_loc: ∅
        │   │           │               ├── arguments: ∅
        │   │           │               ├── closing_loc: ∅
        │   │           │               └── block: ∅
        │   │           ├── closing_loc: (80,16)-(80,17) = ")"
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (81,0)-(81,8))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :x
        │   ├── message_loc: (81,0)-(81,1) = "x"
        │   ├── opening_loc: (81,1)-(81,2) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (81,2)-(81,7))
        │   │   ├── flags: contains_keywords, contains_keyword_splat
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (81,2)-(81,7))
        │   │           ├── flags: ∅
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocSplatNode (location: (81,2)-(81,7))
        │   │                   ├── flags: ∅
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (81,4)-(81,7))
        │   │                   │   ├── flags: variable_call, ignore_visibility
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── name: :foo
        │   │                   │   ├── message_loc: (81,4)-(81,7) = "foo"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   └── block: ∅
        │   │                   └── operator_loc: (81,2)-(81,4) = "**"
        │   ├── closing_loc: (81,7)-(81,8) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (82,0)-(82,6))
        │   ├── flags: newline, safe_navigation
        │   ├── receiver:
        │   │   @ CallNode (location: (82,0)-(82,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (82,0)-(82,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (82,3)-(82,5) = "&."
        │   ├── name: :!
        │   ├── message_loc: (82,5)-(82,6) = "!"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (83,0)-(83,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (83,0)-(83,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (83,0)-(83,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (83,3)-(83,4) = "."
        │   ├── name: :~
        │   ├── message_loc: (83,4)-(83,5) = "~"
        │   ├── opening_loc: (83,5)-(83,6) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (83,6)-(83,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (83,6)-(83,7))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (83,6)-(83,7) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (83,7)-(83,8) = ")"
        │   └── block: ∅
        └── @ CallNode (location: (84,0)-(84,7))
            ├── flags: newline, safe_navigation
            ├── receiver:
            │   @ CallNode (location: (84,0)-(84,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (84,0)-(84,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (84,1)-(84,3) = "&."
            ├── name: :+
            ├── message_loc: (84,3)-(84,4) = "+"
            ├── opening_loc: (84,4)-(84,5) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (84,5)-(84,6))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ CallNode (location: (84,5)-(84,6))
            │           ├── flags: variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :b
            │           ├── message_loc: (84,5)-(84,6) = "b"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── closing_loc: (84,6)-(84,7) = ")"
            └── block: ∅
prism-1.5.1/snapshots/unparser/corpus/literal/since/000077500000000000000000000000001506127434000226035ustar00rootroot00000000000000prism-1.5.1/snapshots/unparser/corpus/literal/since/27.txt000066400000000000000000000056261506127434000236050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,5))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ LambdaNode (location: (1,0)-(3,1))
        │   ├── flags: newline
        │   ├── locals: [:_1, :_2]
        │   ├── operator_loc: (1,0)-(1,2) = "->"
        │   ├── opening_loc: (1,3)-(1,4) = "{"
        │   ├── closing_loc: (3,0)-(3,1) = "}"
        │   ├── parameters:
        │   │   @ NumberedParametersNode (location: (1,0)-(3,1))
        │   │   ├── flags: ∅
        │   │   └── maximum: 2
        │   └── body:
        │       @ StatementsNode (location: (2,2)-(2,9))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ CallNode (location: (2,2)-(2,9))
        │               ├── flags: newline
        │               ├── receiver:
        │               │   @ LocalVariableReadNode (location: (2,2)-(2,4))
        │               │   ├── flags: ∅
        │               │   ├── name: :_1
        │               │   └── depth: 0
        │               ├── call_operator_loc: ∅
        │               ├── name: :+
        │               ├── message_loc: (2,5)-(2,6) = "+"
        │               ├── opening_loc: ∅
        │               ├── arguments:
        │               │   @ ArgumentsNode (location: (2,7)-(2,9))
        │               │   ├── flags: ∅
        │               │   └── arguments: (length: 1)
        │               │       └── @ LocalVariableReadNode (location: (2,7)-(2,9))
        │               │           ├── flags: ∅
        │               │           ├── name: :_2
        │               │           └── depth: 0
        │               ├── closing_loc: ∅
        │               └── block: ∅
        └── @ ParenthesesNode (location: (4,0)-(4,5))
            ├── flags: newline
            ├── body:
            │   @ StatementsNode (location: (4,1)-(4,4))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ RangeNode (location: (4,1)-(4,4))
            │           ├── flags: newline, static_literal
            │           ├── left: ∅
            │           ├── right:
            │           │   @ IntegerNode (location: (4,3)-(4,4))
            │           │   ├── flags: static_literal, decimal
            │           │   └── value: 1
            │           └── operator_loc: (4,1)-(4,3) = ".."
            ├── opening_loc: (4,0)-(4,1) = "("
            └── closing_loc: (4,4)-(4,5) = ")"
prism-1.5.1/snapshots/unparser/corpus/literal/since/30.txt000066400000000000000000000123351506127434000235720ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,17))
├── flags: ∅
├── locals: [:a, :foo]
└── statements:
    @ StatementsNode (location: (1,0)-(4,17))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ MatchRequiredNode (location: (1,0)-(1,8))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ IntegerNode (location: (1,0)-(1,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1,5)-(1,8))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1,6)-(1,7))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1,5)-(1,6) = "["
        │   │   └── closing_loc: (1,7)-(1,8) = "]"
        │   └── operator_loc: (1,2)-(1,4) = "=>"
        ├── @ MatchRequiredNode (location: (2,0)-(2,8))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ IntegerNode (location: (2,0)-(2,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (2,5)-(2,8))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── rest:
        │   │   │   @ SplatNode (location: (2,6)-(2,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (2,6)-(2,7) = "*"
        │   │   │   └── expression: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (2,5)-(2,6) = "["
        │   │   └── closing_loc: (2,7)-(2,8) = "]"
        │   └── operator_loc: (2,2)-(2,4) = "=>"
        ├── @ MatchPredicateNode (location: (3,0)-(3,15))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ IntegerNode (location: (3,0)-(3,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── pattern:
        │   │   @ FindPatternNode (location: (3,5)-(3,15))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── left:
        │   │   │   @ SplatNode (location: (3,6)-(3,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (3,6)-(3,7) = "*"
        │   │   │   └── expression: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ IntegerNode (location: (3,9)-(3,11))
        │   │   │       ├── flags: static_literal, decimal
        │   │   │       └── value: 42
        │   │   ├── right:
        │   │   │   @ SplatNode (location: (3,13)-(3,14))
        │   │   │   ├── flags: ∅
        │   │   │   ├── operator_loc: (3,13)-(3,14) = "*"
        │   │   │   └── expression: ∅
        │   │   ├── opening_loc: (3,5)-(3,6) = "["
        │   │   └── closing_loc: (3,14)-(3,15) = "]"
        │   └── operator_loc: (3,2)-(3,4) = "in"
        └── @ MatchPredicateNode (location: (4,0)-(4,17))
            ├── flags: newline
            ├── value:
            │   @ IntegerNode (location: (4,0)-(4,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── pattern:
            │   @ FindPatternNode (location: (4,5)-(4,17))
            │   ├── flags: ∅
            │   ├── constant: ∅
            │   ├── left:
            │   │   @ SplatNode (location: (4,6)-(4,7))
            │   │   ├── flags: ∅
            │   │   ├── operator_loc: (4,6)-(4,7) = "*"
            │   │   └── expression: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ LocalVariableTargetNode (location: (4,9)-(4,10))
            │   │       ├── flags: ∅
            │   │       ├── name: :a
            │   │       └── depth: 0
            │   ├── right:
            │   │   @ SplatNode (location: (4,12)-(4,16))
            │   │   ├── flags: ∅
            │   │   ├── operator_loc: (4,12)-(4,13) = "*"
            │   │   └── expression:
            │   │       @ LocalVariableTargetNode (location: (4,13)-(4,16))
            │   │       ├── flags: ∅
            │   │       ├── name: :foo
            │   │       └── depth: 0
            │   ├── opening_loc: (4,5)-(4,6) = "["
            │   └── closing_loc: (4,16)-(4,17) = "]"
            └── operator_loc: (4,2)-(4,4) = "in"
prism-1.5.1/snapshots/unparser/corpus/literal/since/31.txt000066400000000000000000000116321506127434000235720ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(7,3))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ DefNode (location: (1,0)-(3,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (1,4)-(1,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (1,8)-(1,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block:
        │   │       @ BlockParameterNode (location: (1,8)-(1,9))
        │   │       ├── flags: ∅
        │   │       ├── name: ∅
        │   │       ├── name_loc: ∅
        │   │       └── operator_loc: (1,8)-(1,9) = "&"
        │   ├── body:
        │   │   @ StatementsNode (location: (2,2)-(2,8))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (2,2)-(2,8))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (2,2)-(2,5) = "bar"
        │   │           ├── opening_loc: (2,5)-(2,6) = "("
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: (2,7)-(2,8) = ")"
        │   │           └── block:
        │   │               @ BlockArgumentNode (location: (2,6)-(2,7))
        │   │               ├── flags: ∅
        │   │               ├── expression: ∅
        │   │               └── operator_loc: (2,6)-(2,7) = "&"
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (1,7)-(1,8) = "("
        │   ├── rparen_loc: (1,9)-(1,10) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (3,0)-(3,3) = "end"
        └── @ DefNode (location: (5,0)-(7,3))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (5,4)-(5,7) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (5,8)-(5,12))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (5,8)-(5,9))
            │   │       ├── flags: ∅
            │   │       └── name: :a
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block:
            │       @ BlockParameterNode (location: (5,11)-(5,12))
            │       ├── flags: ∅
            │       ├── name: ∅
            │       ├── name_loc: ∅
            │       └── operator_loc: (5,11)-(5,12) = "&"
            ├── body:
            │   @ StatementsNode (location: (6,2)-(6,8))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (6,2)-(6,8))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (6,2)-(6,5) = "bar"
            │           ├── opening_loc: (6,5)-(6,6) = "("
            │           ├── arguments: ∅
            │           ├── closing_loc: (6,7)-(6,8) = ")"
            │           └── block:
            │               @ BlockArgumentNode (location: (6,6)-(6,7))
            │               ├── flags: ∅
            │               ├── expression: ∅
            │               └── operator_loc: (6,6)-(6,7) = "&"
            ├── locals: [:a]
            ├── def_keyword_loc: (5,0)-(5,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (5,7)-(5,8) = "("
            ├── rparen_loc: (5,12)-(5,13) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (7,0)-(7,3) = "end"
prism-1.5.1/snapshots/unparser/corpus/literal/since/32.txt000066400000000000000000000232261506127434000235750ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(11,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(11,3))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ DefNode (location: (1,0)-(3,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (1,4)-(1,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (1,8)-(1,20))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (1,8)-(1,16))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :argument
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ KeywordRestParameterNode (location: (1,18)-(1,20))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (1,18)-(1,20) = "**"
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (2,2)-(2,19))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (2,2)-(2,19))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (2,2)-(2,5) = "bar"
        │   │           ├── opening_loc: (2,5)-(2,6) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (2,6)-(2,18))
        │   │           │   ├── flags: contains_keywords, contains_keyword_splat
        │   │           │   └── arguments: (length: 2)
        │   │           │       ├── @ LocalVariableReadNode (location: (2,6)-(2,14))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── name: :argument
        │   │           │       │   └── depth: 0
        │   │           │       └── @ KeywordHashNode (location: (2,16)-(2,18))
        │   │           │           ├── flags: ∅
        │   │           │           └── elements: (length: 1)
        │   │           │               └── @ AssocSplatNode (location: (2,16)-(2,18))
        │   │           │                   ├── flags: ∅
        │   │           │                   ├── value: ∅
        │   │           │                   └── operator_loc: (2,16)-(2,18) = "**"
        │   │           ├── closing_loc: (2,18)-(2,19) = ")"
        │   │           └── block: ∅
        │   ├── locals: [:argument]
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (1,7)-(1,8) = "("
        │   ├── rparen_loc: (1,20)-(1,21) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (3,0)-(3,3) = "end"
        ├── @ DefNode (location: (5,0)-(7,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (5,4)-(5,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (5,8)-(5,19))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (5,8)-(5,16))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :argument
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest:
        │   │   │   @ RestParameterNode (location: (5,18)-(5,19))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: ∅
        │   │   │   ├── name_loc: ∅
        │   │   │   └── operator_loc: (5,18)-(5,19) = "*"
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (6,2)-(6,18))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (6,2)-(6,18))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (6,2)-(6,5) = "bar"
        │   │           ├── opening_loc: (6,5)-(6,6) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (6,6)-(6,17))
        │   │           │   ├── flags: contains_splat
        │   │           │   └── arguments: (length: 2)
        │   │           │       ├── @ LocalVariableReadNode (location: (6,6)-(6,14))
        │   │           │       │   ├── flags: ∅
        │   │           │       │   ├── name: :argument
        │   │           │       │   └── depth: 0
        │   │           │       └── @ SplatNode (location: (6,16)-(6,17))
        │   │           │           ├── flags: ∅
        │   │           │           ├── operator_loc: (6,16)-(6,17) = "*"
        │   │           │           └── expression: ∅
        │   │           ├── closing_loc: (6,17)-(6,18) = ")"
        │   │           └── block: ∅
        │   ├── locals: [:argument]
        │   ├── def_keyword_loc: (5,0)-(5,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (5,7)-(5,8) = "("
        │   ├── rparen_loc: (5,19)-(5,20) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (7,0)-(7,3) = "end"
        └── @ DefNode (location: (9,0)-(11,3))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (9,4)-(9,7) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (9,8)-(9,10))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ KeywordRestParameterNode (location: (9,8)-(9,10))
            │   │   ├── flags: ∅
            │   │   ├── name: ∅
            │   │   ├── name_loc: ∅
            │   │   └── operator_loc: (9,8)-(9,10) = "**"
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (10,2)-(10,20))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ HashNode (location: (10,2)-(10,20))
            │           ├── flags: newline
            │           ├── opening_loc: (10,2)-(10,3) = "{"
            │           ├── elements: (length: 2)
            │           │   ├── @ AssocNode (location: (10,4)-(10,14))
            │           │   │   ├── flags: static_literal
            │           │   │   ├── key:
            │           │   │   │   @ SymbolNode (location: (10,4)-(10,12))
            │           │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │           │   │   │   ├── opening_loc: ∅
            │           │   │   │   ├── value_loc: (10,4)-(10,11) = "default"
            │           │   │   │   ├── closing_loc: (10,11)-(10,12) = ":"
            │           │   │   │   └── unescaped: "default"
            │           │   │   ├── value:
            │           │   │   │   @ IntegerNode (location: (10,13)-(10,14))
            │           │   │   │   ├── flags: static_literal, decimal
            │           │   │   │   └── value: 1
            │           │   │   └── operator_loc: ∅
            │           │   └── @ AssocSplatNode (location: (10,16)-(10,18))
            │           │       ├── flags: ∅
            │           │       ├── value: ∅
            │           │       └── operator_loc: (10,16)-(10,18) = "**"
            │           └── closing_loc: (10,19)-(10,20) = "}"
            ├── locals: []
            ├── def_keyword_loc: (9,0)-(9,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (9,7)-(9,8) = "("
            ├── rparen_loc: (9,10)-(9,11) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (11,0)-(11,3) = "end"
prism-1.5.1/snapshots/unparser/corpus/literal/singletons.txt000066400000000000000000000011521506127434000244270ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(4,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(4,4))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ FalseNode (location: (1,0)-(1,5))
        │   └── flags: newline, static_literal
        ├── @ NilNode (location: (2,0)-(2,3))
        │   └── flags: newline, static_literal
        ├── @ SelfNode (location: (3,0)-(3,4))
        │   └── flags: newline
        └── @ TrueNode (location: (4,0)-(4,4))
            └── flags: newline, static_literal
prism-1.5.1/snapshots/unparser/corpus/literal/super.txt000066400000000000000000000402411506127434000234020ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(21,1))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(21,1))
    ├── flags: ∅
    └── body: (length: 11)
        ├── @ ForwardingSuperNode (location: (1,0)-(1,5))
        │   ├── flags: newline
        │   └── block: ∅
        ├── @ SuperNode (location: (2,0)-(2,7))
        │   ├── flags: newline
        │   ├── keyword_loc: (2,0)-(2,5) = "super"
        │   ├── lparen_loc: (2,5)-(2,6) = "("
        │   ├── arguments: ∅
        │   ├── rparen_loc: (2,6)-(2,7) = ")"
        │   └── block: ∅
        ├── @ SuperNode (location: (3,0)-(3,8))
        │   ├── flags: newline
        │   ├── keyword_loc: (3,0)-(3,5) = "super"
        │   ├── lparen_loc: (3,5)-(3,6) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,6)-(3,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (3,6)-(3,7))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (3,6)-(3,7) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rparen_loc: (3,7)-(3,8) = ")"
        │   └── block: ∅
        ├── @ SuperNode (location: (4,0)-(4,11))
        │   ├── flags: newline
        │   ├── keyword_loc: (4,0)-(4,5) = "super"
        │   ├── lparen_loc: (4,5)-(4,6) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (4,6)-(4,10))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (4,6)-(4,7))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :a
        │   │       │   ├── message_loc: (4,6)-(4,7) = "a"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (4,9)-(4,10))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :b
        │   │           ├── message_loc: (4,9)-(4,10) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rparen_loc: (4,10)-(4,11) = ")"
        │   └── block: ∅
        ├── @ SuperNode (location: (5,0)-(5,13))
        │   ├── flags: newline
        │   ├── keyword_loc: (5,0)-(5,5) = "super"
        │   ├── lparen_loc: (5,5)-(5,6) = "("
        │   ├── arguments: ∅
        │   ├── rparen_loc: (5,12)-(5,13) = ")"
        │   └── block:
        │       @ BlockArgumentNode (location: (5,6)-(5,12))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (5,7)-(5,12))
        │       │   ├── flags: variable_call, ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :block
        │       │   ├── message_loc: (5,7)-(5,12) = "block"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       └── operator_loc: (5,6)-(5,7) = "&"
        ├── @ SuperNode (location: (6,0)-(6,16))
        │   ├── flags: newline
        │   ├── keyword_loc: (6,0)-(6,5) = "super"
        │   ├── lparen_loc: (6,5)-(6,6) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (6,6)-(6,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (6,6)-(6,7))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (6,6)-(6,7) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rparen_loc: (6,15)-(6,16) = ")"
        │   └── block:
        │       @ BlockArgumentNode (location: (6,9)-(6,15))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (6,10)-(6,15))
        │       │   ├── flags: variable_call, ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :block
        │       │   ├── message_loc: (6,10)-(6,15) = "block"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       └── operator_loc: (6,9)-(6,10) = "&"
        ├── @ SuperNode (location: (7,0)-(9,2))
        │   ├── flags: newline
        │   ├── keyword_loc: (7,0)-(7,5) = "super"
        │   ├── lparen_loc: (7,5)-(7,6) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (7,6)-(9,1))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (7,6)-(9,1))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (7,6)-(7,7) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (7,8)-(9,1))
        │   │               ├── flags: ∅
        │   │               ├── locals: []
        │   │               ├── parameters: ∅
        │   │               ├── body:
        │   │               │   @ StatementsNode (location: (8,2)-(8,5))
        │   │               │   ├── flags: ∅
        │   │               │   └── body: (length: 1)
        │   │               │       └── @ CallNode (location: (8,2)-(8,5))
        │   │               │           ├── flags: newline, variable_call, ignore_visibility
        │   │               │           ├── receiver: ∅
        │   │               │           ├── call_operator_loc: ∅
        │   │               │           ├── name: :foo
        │   │               │           ├── message_loc: (8,2)-(8,5) = "foo"
        │   │               │           ├── opening_loc: ∅
        │   │               │           ├── arguments: ∅
        │   │               │           ├── closing_loc: ∅
        │   │               │           └── block: ∅
        │   │               ├── opening_loc: (7,8)-(7,9) = "{"
        │   │               └── closing_loc: (9,0)-(9,1) = "}"
        │   ├── rparen_loc: (9,1)-(9,2) = ")"
        │   └── block: ∅
        ├── @ ForwardingSuperNode (location: (10,0)-(12,1))
        │   ├── flags: newline
        │   └── block:
        │       @ BlockNode (location: (10,6)-(12,1))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (11,2)-(11,5))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (11,2)-(11,5))
        │       │           ├── flags: newline, variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :foo
        │       │           ├── message_loc: (11,2)-(11,5) = "foo"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (10,6)-(10,7) = "{"
        │       └── closing_loc: (12,0)-(12,1) = "}"
        ├── @ SuperNode (location: (13,0)-(15,1))
        │   ├── flags: newline
        │   ├── keyword_loc: (13,0)-(13,5) = "super"
        │   ├── lparen_loc: (13,5)-(13,6) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (13,6)-(13,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (13,6)-(13,7))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (13,6)-(13,7) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rparen_loc: (13,7)-(13,8) = ")"
        │   └── block:
        │       @ BlockNode (location: (13,9)-(15,1))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (14,2)-(14,5))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (14,2)-(14,5))
        │       │           ├── flags: newline, variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :foo
        │       │           ├── message_loc: (14,2)-(14,5) = "foo"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (13,9)-(13,10) = "{"
        │       └── closing_loc: (15,0)-(15,1) = "}"
        ├── @ SuperNode (location: (16,0)-(18,1))
        │   ├── flags: newline
        │   ├── keyword_loc: (16,0)-(16,5) = "super"
        │   ├── lparen_loc: (16,5)-(16,6) = "("
        │   ├── arguments: ∅
        │   ├── rparen_loc: (16,6)-(16,7) = ")"
        │   └── block:
        │       @ BlockNode (location: (16,8)-(18,1))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (17,2)-(17,5))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (17,2)-(17,5))
        │       │           ├── flags: newline, variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :foo
        │       │           ├── message_loc: (17,2)-(17,5) = "foo"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (16,8)-(16,9) = "{"
        │       └── closing_loc: (18,0)-(18,1) = "}"
        └── @ SuperNode (location: (19,0)-(21,1))
            ├── flags: newline
            ├── keyword_loc: (19,0)-(19,5) = "super"
            ├── lparen_loc: (19,5)-(19,6) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (19,6)-(19,10))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ CallNode (location: (19,6)-(19,7))
            │       │   ├── flags: variable_call, ignore_visibility
            │       │   ├── receiver: ∅
            │       │   ├── call_operator_loc: ∅
            │       │   ├── name: :a
            │       │   ├── message_loc: (19,6)-(19,7) = "a"
            │       │   ├── opening_loc: ∅
            │       │   ├── arguments: ∅
            │       │   ├── closing_loc: ∅
            │       │   └── block: ∅
            │       └── @ CallNode (location: (19,9)-(19,10))
            │           ├── flags: variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :b
            │           ├── message_loc: (19,9)-(19,10) = "b"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── rparen_loc: (19,10)-(19,11) = ")"
            └── block:
                @ BlockNode (location: (19,12)-(21,1))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body:
                │   @ StatementsNode (location: (20,2)-(20,5))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ CallNode (location: (20,2)-(20,5))
                │           ├── flags: newline, variable_call, ignore_visibility
                │           ├── receiver: ∅
                │           ├── call_operator_loc: ∅
                │           ├── name: :foo
                │           ├── message_loc: (20,2)-(20,5) = "foo"
                │           ├── opening_loc: ∅
                │           ├── arguments: ∅
                │           ├── closing_loc: ∅
                │           └── block: ∅
                ├── opening_loc: (19,12)-(19,13) = "{"
                └── closing_loc: (21,0)-(21,1) = "}"
prism-1.5.1/snapshots/unparser/corpus/literal/unary.txt000066400000000000000000000417231506127434000234100ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(9,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(9,9))
    ├── flags: ∅
    └── body: (length: 9)
        ├── @ CallNode (location: (1,0)-(1,2))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (1,1)-(1,2))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: ∅
        │   ├── name: :!
        │   ├── message_loc: (1,0)-(1,1) = "!"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (2,0)-(2,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (2,1)-(2,5))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (2,2)-(2,4))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (2,2)-(2,4))
        │   │   │           ├── flags: newline
        │   │   │           ├── receiver:
        │   │   │           │   @ IntegerNode (location: (2,3)-(2,4))
        │   │   │           │   ├── flags: static_literal, decimal
        │   │   │           │   └── value: 1
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :!
        │   │   │           ├── message_loc: (2,2)-(2,3) = "!"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── opening_loc: (2,1)-(2,2) = "("
        │   │   └── closing_loc: (2,4)-(2,5) = ")"
        │   ├── call_operator_loc: ∅
        │   ├── name: :!
        │   ├── message_loc: (2,0)-(2,1) = "!"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,16))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (3,1)-(3,16))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (3,2)-(3,15))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (3,2)-(3,15))
        │   │   │           ├── flags: newline
        │   │   │           ├── receiver:
        │   │   │           │   @ ParenthesesNode (location: (3,3)-(3,15))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   ├── body:
        │   │   │           │   │   @ StatementsNode (location: (3,4)-(3,14))
        │   │   │           │   │   ├── flags: ∅
        │   │   │           │   │   └── body: (length: 1)
        │   │   │           │   │       └── @ OrNode (location: (3,4)-(3,14))
        │   │   │           │   │           ├── flags: newline
        │   │   │           │   │           ├── left:
        │   │   │           │   │           │   @ CallNode (location: (3,4)-(3,7))
        │   │   │           │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   │           │   ├── receiver: ∅
        │   │   │           │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   │           │   ├── name: :foo
        │   │   │           │   │           │   ├── message_loc: (3,4)-(3,7) = "foo"
        │   │   │           │   │           │   ├── opening_loc: ∅
        │   │   │           │   │           │   ├── arguments: ∅
        │   │   │           │   │           │   ├── closing_loc: ∅
        │   │   │           │   │           │   └── block: ∅
        │   │   │           │   │           ├── right:
        │   │   │           │   │           │   @ CallNode (location: (3,11)-(3,14))
        │   │   │           │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   │           │   ├── receiver: ∅
        │   │   │           │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   │           │   ├── name: :bar
        │   │   │           │   │           │   ├── message_loc: (3,11)-(3,14) = "bar"
        │   │   │           │   │           │   ├── opening_loc: ∅
        │   │   │           │   │           │   ├── arguments: ∅
        │   │   │           │   │           │   ├── closing_loc: ∅
        │   │   │           │   │           │   └── block: ∅
        │   │   │           │   │           └── operator_loc: (3,8)-(3,10) = "||"
        │   │   │           │   ├── opening_loc: (3,3)-(3,4) = "("
        │   │   │           │   └── closing_loc: (3,14)-(3,15) = ")"
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :!
        │   │   │           ├── message_loc: (3,2)-(3,3) = "!"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── opening_loc: (3,1)-(3,2) = "("
        │   │   └── closing_loc: (3,15)-(3,16) = ")"
        │   ├── call_operator_loc: ∅
        │   ├── name: :!
        │   ├── message_loc: (3,0)-(3,1) = "!"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (4,0)-(4,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (4,1)-(4,9))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ ParenthesesNode (location: (4,1)-(4,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── body:
        │   │   │   │   @ StatementsNode (location: (4,2)-(4,4))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (4,2)-(4,4))
        │   │   │   │           ├── flags: newline
        │   │   │   │           ├── receiver:
        │   │   │   │           │   @ IntegerNode (location: (4,3)-(4,4))
        │   │   │   │           │   ├── flags: static_literal, decimal
        │   │   │   │           │   └── value: 1
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :!
        │   │   │   │           ├── message_loc: (4,2)-(4,3) = "!"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   ├── opening_loc: (4,1)-(4,2) = "("
        │   │   │   └── closing_loc: (4,4)-(4,5) = ")"
        │   │   ├── call_operator_loc: (4,5)-(4,6) = "."
        │   │   ├── name: :baz
        │   │   ├── message_loc: (4,6)-(4,9) = "baz"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :!
        │   ├── message_loc: (4,0)-(4,1) = "!"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (5,0)-(5,2))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (5,1)-(5,2))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (5,1)-(5,2) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :~
        │   ├── message_loc: (5,0)-(5,1) = "~"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (6,0)-(6,2))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (6,1)-(6,2))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (6,1)-(6,2) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :-@
        │   ├── message_loc: (6,0)-(6,1) = "-"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (7,0)-(7,2))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (7,1)-(7,2))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (7,1)-(7,2) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :+@
        │   ├── message_loc: (7,0)-(7,1) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (8,0)-(8,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (8,1)-(8,9))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ ParenthesesNode (location: (8,1)-(8,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── body:
        │   │   │   │   @ StatementsNode (location: (8,2)-(8,4))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (8,2)-(8,4))
        │   │   │   │           ├── flags: newline
        │   │   │   │           ├── receiver:
        │   │   │   │           │   @ CallNode (location: (8,3)-(8,4))
        │   │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │   │           │   ├── receiver: ∅
        │   │   │   │           │   ├── call_operator_loc: ∅
        │   │   │   │           │   ├── name: :a
        │   │   │   │           │   ├── message_loc: (8,3)-(8,4) = "a"
        │   │   │   │           │   ├── opening_loc: ∅
        │   │   │   │           │   ├── arguments: ∅
        │   │   │   │           │   ├── closing_loc: ∅
        │   │   │   │           │   └── block: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :-@
        │   │   │   │           ├── message_loc: (8,2)-(8,3) = "-"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   ├── opening_loc: (8,1)-(8,2) = "("
        │   │   │   └── closing_loc: (8,4)-(8,5) = ")"
        │   │   ├── call_operator_loc: (8,5)-(8,6) = "."
        │   │   ├── name: :foo
        │   │   ├── message_loc: (8,6)-(8,9) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :-@
        │   ├── message_loc: (8,0)-(8,1) = "-"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (9,0)-(9,9))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (9,1)-(9,9))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ ParenthesesNode (location: (9,1)-(9,5))
            │   │   ├── flags: ∅
            │   │   ├── body:
            │   │   │   @ StatementsNode (location: (9,2)-(9,4))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ CallNode (location: (9,2)-(9,4))
            │   │   │           ├── flags: newline
            │   │   │           ├── receiver:
            │   │   │           │   @ CallNode (location: (9,3)-(9,4))
            │   │   │           │   ├── flags: variable_call, ignore_visibility
            │   │   │           │   ├── receiver: ∅
            │   │   │           │   ├── call_operator_loc: ∅
            │   │   │           │   ├── name: :a
            │   │   │           │   ├── message_loc: (9,3)-(9,4) = "a"
            │   │   │           │   ├── opening_loc: ∅
            │   │   │           │   ├── arguments: ∅
            │   │   │           │   ├── closing_loc: ∅
            │   │   │           │   └── block: ∅
            │   │   │           ├── call_operator_loc: ∅
            │   │   │           ├── name: :+@
            │   │   │           ├── message_loc: (9,2)-(9,3) = "+"
            │   │   │           ├── opening_loc: ∅
            │   │   │           ├── arguments: ∅
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── block: ∅
            │   │   ├── opening_loc: (9,1)-(9,2) = "("
            │   │   └── closing_loc: (9,4)-(9,5) = ")"
            │   ├── call_operator_loc: (9,5)-(9,6) = "."
            │   ├── name: :foo
            │   ├── message_loc: (9,6)-(9,9) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :+@
            ├── message_loc: (9,0)-(9,1) = "+"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/unparser/corpus/literal/undef.txt000066400000000000000000000033031506127434000233430ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,16))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,16))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ UndefNode (location: (1,0)-(1,10))
        │   ├── flags: newline
        │   ├── names: (length: 1)
        │   │   └── @ SymbolNode (location: (1,6)-(1,10))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: (1,6)-(1,7) = ":"
        │   │       ├── value_loc: (1,7)-(1,10) = "foo"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "foo"
        │   └── keyword_loc: (1,0)-(1,5) = "undef"
        └── @ UndefNode (location: (2,0)-(2,16))
            ├── flags: newline
            ├── names: (length: 2)
            │   ├── @ SymbolNode (location: (2,6)-(2,10))
            │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │   ├── opening_loc: (2,6)-(2,7) = ":"
            │   │   ├── value_loc: (2,7)-(2,10) = "foo"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "foo"
            │   └── @ SymbolNode (location: (2,12)-(2,16))
            │       ├── flags: static_literal, forced_us_ascii_encoding
            │       ├── opening_loc: (2,12)-(2,13) = ":"
            │       ├── value_loc: (2,13)-(2,16) = "bar"
            │       ├── closing_loc: ∅
            │       └── unescaped: "bar"
            └── keyword_loc: (2,0)-(2,5) = "undef"
prism-1.5.1/snapshots/unparser/corpus/literal/variables.txt000066400000000000000000000054221506127434000242160ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(10,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(10,17))
    ├── flags: ∅
    └── body: (length: 10)
        ├── @ CallNode (location: (1,0)-(1,1))
        │   ├── flags: newline, variable_call, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (1,0)-(1,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ InstanceVariableReadNode (location: (2,0)-(2,2))
        │   ├── flags: newline
        │   └── name: :@a
        ├── @ ClassVariableReadNode (location: (3,0)-(3,3))
        │   ├── flags: newline
        │   └── name: :@@a
        ├── @ GlobalVariableReadNode (location: (4,0)-(4,2))
        │   ├── flags: newline
        │   └── name: :$a
        ├── @ NumberedReferenceReadNode (location: (5,0)-(5,2))
        │   ├── flags: newline
        │   └── number: 1
        ├── @ BackReferenceReadNode (location: (6,0)-(6,2))
        │   ├── flags: newline
        │   └── name: :$`
        ├── @ ConstantReadNode (location: (7,0)-(7,5))
        │   ├── flags: newline
        │   └── name: :CONST
        ├── @ ConstantPathNode (location: (8,0)-(8,13))
        │   ├── flags: newline
        │   ├── parent:
        │   │   @ ConstantReadNode (location: (8,0)-(8,6))
        │   │   ├── flags: ∅
        │   │   └── name: :SCOPED
        │   ├── name: :CONST
        │   ├── delimiter_loc: (8,6)-(8,8) = "::"
        │   └── name_loc: (8,8)-(8,13) = "CONST"
        ├── @ ConstantPathNode (location: (9,0)-(9,10))
        │   ├── flags: newline
        │   ├── parent: ∅
        │   ├── name: :TOPLEVEL
        │   ├── delimiter_loc: (9,0)-(9,2) = "::"
        │   └── name_loc: (9,2)-(9,10) = "TOPLEVEL"
        └── @ ConstantPathNode (location: (10,0)-(10,17))
            ├── flags: newline
            ├── parent:
            │   @ ConstantPathNode (location: (10,0)-(10,10))
            │   ├── flags: ∅
            │   ├── parent: ∅
            │   ├── name: :TOPLEVEL
            │   ├── delimiter_loc: (10,0)-(10,2) = "::"
            │   └── name_loc: (10,2)-(10,10) = "TOPLEVEL"
            ├── name: :CONST
            ├── delimiter_loc: (10,10)-(10,12) = "::"
            └── name_loc: (10,12)-(10,17) = "CONST"
prism-1.5.1/snapshots/unparser/corpus/literal/while.txt000066400000000000000000001450211506127434000233560ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(73,3))
├── flags: ∅
├── locals: [:x]
└── statements:
    @ StatementsNode (location: (1,0)-(73,3))
    ├── flags: ∅
    └── body: (length: 17)
        ├── @ ModuleNode (location: (1,0)-(7,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── module_keyword_loc: (1,0)-(1,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (1,7)-(1,8))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (2,2)-(6,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (2,2)-(6,3))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :foo
        │   │           ├── message_loc: (2,2)-(2,5) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (2,6)-(6,3))
        │   │               ├── flags: ∅
        │   │               ├── locals: [:bar, :foo]
        │   │               ├── parameters:
        │   │               │   @ BlockParametersNode (location: (2,8)-(2,13))
        │   │               │   ├── flags: ∅
        │   │               │   ├── parameters:
        │   │               │   │   @ ParametersNode (location: (2,9)-(2,12))
        │   │               │   │   ├── flags: ∅
        │   │               │   │   ├── requireds: (length: 1)
        │   │               │   │   │   └── @ RequiredParameterNode (location: (2,9)-(2,12))
        │   │               │   │   │       ├── flags: ∅
        │   │               │   │   │       └── name: :bar
        │   │               │   │   ├── optionals: (length: 0)
        │   │               │   │   ├── rest: ∅
        │   │               │   │   ├── posts: (length: 0)
        │   │               │   │   ├── keywords: (length: 0)
        │   │               │   │   ├── keyword_rest: ∅
        │   │               │   │   └── block: ∅
        │   │               │   ├── locals: (length: 0)
        │   │               │   ├── opening_loc: (2,8)-(2,9) = "|"
        │   │               │   └── closing_loc: (2,12)-(2,13) = "|"
        │   │               ├── body:
        │   │               │   @ StatementsNode (location: (3,4)-(5,7))
        │   │               │   ├── flags: ∅
        │   │               │   └── body: (length: 1)
        │   │               │       └── @ WhileNode (location: (3,4)-(5,7))
        │   │               │           ├── flags: newline
        │   │               │           ├── keyword_loc: (3,4)-(3,9) = "while"
        │   │               │           ├── do_keyword_loc: ∅
        │   │               │           ├── closing_loc: (5,4)-(5,7) = "end"
        │   │               │           ├── predicate:
        │   │               │           │   @ CallNode (location: (3,10)-(3,13))
        │   │               │           │   ├── flags: variable_call, ignore_visibility
        │   │               │           │   ├── receiver: ∅
        │   │               │           │   ├── call_operator_loc: ∅
        │   │               │           │   ├── name: :foo
        │   │               │           │   ├── message_loc: (3,10)-(3,13) = "foo"
        │   │               │           │   ├── opening_loc: ∅
        │   │               │           │   ├── arguments: ∅
        │   │               │           │   ├── closing_loc: ∅
        │   │               │           │   └── block: ∅
        │   │               │           └── statements:
        │   │               │               @ StatementsNode (location: (4,6)-(4,15))
        │   │               │               ├── flags: ∅
        │   │               │               └── body: (length: 1)
        │   │               │                   └── @ LocalVariableWriteNode (location: (4,6)-(4,15))
        │   │               │                       ├── flags: newline
        │   │               │                       ├── name: :foo
        │   │               │                       ├── depth: 0
        │   │               │                       ├── name_loc: (4,6)-(4,9) = "foo"
        │   │               │                       ├── value:
        │   │               │                       │   @ LocalVariableReadNode (location: (4,12)-(4,15))
        │   │               │                       │   ├── flags: ∅
        │   │               │                       │   ├── name: :bar
        │   │               │                       │   └── depth: 0
        │   │               │                       └── operator_loc: (4,10)-(4,11) = "="
        │   │               ├── opening_loc: (2,6)-(2,7) = "{"
        │   │               └── closing_loc: (6,2)-(6,3) = "}"
        │   ├── end_keyword_loc: (7,0)-(7,3) = "end"
        │   └── name: :A
        ├── @ DefNode (location: (9,0)-(11,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (9,4)-(9,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (10,2)-(10,28))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ WhileNode (location: (10,2)-(10,28))
        │   │           ├── flags: newline
        │   │           ├── keyword_loc: (10,12)-(10,17) = "while"
        │   │           ├── do_keyword_loc: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── predicate:
        │   │           │   @ CallNode (location: (10,18)-(10,28))
        │   │           │   ├── flags: ∅
        │   │           │   ├── receiver:
        │   │           │   │   @ LocalVariableReadNode (location: (10,18)-(10,21))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── name: :foo
        │   │           │   │   └── depth: 0
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :!=
        │   │           │   ├── message_loc: (10,22)-(10,24) = "!="
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments:
        │   │           │   │   @ ArgumentsNode (location: (10,25)-(10,28))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   └── arguments: (length: 1)
        │   │           │   │       └── @ CallNode (location: (10,25)-(10,28))
        │   │           │   │           ├── flags: variable_call, ignore_visibility
        │   │           │   │           ├── receiver: ∅
        │   │           │   │           ├── call_operator_loc: ∅
        │   │           │   │           ├── name: :baz
        │   │           │   │           ├── message_loc: (10,25)-(10,28) = "baz"
        │   │           │   │           ├── opening_loc: ∅
        │   │           │   │           ├── arguments: ∅
        │   │           │   │           ├── closing_loc: ∅
        │   │           │   │           └── block: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           └── statements:
        │   │               @ StatementsNode (location: (10,2)-(10,11))
        │   │               ├── flags: ∅
        │   │               └── body: (length: 1)
        │   │                   └── @ LocalVariableWriteNode (location: (10,2)-(10,11))
        │   │                       ├── flags: newline
        │   │                       ├── name: :foo
        │   │                       ├── depth: 0
        │   │                       ├── name_loc: (10,2)-(10,5) = "foo"
        │   │                       ├── value:
        │   │                       │   @ CallNode (location: (10,8)-(10,11))
        │   │                       │   ├── flags: variable_call, ignore_visibility
        │   │                       │   ├── receiver: ∅
        │   │                       │   ├── call_operator_loc: ∅
        │   │                       │   ├── name: :bar
        │   │                       │   ├── message_loc: (10,8)-(10,11) = "bar"
        │   │                       │   ├── opening_loc: ∅
        │   │                       │   ├── arguments: ∅
        │   │                       │   ├── closing_loc: ∅
        │   │                       │   └── block: ∅
        │   │                       └── operator_loc: (10,6)-(10,7) = "="
        │   ├── locals: [:foo]
        │   ├── def_keyword_loc: (9,0)-(9,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (11,0)-(11,3) = "end"
        ├── @ ModuleNode (location: (13,0)-(15,3))
        │   ├── flags: newline
        │   ├── locals: [:foo]
        │   ├── module_keyword_loc: (13,0)-(13,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (13,7)-(13,8))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (14,2)-(14,21))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ WhileNode (location: (14,2)-(14,21))
        │   │           ├── flags: newline
        │   │           ├── keyword_loc: (14,12)-(14,17) = "while"
        │   │           ├── do_keyword_loc: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── predicate:
        │   │           │   @ LocalVariableReadNode (location: (14,18)-(14,21))
        │   │           │   ├── flags: ∅
        │   │           │   ├── name: :foo
        │   │           │   └── depth: 0
        │   │           └── statements:
        │   │               @ StatementsNode (location: (14,2)-(14,11))
        │   │               ├── flags: ∅
        │   │               └── body: (length: 1)
        │   │                   └── @ LocalVariableWriteNode (location: (14,2)-(14,11))
        │   │                       ├── flags: newline
        │   │                       ├── name: :foo
        │   │                       ├── depth: 0
        │   │                       ├── name_loc: (14,2)-(14,5) = "foo"
        │   │                       ├── value:
        │   │                       │   @ CallNode (location: (14,8)-(14,11))
        │   │                       │   ├── flags: variable_call, ignore_visibility
        │   │                       │   ├── receiver: ∅
        │   │                       │   ├── call_operator_loc: ∅
        │   │                       │   ├── name: :bar
        │   │                       │   ├── message_loc: (14,8)-(14,11) = "bar"
        │   │                       │   ├── opening_loc: ∅
        │   │                       │   ├── arguments: ∅
        │   │                       │   ├── closing_loc: ∅
        │   │                       │   └── block: ∅
        │   │                       └── operator_loc: (14,6)-(14,7) = "="
        │   ├── end_keyword_loc: (15,0)-(15,3) = "end"
        │   └── name: :A
        ├── @ ModuleNode (location: (17,0)-(19,3))
        │   ├── flags: newline
        │   ├── locals: [:foo]
        │   ├── module_keyword_loc: (17,0)-(17,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (17,7)-(17,8))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (18,2)-(18,21))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ UntilNode (location: (18,2)-(18,21))
        │   │           ├── flags: newline
        │   │           ├── keyword_loc: (18,12)-(18,17) = "until"
        │   │           ├── do_keyword_loc: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── predicate:
        │   │           │   @ LocalVariableReadNode (location: (18,18)-(18,21))
        │   │           │   ├── flags: ∅
        │   │           │   ├── name: :foo
        │   │           │   └── depth: 0
        │   │           └── statements:
        │   │               @ StatementsNode (location: (18,2)-(18,11))
        │   │               ├── flags: ∅
        │   │               └── body: (length: 1)
        │   │                   └── @ LocalVariableWriteNode (location: (18,2)-(18,11))
        │   │                       ├── flags: newline
        │   │                       ├── name: :foo
        │   │                       ├── depth: 0
        │   │                       ├── name_loc: (18,2)-(18,5) = "foo"
        │   │                       ├── value:
        │   │                       │   @ CallNode (location: (18,8)-(18,11))
        │   │                       │   ├── flags: variable_call, ignore_visibility
        │   │                       │   ├── receiver: ∅
        │   │                       │   ├── call_operator_loc: ∅
        │   │                       │   ├── name: :bar
        │   │                       │   ├── message_loc: (18,8)-(18,11) = "bar"
        │   │                       │   ├── opening_loc: ∅
        │   │                       │   ├── arguments: ∅
        │   │                       │   ├── closing_loc: ∅
        │   │                       │   └── block: ∅
        │   │                       └── operator_loc: (18,6)-(18,7) = "="
        │   ├── end_keyword_loc: (19,0)-(19,3) = "end"
        │   └── name: :A
        ├── @ ModuleNode (location: (21,0)-(25,3))
        │   ├── flags: newline
        │   ├── locals: [:foo]
        │   ├── module_keyword_loc: (21,0)-(21,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (21,7)-(21,8))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (22,2)-(24,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ WhileNode (location: (22,2)-(24,5))
        │   │           ├── flags: newline
        │   │           ├── keyword_loc: (22,2)-(22,7) = "while"
        │   │           ├── do_keyword_loc: ∅
        │   │           ├── closing_loc: (24,2)-(24,5) = "end"
        │   │           ├── predicate:
        │   │           │   @ CallNode (location: (22,8)-(22,11))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :foo
        │   │           │   ├── message_loc: (22,8)-(22,11) = "foo"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           └── statements:
        │   │               @ StatementsNode (location: (23,4)-(23,13))
        │   │               ├── flags: ∅
        │   │               └── body: (length: 1)
        │   │                   └── @ LocalVariableWriteNode (location: (23,4)-(23,13))
        │   │                       ├── flags: newline
        │   │                       ├── name: :foo
        │   │                       ├── depth: 0
        │   │                       ├── name_loc: (23,4)-(23,7) = "foo"
        │   │                       ├── value:
        │   │                       │   @ CallNode (location: (23,10)-(23,13))
        │   │                       │   ├── flags: variable_call, ignore_visibility
        │   │                       │   ├── receiver: ∅
        │   │                       │   ├── call_operator_loc: ∅
        │   │                       │   ├── name: :bar
        │   │                       │   ├── message_loc: (23,10)-(23,13) = "bar"
        │   │                       │   ├── opening_loc: ∅
        │   │                       │   ├── arguments: ∅
        │   │                       │   ├── closing_loc: ∅
        │   │                       │   └── block: ∅
        │   │                       └── operator_loc: (23,8)-(23,9) = "="
        │   ├── end_keyword_loc: (25,0)-(25,3) = "end"
        │   └── name: :A
        ├── @ ModuleNode (location: (27,0)-(33,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── module_keyword_loc: (27,0)-(27,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (27,7)-(27,8))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (28,2)-(32,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (28,2)-(32,3))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :each
        │   │           ├── message_loc: (28,2)-(28,6) = "each"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (28,7)-(32,3))
        │   │               ├── flags: ∅
        │   │               ├── locals: [:baz, :foo]
        │   │               ├── parameters:
        │   │               │   @ BlockParametersNode (location: (28,9)-(28,14))
        │   │               │   ├── flags: ∅
        │   │               │   ├── parameters:
        │   │               │   │   @ ParametersNode (location: (28,10)-(28,13))
        │   │               │   │   ├── flags: ∅
        │   │               │   │   ├── requireds: (length: 1)
        │   │               │   │   │   └── @ RequiredParameterNode (location: (28,10)-(28,13))
        │   │               │   │   │       ├── flags: ∅
        │   │               │   │   │       └── name: :baz
        │   │               │   │   ├── optionals: (length: 0)
        │   │               │   │   ├── rest: ∅
        │   │               │   │   ├── posts: (length: 0)
        │   │               │   │   ├── keywords: (length: 0)
        │   │               │   │   ├── keyword_rest: ∅
        │   │               │   │   └── block: ∅
        │   │               │   ├── locals: (length: 0)
        │   │               │   ├── opening_loc: (28,9)-(28,10) = "|"
        │   │               │   └── closing_loc: (28,13)-(28,14) = "|"
        │   │               ├── body:
        │   │               │   @ StatementsNode (location: (29,4)-(31,7))
        │   │               │   ├── flags: ∅
        │   │               │   └── body: (length: 1)
        │   │               │       └── @ WhileNode (location: (29,4)-(31,7))
        │   │               │           ├── flags: newline
        │   │               │           ├── keyword_loc: (29,4)-(29,9) = "while"
        │   │               │           ├── do_keyword_loc: ∅
        │   │               │           ├── closing_loc: (31,4)-(31,7) = "end"
        │   │               │           ├── predicate:
        │   │               │           │   @ CallNode (location: (29,10)-(29,13))
        │   │               │           │   ├── flags: variable_call, ignore_visibility
        │   │               │           │   ├── receiver: ∅
        │   │               │           │   ├── call_operator_loc: ∅
        │   │               │           │   ├── name: :foo
        │   │               │           │   ├── message_loc: (29,10)-(29,13) = "foo"
        │   │               │           │   ├── opening_loc: ∅
        │   │               │           │   ├── arguments: ∅
        │   │               │           │   ├── closing_loc: ∅
        │   │               │           │   └── block: ∅
        │   │               │           └── statements:
        │   │               │               @ StatementsNode (location: (30,6)-(30,15))
        │   │               │               ├── flags: ∅
        │   │               │               └── body: (length: 1)
        │   │               │                   └── @ LocalVariableWriteNode (location: (30,6)-(30,15))
        │   │               │                       ├── flags: newline
        │   │               │                       ├── name: :foo
        │   │               │                       ├── depth: 0
        │   │               │                       ├── name_loc: (30,6)-(30,9) = "foo"
        │   │               │                       ├── value:
        │   │               │                       │   @ CallNode (location: (30,12)-(30,15))
        │   │               │                       │   ├── flags: variable_call, ignore_visibility
        │   │               │                       │   ├── receiver: ∅
        │   │               │                       │   ├── call_operator_loc: ∅
        │   │               │                       │   ├── name: :bar
        │   │               │                       │   ├── message_loc: (30,12)-(30,15) = "bar"
        │   │               │                       │   ├── opening_loc: ∅
        │   │               │                       │   ├── arguments: ∅
        │   │               │                       │   ├── closing_loc: ∅
        │   │               │                       │   └── block: ∅
        │   │               │                       └── operator_loc: (30,10)-(30,11) = "="
        │   │               ├── opening_loc: (28,7)-(28,8) = "{"
        │   │               └── closing_loc: (32,2)-(32,3) = "}"
        │   ├── end_keyword_loc: (33,0)-(33,3) = "end"
        │   └── name: :A
        ├── @ ModuleNode (location: (35,0)-(41,3))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── module_keyword_loc: (35,0)-(35,6) = "module"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (35,7)-(35,8))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── body:
        │   │   @ StatementsNode (location: (36,2)-(40,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (36,2)-(40,3))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :each
        │   │           ├── message_loc: (36,2)-(36,6) = "each"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (36,7)-(40,3))
        │   │               ├── flags: ∅
        │   │               ├── locals: [:foo]
        │   │               ├── parameters:
        │   │               │   @ BlockParametersNode (location: (36,9)-(36,14))
        │   │               │   ├── flags: ∅
        │   │               │   ├── parameters:
        │   │               │   │   @ ParametersNode (location: (36,10)-(36,13))
        │   │               │   │   ├── flags: ∅
        │   │               │   │   ├── requireds: (length: 1)
        │   │               │   │   │   └── @ RequiredParameterNode (location: (36,10)-(36,13))
        │   │               │   │   │       ├── flags: ∅
        │   │               │   │   │       └── name: :foo
        │   │               │   │   ├── optionals: (length: 0)
        │   │               │   │   ├── rest: ∅
        │   │               │   │   ├── posts: (length: 0)
        │   │               │   │   ├── keywords: (length: 0)
        │   │               │   │   ├── keyword_rest: ∅
        │   │               │   │   └── block: ∅
        │   │               │   ├── locals: (length: 0)
        │   │               │   ├── opening_loc: (36,9)-(36,10) = "|"
        │   │               │   └── closing_loc: (36,13)-(36,14) = "|"
        │   │               ├── body:
        │   │               │   @ StatementsNode (location: (37,4)-(39,7))
        │   │               │   ├── flags: ∅
        │   │               │   └── body: (length: 1)
        │   │               │       └── @ WhileNode (location: (37,4)-(39,7))
        │   │               │           ├── flags: newline
        │   │               │           ├── keyword_loc: (37,4)-(37,9) = "while"
        │   │               │           ├── do_keyword_loc: ∅
        │   │               │           ├── closing_loc: (39,4)-(39,7) = "end"
        │   │               │           ├── predicate:
        │   │               │           │   @ LocalVariableReadNode (location: (37,10)-(37,13))
        │   │               │           │   ├── flags: ∅
        │   │               │           │   ├── name: :foo
        │   │               │           │   └── depth: 0
        │   │               │           └── statements:
        │   │               │               @ StatementsNode (location: (38,6)-(38,15))
        │   │               │               ├── flags: ∅
        │   │               │               └── body: (length: 1)
        │   │               │                   └── @ LocalVariableWriteNode (location: (38,6)-(38,15))
        │   │               │                       ├── flags: newline
        │   │               │                       ├── name: :foo
        │   │               │                       ├── depth: 0
        │   │               │                       ├── name_loc: (38,6)-(38,9) = "foo"
        │   │               │                       ├── value:
        │   │               │                       │   @ CallNode (location: (38,12)-(38,15))
        │   │               │                       │   ├── flags: variable_call, ignore_visibility
        │   │               │                       │   ├── receiver: ∅
        │   │               │                       │   ├── call_operator_loc: ∅
        │   │               │                       │   ├── name: :bar
        │   │               │                       │   ├── message_loc: (38,12)-(38,15) = "bar"
        │   │               │                       │   ├── opening_loc: ∅
        │   │               │                       │   ├── arguments: ∅
        │   │               │                       │   ├── closing_loc: ∅
        │   │               │                       │   └── block: ∅
        │   │               │                       └── operator_loc: (38,10)-(38,11) = "="
        │   │               ├── opening_loc: (36,7)-(36,8) = "{"
        │   │               └── closing_loc: (40,2)-(40,3) = "}"
        │   ├── end_keyword_loc: (41,0)-(41,3) = "end"
        │   └── name: :A
        ├── @ LocalVariableWriteNode (location: (42,0)-(44,14))
        │   ├── flags: newline
        │   ├── name: :x
        │   ├── depth: 0
        │   ├── name_loc: (42,0)-(42,1) = "x"
        │   ├── value:
        │   │   @ ParenthesesNode (location: (42,4)-(44,14))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (42,5)-(44,13))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ WhileNode (location: (42,5)-(44,13))
        │   │   │           ├── flags: newline, begin_modifier
        │   │   │           ├── keyword_loc: (44,4)-(44,9) = "while"
        │   │   │           ├── do_keyword_loc: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── predicate:
        │   │   │           │   @ CallNode (location: (44,10)-(44,13))
        │   │   │           │   ├── flags: variable_call, ignore_visibility
        │   │   │           │   ├── receiver: ∅
        │   │   │           │   ├── call_operator_loc: ∅
        │   │   │           │   ├── name: :baz
        │   │   │           │   ├── message_loc: (44,10)-(44,13) = "baz"
        │   │   │           │   ├── opening_loc: ∅
        │   │   │           │   ├── arguments: ∅
        │   │   │           │   ├── closing_loc: ∅
        │   │   │           │   └── block: ∅
        │   │   │           └── statements:
        │   │   │               @ StatementsNode (location: (42,5)-(44,3))
        │   │   │               ├── flags: ∅
        │   │   │               └── body: (length: 1)
        │   │   │                   └── @ BeginNode (location: (42,5)-(44,3))
        │   │   │                       ├── flags: newline
        │   │   │                       ├── begin_keyword_loc: (42,5)-(42,10) = "begin"
        │   │   │                       ├── statements:
        │   │   │                       │   @ StatementsNode (location: (43,2)-(43,5))
        │   │   │                       │   ├── flags: ∅
        │   │   │                       │   └── body: (length: 1)
        │   │   │                       │       └── @ CallNode (location: (43,2)-(43,5))
        │   │   │                       │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │                       │           ├── receiver: ∅
        │   │   │                       │           ├── call_operator_loc: ∅
        │   │   │                       │           ├── name: :foo
        │   │   │                       │           ├── message_loc: (43,2)-(43,5) = "foo"
        │   │   │                       │           ├── opening_loc: ∅
        │   │   │                       │           ├── arguments: ∅
        │   │   │                       │           ├── closing_loc: ∅
        │   │   │                       │           └── block: ∅
        │   │   │                       ├── rescue_clause: ∅
        │   │   │                       ├── else_clause: ∅
        │   │   │                       ├── ensure_clause: ∅
        │   │   │                       └── end_keyword_loc: (44,0)-(44,3) = "end"
        │   │   ├── opening_loc: (42,4)-(42,5) = "("
        │   │   └── closing_loc: (44,13)-(44,14) = ")"
        │   └── operator_loc: (42,2)-(42,3) = "="
        ├── @ WhileNode (location: (45,0)-(47,13))
        │   ├── flags: newline, begin_modifier
        │   ├── keyword_loc: (47,4)-(47,9) = "while"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (47,10)-(47,13))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :baz
        │   │   ├── message_loc: (47,10)-(47,13) = "baz"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── statements:
        │       @ StatementsNode (location: (45,0)-(47,3))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ BeginNode (location: (45,0)-(47,3))
        │               ├── flags: newline
        │               ├── begin_keyword_loc: (45,0)-(45,5) = "begin"
        │               ├── statements:
        │               │   @ StatementsNode (location: (46,2)-(46,5))
        │               │   ├── flags: ∅
        │               │   └── body: (length: 1)
        │               │       └── @ CallNode (location: (46,2)-(46,5))
        │               │           ├── flags: newline, variable_call, ignore_visibility
        │               │           ├── receiver: ∅
        │               │           ├── call_operator_loc: ∅
        │               │           ├── name: :foo
        │               │           ├── message_loc: (46,2)-(46,5) = "foo"
        │               │           ├── opening_loc: ∅
        │               │           ├── arguments: ∅
        │               │           ├── closing_loc: ∅
        │               │           └── block: ∅
        │               ├── rescue_clause: ∅
        │               ├── else_clause: ∅
        │               ├── ensure_clause: ∅
        │               └── end_keyword_loc: (47,0)-(47,3) = "end"
        ├── @ UntilNode (location: (48,0)-(51,13))
        │   ├── flags: newline, begin_modifier
        │   ├── keyword_loc: (51,4)-(51,9) = "until"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (51,10)-(51,13))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :baz
        │   │   ├── message_loc: (51,10)-(51,13) = "baz"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── statements:
        │       @ StatementsNode (location: (48,0)-(51,3))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ BeginNode (location: (48,0)-(51,3))
        │               ├── flags: newline
        │               ├── begin_keyword_loc: (48,0)-(48,5) = "begin"
        │               ├── statements:
        │               │   @ StatementsNode (location: (49,2)-(50,5))
        │               │   ├── flags: ∅
        │               │   └── body: (length: 2)
        │               │       ├── @ CallNode (location: (49,2)-(49,5))
        │               │       │   ├── flags: newline, variable_call, ignore_visibility
        │               │       │   ├── receiver: ∅
        │               │       │   ├── call_operator_loc: ∅
        │               │       │   ├── name: :foo
        │               │       │   ├── message_loc: (49,2)-(49,5) = "foo"
        │               │       │   ├── opening_loc: ∅
        │               │       │   ├── arguments: ∅
        │               │       │   ├── closing_loc: ∅
        │               │       │   └── block: ∅
        │               │       └── @ CallNode (location: (50,2)-(50,5))
        │               │           ├── flags: newline, variable_call, ignore_visibility
        │               │           ├── receiver: ∅
        │               │           ├── call_operator_loc: ∅
        │               │           ├── name: :bar
        │               │           ├── message_loc: (50,2)-(50,5) = "bar"
        │               │           ├── opening_loc: ∅
        │               │           ├── arguments: ∅
        │               │           ├── closing_loc: ∅
        │               │           └── block: ∅
        │               ├── rescue_clause: ∅
        │               ├── else_clause: ∅
        │               ├── ensure_clause: ∅
        │               └── end_keyword_loc: (51,0)-(51,3) = "end"
        ├── @ WhileNode (location: (52,0)-(55,13))
        │   ├── flags: newline, begin_modifier
        │   ├── keyword_loc: (55,4)-(55,9) = "while"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (55,10)-(55,13))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :baz
        │   │   ├── message_loc: (55,10)-(55,13) = "baz"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── statements:
        │       @ StatementsNode (location: (52,0)-(55,3))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ BeginNode (location: (52,0)-(55,3))
        │               ├── flags: newline
        │               ├── begin_keyword_loc: (52,0)-(52,5) = "begin"
        │               ├── statements:
        │               │   @ StatementsNode (location: (53,2)-(54,5))
        │               │   ├── flags: ∅
        │               │   └── body: (length: 2)
        │               │       ├── @ CallNode (location: (53,2)-(53,5))
        │               │       │   ├── flags: newline, variable_call, ignore_visibility
        │               │       │   ├── receiver: ∅
        │               │       │   ├── call_operator_loc: ∅
        │               │       │   ├── name: :foo
        │               │       │   ├── message_loc: (53,2)-(53,5) = "foo"
        │               │       │   ├── opening_loc: ∅
        │               │       │   ├── arguments: ∅
        │               │       │   ├── closing_loc: ∅
        │               │       │   └── block: ∅
        │               │       └── @ CallNode (location: (54,2)-(54,5))
        │               │           ├── flags: newline, variable_call, ignore_visibility
        │               │           ├── receiver: ∅
        │               │           ├── call_operator_loc: ∅
        │               │           ├── name: :bar
        │               │           ├── message_loc: (54,2)-(54,5) = "bar"
        │               │           ├── opening_loc: ∅
        │               │           ├── arguments: ∅
        │               │           ├── closing_loc: ∅
        │               │           └── block: ∅
        │               ├── rescue_clause: ∅
        │               ├── else_clause: ∅
        │               ├── ensure_clause: ∅
        │               └── end_keyword_loc: (55,0)-(55,3) = "end"
        ├── @ WhileNode (location: (56,0)-(57,3))
        │   ├── flags: newline
        │   ├── keyword_loc: (56,0)-(56,5) = "while"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: (57,0)-(57,3) = "end"
        │   ├── predicate:
        │   │   @ FalseNode (location: (56,6)-(56,11))
        │   │   └── flags: static_literal
        │   └── statements: ∅
        ├── @ WhileNode (location: (58,0)-(60,3))
        │   ├── flags: newline
        │   ├── keyword_loc: (58,0)-(58,5) = "while"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: (60,0)-(60,3) = "end"
        │   ├── predicate:
        │   │   @ FalseNode (location: (58,6)-(58,11))
        │   │   └── flags: static_literal
        │   └── statements:
        │       @ StatementsNode (location: (59,2)-(59,3))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ IntegerNode (location: (59,2)-(59,3))
        │               ├── flags: newline, static_literal, decimal
        │               └── value: 3
        ├── @ WhileNode (location: (61,0)-(64,3))
        │   ├── flags: newline
        │   ├── keyword_loc: (61,0)-(61,5) = "while"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: (64,0)-(64,3) = "end"
        │   ├── predicate:
        │   │   @ ParenthesesNode (location: (61,6)-(62,2))
        │   │   ├── flags: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (61,7)-(62,1))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (61,7)-(62,1))
        │   │   │           ├── flags: newline, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :foo
        │   │   │           ├── message_loc: (61,7)-(61,10) = "foo"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block:
        │   │   │               @ BlockNode (location: (61,11)-(62,1))
        │   │   │               ├── flags: ∅
        │   │   │               ├── locals: []
        │   │   │               ├── parameters: ∅
        │   │   │               ├── body: ∅
        │   │   │               ├── opening_loc: (61,11)-(61,12) = "{"
        │   │   │               └── closing_loc: (62,0)-(62,1) = "}"
        │   │   ├── opening_loc: (61,6)-(61,7) = "("
        │   │   └── closing_loc: (62,1)-(62,2) = ")"
        │   └── statements:
        │       @ StatementsNode (location: (63,2)-(63,7))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ SymbolNode (location: (63,2)-(63,7))
        │               ├── flags: newline, static_literal, forced_us_ascii_encoding
        │               ├── opening_loc: (63,2)-(63,3) = ":"
        │               ├── value_loc: (63,3)-(63,7) = "body"
        │               ├── closing_loc: ∅
        │               └── unescaped: "body"
        ├── @ UntilNode (location: (65,0)-(66,3))
        │   ├── flags: newline
        │   ├── keyword_loc: (65,0)-(65,5) = "until"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: (66,0)-(66,3) = "end"
        │   ├── predicate:
        │   │   @ FalseNode (location: (65,6)-(65,11))
        │   │   └── flags: static_literal
        │   └── statements: ∅
        ├── @ UntilNode (location: (67,0)-(69,3))
        │   ├── flags: newline
        │   ├── keyword_loc: (67,0)-(67,5) = "until"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: (69,0)-(69,3) = "end"
        │   ├── predicate:
        │   │   @ FalseNode (location: (67,6)-(67,11))
        │   │   └── flags: static_literal
        │   └── statements:
        │       @ StatementsNode (location: (68,2)-(68,3))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ IntegerNode (location: (68,2)-(68,3))
        │               ├── flags: newline, static_literal, decimal
        │               └── value: 3
        └── @ UntilNode (location: (70,0)-(73,3))
            ├── flags: newline
            ├── keyword_loc: (70,0)-(70,5) = "until"
            ├── do_keyword_loc: ∅
            ├── closing_loc: (73,0)-(73,3) = "end"
            ├── predicate:
            │   @ ParenthesesNode (location: (70,6)-(71,2))
            │   ├── flags: ∅
            │   ├── body:
            │   │   @ StatementsNode (location: (70,7)-(71,1))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (70,7)-(71,1))
            │   │           ├── flags: newline, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :foo
            │   │           ├── message_loc: (70,7)-(70,10) = "foo"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block:
            │   │               @ BlockNode (location: (70,11)-(71,1))
            │   │               ├── flags: ∅
            │   │               ├── locals: []
            │   │               ├── parameters: ∅
            │   │               ├── body: ∅
            │   │               ├── opening_loc: (70,11)-(70,12) = "{"
            │   │               └── closing_loc: (71,0)-(71,1) = "}"
            │   ├── opening_loc: (70,6)-(70,7) = "("
            │   └── closing_loc: (71,1)-(71,2) = ")"
            └── statements:
                @ StatementsNode (location: (72,2)-(72,7))
                ├── flags: ∅
                └── body: (length: 1)
                    └── @ SymbolNode (location: (72,2)-(72,7))
                        ├── flags: newline, static_literal, forced_us_ascii_encoding
                        ├── opening_loc: (72,2)-(72,3) = ":"
                        ├── value_loc: (72,3)-(72,7) = "body"
                        ├── closing_loc: ∅
                        └── unescaped: "body"
prism-1.5.1/snapshots/unparser/corpus/semantic/000077500000000000000000000000001506127434000216515ustar00rootroot00000000000000prism-1.5.1/snapshots/unparser/corpus/semantic/and.txt000066400000000000000000000317551506127434000231670ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(8,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(8,3))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ OrNode (location: (1,0)-(1,14))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ RangeNode (location: (1,0)-(1,5))
        │   │   ├── flags: exclude_end
        │   │   ├── left:
        │   │   │   @ CallNode (location: (1,0)-(1,1))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :a
        │   │   │   ├── message_loc: (1,0)-(1,1) = "a"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── right:
        │   │   │   @ CallNode (location: (1,4)-(1,5))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :b
        │   │   │   ├── message_loc: (1,4)-(1,5) = "b"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── operator_loc: (1,1)-(1,4) = "..."
        │   ├── right:
        │   │   @ RangeNode (location: (1,9)-(1,14))
        │   │   ├── flags: exclude_end
        │   │   ├── left:
        │   │   │   @ CallNode (location: (1,9)-(1,10))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :c
        │   │   │   ├── message_loc: (1,9)-(1,10) = "c"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── right:
        │   │   │   @ CallNode (location: (1,13)-(1,14))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :d
        │   │   │   ├── message_loc: (1,13)-(1,14) = "d"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── operator_loc: (1,10)-(1,13) = "..."
        │   └── operator_loc: (1,6)-(1,8) = "or"
        ├── @ AndNode (location: (2,0)-(2,15))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ RangeNode (location: (2,0)-(2,5))
        │   │   ├── flags: exclude_end
        │   │   ├── left:
        │   │   │   @ CallNode (location: (2,0)-(2,1))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :a
        │   │   │   ├── message_loc: (2,0)-(2,1) = "a"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── right:
        │   │   │   @ CallNode (location: (2,4)-(2,5))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :b
        │   │   │   ├── message_loc: (2,4)-(2,5) = "b"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── operator_loc: (2,1)-(2,4) = "..."
        │   ├── right:
        │   │   @ RangeNode (location: (2,10)-(2,15))
        │   │   ├── flags: exclude_end
        │   │   ├── left:
        │   │   │   @ CallNode (location: (2,10)-(2,11))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :c
        │   │   │   ├── message_loc: (2,10)-(2,11) = "c"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── right:
        │   │   │   @ CallNode (location: (2,14)-(2,15))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :d
        │   │   │   ├── message_loc: (2,14)-(2,15) = "d"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── operator_loc: (2,11)-(2,14) = "..."
        │   └── operator_loc: (2,6)-(2,9) = "and"
        ├── @ IfNode (location: (4,0)-(5,3))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (4,0)-(4,2) = "if"
        │   ├── predicate:
        │   │   @ OrNode (location: (4,3)-(4,17))
        │   │   ├── flags: ∅
        │   │   ├── left:
        │   │   │   @ FlipFlopNode (location: (4,3)-(4,8))
        │   │   │   ├── flags: exclude_end
        │   │   │   ├── left:
        │   │   │   │   @ CallNode (location: (4,3)-(4,4))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :a
        │   │   │   │   ├── message_loc: (4,3)-(4,4) = "a"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── right:
        │   │   │   │   @ CallNode (location: (4,7)-(4,8))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :b
        │   │   │   │   ├── message_loc: (4,7)-(4,8) = "b"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── operator_loc: (4,4)-(4,7) = "..."
        │   │   ├── right:
        │   │   │   @ FlipFlopNode (location: (4,12)-(4,17))
        │   │   │   ├── flags: exclude_end
        │   │   │   ├── left:
        │   │   │   │   @ CallNode (location: (4,12)-(4,13))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :c
        │   │   │   │   ├── message_loc: (4,12)-(4,13) = "c"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── right:
        │   │   │   │   @ CallNode (location: (4,16)-(4,17))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :d
        │   │   │   │   ├── message_loc: (4,16)-(4,17) = "d"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   └── operator_loc: (4,13)-(4,16) = "..."
        │   │   └── operator_loc: (4,9)-(4,11) = "or"
        │   ├── then_keyword_loc: ∅
        │   ├── statements: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: (5,0)-(5,3) = "end"
        └── @ IfNode (location: (7,0)-(8,3))
            ├── flags: newline
            ├── if_keyword_loc: (7,0)-(7,2) = "if"
            ├── predicate:
            │   @ AndNode (location: (7,3)-(7,18))
            │   ├── flags: ∅
            │   ├── left:
            │   │   @ FlipFlopNode (location: (7,3)-(7,8))
            │   │   ├── flags: exclude_end
            │   │   ├── left:
            │   │   │   @ CallNode (location: (7,3)-(7,4))
            │   │   │   ├── flags: variable_call, ignore_visibility
            │   │   │   ├── receiver: ∅
            │   │   │   ├── call_operator_loc: ∅
            │   │   │   ├── name: :a
            │   │   │   ├── message_loc: (7,3)-(7,4) = "a"
            │   │   │   ├── opening_loc: ∅
            │   │   │   ├── arguments: ∅
            │   │   │   ├── closing_loc: ∅
            │   │   │   └── block: ∅
            │   │   ├── right:
            │   │   │   @ CallNode (location: (7,7)-(7,8))
            │   │   │   ├── flags: variable_call, ignore_visibility
            │   │   │   ├── receiver: ∅
            │   │   │   ├── call_operator_loc: ∅
            │   │   │   ├── name: :b
            │   │   │   ├── message_loc: (7,7)-(7,8) = "b"
            │   │   │   ├── opening_loc: ∅
            │   │   │   ├── arguments: ∅
            │   │   │   ├── closing_loc: ∅
            │   │   │   └── block: ∅
            │   │   └── operator_loc: (7,4)-(7,7) = "..."
            │   ├── right:
            │   │   @ FlipFlopNode (location: (7,13)-(7,18))
            │   │   ├── flags: exclude_end
            │   │   ├── left:
            │   │   │   @ CallNode (location: (7,13)-(7,14))
            │   │   │   ├── flags: variable_call, ignore_visibility
            │   │   │   ├── receiver: ∅
            │   │   │   ├── call_operator_loc: ∅
            │   │   │   ├── name: :c
            │   │   │   ├── message_loc: (7,13)-(7,14) = "c"
            │   │   │   ├── opening_loc: ∅
            │   │   │   ├── arguments: ∅
            │   │   │   ├── closing_loc: ∅
            │   │   │   └── block: ∅
            │   │   ├── right:
            │   │   │   @ CallNode (location: (7,17)-(7,18))
            │   │   │   ├── flags: variable_call, ignore_visibility
            │   │   │   ├── receiver: ∅
            │   │   │   ├── call_operator_loc: ∅
            │   │   │   ├── name: :d
            │   │   │   ├── message_loc: (7,17)-(7,18) = "d"
            │   │   │   ├── opening_loc: ∅
            │   │   │   ├── arguments: ∅
            │   │   │   ├── closing_loc: ∅
            │   │   │   └── block: ∅
            │   │   └── operator_loc: (7,14)-(7,17) = "..."
            │   └── operator_loc: (7,9)-(7,12) = "and"
            ├── then_keyword_loc: ∅
            ├── statements: ∅
            ├── subsequent: ∅
            └── end_keyword_loc: (8,0)-(8,3) = "end"
prism-1.5.1/snapshots/unparser/corpus/semantic/block.txt000066400000000000000000000261061506127434000235110ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(26,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(26,3))
    ├── flags: ∅
    └── body: (length: 6)
        ├── @ CallNode (location: (1,0)-(2,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,4)-(2,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (1,4)-(1,6) = "do"
        │       └── closing_loc: (2,0)-(2,3) = "end"
        ├── @ CallNode (location: (4,0)-(6,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (4,0)-(4,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (4,4)-(6,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ BeginNode (location: (4,4)-(6,3))
        │       │   ├── flags: ∅
        │       │   ├── begin_keyword_loc: ∅
        │       │   ├── statements: ∅
        │       │   ├── rescue_clause:
        │       │   │   @ RescueNode (location: (5,0)-(5,6))
        │       │   │   ├── flags: ∅
        │       │   │   ├── keyword_loc: (5,0)-(5,6) = "rescue"
        │       │   │   ├── exceptions: (length: 0)
        │       │   │   ├── operator_loc: ∅
        │       │   │   ├── reference: ∅
        │       │   │   ├── then_keyword_loc: ∅
        │       │   │   ├── statements: ∅
        │       │   │   └── subsequent: ∅
        │       │   ├── else_clause: ∅
        │       │   ├── ensure_clause: ∅
        │       │   └── end_keyword_loc: (6,0)-(6,3) = "end"
        │       ├── opening_loc: (4,4)-(4,6) = "do"
        │       └── closing_loc: (6,0)-(6,3) = "end"
        ├── @ CallNode (location: (8,0)-(11,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (8,0)-(8,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (8,4)-(11,3))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body:
        │       │   @ StatementsNode (location: (9,2)-(10,5))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 2)
        │       │       ├── @ RescueModifierNode (location: (9,2)-(9,16))
        │       │       │   ├── flags: newline
        │       │       │   ├── expression:
        │       │       │   │   @ NilNode (location: (9,2)-(9,5))
        │       │       │   │   └── flags: static_literal
        │       │       │   ├── keyword_loc: (9,6)-(9,12) = "rescue"
        │       │       │   └── rescue_expression:
        │       │       │       @ NilNode (location: (9,13)-(9,16))
        │       │       │       └── flags: static_literal
        │       │       └── @ NilNode (location: (10,2)-(10,5))
        │       │           └── flags: newline, static_literal
        │       ├── opening_loc: (8,4)-(8,6) = "do"
        │       └── closing_loc: (11,0)-(11,3) = "end"
        ├── @ CallNode (location: (13,0)-(14,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (13,0)-(13,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (13,4)-(14,3))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (13,7)-(13,10))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (13,8)-(13,9))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (13,8)-(13,9))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (13,7)-(13,8) = "|"
        │       │   └── closing_loc: (13,9)-(13,10) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (13,4)-(13,6) = "do"
        │       └── closing_loc: (14,0)-(14,3) = "end"
        ├── @ CallNode (location: (16,0)-(20,3))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (16,0)-(16,3) = "foo"
        │   ├── opening_loc: (16,3)-(16,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (16,4)-(16,10))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (16,4)-(16,10))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (16,4)-(16,10) = "<<-DOC"
        │   │           ├── content_loc: (17,0)-(18,0) = "  b\n"
        │   │           ├── closing_loc: (18,0)-(19,0) = "DOC\n"
        │   │           └── unescaped: "  b\n"
        │   ├── closing_loc: (16,10)-(16,11) = ")"
        │   └── block:
        │       @ BlockNode (location: (16,12)-(20,3))
        │       ├── flags: ∅
        │       ├── locals: [:a]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (16,15)-(16,18))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (16,16)-(16,17))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (16,16)-(16,17))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :a
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (16,15)-(16,16) = "|"
        │       │   └── closing_loc: (16,17)-(16,18) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (19,2)-(19,3))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ LocalVariableReadNode (location: (19,2)-(19,3))
        │       │           ├── flags: newline
        │       │           ├── name: :a
        │       │           └── depth: 0
        │       ├── opening_loc: (16,12)-(16,14) = "do"
        │       └── closing_loc: (20,0)-(20,3) = "end"
        └── @ CallNode (location: (22,0)-(26,3))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :foo
            ├── message_loc: (22,0)-(22,3) = "foo"
            ├── opening_loc: (22,3)-(22,4) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (22,4)-(22,10))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ StringNode (location: (22,4)-(22,10))
            │           ├── flags: ∅
            │           ├── opening_loc: (22,4)-(22,10) = "<<-DOC"
            │           ├── content_loc: (23,0)-(24,0) = "  b\n"
            │           ├── closing_loc: (24,0)-(25,0) = "DOC\n"
            │           └── unescaped: "  b\n"
            ├── closing_loc: (22,10)-(22,11) = ")"
            └── block:
                @ BlockNode (location: (22,12)-(26,3))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body:
                │   @ StatementsNode (location: (25,2)-(25,3))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ CallNode (location: (25,2)-(25,3))
                │           ├── flags: newline, variable_call, ignore_visibility
                │           ├── receiver: ∅
                │           ├── call_operator_loc: ∅
                │           ├── name: :a
                │           ├── message_loc: (25,2)-(25,3) = "a"
                │           ├── opening_loc: ∅
                │           ├── arguments: ∅
                │           ├── closing_loc: ∅
                │           └── block: ∅
                ├── opening_loc: (22,12)-(22,14) = "do"
                └── closing_loc: (26,0)-(26,3) = "end"
prism-1.5.1/snapshots/unparser/corpus/semantic/def.txt000066400000000000000000000133711506127434000231550ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(7,3))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ DefNode (location: (1,0)-(3,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (1,4)-(1,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (2,2)-(2,9))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ ParenthesesNode (location: (2,2)-(2,9))
        │   │           ├── flags: newline
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (2,3)-(2,8))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (2,3)-(2,8))
        │   │           │           ├── flags: newline
        │   │           │           ├── receiver:
        │   │           │           │   @ CallNode (location: (2,3)-(2,4))
        │   │           │           │   ├── flags: variable_call, ignore_visibility
        │   │           │           │   ├── receiver: ∅
        │   │           │           │   ├── call_operator_loc: ∅
        │   │           │           │   ├── name: :a
        │   │           │           │   ├── message_loc: (2,3)-(2,4) = "a"
        │   │           │           │   ├── opening_loc: ∅
        │   │           │           │   ├── arguments: ∅
        │   │           │           │   ├── closing_loc: ∅
        │   │           │           │   └── block: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :-
        │   │           │           ├── message_loc: (2,5)-(2,6) = "-"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (2,7)-(2,8))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ CallNode (location: (2,7)-(2,8))
        │   │           │           │           ├── flags: variable_call, ignore_visibility
        │   │           │           │           ├── receiver: ∅
        │   │           │           │           ├── call_operator_loc: ∅
        │   │           │           │           ├── name: :b
        │   │           │           │           ├── message_loc: (2,7)-(2,8) = "b"
        │   │           │           │           ├── opening_loc: ∅
        │   │           │           │           ├── arguments: ∅
        │   │           │           │           ├── closing_loc: ∅
        │   │           │           │           └── block: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           └── block: ∅
        │   │           ├── opening_loc: (2,2)-(2,3) = "("
        │   │           └── closing_loc: (2,8)-(2,9) = ")"
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (3,0)-(3,3) = "end"
        └── @ DefNode (location: (5,0)-(7,3))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (5,4)-(5,7) = "foo"
            ├── receiver: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (6,2)-(6,20))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ RescueModifierNode (location: (6,2)-(6,20))
            │           ├── flags: newline
            │           ├── expression:
            │           │   @ CallNode (location: (6,2)-(6,3))
            │           │   ├── flags: variable_call, ignore_visibility
            │           │   ├── receiver: ∅
            │           │   ├── call_operator_loc: ∅
            │           │   ├── name: :a
            │           │   ├── message_loc: (6,2)-(6,3) = "a"
            │           │   ├── opening_loc: ∅
            │           │   ├── arguments: ∅
            │           │   ├── closing_loc: ∅
            │           │   └── block: ∅
            │           ├── keyword_loc: (6,4)-(6,10) = "rescue"
            │           └── rescue_expression:
            │               @ ConstantReadNode (location: (6,11)-(6,20))
            │               ├── flags: ∅
            │               └── name: :Exception
            ├── locals: []
            ├── def_keyword_loc: (5,0)-(5,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (7,0)-(7,3) = "end"
prism-1.5.1/snapshots/unparser/corpus/semantic/dstr.txt000066400000000000000000001137301506127434000233730ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(127,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(127,11))
    ├── flags: ∅
    └── body: (length: 33)
        ├── @ StringNode (location: (1,0)-(1,5))
        │   ├── flags: newline
        │   ├── opening_loc: (1,0)-(1,5) = "<=
            ├── name_loc: (11,4)-(11,6) = ">="
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (11,7)-(11,12))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (11,7)-(11,12))
            │   │       ├── flags: ∅
            │   │       └── name: :other
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (11,16)-(11,28))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (11,16)-(11,28))
            │           ├── flags: variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :do_something
            │           ├── message_loc: (11,16)-(11,28) = "do_something"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── locals: [:other]
            ├── def_keyword_loc: (11,0)-(11,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (11,6)-(11,7) = "("
            ├── rparen_loc: (11,12)-(11,13) = ")"
            ├── equal_loc: (11,14)-(11,15) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/whitequark/endless_method.txt000066400000000000000000000202571506127434000226240ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,22))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(7,22))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ DefNode (location: (1,0)-(1,14))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (1,4)-(1,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (1,12)-(1,14))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (1,12)-(1,14))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 42
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (1,7)-(1,8) = "("
        │   ├── rparen_loc: (1,8)-(1,9) = ")"
        │   ├── equal_loc: (1,10)-(1,11) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (3,0)-(3,18))
        │   ├── flags: newline
        │   ├── name: :inc
        │   ├── name_loc: (3,4)-(3,7) = "inc"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (3,8)-(3,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (3,8)-(3,9))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :x
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (3,13)-(3,18))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (3,13)-(3,18))
        │   │           ├── flags: ∅
        │   │           ├── receiver:
        │   │           │   @ LocalVariableReadNode (location: (3,13)-(3,14))
        │   │           │   ├── flags: ∅
        │   │           │   ├── name: :x
        │   │           │   └── depth: 0
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :+
        │   │           ├── message_loc: (3,15)-(3,16) = "+"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (3,17)-(3,18))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (3,17)-(3,18))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: [:x]
        │   ├── def_keyword_loc: (3,0)-(3,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (3,7)-(3,8) = "("
        │   ├── rparen_loc: (3,9)-(3,10) = ")"
        │   ├── equal_loc: (3,11)-(3,12) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (5,0)-(5,18))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (5,8)-(5,11) = "foo"
        │   ├── receiver:
        │   │   @ CallNode (location: (5,4)-(5,7))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :obj
        │   │   ├── message_loc: (5,4)-(5,7) = "obj"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (5,16)-(5,18))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (5,16)-(5,18))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 42
        │   ├── locals: []
        │   ├── def_keyword_loc: (5,0)-(5,3) = "def"
        │   ├── operator_loc: (5,7)-(5,8) = "."
        │   ├── lparen_loc: (5,11)-(5,12) = "("
        │   ├── rparen_loc: (5,12)-(5,13) = ")"
        │   ├── equal_loc: (5,14)-(5,15) = "="
        │   └── end_keyword_loc: ∅
        └── @ DefNode (location: (7,0)-(7,22))
            ├── flags: newline
            ├── name: :inc
            ├── name_loc: (7,8)-(7,11) = "inc"
            ├── receiver:
            │   @ CallNode (location: (7,4)-(7,7))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :obj
            │   ├── message_loc: (7,4)-(7,7) = "obj"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── parameters:
            │   @ ParametersNode (location: (7,12)-(7,13))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (7,12)-(7,13))
            │   │       ├── flags: ∅
            │   │       └── name: :x
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (7,17)-(7,22))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (7,17)-(7,22))
            │           ├── flags: ∅
            │           ├── receiver:
            │           │   @ LocalVariableReadNode (location: (7,17)-(7,18))
            │           │   ├── flags: ∅
            │           │   ├── name: :x
            │           │   └── depth: 0
            │           ├── call_operator_loc: ∅
            │           ├── name: :+
            │           ├── message_loc: (7,19)-(7,20) = "+"
            │           ├── opening_loc: ∅
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (7,21)-(7,22))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 1)
            │           │       └── @ IntegerNode (location: (7,21)-(7,22))
            │           │           ├── flags: static_literal, decimal
            │           │           └── value: 1
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── locals: [:x]
            ├── def_keyword_loc: (7,0)-(7,3) = "def"
            ├── operator_loc: (7,7)-(7,8) = "."
            ├── lparen_loc: (7,11)-(7,12) = "("
            ├── rparen_loc: (7,13)-(7,14) = ")"
            ├── equal_loc: (7,15)-(7,16) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/whitequark/endless_method_command_syntax.txt000066400000000000000000000603141506127434000257260ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(15,62))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(15,62))
    ├── flags: ∅
    └── body: (length: 8)
        ├── @ DefNode (location: (1,0)-(1,22))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (1,4)-(1,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (1,10)-(1,22))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (1,10)-(1,22))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :puts
        │   │           ├── message_loc: (1,10)-(1,14) = "puts"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (1,15)-(1,22))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ StringNode (location: (1,15)-(1,22))
        │   │           │           ├── flags: ∅
        │   │           │           ├── opening_loc: (1,15)-(1,16) = "\""
        │   │           │           ├── content_loc: (1,16)-(1,21) = "Hello"
        │   │           │           ├── closing_loc: (1,21)-(1,22) = "\""
        │   │           │           └── unescaped: "Hello"
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (1,8)-(1,9) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (3,0)-(3,24))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (3,4)-(3,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (3,12)-(3,24))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (3,12)-(3,24))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :puts
        │   │           ├── message_loc: (3,12)-(3,16) = "puts"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (3,17)-(3,24))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ StringNode (location: (3,17)-(3,24))
        │   │           │           ├── flags: ∅
        │   │           │           ├── opening_loc: (3,17)-(3,18) = "\""
        │   │           │           ├── content_loc: (3,18)-(3,23) = "Hello"
        │   │           │           ├── closing_loc: (3,23)-(3,24) = "\""
        │   │           │           └── unescaped: "Hello"
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (3,0)-(3,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (3,7)-(3,8) = "("
        │   ├── rparen_loc: (3,8)-(3,9) = ")"
        │   ├── equal_loc: (3,10)-(3,11) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (5,0)-(5,19))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (5,4)-(5,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (5,8)-(5,9))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (5,8)-(5,9))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :x
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (5,13)-(5,19))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (5,13)-(5,19))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :puts
        │   │           ├── message_loc: (5,13)-(5,17) = "puts"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (5,18)-(5,19))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ LocalVariableReadNode (location: (5,18)-(5,19))
        │   │           │           ├── flags: ∅
        │   │           │           ├── name: :x
        │   │           │           └── depth: 0
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: [:x]
        │   ├── def_keyword_loc: (5,0)-(5,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (5,7)-(5,8) = "("
        │   ├── rparen_loc: (5,9)-(5,10) = ")"
        │   ├── equal_loc: (5,11)-(5,12) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (7,0)-(7,26))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (7,8)-(7,11) = "foo"
        │   ├── receiver:
        │   │   @ CallNode (location: (7,4)-(7,7))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :obj
        │   │   ├── message_loc: (7,4)-(7,7) = "obj"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (7,14)-(7,26))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (7,14)-(7,26))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :puts
        │   │           ├── message_loc: (7,14)-(7,18) = "puts"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (7,19)-(7,26))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ StringNode (location: (7,19)-(7,26))
        │   │           │           ├── flags: ∅
        │   │           │           ├── opening_loc: (7,19)-(7,20) = "\""
        │   │           │           ├── content_loc: (7,20)-(7,25) = "Hello"
        │   │           │           ├── closing_loc: (7,25)-(7,26) = "\""
        │   │           │           └── unescaped: "Hello"
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (7,0)-(7,3) = "def"
        │   ├── operator_loc: (7,7)-(7,8) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (7,12)-(7,13) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (9,0)-(9,28))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (9,8)-(9,11) = "foo"
        │   ├── receiver:
        │   │   @ CallNode (location: (9,4)-(9,7))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :obj
        │   │   ├── message_loc: (9,4)-(9,7) = "obj"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (9,16)-(9,28))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (9,16)-(9,28))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :puts
        │   │           ├── message_loc: (9,16)-(9,20) = "puts"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (9,21)-(9,28))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ StringNode (location: (9,21)-(9,28))
        │   │           │           ├── flags: ∅
        │   │           │           ├── opening_loc: (9,21)-(9,22) = "\""
        │   │           │           ├── content_loc: (9,22)-(9,27) = "Hello"
        │   │           │           ├── closing_loc: (9,27)-(9,28) = "\""
        │   │           │           └── unescaped: "Hello"
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (9,0)-(9,3) = "def"
        │   ├── operator_loc: (9,7)-(9,8) = "."
        │   ├── lparen_loc: (9,11)-(9,12) = "("
        │   ├── rparen_loc: (9,12)-(9,13) = ")"
        │   ├── equal_loc: (9,14)-(9,15) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (11,0)-(11,23))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (11,8)-(11,11) = "foo"
        │   ├── receiver:
        │   │   @ CallNode (location: (11,4)-(11,7))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :obj
        │   │   ├── message_loc: (11,4)-(11,7) = "obj"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (11,12)-(11,13))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (11,12)-(11,13))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :x
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (11,17)-(11,23))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (11,17)-(11,23))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :puts
        │   │           ├── message_loc: (11,17)-(11,21) = "puts"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (11,22)-(11,23))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ LocalVariableReadNode (location: (11,22)-(11,23))
        │   │           │           ├── flags: ∅
        │   │           │           ├── name: :x
        │   │           │           └── depth: 0
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: [:x]
        │   ├── def_keyword_loc: (11,0)-(11,3) = "def"
        │   ├── operator_loc: (11,7)-(11,8) = "."
        │   ├── lparen_loc: (11,11)-(11,12) = "("
        │   ├── rparen_loc: (11,13)-(11,14) = ")"
        │   ├── equal_loc: (11,15)-(11,16) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (13,0)-(13,60))
        │   ├── flags: newline
        │   ├── name: :rescued
        │   ├── name_loc: (13,4)-(13,11) = "rescued"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (13,12)-(13,13))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (13,12)-(13,13))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :x
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (13,17)-(13,60))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ RescueModifierNode (location: (13,17)-(13,60))
        │   │           ├── flags: ∅
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (13,17)-(13,37))
        │   │           │   ├── flags: ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :raise
        │   │           │   ├── message_loc: (13,17)-(13,22) = "raise"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments:
        │   │           │   │   @ ArgumentsNode (location: (13,23)-(13,37))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   └── arguments: (length: 1)
        │   │           │   │       └── @ StringNode (location: (13,23)-(13,37))
        │   │           │   │           ├── flags: ∅
        │   │           │   │           ├── opening_loc: (13,23)-(13,24) = "\""
        │   │           │   │           ├── content_loc: (13,24)-(13,36) = "to be caught"
        │   │           │   │           ├── closing_loc: (13,36)-(13,37) = "\""
        │   │           │   │           └── unescaped: "to be caught"
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── keyword_loc: (13,38)-(13,44) = "rescue"
        │   │           └── rescue_expression:
        │   │               @ InterpolatedStringNode (location: (13,45)-(13,60))
        │   │               ├── flags: ∅
        │   │               ├── opening_loc: (13,45)-(13,46) = "\""
        │   │               ├── parts: (length: 2)
        │   │               │   ├── @ StringNode (location: (13,46)-(13,55))
        │   │               │   │   ├── flags: static_literal, frozen
        │   │               │   │   ├── opening_loc: ∅
        │   │               │   │   ├── content_loc: (13,46)-(13,55) = "instance "
        │   │               │   │   ├── closing_loc: ∅
        │   │               │   │   └── unescaped: "instance "
        │   │               │   └── @ EmbeddedStatementsNode (location: (13,55)-(13,59))
        │   │               │       ├── flags: ∅
        │   │               │       ├── opening_loc: (13,55)-(13,57) = "\#{"
        │   │               │       ├── statements:
        │   │               │       │   @ StatementsNode (location: (13,57)-(13,58))
        │   │               │       │   ├── flags: ∅
        │   │               │       │   └── body: (length: 1)
        │   │               │       │       └── @ LocalVariableReadNode (location: (13,57)-(13,58))
        │   │               │       │           ├── flags: ∅
        │   │               │       │           ├── name: :x
        │   │               │       │           └── depth: 0
        │   │               │       └── closing_loc: (13,58)-(13,59) = "}"
        │   │               └── closing_loc: (13,59)-(13,60) = "\""
        │   ├── locals: [:x]
        │   ├── def_keyword_loc: (13,0)-(13,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (13,11)-(13,12) = "("
        │   ├── rparen_loc: (13,13)-(13,14) = ")"
        │   ├── equal_loc: (13,15)-(13,16) = "="
        │   └── end_keyword_loc: ∅
        └── @ DefNode (location: (15,0)-(15,62))
            ├── flags: newline
            ├── name: :rescued
            ├── name_loc: (15,9)-(15,16) = "rescued"
            ├── receiver:
            │   @ SelfNode (location: (15,4)-(15,8))
            │   └── flags: ∅
            ├── parameters:
            │   @ ParametersNode (location: (15,17)-(15,18))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (15,17)-(15,18))
            │   │       ├── flags: ∅
            │   │       └── name: :x
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (15,22)-(15,62))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ RescueModifierNode (location: (15,22)-(15,62))
            │           ├── flags: ∅
            │           ├── expression:
            │           │   @ CallNode (location: (15,22)-(15,42))
            │           │   ├── flags: ignore_visibility
            │           │   ├── receiver: ∅
            │           │   ├── call_operator_loc: ∅
            │           │   ├── name: :raise
            │           │   ├── message_loc: (15,22)-(15,27) = "raise"
            │           │   ├── opening_loc: ∅
            │           │   ├── arguments:
            │           │   │   @ ArgumentsNode (location: (15,28)-(15,42))
            │           │   │   ├── flags: ∅
            │           │   │   └── arguments: (length: 1)
            │           │   │       └── @ StringNode (location: (15,28)-(15,42))
            │           │   │           ├── flags: ∅
            │           │   │           ├── opening_loc: (15,28)-(15,29) = "\""
            │           │   │           ├── content_loc: (15,29)-(15,41) = "to be caught"
            │           │   │           ├── closing_loc: (15,41)-(15,42) = "\""
            │           │   │           └── unescaped: "to be caught"
            │           │   ├── closing_loc: ∅
            │           │   └── block: ∅
            │           ├── keyword_loc: (15,43)-(15,49) = "rescue"
            │           └── rescue_expression:
            │               @ InterpolatedStringNode (location: (15,50)-(15,62))
            │               ├── flags: ∅
            │               ├── opening_loc: (15,50)-(15,51) = "\""
            │               ├── parts: (length: 2)
            │               │   ├── @ StringNode (location: (15,51)-(15,57))
            │               │   │   ├── flags: static_literal, frozen
            │               │   │   ├── opening_loc: ∅
            │               │   │   ├── content_loc: (15,51)-(15,57) = "class "
            │               │   │   ├── closing_loc: ∅
            │               │   │   └── unescaped: "class "
            │               │   └── @ EmbeddedStatementsNode (location: (15,57)-(15,61))
            │               │       ├── flags: ∅
            │               │       ├── opening_loc: (15,57)-(15,59) = "\#{"
            │               │       ├── statements:
            │               │       │   @ StatementsNode (location: (15,59)-(15,60))
            │               │       │   ├── flags: ∅
            │               │       │   └── body: (length: 1)
            │               │       │       └── @ LocalVariableReadNode (location: (15,59)-(15,60))
            │               │       │           ├── flags: ∅
            │               │       │           ├── name: :x
            │               │       │           └── depth: 0
            │               │       └── closing_loc: (15,60)-(15,61) = "}"
            │               └── closing_loc: (15,61)-(15,62) = "\""
            ├── locals: [:x]
            ├── def_keyword_loc: (15,0)-(15,3) = "def"
            ├── operator_loc: (15,8)-(15,9) = "."
            ├── lparen_loc: (15,16)-(15,17) = "("
            ├── rparen_loc: (15,18)-(15,19) = ")"
            ├── equal_loc: (15,20)-(15,21) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/whitequark/endless_method_forwarded_args_legacy.txt000066400000000000000000000046241506127434000272210ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,23))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,23))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,23))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (1,4)-(1,7) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,8)-(1,11))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ ForwardingParameterNode (location: (1,8)-(1,11))
            │   │   └── flags: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,15)-(1,23))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,15)-(1,23))
            │           ├── flags: ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (1,15)-(1,18) = "bar"
            │           ├── opening_loc: (1,18)-(1,19) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,19)-(1,22))
            │           │   ├── flags: contains_forwarding
            │           │   └── arguments: (length: 1)
            │           │       └── @ ForwardingArgumentsNode (location: (1,19)-(1,22))
            │           │           └── flags: ∅
            │           ├── closing_loc: (1,22)-(1,23) = ")"
            │           └── block: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,7)-(1,8) = "("
            ├── rparen_loc: (1,11)-(1,12) = ")"
            ├── equal_loc: (1,13)-(1,14) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/whitequark/endless_method_with_rescue_mod.txt000066400000000000000000000062551506127434000260660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,25))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,25))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ DefNode (location: (1,0)-(1,20))
        │   ├── flags: newline
        │   ├── name: :m
        │   ├── name_loc: (1,4)-(1,5) = "m"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (1,10)-(1,20))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ RescueModifierNode (location: (1,10)-(1,20))
        │   │           ├── flags: ∅
        │   │           ├── expression:
        │   │           │   @ IntegerNode (location: (1,10)-(1,11))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 1
        │   │           ├── keyword_loc: (1,12)-(1,18) = "rescue"
        │   │           └── rescue_expression:
        │   │               @ IntegerNode (location: (1,19)-(1,20))
        │   │               ├── flags: static_literal, decimal
        │   │               └── value: 2
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (1,5)-(1,6) = "("
        │   ├── rparen_loc: (1,6)-(1,7) = ")"
        │   ├── equal_loc: (1,8)-(1,9) = "="
        │   └── end_keyword_loc: ∅
        └── @ DefNode (location: (3,0)-(3,25))
            ├── flags: newline
            ├── name: :m
            ├── name_loc: (3,9)-(3,10) = "m"
            ├── receiver:
            │   @ SelfNode (location: (3,4)-(3,8))
            │   └── flags: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (3,15)-(3,25))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ RescueModifierNode (location: (3,15)-(3,25))
            │           ├── flags: ∅
            │           ├── expression:
            │           │   @ IntegerNode (location: (3,15)-(3,16))
            │           │   ├── flags: static_literal, decimal
            │           │   └── value: 1
            │           ├── keyword_loc: (3,17)-(3,23) = "rescue"
            │           └── rescue_expression:
            │               @ IntegerNode (location: (3,24)-(3,25))
            │               ├── flags: static_literal, decimal
            │               └── value: 2
            ├── locals: []
            ├── def_keyword_loc: (3,0)-(3,3) = "def"
            ├── operator_loc: (3,8)-(3,9) = "."
            ├── lparen_loc: (3,10)-(3,11) = "("
            ├── rparen_loc: (3,11)-(3,12) = ")"
            ├── equal_loc: (3,13)-(3,14) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/whitequark/endless_method_without_args.txt000066400000000000000000000117221506127434000254200ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,28))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(7,28))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ DefNode (location: (1,0)-(1,12))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (1,4)-(1,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (1,10)-(1,12))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (1,10)-(1,12))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 42
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (1,8)-(1,9) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (3,0)-(3,23))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (3,4)-(3,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (3,10)-(3,23))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ RescueModifierNode (location: (3,10)-(3,23))
        │   │           ├── flags: ∅
        │   │           ├── expression:
        │   │           │   @ IntegerNode (location: (3,10)-(3,12))
        │   │           │   ├── flags: static_literal, decimal
        │   │           │   └── value: 42
        │   │           ├── keyword_loc: (3,13)-(3,19) = "rescue"
        │   │           └── rescue_expression:
        │   │               @ NilNode (location: (3,20)-(3,23))
        │   │               └── flags: static_literal
        │   ├── locals: []
        │   ├── def_keyword_loc: (3,0)-(3,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (3,8)-(3,9) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (5,0)-(5,17))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (5,9)-(5,12) = "foo"
        │   ├── receiver:
        │   │   @ SelfNode (location: (5,4)-(5,8))
        │   │   └── flags: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (5,15)-(5,17))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ IntegerNode (location: (5,15)-(5,17))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 42
        │   ├── locals: []
        │   ├── def_keyword_loc: (5,0)-(5,3) = "def"
        │   ├── operator_loc: (5,8)-(5,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (5,13)-(5,14) = "="
        │   └── end_keyword_loc: ∅
        └── @ DefNode (location: (7,0)-(7,28))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (7,9)-(7,12) = "foo"
            ├── receiver:
            │   @ SelfNode (location: (7,4)-(7,8))
            │   └── flags: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (7,15)-(7,28))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ RescueModifierNode (location: (7,15)-(7,28))
            │           ├── flags: ∅
            │           ├── expression:
            │           │   @ IntegerNode (location: (7,15)-(7,17))
            │           │   ├── flags: static_literal, decimal
            │           │   └── value: 42
            │           ├── keyword_loc: (7,18)-(7,24) = "rescue"
            │           └── rescue_expression:
            │               @ NilNode (location: (7,25)-(7,28))
            │               └── flags: static_literal
            ├── locals: []
            ├── def_keyword_loc: (7,0)-(7,3) = "def"
            ├── operator_loc: (7,8)-(7,9) = "."
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: (7,13)-(7,14) = "="
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/whitequark/ensure.txt000066400000000000000000000045241506127434000211270ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,29))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,29))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ BeginNode (location: (1,0)-(1,29))
            ├── flags: newline
            ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
            ├── statements:
            │   @ StatementsNode (location: (1,7)-(1,11))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,7)-(1,11))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :meth
            │           ├── message_loc: (1,7)-(1,11) = "meth"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── rescue_clause: ∅
            ├── else_clause: ∅
            ├── ensure_clause:
            │   @ EnsureNode (location: (1,13)-(1,29))
            │   ├── flags: ∅
            │   ├── ensure_keyword_loc: (1,13)-(1,19) = "ensure"
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,21)-(1,24))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (1,21)-(1,24))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :bar
            │   │           ├── message_loc: (1,21)-(1,24) = "bar"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── end_keyword_loc: (1,26)-(1,29) = "end"
            └── end_keyword_loc: (1,26)-(1,29) = "end"
prism-1.5.1/snapshots/whitequark/ensure_empty.txt000066400000000000000000000015271506127434000223450ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,16))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,16))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ BeginNode (location: (1,0)-(1,16))
            ├── flags: newline
            ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
            ├── statements: ∅
            ├── rescue_clause: ∅
            ├── else_clause: ∅
            ├── ensure_clause:
            │   @ EnsureNode (location: (1,6)-(1,16))
            │   ├── flags: ∅
            │   ├── ensure_keyword_loc: (1,6)-(1,12) = "ensure"
            │   ├── statements: ∅
            │   └── end_keyword_loc: (1,13)-(1,16) = "end"
            └── end_keyword_loc: (1,13)-(1,16) = "end"
prism-1.5.1/snapshots/whitequark/false.txt000066400000000000000000000004671506127434000207220ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ FalseNode (location: (1,0)-(1,5))
            └── flags: newline, static_literal
prism-1.5.1/snapshots/whitequark/find_pattern.txt000066400000000000000000000307211506127434000223010ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,44))
├── flags: ∅
├── locals: [:x, :a, :y]
└── statements:
    @ StatementsNode (location: (1,0)-(7,44))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ CaseMatchNode (location: (1,0)-(1,36))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (1,5)-(1,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,5)-(1,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (1,10)-(1,31))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ FindPatternNode (location: (1,13)-(1,21))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── left:
        │   │       │   │   @ SplatNode (location: (1,13)-(1,14))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (1,13)-(1,14) = "*"
        │   │       │   │   └── expression: ∅
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ IntegerNode (location: (1,16)-(1,18))
        │   │       │   │       ├── flags: static_literal, decimal
        │   │       │   │       └── value: 42
        │   │       │   ├── right:
        │   │       │   │   @ SplatNode (location: (1,20)-(1,21))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (1,20)-(1,21) = "*"
        │   │       │   │   └── expression: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (1,27)-(1,31))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (1,27)-(1,31))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (1,10)-(1,12) = "in"
        │   │       └── then_loc: (1,22)-(1,26) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (1,33)-(1,36) = "end"
        ├── @ CaseMatchNode (location: (3,0)-(3,42))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (3,5)-(3,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,5)-(3,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3,10)-(3,37))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ FindPatternNode (location: (3,13)-(3,27))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (3,13)-(3,18))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :Array
        │   │       │   ├── left:
        │   │       │   │   @ SplatNode (location: (3,19)-(3,20))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (3,19)-(3,20) = "*"
        │   │       │   │   └── expression: ∅
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ IntegerNode (location: (3,22)-(3,23))
        │   │       │   │       ├── flags: static_literal, decimal
        │   │       │   │       └── value: 1
        │   │       │   ├── right:
        │   │       │   │   @ SplatNode (location: (3,25)-(3,26))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (3,25)-(3,26) = "*"
        │   │       │   │   └── expression: ∅
        │   │       │   ├── opening_loc: (3,18)-(3,19) = "["
        │   │       │   └── closing_loc: (3,26)-(3,27) = "]"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (3,33)-(3,37))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (3,33)-(3,37))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (3,10)-(3,12) = "in"
        │   │       └── then_loc: (3,28)-(3,32) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (3,0)-(3,4) = "case"
        │   └── end_keyword_loc: (3,39)-(3,42) = "end"
        ├── @ CaseMatchNode (location: (5,0)-(5,43))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (5,5)-(5,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (5,5)-(5,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (5,10)-(5,38))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ FindPatternNode (location: (5,13)-(5,28))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (5,13)-(5,19))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :String
        │   │       │   ├── left:
        │   │       │   │   @ SplatNode (location: (5,20)-(5,21))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (5,20)-(5,21) = "*"
        │   │       │   │   └── expression: ∅
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ IntegerNode (location: (5,23)-(5,24))
        │   │       │   │       ├── flags: static_literal, decimal
        │   │       │   │       └── value: 1
        │   │       │   ├── right:
        │   │       │   │   @ SplatNode (location: (5,26)-(5,27))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (5,26)-(5,27) = "*"
        │   │       │   │   └── expression: ∅
        │   │       │   ├── opening_loc: (5,19)-(5,20) = "("
        │   │       │   └── closing_loc: (5,27)-(5,28) = ")"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (5,34)-(5,38))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (5,34)-(5,38))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (5,10)-(5,12) = "in"
        │   │       └── then_loc: (5,29)-(5,33) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (5,0)-(5,4) = "case"
        │   └── end_keyword_loc: (5,40)-(5,43) = "end"
        └── @ CaseMatchNode (location: (7,0)-(7,44))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (7,5)-(7,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (7,5)-(7,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (7,10)-(7,39))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ FindPatternNode (location: (7,13)-(7,29))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── left:
            │       │   │   @ SplatNode (location: (7,14)-(7,16))
            │       │   │   ├── flags: ∅
            │       │   │   ├── operator_loc: (7,14)-(7,15) = "*"
            │       │   │   └── expression:
            │       │   │       @ LocalVariableTargetNode (location: (7,15)-(7,16))
            │       │   │       ├── flags: ∅
            │       │   │       ├── name: :x
            │       │   │       └── depth: 0
            │       │   ├── requireds: (length: 1)
            │       │   │   └── @ CapturePatternNode (location: (7,18)-(7,24))
            │       │   │       ├── flags: ∅
            │       │   │       ├── value:
            │       │   │       │   @ IntegerNode (location: (7,18)-(7,19))
            │       │   │       │   ├── flags: static_literal, decimal
            │       │   │       │   └── value: 1
            │       │   │       ├── target:
            │       │   │       │   @ LocalVariableTargetNode (location: (7,23)-(7,24))
            │       │   │       │   ├── flags: ∅
            │       │   │       │   ├── name: :a
            │       │   │       │   └── depth: 0
            │       │   │       └── operator_loc: (7,20)-(7,22) = "=>"
            │       │   ├── right:
            │       │   │   @ SplatNode (location: (7,26)-(7,28))
            │       │   │   ├── flags: ∅
            │       │   │   ├── operator_loc: (7,26)-(7,27) = "*"
            │       │   │   └── expression:
            │       │   │       @ LocalVariableTargetNode (location: (7,27)-(7,28))
            │       │   │       ├── flags: ∅
            │       │   │       ├── name: :y
            │       │   │       └── depth: 0
            │       │   ├── opening_loc: (7,13)-(7,14) = "["
            │       │   └── closing_loc: (7,28)-(7,29) = "]"
            │       ├── statements:
            │       │   @ StatementsNode (location: (7,35)-(7,39))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ TrueNode (location: (7,35)-(7,39))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (7,10)-(7,12) = "in"
            │       └── then_loc: (7,30)-(7,34) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (7,0)-(7,4) = "case"
            └── end_keyword_loc: (7,41)-(7,44) = "end"
prism-1.5.1/snapshots/whitequark/float.txt000066400000000000000000000007531506127434000207330ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,4))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ FloatNode (location: (1,0)-(1,5))
        │   ├── flags: newline, static_literal
        │   └── value: -1.33
        └── @ FloatNode (location: (3,0)-(3,4))
            ├── flags: newline, static_literal
            └── value: 1.33
prism-1.5.1/snapshots/whitequark/for.txt000066400000000000000000000113111506127434000204040ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,22))
├── flags: ∅
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (1,0)-(3,22))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ ForNode (location: (1,0)-(1,24))
        │   ├── flags: newline
        │   ├── index:
        │   │   @ LocalVariableTargetNode (location: (1,4)-(1,5))
        │   │   ├── flags: ∅
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── collection:
        │   │   @ CallNode (location: (1,9)-(1,12))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,9)-(1,12) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (1,16)-(1,19))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (1,16)-(1,19))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :p
        │   │           ├── message_loc: (1,16)-(1,17) = "p"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (1,18)-(1,19))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ LocalVariableReadNode (location: (1,18)-(1,19))
        │   │           │           ├── flags: ∅
        │   │           │           ├── name: :a
        │   │           │           └── depth: 0
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── for_keyword_loc: (1,0)-(1,3) = "for"
        │   ├── in_keyword_loc: (1,6)-(1,8) = "in"
        │   ├── do_keyword_loc: (1,13)-(1,15) = "do"
        │   └── end_keyword_loc: (1,21)-(1,24) = "end"
        └── @ ForNode (location: (3,0)-(3,22))
            ├── flags: newline
            ├── index:
            │   @ LocalVariableTargetNode (location: (3,4)-(3,5))
            │   ├── flags: ∅
            │   ├── name: :a
            │   └── depth: 0
            ├── collection:
            │   @ CallNode (location: (3,9)-(3,12))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (3,9)-(3,12) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── statements:
            │   @ StatementsNode (location: (3,14)-(3,17))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (3,14)-(3,17))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :p
            │           ├── message_loc: (3,14)-(3,15) = "p"
            │           ├── opening_loc: ∅
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (3,16)-(3,17))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 1)
            │           │       └── @ LocalVariableReadNode (location: (3,16)-(3,17))
            │           │           ├── flags: ∅
            │           │           ├── name: :a
            │           │           └── depth: 0
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── for_keyword_loc: (3,0)-(3,3) = "for"
            ├── in_keyword_loc: (3,6)-(3,8) = "in"
            ├── do_keyword_loc: ∅
            └── end_keyword_loc: (3,19)-(3,22) = "end"
prism-1.5.1/snapshots/whitequark/for_mlhs.txt000066400000000000000000000064211506127434000214350ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,28))
├── flags: ∅
├── locals: [:a, :b]
└── statements:
    @ StatementsNode (location: (1,0)-(1,28))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ForNode (location: (1,0)-(1,28))
            ├── flags: newline
            ├── index:
            │   @ MultiTargetNode (location: (1,4)-(1,8))
            │   ├── flags: ∅
            │   ├── lefts: (length: 2)
            │   │   ├── @ LocalVariableTargetNode (location: (1,4)-(1,5))
            │   │   │   ├── flags: ∅
            │   │   │   ├── name: :a
            │   │   │   └── depth: 0
            │   │   └── @ LocalVariableTargetNode (location: (1,7)-(1,8))
            │   │       ├── flags: ∅
            │   │       ├── name: :b
            │   │       └── depth: 0
            │   ├── rest: ∅
            │   ├── rights: (length: 0)
            │   ├── lparen_loc: ∅
            │   └── rparen_loc: ∅
            ├── collection:
            │   @ CallNode (location: (1,12)-(1,15))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,12)-(1,15) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── statements:
            │   @ StatementsNode (location: (1,17)-(1,23))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,17)-(1,23))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :p
            │           ├── message_loc: (1,17)-(1,18) = "p"
            │           ├── opening_loc: ∅
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,19)-(1,23))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 2)
            │           │       ├── @ LocalVariableReadNode (location: (1,19)-(1,20))
            │           │       │   ├── flags: ∅
            │           │       │   ├── name: :a
            │           │       │   └── depth: 0
            │           │       └── @ LocalVariableReadNode (location: (1,22)-(1,23))
            │           │           ├── flags: ∅
            │           │           ├── name: :b
            │           │           └── depth: 0
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── for_keyword_loc: (1,0)-(1,3) = "for"
            ├── in_keyword_loc: (1,9)-(1,11) = "in"
            ├── do_keyword_loc: ∅
            └── end_keyword_loc: (1,25)-(1,28) = "end"
prism-1.5.1/snapshots/whitequark/forward_arg.txt000066400000000000000000000046371506127434000221300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,27))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,27))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,27))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (1,4)-(1,7) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,8)-(1,11))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ ForwardingParameterNode (location: (1,8)-(1,11))
            │   │   └── flags: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,14)-(1,22))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,14)-(1,22))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (1,14)-(1,17) = "bar"
            │           ├── opening_loc: (1,17)-(1,18) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,18)-(1,21))
            │           │   ├── flags: contains_forwarding
            │           │   └── arguments: (length: 1)
            │           │       └── @ ForwardingArgumentsNode (location: (1,18)-(1,21))
            │           │           └── flags: ∅
            │           ├── closing_loc: (1,21)-(1,22) = ")"
            │           └── block: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,7)-(1,8) = "("
            ├── rparen_loc: (1,11)-(1,12) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,24)-(1,27) = "end"
prism-1.5.1/snapshots/whitequark/forward_arg_with_open_args.txt000066400000000000000000000620101506127434000252050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(27,28))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(27,28))
    ├── flags: ∅
    └── body: (length: 10)
        ├── @ ParenthesesNode (location: (1,0)-(3,4))
        │   ├── flags: newline
        │   ├── body:
        │   │   @ StatementsNode (location: (1,1)-(3,3))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ DefNode (location: (1,1)-(3,3))
        │   │           ├── flags: newline
        │   │           ├── name: :foo
        │   │           ├── name_loc: (1,5)-(1,8) = "foo"
        │   │           ├── receiver: ∅
        │   │           ├── parameters:
        │   │           │   @ ParametersNode (location: (1,9)-(1,12))
        │   │           │   ├── flags: ∅
        │   │           │   ├── requireds: (length: 0)
        │   │           │   ├── optionals: (length: 0)
        │   │           │   ├── rest: ∅
        │   │           │   ├── posts: (length: 0)
        │   │           │   ├── keywords: (length: 0)
        │   │           │   ├── keyword_rest:
        │   │           │   │   @ ForwardingParameterNode (location: (1,9)-(1,12))
        │   │           │   │   └── flags: ∅
        │   │           │   └── block: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (2,2)-(2,10))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (2,2)-(2,10))
        │   │           │           ├── flags: newline, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :bar
        │   │           │           ├── message_loc: (2,2)-(2,5) = "bar"
        │   │           │           ├── opening_loc: (2,5)-(2,6) = "("
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (2,6)-(2,9))
        │   │           │           │   ├── flags: contains_forwarding
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ ForwardingArgumentsNode (location: (2,6)-(2,9))
        │   │           │           │           └── flags: ∅
        │   │           │           ├── closing_loc: (2,9)-(2,10) = ")"
        │   │           │           └── block: ∅
        │   │           ├── locals: []
        │   │           ├── def_keyword_loc: (1,1)-(1,4) = "def"
        │   │           ├── operator_loc: ∅
        │   │           ├── lparen_loc: ∅
        │   │           ├── rparen_loc: ∅
        │   │           ├── equal_loc: ∅
        │   │           └── end_keyword_loc: (3,0)-(3,3) = "end"
        │   ├── opening_loc: (1,0)-(1,1) = "("
        │   └── closing_loc: (3,3)-(3,4) = ")"
        ├── @ ParenthesesNode (location: (5,0)-(5,28))
        │   ├── flags: newline
        │   ├── body:
        │   │   @ StatementsNode (location: (5,1)-(5,27))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ DefNode (location: (5,1)-(5,27))
        │   │           ├── flags: newline
        │   │           ├── name: :foo
        │   │           ├── name_loc: (5,5)-(5,8) = "foo"
        │   │           ├── receiver: ∅
        │   │           ├── parameters:
        │   │           │   @ ParametersNode (location: (5,9)-(5,12))
        │   │           │   ├── flags: ∅
        │   │           │   ├── requireds: (length: 0)
        │   │           │   ├── optionals: (length: 0)
        │   │           │   ├── rest: ∅
        │   │           │   ├── posts: (length: 0)
        │   │           │   ├── keywords: (length: 0)
        │   │           │   ├── keyword_rest:
        │   │           │   │   @ ForwardingParameterNode (location: (5,9)-(5,12))
        │   │           │   │   └── flags: ∅
        │   │           │   └── block: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (5,14)-(5,22))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ CallNode (location: (5,14)-(5,22))
        │   │           │           ├── flags: newline, ignore_visibility
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── name: :bar
        │   │           │           ├── message_loc: (5,14)-(5,17) = "bar"
        │   │           │           ├── opening_loc: (5,17)-(5,18) = "("
        │   │           │           ├── arguments:
        │   │           │           │   @ ArgumentsNode (location: (5,18)-(5,21))
        │   │           │           │   ├── flags: contains_forwarding
        │   │           │           │   └── arguments: (length: 1)
        │   │           │           │       └── @ ForwardingArgumentsNode (location: (5,18)-(5,21))
        │   │           │           │           └── flags: ∅
        │   │           │           ├── closing_loc: (5,21)-(5,22) = ")"
        │   │           │           └── block: ∅
        │   │           ├── locals: []
        │   │           ├── def_keyword_loc: (5,1)-(5,4) = "def"
        │   │           ├── operator_loc: ∅
        │   │           ├── lparen_loc: ∅
        │   │           ├── rparen_loc: ∅
        │   │           ├── equal_loc: ∅
        │   │           └── end_keyword_loc: (5,24)-(5,27) = "end"
        │   ├── opening_loc: (5,0)-(5,1) = "("
        │   └── closing_loc: (5,27)-(5,28) = ")"
        ├── @ DefNode (location: (7,0)-(8,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (7,4)-(7,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (7,8)-(7,11))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (7,8)-(7,11))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (7,0)-(7,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (8,0)-(8,3) = "end"
        ├── @ DefNode (location: (10,0)-(10,26))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (10,4)-(10,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (10,8)-(10,11))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (10,8)-(10,11))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (10,13)-(10,21))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (10,13)-(10,21))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (10,13)-(10,16) = "bar"
        │   │           ├── opening_loc: (10,16)-(10,17) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (10,17)-(10,20))
        │   │           │   ├── flags: contains_forwarding
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (10,17)-(10,20))
        │   │           │           └── flags: ∅
        │   │           ├── closing_loc: (10,20)-(10,21) = ")"
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (10,0)-(10,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (10,23)-(10,26) = "end"
        ├── @ DefNode (location: (12,0)-(14,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (12,4)-(12,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (12,8)-(12,14))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (12,8)-(12,9))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (12,11)-(12,14))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (13,2)-(13,10))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (13,2)-(13,10))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (13,2)-(13,5) = "bar"
        │   │           ├── opening_loc: (13,5)-(13,6) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (13,6)-(13,9))
        │   │           │   ├── flags: contains_forwarding
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (13,6)-(13,9))
        │   │           │           └── flags: ∅
        │   │           ├── closing_loc: (13,9)-(13,10) = ")"
        │   │           └── block: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (12,0)-(12,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (14,0)-(14,3) = "end"
        ├── @ DefNode (location: (16,0)-(16,29))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (16,4)-(16,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (16,8)-(16,14))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (16,8)-(16,9))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (16,11)-(16,14))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (16,16)-(16,24))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (16,16)-(16,24))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (16,16)-(16,19) = "bar"
        │   │           ├── opening_loc: (16,19)-(16,20) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (16,20)-(16,23))
        │   │           │   ├── flags: contains_forwarding
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (16,20)-(16,23))
        │   │           │           └── flags: ∅
        │   │           ├── closing_loc: (16,23)-(16,24) = ")"
        │   │           └── block: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (16,0)-(16,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (16,26)-(16,29) = "end"
        ├── @ DefNode (location: (18,0)-(19,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (18,4)-(18,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (18,8)-(18,21))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ RequiredParameterNode (location: (18,8)-(18,9))
        │   │   │       ├── flags: ∅
        │   │   │       └── name: :a
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (18,11)-(18,16))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :b
        │   │   │       ├── name_loc: (18,11)-(18,12) = "b"
        │   │   │       ├── operator_loc: (18,13)-(18,14) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (18,15)-(18,16))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (18,18)-(18,21))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :b]
        │   ├── def_keyword_loc: (18,0)-(18,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (19,0)-(19,3) = "end"
        ├── @ DefNode (location: (21,0)-(23,3))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (21,4)-(21,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (21,8)-(21,18))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (21,8)-(21,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :b
        │   │   │       ├── name_loc: (21,8)-(21,9) = "b"
        │   │   │       ├── operator_loc: (21,10)-(21,11) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (21,12)-(21,13))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (21,15)-(21,18))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (22,2)-(22,10))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (22,2)-(22,10))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (22,2)-(22,5) = "bar"
        │   │           ├── opening_loc: (22,5)-(22,6) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (22,6)-(22,9))
        │   │           │   ├── flags: contains_forwarding
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (22,6)-(22,9))
        │   │           │           └── flags: ∅
        │   │           ├── closing_loc: (22,9)-(22,10) = ")"
        │   │           └── block: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (21,0)-(21,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (23,0)-(23,3) = "end"
        ├── @ DefNode (location: (25,0)-(25,33))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (25,4)-(25,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (25,8)-(25,18))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (25,8)-(25,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :b
        │   │   │       ├── name_loc: (25,8)-(25,9) = "b"
        │   │   │       ├── operator_loc: (25,10)-(25,11) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (25,12)-(25,13))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (25,15)-(25,18))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (25,20)-(25,28))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (25,20)-(25,28))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (25,20)-(25,23) = "bar"
        │   │           ├── opening_loc: (25,23)-(25,24) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (25,24)-(25,27))
        │   │           │   ├── flags: contains_forwarding
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (25,24)-(25,27))
        │   │           │           └── flags: ∅
        │   │           ├── closing_loc: (25,27)-(25,28) = ")"
        │   │           └── block: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (25,0)-(25,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (25,30)-(25,33) = "end"
        └── @ DefNode (location: (27,0)-(27,28))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (27,4)-(27,7) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (27,8)-(27,14))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (27,8)-(27,9))
            │   │       ├── flags: ∅
            │   │       └── name: :a
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ ForwardingParameterNode (location: (27,11)-(27,14))
            │   │   └── flags: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (27,16)-(27,24))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (27,16)-(27,24))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (27,16)-(27,19) = "bar"
            │           ├── opening_loc: (27,19)-(27,20) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (27,20)-(27,23))
            │           │   ├── flags: contains_forwarding
            │           │   └── arguments: (length: 1)
            │           │       └── @ ForwardingArgumentsNode (location: (27,20)-(27,23))
            │           │           └── flags: ∅
            │           ├── closing_loc: (27,23)-(27,24) = ")"
            │           └── block: ∅
            ├── locals: [:a]
            ├── def_keyword_loc: (27,0)-(27,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (27,7)-(27,8) = "("
            ├── rparen_loc: (27,14)-(27,15) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (27,25)-(27,28) = "end"
prism-1.5.1/snapshots/whitequark/forward_args_legacy.txt000066400000000000000000000133041506127434000236260ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,29))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,29))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ DefNode (location: (1,0)-(1,27))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (1,4)-(1,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (1,8)-(1,11))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (1,8)-(1,11))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (1,14)-(1,22))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (1,14)-(1,22))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (1,14)-(1,17) = "bar"
        │   │           ├── opening_loc: (1,17)-(1,18) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (1,18)-(1,21))
        │   │           │   ├── flags: contains_forwarding
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ ForwardingArgumentsNode (location: (1,18)-(1,21))
        │   │           │           └── flags: ∅
        │   │           ├── closing_loc: (1,21)-(1,22) = ")"
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (1,7)-(1,8) = "("
        │   ├── rparen_loc: (1,11)-(1,12) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (1,24)-(1,27) = "end"
        ├── @ DefNode (location: (3,0)-(3,17))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (3,4)-(3,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (3,8)-(3,11))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest:
        │   │   │   @ ForwardingParameterNode (location: (3,8)-(3,11))
        │   │   │   └── flags: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (3,0)-(3,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (3,7)-(3,8) = "("
        │   ├── rparen_loc: (3,11)-(3,12) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (3,14)-(3,17) = "end"
        └── @ DefNode (location: (5,0)-(5,29))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (5,4)-(5,7) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (5,8)-(5,11))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ ForwardingParameterNode (location: (5,8)-(5,11))
            │   │   └── flags: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (5,14)-(5,24))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ SuperNode (location: (5,14)-(5,24))
            │           ├── flags: newline
            │           ├── keyword_loc: (5,14)-(5,19) = "super"
            │           ├── lparen_loc: (5,19)-(5,20) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (5,20)-(5,23))
            │           │   ├── flags: contains_forwarding
            │           │   └── arguments: (length: 1)
            │           │       └── @ ForwardingArgumentsNode (location: (5,20)-(5,23))
            │           │           └── flags: ∅
            │           ├── rparen_loc: (5,23)-(5,24) = ")"
            │           └── block: ∅
            ├── locals: []
            ├── def_keyword_loc: (5,0)-(5,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (5,7)-(5,8) = "("
            ├── rparen_loc: (5,11)-(5,12) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (5,26)-(5,29) = "end"
prism-1.5.1/snapshots/whitequark/forwarded_argument_with_kwrestarg.txt000066400000000000000000000067031506127434000266320ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,45))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,45))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,45))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (1,4)-(1,7) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,8)-(1,20))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (1,8)-(1,16))
            │   │       ├── flags: ∅
            │   │       └── name: :argument
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ KeywordRestParameterNode (location: (1,18)-(1,20))
            │   │   ├── flags: ∅
            │   │   ├── name: ∅
            │   │   ├── name_loc: ∅
            │   │   └── operator_loc: (1,18)-(1,20) = "**"
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,23)-(1,40))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,23)-(1,40))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (1,23)-(1,26) = "bar"
            │           ├── opening_loc: (1,26)-(1,27) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,27)-(1,39))
            │           │   ├── flags: contains_keywords, contains_keyword_splat
            │           │   └── arguments: (length: 2)
            │           │       ├── @ LocalVariableReadNode (location: (1,27)-(1,35))
            │           │       │   ├── flags: ∅
            │           │       │   ├── name: :argument
            │           │       │   └── depth: 0
            │           │       └── @ KeywordHashNode (location: (1,37)-(1,39))
            │           │           ├── flags: ∅
            │           │           └── elements: (length: 1)
            │           │               └── @ AssocSplatNode (location: (1,37)-(1,39))
            │           │                   ├── flags: ∅
            │           │                   ├── value: ∅
            │           │                   └── operator_loc: (1,37)-(1,39) = "**"
            │           ├── closing_loc: (1,39)-(1,40) = ")"
            │           └── block: ∅
            ├── locals: [:argument]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,7)-(1,8) = "("
            ├── rparen_loc: (1,20)-(1,21) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,42)-(1,45) = "end"
prism-1.5.1/snapshots/whitequark/forwarded_argument_with_restarg.txt000066400000000000000000000062401506127434000262640ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,43))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,43))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,43))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (1,4)-(1,7) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,8)-(1,19))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (1,8)-(1,16))
            │   │       ├── flags: ∅
            │   │       └── name: :argument
            │   ├── optionals: (length: 0)
            │   ├── rest:
            │   │   @ RestParameterNode (location: (1,18)-(1,19))
            │   │   ├── flags: ∅
            │   │   ├── name: ∅
            │   │   ├── name_loc: ∅
            │   │   └── operator_loc: (1,18)-(1,19) = "*"
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,22)-(1,38))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,22)-(1,38))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (1,22)-(1,25) = "bar"
            │           ├── opening_loc: (1,25)-(1,26) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,26)-(1,37))
            │           │   ├── flags: contains_splat
            │           │   └── arguments: (length: 2)
            │           │       ├── @ LocalVariableReadNode (location: (1,26)-(1,34))
            │           │       │   ├── flags: ∅
            │           │       │   ├── name: :argument
            │           │       │   └── depth: 0
            │           │       └── @ SplatNode (location: (1,36)-(1,37))
            │           │           ├── flags: ∅
            │           │           ├── operator_loc: (1,36)-(1,37) = "*"
            │           │           └── expression: ∅
            │           ├── closing_loc: (1,37)-(1,38) = ")"
            │           └── block: ∅
            ├── locals: [:argument]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,7)-(1,8) = "("
            ├── rparen_loc: (1,19)-(1,20) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,40)-(1,43) = "end"
prism-1.5.1/snapshots/whitequark/forwarded_kwrestarg.txt000066400000000000000000000057361506127434000237020ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,25))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,25))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,25))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (1,4)-(1,7) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,8)-(1,10))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ KeywordRestParameterNode (location: (1,8)-(1,10))
            │   │   ├── flags: ∅
            │   │   ├── name: ∅
            │   │   ├── name_loc: ∅
            │   │   └── operator_loc: (1,8)-(1,10) = "**"
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,13)-(1,20))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,13)-(1,20))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (1,13)-(1,16) = "bar"
            │           ├── opening_loc: (1,16)-(1,17) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,17)-(1,19))
            │           │   ├── flags: contains_keywords, contains_keyword_splat
            │           │   └── arguments: (length: 1)
            │           │       └── @ KeywordHashNode (location: (1,17)-(1,19))
            │           │           ├── flags: ∅
            │           │           └── elements: (length: 1)
            │           │               └── @ AssocSplatNode (location: (1,17)-(1,19))
            │           │                   ├── flags: ∅
            │           │                   ├── value: ∅
            │           │                   └── operator_loc: (1,17)-(1,19) = "**"
            │           ├── closing_loc: (1,19)-(1,20) = ")"
            │           └── block: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,7)-(1,8) = "("
            ├── rparen_loc: (1,10)-(1,11) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,22)-(1,25) = "end"
prism-1.5.1/snapshots/whitequark/forwarded_kwrestarg_with_additional_kwarg.txt000066400000000000000000000101101506127434000302760ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,41))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,41))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,41))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (1,4)-(1,7) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,8)-(1,10))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ KeywordRestParameterNode (location: (1,8)-(1,10))
            │   │   ├── flags: ∅
            │   │   ├── name: ∅
            │   │   ├── name_loc: ∅
            │   │   └── operator_loc: (1,8)-(1,10) = "**"
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,13)-(1,36))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,13)-(1,36))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (1,13)-(1,16) = "bar"
            │           ├── opening_loc: (1,16)-(1,17) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,17)-(1,35))
            │           │   ├── flags: contains_keywords, contains_keyword_splat
            │           │   └── arguments: (length: 1)
            │           │       └── @ KeywordHashNode (location: (1,17)-(1,35))
            │           │           ├── flags: ∅
            │           │           └── elements: (length: 2)
            │           │               ├── @ AssocSplatNode (location: (1,17)-(1,19))
            │           │               │   ├── flags: ∅
            │           │               │   ├── value: ∅
            │           │               │   └── operator_loc: (1,17)-(1,19) = "**"
            │           │               └── @ AssocNode (location: (1,21)-(1,35))
            │           │                   ├── flags: static_literal
            │           │                   ├── key:
            │           │                   │   @ SymbolNode (location: (1,21)-(1,30))
            │           │                   │   ├── flags: static_literal, forced_us_ascii_encoding
            │           │                   │   ├── opening_loc: ∅
            │           │                   │   ├── value_loc: (1,21)-(1,29) = "from_foo"
            │           │                   │   ├── closing_loc: (1,29)-(1,30) = ":"
            │           │                   │   └── unescaped: "from_foo"
            │           │                   ├── value:
            │           │                   │   @ TrueNode (location: (1,31)-(1,35))
            │           │                   │   └── flags: static_literal
            │           │                   └── operator_loc: ∅
            │           ├── closing_loc: (1,35)-(1,36) = ")"
            │           └── block: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,7)-(1,8) = "("
            ├── rparen_loc: (1,10)-(1,11) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,38)-(1,41) = "end"
prism-1.5.1/snapshots/whitequark/forwarded_restarg.txt000066400000000000000000000052671506127434000233370ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,23))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,23))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,23))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (1,4)-(1,7) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,8)-(1,9))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest:
            │   │   @ RestParameterNode (location: (1,8)-(1,9))
            │   │   ├── flags: ∅
            │   │   ├── name: ∅
            │   │   ├── name_loc: ∅
            │   │   └── operator_loc: (1,8)-(1,9) = "*"
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,12)-(1,18))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,12)-(1,18))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (1,12)-(1,15) = "bar"
            │           ├── opening_loc: (1,15)-(1,16) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,16)-(1,17))
            │           │   ├── flags: contains_splat
            │           │   └── arguments: (length: 1)
            │           │       └── @ SplatNode (location: (1,16)-(1,17))
            │           │           ├── flags: ∅
            │           │           ├── operator_loc: (1,16)-(1,17) = "*"
            │           │           └── expression: ∅
            │           ├── closing_loc: (1,17)-(1,18) = ")"
            │           └── block: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,7)-(1,8) = "("
            ├── rparen_loc: (1,9)-(1,10) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,20)-(1,23) = "end"
prism-1.5.1/snapshots/whitequark/gvar.txt000066400000000000000000000005261506127434000205630ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ GlobalVariableReadNode (location: (1,0)-(1,4))
            ├── flags: newline
            └── name: :$foo
prism-1.5.1/snapshots/whitequark/gvasgn.txt000066400000000000000000000011701506127434000211050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ GlobalVariableWriteNode (location: (1,0)-(1,9))
            ├── flags: newline
            ├── name: :$var
            ├── name_loc: (1,0)-(1,4) = "$var"
            ├── value:
            │   @ IntegerNode (location: (1,7)-(1,9))
            │   ├── flags: static_literal, decimal
            │   └── value: 10
            └── operator_loc: (1,5)-(1,6) = "="
prism-1.5.1/snapshots/whitequark/hash_empty.txt000066400000000000000000000007141506127434000217640ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ HashNode (location: (1,0)-(1,3))
            ├── flags: newline, static_literal
            ├── opening_loc: (1,0)-(1,1) = "{"
            ├── elements: (length: 0)
            └── closing_loc: (1,2)-(1,3) = "}"
prism-1.5.1/snapshots/whitequark/hash_hashrocket.txt000066400000000000000000000057501506127434000227660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,25))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,25))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ HashNode (location: (1,0)-(1,10))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (1,0)-(1,1) = "{"
        │   ├── elements: (length: 1)
        │   │   └── @ AssocNode (location: (1,2)-(1,8))
        │   │       ├── flags: static_literal
        │   │       ├── key:
        │   │       │   @ IntegerNode (location: (1,2)-(1,3))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 1
        │   │       ├── value:
        │   │       │   @ IntegerNode (location: (1,7)-(1,8))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 2
        │   │       └── operator_loc: (1,4)-(1,6) = "=>"
        │   └── closing_loc: (1,9)-(1,10) = "}"
        └── @ HashNode (location: (3,0)-(3,25))
            ├── flags: newline
            ├── opening_loc: (3,0)-(3,1) = "{"
            ├── elements: (length: 2)
            │   ├── @ AssocNode (location: (3,2)-(3,8))
            │   │   ├── flags: static_literal
            │   │   ├── key:
            │   │   │   @ IntegerNode (location: (3,2)-(3,3))
            │   │   │   ├── flags: static_literal, decimal
            │   │   │   └── value: 1
            │   │   ├── value:
            │   │   │   @ IntegerNode (location: (3,7)-(3,8))
            │   │   │   ├── flags: static_literal, decimal
            │   │   │   └── value: 2
            │   │   └── operator_loc: (3,4)-(3,6) = "=>"
            │   └── @ AssocNode (location: (3,10)-(3,23))
            │       ├── flags: ∅
            │       ├── key:
            │       │   @ SymbolNode (location: (3,10)-(3,14))
            │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   ├── opening_loc: (3,10)-(3,11) = ":"
            │       │   ├── value_loc: (3,11)-(3,14) = "foo"
            │       │   ├── closing_loc: ∅
            │       │   └── unescaped: "foo"
            │       ├── value:
            │       │   @ StringNode (location: (3,18)-(3,23))
            │       │   ├── flags: ∅
            │       │   ├── opening_loc: (3,18)-(3,19) = "\""
            │       │   ├── content_loc: (3,19)-(3,22) = "bar"
            │       │   ├── closing_loc: (3,22)-(3,23) = "\""
            │       │   └── unescaped: "bar"
            │       └── operator_loc: (3,15)-(3,17) = "=>"
            └── closing_loc: (3,24)-(3,25) = "}"
prism-1.5.1/snapshots/whitequark/hash_kwsplat.txt000066400000000000000000000040761506127434000223200ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ HashNode (location: (1,0)-(1,17))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "{"
            ├── elements: (length: 2)
            │   ├── @ AssocNode (location: (1,2)-(1,8))
            │   │   ├── flags: static_literal
            │   │   ├── key:
            │   │   │   @ SymbolNode (location: (1,2)-(1,6))
            │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │   │   ├── opening_loc: ∅
            │   │   │   ├── value_loc: (1,2)-(1,5) = "foo"
            │   │   │   ├── closing_loc: (1,5)-(1,6) = ":"
            │   │   │   └── unescaped: "foo"
            │   │   ├── value:
            │   │   │   @ IntegerNode (location: (1,7)-(1,8))
            │   │   │   ├── flags: static_literal, decimal
            │   │   │   └── value: 2
            │   │   └── operator_loc: ∅
            │   └── @ AssocSplatNode (location: (1,10)-(1,15))
            │       ├── flags: ∅
            │       ├── value:
            │       │   @ CallNode (location: (1,12)-(1,15))
            │       │   ├── flags: variable_call, ignore_visibility
            │       │   ├── receiver: ∅
            │       │   ├── call_operator_loc: ∅
            │       │   ├── name: :bar
            │       │   ├── message_loc: (1,12)-(1,15) = "bar"
            │       │   ├── opening_loc: ∅
            │       │   ├── arguments: ∅
            │       │   ├── closing_loc: ∅
            │       │   └── block: ∅
            │       └── operator_loc: (1,10)-(1,12) = "**"
            └── closing_loc: (1,16)-(1,17) = "}"
prism-1.5.1/snapshots/whitequark/hash_label.txt000066400000000000000000000024111506127434000217010ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,10))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ HashNode (location: (1,0)-(1,10))
            ├── flags: newline, static_literal
            ├── opening_loc: (1,0)-(1,1) = "{"
            ├── elements: (length: 1)
            │   └── @ AssocNode (location: (1,2)-(1,8))
            │       ├── flags: static_literal
            │       ├── key:
            │       │   @ SymbolNode (location: (1,2)-(1,6))
            │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   ├── opening_loc: ∅
            │       │   ├── value_loc: (1,2)-(1,5) = "foo"
            │       │   ├── closing_loc: (1,5)-(1,6) = ":"
            │       │   └── unescaped: "foo"
            │       ├── value:
            │       │   @ IntegerNode (location: (1,7)-(1,8))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 2
            │       └── operator_loc: ∅
            └── closing_loc: (1,9)-(1,10) = "}"
prism-1.5.1/snapshots/whitequark/hash_label_end.txt000066400000000000000000000147371506127434000225450ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,22))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,22))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ CallNode (location: (1,0)-(1,12))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :f
        │   ├── message_loc: (1,0)-(1,1) = "f"
        │   ├── opening_loc: (1,1)-(1,2) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(1,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IfNode (location: (1,2)-(1,11))
        │   │           ├── flags: newline
        │   │           ├── if_keyword_loc: ∅
        │   │           ├── predicate:
        │   │           │   @ CallNode (location: (1,2)-(1,3))
        │   │           │   ├── flags: variable_call, ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :a
        │   │           │   ├── message_loc: (1,2)-(1,3) = "a"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments: ∅
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── then_keyword_loc: (1,4)-(1,5) = "?"
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (1,6)-(1,9))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ StringNode (location: (1,6)-(1,9))
        │   │           │           ├── flags: newline
        │   │           │           ├── opening_loc: (1,6)-(1,7) = "\""
        │   │           │           ├── content_loc: (1,7)-(1,8) = "a"
        │   │           │           ├── closing_loc: (1,8)-(1,9) = "\""
        │   │           │           └── unescaped: "a"
        │   │           ├── subsequent:
        │   │           │   @ ElseNode (location: (1,9)-(1,11))
        │   │           │   ├── flags: ∅
        │   │           │   ├── else_keyword_loc: (1,9)-(1,10) = ":"
        │   │           │   ├── statements:
        │   │           │   │   @ StatementsNode (location: (1,10)-(1,11))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   └── body: (length: 1)
        │   │           │   │       └── @ IntegerNode (location: (1,10)-(1,11))
        │   │           │   │           ├── flags: newline, static_literal, decimal
        │   │           │   │           └── value: 1
        │   │           │   └── end_keyword_loc: ∅
        │   │           └── end_keyword_loc: ∅
        │   ├── closing_loc: (1,11)-(1,12) = ")"
        │   └── block: ∅
        ├── @ HashNode (location: (3,0)-(3,12))
        │   ├── flags: newline, static_literal
        │   ├── opening_loc: (3,0)-(3,1) = "{"
        │   ├── elements: (length: 1)
        │   │   └── @ AssocNode (location: (3,2)-(3,10))
        │   │       ├── flags: static_literal
        │   │       ├── key:
        │   │       │   @ SymbolNode (location: (3,2)-(3,8))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: (3,2)-(3,3) = "'"
        │   │       │   ├── value_loc: (3,3)-(3,6) = "foo"
        │   │       │   ├── closing_loc: (3,6)-(3,8) = "':"
        │   │       │   └── unescaped: "foo"
        │   │       ├── value:
        │   │       │   @ IntegerNode (location: (3,9)-(3,10))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 2
        │   │       └── operator_loc: ∅
        │   └── closing_loc: (3,11)-(3,12) = "}"
        └── @ HashNode (location: (5,0)-(5,22))
            ├── flags: newline
            ├── opening_loc: (5,0)-(5,1) = "{"
            ├── elements: (length: 2)
            │   ├── @ AssocNode (location: (5,2)-(5,10))
            │   │   ├── flags: static_literal
            │   │   ├── key:
            │   │   │   @ SymbolNode (location: (5,2)-(5,8))
            │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │   │   ├── opening_loc: (5,2)-(5,3) = "'"
            │   │   │   ├── value_loc: (5,3)-(5,6) = "foo"
            │   │   │   ├── closing_loc: (5,6)-(5,8) = "':"
            │   │   │   └── unescaped: "foo"
            │   │   ├── value:
            │   │   │   @ IntegerNode (location: (5,9)-(5,10))
            │   │   │   ├── flags: static_literal, decimal
            │   │   │   └── value: 2
            │   │   └── operator_loc: ∅
            │   └── @ AssocNode (location: (5,12)-(5,21))
            │       ├── flags: ∅
            │       ├── key:
            │       │   @ SymbolNode (location: (5,12)-(5,18))
            │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   ├── opening_loc: (5,12)-(5,13) = "'"
            │       │   ├── value_loc: (5,13)-(5,16) = "bar"
            │       │   ├── closing_loc: (5,16)-(5,18) = "':"
            │       │   └── unescaped: "bar"
            │       ├── value:
            │       │   @ HashNode (location: (5,19)-(5,21))
            │       │   ├── flags: static_literal
            │       │   ├── opening_loc: (5,19)-(5,20) = "{"
            │       │   ├── elements: (length: 0)
            │       │   └── closing_loc: (5,20)-(5,21) = "}"
            │       └── operator_loc: ∅
            └── closing_loc: (5,21)-(5,22) = "}"
prism-1.5.1/snapshots/whitequark/hash_pair_value_omission.txt000066400000000000000000000142221506127434000246740ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,7))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ HashNode (location: (1,0)-(1,6))
        │   ├── flags: newline
        │   ├── opening_loc: (1,0)-(1,1) = "{"
        │   ├── elements: (length: 1)
        │   │   └── @ AssocNode (location: (1,1)-(1,5))
        │   │       ├── flags: ∅
        │   │       ├── key:
        │   │       │   @ SymbolNode (location: (1,1)-(1,5))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── value_loc: (1,1)-(1,4) = "BAR"
        │   │       │   ├── closing_loc: (1,4)-(1,5) = ":"
        │   │       │   └── unescaped: "BAR"
        │   │       ├── value:
        │   │       │   @ ImplicitNode (location: (1,1)-(1,5))
        │   │       │   ├── flags: ∅
        │   │       │   └── value:
        │   │       │       @ ConstantReadNode (location: (1,1)-(1,5))
        │   │       │       ├── flags: ∅
        │   │       │       └── name: :BAR
        │   │       └── operator_loc: ∅
        │   └── closing_loc: (1,5)-(1,6) = "}"
        ├── @ HashNode (location: (3,0)-(3,8))
        │   ├── flags: newline
        │   ├── opening_loc: (3,0)-(3,1) = "{"
        │   ├── elements: (length: 2)
        │   │   ├── @ AssocNode (location: (3,1)-(3,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── key:
        │   │   │   │   @ SymbolNode (location: (3,1)-(3,3))
        │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── value_loc: (3,1)-(3,2) = "a"
        │   │   │   │   ├── closing_loc: (3,2)-(3,3) = ":"
        │   │   │   │   └── unescaped: "a"
        │   │   │   ├── value:
        │   │   │   │   @ ImplicitNode (location: (3,1)-(3,3))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── value:
        │   │   │   │       @ CallNode (location: (3,1)-(3,3))
        │   │   │   │       ├── flags: ignore_visibility
        │   │   │   │       ├── receiver: ∅
        │   │   │   │       ├── call_operator_loc: ∅
        │   │   │   │       ├── name: :a
        │   │   │   │       ├── message_loc: (3,1)-(3,2) = "a"
        │   │   │   │       ├── opening_loc: ∅
        │   │   │   │       ├── arguments: ∅
        │   │   │   │       ├── closing_loc: ∅
        │   │   │   │       └── block: ∅
        │   │   │   └── operator_loc: ∅
        │   │   └── @ AssocNode (location: (3,5)-(3,7))
        │   │       ├── flags: ∅
        │   │       ├── key:
        │   │       │   @ SymbolNode (location: (3,5)-(3,7))
        │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── value_loc: (3,5)-(3,6) = "b"
        │   │       │   ├── closing_loc: (3,6)-(3,7) = ":"
        │   │       │   └── unescaped: "b"
        │   │       ├── value:
        │   │       │   @ ImplicitNode (location: (3,5)-(3,7))
        │   │       │   ├── flags: ∅
        │   │       │   └── value:
        │   │       │       @ CallNode (location: (3,5)-(3,7))
        │   │       │       ├── flags: ignore_visibility
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── name: :b
        │   │       │       ├── message_loc: (3,5)-(3,6) = "b"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── block: ∅
        │   │       └── operator_loc: ∅
        │   └── closing_loc: (3,7)-(3,8) = "}"
        └── @ HashNode (location: (5,0)-(5,7))
            ├── flags: newline
            ├── opening_loc: (5,0)-(5,1) = "{"
            ├── elements: (length: 1)
            │   └── @ AssocNode (location: (5,1)-(5,6))
            │       ├── flags: ∅
            │       ├── key:
            │       │   @ SymbolNode (location: (5,1)-(5,6))
            │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   ├── opening_loc: ∅
            │       │   ├── value_loc: (5,1)-(5,5) = "puts"
            │       │   ├── closing_loc: (5,5)-(5,6) = ":"
            │       │   └── unescaped: "puts"
            │       ├── value:
            │       │   @ ImplicitNode (location: (5,1)-(5,6))
            │       │   ├── flags: ∅
            │       │   └── value:
            │       │       @ CallNode (location: (5,1)-(5,6))
            │       │       ├── flags: ignore_visibility
            │       │       ├── receiver: ∅
            │       │       ├── call_operator_loc: ∅
            │       │       ├── name: :puts
            │       │       ├── message_loc: (5,1)-(5,5) = "puts"
            │       │       ├── opening_loc: ∅
            │       │       ├── arguments: ∅
            │       │       ├── closing_loc: ∅
            │       │       └── block: ∅
            │       └── operator_loc: ∅
            └── closing_loc: (5,6)-(5,7) = "}"
prism-1.5.1/snapshots/whitequark/heredoc.txt000066400000000000000000000022441506127434000212340ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(11,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(11,8))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ StringNode (location: (1,0)-(1,8))
        │   ├── flags: newline
        │   ├── opening_loc: (1,0)-(1,8) = "<<'HERE'"
        │   ├── content_loc: (2,0)-(4,0) = "foo\nbar\n"
        │   ├── closing_loc: (4,0)-(5,0) = "HERE\n"
        │   └── unescaped: "foo\nbar\n"
        ├── @ StringNode (location: (6,0)-(6,6))
        │   ├── flags: newline
        │   ├── opening_loc: (6,0)-(6,6) = "<a)"
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :=~
        │   │   ├── message_loc: (1,10)-(1,12) = "=~"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (1,13)-(1,16))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ StringNode (location: (1,13)-(1,16))
        │   │   │           ├── flags: ∅
        │   │   │           ├── opening_loc: (1,13)-(1,14) = "'"
        │   │   │           ├── content_loc: (1,14)-(1,15) = "a"
        │   │   │           ├── closing_loc: (1,15)-(1,16) = "'"
        │   │   │           └── unescaped: "a"
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── targets: (length: 1)
        │       └── @ LocalVariableTargetNode (location: (1,4)-(1,5))
        │           ├── flags: ∅
        │           ├── name: :a
        │           └── depth: 0
        ├── @ CallNode (location: (1,18)-(1,37))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ InterpolatedRegularExpressionNode (location: (1,18)-(1,30))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (1,18)-(1,19) = "/"
        │   │   ├── parts: (length: 2)
        │   │   │   ├── @ EmbeddedStatementsNode (location: (1,19)-(1,22))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── opening_loc: (1,19)-(1,21) = "\#{"
        │   │   │   │   ├── statements: ∅
        │   │   │   │   └── closing_loc: (1,21)-(1,22) = "}"
        │   │   │   └── @ StringNode (location: (1,22)-(1,29))
        │   │   │       ├── flags: static_literal, frozen
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (1,22)-(1,29) = "(?b)"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "(?b)"
        │   │   └── closing_loc: (1,29)-(1,30) = "/"
        │   ├── call_operator_loc: ∅
        │   ├── name: :=~
        │   ├── message_loc: (1,31)-(1,33) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,34)-(1,37))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (1,34)-(1,37))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (1,34)-(1,35) = "'"
        │   │           ├── content_loc: (1,35)-(1,36) = "b"
        │   │           ├── closing_loc: (1,36)-(1,37) = "'"
        │   │           └── unescaped: "b"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ LocalVariableReadNode (location: (1,39)-(1,40))
        │   ├── flags: newline
        │   ├── name: :a
        │   └── depth: 0
        ├── @ CallNode (location: (1,42)-(1,43))
        │   ├── flags: newline, variable_call, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :b
        │   ├── message_loc: (1,42)-(1,43) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ MatchWriteNode (location: (3,0)-(3,24))
        │   ├── flags: newline
        │   ├── call:
        │   │   @ CallNode (location: (3,0)-(3,24))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ RegularExpressionNode (location: (3,0)-(3,15))
        │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   ├── opening_loc: (3,0)-(3,1) = "/"
        │   │   │   ├── content_loc: (3,1)-(3,14) = "(?bar)"
        │   │   │   ├── closing_loc: (3,14)-(3,15) = "/"
        │   │   │   └── unescaped: "(?bar)"
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :=~
        │   │   ├── message_loc: (3,16)-(3,18) = "=~"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (3,19)-(3,24))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ StringNode (location: (3,19)-(3,24))
        │   │   │           ├── flags: ∅
        │   │   │           ├── opening_loc: (3,19)-(3,20) = "'"
        │   │   │           ├── content_loc: (3,20)-(3,23) = "bar"
        │   │   │           ├── closing_loc: (3,23)-(3,24) = "'"
        │   │   │           └── unescaped: "bar"
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── targets: (length: 1)
        │       └── @ LocalVariableTargetNode (location: (3,4)-(3,9))
        │           ├── flags: ∅
        │           ├── name: :match
        │           └── depth: 0
        └── @ LocalVariableReadNode (location: (3,26)-(3,31))
            ├── flags: newline
            ├── name: :match
            └── depth: 0
prism-1.5.1/snapshots/whitequark/lvasgn.txt000066400000000000000000000015251506127434000211160ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: [:var]
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ LocalVariableWriteNode (location: (1,0)-(1,8))
        │   ├── flags: newline
        │   ├── name: :var
        │   ├── depth: 0
        │   ├── name_loc: (1,0)-(1,3) = "var"
        │   ├── value:
        │   │   @ IntegerNode (location: (1,6)-(1,8))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 10
        │   └── operator_loc: (1,4)-(1,5) = "="
        └── @ LocalVariableReadNode (location: (1,10)-(1,13))
            ├── flags: newline
            ├── name: :var
            └── depth: 0
prism-1.5.1/snapshots/whitequark/marg_combinations.txt000066400000000000000000000515321506127434000233220ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(19,20))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(19,20))
    ├── flags: ∅
    └── body: (length: 10)
        ├── @ DefNode (location: (1,0)-(1,18))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (1,4)-(1,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (1,7)-(1,12))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (1,7)-(1,12))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 1)
        │   │   │       │   └── @ MultiTargetNode (location: (1,8)-(1,11))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       ├── lefts: (length: 1)
        │   │   │       │       │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
        │   │   │       │       │       ├── flags: ∅
        │   │   │       │       │       └── name: :a
        │   │   │       │       ├── rest: ∅
        │   │   │       │       ├── rights: (length: 0)
        │   │   │       │       ├── lparen_loc: (1,8)-(1,9) = "("
        │   │   │       │       └── rparen_loc: (1,10)-(1,11) = ")"
        │   │   │       ├── rest: ∅
        │   │   │       ├── rights: (length: 0)
        │   │   │       ├── lparen_loc: (1,7)-(1,8) = "("
        │   │   │       └── rparen_loc: (1,11)-(1,12) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (1,6)-(1,7) = "("
        │   ├── rparen_loc: (1,12)-(1,13) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (1,15)-(1,18) = "end"
        ├── @ DefNode (location: (3,0)-(3,16))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (3,4)-(3,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (3,7)-(3,10))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (3,7)-(3,10))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 0)
        │   │   │       ├── rest:
        │   │   │       │   @ SplatNode (location: (3,8)-(3,9))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   ├── operator_loc: (3,8)-(3,9) = "*"
        │   │   │       │   └── expression: ∅
        │   │   │       ├── rights: (length: 0)
        │   │   │       ├── lparen_loc: (3,7)-(3,8) = "("
        │   │   │       └── rparen_loc: (3,9)-(3,10) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (3,0)-(3,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (3,6)-(3,7) = "("
        │   ├── rparen_loc: (3,10)-(3,11) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (3,13)-(3,16) = "end"
        ├── @ DefNode (location: (5,0)-(5,19))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (5,4)-(5,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (5,7)-(5,13))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (5,7)-(5,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 0)
        │   │   │       ├── rest:
        │   │   │       │   @ SplatNode (location: (5,8)-(5,9))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   ├── operator_loc: (5,8)-(5,9) = "*"
        │   │   │       │   └── expression: ∅
        │   │   │       ├── rights: (length: 1)
        │   │   │       │   └── @ RequiredParameterNode (location: (5,11)-(5,12))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :p
        │   │   │       ├── lparen_loc: (5,7)-(5,8) = "("
        │   │   │       └── rparen_loc: (5,12)-(5,13) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:p]
        │   ├── def_keyword_loc: (5,0)-(5,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (5,6)-(5,7) = "("
        │   ├── rparen_loc: (5,13)-(5,14) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (5,16)-(5,19) = "end"
        ├── @ DefNode (location: (7,0)-(7,17))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (7,4)-(7,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (7,7)-(7,11))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (7,7)-(7,11))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 0)
        │   │   │       ├── rest:
        │   │   │       │   @ SplatNode (location: (7,8)-(7,10))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   ├── operator_loc: (7,8)-(7,9) = "*"
        │   │   │       │   └── expression:
        │   │   │       │       @ RequiredParameterNode (location: (7,9)-(7,10))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :r
        │   │   │       ├── rights: (length: 0)
        │   │   │       ├── lparen_loc: (7,7)-(7,8) = "("
        │   │   │       └── rparen_loc: (7,10)-(7,11) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:r]
        │   ├── def_keyword_loc: (7,0)-(7,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (7,6)-(7,7) = "("
        │   ├── rparen_loc: (7,11)-(7,12) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (7,14)-(7,17) = "end"
        ├── @ DefNode (location: (9,0)-(9,20))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (9,4)-(9,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (9,7)-(9,14))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (9,7)-(9,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 0)
        │   │   │       ├── rest:
        │   │   │       │   @ SplatNode (location: (9,8)-(9,10))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   ├── operator_loc: (9,8)-(9,9) = "*"
        │   │   │       │   └── expression:
        │   │   │       │       @ RequiredParameterNode (location: (9,9)-(9,10))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :r
        │   │   │       ├── rights: (length: 1)
        │   │   │       │   └── @ RequiredParameterNode (location: (9,12)-(9,13))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :p
        │   │   │       ├── lparen_loc: (9,7)-(9,8) = "("
        │   │   │       └── rparen_loc: (9,13)-(9,14) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:r, :p]
        │   ├── def_keyword_loc: (9,0)-(9,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (9,6)-(9,7) = "("
        │   ├── rparen_loc: (9,14)-(9,15) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (9,17)-(9,20) = "end"
        ├── @ DefNode (location: (11,0)-(11,19))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (11,4)-(11,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (11,7)-(11,13))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (11,7)-(11,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 1)
        │   │   │       │   └── @ RequiredParameterNode (location: (11,8)-(11,9))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :a
        │   │   │       ├── rest:
        │   │   │       │   @ SplatNode (location: (11,11)-(11,12))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   ├── operator_loc: (11,11)-(11,12) = "*"
        │   │   │       │   └── expression: ∅
        │   │   │       ├── rights: (length: 0)
        │   │   │       ├── lparen_loc: (11,7)-(11,8) = "("
        │   │   │       └── rparen_loc: (11,12)-(11,13) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a]
        │   ├── def_keyword_loc: (11,0)-(11,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (11,6)-(11,7) = "("
        │   ├── rparen_loc: (11,13)-(11,14) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (11,16)-(11,19) = "end"
        ├── @ DefNode (location: (13,0)-(13,22))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (13,4)-(13,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (13,7)-(13,16))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (13,7)-(13,16))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 1)
        │   │   │       │   └── @ RequiredParameterNode (location: (13,8)-(13,9))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :a
        │   │   │       ├── rest:
        │   │   │       │   @ SplatNode (location: (13,11)-(13,12))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   ├── operator_loc: (13,11)-(13,12) = "*"
        │   │   │       │   └── expression: ∅
        │   │   │       ├── rights: (length: 1)
        │   │   │       │   └── @ RequiredParameterNode (location: (13,14)-(13,15))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :p
        │   │   │       ├── lparen_loc: (13,7)-(13,8) = "("
        │   │   │       └── rparen_loc: (13,15)-(13,16) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :p]
        │   ├── def_keyword_loc: (13,0)-(13,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (13,6)-(13,7) = "("
        │   ├── rparen_loc: (13,16)-(13,17) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (13,19)-(13,22) = "end"
        ├── @ DefNode (location: (15,0)-(15,20))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (15,4)-(15,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (15,7)-(15,14))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (15,7)-(15,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 1)
        │   │   │       │   └── @ RequiredParameterNode (location: (15,8)-(15,9))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :a
        │   │   │       ├── rest:
        │   │   │       │   @ SplatNode (location: (15,11)-(15,13))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   ├── operator_loc: (15,11)-(15,12) = "*"
        │   │   │       │   └── expression:
        │   │   │       │       @ RequiredParameterNode (location: (15,12)-(15,13))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :r
        │   │   │       ├── rights: (length: 0)
        │   │   │       ├── lparen_loc: (15,7)-(15,8) = "("
        │   │   │       └── rparen_loc: (15,13)-(15,14) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :r]
        │   ├── def_keyword_loc: (15,0)-(15,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (15,6)-(15,7) = "("
        │   ├── rparen_loc: (15,14)-(15,15) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (15,17)-(15,20) = "end"
        ├── @ DefNode (location: (17,0)-(17,23))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (17,4)-(17,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (17,7)-(17,17))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ MultiTargetNode (location: (17,7)-(17,17))
        │   │   │       ├── flags: ∅
        │   │   │       ├── lefts: (length: 1)
        │   │   │       │   └── @ RequiredParameterNode (location: (17,8)-(17,9))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :a
        │   │   │       ├── rest:
        │   │   │       │   @ SplatNode (location: (17,11)-(17,13))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   ├── operator_loc: (17,11)-(17,12) = "*"
        │   │   │       │   └── expression:
        │   │   │       │       @ RequiredParameterNode (location: (17,12)-(17,13))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :r
        │   │   │       ├── rights: (length: 1)
        │   │   │       │   └── @ RequiredParameterNode (location: (17,15)-(17,16))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       └── name: :p
        │   │   │       ├── lparen_loc: (17,7)-(17,8) = "("
        │   │   │       └── rparen_loc: (17,16)-(17,17) = ")"
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:a, :r, :p]
        │   ├── def_keyword_loc: (17,0)-(17,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: (17,6)-(17,7) = "("
        │   ├── rparen_loc: (17,17)-(17,18) = ")"
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (17,20)-(17,23) = "end"
        └── @ DefNode (location: (19,0)-(19,20))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (19,4)-(19,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (19,7)-(19,14))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ MultiTargetNode (location: (19,7)-(19,14))
            │   │       ├── flags: ∅
            │   │       ├── lefts: (length: 2)
            │   │       │   ├── @ RequiredParameterNode (location: (19,8)-(19,9))
            │   │       │   │   ├── flags: ∅
            │   │       │   │   └── name: :a
            │   │       │   └── @ RequiredParameterNode (location: (19,11)-(19,13))
            │   │       │       ├── flags: ∅
            │   │       │       └── name: :a1
            │   │       ├── rest: ∅
            │   │       ├── rights: (length: 0)
            │   │       ├── lparen_loc: (19,7)-(19,8) = "("
            │   │       └── rparen_loc: (19,13)-(19,14) = ")"
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:a, :a1]
            ├── def_keyword_loc: (19,0)-(19,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (19,6)-(19,7) = "("
            ├── rparen_loc: (19,14)-(19,15) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (19,17)-(19,20) = "end"
prism-1.5.1/snapshots/whitequark/masgn.txt000066400000000000000000000112321506127434000207250ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,20))
├── flags: ∅
├── locals: [:foo, :bar, :baz]
└── statements:
    @ StatementsNode (location: (1,0)-(5,20))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ MultiWriteNode (location: (1,0)-(1,17))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ LocalVariableTargetNode (location: (1,1)-(1,4))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :foo
        │   │   │   └── depth: 0
        │   │   └── @ LocalVariableTargetNode (location: (1,6)-(1,9))
        │   │       ├── flags: ∅
        │   │       ├── name: :bar
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (1,0)-(1,1) = "("
        │   ├── rparen_loc: (1,9)-(1,10) = ")"
        │   ├── operator_loc: (1,11)-(1,12) = "="
        │   └── value:
        │       @ ArrayNode (location: (1,13)-(1,17))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (1,13)-(1,14))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (1,16)-(1,17))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: ∅
        │       └── closing_loc: ∅
        ├── @ MultiWriteNode (location: (3,0)-(3,15))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ LocalVariableTargetNode (location: (3,0)-(3,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :foo
        │   │   │   └── depth: 0
        │   │   └── @ LocalVariableTargetNode (location: (3,5)-(3,8))
        │   │       ├── flags: ∅
        │   │       ├── name: :bar
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (3,9)-(3,10) = "="
        │   └── value:
        │       @ ArrayNode (location: (3,11)-(3,15))
        │       ├── flags: static_literal
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (3,11)-(3,12))
        │       │   │   ├── flags: static_literal, decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (3,14)-(3,15))
        │       │       ├── flags: static_literal, decimal
        │       │       └── value: 2
        │       ├── opening_loc: ∅
        │       └── closing_loc: ∅
        └── @ MultiWriteNode (location: (5,0)-(5,20))
            ├── flags: newline
            ├── lefts: (length: 3)
            │   ├── @ LocalVariableTargetNode (location: (5,0)-(5,3))
            │   │   ├── flags: ∅
            │   │   ├── name: :foo
            │   │   └── depth: 0
            │   ├── @ LocalVariableTargetNode (location: (5,5)-(5,8))
            │   │   ├── flags: ∅
            │   │   ├── name: :bar
            │   │   └── depth: 0
            │   └── @ LocalVariableTargetNode (location: (5,10)-(5,13))
            │       ├── flags: ∅
            │       ├── name: :baz
            │       └── depth: 0
            ├── rest: ∅
            ├── rights: (length: 0)
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── operator_loc: (5,14)-(5,15) = "="
            └── value:
                @ ArrayNode (location: (5,16)-(5,20))
                ├── flags: static_literal
                ├── elements: (length: 2)
                │   ├── @ IntegerNode (location: (5,16)-(5,17))
                │   │   ├── flags: static_literal, decimal
                │   │   └── value: 1
                │   └── @ IntegerNode (location: (5,19)-(5,20))
                │       ├── flags: static_literal, decimal
                │       └── value: 2
                ├── opening_loc: ∅
                └── closing_loc: ∅
prism-1.5.1/snapshots/whitequark/masgn_attr.txt000066400000000000000000000114731506127434000217660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,18))
├── flags: ∅
├── locals: [:foo]
└── statements:
    @ StatementsNode (location: (1,0)-(5,18))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ MultiWriteNode (location: (1,0)-(1,17))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ CallTargetNode (location: (1,0)-(1,6))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver:
        │   │   │   │   @ SelfNode (location: (1,0)-(1,4))
        │   │   │   │   └── flags: ∅
        │   │   │   ├── call_operator_loc: (1,4)-(1,5) = "."
        │   │   │   ├── name: :A=
        │   │   │   └── message_loc: (1,5)-(1,6) = "A"
        │   │   └── @ LocalVariableTargetNode (location: (1,8)-(1,11))
        │   │       ├── flags: ∅
        │   │       ├── name: :foo
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (1,12)-(1,13) = "="
        │   └── value:
        │       @ LocalVariableReadNode (location: (1,14)-(1,17))
        │       ├── flags: ∅
        │       ├── name: :foo
        │       └── depth: 0
        ├── @ MultiWriteNode (location: (3,0)-(3,24))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ CallTargetNode (location: (3,0)-(3,6))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver:
        │   │   │   │   @ SelfNode (location: (3,0)-(3,4))
        │   │   │   │   └── flags: ∅
        │   │   │   ├── call_operator_loc: (3,4)-(3,5) = "."
        │   │   │   ├── name: :a=
        │   │   │   └── message_loc: (3,5)-(3,6) = "a"
        │   │   └── @ IndexTargetNode (location: (3,8)-(3,18))
        │   │       ├── flags: attribute_write, ignore_visibility
        │   │       ├── receiver:
        │   │       │   @ SelfNode (location: (3,8)-(3,12))
        │   │       │   └── flags: ∅
        │   │       ├── opening_loc: (3,12)-(3,13) = "["
        │   │       ├── arguments:
        │   │       │   @ ArgumentsNode (location: (3,13)-(3,17))
        │   │       │   ├── flags: ∅
        │   │       │   └── arguments: (length: 2)
        │   │       │       ├── @ IntegerNode (location: (3,13)-(3,14))
        │   │       │       │   ├── flags: static_literal, decimal
        │   │       │       │   └── value: 1
        │   │       │       └── @ IntegerNode (location: (3,16)-(3,17))
        │   │       │           ├── flags: static_literal, decimal
        │   │       │           └── value: 2
        │   │       ├── closing_loc: (3,17)-(3,18) = "]"
        │   │       └── block: ∅
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (3,19)-(3,20) = "="
        │   └── value:
        │       @ LocalVariableReadNode (location: (3,21)-(3,24))
        │       ├── flags: ∅
        │       ├── name: :foo
        │       └── depth: 0
        └── @ MultiWriteNode (location: (5,0)-(5,18))
            ├── flags: newline
            ├── lefts: (length: 2)
            │   ├── @ CallTargetNode (location: (5,0)-(5,7))
            │   │   ├── flags: ignore_visibility
            │   │   ├── receiver:
            │   │   │   @ SelfNode (location: (5,0)-(5,4))
            │   │   │   └── flags: ∅
            │   │   ├── call_operator_loc: (5,4)-(5,6) = "::"
            │   │   ├── name: :a=
            │   │   └── message_loc: (5,6)-(5,7) = "a"
            │   └── @ LocalVariableTargetNode (location: (5,9)-(5,12))
            │       ├── flags: ∅
            │       ├── name: :foo
            │       └── depth: 0
            ├── rest: ∅
            ├── rights: (length: 0)
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── operator_loc: (5,13)-(5,14) = "="
            └── value:
                @ LocalVariableReadNode (location: (5,15)-(5,18))
                ├── flags: ∅
                ├── name: :foo
                └── depth: 0
prism-1.5.1/snapshots/whitequark/masgn_cmd.txt000066400000000000000000000034721506127434000215570ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,16))
├── flags: ∅
├── locals: [:foo, :bar]
└── statements:
    @ StatementsNode (location: (1,0)-(1,16))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ MultiWriteNode (location: (1,0)-(1,16))
            ├── flags: newline
            ├── lefts: (length: 2)
            │   ├── @ LocalVariableTargetNode (location: (1,0)-(1,3))
            │   │   ├── flags: ∅
            │   │   ├── name: :foo
            │   │   └── depth: 0
            │   └── @ LocalVariableTargetNode (location: (1,5)-(1,8))
            │       ├── flags: ∅
            │       ├── name: :bar
            │       └── depth: 0
            ├── rest: ∅
            ├── rights: (length: 0)
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── operator_loc: (1,9)-(1,10) = "="
            └── value:
                @ CallNode (location: (1,11)-(1,16))
                ├── flags: ignore_visibility
                ├── receiver: ∅
                ├── call_operator_loc: ∅
                ├── name: :m
                ├── message_loc: (1,11)-(1,12) = "m"
                ├── opening_loc: ∅
                ├── arguments:
                │   @ ArgumentsNode (location: (1,13)-(1,16))
                │   ├── flags: ∅
                │   └── arguments: (length: 1)
                │       └── @ LocalVariableReadNode (location: (1,13)-(1,16))
                │           ├── flags: ∅
                │           ├── name: :foo
                │           └── depth: 0
                ├── closing_loc: ∅
                └── block: ∅
prism-1.5.1/snapshots/whitequark/masgn_const.txt000066400000000000000000000047721506127434000221460ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,18))
├── flags: ∅
├── locals: [:foo]
└── statements:
    @ StatementsNode (location: (1,0)-(3,18))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ MultiWriteNode (location: (1,0)-(1,14))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ ConstantPathTargetNode (location: (1,0)-(1,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── parent: ∅
        │   │   │   ├── name: :A
        │   │   │   ├── delimiter_loc: (1,0)-(1,2) = "::"
        │   │   │   └── name_loc: (1,2)-(1,3) = "A"
        │   │   └── @ LocalVariableTargetNode (location: (1,5)-(1,8))
        │   │       ├── flags: ∅
        │   │       ├── name: :foo
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (1,9)-(1,10) = "="
        │   └── value:
        │       @ LocalVariableReadNode (location: (1,11)-(1,14))
        │       ├── flags: ∅
        │       ├── name: :foo
        │       └── depth: 0
        └── @ MultiWriteNode (location: (3,0)-(3,18))
            ├── flags: newline
            ├── lefts: (length: 2)
            │   ├── @ ConstantPathTargetNode (location: (3,0)-(3,7))
            │   │   ├── flags: ∅
            │   │   ├── parent:
            │   │   │   @ SelfNode (location: (3,0)-(3,4))
            │   │   │   └── flags: ∅
            │   │   ├── name: :A
            │   │   ├── delimiter_loc: (3,4)-(3,6) = "::"
            │   │   └── name_loc: (3,6)-(3,7) = "A"
            │   └── @ LocalVariableTargetNode (location: (3,9)-(3,12))
            │       ├── flags: ∅
            │       ├── name: :foo
            │       └── depth: 0
            ├── rest: ∅
            ├── rights: (length: 0)
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── operator_loc: (3,13)-(3,14) = "="
            └── value:
                @ LocalVariableReadNode (location: (3,15)-(3,18))
                ├── flags: ∅
                ├── name: :foo
                └── depth: 0
prism-1.5.1/snapshots/whitequark/masgn_nested.txt000066400000000000000000000073461506127434000223020ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,15))
├── flags: ∅
├── locals: [:b, :a, :c]
└── statements:
    @ StatementsNode (location: (1,0)-(3,15))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ MultiWriteNode (location: (1,0)-(1,13))
        │   ├── flags: newline
        │   ├── lefts: (length: 1)
        │   │   └── @ MultiTargetNode (location: (1,1)-(1,6))
        │   │       ├── flags: ∅
        │   │       ├── lefts: (length: 1)
        │   │       │   └── @ LocalVariableTargetNode (location: (1,2)-(1,3))
        │   │       │       ├── flags: ∅
        │   │       │       ├── name: :b
        │   │       │       └── depth: 0
        │   │       ├── rest:
        │   │       │   @ ImplicitRestNode (location: (1,3)-(1,4))
        │   │       │   └── flags: ∅
        │   │       ├── rights: (length: 0)
        │   │       ├── lparen_loc: (1,1)-(1,2) = "("
        │   │       └── rparen_loc: (1,5)-(1,6) = ")"
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (1,0)-(1,1) = "("
        │   ├── rparen_loc: (1,6)-(1,7) = ")"
        │   ├── operator_loc: (1,8)-(1,9) = "="
        │   └── value:
        │       @ CallNode (location: (1,10)-(1,13))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :foo
        │       ├── message_loc: (1,10)-(1,13) = "foo"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        └── @ MultiWriteNode (location: (3,0)-(3,15))
            ├── flags: newline
            ├── lefts: (length: 2)
            │   ├── @ LocalVariableTargetNode (location: (3,0)-(3,1))
            │   │   ├── flags: ∅
            │   │   ├── name: :a
            │   │   └── depth: 0
            │   └── @ MultiTargetNode (location: (3,3)-(3,9))
            │       ├── flags: ∅
            │       ├── lefts: (length: 2)
            │       │   ├── @ LocalVariableTargetNode (location: (3,4)-(3,5))
            │       │   │   ├── flags: ∅
            │       │   │   ├── name: :b
            │       │   │   └── depth: 0
            │       │   └── @ LocalVariableTargetNode (location: (3,7)-(3,8))
            │       │       ├── flags: ∅
            │       │       ├── name: :c
            │       │       └── depth: 0
            │       ├── rest: ∅
            │       ├── rights: (length: 0)
            │       ├── lparen_loc: (3,3)-(3,4) = "("
            │       └── rparen_loc: (3,8)-(3,9) = ")"
            ├── rest: ∅
            ├── rights: (length: 0)
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── operator_loc: (3,10)-(3,11) = "="
            └── value:
                @ CallNode (location: (3,12)-(3,15))
                ├── flags: variable_call, ignore_visibility
                ├── receiver: ∅
                ├── call_operator_loc: ∅
                ├── name: :foo
                ├── message_loc: (3,12)-(3,15) = "foo"
                ├── opening_loc: ∅
                ├── arguments: ∅
                ├── closing_loc: ∅
                └── block: ∅
prism-1.5.1/snapshots/whitequark/masgn_splat.txt000066400000000000000000000371121506127434000221350ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(19,16))
├── flags: ∅
├── locals: [:c, :d, :b, :a]
└── statements:
    @ StatementsNode (location: (1,0)-(19,16))
    ├── flags: ∅
    └── body: (length: 10)
        ├── @ MultiWriteNode (location: (1,0)-(1,7))
        │   ├── flags: newline
        │   ├── lefts: (length: 0)
        │   ├── rest:
        │   │   @ SplatNode (location: (1,0)-(1,1))
        │   │   ├── flags: ∅
        │   │   ├── operator_loc: (1,0)-(1,1) = "*"
        │   │   └── expression: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (1,2)-(1,3) = "="
        │   └── value:
        │       @ CallNode (location: (1,4)-(1,7))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (1,4)-(1,7) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ MultiWriteNode (location: (3,0)-(3,13))
        │   ├── flags: newline
        │   ├── lefts: (length: 0)
        │   ├── rest:
        │   │   @ SplatNode (location: (3,0)-(3,1))
        │   │   ├── flags: ∅
        │   │   ├── operator_loc: (3,0)-(3,1) = "*"
        │   │   └── expression: ∅
        │   ├── rights: (length: 2)
        │   │   ├── @ LocalVariableTargetNode (location: (3,3)-(3,4))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :c
        │   │   │   └── depth: 0
        │   │   └── @ LocalVariableTargetNode (location: (3,6)-(3,7))
        │   │       ├── flags: ∅
        │   │       ├── name: :d
        │   │       └── depth: 0
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (3,8)-(3,9) = "="
        │   └── value:
        │       @ CallNode (location: (3,10)-(3,13))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (3,10)-(3,13) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ MultiWriteNode (location: (5,0)-(5,8))
        │   ├── flags: newline
        │   ├── lefts: (length: 0)
        │   ├── rest:
        │   │   @ SplatNode (location: (5,0)-(5,2))
        │   │   ├── flags: ∅
        │   │   ├── operator_loc: (5,0)-(5,1) = "*"
        │   │   └── expression:
        │   │       @ LocalVariableTargetNode (location: (5,1)-(5,2))
        │   │       ├── flags: ∅
        │   │       ├── name: :b
        │   │       └── depth: 0
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (5,3)-(5,4) = "="
        │   └── value:
        │       @ CallNode (location: (5,5)-(5,8))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (5,5)-(5,8) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ MultiWriteNode (location: (7,0)-(7,11))
        │   ├── flags: newline
        │   ├── lefts: (length: 0)
        │   ├── rest:
        │   │   @ SplatNode (location: (7,0)-(7,2))
        │   │   ├── flags: ∅
        │   │   ├── operator_loc: (7,0)-(7,1) = "*"
        │   │   └── expression:
        │   │       @ LocalVariableTargetNode (location: (7,1)-(7,2))
        │   │       ├── flags: ∅
        │   │       ├── name: :b
        │   │       └── depth: 0
        │   ├── rights: (length: 1)
        │   │   └── @ LocalVariableTargetNode (location: (7,4)-(7,5))
        │   │       ├── flags: ∅
        │   │       ├── name: :c
        │   │       └── depth: 0
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (7,6)-(7,7) = "="
        │   └── value:
        │       @ CallNode (location: (7,8)-(7,11))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (7,8)-(7,11) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ MultiWriteNode (location: (9,0)-(9,18))
        │   ├── flags: newline
        │   ├── lefts: (length: 2)
        │   │   ├── @ InstanceVariableTargetNode (location: (9,0)-(9,4))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :@foo
        │   │   └── @ ClassVariableTargetNode (location: (9,6)-(9,11))
        │   │       ├── flags: ∅
        │   │       └── name: :@@bar
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (9,12)-(9,13) = "="
        │   └── value:
        │       @ ArrayNode (location: (9,14)-(9,18))
        │       ├── flags: contains_splat
        │       ├── elements: (length: 1)
        │       │   └── @ SplatNode (location: (9,14)-(9,18))
        │       │       ├── flags: ∅
        │       │       ├── operator_loc: (9,14)-(9,15) = "*"
        │       │       └── expression:
        │       │           @ CallNode (location: (9,15)-(9,18))
        │       │           ├── flags: variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :foo
        │       │           ├── message_loc: (9,15)-(9,18) = "foo"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: ∅
        │       └── closing_loc: ∅
        ├── @ MultiWriteNode (location: (11,0)-(11,10))
        │   ├── flags: newline
        │   ├── lefts: (length: 1)
        │   │   └── @ LocalVariableTargetNode (location: (11,0)-(11,1))
        │   │       ├── flags: ∅
        │   │       ├── name: :a
        │   │       └── depth: 0
        │   ├── rest:
        │   │   @ SplatNode (location: (11,3)-(11,4))
        │   │   ├── flags: ∅
        │   │   ├── operator_loc: (11,3)-(11,4) = "*"
        │   │   └── expression: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (11,5)-(11,6) = "="
        │   └── value:
        │       @ CallNode (location: (11,7)-(11,10))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (11,7)-(11,10) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ MultiWriteNode (location: (13,0)-(13,13))
        │   ├── flags: newline
        │   ├── lefts: (length: 1)
        │   │   └── @ LocalVariableTargetNode (location: (13,0)-(13,1))
        │   │       ├── flags: ∅
        │   │       ├── name: :a
        │   │       └── depth: 0
        │   ├── rest:
        │   │   @ SplatNode (location: (13,3)-(13,4))
        │   │   ├── flags: ∅
        │   │   ├── operator_loc: (13,3)-(13,4) = "*"
        │   │   └── expression: ∅
        │   ├── rights: (length: 1)
        │   │   └── @ LocalVariableTargetNode (location: (13,6)-(13,7))
        │   │       ├── flags: ∅
        │   │       ├── name: :c
        │   │       └── depth: 0
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (13,8)-(13,9) = "="
        │   └── value:
        │       @ CallNode (location: (13,10)-(13,13))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (13,10)-(13,13) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ MultiWriteNode (location: (15,0)-(15,11))
        │   ├── flags: newline
        │   ├── lefts: (length: 1)
        │   │   └── @ LocalVariableTargetNode (location: (15,0)-(15,1))
        │   │       ├── flags: ∅
        │   │       ├── name: :a
        │   │       └── depth: 0
        │   ├── rest:
        │   │   @ SplatNode (location: (15,3)-(15,5))
        │   │   ├── flags: ∅
        │   │   ├── operator_loc: (15,3)-(15,4) = "*"
        │   │   └── expression:
        │   │       @ LocalVariableTargetNode (location: (15,4)-(15,5))
        │   │       ├── flags: ∅
        │   │       ├── name: :b
        │   │       └── depth: 0
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (15,6)-(15,7) = "="
        │   └── value:
        │       @ CallNode (location: (15,8)-(15,11))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (15,8)-(15,11) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ MultiWriteNode (location: (17,0)-(17,14))
        │   ├── flags: newline
        │   ├── lefts: (length: 1)
        │   │   └── @ LocalVariableTargetNode (location: (17,0)-(17,1))
        │   │       ├── flags: ∅
        │   │       ├── name: :a
        │   │       └── depth: 0
        │   ├── rest:
        │   │   @ SplatNode (location: (17,3)-(17,5))
        │   │   ├── flags: ∅
        │   │   ├── operator_loc: (17,3)-(17,4) = "*"
        │   │   └── expression:
        │   │       @ LocalVariableTargetNode (location: (17,4)-(17,5))
        │   │       ├── flags: ∅
        │   │       ├── name: :b
        │   │       └── depth: 0
        │   ├── rights: (length: 1)
        │   │   └── @ LocalVariableTargetNode (location: (17,7)-(17,8))
        │   │       ├── flags: ∅
        │   │       ├── name: :c
        │   │       └── depth: 0
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── operator_loc: (17,9)-(17,10) = "="
        │   └── value:
        │       @ CallNode (location: (17,11)-(17,14))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (17,11)-(17,14) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        └── @ MultiWriteNode (location: (19,0)-(19,16))
            ├── flags: newline
            ├── lefts: (length: 2)
            │   ├── @ LocalVariableTargetNode (location: (19,0)-(19,1))
            │   │   ├── flags: ∅
            │   │   ├── name: :a
            │   │   └── depth: 0
            │   └── @ LocalVariableTargetNode (location: (19,3)-(19,4))
            │       ├── flags: ∅
            │       ├── name: :b
            │       └── depth: 0
            ├── rest: ∅
            ├── rights: (length: 0)
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── operator_loc: (19,5)-(19,6) = "="
            └── value:
                @ ArrayNode (location: (19,7)-(19,16))
                ├── flags: contains_splat
                ├── elements: (length: 2)
                │   ├── @ SplatNode (location: (19,7)-(19,11))
                │   │   ├── flags: ∅
                │   │   ├── operator_loc: (19,7)-(19,8) = "*"
                │   │   └── expression:
                │   │       @ CallNode (location: (19,8)-(19,11))
                │   │       ├── flags: variable_call, ignore_visibility
                │   │       ├── receiver: ∅
                │   │       ├── call_operator_loc: ∅
                │   │       ├── name: :foo
                │   │       ├── message_loc: (19,8)-(19,11) = "foo"
                │   │       ├── opening_loc: ∅
                │   │       ├── arguments: ∅
                │   │       ├── closing_loc: ∅
                │   │       └── block: ∅
                │   └── @ CallNode (location: (19,13)-(19,16))
                │       ├── flags: variable_call, ignore_visibility
                │       ├── receiver: ∅
                │       ├── call_operator_loc: ∅
                │       ├── name: :bar
                │       ├── message_loc: (19,13)-(19,16) = "bar"
                │       ├── opening_loc: ∅
                │       ├── arguments: ∅
                │       ├── closing_loc: ∅
                │       └── block: ∅
                ├── opening_loc: ∅
                └── closing_loc: ∅
prism-1.5.1/snapshots/whitequark/method_definition_in_while_cond.txt000066400000000000000000000310141506127434000261710ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,47))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(7,47))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ WhileNode (location: (1,0)-(1,45))
        │   ├── flags: newline
        │   ├── keyword_loc: (1,0)-(1,5) = "while"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: (1,42)-(1,45) = "end"
        │   ├── predicate:
        │   │   @ DefNode (location: (1,6)-(1,33))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   ├── name_loc: (1,10)-(1,13) = "foo"
        │   │   ├── receiver: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (1,14)-(1,28))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 0)
        │   │   │   ├── optionals: (length: 1)
        │   │   │   │   └── @ OptionalParameterNode (location: (1,14)-(1,28))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :a
        │   │   │   │       ├── name_loc: (1,14)-(1,15) = "a"
        │   │   │   │       ├── operator_loc: (1,16)-(1,17) = "="
        │   │   │   │       └── value:
        │   │   │   │           @ CallNode (location: (1,18)-(1,28))
        │   │   │   │           ├── flags: ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :tap
        │   │   │   │           ├── message_loc: (1,18)-(1,21) = "tap"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block:
        │   │   │   │               @ BlockNode (location: (1,22)-(1,28))
        │   │   │   │               ├── flags: ∅
        │   │   │   │               ├── locals: []
        │   │   │   │               ├── parameters: ∅
        │   │   │   │               ├── body: ∅
        │   │   │   │               ├── opening_loc: (1,22)-(1,24) = "do"
        │   │   │   │               └── closing_loc: (1,25)-(1,28) = "end"
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 0)
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── body: ∅
        │   │   ├── locals: [:a]
        │   │   ├── def_keyword_loc: (1,6)-(1,9) = "def"
        │   │   ├── operator_loc: ∅
        │   │   ├── lparen_loc: ∅
        │   │   ├── rparen_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── end_keyword_loc: (1,30)-(1,33) = "end"
        │   └── statements:
        │       @ StatementsNode (location: (1,35)-(1,40))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ BreakNode (location: (1,35)-(1,40))
        │               ├── flags: newline
        │               ├── arguments: ∅
        │               └── keyword_loc: (1,35)-(1,40) = "break"
        ├── @ WhileNode (location: (3,0)-(3,42))
        │   ├── flags: newline
        │   ├── keyword_loc: (3,0)-(3,5) = "while"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: (3,39)-(3,42) = "end"
        │   ├── predicate:
        │   │   @ DefNode (location: (3,6)-(3,30))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   ├── name_loc: (3,10)-(3,13) = "foo"
        │   │   ├── receiver: ∅
        │   │   ├── parameters: ∅
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (3,15)-(3,25))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (3,15)-(3,25))
        │   │   │           ├── flags: newline, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :tap
        │   │   │           ├── message_loc: (3,15)-(3,18) = "tap"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block:
        │   │   │               @ BlockNode (location: (3,19)-(3,25))
        │   │   │               ├── flags: ∅
        │   │   │               ├── locals: []
        │   │   │               ├── parameters: ∅
        │   │   │               ├── body: ∅
        │   │   │               ├── opening_loc: (3,19)-(3,21) = "do"
        │   │   │               └── closing_loc: (3,22)-(3,25) = "end"
        │   │   ├── locals: []
        │   │   ├── def_keyword_loc: (3,6)-(3,9) = "def"
        │   │   ├── operator_loc: ∅
        │   │   ├── lparen_loc: ∅
        │   │   ├── rparen_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── end_keyword_loc: (3,27)-(3,30) = "end"
        │   └── statements:
        │       @ StatementsNode (location: (3,32)-(3,37))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ BreakNode (location: (3,32)-(3,37))
        │               ├── flags: newline
        │               ├── arguments: ∅
        │               └── keyword_loc: (3,32)-(3,37) = "break"
        ├── @ WhileNode (location: (5,0)-(5,50))
        │   ├── flags: newline
        │   ├── keyword_loc: (5,0)-(5,5) = "while"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: (5,47)-(5,50) = "end"
        │   ├── predicate:
        │   │   @ DefNode (location: (5,6)-(5,38))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   ├── name_loc: (5,15)-(5,18) = "foo"
        │   │   ├── receiver:
        │   │   │   @ SelfNode (location: (5,10)-(5,14))
        │   │   │   └── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (5,19)-(5,33))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 0)
        │   │   │   ├── optionals: (length: 1)
        │   │   │   │   └── @ OptionalParameterNode (location: (5,19)-(5,33))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :a
        │   │   │   │       ├── name_loc: (5,19)-(5,20) = "a"
        │   │   │   │       ├── operator_loc: (5,21)-(5,22) = "="
        │   │   │   │       └── value:
        │   │   │   │           @ CallNode (location: (5,23)-(5,33))
        │   │   │   │           ├── flags: ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :tap
        │   │   │   │           ├── message_loc: (5,23)-(5,26) = "tap"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block:
        │   │   │   │               @ BlockNode (location: (5,27)-(5,33))
        │   │   │   │               ├── flags: ∅
        │   │   │   │               ├── locals: []
        │   │   │   │               ├── parameters: ∅
        │   │   │   │               ├── body: ∅
        │   │   │   │               ├── opening_loc: (5,27)-(5,29) = "do"
        │   │   │   │               └── closing_loc: (5,30)-(5,33) = "end"
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 0)
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── body: ∅
        │   │   ├── locals: [:a]
        │   │   ├── def_keyword_loc: (5,6)-(5,9) = "def"
        │   │   ├── operator_loc: (5,14)-(5,15) = "."
        │   │   ├── lparen_loc: ∅
        │   │   ├── rparen_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── end_keyword_loc: (5,35)-(5,38) = "end"
        │   └── statements:
        │       @ StatementsNode (location: (5,40)-(5,45))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ BreakNode (location: (5,40)-(5,45))
        │               ├── flags: newline
        │               ├── arguments: ∅
        │               └── keyword_loc: (5,40)-(5,45) = "break"
        └── @ WhileNode (location: (7,0)-(7,47))
            ├── flags: newline
            ├── keyword_loc: (7,0)-(7,5) = "while"
            ├── do_keyword_loc: ∅
            ├── closing_loc: (7,44)-(7,47) = "end"
            ├── predicate:
            │   @ DefNode (location: (7,6)-(7,35))
            │   ├── flags: ∅
            │   ├── name: :foo
            │   ├── name_loc: (7,15)-(7,18) = "foo"
            │   ├── receiver:
            │   │   @ SelfNode (location: (7,10)-(7,14))
            │   │   └── flags: ∅
            │   ├── parameters: ∅
            │   ├── body:
            │   │   @ StatementsNode (location: (7,20)-(7,30))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (7,20)-(7,30))
            │   │           ├── flags: newline, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :tap
            │   │           ├── message_loc: (7,20)-(7,23) = "tap"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block:
            │   │               @ BlockNode (location: (7,24)-(7,30))
            │   │               ├── flags: ∅
            │   │               ├── locals: []
            │   │               ├── parameters: ∅
            │   │               ├── body: ∅
            │   │               ├── opening_loc: (7,24)-(7,26) = "do"
            │   │               └── closing_loc: (7,27)-(7,30) = "end"
            │   ├── locals: []
            │   ├── def_keyword_loc: (7,6)-(7,9) = "def"
            │   ├── operator_loc: (7,14)-(7,15) = "."
            │   ├── lparen_loc: ∅
            │   ├── rparen_loc: ∅
            │   ├── equal_loc: ∅
            │   └── end_keyword_loc: (7,32)-(7,35) = "end"
            └── statements:
                @ StatementsNode (location: (7,37)-(7,42))
                ├── flags: ∅
                └── body: (length: 1)
                    └── @ BreakNode (location: (7,37)-(7,42))
                        ├── flags: newline
                        ├── arguments: ∅
                        └── keyword_loc: (7,37)-(7,42) = "break"
prism-1.5.1/snapshots/whitequark/module.txt000066400000000000000000000012741506127434000211120ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,15))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ModuleNode (location: (1,0)-(1,15))
            ├── flags: newline
            ├── locals: []
            ├── module_keyword_loc: (1,0)-(1,6) = "module"
            ├── constant_path:
            │   @ ConstantReadNode (location: (1,7)-(1,10))
            │   ├── flags: ∅
            │   └── name: :Foo
            ├── body: ∅
            ├── end_keyword_loc: (1,12)-(1,15) = "end"
            └── name: :Foo
prism-1.5.1/snapshots/whitequark/multiple_args_with_trailing_comma.txt000066400000000000000000000044451506127434000265770ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,12))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,1)-(1,12))
                ├── flags: ∅
                ├── locals: [:a, :b]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,3)-(1,10))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,4)-(1,9))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 2)
                │   │   │   ├── @ RequiredParameterNode (location: (1,4)-(1,5))
                │   │   │   │   ├── flags: ∅
                │   │   │   │   └── name: :a
                │   │   │   └── @ RequiredParameterNode (location: (1,7)-(1,8))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :b
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest:
                │   │   │   @ ImplicitRestNode (location: (1,8)-(1,9))
                │   │   │   └── flags: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,3)-(1,4) = "|"
                │   └── closing_loc: (1,9)-(1,10) = "|"
                ├── body: ∅
                ├── opening_loc: (1,1)-(1,2) = "{"
                └── closing_loc: (1,11)-(1,12) = "}"
prism-1.5.1/snapshots/whitequark/multiple_pattern_matches.txt000066400000000000000000000272321506127434000247230ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,12))
├── flags: ∅
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (1,0)-(5,12))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ MatchRequiredNode (location: (1,0)-(1,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ HashNode (location: (1,0)-(1,6))
        │   │   ├── flags: static_literal
        │   │   ├── opening_loc: (1,0)-(1,1) = "{"
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (1,1)-(1,5))
        │   │   │       ├── flags: static_literal
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (1,1)-(1,3))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (1,1)-(1,2) = "a"
        │   │   │       │   ├── closing_loc: (1,2)-(1,3) = ":"
        │   │   │       │   └── unescaped: "a"
        │   │   │       ├── value:
        │   │   │       │   @ IntegerNode (location: (1,4)-(1,5))
        │   │   │       │   ├── flags: static_literal, decimal
        │   │   │       │   └── value: 0
        │   │   │       └── operator_loc: ∅
        │   │   └── closing_loc: (1,5)-(1,6) = "}"
        │   ├── pattern:
        │   │   @ HashPatternNode (location: (1,10)-(1,12))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (1,10)-(1,12))
        │   │   │       ├── flags: ∅
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (1,10)-(1,12))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (1,10)-(1,11) = "a"
        │   │   │       │   ├── closing_loc: (1,11)-(1,12) = ":"
        │   │   │       │   └── unescaped: "a"
        │   │   │       ├── value:
        │   │   │       │   @ ImplicitNode (location: (1,10)-(1,11))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   └── value:
        │   │   │       │       @ LocalVariableTargetNode (location: (1,10)-(1,11))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       ├── name: :a
        │   │   │       │       └── depth: 0
        │   │   │       └── operator_loc: ∅
        │   │   ├── rest: ∅
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (1,7)-(1,9) = "=>"
        ├── @ MatchRequiredNode (location: (2,0)-(2,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ HashNode (location: (2,0)-(2,6))
        │   │   ├── flags: static_literal
        │   │   ├── opening_loc: (2,0)-(2,1) = "{"
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (2,1)-(2,5))
        │   │   │       ├── flags: static_literal
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (2,1)-(2,3))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (2,1)-(2,2) = "a"
        │   │   │       │   ├── closing_loc: (2,2)-(2,3) = ":"
        │   │   │       │   └── unescaped: "a"
        │   │   │       ├── value:
        │   │   │       │   @ IntegerNode (location: (2,4)-(2,5))
        │   │   │       │   ├── flags: static_literal, decimal
        │   │   │       │   └── value: 0
        │   │   │       └── operator_loc: ∅
        │   │   └── closing_loc: (2,5)-(2,6) = "}"
        │   ├── pattern:
        │   │   @ HashPatternNode (location: (2,10)-(2,12))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (2,10)-(2,12))
        │   │   │       ├── flags: ∅
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (2,10)-(2,12))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (2,10)-(2,11) = "a"
        │   │   │       │   ├── closing_loc: (2,11)-(2,12) = ":"
        │   │   │       │   └── unescaped: "a"
        │   │   │       ├── value:
        │   │   │       │   @ ImplicitNode (location: (2,10)-(2,11))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   └── value:
        │   │   │       │       @ LocalVariableTargetNode (location: (2,10)-(2,11))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       ├── name: :a
        │   │   │       │       └── depth: 0
        │   │   │       └── operator_loc: ∅
        │   │   ├── rest: ∅
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (2,7)-(2,9) = "=>"
        ├── @ MatchPredicateNode (location: (4,0)-(4,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ HashNode (location: (4,0)-(4,6))
        │   │   ├── flags: static_literal
        │   │   ├── opening_loc: (4,0)-(4,1) = "{"
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (4,1)-(4,5))
        │   │   │       ├── flags: static_literal
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (4,1)-(4,3))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (4,1)-(4,2) = "a"
        │   │   │       │   ├── closing_loc: (4,2)-(4,3) = ":"
        │   │   │       │   └── unescaped: "a"
        │   │   │       ├── value:
        │   │   │       │   @ IntegerNode (location: (4,4)-(4,5))
        │   │   │       │   ├── flags: static_literal, decimal
        │   │   │       │   └── value: 0
        │   │   │       └── operator_loc: ∅
        │   │   └── closing_loc: (4,5)-(4,6) = "}"
        │   ├── pattern:
        │   │   @ HashPatternNode (location: (4,10)-(4,12))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (4,10)-(4,12))
        │   │   │       ├── flags: ∅
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (4,10)-(4,12))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (4,10)-(4,11) = "a"
        │   │   │       │   ├── closing_loc: (4,11)-(4,12) = ":"
        │   │   │       │   └── unescaped: "a"
        │   │   │       ├── value:
        │   │   │       │   @ ImplicitNode (location: (4,10)-(4,11))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   └── value:
        │   │   │       │       @ LocalVariableTargetNode (location: (4,10)-(4,11))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       ├── name: :a
        │   │   │       │       └── depth: 0
        │   │   │       └── operator_loc: ∅
        │   │   ├── rest: ∅
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (4,7)-(4,9) = "in"
        └── @ MatchPredicateNode (location: (5,0)-(5,12))
            ├── flags: newline
            ├── value:
            │   @ HashNode (location: (5,0)-(5,6))
            │   ├── flags: static_literal
            │   ├── opening_loc: (5,0)-(5,1) = "{"
            │   ├── elements: (length: 1)
            │   │   └── @ AssocNode (location: (5,1)-(5,5))
            │   │       ├── flags: static_literal
            │   │       ├── key:
            │   │       │   @ SymbolNode (location: (5,1)-(5,3))
            │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │       │   ├── opening_loc: ∅
            │   │       │   ├── value_loc: (5,1)-(5,2) = "a"
            │   │       │   ├── closing_loc: (5,2)-(5,3) = ":"
            │   │       │   └── unescaped: "a"
            │   │       ├── value:
            │   │       │   @ IntegerNode (location: (5,4)-(5,5))
            │   │       │   ├── flags: static_literal, decimal
            │   │       │   └── value: 0
            │   │       └── operator_loc: ∅
            │   └── closing_loc: (5,5)-(5,6) = "}"
            ├── pattern:
            │   @ HashPatternNode (location: (5,10)-(5,12))
            │   ├── flags: ∅
            │   ├── constant: ∅
            │   ├── elements: (length: 1)
            │   │   └── @ AssocNode (location: (5,10)-(5,12))
            │   │       ├── flags: ∅
            │   │       ├── key:
            │   │       │   @ SymbolNode (location: (5,10)-(5,12))
            │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │       │   ├── opening_loc: ∅
            │   │       │   ├── value_loc: (5,10)-(5,11) = "a"
            │   │       │   ├── closing_loc: (5,11)-(5,12) = ":"
            │   │       │   └── unescaped: "a"
            │   │       ├── value:
            │   │       │   @ ImplicitNode (location: (5,10)-(5,11))
            │   │       │   ├── flags: ∅
            │   │       │   └── value:
            │   │       │       @ LocalVariableTargetNode (location: (5,10)-(5,11))
            │   │       │       ├── flags: ∅
            │   │       │       ├── name: :a
            │   │       │       └── depth: 0
            │   │       └── operator_loc: ∅
            │   ├── rest: ∅
            │   ├── opening_loc: ∅
            │   └── closing_loc: ∅
            └── operator_loc: (5,7)-(5,9) = "in"
prism-1.5.1/snapshots/whitequark/newline_in_hash_argument.txt000066400000000000000000000254471506127434000246710ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(14,1))
├── flags: ∅
├── locals: [:a, :b]
└── statements:
    @ StatementsNode (location: (1,0)-(14,1))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ CaseMatchNode (location: (1,0)-(8,3))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (1,5)-(1,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,5)-(1,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 2)
        │   │   ├── @ InNode (location: (2,0)-(4,4))
        │   │   │   ├── flags: ∅
        │   │   │   ├── pattern:
        │   │   │   │   @ HashPatternNode (location: (2,3)-(2,5))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── constant: ∅
        │   │   │   │   ├── elements: (length: 1)
        │   │   │   │   │   └── @ AssocNode (location: (2,3)-(2,5))
        │   │   │   │   │       ├── flags: ∅
        │   │   │   │   │       ├── key:
        │   │   │   │   │       │   @ SymbolNode (location: (2,3)-(2,5))
        │   │   │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │   │       │   ├── opening_loc: ∅
        │   │   │   │   │       │   ├── value_loc: (2,3)-(2,4) = "a"
        │   │   │   │   │       │   ├── closing_loc: (2,4)-(2,5) = ":"
        │   │   │   │   │       │   └── unescaped: "a"
        │   │   │   │   │       ├── value:
        │   │   │   │   │       │   @ ImplicitNode (location: (2,3)-(2,4))
        │   │   │   │   │       │   ├── flags: ∅
        │   │   │   │   │       │   └── value:
        │   │   │   │   │       │       @ LocalVariableTargetNode (location: (2,3)-(2,4))
        │   │   │   │   │       │       ├── flags: ∅
        │   │   │   │   │       │       ├── name: :a
        │   │   │   │   │       │       └── depth: 0
        │   │   │   │   │       └── operator_loc: ∅
        │   │   │   │   ├── rest: ∅
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   └── closing_loc: ∅
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (3,0)-(4,4))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 2)
        │   │   │   │       ├── @ IntegerNode (location: (3,0)-(3,1))
        │   │   │   │       │   ├── flags: newline, static_literal, decimal
        │   │   │   │       │   └── value: 0
        │   │   │   │       └── @ TrueNode (location: (4,0)-(4,4))
        │   │   │   │           └── flags: newline, static_literal
        │   │   │   ├── in_loc: (2,0)-(2,2) = "in"
        │   │   │   └── then_loc: ∅
        │   │   └── @ InNode (location: (5,0)-(7,4))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (5,3)-(5,7))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (5,3)-(5,7))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (5,3)-(5,7))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: (5,3)-(5,4) = "\""
        │   │       │   │       │   ├── value_loc: (5,4)-(5,5) = "b"
        │   │       │   │       │   ├── closing_loc: (5,5)-(5,7) = "\":"
        │   │       │   │       │   └── unescaped: "b"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ ImplicitNode (location: (5,4)-(5,5))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── value:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (5,4)-(5,5))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :b
        │   │       │   │       │       └── depth: 0
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (6,0)-(7,4))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 2)
        │   │       │       ├── @ IntegerNode (location: (6,0)-(6,1))
        │   │       │       │   ├── flags: newline, static_literal, decimal
        │   │       │       │   └── value: 0
        │   │       │       └── @ TrueNode (location: (7,0)-(7,4))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (5,0)-(5,2) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (8,0)-(8,3) = "end"
        ├── @ CallNode (location: (10,0)-(11,1))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (10,0)-(10,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :obj
        │   │   ├── message_loc: (10,0)-(10,3) = "obj"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (10,3)-(10,4) = "."
        │   ├── name: :set
        │   ├── message_loc: (10,4)-(10,7) = "set"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (10,8)-(11,1))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (10,8)-(11,1))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (10,8)-(11,1))
        │   │                   ├── flags: static_literal
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (10,8)-(10,14))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: (10,8)-(10,9) = "\""
        │   │                   │   ├── value_loc: (10,9)-(10,12) = "foo"
        │   │                   │   ├── closing_loc: (10,12)-(10,14) = "\":"
        │   │                   │   └── unescaped: "foo"
        │   │                   ├── value:
        │   │                   │   @ IntegerNode (location: (11,0)-(11,1))
        │   │                   │   ├── flags: static_literal, decimal
        │   │                   │   └── value: 1
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (13,0)-(14,1))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (13,0)-(13,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :obj
            │   ├── message_loc: (13,0)-(13,3) = "obj"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (13,3)-(13,4) = "."
            ├── name: :set
            ├── message_loc: (13,4)-(13,7) = "set"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (13,8)-(14,1))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 1)
            │       └── @ KeywordHashNode (location: (13,8)-(14,1))
            │           ├── flags: symbol_keys
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (13,8)-(14,1))
            │                   ├── flags: static_literal
            │                   ├── key:
            │                   │   @ SymbolNode (location: (13,8)-(13,12))
            │                   │   ├── flags: static_literal, forced_us_ascii_encoding
            │                   │   ├── opening_loc: ∅
            │                   │   ├── value_loc: (13,8)-(13,11) = "foo"
            │                   │   ├── closing_loc: (13,11)-(13,12) = ":"
            │                   │   └── unescaped: "foo"
            │                   ├── value:
            │                   │   @ IntegerNode (location: (14,0)-(14,1))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 1
            │                   └── operator_loc: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/nil.txt000066400000000000000000000004651506127434000204100ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ NilNode (location: (1,0)-(1,3))
            └── flags: newline, static_literal
prism-1.5.1/snapshots/whitequark/nil_expression.txt000066400000000000000000000014631506127434000226660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,9))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ ParenthesesNode (location: (1,0)-(1,2))
        │   ├── flags: newline
        │   ├── body: ∅
        │   ├── opening_loc: (1,0)-(1,1) = "("
        │   └── closing_loc: (1,1)-(1,2) = ")"
        └── @ BeginNode (location: (3,0)-(3,9))
            ├── flags: newline
            ├── begin_keyword_loc: (3,0)-(3,5) = "begin"
            ├── statements: ∅
            ├── rescue_clause: ∅
            ├── else_clause: ∅
            ├── ensure_clause: ∅
            └── end_keyword_loc: (3,6)-(3,9) = "end"
prism-1.5.1/snapshots/whitequark/non_lvar_injecting_match.txt000066400000000000000000000050261506127434000246500ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,28))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,28))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,28))
            ├── flags: newline
            ├── receiver:
            │   @ InterpolatedRegularExpressionNode (location: (1,0)-(1,19))
            │   ├── flags: ∅
            │   ├── opening_loc: (1,0)-(1,1) = "/"
            │   ├── parts: (length: 2)
            │   │   ├── @ EmbeddedStatementsNode (location: (1,1)-(1,5))
            │   │   │   ├── flags: ∅
            │   │   │   ├── opening_loc: (1,1)-(1,3) = "\#{"
            │   │   │   ├── statements:
            │   │   │   │   @ StatementsNode (location: (1,3)-(1,4))
            │   │   │   │   ├── flags: ∅
            │   │   │   │   └── body: (length: 1)
            │   │   │   │       └── @ IntegerNode (location: (1,3)-(1,4))
            │   │   │   │           ├── flags: static_literal, decimal
            │   │   │   │           └── value: 1
            │   │   │   └── closing_loc: (1,4)-(1,5) = "}"
            │   │   └── @ StringNode (location: (1,5)-(1,18))
            │   │       ├── flags: static_literal, frozen
            │   │       ├── opening_loc: ∅
            │   │       ├── content_loc: (1,5)-(1,18) = "(?bar)"
            │   │       ├── closing_loc: ∅
            │   │       └── unescaped: "(?bar)"
            │   └── closing_loc: (1,18)-(1,19) = "/"
            ├── call_operator_loc: ∅
            ├── name: :=~
            ├── message_loc: (1,20)-(1,22) = "=~"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,23)-(1,28))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ StringNode (location: (1,23)-(1,28))
            │           ├── flags: ∅
            │           ├── opening_loc: (1,23)-(1,24) = "'"
            │           ├── content_loc: (1,24)-(1,27) = "bar"
            │           ├── closing_loc: (1,27)-(1,28) = "'"
            │           └── unescaped: "bar"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/not.txt000066400000000000000000000052501506127434000204230ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,8))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ CallNode (location: (1,0)-(1,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,4)-(1,7))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,4)-(1,7) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :!
        │   ├── message_loc: (1,0)-(1,3) = "not"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,5))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ ParenthesesNode (location: (3,3)-(3,5))
        │   │   ├── flags: ∅
        │   │   ├── body: ∅
        │   │   ├── opening_loc: (3,3)-(3,4) = "("
        │   │   └── closing_loc: (3,4)-(3,5) = ")"
        │   ├── call_operator_loc: ∅
        │   ├── name: :!
        │   ├── message_loc: (3,0)-(3,3) = "not"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (5,0)-(5,8))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (5,4)-(5,7))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (5,4)-(5,7) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :!
            ├── message_loc: (5,0)-(5,3) = "not"
            ├── opening_loc: (5,3)-(5,4) = "("
            ├── arguments: ∅
            ├── closing_loc: (5,7)-(5,8) = ")"
            └── block: ∅
prism-1.5.1/snapshots/whitequark/not_cmd.txt000066400000000000000000000035121506127434000212450ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,9))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,4)-(1,9))
            │   ├── flags: ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :m
            │   ├── message_loc: (1,4)-(1,5) = "m"
            │   ├── opening_loc: ∅
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (1,6)-(1,9))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 1)
            │   │       └── @ CallNode (location: (1,6)-(1,9))
            │   │           ├── flags: variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :foo
            │   │           ├── message_loc: (1,6)-(1,9) = "foo"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :!
            ├── message_loc: (1,0)-(1,3) = "not"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/not_masgn__24.txt000066400000000000000000000054041506127434000222550ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: [:a, :b]
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,13))
            ├── flags: newline
            ├── receiver:
            │   @ ParenthesesNode (location: (1,1)-(1,13))
            │   ├── flags: ∅
            │   ├── body:
            │   │   @ StatementsNode (location: (1,2)-(1,12))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ MultiWriteNode (location: (1,2)-(1,12))
            │   │           ├── flags: newline
            │   │           ├── lefts: (length: 2)
            │   │           │   ├── @ LocalVariableTargetNode (location: (1,2)-(1,3))
            │   │           │   │   ├── flags: ∅
            │   │           │   │   ├── name: :a
            │   │           │   │   └── depth: 0
            │   │           │   └── @ LocalVariableTargetNode (location: (1,5)-(1,6))
            │   │           │       ├── flags: ∅
            │   │           │       ├── name: :b
            │   │           │       └── depth: 0
            │   │           ├── rest: ∅
            │   │           ├── rights: (length: 0)
            │   │           ├── lparen_loc: ∅
            │   │           ├── rparen_loc: ∅
            │   │           ├── operator_loc: (1,7)-(1,8) = "="
            │   │           └── value:
            │   │               @ CallNode (location: (1,9)-(1,12))
            │   │               ├── flags: variable_call, ignore_visibility
            │   │               ├── receiver: ∅
            │   │               ├── call_operator_loc: ∅
            │   │               ├── name: :foo
            │   │               ├── message_loc: (1,9)-(1,12) = "foo"
            │   │               ├── opening_loc: ∅
            │   │               ├── arguments: ∅
            │   │               ├── closing_loc: ∅
            │   │               └── block: ∅
            │   ├── opening_loc: (1,1)-(1,2) = "("
            │   └── closing_loc: (1,12)-(1,13) = ")"
            ├── call_operator_loc: ∅
            ├── name: :!
            ├── message_loc: (1,0)-(1,1) = "!"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/nth_ref.txt000066400000000000000000000005301506127434000212440ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ NumberedReferenceReadNode (location: (1,0)-(1,3))
            ├── flags: newline
            └── number: 10
prism-1.5.1/snapshots/whitequark/numbered_args_after_27.txt000066400000000000000000000214671506127434000241410ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(7,13))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ LambdaNode (location: (1,0)-(1,17))
        │   ├── flags: newline
        │   ├── locals: [:_1, :_2, :_3, :_4, :_5, :_6, :_7, :_8, :_9]
        │   ├── operator_loc: (1,0)-(1,2) = "->"
        │   ├── opening_loc: (1,3)-(1,5) = "do"
        │   ├── closing_loc: (1,14)-(1,17) = "end"
        │   ├── parameters:
        │   │   @ NumberedParametersNode (location: (1,0)-(1,17))
        │   │   ├── flags: ∅
        │   │   └── maximum: 9
        │   └── body:
        │       @ StatementsNode (location: (1,6)-(1,13))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ CallNode (location: (1,6)-(1,13))
        │               ├── flags: newline
        │               ├── receiver:
        │               │   @ LocalVariableReadNode (location: (1,6)-(1,8))
        │               │   ├── flags: ∅
        │               │   ├── name: :_1
        │               │   └── depth: 0
        │               ├── call_operator_loc: ∅
        │               ├── name: :+
        │               ├── message_loc: (1,9)-(1,10) = "+"
        │               ├── opening_loc: ∅
        │               ├── arguments:
        │               │   @ ArgumentsNode (location: (1,11)-(1,13))
        │               │   ├── flags: ∅
        │               │   └── arguments: (length: 1)
        │               │       └── @ LocalVariableReadNode (location: (1,11)-(1,13))
        │               │           ├── flags: ∅
        │               │           ├── name: :_9
        │               │           └── depth: 0
        │               ├── closing_loc: ∅
        │               └── block: ∅
        ├── @ LambdaNode (location: (3,0)-(3,13))
        │   ├── flags: newline
        │   ├── locals: [:_1, :_2, :_3, :_4, :_5, :_6, :_7, :_8, :_9]
        │   ├── operator_loc: (3,0)-(3,2) = "->"
        │   ├── opening_loc: (3,3)-(3,4) = "{"
        │   ├── closing_loc: (3,12)-(3,13) = "}"
        │   ├── parameters:
        │   │   @ NumberedParametersNode (location: (3,0)-(3,13))
        │   │   ├── flags: ∅
        │   │   └── maximum: 9
        │   └── body:
        │       @ StatementsNode (location: (3,5)-(3,12))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ CallNode (location: (3,5)-(3,12))
        │               ├── flags: newline
        │               ├── receiver:
        │               │   @ LocalVariableReadNode (location: (3,5)-(3,7))
        │               │   ├── flags: ∅
        │               │   ├── name: :_1
        │               │   └── depth: 0
        │               ├── call_operator_loc: ∅
        │               ├── name: :+
        │               ├── message_loc: (3,8)-(3,9) = "+"
        │               ├── opening_loc: ∅
        │               ├── arguments:
        │               │   @ ArgumentsNode (location: (3,10)-(3,12))
        │               │   ├── flags: ∅
        │               │   └── arguments: (length: 1)
        │               │       └── @ LocalVariableReadNode (location: (3,10)-(3,12))
        │               │           ├── flags: ∅
        │               │           ├── name: :_9
        │               │           └── depth: 0
        │               ├── closing_loc: ∅
        │               └── block: ∅
        ├── @ CallNode (location: (5,0)-(5,16))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (5,0)-(5,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (5,2)-(5,16))
        │       ├── flags: ∅
        │       ├── locals: [:_1, :_2, :_3, :_4, :_5, :_6, :_7, :_8, :_9]
        │       ├── parameters:
        │       │   @ NumberedParametersNode (location: (5,2)-(5,16))
        │       │   ├── flags: ∅
        │       │   └── maximum: 9
        │       ├── body:
        │       │   @ StatementsNode (location: (5,5)-(5,12))
        │       │   ├── flags: ∅
        │       │   └── body: (length: 1)
        │       │       └── @ CallNode (location: (5,5)-(5,12))
        │       │           ├── flags: newline
        │       │           ├── receiver:
        │       │           │   @ LocalVariableReadNode (location: (5,5)-(5,7))
        │       │           │   ├── flags: ∅
        │       │           │   ├── name: :_1
        │       │           │   └── depth: 0
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :+
        │       │           ├── message_loc: (5,8)-(5,9) = "+"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments:
        │       │           │   @ ArgumentsNode (location: (5,10)-(5,12))
        │       │           │   ├── flags: ∅
        │       │           │   └── arguments: (length: 1)
        │       │           │       └── @ LocalVariableReadNode (location: (5,10)-(5,12))
        │       │           │           ├── flags: ∅
        │       │           │           ├── name: :_9
        │       │           │           └── depth: 0
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── opening_loc: (5,2)-(5,4) = "do"
        │       └── closing_loc: (5,13)-(5,16) = "end"
        └── @ CallNode (location: (7,0)-(7,13))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :m
            ├── message_loc: (7,0)-(7,1) = "m"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (7,2)-(7,13))
                ├── flags: ∅
                ├── locals: [:_1, :_2, :_3, :_4, :_5, :_6, :_7, :_8, :_9]
                ├── parameters:
                │   @ NumberedParametersNode (location: (7,2)-(7,13))
                │   ├── flags: ∅
                │   └── maximum: 9
                ├── body:
                │   @ StatementsNode (location: (7,4)-(7,11))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ CallNode (location: (7,4)-(7,11))
                │           ├── flags: newline
                │           ├── receiver:
                │           │   @ LocalVariableReadNode (location: (7,4)-(7,6))
                │           │   ├── flags: ∅
                │           │   ├── name: :_1
                │           │   └── depth: 0
                │           ├── call_operator_loc: ∅
                │           ├── name: :+
                │           ├── message_loc: (7,7)-(7,8) = "+"
                │           ├── opening_loc: ∅
                │           ├── arguments:
                │           │   @ ArgumentsNode (location: (7,9)-(7,11))
                │           │   ├── flags: ∅
                │           │   └── arguments: (length: 1)
                │           │       └── @ LocalVariableReadNode (location: (7,9)-(7,11))
                │           │           ├── flags: ∅
                │           │           ├── name: :_9
                │           │           └── depth: 0
                │           ├── closing_loc: ∅
                │           └── block: ∅
                ├── opening_loc: (7,2)-(7,3) = "{"
                └── closing_loc: (7,12)-(7,13) = "}"
prism-1.5.1/snapshots/whitequark/numparam_outside_block.txt000066400000000000000000000143101506127434000243460ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(9,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(9,17))
    ├── flags: ∅
    └── body: (length: 5)
        ├── @ CallNode (location: (1,0)-(1,2))
        │   ├── flags: newline, variable_call, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :_1
        │   ├── message_loc: (1,0)-(1,2) = "_1"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ SingletonClassNode (location: (3,0)-(3,21))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (3,0)-(3,5) = "class"
        │   ├── operator_loc: (3,6)-(3,8) = "<<"
        │   ├── expression:
        │   │   @ CallNode (location: (3,9)-(3,12))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,9)-(3,12) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (3,14)-(3,16))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (3,14)-(3,16))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :_1
        │   │           ├── message_loc: (3,14)-(3,16) = "_1"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   └── end_keyword_loc: (3,18)-(3,21) = "end"
        ├── @ ClassNode (location: (5,0)-(5,16))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── class_keyword_loc: (5,0)-(5,5) = "class"
        │   ├── constant_path:
        │   │   @ ConstantReadNode (location: (5,6)-(5,7))
        │   │   ├── flags: ∅
        │   │   └── name: :A
        │   ├── inheritance_operator_loc: ∅
        │   ├── superclass: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (5,9)-(5,11))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (5,9)-(5,11))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :_1
        │   │           ├── message_loc: (5,9)-(5,11) = "_1"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── end_keyword_loc: (5,13)-(5,16) = "end"
        │   └── name: :A
        ├── @ DefNode (location: (7,0)-(7,19))
        │   ├── flags: newline
        │   ├── name: :m
        │   ├── name_loc: (7,9)-(7,10) = "m"
        │   ├── receiver:
        │   │   @ SelfNode (location: (7,4)-(7,8))
        │   │   └── flags: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (7,12)-(7,14))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (7,12)-(7,14))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :_1
        │   │           ├── message_loc: (7,12)-(7,14) = "_1"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (7,0)-(7,3) = "def"
        │   ├── operator_loc: (7,8)-(7,9) = "."
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (7,16)-(7,19) = "end"
        └── @ ModuleNode (location: (9,0)-(9,17))
            ├── flags: newline
            ├── locals: []
            ├── module_keyword_loc: (9,0)-(9,6) = "module"
            ├── constant_path:
            │   @ ConstantReadNode (location: (9,7)-(9,8))
            │   ├── flags: ∅
            │   └── name: :A
            ├── body:
            │   @ StatementsNode (location: (9,10)-(9,12))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (9,10)-(9,12))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :_1
            │           ├── message_loc: (9,10)-(9,12) = "_1"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── end_keyword_loc: (9,14)-(9,17) = "end"
            └── name: :A
prism-1.5.1/snapshots/whitequark/numparam_ruby_bug_19025.txt000066400000000000000000000057631506127434000241120ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,14))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :p
            ├── message_loc: (1,0)-(1,1) = "p"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,2)-(1,14))
                ├── flags: ∅
                ├── locals: [:_1]
                ├── parameters:
                │   @ NumberedParametersNode (location: (1,2)-(1,14))
                │   ├── flags: ∅
                │   └── maximum: 1
                ├── body:
                │   @ StatementsNode (location: (1,4)-(1,12))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ ArrayNode (location: (1,4)-(1,12))
                │           ├── flags: newline
                │           ├── elements: (length: 1)
                │           │   └── @ CallNode (location: (1,5)-(1,11))
                │           │       ├── flags: ∅
                │           │       ├── receiver:
                │           │       │   @ LocalVariableReadNode (location: (1,5)-(1,7))
                │           │       │   ├── flags: ∅
                │           │       │   ├── name: :_1
                │           │       │   └── depth: 0
                │           │       ├── call_operator_loc: ∅
                │           │       ├── name: :**
                │           │       ├── message_loc: (1,8)-(1,10) = "**"
                │           │       ├── opening_loc: ∅
                │           │       ├── arguments:
                │           │       │   @ ArgumentsNode (location: (1,10)-(1,11))
                │           │       │   ├── flags: ∅
                │           │       │   └── arguments: (length: 1)
                │           │       │       └── @ IntegerNode (location: (1,10)-(1,11))
                │           │       │           ├── flags: static_literal, decimal
                │           │       │           └── value: 2
                │           │       ├── closing_loc: ∅
                │           │       └── block: ∅
                │           ├── opening_loc: (1,4)-(1,5) = "["
                │           └── closing_loc: (1,11)-(1,12) = "]"
                ├── opening_loc: (1,2)-(1,3) = "{"
                └── closing_loc: (1,13)-(1,14) = "}"
prism-1.5.1/snapshots/whitequark/op_asgn.txt000066400000000000000000000067501506127434000212570ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,11))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ CallOperatorWriteNode (location: (1,0)-(1,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (1,3)-(1,4) = "."
        │   ├── message_loc: (1,4)-(1,5) = "A"
        │   ├── read_name: :A
        │   ├── write_name: :A=
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (1,6)-(1,8) = "+="
        │   └── value:
        │       @ IntegerNode (location: (1,9)-(1,10))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        ├── @ CallOperatorWriteNode (location: (3,0)-(3,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (3,3)-(3,4) = "."
        │   ├── message_loc: (3,4)-(3,5) = "a"
        │   ├── read_name: :a
        │   ├── write_name: :a=
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (3,6)-(3,8) = "+="
        │   └── value:
        │       @ IntegerNode (location: (3,9)-(3,10))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        └── @ CallOperatorWriteNode (location: (5,0)-(5,11))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (5,0)-(5,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (5,0)-(5,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (5,3)-(5,5) = "::"
            ├── message_loc: (5,5)-(5,6) = "a"
            ├── read_name: :a
            ├── write_name: :a=
            ├── binary_operator: :+
            ├── binary_operator_loc: (5,7)-(5,9) = "+="
            └── value:
                @ IntegerNode (location: (5,10)-(5,11))
                ├── flags: static_literal, decimal
                └── value: 1
prism-1.5.1/snapshots/whitequark/op_asgn_cmd.txt000066400000000000000000000221741506127434000221000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(7,15))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ CallOperatorWriteNode (location: (1,0)-(1,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (1,3)-(1,4) = "."
        │   ├── message_loc: (1,4)-(1,5) = "A"
        │   ├── read_name: :A
        │   ├── write_name: :A=
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (1,6)-(1,8) = "+="
        │   └── value:
        │       @ CallNode (location: (1,9)-(1,14))
        │       ├── flags: ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :m
        │       ├── message_loc: (1,9)-(1,10) = "m"
        │       ├── opening_loc: ∅
        │       ├── arguments:
        │       │   @ ArgumentsNode (location: (1,11)-(1,14))
        │       │   ├── flags: ∅
        │       │   └── arguments: (length: 1)
        │       │       └── @ CallNode (location: (1,11)-(1,14))
        │       │           ├── flags: variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :foo
        │       │           ├── message_loc: (1,11)-(1,14) = "foo"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ CallOperatorWriteNode (location: (3,0)-(3,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (3,3)-(3,4) = "."
        │   ├── message_loc: (3,4)-(3,5) = "a"
        │   ├── read_name: :a
        │   ├── write_name: :a=
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (3,6)-(3,8) = "+="
        │   └── value:
        │       @ CallNode (location: (3,9)-(3,14))
        │       ├── flags: ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :m
        │       ├── message_loc: (3,9)-(3,10) = "m"
        │       ├── opening_loc: ∅
        │       ├── arguments:
        │       │   @ ArgumentsNode (location: (3,11)-(3,14))
        │       │   ├── flags: ∅
        │       │   └── arguments: (length: 1)
        │       │       └── @ CallNode (location: (3,11)-(3,14))
        │       │           ├── flags: variable_call, ignore_visibility
        │       │           ├── receiver: ∅
        │       │           ├── call_operator_loc: ∅
        │       │           ├── name: :foo
        │       │           ├── message_loc: (3,11)-(3,14) = "foo"
        │       │           ├── opening_loc: ∅
        │       │           ├── arguments: ∅
        │       │           ├── closing_loc: ∅
        │       │           └── block: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ ConstantPathOperatorWriteNode (location: (5,0)-(5,15))
        │   ├── flags: newline
        │   ├── target:
        │   │   @ ConstantPathNode (location: (5,0)-(5,6))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ CallNode (location: (5,0)-(5,3))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (5,0)-(5,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── name: :A
        │   │   ├── delimiter_loc: (5,3)-(5,5) = "::"
        │   │   └── name_loc: (5,5)-(5,6) = "A"
        │   ├── binary_operator_loc: (5,7)-(5,9) = "+="
        │   ├── value:
        │   │   @ CallNode (location: (5,10)-(5,15))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :m
        │   │   ├── message_loc: (5,10)-(5,11) = "m"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (5,12)-(5,15))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ CallNode (location: (5,12)-(5,15))
        │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :foo
        │   │   │           ├── message_loc: (5,12)-(5,15) = "foo"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── binary_operator: :+
        └── @ CallOperatorWriteNode (location: (7,0)-(7,15))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (7,0)-(7,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (7,0)-(7,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (7,3)-(7,5) = "::"
            ├── message_loc: (7,5)-(7,6) = "a"
            ├── read_name: :a
            ├── write_name: :a=
            ├── binary_operator: :+
            ├── binary_operator_loc: (7,7)-(7,9) = "+="
            └── value:
                @ CallNode (location: (7,10)-(7,15))
                ├── flags: ignore_visibility
                ├── receiver: ∅
                ├── call_operator_loc: ∅
                ├── name: :m
                ├── message_loc: (7,10)-(7,11) = "m"
                ├── opening_loc: ∅
                ├── arguments:
                │   @ ArgumentsNode (location: (7,12)-(7,15))
                │   ├── flags: ∅
                │   └── arguments: (length: 1)
                │       └── @ CallNode (location: (7,12)-(7,15))
                │           ├── flags: variable_call, ignore_visibility
                │           ├── receiver: ∅
                │           ├── call_operator_loc: ∅
                │           ├── name: :foo
                │           ├── message_loc: (7,12)-(7,15) = "foo"
                │           ├── opening_loc: ∅
                │           ├── arguments: ∅
                │           ├── closing_loc: ∅
                │           └── block: ∅
                ├── closing_loc: ∅
                └── block: ∅
prism-1.5.1/snapshots/whitequark/op_asgn_index.txt000066400000000000000000000034651506127434000224460ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ IndexOperatorWriteNode (location: (1,0)-(1,14))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,0)-(1,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── opening_loc: (1,3)-(1,4) = "["
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,8))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ IntegerNode (location: (1,4)-(1,5))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 0
            │       └── @ IntegerNode (location: (1,7)-(1,8))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: (1,8)-(1,9) = "]"
            ├── block: ∅
            ├── binary_operator: :+
            ├── binary_operator_loc: (1,10)-(1,12) = "+="
            └── value:
                @ IntegerNode (location: (1,13)-(1,14))
                ├── flags: static_literal, decimal
                └── value: 2
prism-1.5.1/snapshots/whitequark/op_asgn_index_cmd.txt000066400000000000000000000055521506127434000232700ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,18))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,18))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ IndexOperatorWriteNode (location: (1,0)-(1,18))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,0)-(1,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── opening_loc: (1,3)-(1,4) = "["
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,8))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ IntegerNode (location: (1,4)-(1,5))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 0
            │       └── @ IntegerNode (location: (1,7)-(1,8))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: (1,8)-(1,9) = "]"
            ├── block: ∅
            ├── binary_operator: :+
            ├── binary_operator_loc: (1,10)-(1,12) = "+="
            └── value:
                @ CallNode (location: (1,13)-(1,18))
                ├── flags: ignore_visibility
                ├── receiver: ∅
                ├── call_operator_loc: ∅
                ├── name: :m
                ├── message_loc: (1,13)-(1,14) = "m"
                ├── opening_loc: ∅
                ├── arguments:
                │   @ ArgumentsNode (location: (1,15)-(1,18))
                │   ├── flags: ∅
                │   └── arguments: (length: 1)
                │       └── @ CallNode (location: (1,15)-(1,18))
                │           ├── flags: variable_call, ignore_visibility
                │           ├── receiver: ∅
                │           ├── call_operator_loc: ∅
                │           ├── name: :foo
                │           ├── message_loc: (1,15)-(1,18) = "foo"
                │           ├── opening_loc: ∅
                │           ├── arguments: ∅
                │           ├── closing_loc: ∅
                │           └── block: ∅
                ├── closing_loc: ∅
                └── block: ∅
prism-1.5.1/snapshots/whitequark/optarg.txt000066400000000000000000000076601506127434000211260ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,24))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,24))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ DefNode (location: (1,0)-(1,18))
        │   ├── flags: newline
        │   ├── name: :f
        │   ├── name_loc: (1,4)-(1,5) = "f"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (1,6)-(1,13))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 1)
        │   │   │   └── @ OptionalParameterNode (location: (1,6)-(1,13))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :foo
        │   │   │       ├── name_loc: (1,6)-(1,9) = "foo"
        │   │   │       ├── operator_loc: (1,10)-(1,11) = "="
        │   │   │       └── value:
        │   │   │           @ IntegerNode (location: (1,12)-(1,13))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 0)
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body: ∅
        │   ├── locals: [:foo]
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (1,15)-(1,18) = "end"
        └── @ DefNode (location: (3,0)-(3,24))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (3,4)-(3,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (3,6)-(3,18))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 2)
            │   │   ├── @ OptionalParameterNode (location: (3,6)-(3,11))
            │   │   │   ├── flags: ∅
            │   │   │   ├── name: :foo
            │   │   │   ├── name_loc: (3,6)-(3,9) = "foo"
            │   │   │   ├── operator_loc: (3,9)-(3,10) = "="
            │   │   │   └── value:
            │   │   │       @ IntegerNode (location: (3,10)-(3,11))
            │   │   │       ├── flags: static_literal, decimal
            │   │   │       └── value: 1
            │   │   └── @ OptionalParameterNode (location: (3,13)-(3,18))
            │   │       ├── flags: ∅
            │   │       ├── name: :bar
            │   │       ├── name_loc: (3,13)-(3,16) = "bar"
            │   │       ├── operator_loc: (3,16)-(3,17) = "="
            │   │       └── value:
            │   │           @ IntegerNode (location: (3,17)-(3,18))
            │   │           ├── flags: static_literal, decimal
            │   │           └── value: 2
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:foo, :bar]
            ├── def_keyword_loc: (3,0)-(3,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (3,5)-(3,6) = "("
            ├── rparen_loc: (3,18)-(3,19) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (3,21)-(3,24) = "end"
prism-1.5.1/snapshots/whitequark/or.txt000066400000000000000000000050541506127434000202450ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,10))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ OrNode (location: (1,0)-(1,10))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── right:
        │   │   @ CallNode (location: (1,7)-(1,10))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (1,7)-(1,10) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (1,4)-(1,6) = "or"
        └── @ OrNode (location: (3,0)-(3,10))
            ├── flags: newline
            ├── left:
            │   @ CallNode (location: (3,0)-(3,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (3,0)-(3,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── right:
            │   @ CallNode (location: (3,7)-(3,10))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :bar
            │   ├── message_loc: (3,7)-(3,10) = "bar"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            └── operator_loc: (3,4)-(3,6) = "||"
prism-1.5.1/snapshots/whitequark/or_asgn.txt000066400000000000000000000054641506127434000212620ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,15))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallOrWriteNode (location: (1,0)-(1,11))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (1,3)-(1,4) = "."
        │   ├── message_loc: (1,4)-(1,5) = "a"
        │   ├── read_name: :a
        │   ├── write_name: :a=
        │   ├── operator_loc: (1,6)-(1,9) = "||="
        │   └── value:
        │       @ IntegerNode (location: (1,10)-(1,11))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        └── @ IndexOrWriteNode (location: (3,0)-(3,15))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (3,0)-(3,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (3,0)-(3,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── opening_loc: (3,3)-(3,4) = "["
            ├── arguments:
            │   @ ArgumentsNode (location: (3,4)-(3,8))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ IntegerNode (location: (3,4)-(3,5))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 0
            │       └── @ IntegerNode (location: (3,7)-(3,8))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: (3,8)-(3,9) = "]"
            ├── block: ∅
            ├── operator_loc: (3,10)-(3,13) = "||="
            └── value:
                @ IntegerNode (location: (3,14)-(3,15))
                ├── flags: static_literal, decimal
                └── value: 2
prism-1.5.1/snapshots/whitequark/parser_bug_272.txt000066400000000000000000000044231506127434000223470ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,15))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,15))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (1,0)-(1,1) = "a"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,4))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ InstanceVariableReadNode (location: (1,2)-(1,4))
            │           ├── flags: ∅
            │           └── name: :@b
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,5)-(1,15))
                ├── flags: ∅
                ├── locals: [:c]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,8)-(1,11))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,9)-(1,10))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :c
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,8)-(1,9) = "|"
                │   └── closing_loc: (1,10)-(1,11) = "|"
                ├── body: ∅
                ├── opening_loc: (1,5)-(1,7) = "do"
                └── closing_loc: (1,12)-(1,15) = "end"
prism-1.5.1/snapshots/whitequark/parser_bug_490.txt000066400000000000000000000161601506127434000223520ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,45))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,45))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ DefNode (location: (1,0)-(1,39))
        │   ├── flags: newline
        │   ├── name: :m
        │   ├── name_loc: (1,4)-(1,5) = "m"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (1,7)-(1,34))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ SingletonClassNode (location: (1,7)-(1,34))
        │   │           ├── flags: newline
        │   │           ├── locals: []
        │   │           ├── class_keyword_loc: (1,7)-(1,12) = "class"
        │   │           ├── operator_loc: (1,13)-(1,15) = "<<"
        │   │           ├── expression:
        │   │           │   @ SelfNode (location: (1,16)-(1,20))
        │   │           │   └── flags: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (1,22)-(1,29))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ ConstantWriteNode (location: (1,22)-(1,29))
        │   │           │           ├── flags: newline
        │   │           │           ├── name: :A
        │   │           │           ├── name_loc: (1,22)-(1,23) = "A"
        │   │           │           ├── value:
        │   │           │           │   @ NilNode (location: (1,26)-(1,29))
        │   │           │           │   └── flags: static_literal
        │   │           │           └── operator_loc: (1,24)-(1,25) = "="
        │   │           └── end_keyword_loc: (1,31)-(1,34) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (1,36)-(1,39) = "end"
        ├── @ DefNode (location: (3,0)-(3,44))
        │   ├── flags: newline
        │   ├── name: :m
        │   ├── name_loc: (3,4)-(3,5) = "m"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (3,7)-(3,39))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ SingletonClassNode (location: (3,7)-(3,39))
        │   │           ├── flags: newline
        │   │           ├── locals: []
        │   │           ├── class_keyword_loc: (3,7)-(3,12) = "class"
        │   │           ├── operator_loc: (3,13)-(3,15) = "<<"
        │   │           ├── expression:
        │   │           │   @ SelfNode (location: (3,16)-(3,20))
        │   │           │   └── flags: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (3,22)-(3,34))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ ClassNode (location: (3,22)-(3,34))
        │   │           │           ├── flags: newline
        │   │           │           ├── locals: []
        │   │           │           ├── class_keyword_loc: (3,22)-(3,27) = "class"
        │   │           │           ├── constant_path:
        │   │           │           │   @ ConstantReadNode (location: (3,28)-(3,29))
        │   │           │           │   ├── flags: ∅
        │   │           │           │   └── name: :C
        │   │           │           ├── inheritance_operator_loc: ∅
        │   │           │           ├── superclass: ∅
        │   │           │           ├── body: ∅
        │   │           │           ├── end_keyword_loc: (3,31)-(3,34) = "end"
        │   │           │           └── name: :C
        │   │           └── end_keyword_loc: (3,36)-(3,39) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (3,0)-(3,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (3,41)-(3,44) = "end"
        └── @ DefNode (location: (5,0)-(5,45))
            ├── flags: newline
            ├── name: :m
            ├── name_loc: (5,4)-(5,5) = "m"
            ├── receiver: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (5,7)-(5,40))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ SingletonClassNode (location: (5,7)-(5,40))
            │           ├── flags: newline
            │           ├── locals: []
            │           ├── class_keyword_loc: (5,7)-(5,12) = "class"
            │           ├── operator_loc: (5,13)-(5,15) = "<<"
            │           ├── expression:
            │           │   @ SelfNode (location: (5,16)-(5,20))
            │           │   └── flags: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (5,22)-(5,35))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ ModuleNode (location: (5,22)-(5,35))
            │           │           ├── flags: newline
            │           │           ├── locals: []
            │           │           ├── module_keyword_loc: (5,22)-(5,28) = "module"
            │           │           ├── constant_path:
            │           │           │   @ ConstantReadNode (location: (5,29)-(5,30))
            │           │           │   ├── flags: ∅
            │           │           │   └── name: :M
            │           │           ├── body: ∅
            │           │           ├── end_keyword_loc: (5,32)-(5,35) = "end"
            │           │           └── name: :M
            │           └── end_keyword_loc: (5,37)-(5,40) = "end"
            ├── locals: []
            ├── def_keyword_loc: (5,0)-(5,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (5,42)-(5,45) = "end"
prism-1.5.1/snapshots/whitequark/parser_bug_507.txt000066400000000000000000000040721506127434000223500ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,19))
├── flags: ∅
├── locals: [:m]
└── statements:
    @ StatementsNode (location: (1,0)-(1,19))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LocalVariableWriteNode (location: (1,0)-(1,19))
            ├── flags: newline
            ├── name: :m
            ├── depth: 0
            ├── name_loc: (1,0)-(1,1) = "m"
            ├── value:
            │   @ LambdaNode (location: (1,4)-(1,19))
            │   ├── flags: ∅
            │   ├── locals: [:args]
            │   ├── operator_loc: (1,4)-(1,6) = "->"
            │   ├── opening_loc: (1,13)-(1,15) = "do"
            │   ├── closing_loc: (1,16)-(1,19) = "end"
            │   ├── parameters:
            │   │   @ BlockParametersNode (location: (1,7)-(1,12))
            │   │   ├── flags: ∅
            │   │   ├── parameters:
            │   │   │   @ ParametersNode (location: (1,7)-(1,12))
            │   │   │   ├── flags: ∅
            │   │   │   ├── requireds: (length: 0)
            │   │   │   ├── optionals: (length: 0)
            │   │   │   ├── rest:
            │   │   │   │   @ RestParameterNode (location: (1,7)-(1,12))
            │   │   │   │   ├── flags: ∅
            │   │   │   │   ├── name: :args
            │   │   │   │   ├── name_loc: (1,8)-(1,12) = "args"
            │   │   │   │   └── operator_loc: (1,7)-(1,8) = "*"
            │   │   │   ├── posts: (length: 0)
            │   │   │   ├── keywords: (length: 0)
            │   │   │   ├── keyword_rest: ∅
            │   │   │   └── block: ∅
            │   │   ├── locals: (length: 0)
            │   │   ├── opening_loc: ∅
            │   │   └── closing_loc: ∅
            │   └── body: ∅
            └── operator_loc: (1,2)-(1,3) = "="
prism-1.5.1/snapshots/whitequark/parser_bug_518.txt000066400000000000000000000016361506127434000223550ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,3))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ClassNode (location: (1,0)-(2,3))
            ├── flags: newline
            ├── locals: []
            ├── class_keyword_loc: (1,0)-(1,5) = "class"
            ├── constant_path:
            │   @ ConstantReadNode (location: (1,6)-(1,7))
            │   ├── flags: ∅
            │   └── name: :A
            ├── inheritance_operator_loc: (1,8)-(1,9) = "<"
            ├── superclass:
            │   @ ConstantReadNode (location: (1,10)-(1,11))
            │   ├── flags: ∅
            │   └── name: :B
            ├── body: ∅
            ├── end_keyword_loc: (2,0)-(2,3) = "end"
            └── name: :A
prism-1.5.1/snapshots/whitequark/parser_bug_525.txt000066400000000000000000000076721506127434000223610ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,32))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,32))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,32))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :m1
            ├── message_loc: (1,0)-(1,2) = "m1"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,3)-(1,11))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 1)
            │       └── @ KeywordHashNode (location: (1,3)-(1,11))
            │           ├── flags: symbol_keys
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (1,3)-(1,11))
            │                   ├── flags: ∅
            │                   ├── key:
            │                   │   @ SymbolNode (location: (1,3)-(1,5))
            │                   │   ├── flags: static_literal, forced_us_ascii_encoding
            │                   │   ├── opening_loc: (1,3)-(1,4) = ":"
            │                   │   ├── value_loc: (1,4)-(1,5) = "k"
            │                   │   ├── closing_loc: ∅
            │                   │   └── unescaped: "k"
            │                   ├── value:
            │                   │   @ CallNode (location: (1,9)-(1,11))
            │                   │   ├── flags: variable_call, ignore_visibility
            │                   │   ├── receiver: ∅
            │                   │   ├── call_operator_loc: ∅
            │                   │   ├── name: :m2
            │                   │   ├── message_loc: (1,9)-(1,11) = "m2"
            │                   │   ├── opening_loc: ∅
            │                   │   ├── arguments: ∅
            │                   │   ├── closing_loc: ∅
            │                   │   └── block: ∅
            │                   └── operator_loc: (1,6)-(1,8) = "=>"
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,12)-(1,32))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body:
                │   @ StatementsNode (location: (1,16)-(1,27))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ CallNode (location: (1,16)-(1,27))
                │           ├── flags: newline, ignore_visibility
                │           ├── receiver: ∅
                │           ├── call_operator_loc: ∅
                │           ├── name: :m3
                │           ├── message_loc: (1,16)-(1,18) = "m3"
                │           ├── opening_loc: (1,18)-(1,19) = "("
                │           ├── arguments: ∅
                │           ├── closing_loc: (1,19)-(1,20) = ")"
                │           └── block:
                │               @ BlockNode (location: (1,21)-(1,27))
                │               ├── flags: ∅
                │               ├── locals: []
                │               ├── parameters: ∅
                │               ├── body: ∅
                │               ├── opening_loc: (1,21)-(1,23) = "do"
                │               └── closing_loc: (1,24)-(1,27) = "end"
                ├── opening_loc: (1,12)-(1,14) = "do"
                └── closing_loc: (1,29)-(1,32) = "end"
prism-1.5.1/snapshots/whitequark/parser_bug_604.txt000066400000000000000000000061111506127434000223420ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,14))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :m
            ├── message_loc: (1,0)-(1,1) = "m"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,7))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ CallNode (location: (1,2)-(1,7))
            │           ├── flags: ∅
            │           ├── receiver:
            │           │   @ CallNode (location: (1,2)-(1,3))
            │           │   ├── flags: variable_call, ignore_visibility
            │           │   ├── receiver: ∅
            │           │   ├── call_operator_loc: ∅
            │           │   ├── name: :a
            │           │   ├── message_loc: (1,2)-(1,3) = "a"
            │           │   ├── opening_loc: ∅
            │           │   ├── arguments: ∅
            │           │   ├── closing_loc: ∅
            │           │   └── block: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :+
            │           ├── message_loc: (1,4)-(1,5) = "+"
            │           ├── opening_loc: ∅
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,6)-(1,7))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 1)
            │           │       └── @ CallNode (location: (1,6)-(1,7))
            │           │           ├── flags: variable_call, ignore_visibility
            │           │           ├── receiver: ∅
            │           │           ├── call_operator_loc: ∅
            │           │           ├── name: :b
            │           │           ├── message_loc: (1,6)-(1,7) = "b"
            │           │           ├── opening_loc: ∅
            │           │           ├── arguments: ∅
            │           │           ├── closing_loc: ∅
            │           │           └── block: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,8)-(1,14))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (1,8)-(1,10) = "do"
                └── closing_loc: (1,11)-(1,14) = "end"
prism-1.5.1/snapshots/whitequark/parser_bug_640.txt000066400000000000000000000022341506127434000223440ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,6))
            ├── flags: newline, static_literal
            ├── opening_loc: (1,0)-(1,6) = "<<~FOO"
            ├── parts: (length: 2)
            │   ├── @ StringNode (location: (2,0)-(3,0))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (2,0)-(3,0) = "  baz\\\n"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "baz"
            │   └── @ StringNode (location: (3,0)-(4,0))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (3,0)-(4,0) = "  qux\n"
            │       ├── closing_loc: ∅
            │       └── unescaped: "qux\n"
            └── closing_loc: (4,0)-(5,0) = "FOO\n"
prism-1.5.1/snapshots/whitequark/parser_bug_645.txt000066400000000000000000000041171506127434000223530ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LambdaNode (location: (1,0)-(1,14))
            ├── flags: newline
            ├── locals: [:arg]
            ├── operator_loc: (1,0)-(1,2) = "->"
            ├── opening_loc: (1,12)-(1,13) = "{"
            ├── closing_loc: (1,13)-(1,14) = "}"
            ├── parameters:
            │   @ BlockParametersNode (location: (1,3)-(1,11))
            │   ├── flags: ∅
            │   ├── parameters:
            │   │   @ ParametersNode (location: (1,4)-(1,10))
            │   │   ├── flags: ∅
            │   │   ├── requireds: (length: 0)
            │   │   ├── optionals: (length: 1)
            │   │   │   └── @ OptionalParameterNode (location: (1,4)-(1,10))
            │   │   │       ├── flags: ∅
            │   │   │       ├── name: :arg
            │   │   │       ├── name_loc: (1,4)-(1,7) = "arg"
            │   │   │       ├── operator_loc: (1,7)-(1,8) = "="
            │   │   │       └── value:
            │   │   │           @ HashNode (location: (1,8)-(1,10))
            │   │   │           ├── flags: static_literal
            │   │   │           ├── opening_loc: (1,8)-(1,9) = "{"
            │   │   │           ├── elements: (length: 0)
            │   │   │           └── closing_loc: (1,9)-(1,10) = "}"
            │   │   ├── rest: ∅
            │   │   ├── posts: (length: 0)
            │   │   ├── keywords: (length: 0)
            │   │   ├── keyword_rest: ∅
            │   │   └── block: ∅
            │   ├── locals: (length: 0)
            │   ├── opening_loc: (1,3)-(1,4) = "("
            │   └── closing_loc: (1,10)-(1,11) = ")"
            └── body: ∅
prism-1.5.1/snapshots/whitequark/parser_bug_830.txt000066400000000000000000000010451506127434000223440ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ RegularExpressionNode (location: (1,0)-(1,4))
            ├── flags: newline, static_literal, forced_us_ascii_encoding
            ├── opening_loc: (1,0)-(1,1) = "/"
            ├── content_loc: (1,1)-(1,3) = "\\("
            ├── closing_loc: (1,3)-(1,4) = "/"
            └── unescaped: "\\("
prism-1.5.1/snapshots/whitequark/parser_bug_989.txt000066400000000000000000000010211506127434000223550ustar00rootroot00000000000000@ ProgramNode (location: (1,1)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,1)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ StringNode (location: (1,1)-(1,8))
            ├── flags: newline
            ├── opening_loc: (1,1)-(1,8) = "<<-HERE"
            ├── content_loc: (2,0)-(3,0) = "\t\tcontent\n"
            ├── closing_loc: (3,0)-(4,0) = "\tHERE\n"
            └── unescaped: "\t\tcontent\n"
prism-1.5.1/snapshots/whitequark/parser_drops_truncated_parts_of_squiggly_heredoc.txt000066400000000000000000000021231506127434000317050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,7))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,7))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,7) = "<<~HERE"
            ├── parts: (length: 2)
            │   ├── @ EmbeddedStatementsNode (location: (2,2)-(2,5))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (2,2)-(2,4) = "\#{"
            │   │   ├── statements: ∅
            │   │   └── closing_loc: (2,4)-(2,5) = "}"
            │   └── @ StringNode (location: (2,5)-(3,0))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (2,5)-(3,0) = "\n"
            │       ├── closing_loc: ∅
            │       └── unescaped: "\n"
            └── closing_loc: (3,0)-(4,0) = "HERE\n"
prism-1.5.1/snapshots/whitequark/parser_slash_slash_n_escaping_in_literals.txt000066400000000000000000000167541506127434000302710ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(62,2))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(62,2))
    ├── flags: ∅
    └── body: (length: 19)
        ├── @ StringNode (location: (1,0)-(2,2))
        │   ├── flags: newline
        │   ├── opening_loc: (1,0)-(1,1) = "\""
        │   ├── content_loc: (1,1)-(2,1) = "a\\\nb"
        │   ├── closing_loc: (2,1)-(2,2) = "\""
        │   └── unescaped: "ab"
        ├── @ ArrayNode (location: (4,0)-(5,2))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 1)
        │   │   └── @ SymbolNode (location: (4,3)-(5,1))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: ∅
        │   │       ├── value_loc: (4,3)-(5,1) = "a\\\nb"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\nb"
        │   ├── opening_loc: (4,0)-(4,3) = "%I{"
        │   └── closing_loc: (5,1)-(5,2) = "}"
        ├── @ StringNode (location: (7,0)-(8,2))
        │   ├── flags: newline
        │   ├── opening_loc: (7,0)-(7,3) = "%Q{"
        │   ├── content_loc: (7,3)-(8,1) = "a\\\nb"
        │   ├── closing_loc: (8,1)-(8,2) = "}"
        │   └── unescaped: "ab"
        ├── @ ArrayNode (location: (10,0)-(11,2))
        │   ├── flags: newline
        │   ├── elements: (length: 1)
        │   │   └── @ StringNode (location: (10,3)-(11,1))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (10,3)-(11,1) = "a\\\nb"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\nb"
        │   ├── opening_loc: (10,0)-(10,3) = "%W{"
        │   └── closing_loc: (11,1)-(11,2) = "}"
        ├── @ ArrayNode (location: (13,0)-(14,2))
        │   ├── flags: newline, static_literal
        │   ├── elements: (length: 1)
        │   │   └── @ SymbolNode (location: (13,3)-(14,1))
        │   │       ├── flags: static_literal, forced_us_ascii_encoding
        │   │       ├── opening_loc: ∅
        │   │       ├── value_loc: (13,3)-(14,1) = "a\\\nb"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\nb"
        │   ├── opening_loc: (13,0)-(13,3) = "%i{"
        │   └── closing_loc: (14,1)-(14,2) = "}"
        ├── @ StringNode (location: (16,0)-(17,2))
        │   ├── flags: newline
        │   ├── opening_loc: (16,0)-(16,3) = "%q{"
        │   ├── content_loc: (16,3)-(17,1) = "a\\\nb"
        │   ├── closing_loc: (17,1)-(17,2) = "}"
        │   └── unescaped: "a\\\nb"
        ├── @ RegularExpressionNode (location: (19,0)-(20,2))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (19,0)-(19,3) = "%r{"
        │   ├── content_loc: (19,3)-(20,1) = "a\\\nb"
        │   ├── closing_loc: (20,1)-(20,2) = "}"
        │   └── unescaped: "ab"
        ├── @ SymbolNode (location: (22,0)-(23,2))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (22,0)-(22,3) = "%s{"
        │   ├── value_loc: (22,3)-(23,1) = "a\\\nb"
        │   ├── closing_loc: (23,1)-(23,2) = "}"
        │   └── unescaped: "a\\\nb"
        ├── @ ArrayNode (location: (25,0)-(26,2))
        │   ├── flags: newline
        │   ├── elements: (length: 1)
        │   │   └── @ StringNode (location: (25,3)-(26,1))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (25,3)-(26,1) = "a\\\nb"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\nb"
        │   ├── opening_loc: (25,0)-(25,3) = "%w{"
        │   └── closing_loc: (26,1)-(26,2) = "}"
        ├── @ XStringNode (location: (28,0)-(29,2))
        │   ├── flags: newline
        │   ├── opening_loc: (28,0)-(28,3) = "%x{"
        │   ├── content_loc: (28,3)-(29,1) = "a\\\nb"
        │   ├── closing_loc: (29,1)-(29,2) = "}"
        │   └── unescaped: "ab"
        ├── @ StringNode (location: (31,0)-(32,2))
        │   ├── flags: newline
        │   ├── opening_loc: (31,0)-(31,2) = "%{"
        │   ├── content_loc: (31,2)-(32,1) = "a\\\nb"
        │   ├── closing_loc: (32,1)-(32,2) = "}"
        │   └── unescaped: "ab"
        ├── @ StringNode (location: (34,0)-(35,2))
        │   ├── flags: newline
        │   ├── opening_loc: (34,0)-(34,1) = "'"
        │   ├── content_loc: (34,1)-(35,1) = "a\\\nb"
        │   ├── closing_loc: (35,1)-(35,2) = "'"
        │   └── unescaped: "a\\\nb"
        ├── @ RegularExpressionNode (location: (37,0)-(38,2))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (37,0)-(37,1) = "/"
        │   ├── content_loc: (37,1)-(38,1) = "a\\\nb"
        │   ├── closing_loc: (38,1)-(38,2) = "/"
        │   └── unescaped: "ab"
        ├── @ SymbolNode (location: (40,0)-(41,2))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (40,0)-(40,2) = ":\""
        │   ├── value_loc: (40,2)-(41,1) = "a\\\nb"
        │   ├── closing_loc: (41,1)-(41,2) = "\""
        │   └── unescaped: "ab"
        ├── @ SymbolNode (location: (43,0)-(44,2))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (43,0)-(43,2) = ":'"
        │   ├── value_loc: (43,2)-(44,1) = "a\\\nb"
        │   ├── closing_loc: (44,1)-(44,2) = "'"
        │   └── unescaped: "a\\\nb"
        ├── @ StringNode (location: (46,0)-(46,9))
        │   ├── flags: newline
        │   ├── opening_loc: (46,0)-(46,9) = "<<-\"HERE\""
        │   ├── content_loc: (47,0)-(49,0) = "a\\\nb\n"
        │   ├── closing_loc: (49,0)-(50,0) = "HERE\n"
        │   └── unescaped: "ab\n"
        ├── @ StringNode (location: (51,0)-(51,9))
        │   ├── flags: newline
        │   ├── opening_loc: (51,0)-(51,9) = "<<-'HERE'"
        │   ├── content_loc: (52,0)-(54,0) = "a\\\nb\n"
        │   ├── closing_loc: (54,0)-(55,0) = "HERE\n"
        │   └── unescaped: "a\\\nb\n"
        ├── @ XStringNode (location: (56,0)-(56,9))
        │   ├── flags: newline
        │   ├── opening_loc: (56,0)-(56,9) = "<<-`HERE`"
        │   ├── content_loc: (57,0)-(59,0) = "a\\\nb\n"
        │   ├── closing_loc: (59,0)-(60,0) = "HERE\n"
        │   └── unescaped: "ab\n"
        └── @ XStringNode (location: (61,0)-(62,2))
            ├── flags: newline
            ├── opening_loc: (61,0)-(61,1) = "`"
            ├── content_loc: (61,1)-(62,1) = "a\\\nb"
            ├── closing_loc: (62,1)-(62,2) = "`"
            └── unescaped: "ab"
prism-1.5.1/snapshots/whitequark/pattern_matching__FILE__LINE_literals.txt000066400000000000000000000072001506127434000267520ustar00rootroot00000000000000@ ProgramNode (location: (1,8)-(3,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,8)-(3,11))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,8)-(3,11))
            ├── flags: newline
            ├── predicate:
            │   @ ArrayNode (location: (1,13)-(1,51))
            │   ├── flags: ∅
            │   ├── elements: (length: 3)
            │   │   ├── @ SourceFileNode (location: (1,14)-(1,22))
            │   │   │   ├── flags: ∅
            │   │   │   └── filepath: "whitequark/pattern_matching__FILE__LINE_literals.txt"
            │   │   ├── @ CallNode (location: (1,24)-(1,36))
            │   │   │   ├── flags: ∅
            │   │   │   ├── receiver:
            │   │   │   │   @ SourceLineNode (location: (1,24)-(1,32))
            │   │   │   │   └── flags: static_literal
            │   │   │   ├── call_operator_loc: ∅
            │   │   │   ├── name: :+
            │   │   │   ├── message_loc: (1,33)-(1,34) = "+"
            │   │   │   ├── opening_loc: ∅
            │   │   │   ├── arguments:
            │   │   │   │   @ ArgumentsNode (location: (1,35)-(1,36))
            │   │   │   │   ├── flags: ∅
            │   │   │   │   └── arguments: (length: 1)
            │   │   │   │       └── @ IntegerNode (location: (1,35)-(1,36))
            │   │   │   │           ├── flags: static_literal, decimal
            │   │   │   │           └── value: 1
            │   │   │   ├── closing_loc: ∅
            │   │   │   └── block: ∅
            │   │   └── @ SourceEncodingNode (location: (1,38)-(1,50))
            │   │       └── flags: static_literal
            │   ├── opening_loc: (1,13)-(1,14) = "["
            │   └── closing_loc: (1,50)-(1,51) = "]"
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (2,10)-(2,47))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ArrayPatternNode (location: (2,13)-(2,47))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── requireds: (length: 3)
            │       │   │   ├── @ SourceFileNode (location: (2,14)-(2,22))
            │       │   │   │   ├── flags: ∅
            │       │   │   │   └── filepath: "whitequark/pattern_matching__FILE__LINE_literals.txt"
            │       │   │   ├── @ SourceLineNode (location: (2,24)-(2,32))
            │       │   │   │   └── flags: static_literal
            │       │   │   └── @ SourceEncodingNode (location: (2,34)-(2,46))
            │       │   │       └── flags: static_literal
            │       │   ├── rest: ∅
            │       │   ├── posts: (length: 0)
            │       │   ├── opening_loc: (2,13)-(2,14) = "["
            │       │   └── closing_loc: (2,46)-(2,47) = "]"
            │       ├── statements: ∅
            │       ├── in_loc: (2,10)-(2,12) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,8)-(1,12) = "case"
            └── end_keyword_loc: (3,8)-(3,11) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_blank_else.txt000066400000000000000000000034631506127434000253350ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,26))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,26))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(1,26))
            ├── flags: newline
            ├── predicate:
            │   @ IntegerNode (location: (1,5)-(1,6))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (1,8)-(1,15))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ IntegerNode (location: (1,11)-(1,12))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 2
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,14)-(1,15))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ IntegerNode (location: (1,14)-(1,15))
            │       │           ├── flags: newline, static_literal, decimal
            │       │           └── value: 3
            │       ├── in_loc: (1,8)-(1,10) = "in"
            │       └── then_loc: ∅
            ├── else_clause:
            │   @ ElseNode (location: (1,17)-(1,26))
            │   ├── flags: ∅
            │   ├── else_keyword_loc: (1,17)-(1,21) = "else"
            │   ├── statements: ∅
            │   └── end_keyword_loc: (1,23)-(1,26) = "end"
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,23)-(1,26) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_const_pattern.txt000066400000000000000000000410361506127434000261170ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(11,33))
├── flags: ∅
├── locals: [:x]
└── statements:
    @ StatementsNode (location: (1,0)-(11,33))
    ├── flags: ∅
    └── body: (length: 6)
        ├── @ CaseMatchNode (location: (1,0)-(1,31))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (1,5)-(1,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,5)-(1,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (1,10)-(1,26))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (1,13)-(1,16))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (1,13)-(1,14))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :A
        │   │       │   ├── requireds: (length: 0)
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (1,14)-(1,15) = "("
        │   │       │   └── closing_loc: (1,15)-(1,16) = ")"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (1,22)-(1,26))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (1,22)-(1,26))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (1,10)-(1,12) = "in"
        │   │       └── then_loc: (1,17)-(1,21) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (1,28)-(1,31) = "end"
        ├── @ CaseMatchNode (location: (3,0)-(3,35))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (3,5)-(3,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,5)-(3,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3,10)-(3,30))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (3,13)-(3,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (3,13)-(3,14))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :A
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ IntegerNode (location: (3,15)-(3,16))
        │   │       │   │   │   ├── flags: static_literal, decimal
        │   │       │   │   │   └── value: 1
        │   │       │   │   └── @ IntegerNode (location: (3,18)-(3,19))
        │   │       │   │       ├── flags: static_literal, decimal
        │   │       │   │       └── value: 2
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (3,14)-(3,15) = "("
        │   │       │   └── closing_loc: (3,19)-(3,20) = ")"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (3,26)-(3,30))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (3,26)-(3,30))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (3,10)-(3,12) = "in"
        │   │       └── then_loc: (3,21)-(3,25) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (3,0)-(3,4) = "case"
        │   └── end_keyword_loc: (3,32)-(3,35) = "end"
        ├── @ CaseMatchNode (location: (5,0)-(5,33))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (5,5)-(5,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (5,5)-(5,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (5,10)-(5,28))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (5,13)-(5,18))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (5,13)-(5,14))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :A
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (5,15)-(5,17))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (5,15)-(5,17))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (5,15)-(5,16) = "x"
        │   │       │   │       │   ├── closing_loc: (5,16)-(5,17) = ":"
        │   │       │   │       │   └── unescaped: "x"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ ImplicitNode (location: (5,15)-(5,16))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── value:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (5,15)-(5,16))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :x
        │   │       │   │       │       └── depth: 0
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: (5,14)-(5,15) = "("
        │   │       │   └── closing_loc: (5,17)-(5,18) = ")"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (5,24)-(5,28))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (5,24)-(5,28))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (5,10)-(5,12) = "in"
        │   │       └── then_loc: (5,19)-(5,23) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (5,0)-(5,4) = "case"
        │   └── end_keyword_loc: (5,30)-(5,33) = "end"
        ├── @ CaseMatchNode (location: (7,0)-(7,35))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (7,5)-(7,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (7,5)-(7,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (7,10)-(7,30))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (7,13)-(7,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (7,13)-(7,14))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :A
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ IntegerNode (location: (7,15)-(7,16))
        │   │       │   │   │   ├── flags: static_literal, decimal
        │   │       │   │   │   └── value: 1
        │   │       │   │   └── @ IntegerNode (location: (7,18)-(7,19))
        │   │       │   │       ├── flags: static_literal, decimal
        │   │       │   │       └── value: 2
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (7,14)-(7,15) = "["
        │   │       │   └── closing_loc: (7,19)-(7,20) = "]"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (7,26)-(7,30))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (7,26)-(7,30))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (7,10)-(7,12) = "in"
        │   │       └── then_loc: (7,21)-(7,25) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (7,0)-(7,4) = "case"
        │   └── end_keyword_loc: (7,32)-(7,35) = "end"
        ├── @ CaseMatchNode (location: (9,0)-(9,31))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (9,5)-(9,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (9,5)-(9,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (9,10)-(9,26))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (9,13)-(9,16))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant:
        │   │       │   │   @ ConstantReadNode (location: (9,13)-(9,14))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :A
        │   │       │   ├── requireds: (length: 0)
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (9,14)-(9,15) = "["
        │   │       │   └── closing_loc: (9,15)-(9,16) = "]"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (9,22)-(9,26))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (9,22)-(9,26))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (9,10)-(9,12) = "in"
        │   │       └── then_loc: (9,17)-(9,21) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (9,0)-(9,4) = "case"
        │   └── end_keyword_loc: (9,28)-(9,31) = "end"
        └── @ CaseMatchNode (location: (11,0)-(11,33))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (11,5)-(11,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (11,5)-(11,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (11,10)-(11,28))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ HashPatternNode (location: (11,13)-(11,18))
            │       │   ├── flags: ∅
            │       │   ├── constant:
            │       │   │   @ ConstantReadNode (location: (11,13)-(11,14))
            │       │   │   ├── flags: ∅
            │       │   │   └── name: :A
            │       │   ├── elements: (length: 1)
            │       │   │   └── @ AssocNode (location: (11,15)-(11,17))
            │       │   │       ├── flags: ∅
            │       │   │       ├── key:
            │       │   │       │   @ SymbolNode (location: (11,15)-(11,17))
            │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │       │   ├── opening_loc: ∅
            │       │   │       │   ├── value_loc: (11,15)-(11,16) = "x"
            │       │   │       │   ├── closing_loc: (11,16)-(11,17) = ":"
            │       │   │       │   └── unescaped: "x"
            │       │   │       ├── value:
            │       │   │       │   @ ImplicitNode (location: (11,15)-(11,16))
            │       │   │       │   ├── flags: ∅
            │       │   │       │   └── value:
            │       │   │       │       @ LocalVariableTargetNode (location: (11,15)-(11,16))
            │       │   │       │       ├── flags: ∅
            │       │   │       │       ├── name: :x
            │       │   │       │       └── depth: 0
            │       │   │       └── operator_loc: ∅
            │       │   ├── rest: ∅
            │       │   ├── opening_loc: (11,14)-(11,15) = "["
            │       │   └── closing_loc: (11,17)-(11,18) = "]"
            │       ├── statements:
            │       │   @ StatementsNode (location: (11,24)-(11,28))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ TrueNode (location: (11,24)-(11,28))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (11,10)-(11,12) = "in"
            │       └── then_loc: (11,19)-(11,23) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (11,0)-(11,4) = "case"
            └── end_keyword_loc: (11,30)-(11,33) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_constants.txt000066400000000000000000000132731506127434000252520ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,32))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,32))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ CaseMatchNode (location: (1,0)-(1,31))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (1,5)-(1,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,5)-(1,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (1,10)-(1,26))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ConstantPathNode (location: (1,13)-(1,16))
        │   │       │   ├── flags: ∅
        │   │       │   ├── parent: ∅
        │   │       │   ├── name: :A
        │   │       │   ├── delimiter_loc: (1,13)-(1,15) = "::"
        │   │       │   └── name_loc: (1,15)-(1,16) = "A"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (1,22)-(1,26))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (1,22)-(1,26))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (1,10)-(1,12) = "in"
        │   │       └── then_loc: (1,17)-(1,21) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (1,28)-(1,31) = "end"
        ├── @ CaseMatchNode (location: (3,0)-(3,29))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (3,5)-(3,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,5)-(3,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3,10)-(3,24))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ConstantReadNode (location: (3,13)-(3,14))
        │   │       │   ├── flags: ∅
        │   │       │   └── name: :A
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (3,20)-(3,24))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (3,20)-(3,24))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (3,10)-(3,12) = "in"
        │   │       └── then_loc: (3,15)-(3,19) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (3,0)-(3,4) = "case"
        │   └── end_keyword_loc: (3,26)-(3,29) = "end"
        └── @ CaseMatchNode (location: (5,0)-(5,32))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (5,5)-(5,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (5,5)-(5,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (5,10)-(5,27))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ConstantPathNode (location: (5,13)-(5,17))
            │       │   ├── flags: ∅
            │       │   ├── parent:
            │       │   │   @ ConstantReadNode (location: (5,13)-(5,14))
            │       │   │   ├── flags: ∅
            │       │   │   └── name: :A
            │       │   ├── name: :B
            │       │   ├── delimiter_loc: (5,14)-(5,16) = "::"
            │       │   └── name_loc: (5,16)-(5,17) = "B"
            │       ├── statements:
            │       │   @ StatementsNode (location: (5,23)-(5,27))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ TrueNode (location: (5,23)-(5,27))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (5,10)-(5,12) = "in"
            │       └── then_loc: (5,18)-(5,22) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (5,0)-(5,4) = "case"
            └── end_keyword_loc: (5,29)-(5,32) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_else.txt000066400000000000000000000042461506127434000241660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,29))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,29))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(1,29))
            ├── flags: newline
            ├── predicate:
            │   @ IntegerNode (location: (1,5)-(1,6))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (1,8)-(1,15))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ IntegerNode (location: (1,11)-(1,12))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 2
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,14)-(1,15))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ IntegerNode (location: (1,14)-(1,15))
            │       │           ├── flags: newline, static_literal, decimal
            │       │           └── value: 3
            │       ├── in_loc: (1,8)-(1,10) = "in"
            │       └── then_loc: ∅
            ├── else_clause:
            │   @ ElseNode (location: (1,17)-(1,29))
            │   ├── flags: ∅
            │   ├── else_keyword_loc: (1,17)-(1,21) = "else"
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,23)-(1,24))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ IntegerNode (location: (1,23)-(1,24))
            │   │           ├── flags: newline, static_literal, decimal
            │   │           └── value: 4
            │   └── end_keyword_loc: (1,26)-(1,29) = "end"
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,26)-(1,29) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_explicit_array_match.txt000066400000000000000000000660201506127434000274270ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(19,30))
├── flags: ∅
├── locals: [:x, :y, :z]
└── statements:
    @ StatementsNode (location: (1,0)-(19,30))
    ├── flags: ∅
    └── body: (length: 10)
        ├── @ CaseMatchNode (location: (1,0)-(1,34))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (1,5)-(1,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,5)-(1,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (1,10)-(1,29))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (1,13)-(1,19))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 0)
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (1,14)-(1,15))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (1,14)-(1,15) = "*"
        │   │       │   │   └── expression: ∅
        │   │       │   ├── posts: (length: 1)
        │   │       │   │   └── @ LocalVariableTargetNode (location: (1,17)-(1,18))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :x
        │   │       │   │       └── depth: 0
        │   │       │   ├── opening_loc: (1,13)-(1,14) = "["
        │   │       │   └── closing_loc: (1,18)-(1,19) = "]"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (1,25)-(1,29))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (1,25)-(1,29))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (1,10)-(1,12) = "in"
        │   │       └── then_loc: (1,20)-(1,24) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (1,31)-(1,34) = "end"
        ├── @ CaseMatchNode (location: (3,0)-(3,35))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (3,5)-(3,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,5)-(3,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3,10)-(3,30))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (3,13)-(3,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 0)
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (3,14)-(3,16))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (3,14)-(3,15) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (3,15)-(3,16))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :x
        │   │       │   │       └── depth: 0
        │   │       │   ├── posts: (length: 1)
        │   │       │   │   └── @ LocalVariableTargetNode (location: (3,18)-(3,19))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :y
        │   │       │   │       └── depth: 0
        │   │       │   ├── opening_loc: (3,13)-(3,14) = "["
        │   │       │   └── closing_loc: (3,19)-(3,20) = "]"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (3,26)-(3,30))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (3,26)-(3,30))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (3,10)-(3,12) = "in"
        │   │       └── then_loc: (3,21)-(3,25) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (3,0)-(3,4) = "case"
        │   └── end_keyword_loc: (3,32)-(3,35) = "end"
        ├── @ CaseMatchNode (location: (5,0)-(5,37))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (5,5)-(5,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (5,5)-(5,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (5,10)-(5,32))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (5,13)-(5,22))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ LocalVariableTargetNode (location: (5,14)-(5,15))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :x
        │   │       │   │       └── depth: 0
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (5,17)-(5,18))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (5,17)-(5,18) = "*"
        │   │       │   │   └── expression: ∅
        │   │       │   ├── posts: (length: 1)
        │   │       │   │   └── @ LocalVariableTargetNode (location: (5,20)-(5,21))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :y
        │   │       │   │       └── depth: 0
        │   │       │   ├── opening_loc: (5,13)-(5,14) = "["
        │   │       │   └── closing_loc: (5,21)-(5,22) = "]"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (5,28)-(5,32))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (5,28)-(5,32))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (5,10)-(5,12) = "in"
        │   │       └── then_loc: (5,23)-(5,27) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (5,0)-(5,4) = "case"
        │   └── end_keyword_loc: (5,34)-(5,37) = "end"
        ├── @ CaseMatchNode (location: (7,0)-(7,38))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (7,5)-(7,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (7,5)-(7,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (7,10)-(7,33))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (7,13)-(7,23))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ LocalVariableTargetNode (location: (7,14)-(7,15))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :x
        │   │       │   │       └── depth: 0
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (7,17)-(7,19))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (7,17)-(7,18) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (7,18)-(7,19))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :y
        │   │       │   │       └── depth: 0
        │   │       │   ├── posts: (length: 1)
        │   │       │   │   └── @ LocalVariableTargetNode (location: (7,21)-(7,22))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :z
        │   │       │   │       └── depth: 0
        │   │       │   ├── opening_loc: (7,13)-(7,14) = "["
        │   │       │   └── closing_loc: (7,22)-(7,23) = "]"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (7,29)-(7,33))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (7,29)-(7,33))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (7,10)-(7,12) = "in"
        │   │       └── then_loc: (7,24)-(7,28) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (7,0)-(7,4) = "case"
        │   └── end_keyword_loc: (7,35)-(7,38) = "end"
        ├── @ CaseMatchNode (location: (9,0)-(9,37))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (9,5)-(9,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (9,5)-(9,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (9,10)-(9,32))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (9,13)-(9,22))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ LocalVariableTargetNode (location: (9,14)-(9,15))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── name: :x
        │   │       │   │   │   └── depth: 0
        │   │       │   │   └── @ LocalVariableTargetNode (location: (9,17)-(9,18))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :y
        │   │       │   │       └── depth: 0
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (9,20)-(9,21))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (9,20)-(9,21) = "*"
        │   │       │   │   └── expression: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (9,13)-(9,14) = "["
        │   │       │   └── closing_loc: (9,21)-(9,22) = "]"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (9,28)-(9,32))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (9,28)-(9,32))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (9,10)-(9,12) = "in"
        │   │       └── then_loc: (9,23)-(9,27) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (9,0)-(9,4) = "case"
        │   └── end_keyword_loc: (9,34)-(9,37) = "end"
        ├── @ CaseMatchNode (location: (11,0)-(11,38))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (11,5)-(11,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (11,5)-(11,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (11,10)-(11,33))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (11,13)-(11,23))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ LocalVariableTargetNode (location: (11,14)-(11,15))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── name: :x
        │   │       │   │   │   └── depth: 0
        │   │       │   │   └── @ LocalVariableTargetNode (location: (11,17)-(11,18))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :y
        │   │       │   │       └── depth: 0
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (11,20)-(11,22))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (11,20)-(11,21) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (11,21)-(11,22))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :z
        │   │       │   │       └── depth: 0
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (11,13)-(11,14) = "["
        │   │       │   └── closing_loc: (11,22)-(11,23) = "]"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (11,29)-(11,33))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (11,29)-(11,33))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (11,10)-(11,12) = "in"
        │   │       └── then_loc: (11,24)-(11,28) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (11,0)-(11,4) = "case"
        │   └── end_keyword_loc: (11,35)-(11,38) = "end"
        ├── @ CaseMatchNode (location: (13,0)-(13,35))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (13,5)-(13,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (13,5)-(13,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (13,10)-(13,30))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (13,13)-(13,20))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ LocalVariableTargetNode (location: (13,14)-(13,15))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── name: :x
        │   │       │   │   │   └── depth: 0
        │   │       │   │   └── @ LocalVariableTargetNode (location: (13,17)-(13,18))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :y
        │   │       │   │       └── depth: 0
        │   │       │   ├── rest:
        │   │       │   │   @ ImplicitRestNode (location: (13,18)-(13,19))
        │   │       │   │   └── flags: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (13,13)-(13,14) = "["
        │   │       │   └── closing_loc: (13,19)-(13,20) = "]"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (13,26)-(13,30))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (13,26)-(13,30))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (13,10)-(13,12) = "in"
        │   │       └── then_loc: (13,21)-(13,25) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (13,0)-(13,4) = "case"
        │   └── end_keyword_loc: (13,32)-(13,35) = "end"
        ├── @ CaseMatchNode (location: (15,0)-(15,34))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (15,5)-(15,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (15,5)-(15,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (15,10)-(15,29))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (15,13)-(15,19))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ LocalVariableTargetNode (location: (15,14)-(15,15))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── name: :x
        │   │       │   │   │   └── depth: 0
        │   │       │   │   └── @ LocalVariableTargetNode (location: (15,17)-(15,18))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :y
        │   │       │   │       └── depth: 0
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (15,13)-(15,14) = "["
        │   │       │   └── closing_loc: (15,18)-(15,19) = "]"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (15,25)-(15,29))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (15,25)-(15,29))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (15,10)-(15,12) = "in"
        │   │       └── then_loc: (15,20)-(15,24) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (15,0)-(15,4) = "case"
        │   └── end_keyword_loc: (15,31)-(15,34) = "end"
        ├── @ CaseMatchNode (location: (17,0)-(17,31))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (17,5)-(17,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (17,5)-(17,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (17,10)-(17,26))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (17,13)-(17,17))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ LocalVariableTargetNode (location: (17,14)-(17,15))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :x
        │   │       │   │       └── depth: 0
        │   │       │   ├── rest:
        │   │       │   │   @ ImplicitRestNode (location: (17,15)-(17,16))
        │   │       │   │   └── flags: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: (17,13)-(17,14) = "["
        │   │       │   └── closing_loc: (17,16)-(17,17) = "]"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (17,23)-(17,26))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ NilNode (location: (17,23)-(17,26))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (17,10)-(17,12) = "in"
        │   │       └── then_loc: (17,18)-(17,22) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (17,0)-(17,4) = "case"
        │   └── end_keyword_loc: (17,28)-(17,31) = "end"
        └── @ CaseMatchNode (location: (19,0)-(19,30))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (19,5)-(19,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (19,5)-(19,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (19,10)-(19,25))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ArrayPatternNode (location: (19,13)-(19,16))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── requireds: (length: 1)
            │       │   │   └── @ LocalVariableTargetNode (location: (19,14)-(19,15))
            │       │   │       ├── flags: ∅
            │       │   │       ├── name: :x
            │       │   │       └── depth: 0
            │       │   ├── rest: ∅
            │       │   ├── posts: (length: 0)
            │       │   ├── opening_loc: (19,13)-(19,14) = "["
            │       │   └── closing_loc: (19,15)-(19,16) = "]"
            │       ├── statements:
            │       │   @ StatementsNode (location: (19,22)-(19,25))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ NilNode (location: (19,22)-(19,25))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (19,10)-(19,12) = "in"
            │       └── then_loc: (19,17)-(19,21) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (19,0)-(19,4) = "case"
            └── end_keyword_loc: (19,27)-(19,30) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_expr_in_paren.txt000066400000000000000000000042121506127434000260600ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,31))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,31))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(1,31))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (1,5)-(1,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,5)-(1,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (1,10)-(1,26))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ParenthesesNode (location: (1,13)-(1,16))
            │       │   ├── flags: ∅
            │       │   ├── body:
            │       │   │   @ IntegerNode (location: (1,14)-(1,15))
            │       │   │   ├── flags: static_literal, decimal
            │       │   │   └── value: 1
            │       │   ├── opening_loc: (1,13)-(1,14) = "("
            │       │   └── closing_loc: (1,15)-(1,16) = ")"
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,22)-(1,26))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ TrueNode (location: (1,22)-(1,26))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (1,10)-(1,12) = "in"
            │       └── then_loc: (1,17)-(1,21) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,28)-(1,31) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_hash.txt000066400000000000000000001473251506127434000241670ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(48,30))
├── flags: ∅
├── locals: [:b, :c, :a, :_a]
└── statements:
    @ StatementsNode (location: (1,0)-(48,30))
    ├── flags: ∅
    └── body: (length: 15)
        ├── @ CaseMatchNode (location: (1,0)-(4,11))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (1,5)-(1,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,5)-(1,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (2,8)-(3,13))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (2,11)-(2,22))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ AssocNode (location: (2,11)-(2,18))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── key:
        │   │       │   │   │   │   @ SymbolNode (location: (2,11)-(2,13))
        │   │       │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   │   ├── value_loc: (2,11)-(2,12) = "a"
        │   │       │   │   │   │   ├── closing_loc: (2,12)-(2,13) = ":"
        │   │       │   │   │   │   └── unescaped: "a"
        │   │       │   │   │   ├── value:
        │   │       │   │   │   │   @ HashPatternNode (location: (2,14)-(2,18))
        │   │       │   │   │   │   ├── flags: ∅
        │   │       │   │   │   │   ├── constant: ∅
        │   │       │   │   │   │   ├── elements: (length: 1)
        │   │       │   │   │   │   │   └── @ AssocNode (location: (2,15)-(2,17))
        │   │       │   │   │   │   │       ├── flags: ∅
        │   │       │   │   │   │   │       ├── key:
        │   │       │   │   │   │   │       │   @ SymbolNode (location: (2,15)-(2,17))
        │   │       │   │   │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   │   │       │   ├── opening_loc: ∅
        │   │       │   │   │   │   │       │   ├── value_loc: (2,15)-(2,16) = "b"
        │   │       │   │   │   │   │       │   ├── closing_loc: (2,16)-(2,17) = ":"
        │   │       │   │   │   │   │       │   └── unescaped: "b"
        │   │       │   │   │   │   │       ├── value:
        │   │       │   │   │   │   │       │   @ ImplicitNode (location: (2,15)-(2,16))
        │   │       │   │   │   │   │       │   ├── flags: ∅
        │   │       │   │   │   │   │       │   └── value:
        │   │       │   │   │   │   │       │       @ LocalVariableTargetNode (location: (2,15)-(2,16))
        │   │       │   │   │   │   │       │       ├── flags: ∅
        │   │       │   │   │   │   │       │       ├── name: :b
        │   │       │   │   │   │   │       │       └── depth: 0
        │   │       │   │   │   │   │       └── operator_loc: ∅
        │   │       │   │   │   │   ├── rest: ∅
        │   │       │   │   │   │   ├── opening_loc: (2,14)-(2,15) = "{"
        │   │       │   │   │   │   └── closing_loc: (2,17)-(2,18) = "}"
        │   │       │   │   │   └── operator_loc: ∅
        │   │       │   │   └── @ AssocNode (location: (2,20)-(2,22))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (2,20)-(2,22))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (2,20)-(2,21) = "c"
        │   │       │   │       │   ├── closing_loc: (2,21)-(2,22) = ":"
        │   │       │   │       │   └── unescaped: "c"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ ImplicitNode (location: (2,20)-(2,21))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── value:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (2,20)-(2,21))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :c
        │   │       │   │       │       └── depth: 0
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (3,10)-(3,13))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (3,10)-(3,13))
        │   │       │           ├── flags: newline, ignore_visibility
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── name: :p
        │   │       │           ├── message_loc: (3,10)-(3,11) = "p"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments:
        │   │       │           │   @ ArgumentsNode (location: (3,12)-(3,13))
        │   │       │           │   ├── flags: ∅
        │   │       │           │   └── arguments: (length: 1)
        │   │       │           │       └── @ LocalVariableReadNode (location: (3,12)-(3,13))
        │   │       │           │           ├── flags: ∅
        │   │       │           │           ├── name: :c
        │   │       │           │           └── depth: 0
        │   │       │           ├── closing_loc: ∅
        │   │       │           └── block: ∅
        │   │       ├── in_loc: (2,8)-(2,10) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (4,8)-(4,11) = "end"
        ├── @ CaseMatchNode (location: (6,0)-(10,11))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (6,5)-(6,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (6,5)-(6,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (7,8)-(9,15))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (7,11)-(8,9))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (7,12)-(7,19))
        │   │       │   │       ├── flags: static_literal
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (7,12)-(7,16))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (7,12)-(7,15) = "Foo"
        │   │       │   │       │   ├── closing_loc: (7,15)-(7,16) = ":"
        │   │       │   │       │   └── unescaped: "Foo"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ IntegerNode (location: (7,17)-(7,19))
        │   │       │   │       │   ├── flags: static_literal, decimal
        │   │       │   │       │   └── value: 42
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: (7,11)-(7,12) = "{"
        │   │       │   └── closing_loc: (8,8)-(8,9) = "}"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (9,10)-(9,15))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ FalseNode (location: (9,10)-(9,15))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (7,8)-(7,10) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (6,0)-(6,4) = "case"
        │   └── end_keyword_loc: (10,8)-(10,11) = "end"
        ├── @ CaseMatchNode (location: (12,0)-(16,11))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (12,5)-(12,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (12,5)-(12,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (13,8)-(15,15))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (13,11)-(14,16))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (13,12)-(14,15))
        │   │       │   │       ├── flags: static_literal
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (13,12)-(13,14))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (13,12)-(13,13) = "a"
        │   │       │   │       │   ├── closing_loc: (13,13)-(13,14) = ":"
        │   │       │   │       │   └── unescaped: "a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ IntegerNode (location: (14,14)-(14,15))
        │   │       │   │       │   ├── flags: static_literal, decimal
        │   │       │   │       │   └── value: 2
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: (13,11)-(13,12) = "{"
        │   │       │   └── closing_loc: (14,15)-(14,16) = "}"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (15,10)-(15,15))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ FalseNode (location: (15,10)-(15,15))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (13,8)-(13,10) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (12,0)-(12,4) = "case"
        │   └── end_keyword_loc: (16,8)-(16,11) = "end"
        ├── @ CaseMatchNode (location: (18,0)-(22,11))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (18,5)-(18,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (18,5)-(18,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (19,8)-(21,14))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (19,11)-(20,9))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (19,12)-(19,14))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (19,12)-(19,14))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (19,12)-(19,13) = "a"
        │   │       │   │       │   ├── closing_loc: (19,13)-(19,14) = ":"
        │   │       │   │       │   └── unescaped: "a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ ImplicitNode (location: (19,12)-(19,13))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── value:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (19,12)-(19,13))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :a
        │   │       │   │       │       └── depth: 0
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: (19,11)-(19,12) = "{"
        │   │       │   └── closing_loc: (20,8)-(20,9) = "}"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (21,10)-(21,14))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (21,10)-(21,14))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (19,8)-(19,10) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (18,0)-(18,4) = "case"
        │   └── end_keyword_loc: (22,8)-(22,11) = "end"
        ├── @ CaseMatchNode (location: (24,0)-(28,11))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (24,5)-(24,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (24,5)-(24,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (25,8)-(27,15))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (25,11)-(26,9))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (25,12)-(25,16))
        │   │       │   │       ├── flags: static_literal
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (25,12)-(25,14))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (25,12)-(25,13) = "a"
        │   │       │   │       │   ├── closing_loc: (25,13)-(25,14) = ":"
        │   │       │   │       │   └── unescaped: "a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ IntegerNode (location: (25,15)-(25,16))
        │   │       │   │       │   ├── flags: static_literal, decimal
        │   │       │   │       │   └── value: 1
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: (25,11)-(25,12) = "{"
        │   │       │   └── closing_loc: (26,8)-(26,9) = "}"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (27,10)-(27,15))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ FalseNode (location: (27,10)-(27,15))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (25,8)-(25,10) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (24,0)-(24,4) = "case"
        │   └── end_keyword_loc: (28,8)-(28,11) = "end"
        ├── @ CaseMatchNode (location: (30,0)-(30,30))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (30,5)-(30,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (30,5)-(30,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (30,10)-(30,25))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (30,13)-(30,15))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 0)
        │   │       │   ├── rest:
        │   │       │   │   @ AssocSplatNode (location: (30,13)-(30,15))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── value: ∅
        │   │       │   │   └── operator_loc: (30,13)-(30,15) = "**"
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (30,21)-(30,25))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (30,21)-(30,25))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (30,10)-(30,12) = "in"
        │   │       └── then_loc: (30,16)-(30,20) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (30,0)-(30,4) = "case"
        │   └── end_keyword_loc: (30,27)-(30,30) = "end"
        ├── @ CaseMatchNode (location: (32,0)-(32,31))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (32,5)-(32,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (32,5)-(32,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (32,10)-(32,26))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (32,13)-(32,16))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 0)
        │   │       │   ├── rest:
        │   │       │   │   @ AssocSplatNode (location: (32,13)-(32,16))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── value:
        │   │       │   │   │   @ LocalVariableTargetNode (location: (32,15)-(32,16))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── name: :a
        │   │       │   │   │   └── depth: 0
        │   │       │   │   └── operator_loc: (32,13)-(32,15) = "**"
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (32,22)-(32,26))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (32,22)-(32,26))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (32,10)-(32,12) = "in"
        │   │       └── then_loc: (32,17)-(32,21) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (32,0)-(32,4) = "case"
        │   └── end_keyword_loc: (32,28)-(32,31) = "end"
        ├── @ CaseMatchNode (location: (34,0)-(34,32))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (34,5)-(34,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (34,5)-(34,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (34,10)-(34,27))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (34,13)-(34,17))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (34,13)-(34,17))
        │   │       │   │       ├── flags: static_literal
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (34,13)-(34,15))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (34,13)-(34,14) = "a"
        │   │       │   │       │   ├── closing_loc: (34,14)-(34,15) = ":"
        │   │       │   │       │   └── unescaped: "a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ IntegerNode (location: (34,16)-(34,17))
        │   │       │   │       │   ├── flags: static_literal, decimal
        │   │       │   │       │   └── value: 1
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (34,23)-(34,27))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (34,23)-(34,27))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (34,10)-(34,12) = "in"
        │   │       └── then_loc: (34,18)-(34,22) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (34,0)-(34,4) = "case"
        │   └── end_keyword_loc: (34,29)-(34,32) = "end"
        ├── @ CaseMatchNode (location: (36,0)-(36,41))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (36,5)-(36,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (36,5)-(36,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (36,10)-(36,36))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (36,13)-(36,26))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ AssocNode (location: (36,13)-(36,17))
        │   │       │   │   │   ├── flags: static_literal
        │   │       │   │   │   ├── key:
        │   │       │   │   │   │   @ SymbolNode (location: (36,13)-(36,15))
        │   │       │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   │   ├── value_loc: (36,13)-(36,14) = "a"
        │   │       │   │   │   │   ├── closing_loc: (36,14)-(36,15) = ":"
        │   │       │   │   │   │   └── unescaped: "a"
        │   │       │   │   │   ├── value:
        │   │       │   │   │   │   @ IntegerNode (location: (36,16)-(36,17))
        │   │       │   │   │   │   ├── flags: static_literal, decimal
        │   │       │   │   │   │   └── value: 1
        │   │       │   │   │   └── operator_loc: ∅
        │   │       │   │   └── @ AssocNode (location: (36,19)-(36,22))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (36,19)-(36,22))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (36,19)-(36,21) = "_a"
        │   │       │   │       │   ├── closing_loc: (36,21)-(36,22) = ":"
        │   │       │   │       │   └── unescaped: "_a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ ImplicitNode (location: (36,19)-(36,21))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── value:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (36,19)-(36,21))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :_a
        │   │       │   │       │       └── depth: 0
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest:
        │   │       │   │   @ AssocSplatNode (location: (36,24)-(36,26))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── value: ∅
        │   │       │   │   └── operator_loc: (36,24)-(36,26) = "**"
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (36,32)-(36,36))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (36,32)-(36,36))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (36,10)-(36,12) = "in"
        │   │       └── then_loc: (36,27)-(36,31) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (36,0)-(36,4) = "case"
        │   └── end_keyword_loc: (36,38)-(36,41) = "end"
        ├── @ CaseMatchNode (location: (38,0)-(38,38))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (38,5)-(38,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (38,5)-(38,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (38,10)-(38,33))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (38,13)-(38,23))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ AssocNode (location: (38,13)-(38,17))
        │   │       │   │   │   ├── flags: static_literal
        │   │       │   │   │   ├── key:
        │   │       │   │   │   │   @ SymbolNode (location: (38,13)-(38,15))
        │   │       │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   │   ├── value_loc: (38,13)-(38,14) = "a"
        │   │       │   │   │   │   ├── closing_loc: (38,14)-(38,15) = ":"
        │   │       │   │   │   │   └── unescaped: "a"
        │   │       │   │   │   ├── value:
        │   │       │   │   │   │   @ IntegerNode (location: (38,16)-(38,17))
        │   │       │   │   │   │   ├── flags: static_literal, decimal
        │   │       │   │   │   │   └── value: 1
        │   │       │   │   │   └── operator_loc: ∅
        │   │       │   │   └── @ AssocNode (location: (38,19)-(38,23))
        │   │       │   │       ├── flags: static_literal
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (38,19)-(38,21))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (38,19)-(38,20) = "b"
        │   │       │   │       │   ├── closing_loc: (38,20)-(38,21) = ":"
        │   │       │   │       │   └── unescaped: "b"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ IntegerNode (location: (38,22)-(38,23))
        │   │       │   │       │   ├── flags: static_literal, decimal
        │   │       │   │       │   └── value: 2
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (38,29)-(38,33))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (38,29)-(38,33))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (38,10)-(38,12) = "in"
        │   │       └── then_loc: (38,24)-(38,28) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (38,0)-(38,4) = "case"
        │   └── end_keyword_loc: (38,35)-(38,38) = "end"
        ├── @ CaseMatchNode (location: (40,0)-(40,30))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (40,5)-(40,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (40,5)-(40,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (40,10)-(40,25))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (40,13)-(40,15))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (40,13)-(40,15))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (40,13)-(40,15))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (40,13)-(40,14) = "a"
        │   │       │   │       │   ├── closing_loc: (40,14)-(40,15) = ":"
        │   │       │   │       │   └── unescaped: "a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ ImplicitNode (location: (40,13)-(40,14))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── value:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (40,13)-(40,14))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :a
        │   │       │   │       │       └── depth: 0
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (40,21)-(40,25))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (40,21)-(40,25))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (40,10)-(40,12) = "in"
        │   │       └── then_loc: (40,16)-(40,20) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (40,0)-(40,4) = "case"
        │   └── end_keyword_loc: (40,27)-(40,30) = "end"
        ├── @ CaseMatchNode (location: (42,0)-(42,34))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (42,5)-(42,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (42,5)-(42,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (42,10)-(42,29))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (42,13)-(42,19))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 2)
        │   │       │   │   ├── @ AssocNode (location: (42,13)-(42,15))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── key:
        │   │       │   │   │   │   @ SymbolNode (location: (42,13)-(42,15))
        │   │       │   │   │   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   │   ├── value_loc: (42,13)-(42,14) = "a"
        │   │       │   │   │   │   ├── closing_loc: (42,14)-(42,15) = ":"
        │   │       │   │   │   │   └── unescaped: "a"
        │   │       │   │   │   ├── value:
        │   │       │   │   │   │   @ ImplicitNode (location: (42,13)-(42,14))
        │   │       │   │   │   │   ├── flags: ∅
        │   │       │   │   │   │   └── value:
        │   │       │   │   │   │       @ LocalVariableTargetNode (location: (42,13)-(42,14))
        │   │       │   │   │   │       ├── flags: ∅
        │   │       │   │   │   │       ├── name: :a
        │   │       │   │   │   │       └── depth: 0
        │   │       │   │   │   └── operator_loc: ∅
        │   │       │   │   └── @ AssocNode (location: (42,17)-(42,19))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (42,17)-(42,19))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (42,17)-(42,18) = "b"
        │   │       │   │       │   ├── closing_loc: (42,18)-(42,19) = ":"
        │   │       │   │       │   └── unescaped: "b"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ ImplicitNode (location: (42,17)-(42,18))
        │   │       │   │       │   ├── flags: ∅
        │   │       │   │       │   └── value:
        │   │       │   │       │       @ LocalVariableTargetNode (location: (42,17)-(42,18))
        │   │       │   │       │       ├── flags: ∅
        │   │       │   │       │       ├── name: :b
        │   │       │   │       │       └── depth: 0
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (42,25)-(42,29))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (42,25)-(42,29))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (42,10)-(42,12) = "in"
        │   │       └── then_loc: (42,20)-(42,24) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (42,0)-(42,4) = "case"
        │   └── end_keyword_loc: (42,31)-(42,34) = "end"
        ├── @ CaseMatchNode (location: (44,0)-(44,36))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (44,5)-(44,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (44,5)-(44,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (44,10)-(44,31))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (44,13)-(44,21))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (44,15)-(44,19))
        │   │       │   │       ├── flags: static_literal
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (44,15)-(44,17))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (44,15)-(44,16) = "a"
        │   │       │   │       │   ├── closing_loc: (44,16)-(44,17) = ":"
        │   │       │   │       │   └── unescaped: "a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ IntegerNode (location: (44,18)-(44,19))
        │   │       │   │       │   ├── flags: static_literal, decimal
        │   │       │   │       │   └── value: 1
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: (44,13)-(44,14) = "{"
        │   │       │   └── closing_loc: (44,20)-(44,21) = "}"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (44,27)-(44,31))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (44,27)-(44,31))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (44,10)-(44,12) = "in"
        │   │       └── then_loc: (44,22)-(44,26) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (44,0)-(44,4) = "case"
        │   └── end_keyword_loc: (44,33)-(44,36) = "end"
        ├── @ CaseMatchNode (location: (46,0)-(46,37))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (46,5)-(46,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (46,5)-(46,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (46,10)-(46,32))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ HashPatternNode (location: (46,13)-(46,22))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── elements: (length: 1)
        │   │       │   │   └── @ AssocNode (location: (46,15)-(46,19))
        │   │       │   │       ├── flags: static_literal
        │   │       │   │       ├── key:
        │   │       │   │       │   @ SymbolNode (location: (46,15)-(46,17))
        │   │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │       │   │       │   ├── opening_loc: ∅
        │   │       │   │       │   ├── value_loc: (46,15)-(46,16) = "a"
        │   │       │   │       │   ├── closing_loc: (46,16)-(46,17) = ":"
        │   │       │   │       │   └── unescaped: "a"
        │   │       │   │       ├── value:
        │   │       │   │       │   @ IntegerNode (location: (46,18)-(46,19))
        │   │       │   │       │   ├── flags: static_literal, decimal
        │   │       │   │       │   └── value: 1
        │   │       │   │       └── operator_loc: ∅
        │   │       │   ├── rest: ∅
        │   │       │   ├── opening_loc: (46,13)-(46,14) = "{"
        │   │       │   └── closing_loc: (46,21)-(46,22) = "}"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (46,28)-(46,32))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (46,28)-(46,32))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (46,10)-(46,12) = "in"
        │   │       └── then_loc: (46,23)-(46,27) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (46,0)-(46,4) = "case"
        │   └── end_keyword_loc: (46,34)-(46,37) = "end"
        └── @ CaseMatchNode (location: (48,0)-(48,30))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (48,5)-(48,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (48,5)-(48,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (48,10)-(48,25))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ HashPatternNode (location: (48,13)-(48,15))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── elements: (length: 0)
            │       │   ├── rest: ∅
            │       │   ├── opening_loc: (48,13)-(48,14) = "{"
            │       │   └── closing_loc: (48,14)-(48,15) = "}"
            │       ├── statements:
            │       │   @ StatementsNode (location: (48,21)-(48,25))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ TrueNode (location: (48,21)-(48,25))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (48,10)-(48,12) = "in"
            │       └── then_loc: (48,16)-(48,20) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (48,0)-(48,4) = "case"
            └── end_keyword_loc: (48,27)-(48,30) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_if_unless_modifiers.txt000066400000000000000000000123721506127434000272650ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,36))
├── flags: ∅
├── locals: [:x]
└── statements:
    @ StatementsNode (location: (1,0)-(3,36))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CaseMatchNode (location: (1,0)-(1,32))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (1,5)-(1,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,5)-(1,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (1,10)-(1,27))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ IfNode (location: (1,13)-(1,22))
        │   │       │   ├── flags: newline
        │   │       │   ├── if_keyword_loc: (1,15)-(1,17) = "if"
        │   │       │   ├── predicate:
        │   │       │   │   @ TrueNode (location: (1,18)-(1,22))
        │   │       │   │   └── flags: static_literal
        │   │       │   ├── then_keyword_loc: ∅
        │   │       │   ├── statements:
        │   │       │   │   @ StatementsNode (location: (1,13)-(1,14))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ LocalVariableTargetNode (location: (1,13)-(1,14))
        │   │       │   │           ├── flags: newline
        │   │       │   │           ├── name: :x
        │   │       │   │           └── depth: 0
        │   │       │   ├── subsequent: ∅
        │   │       │   └── end_keyword_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (1,24)-(1,27))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ NilNode (location: (1,24)-(1,27))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (1,10)-(1,12) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (1,29)-(1,32) = "end"
        └── @ CaseMatchNode (location: (3,0)-(3,36))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (3,5)-(3,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (3,5)-(3,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (3,10)-(3,31))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ UnlessNode (location: (3,13)-(3,26))
            │       │   ├── flags: newline
            │       │   ├── keyword_loc: (3,15)-(3,21) = "unless"
            │       │   ├── predicate:
            │       │   │   @ TrueNode (location: (3,22)-(3,26))
            │       │   │   └── flags: static_literal
            │       │   ├── then_keyword_loc: ∅
            │       │   ├── statements:
            │       │   │   @ StatementsNode (location: (3,13)-(3,14))
            │       │   │   ├── flags: ∅
            │       │   │   └── body: (length: 1)
            │       │   │       └── @ LocalVariableTargetNode (location: (3,13)-(3,14))
            │       │   │           ├── flags: newline
            │       │   │           ├── name: :x
            │       │   │           └── depth: 0
            │       │   ├── else_clause: ∅
            │       │   └── end_keyword_loc: ∅
            │       ├── statements:
            │       │   @ StatementsNode (location: (3,28)-(3,31))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ NilNode (location: (3,28)-(3,31))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (3,10)-(3,12) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (3,0)-(3,4) = "case"
            └── end_keyword_loc: (3,33)-(3,36) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_implicit_array_match.txt000066400000000000000000000541051506127434000274210ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(15,32))
├── flags: ∅
├── locals: [:x, :y, :z]
└── statements:
    @ StatementsNode (location: (1,0)-(15,32))
    ├── flags: ∅
    └── body: (length: 8)
        ├── @ CaseMatchNode (location: (1,0)-(1,28))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (1,5)-(1,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,5)-(1,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (1,10)-(1,23))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (1,13)-(1,14))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 0)
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (1,13)-(1,14))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (1,13)-(1,14) = "*"
        │   │       │   │   └── expression: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (1,20)-(1,23))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ NilNode (location: (1,20)-(1,23))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (1,10)-(1,12) = "in"
        │   │       └── then_loc: (1,15)-(1,19) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (1,25)-(1,28) = "end"
        ├── @ CaseMatchNode (location: (3,0)-(3,29))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (3,5)-(3,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,5)-(3,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3,10)-(3,24))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (3,13)-(3,15))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 0)
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (3,13)-(3,15))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (3,13)-(3,14) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (3,14)-(3,15))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :x
        │   │       │   │       └── depth: 0
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (3,21)-(3,24))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ NilNode (location: (3,21)-(3,24))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (3,10)-(3,12) = "in"
        │   │       └── then_loc: (3,16)-(3,20) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (3,0)-(3,4) = "case"
        │   └── end_keyword_loc: (3,26)-(3,29) = "end"
        ├── @ CaseMatchNode (location: (5,0)-(5,35))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (5,5)-(5,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (5,5)-(5,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (5,10)-(5,30))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (5,13)-(5,21))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 0)
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (5,13)-(5,15))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (5,13)-(5,14) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (5,14)-(5,15))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :x
        │   │       │   │       └── depth: 0
        │   │       │   ├── posts: (length: 2)
        │   │       │   │   ├── @ LocalVariableTargetNode (location: (5,17)-(5,18))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── name: :y
        │   │       │   │   │   └── depth: 0
        │   │       │   │   └── @ LocalVariableTargetNode (location: (5,20)-(5,21))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :z
        │   │       │   │       └── depth: 0
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (5,27)-(5,30))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ NilNode (location: (5,27)-(5,30))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (5,10)-(5,12) = "in"
        │   │       └── then_loc: (5,22)-(5,26) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (5,0)-(5,4) = "case"
        │   └── end_keyword_loc: (5,32)-(5,35) = "end"
        ├── @ CaseMatchNode (location: (7,0)-(7,41))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (7,5)-(7,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (7,5)-(7,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (7,10)-(7,36))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (7,13)-(7,27))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 4)
        │   │       │   │   ├── @ IntegerNode (location: (7,13)-(7,14))
        │   │       │   │   │   ├── flags: static_literal, decimal
        │   │       │   │   │   └── value: 1
        │   │       │   │   ├── @ StringNode (location: (7,16)-(7,19))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── opening_loc: (7,16)-(7,17) = "\""
        │   │       │   │   │   ├── content_loc: (7,17)-(7,18) = "a"
        │   │       │   │   │   ├── closing_loc: (7,18)-(7,19) = "\""
        │   │       │   │   │   └── unescaped: "a"
        │   │       │   │   ├── @ ArrayPatternNode (location: (7,21)-(7,23))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── constant: ∅
        │   │       │   │   │   ├── requireds: (length: 0)
        │   │       │   │   │   ├── rest: ∅
        │   │       │   │   │   ├── posts: (length: 0)
        │   │       │   │   │   ├── opening_loc: (7,21)-(7,22) = "["
        │   │       │   │   │   └── closing_loc: (7,22)-(7,23) = "]"
        │   │       │   │   └── @ HashPatternNode (location: (7,25)-(7,27))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── constant: ∅
        │   │       │   │       ├── elements: (length: 0)
        │   │       │   │       ├── rest: ∅
        │   │       │   │       ├── opening_loc: (7,25)-(7,26) = "{"
        │   │       │   │       └── closing_loc: (7,26)-(7,27) = "}"
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (7,33)-(7,36))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ NilNode (location: (7,33)-(7,36))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (7,10)-(7,12) = "in"
        │   │       └── then_loc: (7,28)-(7,32) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (7,0)-(7,4) = "case"
        │   └── end_keyword_loc: (7,38)-(7,41) = "end"
        ├── @ CaseMatchNode (location: (9,0)-(9,35))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (9,5)-(9,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (9,5)-(9,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (9,10)-(9,30))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (9,13)-(9,21))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ LocalVariableTargetNode (location: (9,13)-(9,14))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :x
        │   │       │   │       └── depth: 0
        │   │       │   ├── rest:
        │   │       │   │   @ SplatNode (location: (9,16)-(9,18))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── operator_loc: (9,16)-(9,17) = "*"
        │   │       │   │   └── expression:
        │   │       │   │       @ LocalVariableTargetNode (location: (9,17)-(9,18))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :y
        │   │       │   │       └── depth: 0
        │   │       │   ├── posts: (length: 1)
        │   │       │   │   └── @ LocalVariableTargetNode (location: (9,20)-(9,21))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :z
        │   │       │   │       └── depth: 0
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (9,27)-(9,30))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ NilNode (location: (9,27)-(9,30))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (9,10)-(9,12) = "in"
        │   │       └── then_loc: (9,22)-(9,26) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (9,0)-(9,4) = "case"
        │   └── end_keyword_loc: (9,32)-(9,35) = "end"
        ├── @ CaseMatchNode (location: (11,0)-(11,29))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (11,5)-(11,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (11,5)-(11,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (11,10)-(11,24))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (11,13)-(11,15))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 1)
        │   │       │   │   └── @ LocalVariableTargetNode (location: (11,13)-(11,14))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :x
        │   │       │   │       └── depth: 0
        │   │       │   ├── rest:
        │   │       │   │   @ ImplicitRestNode (location: (11,14)-(11,15))
        │   │       │   │   └── flags: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (11,21)-(11,24))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ NilNode (location: (11,21)-(11,24))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (11,10)-(11,12) = "in"
        │   │       └── then_loc: (11,16)-(11,20) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (11,0)-(11,4) = "case"
        │   └── end_keyword_loc: (11,26)-(11,29) = "end"
        ├── @ CaseMatchNode (location: (13,0)-(13,31))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (13,5)-(13,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (13,5)-(13,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (13,10)-(13,26))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ ArrayPatternNode (location: (13,13)-(13,17))
        │   │       │   ├── flags: ∅
        │   │       │   ├── constant: ∅
        │   │       │   ├── requireds: (length: 2)
        │   │       │   │   ├── @ LocalVariableTargetNode (location: (13,13)-(13,14))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── name: :x
        │   │       │   │   │   └── depth: 0
        │   │       │   │   └── @ LocalVariableTargetNode (location: (13,16)-(13,17))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── name: :y
        │   │       │   │       └── depth: 0
        │   │       │   ├── rest: ∅
        │   │       │   ├── posts: (length: 0)
        │   │       │   ├── opening_loc: ∅
        │   │       │   └── closing_loc: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (13,23)-(13,26))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ NilNode (location: (13,23)-(13,26))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (13,10)-(13,12) = "in"
        │   │       └── then_loc: (13,18)-(13,22) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (13,0)-(13,4) = "case"
        │   └── end_keyword_loc: (13,28)-(13,31) = "end"
        └── @ CaseMatchNode (location: (15,0)-(15,32))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (15,5)-(15,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (15,5)-(15,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (15,10)-(15,27))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ ArrayPatternNode (location: (15,13)-(15,18))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── requireds: (length: 2)
            │       │   │   ├── @ LocalVariableTargetNode (location: (15,13)-(15,14))
            │       │   │   │   ├── flags: ∅
            │       │   │   │   ├── name: :x
            │       │   │   │   └── depth: 0
            │       │   │   └── @ LocalVariableTargetNode (location: (15,16)-(15,17))
            │       │   │       ├── flags: ∅
            │       │   │       ├── name: :y
            │       │   │       └── depth: 0
            │       │   ├── rest:
            │       │   │   @ ImplicitRestNode (location: (15,17)-(15,18))
            │       │   │   └── flags: ∅
            │       │   ├── posts: (length: 0)
            │       │   ├── opening_loc: ∅
            │       │   └── closing_loc: ∅
            │       ├── statements:
            │       │   @ StatementsNode (location: (15,24)-(15,27))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ NilNode (location: (15,24)-(15,27))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (15,10)-(15,12) = "in"
            │       └── then_loc: (15,19)-(15,23) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (15,0)-(15,4) = "case"
            └── end_keyword_loc: (15,29)-(15,32) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_keyword_variable.txt000066400000000000000000000033771506127434000265730ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,32))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,32))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(1,32))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (1,5)-(1,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,5)-(1,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (1,10)-(1,27))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ SelfNode (location: (1,13)-(1,17))
            │       │   └── flags: ∅
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,23)-(1,27))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ TrueNode (location: (1,23)-(1,27))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (1,10)-(1,12) = "in"
            │       └── then_loc: (1,18)-(1,22) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,29)-(1,32) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_lambda.txt000066400000000000000000000050231506127434000244500ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,36))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,36))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(1,36))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (1,5)-(1,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,5)-(1,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (1,10)-(1,31))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ LambdaNode (location: (1,13)-(1,21))
            │       │   ├── flags: ∅
            │       │   ├── locals: []
            │       │   ├── operator_loc: (1,13)-(1,15) = "->"
            │       │   ├── opening_loc: (1,15)-(1,16) = "{"
            │       │   ├── closing_loc: (1,20)-(1,21) = "}"
            │       │   ├── parameters: ∅
            │       │   └── body:
            │       │       @ StatementsNode (location: (1,17)-(1,19))
            │       │       ├── flags: ∅
            │       │       └── body: (length: 1)
            │       │           └── @ IntegerNode (location: (1,17)-(1,19))
            │       │               ├── flags: newline, static_literal, decimal
            │       │               └── value: 42
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,27)-(1,31))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ TrueNode (location: (1,27)-(1,31))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (1,10)-(1,12) = "in"
            │       └── then_loc: (1,22)-(1,26) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,33)-(1,36) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_match_alt.txt000066400000000000000000000045021506127434000251650ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,33))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,33))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(1,33))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (1,5)-(1,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,5)-(1,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (1,10)-(1,28))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ AlternationPatternNode (location: (1,13)-(1,18))
            │       │   ├── flags: ∅
            │       │   ├── left:
            │       │   │   @ IntegerNode (location: (1,13)-(1,14))
            │       │   │   ├── flags: static_literal, decimal
            │       │   │   └── value: 1
            │       │   ├── right:
            │       │   │   @ IntegerNode (location: (1,17)-(1,18))
            │       │   │   ├── flags: static_literal, decimal
            │       │   │   └── value: 2
            │       │   └── operator_loc: (1,15)-(1,16) = "|"
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,24)-(1,28))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ TrueNode (location: (1,24)-(1,28))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (1,10)-(1,12) = "in"
            │       └── then_loc: (1,19)-(1,23) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,30)-(1,33) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_match_as.txt000066400000000000000000000045601506127434000250140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,34))
├── flags: ∅
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (1,0)-(1,34))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(1,34))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (1,5)-(1,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,5)-(1,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (1,10)-(1,29))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ CapturePatternNode (location: (1,13)-(1,19))
            │       │   ├── flags: ∅
            │       │   ├── value:
            │       │   │   @ IntegerNode (location: (1,13)-(1,14))
            │       │   │   ├── flags: static_literal, decimal
            │       │   │   └── value: 1
            │       │   ├── target:
            │       │   │   @ LocalVariableTargetNode (location: (1,18)-(1,19))
            │       │   │   ├── flags: ∅
            │       │   │   ├── name: :a
            │       │   │   └── depth: 0
            │       │   └── operator_loc: (1,15)-(1,17) = "=>"
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,25)-(1,29))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ TrueNode (location: (1,25)-(1,29))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (1,10)-(1,12) = "in"
            │       └── then_loc: (1,20)-(1,24) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,31)-(1,34) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_nil_pattern.txt000066400000000000000000000044731506127434000255570ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,33))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,33))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(1,33))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (1,5)-(1,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,5)-(1,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (1,10)-(1,28))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ HashPatternNode (location: (1,13)-(1,18))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── elements: (length: 0)
            │       │   ├── rest:
            │       │   │   @ NoKeywordsParameterNode (location: (1,13)-(1,18))
            │       │   │   ├── flags: ∅
            │       │   │   ├── operator_loc: (1,13)-(1,15) = "**"
            │       │   │   └── keyword_loc: (1,15)-(1,18) = "nil"
            │       │   ├── opening_loc: ∅
            │       │   └── closing_loc: ∅
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,24)-(1,28))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ TrueNode (location: (1,24)-(1,28))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (1,10)-(1,12) = "in"
            │       └── then_loc: (1,19)-(1,23) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,30)-(1,33) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_no_body.txt000066400000000000000000000027521506127434000246670ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,19))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(1,19))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (1,5)-(1,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,5)-(1,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (1,10)-(1,14))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ IntegerNode (location: (1,13)-(1,14))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 1
            │       ├── statements: ∅
            │       ├── in_loc: (1,10)-(1,12) = "in"
            │       └── then_loc: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,16)-(1,19) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_ranges.txt000066400000000000000000000310241506127434000245070ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(11,32))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(11,32))
    ├── flags: ∅
    └── body: (length: 6)
        ├── @ CaseMatchNode (location: (1,0)-(1,32))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (1,5)-(1,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,5)-(1,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (1,10)-(1,27))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ RangeNode (location: (1,13)-(1,17))
        │   │       │   ├── flags: static_literal, exclude_end
        │   │       │   ├── left: ∅
        │   │       │   ├── right:
        │   │       │   │   @ IntegerNode (location: (1,16)-(1,17))
        │   │       │   │   ├── flags: static_literal, decimal
        │   │       │   │   └── value: 2
        │   │       │   └── operator_loc: (1,13)-(1,16) = "..."
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (1,23)-(1,27))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (1,23)-(1,27))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (1,10)-(1,12) = "in"
        │   │       └── then_loc: (1,18)-(1,22) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (1,29)-(1,32) = "end"
        ├── @ CaseMatchNode (location: (3,0)-(3,31))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (3,5)-(3,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,5)-(3,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3,10)-(3,26))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ RangeNode (location: (3,13)-(3,16))
        │   │       │   ├── flags: static_literal
        │   │       │   ├── left: ∅
        │   │       │   ├── right:
        │   │       │   │   @ IntegerNode (location: (3,15)-(3,16))
        │   │       │   │   ├── flags: static_literal, decimal
        │   │       │   │   └── value: 2
        │   │       │   └── operator_loc: (3,13)-(3,15) = ".."
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (3,22)-(3,26))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (3,22)-(3,26))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (3,10)-(3,12) = "in"
        │   │       └── then_loc: (3,17)-(3,21) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (3,0)-(3,4) = "case"
        │   └── end_keyword_loc: (3,28)-(3,31) = "end"
        ├── @ CaseMatchNode (location: (5,0)-(5,31))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (5,5)-(5,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (5,5)-(5,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (5,10)-(5,26))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ RangeNode (location: (5,13)-(5,16))
        │   │       │   ├── flags: static_literal
        │   │       │   ├── left:
        │   │       │   │   @ IntegerNode (location: (5,13)-(5,14))
        │   │       │   │   ├── flags: static_literal, decimal
        │   │       │   │   └── value: 1
        │   │       │   ├── right: ∅
        │   │       │   └── operator_loc: (5,14)-(5,16) = ".."
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (5,22)-(5,26))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (5,22)-(5,26))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (5,10)-(5,12) = "in"
        │   │       └── then_loc: (5,17)-(5,21) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (5,0)-(5,4) = "case"
        │   └── end_keyword_loc: (5,28)-(5,31) = "end"
        ├── @ CaseMatchNode (location: (7,0)-(7,32))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (7,5)-(7,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (7,5)-(7,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (7,10)-(7,27))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ RangeNode (location: (7,13)-(7,17))
        │   │       │   ├── flags: static_literal, exclude_end
        │   │       │   ├── left:
        │   │       │   │   @ IntegerNode (location: (7,13)-(7,14))
        │   │       │   │   ├── flags: static_literal, decimal
        │   │       │   │   └── value: 1
        │   │       │   ├── right: ∅
        │   │       │   └── operator_loc: (7,14)-(7,17) = "..."
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (7,23)-(7,27))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (7,23)-(7,27))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (7,10)-(7,12) = "in"
        │   │       └── then_loc: (7,18)-(7,22) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (7,0)-(7,4) = "case"
        │   └── end_keyword_loc: (7,29)-(7,32) = "end"
        ├── @ CaseMatchNode (location: (9,0)-(9,33))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (9,5)-(9,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (9,5)-(9,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (9,10)-(9,28))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ RangeNode (location: (9,13)-(9,18))
        │   │       │   ├── flags: static_literal, exclude_end
        │   │       │   ├── left:
        │   │       │   │   @ IntegerNode (location: (9,13)-(9,14))
        │   │       │   │   ├── flags: static_literal, decimal
        │   │       │   │   └── value: 1
        │   │       │   ├── right:
        │   │       │   │   @ IntegerNode (location: (9,17)-(9,18))
        │   │       │   │   ├── flags: static_literal, decimal
        │   │       │   │   └── value: 2
        │   │       │   └── operator_loc: (9,14)-(9,17) = "..."
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (9,24)-(9,28))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ TrueNode (location: (9,24)-(9,28))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (9,10)-(9,12) = "in"
        │   │       └── then_loc: (9,19)-(9,23) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (9,0)-(9,4) = "case"
        │   └── end_keyword_loc: (9,30)-(9,33) = "end"
        └── @ CaseMatchNode (location: (11,0)-(11,32))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (11,5)-(11,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (11,5)-(11,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (11,10)-(11,27))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ RangeNode (location: (11,13)-(11,17))
            │       │   ├── flags: static_literal
            │       │   ├── left:
            │       │   │   @ IntegerNode (location: (11,13)-(11,14))
            │       │   │   ├── flags: static_literal, decimal
            │       │   │   └── value: 1
            │       │   ├── right:
            │       │   │   @ IntegerNode (location: (11,16)-(11,17))
            │       │   │   ├── flags: static_literal, decimal
            │       │   │   └── value: 2
            │       │   └── operator_loc: (11,14)-(11,16) = ".."
            │       ├── statements:
            │       │   @ StatementsNode (location: (11,23)-(11,27))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ TrueNode (location: (11,23)-(11,27))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (11,10)-(11,12) = "in"
            │       └── then_loc: (11,18)-(11,22) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (11,0)-(11,4) = "case"
            └── end_keyword_loc: (11,29)-(11,32) = "end"
prism-1.5.1/snapshots/whitequark/pattern_matching_single_line.txt000066400000000000000000000050531506127434000255230ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,11))
├── flags: ∅
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (1,0)-(3,11))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ MatchRequiredNode (location: (1,0)-(1,8))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ IntegerNode (location: (1,0)-(1,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1,5)-(1,8))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (1,6)-(1,7))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (1,5)-(1,6) = "["
        │   │   └── closing_loc: (1,7)-(1,8) = "]"
        │   └── operator_loc: (1,2)-(1,4) = "=>"
        ├── @ LocalVariableReadNode (location: (1,10)-(1,11))
        │   ├── flags: newline
        │   ├── name: :a
        │   └── depth: 0
        ├── @ MatchPredicateNode (location: (3,0)-(3,8))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ IntegerNode (location: (3,0)-(3,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (3,5)-(3,8))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 1)
        │   │   │   └── @ LocalVariableTargetNode (location: (3,6)-(3,7))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :a
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: (3,5)-(3,6) = "["
        │   │   └── closing_loc: (3,7)-(3,8) = "]"
        │   └── operator_loc: (3,2)-(3,4) = "in"
        └── @ LocalVariableReadNode (location: (3,10)-(3,11))
            ├── flags: newline
            ├── name: :a
            └── depth: 0
prism-1.5.1/snapshots/whitequark/pattern_matching_single_line_allowed_omission_of_parentheses.txt000066400000000000000000000406021506127434000342360ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(11,34))
├── flags: ∅
├── locals: [:a, :b, :value]
└── statements:
    @ StatementsNode (location: (1,0)-(11,34))
    ├── flags: ∅
    └── body: (length: 12)
        ├── @ MatchRequiredNode (location: (1,0)-(1,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ ArrayNode (location: (1,0)-(1,6))
        │   │   ├── flags: static_literal
        │   │   ├── elements: (length: 2)
        │   │   │   ├── @ IntegerNode (location: (1,1)-(1,2))
        │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   └── value: 1
        │   │   │   └── @ IntegerNode (location: (1,4)-(1,5))
        │   │   │       ├── flags: static_literal, decimal
        │   │   │       └── value: 2
        │   │   ├── opening_loc: (1,0)-(1,1) = "["
        │   │   └── closing_loc: (1,5)-(1,6) = "]"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (1,10)-(1,14))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (1,10)-(1,11))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :a
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (1,13)-(1,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :b
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (1,7)-(1,9) = "=>"
        ├── @ LocalVariableReadNode (location: (1,16)-(1,17))
        │   ├── flags: newline
        │   ├── name: :a
        │   └── depth: 0
        ├── @ MatchPredicateNode (location: (3,0)-(3,14))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ ArrayNode (location: (3,0)-(3,6))
        │   │   ├── flags: static_literal
        │   │   ├── elements: (length: 2)
        │   │   │   ├── @ IntegerNode (location: (3,1)-(3,2))
        │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   └── value: 1
        │   │   │   └── @ IntegerNode (location: (3,4)-(3,5))
        │   │   │       ├── flags: static_literal, decimal
        │   │   │       └── value: 2
        │   │   ├── opening_loc: (3,0)-(3,1) = "["
        │   │   └── closing_loc: (3,5)-(3,6) = "]"
        │   ├── pattern:
        │   │   @ ArrayPatternNode (location: (3,10)-(3,14))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── requireds: (length: 2)
        │   │   │   ├── @ LocalVariableTargetNode (location: (3,10)-(3,11))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: :a
        │   │   │   │   └── depth: 0
        │   │   │   └── @ LocalVariableTargetNode (location: (3,13)-(3,14))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :b
        │   │   │       └── depth: 0
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (3,7)-(3,9) = "in"
        ├── @ LocalVariableReadNode (location: (3,16)-(3,17))
        │   ├── flags: newline
        │   ├── name: :a
        │   └── depth: 0
        ├── @ MatchRequiredNode (location: (5,0)-(5,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ HashNode (location: (5,0)-(5,6))
        │   │   ├── flags: static_literal
        │   │   ├── opening_loc: (5,0)-(5,1) = "{"
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (5,1)-(5,5))
        │   │   │       ├── flags: static_literal
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (5,1)-(5,3))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (5,1)-(5,2) = "a"
        │   │   │       │   ├── closing_loc: (5,2)-(5,3) = ":"
        │   │   │       │   └── unescaped: "a"
        │   │   │       ├── value:
        │   │   │       │   @ IntegerNode (location: (5,4)-(5,5))
        │   │   │       │   ├── flags: static_literal, decimal
        │   │   │       │   └── value: 1
        │   │   │       └── operator_loc: ∅
        │   │   └── closing_loc: (5,5)-(5,6) = "}"
        │   ├── pattern:
        │   │   @ HashPatternNode (location: (5,10)-(5,12))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (5,10)-(5,12))
        │   │   │       ├── flags: ∅
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (5,10)-(5,12))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (5,10)-(5,11) = "a"
        │   │   │       │   ├── closing_loc: (5,11)-(5,12) = ":"
        │   │   │       │   └── unescaped: "a"
        │   │   │       ├── value:
        │   │   │       │   @ ImplicitNode (location: (5,10)-(5,11))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   └── value:
        │   │   │       │       @ LocalVariableTargetNode (location: (5,10)-(5,11))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       ├── name: :a
        │   │   │       │       └── depth: 0
        │   │   │       └── operator_loc: ∅
        │   │   ├── rest: ∅
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (5,7)-(5,9) = "=>"
        ├── @ LocalVariableReadNode (location: (5,14)-(5,15))
        │   ├── flags: newline
        │   ├── name: :a
        │   └── depth: 0
        ├── @ MatchPredicateNode (location: (7,0)-(7,12))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ HashNode (location: (7,0)-(7,6))
        │   │   ├── flags: static_literal
        │   │   ├── opening_loc: (7,0)-(7,1) = "{"
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (7,1)-(7,5))
        │   │   │       ├── flags: static_literal
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (7,1)-(7,3))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (7,1)-(7,2) = "a"
        │   │   │       │   ├── closing_loc: (7,2)-(7,3) = ":"
        │   │   │       │   └── unescaped: "a"
        │   │   │       ├── value:
        │   │   │       │   @ IntegerNode (location: (7,4)-(7,5))
        │   │   │       │   ├── flags: static_literal, decimal
        │   │   │       │   └── value: 1
        │   │   │       └── operator_loc: ∅
        │   │   └── closing_loc: (7,5)-(7,6) = "}"
        │   ├── pattern:
        │   │   @ HashPatternNode (location: (7,10)-(7,12))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (7,10)-(7,12))
        │   │   │       ├── flags: ∅
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (7,10)-(7,12))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (7,10)-(7,11) = "a"
        │   │   │       │   ├── closing_loc: (7,11)-(7,12) = ":"
        │   │   │       │   └── unescaped: "a"
        │   │   │       ├── value:
        │   │   │       │   @ ImplicitNode (location: (7,10)-(7,11))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   └── value:
        │   │   │       │       @ LocalVariableTargetNode (location: (7,10)-(7,11))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       ├── name: :a
        │   │   │       │       └── depth: 0
        │   │   │       └── operator_loc: ∅
        │   │   ├── rest: ∅
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (7,7)-(7,9) = "in"
        ├── @ LocalVariableReadNode (location: (7,14)-(7,15))
        │   ├── flags: newline
        │   ├── name: :a
        │   └── depth: 0
        ├── @ MatchRequiredNode (location: (9,0)-(9,27))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ HashNode (location: (9,0)-(9,13))
        │   │   ├── flags: static_literal
        │   │   ├── opening_loc: (9,0)-(9,1) = "{"
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (9,1)-(9,12))
        │   │   │       ├── flags: static_literal
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (9,1)-(9,5))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (9,1)-(9,4) = "key"
        │   │   │       │   ├── closing_loc: (9,4)-(9,5) = ":"
        │   │   │       │   └── unescaped: "key"
        │   │   │       ├── value:
        │   │   │       │   @ SymbolNode (location: (9,6)-(9,12))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: (9,6)-(9,7) = ":"
        │   │   │       │   ├── value_loc: (9,7)-(9,12) = "value"
        │   │   │       │   ├── closing_loc: ∅
        │   │   │       │   └── unescaped: "value"
        │   │   │       └── operator_loc: ∅
        │   │   └── closing_loc: (9,12)-(9,13) = "}"
        │   ├── pattern:
        │   │   @ HashPatternNode (location: (9,17)-(9,27))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (9,17)-(9,27))
        │   │   │       ├── flags: ∅
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (9,17)-(9,21))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (9,17)-(9,20) = "key"
        │   │   │       │   ├── closing_loc: (9,20)-(9,21) = ":"
        │   │   │       │   └── unescaped: "key"
        │   │   │       ├── value:
        │   │   │       │   @ LocalVariableTargetNode (location: (9,22)-(9,27))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   ├── name: :value
        │   │   │       │   └── depth: 0
        │   │   │       └── operator_loc: ∅
        │   │   ├── rest: ∅
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (9,14)-(9,16) = "=>"
        ├── @ LocalVariableReadNode (location: (9,29)-(9,34))
        │   ├── flags: newline
        │   ├── name: :value
        │   └── depth: 0
        ├── @ MatchPredicateNode (location: (11,0)-(11,27))
        │   ├── flags: newline
        │   ├── value:
        │   │   @ HashNode (location: (11,0)-(11,13))
        │   │   ├── flags: static_literal
        │   │   ├── opening_loc: (11,0)-(11,1) = "{"
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (11,1)-(11,12))
        │   │   │       ├── flags: static_literal
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (11,1)-(11,5))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (11,1)-(11,4) = "key"
        │   │   │       │   ├── closing_loc: (11,4)-(11,5) = ":"
        │   │   │       │   └── unescaped: "key"
        │   │   │       ├── value:
        │   │   │       │   @ SymbolNode (location: (11,6)-(11,12))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: (11,6)-(11,7) = ":"
        │   │   │       │   ├── value_loc: (11,7)-(11,12) = "value"
        │   │   │       │   ├── closing_loc: ∅
        │   │   │       │   └── unescaped: "value"
        │   │   │       └── operator_loc: ∅
        │   │   └── closing_loc: (11,12)-(11,13) = "}"
        │   ├── pattern:
        │   │   @ HashPatternNode (location: (11,17)-(11,27))
        │   │   ├── flags: ∅
        │   │   ├── constant: ∅
        │   │   ├── elements: (length: 1)
        │   │   │   └── @ AssocNode (location: (11,17)-(11,27))
        │   │   │       ├── flags: ∅
        │   │   │       ├── key:
        │   │   │       │   @ SymbolNode (location: (11,17)-(11,21))
        │   │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── value_loc: (11,17)-(11,20) = "key"
        │   │   │       │   ├── closing_loc: (11,20)-(11,21) = ":"
        │   │   │       │   └── unescaped: "key"
        │   │   │       ├── value:
        │   │   │       │   @ LocalVariableTargetNode (location: (11,22)-(11,27))
        │   │   │       │   ├── flags: ∅
        │   │   │       │   ├── name: :value
        │   │   │       │   └── depth: 0
        │   │   │       └── operator_loc: ∅
        │   │   ├── rest: ∅
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── operator_loc: (11,14)-(11,16) = "in"
        └── @ LocalVariableReadNode (location: (11,29)-(11,34))
            ├── flags: newline
            ├── name: :value
            └── depth: 0
prism-1.5.1/snapshots/whitequark/pattern_matching_single_match.txt000066400000000000000000000037311506127434000256710ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,26))
├── flags: ∅
├── locals: [:x]
└── statements:
    @ StatementsNode (location: (1,0)-(1,26))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseMatchNode (location: (1,0)-(1,26))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (1,5)-(1,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,5)-(1,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (1,10)-(1,21))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ LocalVariableTargetNode (location: (1,13)-(1,14))
            │       │   ├── flags: ∅
            │       │   ├── name: :x
            │       │   └── depth: 0
            │       ├── statements:
            │       │   @ StatementsNode (location: (1,20)-(1,21))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ LocalVariableReadNode (location: (1,20)-(1,21))
            │       │           ├── flags: newline
            │       │           ├── name: :x
            │       │           └── depth: 0
            │       ├── in_loc: (1,10)-(1,12) = "in"
            │       └── then_loc: (1,15)-(1,19) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,23)-(1,26) = "end"
prism-1.5.1/snapshots/whitequark/pin_expr.txt000066400000000000000000000366611506127434000214610ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(14,41))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(14,41))
    ├── flags: ∅
    └── body: (length: 7)
        ├── @ CaseMatchNode (location: (1,0)-(1,39))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (1,5)-(1,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,5)-(1,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (1,10)-(1,34))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ PinnedVariableNode (location: (1,13)-(1,34))
        │   │       │   ├── flags: ∅
        │   │       │   ├── variable:
        │   │       │   │   @ GlobalVariableReadNode (location: (1,14)-(1,34))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :$TestPatternMatching
        │   │       │   └── operator_loc: (1,13)-(1,14) = "^"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (1,10)-(1,12) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (1,0)-(1,4) = "case"
        │   └── end_keyword_loc: (1,36)-(1,39) = "end"
        ├── @ CaseMatchNode (location: (3,0)-(3,33))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (3,5)-(3,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,5)-(3,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (3,10)-(3,28))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ PinnedExpressionNode (location: (3,13)-(3,19))
        │   │       │   ├── flags: ∅
        │   │       │   ├── expression:
        │   │       │   │   @ CallNode (location: (3,15)-(3,18))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   ├── receiver:
        │   │       │   │   │   @ IntegerNode (location: (3,15)-(3,16))
        │   │       │   │   │   ├── flags: static_literal, decimal
        │   │       │   │   │   └── value: 0
        │   │       │   │   ├── call_operator_loc: ∅
        │   │       │   │   ├── name: :+
        │   │       │   │   ├── message_loc: (3,16)-(3,17) = "+"
        │   │       │   │   ├── opening_loc: ∅
        │   │       │   │   ├── arguments:
        │   │       │   │   │   @ ArgumentsNode (location: (3,17)-(3,18))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   └── arguments: (length: 1)
        │   │       │   │   │       └── @ IntegerNode (location: (3,17)-(3,18))
        │   │       │   │   │           ├── flags: static_literal, decimal
        │   │       │   │   │           └── value: 0
        │   │       │   │   ├── closing_loc: ∅
        │   │       │   │   └── block: ∅
        │   │       │   ├── operator_loc: (3,13)-(3,14) = "^"
        │   │       │   ├── lparen_loc: (3,14)-(3,15) = "("
        │   │       │   └── rparen_loc: (3,18)-(3,19) = ")"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (3,25)-(3,28))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ NilNode (location: (3,25)-(3,28))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (3,10)-(3,12) = "in"
        │   │       └── then_loc: (3,20)-(3,24) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (3,0)-(3,4) = "case"
        │   └── end_keyword_loc: (3,30)-(3,33) = "end"
        ├── @ CaseMatchNode (location: (5,0)-(6,6))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (5,5)-(5,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (5,5)-(5,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (5,10)-(6,1))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ PinnedExpressionNode (location: (5,13)-(6,1))
        │   │       │   ├── flags: ∅
        │   │       │   ├── expression:
        │   │       │   │   @ IntegerNode (location: (5,15)-(5,16))
        │   │       │   │   ├── flags: static_literal, decimal
        │   │       │   │   └── value: 1
        │   │       │   ├── operator_loc: (5,13)-(5,14) = "^"
        │   │       │   ├── lparen_loc: (5,14)-(5,15) = "("
        │   │       │   └── rparen_loc: (6,0)-(6,1) = ")"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (5,10)-(5,12) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (5,0)-(5,4) = "case"
        │   └── end_keyword_loc: (6,3)-(6,6) = "end"
        ├── @ CaseMatchNode (location: (8,0)-(8,32))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (8,5)-(8,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (8,5)-(8,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (8,10)-(8,27))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ PinnedExpressionNode (location: (8,13)-(8,18))
        │   │       │   ├── flags: ∅
        │   │       │   ├── expression:
        │   │       │   │   @ IntegerNode (location: (8,15)-(8,17))
        │   │       │   │   ├── flags: static_literal, decimal
        │   │       │   │   └── value: 42
        │   │       │   ├── operator_loc: (8,13)-(8,14) = "^"
        │   │       │   ├── lparen_loc: (8,14)-(8,15) = "("
        │   │       │   └── rparen_loc: (8,17)-(8,18) = ")"
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (8,24)-(8,27))
        │   │       │   ├── flags: ∅
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ NilNode (location: (8,24)-(8,27))
        │   │       │           └── flags: newline, static_literal
        │   │       ├── in_loc: (8,10)-(8,12) = "in"
        │   │       └── then_loc: (8,19)-(8,23) = "then"
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (8,0)-(8,4) = "case"
        │   └── end_keyword_loc: (8,29)-(8,32) = "end"
        ├── @ CaseMatchNode (location: (10,0)-(10,40))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (10,5)-(10,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (10,5)-(10,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (10,10)-(10,35))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ PinnedVariableNode (location: (10,13)-(10,35))
        │   │       │   ├── flags: ∅
        │   │       │   ├── variable:
        │   │       │   │   @ ClassVariableReadNode (location: (10,14)-(10,35))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :@@TestPatternMatching
        │   │       │   └── operator_loc: (10,13)-(10,14) = "^"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (10,10)-(10,12) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (10,0)-(10,4) = "case"
        │   └── end_keyword_loc: (10,37)-(10,40) = "end"
        ├── @ CaseMatchNode (location: (12,0)-(12,21))
        │   ├── flags: newline
        │   ├── predicate:
        │   │   @ CallNode (location: (12,5)-(12,8))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (12,5)-(12,8) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── conditions: (length: 1)
        │   │   └── @ InNode (location: (12,10)-(12,16))
        │   │       ├── flags: ∅
        │   │       ├── pattern:
        │   │       │   @ PinnedVariableNode (location: (12,13)-(12,16))
        │   │       │   ├── flags: ∅
        │   │       │   ├── variable:
        │   │       │   │   @ InstanceVariableReadNode (location: (12,14)-(12,16))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── name: :@a
        │   │       │   └── operator_loc: (12,13)-(12,14) = "^"
        │   │       ├── statements: ∅
        │   │       ├── in_loc: (12,10)-(12,12) = "in"
        │   │       └── then_loc: ∅
        │   ├── else_clause: ∅
        │   ├── case_keyword_loc: (12,0)-(12,4) = "case"
        │   └── end_keyword_loc: (12,18)-(12,21) = "end"
        └── @ CaseMatchNode (location: (14,0)-(14,41))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (14,5)-(14,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (14,5)-(14,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ InNode (location: (14,10)-(14,36))
            │       ├── flags: ∅
            │       ├── pattern:
            │       │   @ HashPatternNode (location: (14,13)-(14,27))
            │       │   ├── flags: ∅
            │       │   ├── constant: ∅
            │       │   ├── elements: (length: 1)
            │       │   │   └── @ AssocNode (location: (14,15)-(14,25))
            │       │   │       ├── flags: ∅
            │       │   │       ├── key:
            │       │   │       │   @ SymbolNode (location: (14,15)-(14,19))
            │       │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   │       │   ├── opening_loc: ∅
            │       │   │       │   ├── value_loc: (14,15)-(14,18) = "foo"
            │       │   │       │   ├── closing_loc: (14,18)-(14,19) = ":"
            │       │   │       │   └── unescaped: "foo"
            │       │   │       ├── value:
            │       │   │       │   @ PinnedExpressionNode (location: (14,20)-(14,25))
            │       │   │       │   ├── flags: ∅
            │       │   │       │   ├── expression:
            │       │   │       │   │   @ IntegerNode (location: (14,22)-(14,24))
            │       │   │       │   │   ├── flags: static_literal, decimal
            │       │   │       │   │   └── value: 42
            │       │   │       │   ├── operator_loc: (14,20)-(14,21) = "^"
            │       │   │       │   ├── lparen_loc: (14,21)-(14,22) = "("
            │       │   │       │   └── rparen_loc: (14,24)-(14,25) = ")"
            │       │   │       └── operator_loc: ∅
            │       │   ├── rest: ∅
            │       │   ├── opening_loc: (14,13)-(14,14) = "{"
            │       │   └── closing_loc: (14,26)-(14,27) = "}"
            │       ├── statements:
            │       │   @ StatementsNode (location: (14,33)-(14,36))
            │       │   ├── flags: ∅
            │       │   └── body: (length: 1)
            │       │       └── @ NilNode (location: (14,33)-(14,36))
            │       │           └── flags: newline, static_literal
            │       ├── in_loc: (14,10)-(14,12) = "in"
            │       └── then_loc: (14,28)-(14,32) = "then"
            ├── else_clause: ∅
            ├── case_keyword_loc: (14,0)-(14,4) = "case"
            └── end_keyword_loc: (14,38)-(14,41) = "end"
prism-1.5.1/snapshots/whitequark/postexe.txt000066400000000000000000000015011506127434000213050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ PostExecutionNode (location: (1,0)-(1,9))
            ├── flags: newline
            ├── statements:
            │   @ StatementsNode (location: (1,6)-(1,7))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ IntegerNode (location: (1,6)-(1,7))
            │           ├── flags: newline, static_literal, decimal
            │           └── value: 1
            ├── keyword_loc: (1,0)-(1,3) = "END"
            ├── opening_loc: (1,4)-(1,5) = "{"
            └── closing_loc: (1,8)-(1,9) = "}"
prism-1.5.1/snapshots/whitequark/preexe.txt000066400000000000000000000015071506127434000211140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,11))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ PreExecutionNode (location: (1,0)-(1,11))
            ├── flags: newline
            ├── statements:
            │   @ StatementsNode (location: (1,8)-(1,9))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ IntegerNode (location: (1,8)-(1,9))
            │           ├── flags: newline, static_literal, decimal
            │           └── value: 1
            ├── keyword_loc: (1,0)-(1,5) = "BEGIN"
            ├── opening_loc: (1,6)-(1,7) = "{"
            └── closing_loc: (1,10)-(1,11) = "}"
prism-1.5.1/snapshots/whitequark/procarg0.txt000066400000000000000000000110671506127434000213430ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,11))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(1,18))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (1,0)-(1,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,2)-(1,18))
        │       ├── flags: ∅
        │       ├── locals: [:foo, :bar]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (1,4)-(1,16))
        │       │   ├── flags: ∅
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (1,5)-(1,15))
        │       │   │   ├── flags: ∅
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ MultiTargetNode (location: (1,5)-(1,15))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       ├── lefts: (length: 2)
        │       │   │   │       │   ├── @ RequiredParameterNode (location: (1,6)-(1,9))
        │       │   │   │       │   │   ├── flags: ∅
        │       │   │   │       │   │   └── name: :foo
        │       │   │   │       │   └── @ RequiredParameterNode (location: (1,11)-(1,14))
        │       │   │   │       │       ├── flags: ∅
        │       │   │   │       │       └── name: :bar
        │       │   │   │       ├── rest: ∅
        │       │   │   │       ├── rights: (length: 0)
        │       │   │   │       ├── lparen_loc: (1,5)-(1,6) = "("
        │       │   │   │       └── rparen_loc: (1,14)-(1,15) = ")"
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (1,4)-(1,5) = "|"
        │       │   └── closing_loc: (1,15)-(1,16) = "|"
        │       ├── body: ∅
        │       ├── opening_loc: (1,2)-(1,3) = "{"
        │       └── closing_loc: (1,17)-(1,18) = "}"
        └── @ CallNode (location: (3,0)-(3,11))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :m
            ├── message_loc: (3,0)-(3,1) = "m"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (3,2)-(3,11))
                ├── flags: ∅
                ├── locals: [:foo]
                ├── parameters:
                │   @ BlockParametersNode (location: (3,4)-(3,9))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (3,5)-(3,8))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (3,5)-(3,8))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :foo
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (3,4)-(3,5) = "|"
                │   └── closing_loc: (3,8)-(3,9) = "|"
                ├── body: ∅
                ├── opening_loc: (3,2)-(3,3) = "{"
                └── closing_loc: (3,10)-(3,11) = "}"
prism-1.5.1/snapshots/whitequark/procarg0_legacy.txt000066400000000000000000000037051506127434000226670ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,8))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,1)-(1,8))
                ├── flags: ∅
                ├── locals: [:a]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,3)-(1,6))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,4)-(1,5))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,4)-(1,5))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :a
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,3)-(1,4) = "|"
                │   └── closing_loc: (1,5)-(1,6) = "|"
                ├── body: ∅
                ├── opening_loc: (1,1)-(1,2) = "{"
                └── closing_loc: (1,7)-(1,8) = "}"
prism-1.5.1/snapshots/whitequark/range_exclusive.txt000066400000000000000000000013451506127434000230070ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ RangeNode (location: (1,0)-(1,5))
            ├── flags: newline, static_literal, exclude_end
            ├── left:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── right:
            │   @ IntegerNode (location: (1,4)-(1,5))
            │   ├── flags: static_literal, decimal
            │   └── value: 2
            └── operator_loc: (1,1)-(1,4) = "..."
prism-1.5.1/snapshots/whitequark/range_inclusive.txt000066400000000000000000000013271506127434000230010ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ RangeNode (location: (1,0)-(1,4))
            ├── flags: newline, static_literal
            ├── left:
            │   @ IntegerNode (location: (1,0)-(1,1))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── right:
            │   @ IntegerNode (location: (1,3)-(1,4))
            │   ├── flags: static_literal, decimal
            │   └── value: 2
            └── operator_loc: (1,1)-(1,3) = ".."
prism-1.5.1/snapshots/whitequark/rational.txt000066400000000000000000000011241506127434000214300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,3))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,3))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ RationalNode (location: (1,0)-(1,5))
        │   ├── flags: newline, static_literal, decimal
        │   ├── numerator: 421
        │   └── denominator: 10
        └── @ RationalNode (location: (3,0)-(3,3))
            ├── flags: newline, static_literal, decimal
            ├── numerator: 42
            └── denominator: 1
prism-1.5.1/snapshots/whitequark/regex_interp.txt000066400000000000000000000044411506127434000223170ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedRegularExpressionNode (location: (1,0)-(1,14))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "/"
            ├── parts: (length: 3)
            │   ├── @ StringNode (location: (1,1)-(1,4))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (1,1)-(1,4) = "foo"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "foo"
            │   ├── @ EmbeddedStatementsNode (location: (1,4)-(1,10))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (1,4)-(1,6) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (1,6)-(1,9))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ CallNode (location: (1,6)-(1,9))
            │   │   │           ├── flags: variable_call, ignore_visibility
            │   │   │           ├── receiver: ∅
            │   │   │           ├── call_operator_loc: ∅
            │   │   │           ├── name: :bar
            │   │   │           ├── message_loc: (1,6)-(1,9) = "bar"
            │   │   │           ├── opening_loc: ∅
            │   │   │           ├── arguments: ∅
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── block: ∅
            │   │   └── closing_loc: (1,9)-(1,10) = "}"
            │   └── @ StringNode (location: (1,10)-(1,13))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (1,10)-(1,13) = "baz"
            │       ├── closing_loc: ∅
            │       └── unescaped: "baz"
            └── closing_loc: (1,13)-(1,14) = "/"
prism-1.5.1/snapshots/whitequark/regex_plain.txt000066400000000000000000000011121506127434000221110ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,10))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ RegularExpressionNode (location: (1,0)-(1,10))
            ├── flags: newline, static_literal, ignore_case, multi_line, forced_us_ascii_encoding
            ├── opening_loc: (1,0)-(1,1) = "/"
            ├── content_loc: (1,1)-(1,7) = "source"
            ├── closing_loc: (1,7)-(1,10) = "/im"
            └── unescaped: "source"
prism-1.5.1/snapshots/whitequark/resbody_list.txt000066400000000000000000000052541506127434000223310ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,39))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,39))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ BeginNode (location: (1,0)-(1,39))
            ├── flags: newline
            ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
            ├── statements:
            │   @ StatementsNode (location: (1,7)-(1,11))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,7)-(1,11))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :meth
            │           ├── message_loc: (1,7)-(1,11) = "meth"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── rescue_clause:
            │   @ RescueNode (location: (1,13)-(1,34))
            │   ├── flags: ∅
            │   ├── keyword_loc: (1,13)-(1,19) = "rescue"
            │   ├── exceptions: (length: 1)
            │   │   └── @ ConstantReadNode (location: (1,20)-(1,29))
            │   │       ├── flags: ∅
            │   │       └── name: :Exception
            │   ├── operator_loc: ∅
            │   ├── reference: ∅
            │   ├── then_keyword_loc: ∅
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,31)-(1,34))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (1,31)-(1,34))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :bar
            │   │           ├── message_loc: (1,31)-(1,34) = "bar"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── subsequent: ∅
            ├── else_clause: ∅
            ├── ensure_clause: ∅
            └── end_keyword_loc: (1,36)-(1,39) = "end"
prism-1.5.1/snapshots/whitequark/resbody_list_mrhs.txt000066400000000000000000000064041506127434000233600ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,44))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,44))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ BeginNode (location: (1,0)-(1,44))
            ├── flags: newline
            ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
            ├── statements:
            │   @ StatementsNode (location: (1,7)-(1,11))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,7)-(1,11))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :meth
            │           ├── message_loc: (1,7)-(1,11) = "meth"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── rescue_clause:
            │   @ RescueNode (location: (1,13)-(1,39))
            │   ├── flags: ∅
            │   ├── keyword_loc: (1,13)-(1,19) = "rescue"
            │   ├── exceptions: (length: 2)
            │   │   ├── @ ConstantReadNode (location: (1,20)-(1,29))
            │   │   │   ├── flags: ∅
            │   │   │   └── name: :Exception
            │   │   └── @ CallNode (location: (1,31)-(1,34))
            │   │       ├── flags: variable_call, ignore_visibility
            │   │       ├── receiver: ∅
            │   │       ├── call_operator_loc: ∅
            │   │       ├── name: :foo
            │   │       ├── message_loc: (1,31)-(1,34) = "foo"
            │   │       ├── opening_loc: ∅
            │   │       ├── arguments: ∅
            │   │       ├── closing_loc: ∅
            │   │       └── block: ∅
            │   ├── operator_loc: ∅
            │   ├── reference: ∅
            │   ├── then_keyword_loc: ∅
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,36)-(1,39))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (1,36)-(1,39))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :bar
            │   │           ├── message_loc: (1,36)-(1,39) = "bar"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── subsequent: ∅
            ├── else_clause: ∅
            ├── ensure_clause: ∅
            └── end_keyword_loc: (1,41)-(1,44) = "end"
prism-1.5.1/snapshots/whitequark/resbody_list_var.txt000066400000000000000000000064511506127434000232010ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,39))
├── flags: ∅
├── locals: [:ex]
└── statements:
    @ StatementsNode (location: (1,0)-(1,39))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ BeginNode (location: (1,0)-(1,39))
            ├── flags: newline
            ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
            ├── statements:
            │   @ StatementsNode (location: (1,7)-(1,11))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,7)-(1,11))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :meth
            │           ├── message_loc: (1,7)-(1,11) = "meth"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── rescue_clause:
            │   @ RescueNode (location: (1,13)-(1,34))
            │   ├── flags: ∅
            │   ├── keyword_loc: (1,13)-(1,19) = "rescue"
            │   ├── exceptions: (length: 1)
            │   │   └── @ CallNode (location: (1,20)-(1,23))
            │   │       ├── flags: variable_call, ignore_visibility
            │   │       ├── receiver: ∅
            │   │       ├── call_operator_loc: ∅
            │   │       ├── name: :foo
            │   │       ├── message_loc: (1,20)-(1,23) = "foo"
            │   │       ├── opening_loc: ∅
            │   │       ├── arguments: ∅
            │   │       ├── closing_loc: ∅
            │   │       └── block: ∅
            │   ├── operator_loc: (1,24)-(1,26) = "=>"
            │   ├── reference:
            │   │   @ LocalVariableTargetNode (location: (1,27)-(1,29))
            │   │   ├── flags: ∅
            │   │   ├── name: :ex
            │   │   └── depth: 0
            │   ├── then_keyword_loc: ∅
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,31)-(1,34))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (1,31)-(1,34))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :bar
            │   │           ├── message_loc: (1,31)-(1,34) = "bar"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── subsequent: ∅
            ├── else_clause: ∅
            ├── ensure_clause: ∅
            └── end_keyword_loc: (1,36)-(1,39) = "end"
prism-1.5.1/snapshots/whitequark/resbody_var.txt000066400000000000000000000124141506127434000221420ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,35))
├── flags: ∅
├── locals: [:ex]
└── statements:
    @ StatementsNode (location: (1,0)-(3,35))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ BeginNode (location: (1,0)-(1,36))
        │   ├── flags: newline
        │   ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (1,7)-(1,11))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (1,7)-(1,11))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :meth
        │   │           ├── message_loc: (1,7)-(1,11) = "meth"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (1,13)-(1,31))
        │   │   ├── flags: ∅
        │   │   ├── keyword_loc: (1,13)-(1,19) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: (1,20)-(1,22) = "=>"
        │   │   ├── reference:
        │   │   │   @ InstanceVariableTargetNode (location: (1,23)-(1,26))
        │   │   │   ├── flags: ∅
        │   │   │   └── name: :@ex
        │   │   ├── then_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (1,28)-(1,31))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (1,28)-(1,31))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :bar
        │   │   │           ├── message_loc: (1,28)-(1,31) = "bar"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── subsequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (1,33)-(1,36) = "end"
        └── @ BeginNode (location: (3,0)-(3,35))
            ├── flags: newline
            ├── begin_keyword_loc: (3,0)-(3,5) = "begin"
            ├── statements:
            │   @ StatementsNode (location: (3,7)-(3,11))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (3,7)-(3,11))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :meth
            │           ├── message_loc: (3,7)-(3,11) = "meth"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── rescue_clause:
            │   @ RescueNode (location: (3,13)-(3,30))
            │   ├── flags: ∅
            │   ├── keyword_loc: (3,13)-(3,19) = "rescue"
            │   ├── exceptions: (length: 0)
            │   ├── operator_loc: (3,20)-(3,22) = "=>"
            │   ├── reference:
            │   │   @ LocalVariableTargetNode (location: (3,23)-(3,25))
            │   │   ├── flags: ∅
            │   │   ├── name: :ex
            │   │   └── depth: 0
            │   ├── then_keyword_loc: ∅
            │   ├── statements:
            │   │   @ StatementsNode (location: (3,27)-(3,30))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (3,27)-(3,30))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :bar
            │   │           ├── message_loc: (3,27)-(3,30) = "bar"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── subsequent: ∅
            ├── else_clause: ∅
            ├── ensure_clause: ∅
            └── end_keyword_loc: (3,32)-(3,35) = "end"
prism-1.5.1/snapshots/whitequark/rescue.txt000066400000000000000000000047651506127434000211230ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,29))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,29))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ BeginNode (location: (1,0)-(1,29))
            ├── flags: newline
            ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
            ├── statements:
            │   @ StatementsNode (location: (1,7)-(1,11))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,7)-(1,11))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :meth
            │           ├── message_loc: (1,7)-(1,11) = "meth"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── rescue_clause:
            │   @ RescueNode (location: (1,13)-(1,24))
            │   ├── flags: ∅
            │   ├── keyword_loc: (1,13)-(1,19) = "rescue"
            │   ├── exceptions: (length: 0)
            │   ├── operator_loc: ∅
            │   ├── reference: ∅
            │   ├── then_keyword_loc: ∅
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,21)-(1,24))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (1,21)-(1,24))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :foo
            │   │           ├── message_loc: (1,21)-(1,24) = "foo"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── subsequent: ∅
            ├── else_clause: ∅
            ├── ensure_clause: ∅
            └── end_keyword_loc: (1,26)-(1,29) = "end"
prism-1.5.1/snapshots/whitequark/rescue_else.txt000066400000000000000000000070501506127434000221210ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,40))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,40))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ BeginNode (location: (1,0)-(1,40))
            ├── flags: newline
            ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
            ├── statements:
            │   @ StatementsNode (location: (1,7)-(1,11))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,7)-(1,11))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :meth
            │           ├── message_loc: (1,7)-(1,11) = "meth"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── rescue_clause:
            │   @ RescueNode (location: (1,13)-(1,24))
            │   ├── flags: ∅
            │   ├── keyword_loc: (1,13)-(1,19) = "rescue"
            │   ├── exceptions: (length: 0)
            │   ├── operator_loc: ∅
            │   ├── reference: ∅
            │   ├── then_keyword_loc: ∅
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,21)-(1,24))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (1,21)-(1,24))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :foo
            │   │           ├── message_loc: (1,21)-(1,24) = "foo"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── subsequent: ∅
            ├── else_clause:
            │   @ ElseNode (location: (1,26)-(1,40))
            │   ├── flags: ∅
            │   ├── else_keyword_loc: (1,26)-(1,30) = "else"
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,32)-(1,35))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (1,32)-(1,35))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :bar
            │   │           ├── message_loc: (1,32)-(1,35) = "bar"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── end_keyword_loc: (1,37)-(1,40) = "end"
            ├── ensure_clause: ∅
            └── end_keyword_loc: (1,37)-(1,40) = "end"
prism-1.5.1/snapshots/whitequark/rescue_else_ensure.txt000066400000000000000000000111441506127434000235010ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,51))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,51))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ BeginNode (location: (1,0)-(1,51))
            ├── flags: newline
            ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
            ├── statements:
            │   @ StatementsNode (location: (1,7)-(1,11))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,7)-(1,11))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :meth
            │           ├── message_loc: (1,7)-(1,11) = "meth"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── rescue_clause:
            │   @ RescueNode (location: (1,13)-(1,24))
            │   ├── flags: ∅
            │   ├── keyword_loc: (1,13)-(1,19) = "rescue"
            │   ├── exceptions: (length: 0)
            │   ├── operator_loc: ∅
            │   ├── reference: ∅
            │   ├── then_keyword_loc: ∅
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,21)-(1,24))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (1,21)-(1,24))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :baz
            │   │           ├── message_loc: (1,21)-(1,24) = "baz"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── subsequent: ∅
            ├── else_clause:
            │   @ ElseNode (location: (1,26)-(1,42))
            │   ├── flags: ∅
            │   ├── else_keyword_loc: (1,26)-(1,30) = "else"
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,31)-(1,34))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (1,31)-(1,34))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :foo
            │   │           ├── message_loc: (1,31)-(1,34) = "foo"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── end_keyword_loc: (1,36)-(1,42) = "ensure"
            ├── ensure_clause:
            │   @ EnsureNode (location: (1,36)-(1,51))
            │   ├── flags: ∅
            │   ├── ensure_keyword_loc: (1,36)-(1,42) = "ensure"
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,44)-(1,47))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (1,44)-(1,47))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :bar
            │   │           ├── message_loc: (1,44)-(1,47) = "bar"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── end_keyword_loc: (1,48)-(1,51) = "end"
            └── end_keyword_loc: (1,48)-(1,51) = "end"
prism-1.5.1/snapshots/whitequark/rescue_ensure.txt000066400000000000000000000070561506127434000225000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,42))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,42))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ BeginNode (location: (1,0)-(1,42))
            ├── flags: newline
            ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
            ├── statements:
            │   @ StatementsNode (location: (1,7)-(1,11))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,7)-(1,11))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :meth
            │           ├── message_loc: (1,7)-(1,11) = "meth"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── rescue_clause:
            │   @ RescueNode (location: (1,13)-(1,24))
            │   ├── flags: ∅
            │   ├── keyword_loc: (1,13)-(1,19) = "rescue"
            │   ├── exceptions: (length: 0)
            │   ├── operator_loc: ∅
            │   ├── reference: ∅
            │   ├── then_keyword_loc: ∅
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,21)-(1,24))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (1,21)-(1,24))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :baz
            │   │           ├── message_loc: (1,21)-(1,24) = "baz"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── subsequent: ∅
            ├── else_clause: ∅
            ├── ensure_clause:
            │   @ EnsureNode (location: (1,26)-(1,42))
            │   ├── flags: ∅
            │   ├── ensure_keyword_loc: (1,26)-(1,32) = "ensure"
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,34)-(1,37))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (1,34)-(1,37))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :bar
            │   │           ├── message_loc: (1,34)-(1,37) = "bar"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── end_keyword_loc: (1,39)-(1,42) = "end"
            └── end_keyword_loc: (1,39)-(1,42) = "end"
prism-1.5.1/snapshots/whitequark/rescue_in_lambda_block.txt000066400000000000000000000026061506127434000242530ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,17))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,17))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LambdaNode (location: (1,0)-(1,17))
            ├── flags: newline
            ├── locals: []
            ├── operator_loc: (1,0)-(1,2) = "->"
            ├── opening_loc: (1,3)-(1,5) = "do"
            ├── closing_loc: (1,14)-(1,17) = "end"
            ├── parameters: ∅
            └── body:
                @ BeginNode (location: (1,3)-(1,17))
                ├── flags: ∅
                ├── begin_keyword_loc: ∅
                ├── statements: ∅
                ├── rescue_clause:
                │   @ RescueNode (location: (1,6)-(1,12))
                │   ├── flags: ∅
                │   ├── keyword_loc: (1,6)-(1,12) = "rescue"
                │   ├── exceptions: (length: 0)
                │   ├── operator_loc: ∅
                │   ├── reference: ∅
                │   ├── then_keyword_loc: ∅
                │   ├── statements: ∅
                │   └── subsequent: ∅
                ├── else_clause: ∅
                ├── ensure_clause: ∅
                └── end_keyword_loc: (1,14)-(1,17) = "end"
prism-1.5.1/snapshots/whitequark/rescue_mod.txt000066400000000000000000000025671506127434000217600ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,15))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ RescueModifierNode (location: (1,0)-(1,15))
            ├── flags: newline
            ├── expression:
            │   @ CallNode (location: (1,0)-(1,4))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :meth
            │   ├── message_loc: (1,0)-(1,4) = "meth"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── keyword_loc: (1,5)-(1,11) = "rescue"
            └── rescue_expression:
                @ CallNode (location: (1,12)-(1,15))
                ├── flags: variable_call, ignore_visibility
                ├── receiver: ∅
                ├── call_operator_loc: ∅
                ├── name: :bar
                ├── message_loc: (1,12)-(1,15) = "bar"
                ├── opening_loc: ∅
                ├── arguments: ∅
                ├── closing_loc: ∅
                └── block: ∅
prism-1.5.1/snapshots/whitequark/rescue_mod_asgn.txt000066400000000000000000000034721506127434000227640ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,21))
├── flags: ∅
├── locals: [:foo]
└── statements:
    @ StatementsNode (location: (1,0)-(1,21))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LocalVariableWriteNode (location: (1,0)-(1,21))
            ├── flags: newline
            ├── name: :foo
            ├── depth: 0
            ├── name_loc: (1,0)-(1,3) = "foo"
            ├── value:
            │   @ RescueModifierNode (location: (1,6)-(1,21))
            │   ├── flags: ∅
            │   ├── expression:
            │   │   @ CallNode (location: (1,6)-(1,10))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :meth
            │   │   ├── message_loc: (1,6)-(1,10) = "meth"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── keyword_loc: (1,11)-(1,17) = "rescue"
            │   └── rescue_expression:
            │       @ CallNode (location: (1,18)-(1,21))
            │       ├── flags: variable_call, ignore_visibility
            │       ├── receiver: ∅
            │       ├── call_operator_loc: ∅
            │       ├── name: :bar
            │       ├── message_loc: (1,18)-(1,21) = "bar"
            │       ├── opening_loc: ∅
            │       ├── arguments: ∅
            │       ├── closing_loc: ∅
            │       └── block: ∅
            └── operator_loc: (1,4)-(1,5) = "="
prism-1.5.1/snapshots/whitequark/rescue_mod_masgn.txt000066400000000000000000000046431506127434000231420ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,29))
├── flags: ∅
├── locals: [:foo, :bar]
└── statements:
    @ StatementsNode (location: (1,0)-(1,29))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ MultiWriteNode (location: (1,0)-(1,29))
            ├── flags: newline
            ├── lefts: (length: 2)
            │   ├── @ LocalVariableTargetNode (location: (1,0)-(1,3))
            │   │   ├── flags: ∅
            │   │   ├── name: :foo
            │   │   └── depth: 0
            │   └── @ LocalVariableTargetNode (location: (1,5)-(1,8))
            │       ├── flags: ∅
            │       ├── name: :bar
            │       └── depth: 0
            ├── rest: ∅
            ├── rights: (length: 0)
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── operator_loc: (1,9)-(1,10) = "="
            └── value:
                @ RescueModifierNode (location: (1,11)-(1,29))
                ├── flags: ∅
                ├── expression:
                │   @ CallNode (location: (1,11)-(1,15))
                │   ├── flags: variable_call, ignore_visibility
                │   ├── receiver: ∅
                │   ├── call_operator_loc: ∅
                │   ├── name: :meth
                │   ├── message_loc: (1,11)-(1,15) = "meth"
                │   ├── opening_loc: ∅
                │   ├── arguments: ∅
                │   ├── closing_loc: ∅
                │   └── block: ∅
                ├── keyword_loc: (1,16)-(1,22) = "rescue"
                └── rescue_expression:
                    @ ArrayNode (location: (1,23)-(1,29))
                    ├── flags: static_literal
                    ├── elements: (length: 2)
                    │   ├── @ IntegerNode (location: (1,24)-(1,25))
                    │   │   ├── flags: static_literal, decimal
                    │   │   └── value: 1
                    │   └── @ IntegerNode (location: (1,27)-(1,28))
                    │       ├── flags: static_literal, decimal
                    │       └── value: 2
                    ├── opening_loc: (1,23)-(1,24) = "["
                    └── closing_loc: (1,28)-(1,29) = "]"
prism-1.5.1/snapshots/whitequark/rescue_mod_op_assign.txt000066400000000000000000000035641506127434000240200ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,22))
├── flags: ∅
├── locals: [:foo]
└── statements:
    @ StatementsNode (location: (1,0)-(1,22))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LocalVariableOperatorWriteNode (location: (1,0)-(1,22))
            ├── flags: newline
            ├── name_loc: (1,0)-(1,3) = "foo"
            ├── binary_operator_loc: (1,4)-(1,6) = "+="
            ├── value:
            │   @ RescueModifierNode (location: (1,7)-(1,22))
            │   ├── flags: ∅
            │   ├── expression:
            │   │   @ CallNode (location: (1,7)-(1,11))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :meth
            │   │   ├── message_loc: (1,7)-(1,11) = "meth"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── keyword_loc: (1,12)-(1,18) = "rescue"
            │   └── rescue_expression:
            │       @ CallNode (location: (1,19)-(1,22))
            │       ├── flags: variable_call, ignore_visibility
            │       ├── receiver: ∅
            │       ├── call_operator_loc: ∅
            │       ├── name: :bar
            │       ├── message_loc: (1,19)-(1,22) = "bar"
            │       ├── opening_loc: ∅
            │       ├── arguments: ∅
            │       ├── closing_loc: ∅
            │       └── block: ∅
            ├── name: :foo
            ├── binary_operator: :+
            └── depth: 0
prism-1.5.1/snapshots/whitequark/rescue_without_begin_end.txt000066400000000000000000000071561506127434000246750ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,30))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,30))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,30))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :meth
            ├── message_loc: (1,0)-(1,4) = "meth"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,5)-(1,30))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body:
                │   @ BeginNode (location: (1,5)-(1,30))
                │   ├── flags: ∅
                │   ├── begin_keyword_loc: ∅
                │   ├── statements:
                │   │   @ StatementsNode (location: (1,9)-(1,12))
                │   │   ├── flags: ∅
                │   │   └── body: (length: 1)
                │   │       └── @ CallNode (location: (1,9)-(1,12))
                │   │           ├── flags: newline, variable_call, ignore_visibility
                │   │           ├── receiver: ∅
                │   │           ├── call_operator_loc: ∅
                │   │           ├── name: :foo
                │   │           ├── message_loc: (1,9)-(1,12) = "foo"
                │   │           ├── opening_loc: ∅
                │   │           ├── arguments: ∅
                │   │           ├── closing_loc: ∅
                │   │           └── block: ∅
                │   ├── rescue_clause:
                │   │   @ RescueNode (location: (1,14)-(1,25))
                │   │   ├── flags: ∅
                │   │   ├── keyword_loc: (1,14)-(1,20) = "rescue"
                │   │   ├── exceptions: (length: 0)
                │   │   ├── operator_loc: ∅
                │   │   ├── reference: ∅
                │   │   ├── then_keyword_loc: ∅
                │   │   ├── statements:
                │   │   │   @ StatementsNode (location: (1,22)-(1,25))
                │   │   │   ├── flags: ∅
                │   │   │   └── body: (length: 1)
                │   │   │       └── @ CallNode (location: (1,22)-(1,25))
                │   │   │           ├── flags: newline, variable_call, ignore_visibility
                │   │   │           ├── receiver: ∅
                │   │   │           ├── call_operator_loc: ∅
                │   │   │           ├── name: :bar
                │   │   │           ├── message_loc: (1,22)-(1,25) = "bar"
                │   │   │           ├── opening_loc: ∅
                │   │   │           ├── arguments: ∅
                │   │   │           ├── closing_loc: ∅
                │   │   │           └── block: ∅
                │   │   └── subsequent: ∅
                │   ├── else_clause: ∅
                │   ├── ensure_clause: ∅
                │   └── end_keyword_loc: (1,27)-(1,30) = "end"
                ├── opening_loc: (1,5)-(1,7) = "do"
                └── closing_loc: (1,27)-(1,30) = "end"
prism-1.5.1/snapshots/whitequark/restarg_named.txt000066400000000000000000000027661506127434000224470ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,16))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,16))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,16))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (1,4)-(1,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,10))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest:
            │   │   @ RestParameterNode (location: (1,6)-(1,10))
            │   │   ├── flags: ∅
            │   │   ├── name: :foo
            │   │   ├── name_loc: (1,7)-(1,10) = "foo"
            │   │   └── operator_loc: (1,6)-(1,7) = "*"
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: [:foo]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,10)-(1,11) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,13)-(1,16) = "end"
prism-1.5.1/snapshots/whitequark/restarg_unnamed.txt000066400000000000000000000027341506127434000230050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,13))
            ├── flags: newline
            ├── name: :f
            ├── name_loc: (1,4)-(1,5) = "f"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,6)-(1,7))
            │   ├── flags: ∅
            │   ├── requireds: (length: 0)
            │   ├── optionals: (length: 0)
            │   ├── rest:
            │   │   @ RestParameterNode (location: (1,6)-(1,7))
            │   │   ├── flags: ∅
            │   │   ├── name: ∅
            │   │   ├── name_loc: ∅
            │   │   └── operator_loc: (1,6)-(1,7) = "*"
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body: ∅
            ├── locals: []
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,5)-(1,6) = "("
            ├── rparen_loc: (1,7)-(1,8) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,10)-(1,13) = "end"
prism-1.5.1/snapshots/whitequark/return.txt000066400000000000000000000065731506127434000211530ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(7,11))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ ReturnNode (location: (1,0)-(1,6))
        │   ├── flags: newline
        │   ├── keyword_loc: (1,0)-(1,6) = "return"
        │   └── arguments: ∅
        ├── @ ReturnNode (location: (3,0)-(3,10))
        │   ├── flags: newline
        │   ├── keyword_loc: (3,0)-(3,6) = "return"
        │   └── arguments:
        │       @ ArgumentsNode (location: (3,7)-(3,10))
        │       ├── flags: ∅
        │       └── arguments: (length: 1)
        │           └── @ CallNode (location: (3,7)-(3,10))
        │               ├── flags: variable_call, ignore_visibility
        │               ├── receiver: ∅
        │               ├── call_operator_loc: ∅
        │               ├── name: :foo
        │               ├── message_loc: (3,7)-(3,10) = "foo"
        │               ├── opening_loc: ∅
        │               ├── arguments: ∅
        │               ├── closing_loc: ∅
        │               └── block: ∅
        ├── @ ReturnNode (location: (5,0)-(5,8))
        │   ├── flags: newline
        │   ├── keyword_loc: (5,0)-(5,6) = "return"
        │   └── arguments:
        │       @ ArgumentsNode (location: (5,6)-(5,8))
        │       ├── flags: ∅
        │       └── arguments: (length: 1)
        │           └── @ ParenthesesNode (location: (5,6)-(5,8))
        │               ├── flags: ∅
        │               ├── body: ∅
        │               ├── opening_loc: (5,6)-(5,7) = "("
        │               └── closing_loc: (5,7)-(5,8) = ")"
        └── @ ReturnNode (location: (7,0)-(7,11))
            ├── flags: newline
            ├── keyword_loc: (7,0)-(7,6) = "return"
            └── arguments:
                @ ArgumentsNode (location: (7,6)-(7,11))
                ├── flags: ∅
                └── arguments: (length: 1)
                    └── @ ParenthesesNode (location: (7,6)-(7,11))
                        ├── flags: ∅
                        ├── body:
                        │   @ StatementsNode (location: (7,7)-(7,10))
                        │   ├── flags: ∅
                        │   └── body: (length: 1)
                        │       └── @ CallNode (location: (7,7)-(7,10))
                        │           ├── flags: newline, variable_call, ignore_visibility
                        │           ├── receiver: ∅
                        │           ├── call_operator_loc: ∅
                        │           ├── name: :foo
                        │           ├── message_loc: (7,7)-(7,10) = "foo"
                        │           ├── opening_loc: ∅
                        │           ├── arguments: ∅
                        │           ├── closing_loc: ∅
                        │           └── block: ∅
                        ├── opening_loc: (7,6)-(7,7) = "("
                        └── closing_loc: (7,10)-(7,11) = ")"
prism-1.5.1/snapshots/whitequark/return_block.txt000066400000000000000000000044651506127434000223230ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,21))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,21))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ReturnNode (location: (1,0)-(1,21))
            ├── flags: newline
            ├── keyword_loc: (1,0)-(1,6) = "return"
            └── arguments:
                @ ArgumentsNode (location: (1,7)-(1,21))
                ├── flags: ∅
                └── arguments: (length: 1)
                    └── @ CallNode (location: (1,7)-(1,21))
                        ├── flags: ignore_visibility
                        ├── receiver: ∅
                        ├── call_operator_loc: ∅
                        ├── name: :fun
                        ├── message_loc: (1,7)-(1,10) = "fun"
                        ├── opening_loc: ∅
                        ├── arguments:
                        │   @ ArgumentsNode (location: (1,11)-(1,14))
                        │   ├── flags: ∅
                        │   └── arguments: (length: 1)
                        │       └── @ CallNode (location: (1,11)-(1,14))
                        │           ├── flags: variable_call, ignore_visibility
                        │           ├── receiver: ∅
                        │           ├── call_operator_loc: ∅
                        │           ├── name: :foo
                        │           ├── message_loc: (1,11)-(1,14) = "foo"
                        │           ├── opening_loc: ∅
                        │           ├── arguments: ∅
                        │           ├── closing_loc: ∅
                        │           └── block: ∅
                        ├── closing_loc: ∅
                        └── block:
                            @ BlockNode (location: (1,15)-(1,21))
                            ├── flags: ∅
                            ├── locals: []
                            ├── parameters: ∅
                            ├── body: ∅
                            ├── opening_loc: (1,15)-(1,17) = "do"
                            └── closing_loc: (1,18)-(1,21) = "end"
prism-1.5.1/snapshots/whitequark/ruby_bug_10279.txt000066400000000000000000000041431506127434000222030ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,24))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,24))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ HashNode (location: (1,0)-(1,24))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "{"
            ├── elements: (length: 1)
            │   └── @ AssocNode (location: (1,1)-(1,23))
            │       ├── flags: ∅
            │       ├── key:
            │       │   @ SymbolNode (location: (1,1)-(1,3))
            │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │       │   ├── opening_loc: ∅
            │       │   ├── value_loc: (1,1)-(1,2) = "a"
            │       │   ├── closing_loc: (1,2)-(1,3) = ":"
            │       │   └── unescaped: "a"
            │       ├── value:
            │       │   @ IfNode (location: (1,4)-(1,23))
            │       │   ├── flags: newline
            │       │   ├── if_keyword_loc: (1,4)-(1,6) = "if"
            │       │   ├── predicate:
            │       │   │   @ TrueNode (location: (1,7)-(1,11))
            │       │   │   └── flags: static_literal
            │       │   ├── then_keyword_loc: (1,12)-(1,16) = "then"
            │       │   ├── statements:
            │       │   │   @ StatementsNode (location: (1,17)-(1,19))
            │       │   │   ├── flags: ∅
            │       │   │   └── body: (length: 1)
            │       │   │       └── @ IntegerNode (location: (1,17)-(1,19))
            │       │   │           ├── flags: newline, static_literal, decimal
            │       │   │           └── value: 42
            │       │   ├── subsequent: ∅
            │       │   └── end_keyword_loc: (1,20)-(1,23) = "end"
            │       └── operator_loc: ∅
            └── closing_loc: (1,23)-(1,24) = "}"
prism-1.5.1/snapshots/whitequark/ruby_bug_10653.txt000066400000000000000000000270271506127434000222050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,31))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,31))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ IfNode (location: (1,0)-(1,33))
        │   ├── flags: newline
        │   ├── if_keyword_loc: ∅
        │   ├── predicate:
        │   │   @ FalseNode (location: (1,0)-(1,5))
        │   │   └── flags: static_literal
        │   ├── then_keyword_loc: (1,6)-(1,7) = "?"
        │   ├── statements:
        │   │   @ StatementsNode (location: (1,8)-(1,20))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (1,8)-(1,20))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :raise
        │   │           ├── message_loc: (1,8)-(1,13) = "raise"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (1,14)-(1,20))
        │   │               ├── flags: ∅
        │   │               ├── locals: []
        │   │               ├── parameters: ∅
        │   │               ├── body: ∅
        │   │               ├── opening_loc: (1,14)-(1,16) = "do"
        │   │               └── closing_loc: (1,17)-(1,20) = "end"
        │   ├── subsequent:
        │   │   @ ElseNode (location: (1,21)-(1,33))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (1,21)-(1,22) = ":"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (1,23)-(1,33))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (1,23)-(1,33))
        │   │   │           ├── flags: newline, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :tap
        │   │   │           ├── message_loc: (1,23)-(1,26) = "tap"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block:
        │   │   │               @ BlockNode (location: (1,27)-(1,33))
        │   │   │               ├── flags: ∅
        │   │   │               ├── locals: []
        │   │   │               ├── parameters: ∅
        │   │   │               ├── body: ∅
        │   │   │               ├── opening_loc: (1,27)-(1,29) = "do"
        │   │   │               └── closing_loc: (1,30)-(1,33) = "end"
        │   │   └── end_keyword_loc: ∅
        │   └── end_keyword_loc: ∅
        ├── @ IfNode (location: (3,0)-(3,25))
        │   ├── flags: newline
        │   ├── if_keyword_loc: ∅
        │   ├── predicate:
        │   │   @ FalseNode (location: (3,0)-(3,5))
        │   │   └── flags: static_literal
        │   ├── then_keyword_loc: (3,6)-(3,7) = "?"
        │   ├── statements:
        │   │   @ StatementsNode (location: (3,8)-(3,16))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (3,8)-(3,16))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :raise
        │   │           ├── message_loc: (3,8)-(3,13) = "raise"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block:
        │   │               @ BlockNode (location: (3,14)-(3,16))
        │   │               ├── flags: ∅
        │   │               ├── locals: []
        │   │               ├── parameters: ∅
        │   │               ├── body: ∅
        │   │               ├── opening_loc: (3,14)-(3,15) = "{"
        │   │               └── closing_loc: (3,15)-(3,16) = "}"
        │   ├── subsequent:
        │   │   @ ElseNode (location: (3,17)-(3,25))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (3,17)-(3,18) = ":"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (3,19)-(3,25))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (3,19)-(3,25))
        │   │   │           ├── flags: newline, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :tap
        │   │   │           ├── message_loc: (3,19)-(3,22) = "tap"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block:
        │   │   │               @ BlockNode (location: (3,23)-(3,25))
        │   │   │               ├── flags: ∅
        │   │   │               ├── locals: []
        │   │   │               ├── parameters: ∅
        │   │   │               ├── body: ∅
        │   │   │               ├── opening_loc: (3,23)-(3,24) = "{"
        │   │   │               └── closing_loc: (3,24)-(3,25) = "}"
        │   │   └── end_keyword_loc: ∅
        │   └── end_keyword_loc: ∅
        └── @ IfNode (location: (5,0)-(5,31))
            ├── flags: newline
            ├── if_keyword_loc: ∅
            ├── predicate:
            │   @ TrueNode (location: (5,0)-(5,4))
            │   └── flags: static_literal
            ├── then_keyword_loc: (5,5)-(5,6) = "?"
            ├── statements:
            │   @ StatementsNode (location: (5,7)-(5,27))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (5,7)-(5,27))
            │           ├── flags: newline
            │           ├── receiver:
            │           │   @ IntegerNode (location: (5,7)-(5,8))
            │           │   ├── flags: static_literal, decimal
            │           │   └── value: 1
            │           ├── call_operator_loc: (5,8)-(5,9) = "."
            │           ├── name: :tap
            │           ├── message_loc: (5,9)-(5,12) = "tap"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block:
            │               @ BlockNode (location: (5,13)-(5,27))
            │               ├── flags: ∅
            │               ├── locals: [:n]
            │               ├── parameters:
            │               │   @ BlockParametersNode (location: (5,16)-(5,19))
            │               │   ├── flags: ∅
            │               │   ├── parameters:
            │               │   │   @ ParametersNode (location: (5,17)-(5,18))
            │               │   │   ├── flags: ∅
            │               │   │   ├── requireds: (length: 1)
            │               │   │   │   └── @ RequiredParameterNode (location: (5,17)-(5,18))
            │               │   │   │       ├── flags: ∅
            │               │   │   │       └── name: :n
            │               │   │   ├── optionals: (length: 0)
            │               │   │   ├── rest: ∅
            │               │   │   ├── posts: (length: 0)
            │               │   │   ├── keywords: (length: 0)
            │               │   │   ├── keyword_rest: ∅
            │               │   │   └── block: ∅
            │               │   ├── locals: (length: 0)
            │               │   ├── opening_loc: (5,16)-(5,17) = "|"
            │               │   └── closing_loc: (5,18)-(5,19) = "|"
            │               ├── body:
            │               │   @ StatementsNode (location: (5,20)-(5,23))
            │               │   ├── flags: ∅
            │               │   └── body: (length: 1)
            │               │       └── @ CallNode (location: (5,20)-(5,23))
            │               │           ├── flags: newline, ignore_visibility
            │               │           ├── receiver: ∅
            │               │           ├── call_operator_loc: ∅
            │               │           ├── name: :p
            │               │           ├── message_loc: (5,20)-(5,21) = "p"
            │               │           ├── opening_loc: ∅
            │               │           ├── arguments:
            │               │           │   @ ArgumentsNode (location: (5,22)-(5,23))
            │               │           │   ├── flags: ∅
            │               │           │   └── arguments: (length: 1)
            │               │           │       └── @ LocalVariableReadNode (location: (5,22)-(5,23))
            │               │           │           ├── flags: ∅
            │               │           │           ├── name: :n
            │               │           │           └── depth: 0
            │               │           ├── closing_loc: ∅
            │               │           └── block: ∅
            │               ├── opening_loc: (5,13)-(5,15) = "do"
            │               └── closing_loc: (5,24)-(5,27) = "end"
            ├── subsequent:
            │   @ ElseNode (location: (5,28)-(5,31))
            │   ├── flags: ∅
            │   ├── else_keyword_loc: (5,28)-(5,29) = ":"
            │   ├── statements:
            │   │   @ StatementsNode (location: (5,30)-(5,31))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ IntegerNode (location: (5,30)-(5,31))
            │   │           ├── flags: newline, static_literal, decimal
            │   │           └── value: 0
            │   └── end_keyword_loc: ∅
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/whitequark/ruby_bug_11107.txt000066400000000000000000000057361506127434000222030ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,24))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,24))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,24))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :p
            ├── message_loc: (1,0)-(1,1) = "p"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,24))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ LambdaNode (location: (1,2)-(1,24))
            │           ├── flags: ∅
            │           ├── locals: []
            │           ├── operator_loc: (1,2)-(1,4) = "->"
            │           ├── opening_loc: (1,7)-(1,9) = "do"
            │           ├── closing_loc: (1,21)-(1,24) = "end"
            │           ├── parameters:
            │           │   @ BlockParametersNode (location: (1,4)-(1,6))
            │           │   ├── flags: ∅
            │           │   ├── parameters: ∅
            │           │   ├── locals: (length: 0)
            │           │   ├── opening_loc: (1,4)-(1,5) = "("
            │           │   └── closing_loc: (1,5)-(1,6) = ")"
            │           └── body:
            │               @ StatementsNode (location: (1,10)-(1,20))
            │               ├── flags: ∅
            │               └── body: (length: 1)
            │                   └── @ CallNode (location: (1,10)-(1,20))
            │                       ├── flags: newline, ignore_visibility
            │                       ├── receiver: ∅
            │                       ├── call_operator_loc: ∅
            │                       ├── name: :a
            │                       ├── message_loc: (1,10)-(1,11) = "a"
            │                       ├── opening_loc: (1,11)-(1,12) = "("
            │                       ├── arguments: ∅
            │                       ├── closing_loc: (1,12)-(1,13) = ")"
            │                       └── block:
            │                           @ BlockNode (location: (1,14)-(1,20))
            │                           ├── flags: ∅
            │                           ├── locals: []
            │                           ├── parameters: ∅
            │                           ├── body: ∅
            │                           ├── opening_loc: (1,14)-(1,16) = "do"
            │                           └── closing_loc: (1,17)-(1,20) = "end"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/ruby_bug_11380.txt000066400000000000000000000065771506127434000222120ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,28))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,28))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,28))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :p
            ├── message_loc: (1,0)-(1,1) = "p"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,21))
            │   ├── flags: contains_keywords
            │   └── arguments: (length: 2)
            │       ├── @ LambdaNode (location: (1,2)-(1,15))
            │       │   ├── flags: ∅
            │       │   ├── locals: []
            │       │   ├── operator_loc: (1,2)-(1,4) = "->"
            │       │   ├── opening_loc: (1,5)-(1,6) = "{"
            │       │   ├── closing_loc: (1,14)-(1,15) = "}"
            │       │   ├── parameters: ∅
            │       │   └── body:
            │       │       @ StatementsNode (location: (1,7)-(1,13))
            │       │       ├── flags: ∅
            │       │       └── body: (length: 1)
            │       │           └── @ SymbolNode (location: (1,7)-(1,13))
            │       │               ├── flags: newline, static_literal, forced_us_ascii_encoding
            │       │               ├── opening_loc: (1,7)-(1,8) = ":"
            │       │               ├── value_loc: (1,8)-(1,13) = "hello"
            │       │               ├── closing_loc: ∅
            │       │               └── unescaped: "hello"
            │       └── @ KeywordHashNode (location: (1,17)-(1,21))
            │           ├── flags: symbol_keys
            │           └── elements: (length: 1)
            │               └── @ AssocNode (location: (1,17)-(1,21))
            │                   ├── flags: static_literal
            │                   ├── key:
            │                   │   @ SymbolNode (location: (1,17)-(1,19))
            │                   │   ├── flags: static_literal, forced_us_ascii_encoding
            │                   │   ├── opening_loc: ∅
            │                   │   ├── value_loc: (1,17)-(1,18) = "a"
            │                   │   ├── closing_loc: (1,18)-(1,19) = ":"
            │                   │   └── unescaped: "a"
            │                   ├── value:
            │                   │   @ IntegerNode (location: (1,20)-(1,21))
            │                   │   ├── flags: static_literal, decimal
            │                   │   └── value: 1
            │                   └── operator_loc: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,22)-(1,28))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (1,22)-(1,24) = "do"
                └── closing_loc: (1,25)-(1,28) = "end"
prism-1.5.1/snapshots/whitequark/ruby_bug_11873.txt000066400000000000000000001455331506127434000222150ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(23,22))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(23,22))
    ├── flags: ∅
    └── body: (length: 12)
        ├── @ CallNode (location: (1,0)-(1,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (1,0)-(1,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(1,13))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (1,2)-(1,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (1,2)-(1,3) = "b"
        │   │       │   ├── opening_loc: (1,3)-(1,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (1,4)-(1,7))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (1,4)-(1,7))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (1,4)-(1,5) = "c"
        │   │       │   │           ├── opening_loc: ∅
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (1,6)-(1,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (1,6)-(1,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (1,6)-(1,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: ∅
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (1,7)-(1,8) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ StringNode (location: (1,10)-(1,13))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (1,10)-(1,11) = "\""
        │   │           ├── content_loc: (1,11)-(1,12) = "x"
        │   │           ├── closing_loc: (1,12)-(1,13) = "\""
        │   │           └── unescaped: "x"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,14)-(1,20))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (1,14)-(1,16) = "do"
        │       └── closing_loc: (1,17)-(1,20) = "end"
        ├── @ CallNode (location: (3,0)-(3,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (3,0)-(3,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,2)-(3,13))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (3,2)-(3,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (3,2)-(3,3) = "b"
        │   │       │   ├── opening_loc: (3,3)-(3,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (3,4)-(3,7))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (3,4)-(3,7))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (3,4)-(3,5) = "c"
        │   │       │   │           ├── opening_loc: ∅
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (3,6)-(3,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (3,6)-(3,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (3,6)-(3,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: ∅
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (3,7)-(3,8) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ RegularExpressionNode (location: (3,10)-(3,13))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (3,10)-(3,11) = "/"
        │   │           ├── content_loc: (3,11)-(3,12) = "x"
        │   │           ├── closing_loc: (3,12)-(3,13) = "/"
        │   │           └── unescaped: "x"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (3,14)-(3,20))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (3,14)-(3,16) = "do"
        │       └── closing_loc: (3,17)-(3,20) = "end"
        ├── @ CallNode (location: (5,0)-(5,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (5,0)-(5,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (5,2)-(5,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (5,2)-(5,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (5,2)-(5,3) = "b"
        │   │       │   ├── opening_loc: (5,3)-(5,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (5,4)-(5,7))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (5,4)-(5,7))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (5,4)-(5,5) = "c"
        │   │       │   │           ├── opening_loc: ∅
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (5,6)-(5,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (5,6)-(5,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (5,6)-(5,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: ∅
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (5,7)-(5,8) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ RegularExpressionNode (location: (5,10)-(5,14))
        │   │           ├── flags: static_literal, multi_line, forced_us_ascii_encoding
        │   │           ├── opening_loc: (5,10)-(5,11) = "/"
        │   │           ├── content_loc: (5,11)-(5,12) = "x"
        │   │           ├── closing_loc: (5,12)-(5,14) = "/m"
        │   │           └── unescaped: "x"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (5,15)-(5,21))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (5,15)-(5,17) = "do"
        │       └── closing_loc: (5,18)-(5,21) = "end"
        ├── @ CallNode (location: (7,0)-(7,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (7,0)-(7,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (7,2)-(7,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (7,2)-(7,9))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (7,2)-(7,3) = "b"
        │   │       │   ├── opening_loc: (7,3)-(7,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (7,4)-(7,8))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (7,4)-(7,8))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (7,4)-(7,5) = "c"
        │   │       │   │           ├── opening_loc: (7,5)-(7,6) = "("
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (7,6)-(7,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (7,6)-(7,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (7,6)-(7,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: (7,7)-(7,8) = ")"
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (7,8)-(7,9) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ StringNode (location: (7,11)-(7,14))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (7,11)-(7,12) = "\""
        │   │           ├── content_loc: (7,12)-(7,13) = "x"
        │   │           ├── closing_loc: (7,13)-(7,14) = "\""
        │   │           └── unescaped: "x"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (7,15)-(7,21))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (7,15)-(7,17) = "do"
        │       └── closing_loc: (7,18)-(7,21) = "end"
        ├── @ CallNode (location: (9,0)-(9,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (9,0)-(9,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (9,2)-(9,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (9,2)-(9,9))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (9,2)-(9,3) = "b"
        │   │       │   ├── opening_loc: (9,3)-(9,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (9,4)-(9,8))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (9,4)-(9,8))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (9,4)-(9,5) = "c"
        │   │       │   │           ├── opening_loc: (9,5)-(9,6) = "("
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (9,6)-(9,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (9,6)-(9,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (9,6)-(9,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: (9,7)-(9,8) = ")"
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (9,8)-(9,9) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ RegularExpressionNode (location: (9,11)-(9,14))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (9,11)-(9,12) = "/"
        │   │           ├── content_loc: (9,12)-(9,13) = "x"
        │   │           ├── closing_loc: (9,13)-(9,14) = "/"
        │   │           └── unescaped: "x"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (9,15)-(9,21))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (9,15)-(9,17) = "do"
        │       └── closing_loc: (9,18)-(9,21) = "end"
        ├── @ CallNode (location: (11,0)-(11,22))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (11,0)-(11,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (11,2)-(11,15))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (11,2)-(11,9))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (11,2)-(11,3) = "b"
        │   │       │   ├── opening_loc: (11,3)-(11,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (11,4)-(11,8))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (11,4)-(11,8))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (11,4)-(11,5) = "c"
        │   │       │   │           ├── opening_loc: (11,5)-(11,6) = "("
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (11,6)-(11,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (11,6)-(11,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (11,6)-(11,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: (11,7)-(11,8) = ")"
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (11,8)-(11,9) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ RegularExpressionNode (location: (11,11)-(11,15))
        │   │           ├── flags: static_literal, multi_line, forced_us_ascii_encoding
        │   │           ├── opening_loc: (11,11)-(11,12) = "/"
        │   │           ├── content_loc: (11,12)-(11,13) = "x"
        │   │           ├── closing_loc: (11,13)-(11,15) = "/m"
        │   │           └── unescaped: "x"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (11,16)-(11,22))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (11,16)-(11,18) = "do"
        │       └── closing_loc: (11,19)-(11,22) = "end"
        ├── @ CallNode (location: (13,0)-(13,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (13,0)-(13,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (13,2)-(13,13))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (13,2)-(13,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (13,2)-(13,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block:
        │   │       │       @ BlockNode (location: (13,3)-(13,8))
        │   │       │       ├── flags: ∅
        │   │       │       ├── locals: []
        │   │       │       ├── parameters: ∅
        │   │       │       ├── body:
        │   │       │       │   @ StatementsNode (location: (13,4)-(13,7))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ CallNode (location: (13,4)-(13,7))
        │   │       │       │           ├── flags: newline, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :c
        │   │       │       │           ├── message_loc: (13,4)-(13,5) = "c"
        │   │       │       │           ├── opening_loc: ∅
        │   │       │       │           ├── arguments:
        │   │       │       │           │   @ ArgumentsNode (location: (13,6)-(13,7))
        │   │       │       │           │   ├── flags: ∅
        │   │       │       │           │   └── arguments: (length: 1)
        │   │       │       │           │       └── @ CallNode (location: (13,6)-(13,7))
        │   │       │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           │           ├── receiver: ∅
        │   │       │       │           │           ├── call_operator_loc: ∅
        │   │       │       │           │           ├── name: :d
        │   │       │       │           │           ├── message_loc: (13,6)-(13,7) = "d"
        │   │       │       │           │           ├── opening_loc: ∅
        │   │       │       │           │           ├── arguments: ∅
        │   │       │       │           │           ├── closing_loc: ∅
        │   │       │       │           │           └── block: ∅
        │   │       │       │           ├── closing_loc: ∅
        │   │       │       │           └── block: ∅
        │   │       │       ├── opening_loc: (13,3)-(13,4) = "{"
        │   │       │       └── closing_loc: (13,7)-(13,8) = "}"
        │   │       └── @ StringNode (location: (13,10)-(13,13))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (13,10)-(13,11) = "\""
        │   │           ├── content_loc: (13,11)-(13,12) = "x"
        │   │           ├── closing_loc: (13,12)-(13,13) = "\""
        │   │           └── unescaped: "x"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (13,14)-(13,20))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (13,14)-(13,16) = "do"
        │       └── closing_loc: (13,17)-(13,20) = "end"
        ├── @ CallNode (location: (15,0)-(15,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (15,0)-(15,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (15,2)-(15,13))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (15,2)-(15,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (15,2)-(15,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block:
        │   │       │       @ BlockNode (location: (15,3)-(15,8))
        │   │       │       ├── flags: ∅
        │   │       │       ├── locals: []
        │   │       │       ├── parameters: ∅
        │   │       │       ├── body:
        │   │       │       │   @ StatementsNode (location: (15,4)-(15,7))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ CallNode (location: (15,4)-(15,7))
        │   │       │       │           ├── flags: newline, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :c
        │   │       │       │           ├── message_loc: (15,4)-(15,5) = "c"
        │   │       │       │           ├── opening_loc: ∅
        │   │       │       │           ├── arguments:
        │   │       │       │           │   @ ArgumentsNode (location: (15,6)-(15,7))
        │   │       │       │           │   ├── flags: ∅
        │   │       │       │           │   └── arguments: (length: 1)
        │   │       │       │           │       └── @ CallNode (location: (15,6)-(15,7))
        │   │       │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           │           ├── receiver: ∅
        │   │       │       │           │           ├── call_operator_loc: ∅
        │   │       │       │           │           ├── name: :d
        │   │       │       │           │           ├── message_loc: (15,6)-(15,7) = "d"
        │   │       │       │           │           ├── opening_loc: ∅
        │   │       │       │           │           ├── arguments: ∅
        │   │       │       │           │           ├── closing_loc: ∅
        │   │       │       │           │           └── block: ∅
        │   │       │       │           ├── closing_loc: ∅
        │   │       │       │           └── block: ∅
        │   │       │       ├── opening_loc: (15,3)-(15,4) = "{"
        │   │       │       └── closing_loc: (15,7)-(15,8) = "}"
        │   │       └── @ RegularExpressionNode (location: (15,10)-(15,13))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (15,10)-(15,11) = "/"
        │   │           ├── content_loc: (15,11)-(15,12) = "x"
        │   │           ├── closing_loc: (15,12)-(15,13) = "/"
        │   │           └── unescaped: "x"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (15,14)-(15,20))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (15,14)-(15,16) = "do"
        │       └── closing_loc: (15,17)-(15,20) = "end"
        ├── @ CallNode (location: (17,0)-(17,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (17,0)-(17,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (17,2)-(17,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (17,2)-(17,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (17,2)-(17,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block:
        │   │       │       @ BlockNode (location: (17,3)-(17,8))
        │   │       │       ├── flags: ∅
        │   │       │       ├── locals: []
        │   │       │       ├── parameters: ∅
        │   │       │       ├── body:
        │   │       │       │   @ StatementsNode (location: (17,4)-(17,7))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ CallNode (location: (17,4)-(17,7))
        │   │       │       │           ├── flags: newline, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :c
        │   │       │       │           ├── message_loc: (17,4)-(17,5) = "c"
        │   │       │       │           ├── opening_loc: ∅
        │   │       │       │           ├── arguments:
        │   │       │       │           │   @ ArgumentsNode (location: (17,6)-(17,7))
        │   │       │       │           │   ├── flags: ∅
        │   │       │       │           │   └── arguments: (length: 1)
        │   │       │       │           │       └── @ CallNode (location: (17,6)-(17,7))
        │   │       │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           │           ├── receiver: ∅
        │   │       │       │           │           ├── call_operator_loc: ∅
        │   │       │       │           │           ├── name: :d
        │   │       │       │           │           ├── message_loc: (17,6)-(17,7) = "d"
        │   │       │       │           │           ├── opening_loc: ∅
        │   │       │       │           │           ├── arguments: ∅
        │   │       │       │           │           ├── closing_loc: ∅
        │   │       │       │           │           └── block: ∅
        │   │       │       │           ├── closing_loc: ∅
        │   │       │       │           └── block: ∅
        │   │       │       ├── opening_loc: (17,3)-(17,4) = "{"
        │   │       │       └── closing_loc: (17,7)-(17,8) = "}"
        │   │       └── @ RegularExpressionNode (location: (17,10)-(17,14))
        │   │           ├── flags: static_literal, multi_line, forced_us_ascii_encoding
        │   │           ├── opening_loc: (17,10)-(17,11) = "/"
        │   │           ├── content_loc: (17,11)-(17,12) = "x"
        │   │           ├── closing_loc: (17,12)-(17,14) = "/m"
        │   │           └── unescaped: "x"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (17,15)-(17,21))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (17,15)-(17,17) = "do"
        │       └── closing_loc: (17,18)-(17,21) = "end"
        ├── @ CallNode (location: (19,0)-(19,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (19,0)-(19,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (19,2)-(19,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (19,2)-(19,9))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (19,2)-(19,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block:
        │   │       │       @ BlockNode (location: (19,3)-(19,9))
        │   │       │       ├── flags: ∅
        │   │       │       ├── locals: []
        │   │       │       ├── parameters: ∅
        │   │       │       ├── body:
        │   │       │       │   @ StatementsNode (location: (19,4)-(19,8))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ CallNode (location: (19,4)-(19,8))
        │   │       │       │           ├── flags: newline, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :c
        │   │       │       │           ├── message_loc: (19,4)-(19,5) = "c"
        │   │       │       │           ├── opening_loc: (19,5)-(19,6) = "("
        │   │       │       │           ├── arguments:
        │   │       │       │           │   @ ArgumentsNode (location: (19,6)-(19,7))
        │   │       │       │           │   ├── flags: ∅
        │   │       │       │           │   └── arguments: (length: 1)
        │   │       │       │           │       └── @ CallNode (location: (19,6)-(19,7))
        │   │       │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           │           ├── receiver: ∅
        │   │       │       │           │           ├── call_operator_loc: ∅
        │   │       │       │           │           ├── name: :d
        │   │       │       │           │           ├── message_loc: (19,6)-(19,7) = "d"
        │   │       │       │           │           ├── opening_loc: ∅
        │   │       │       │           │           ├── arguments: ∅
        │   │       │       │           │           ├── closing_loc: ∅
        │   │       │       │           │           └── block: ∅
        │   │       │       │           ├── closing_loc: (19,7)-(19,8) = ")"
        │   │       │       │           └── block: ∅
        │   │       │       ├── opening_loc: (19,3)-(19,4) = "{"
        │   │       │       └── closing_loc: (19,8)-(19,9) = "}"
        │   │       └── @ StringNode (location: (19,11)-(19,14))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (19,11)-(19,12) = "\""
        │   │           ├── content_loc: (19,12)-(19,13) = "x"
        │   │           ├── closing_loc: (19,13)-(19,14) = "\""
        │   │           └── unescaped: "x"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (19,15)-(19,21))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (19,15)-(19,17) = "do"
        │       └── closing_loc: (19,18)-(19,21) = "end"
        ├── @ CallNode (location: (21,0)-(21,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (21,0)-(21,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (21,2)-(21,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (21,2)-(21,9))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (21,2)-(21,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block:
        │   │       │       @ BlockNode (location: (21,3)-(21,9))
        │   │       │       ├── flags: ∅
        │   │       │       ├── locals: []
        │   │       │       ├── parameters: ∅
        │   │       │       ├── body:
        │   │       │       │   @ StatementsNode (location: (21,4)-(21,8))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ CallNode (location: (21,4)-(21,8))
        │   │       │       │           ├── flags: newline, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :c
        │   │       │       │           ├── message_loc: (21,4)-(21,5) = "c"
        │   │       │       │           ├── opening_loc: (21,5)-(21,6) = "("
        │   │       │       │           ├── arguments:
        │   │       │       │           │   @ ArgumentsNode (location: (21,6)-(21,7))
        │   │       │       │           │   ├── flags: ∅
        │   │       │       │           │   └── arguments: (length: 1)
        │   │       │       │           │       └── @ CallNode (location: (21,6)-(21,7))
        │   │       │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           │           ├── receiver: ∅
        │   │       │       │           │           ├── call_operator_loc: ∅
        │   │       │       │           │           ├── name: :d
        │   │       │       │           │           ├── message_loc: (21,6)-(21,7) = "d"
        │   │       │       │           │           ├── opening_loc: ∅
        │   │       │       │           │           ├── arguments: ∅
        │   │       │       │           │           ├── closing_loc: ∅
        │   │       │       │           │           └── block: ∅
        │   │       │       │           ├── closing_loc: (21,7)-(21,8) = ")"
        │   │       │       │           └── block: ∅
        │   │       │       ├── opening_loc: (21,3)-(21,4) = "{"
        │   │       │       └── closing_loc: (21,8)-(21,9) = "}"
        │   │       └── @ RegularExpressionNode (location: (21,11)-(21,14))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (21,11)-(21,12) = "/"
        │   │           ├── content_loc: (21,12)-(21,13) = "x"
        │   │           ├── closing_loc: (21,13)-(21,14) = "/"
        │   │           └── unescaped: "x"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (21,15)-(21,21))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (21,15)-(21,17) = "do"
        │       └── closing_loc: (21,18)-(21,21) = "end"
        └── @ CallNode (location: (23,0)-(23,22))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (23,0)-(23,1) = "a"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (23,2)-(23,15))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ CallNode (location: (23,2)-(23,9))
            │       │   ├── flags: ignore_visibility
            │       │   ├── receiver: ∅
            │       │   ├── call_operator_loc: ∅
            │       │   ├── name: :b
            │       │   ├── message_loc: (23,2)-(23,3) = "b"
            │       │   ├── opening_loc: ∅
            │       │   ├── arguments: ∅
            │       │   ├── closing_loc: ∅
            │       │   └── block:
            │       │       @ BlockNode (location: (23,3)-(23,9))
            │       │       ├── flags: ∅
            │       │       ├── locals: []
            │       │       ├── parameters: ∅
            │       │       ├── body:
            │       │       │   @ StatementsNode (location: (23,4)-(23,8))
            │       │       │   ├── flags: ∅
            │       │       │   └── body: (length: 1)
            │       │       │       └── @ CallNode (location: (23,4)-(23,8))
            │       │       │           ├── flags: newline, ignore_visibility
            │       │       │           ├── receiver: ∅
            │       │       │           ├── call_operator_loc: ∅
            │       │       │           ├── name: :c
            │       │       │           ├── message_loc: (23,4)-(23,5) = "c"
            │       │       │           ├── opening_loc: (23,5)-(23,6) = "("
            │       │       │           ├── arguments:
            │       │       │           │   @ ArgumentsNode (location: (23,6)-(23,7))
            │       │       │           │   ├── flags: ∅
            │       │       │           │   └── arguments: (length: 1)
            │       │       │           │       └── @ CallNode (location: (23,6)-(23,7))
            │       │       │           │           ├── flags: variable_call, ignore_visibility
            │       │       │           │           ├── receiver: ∅
            │       │       │           │           ├── call_operator_loc: ∅
            │       │       │           │           ├── name: :d
            │       │       │           │           ├── message_loc: (23,6)-(23,7) = "d"
            │       │       │           │           ├── opening_loc: ∅
            │       │       │           │           ├── arguments: ∅
            │       │       │           │           ├── closing_loc: ∅
            │       │       │           │           └── block: ∅
            │       │       │           ├── closing_loc: (23,7)-(23,8) = ")"
            │       │       │           └── block: ∅
            │       │       ├── opening_loc: (23,3)-(23,4) = "{"
            │       │       └── closing_loc: (23,8)-(23,9) = "}"
            │       └── @ RegularExpressionNode (location: (23,11)-(23,15))
            │           ├── flags: static_literal, multi_line, forced_us_ascii_encoding
            │           ├── opening_loc: (23,11)-(23,12) = "/"
            │           ├── content_loc: (23,12)-(23,13) = "x"
            │           ├── closing_loc: (23,13)-(23,15) = "/m"
            │           └── unescaped: "x"
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (23,16)-(23,22))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (23,16)-(23,18) = "do"
                └── closing_loc: (23,19)-(23,22) = "end"
prism-1.5.1/snapshots/whitequark/ruby_bug_11873_a.txt000066400000000000000000002436431506127434000225160ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(39,20))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(39,20))
    ├── flags: ∅
    └── body: (length: 20)
        ├── @ CallNode (location: (1,0)-(1,18))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (1,0)-(1,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(1,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (1,2)-(1,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (1,2)-(1,3) = "b"
        │   │       │   ├── opening_loc: (1,3)-(1,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (1,4)-(1,7))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (1,4)-(1,7))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (1,4)-(1,5) = "c"
        │   │       │   │           ├── opening_loc: ∅
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (1,6)-(1,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (1,6)-(1,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (1,6)-(1,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: ∅
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (1,7)-(1,8) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ IntegerNode (location: (1,10)-(1,11))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,12)-(1,18))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (1,12)-(1,14) = "do"
        │       └── closing_loc: (1,15)-(1,18) = "end"
        ├── @ CallNode (location: (3,0)-(3,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (3,0)-(3,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,2)-(3,13))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (3,2)-(3,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (3,2)-(3,3) = "b"
        │   │       │   ├── opening_loc: (3,3)-(3,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (3,4)-(3,7))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (3,4)-(3,7))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (3,4)-(3,5) = "c"
        │   │       │   │           ├── opening_loc: ∅
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (3,6)-(3,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (3,6)-(3,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (3,6)-(3,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: ∅
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (3,7)-(3,8) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ FloatNode (location: (3,10)-(3,13))
        │   │           ├── flags: static_literal
        │   │           └── value: 1.0
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (3,14)-(3,20))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (3,14)-(3,16) = "do"
        │       └── closing_loc: (3,17)-(3,20) = "end"
        ├── @ CallNode (location: (5,0)-(5,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (5,0)-(5,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (5,2)-(5,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (5,2)-(5,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (5,2)-(5,3) = "b"
        │   │       │   ├── opening_loc: (5,3)-(5,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (5,4)-(5,7))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (5,4)-(5,7))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (5,4)-(5,5) = "c"
        │   │       │   │           ├── opening_loc: ∅
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (5,6)-(5,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (5,6)-(5,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (5,6)-(5,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: ∅
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (5,7)-(5,8) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ ImaginaryNode (location: (5,10)-(5,14))
        │   │           ├── flags: static_literal
        │   │           └── numeric:
        │   │               @ FloatNode (location: (5,10)-(5,13))
        │   │               ├── flags: static_literal
        │   │               └── value: 1.0
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (5,15)-(5,21))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (5,15)-(5,17) = "do"
        │       └── closing_loc: (5,18)-(5,21) = "end"
        ├── @ CallNode (location: (7,0)-(7,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (7,0)-(7,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (7,2)-(7,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (7,2)-(7,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (7,2)-(7,3) = "b"
        │   │       │   ├── opening_loc: (7,3)-(7,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (7,4)-(7,7))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (7,4)-(7,7))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (7,4)-(7,5) = "c"
        │   │       │   │           ├── opening_loc: ∅
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (7,6)-(7,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (7,6)-(7,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (7,6)-(7,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: ∅
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (7,7)-(7,8) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ RationalNode (location: (7,10)-(7,14))
        │   │           ├── flags: static_literal, decimal
        │   │           ├── numerator: 1
        │   │           └── denominator: 1
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (7,15)-(7,21))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (7,15)-(7,17) = "do"
        │       └── closing_loc: (7,18)-(7,21) = "end"
        ├── @ CallNode (location: (9,0)-(9,19))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (9,0)-(9,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (9,2)-(9,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (9,2)-(9,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (9,2)-(9,3) = "b"
        │   │       │   ├── opening_loc: (9,3)-(9,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (9,4)-(9,7))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (9,4)-(9,7))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (9,4)-(9,5) = "c"
        │   │       │   │           ├── opening_loc: ∅
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (9,6)-(9,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (9,6)-(9,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (9,6)-(9,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: ∅
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (9,7)-(9,8) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ SymbolNode (location: (9,10)-(9,12))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (9,10)-(9,11) = ":"
        │   │           ├── value_loc: (9,11)-(9,12) = "e"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "e"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (9,13)-(9,19))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (9,13)-(9,15) = "do"
        │       └── closing_loc: (9,16)-(9,19) = "end"
        ├── @ CallNode (location: (11,0)-(11,19))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (11,0)-(11,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (11,2)-(11,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (11,2)-(11,9))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (11,2)-(11,3) = "b"
        │   │       │   ├── opening_loc: (11,3)-(11,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (11,4)-(11,8))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (11,4)-(11,8))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (11,4)-(11,5) = "c"
        │   │       │   │           ├── opening_loc: (11,5)-(11,6) = "("
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (11,6)-(11,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (11,6)-(11,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (11,6)-(11,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: (11,7)-(11,8) = ")"
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (11,8)-(11,9) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ IntegerNode (location: (11,11)-(11,12))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (11,13)-(11,19))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (11,13)-(11,15) = "do"
        │       └── closing_loc: (11,16)-(11,19) = "end"
        ├── @ CallNode (location: (13,0)-(13,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (13,0)-(13,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (13,2)-(13,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (13,2)-(13,9))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (13,2)-(13,3) = "b"
        │   │       │   ├── opening_loc: (13,3)-(13,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (13,4)-(13,8))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (13,4)-(13,8))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (13,4)-(13,5) = "c"
        │   │       │   │           ├── opening_loc: (13,5)-(13,6) = "("
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (13,6)-(13,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (13,6)-(13,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (13,6)-(13,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: (13,7)-(13,8) = ")"
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (13,8)-(13,9) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ FloatNode (location: (13,11)-(13,14))
        │   │           ├── flags: static_literal
        │   │           └── value: 1.0
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (13,15)-(13,21))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (13,15)-(13,17) = "do"
        │       └── closing_loc: (13,18)-(13,21) = "end"
        ├── @ CallNode (location: (15,0)-(15,22))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (15,0)-(15,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (15,2)-(15,15))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (15,2)-(15,9))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (15,2)-(15,3) = "b"
        │   │       │   ├── opening_loc: (15,3)-(15,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (15,4)-(15,8))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (15,4)-(15,8))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (15,4)-(15,5) = "c"
        │   │       │   │           ├── opening_loc: (15,5)-(15,6) = "("
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (15,6)-(15,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (15,6)-(15,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (15,6)-(15,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: (15,7)-(15,8) = ")"
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (15,8)-(15,9) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ ImaginaryNode (location: (15,11)-(15,15))
        │   │           ├── flags: static_literal
        │   │           └── numeric:
        │   │               @ FloatNode (location: (15,11)-(15,14))
        │   │               ├── flags: static_literal
        │   │               └── value: 1.0
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (15,16)-(15,22))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (15,16)-(15,18) = "do"
        │       └── closing_loc: (15,19)-(15,22) = "end"
        ├── @ CallNode (location: (17,0)-(17,22))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (17,0)-(17,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (17,2)-(17,15))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (17,2)-(17,9))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (17,2)-(17,3) = "b"
        │   │       │   ├── opening_loc: (17,3)-(17,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (17,4)-(17,8))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (17,4)-(17,8))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (17,4)-(17,5) = "c"
        │   │       │   │           ├── opening_loc: (17,5)-(17,6) = "("
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (17,6)-(17,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (17,6)-(17,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (17,6)-(17,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: (17,7)-(17,8) = ")"
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (17,8)-(17,9) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ RationalNode (location: (17,11)-(17,15))
        │   │           ├── flags: static_literal, decimal
        │   │           ├── numerator: 1
        │   │           └── denominator: 1
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (17,16)-(17,22))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (17,16)-(17,18) = "do"
        │       └── closing_loc: (17,19)-(17,22) = "end"
        ├── @ CallNode (location: (19,0)-(19,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (19,0)-(19,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (19,2)-(19,13))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (19,2)-(19,9))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (19,2)-(19,3) = "b"
        │   │       │   ├── opening_loc: (19,3)-(19,4) = "("
        │   │       │   ├── arguments:
        │   │       │   │   @ ArgumentsNode (location: (19,4)-(19,8))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── arguments: (length: 1)
        │   │       │   │       └── @ CallNode (location: (19,4)-(19,8))
        │   │       │   │           ├── flags: ignore_visibility
        │   │       │   │           ├── receiver: ∅
        │   │       │   │           ├── call_operator_loc: ∅
        │   │       │   │           ├── name: :c
        │   │       │   │           ├── message_loc: (19,4)-(19,5) = "c"
        │   │       │   │           ├── opening_loc: (19,5)-(19,6) = "("
        │   │       │   │           ├── arguments:
        │   │       │   │           │   @ ArgumentsNode (location: (19,6)-(19,7))
        │   │       │   │           │   ├── flags: ∅
        │   │       │   │           │   └── arguments: (length: 1)
        │   │       │   │           │       └── @ CallNode (location: (19,6)-(19,7))
        │   │       │   │           │           ├── flags: variable_call, ignore_visibility
        │   │       │   │           │           ├── receiver: ∅
        │   │       │   │           │           ├── call_operator_loc: ∅
        │   │       │   │           │           ├── name: :d
        │   │       │   │           │           ├── message_loc: (19,6)-(19,7) = "d"
        │   │       │   │           │           ├── opening_loc: ∅
        │   │       │   │           │           ├── arguments: ∅
        │   │       │   │           │           ├── closing_loc: ∅
        │   │       │   │           │           └── block: ∅
        │   │       │   │           ├── closing_loc: (19,7)-(19,8) = ")"
        │   │       │   │           └── block: ∅
        │   │       │   ├── closing_loc: (19,8)-(19,9) = ")"
        │   │       │   └── block: ∅
        │   │       └── @ SymbolNode (location: (19,11)-(19,13))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (19,11)-(19,12) = ":"
        │   │           ├── value_loc: (19,12)-(19,13) = "e"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "e"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (19,14)-(19,20))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (19,14)-(19,16) = "do"
        │       └── closing_loc: (19,17)-(19,20) = "end"
        ├── @ CallNode (location: (21,0)-(21,18))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (21,0)-(21,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (21,2)-(21,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (21,2)-(21,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (21,2)-(21,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block:
        │   │       │       @ BlockNode (location: (21,3)-(21,8))
        │   │       │       ├── flags: ∅
        │   │       │       ├── locals: []
        │   │       │       ├── parameters: ∅
        │   │       │       ├── body:
        │   │       │       │   @ StatementsNode (location: (21,4)-(21,7))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ CallNode (location: (21,4)-(21,7))
        │   │       │       │           ├── flags: newline, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :c
        │   │       │       │           ├── message_loc: (21,4)-(21,5) = "c"
        │   │       │       │           ├── opening_loc: ∅
        │   │       │       │           ├── arguments:
        │   │       │       │           │   @ ArgumentsNode (location: (21,6)-(21,7))
        │   │       │       │           │   ├── flags: ∅
        │   │       │       │           │   └── arguments: (length: 1)
        │   │       │       │           │       └── @ CallNode (location: (21,6)-(21,7))
        │   │       │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           │           ├── receiver: ∅
        │   │       │       │           │           ├── call_operator_loc: ∅
        │   │       │       │           │           ├── name: :d
        │   │       │       │           │           ├── message_loc: (21,6)-(21,7) = "d"
        │   │       │       │           │           ├── opening_loc: ∅
        │   │       │       │           │           ├── arguments: ∅
        │   │       │       │           │           ├── closing_loc: ∅
        │   │       │       │           │           └── block: ∅
        │   │       │       │           ├── closing_loc: ∅
        │   │       │       │           └── block: ∅
        │   │       │       ├── opening_loc: (21,3)-(21,4) = "{"
        │   │       │       └── closing_loc: (21,7)-(21,8) = "}"
        │   │       └── @ IntegerNode (location: (21,10)-(21,11))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (21,12)-(21,18))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (21,12)-(21,14) = "do"
        │       └── closing_loc: (21,15)-(21,18) = "end"
        ├── @ CallNode (location: (23,0)-(23,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (23,0)-(23,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (23,2)-(23,13))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (23,2)-(23,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (23,2)-(23,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block:
        │   │       │       @ BlockNode (location: (23,3)-(23,8))
        │   │       │       ├── flags: ∅
        │   │       │       ├── locals: []
        │   │       │       ├── parameters: ∅
        │   │       │       ├── body:
        │   │       │       │   @ StatementsNode (location: (23,4)-(23,7))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ CallNode (location: (23,4)-(23,7))
        │   │       │       │           ├── flags: newline, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :c
        │   │       │       │           ├── message_loc: (23,4)-(23,5) = "c"
        │   │       │       │           ├── opening_loc: ∅
        │   │       │       │           ├── arguments:
        │   │       │       │           │   @ ArgumentsNode (location: (23,6)-(23,7))
        │   │       │       │           │   ├── flags: ∅
        │   │       │       │           │   └── arguments: (length: 1)
        │   │       │       │           │       └── @ CallNode (location: (23,6)-(23,7))
        │   │       │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           │           ├── receiver: ∅
        │   │       │       │           │           ├── call_operator_loc: ∅
        │   │       │       │           │           ├── name: :d
        │   │       │       │           │           ├── message_loc: (23,6)-(23,7) = "d"
        │   │       │       │           │           ├── opening_loc: ∅
        │   │       │       │           │           ├── arguments: ∅
        │   │       │       │           │           ├── closing_loc: ∅
        │   │       │       │           │           └── block: ∅
        │   │       │       │           ├── closing_loc: ∅
        │   │       │       │           └── block: ∅
        │   │       │       ├── opening_loc: (23,3)-(23,4) = "{"
        │   │       │       └── closing_loc: (23,7)-(23,8) = "}"
        │   │       └── @ FloatNode (location: (23,10)-(23,13))
        │   │           ├── flags: static_literal
        │   │           └── value: 1.0
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (23,14)-(23,20))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (23,14)-(23,16) = "do"
        │       └── closing_loc: (23,17)-(23,20) = "end"
        ├── @ CallNode (location: (25,0)-(25,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (25,0)-(25,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (25,2)-(25,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (25,2)-(25,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (25,2)-(25,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block:
        │   │       │       @ BlockNode (location: (25,3)-(25,8))
        │   │       │       ├── flags: ∅
        │   │       │       ├── locals: []
        │   │       │       ├── parameters: ∅
        │   │       │       ├── body:
        │   │       │       │   @ StatementsNode (location: (25,4)-(25,7))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ CallNode (location: (25,4)-(25,7))
        │   │       │       │           ├── flags: newline, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :c
        │   │       │       │           ├── message_loc: (25,4)-(25,5) = "c"
        │   │       │       │           ├── opening_loc: ∅
        │   │       │       │           ├── arguments:
        │   │       │       │           │   @ ArgumentsNode (location: (25,6)-(25,7))
        │   │       │       │           │   ├── flags: ∅
        │   │       │       │           │   └── arguments: (length: 1)
        │   │       │       │           │       └── @ CallNode (location: (25,6)-(25,7))
        │   │       │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           │           ├── receiver: ∅
        │   │       │       │           │           ├── call_operator_loc: ∅
        │   │       │       │           │           ├── name: :d
        │   │       │       │           │           ├── message_loc: (25,6)-(25,7) = "d"
        │   │       │       │           │           ├── opening_loc: ∅
        │   │       │       │           │           ├── arguments: ∅
        │   │       │       │           │           ├── closing_loc: ∅
        │   │       │       │           │           └── block: ∅
        │   │       │       │           ├── closing_loc: ∅
        │   │       │       │           └── block: ∅
        │   │       │       ├── opening_loc: (25,3)-(25,4) = "{"
        │   │       │       └── closing_loc: (25,7)-(25,8) = "}"
        │   │       └── @ ImaginaryNode (location: (25,10)-(25,14))
        │   │           ├── flags: static_literal
        │   │           └── numeric:
        │   │               @ FloatNode (location: (25,10)-(25,13))
        │   │               ├── flags: static_literal
        │   │               └── value: 1.0
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (25,15)-(25,21))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (25,15)-(25,17) = "do"
        │       └── closing_loc: (25,18)-(25,21) = "end"
        ├── @ CallNode (location: (27,0)-(27,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (27,0)-(27,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (27,2)-(27,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (27,2)-(27,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (27,2)-(27,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block:
        │   │       │       @ BlockNode (location: (27,3)-(27,8))
        │   │       │       ├── flags: ∅
        │   │       │       ├── locals: []
        │   │       │       ├── parameters: ∅
        │   │       │       ├── body:
        │   │       │       │   @ StatementsNode (location: (27,4)-(27,7))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ CallNode (location: (27,4)-(27,7))
        │   │       │       │           ├── flags: newline, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :c
        │   │       │       │           ├── message_loc: (27,4)-(27,5) = "c"
        │   │       │       │           ├── opening_loc: ∅
        │   │       │       │           ├── arguments:
        │   │       │       │           │   @ ArgumentsNode (location: (27,6)-(27,7))
        │   │       │       │           │   ├── flags: ∅
        │   │       │       │           │   └── arguments: (length: 1)
        │   │       │       │           │       └── @ CallNode (location: (27,6)-(27,7))
        │   │       │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           │           ├── receiver: ∅
        │   │       │       │           │           ├── call_operator_loc: ∅
        │   │       │       │           │           ├── name: :d
        │   │       │       │           │           ├── message_loc: (27,6)-(27,7) = "d"
        │   │       │       │           │           ├── opening_loc: ∅
        │   │       │       │           │           ├── arguments: ∅
        │   │       │       │           │           ├── closing_loc: ∅
        │   │       │       │           │           └── block: ∅
        │   │       │       │           ├── closing_loc: ∅
        │   │       │       │           └── block: ∅
        │   │       │       ├── opening_loc: (27,3)-(27,4) = "{"
        │   │       │       └── closing_loc: (27,7)-(27,8) = "}"
        │   │       └── @ RationalNode (location: (27,10)-(27,14))
        │   │           ├── flags: static_literal, decimal
        │   │           ├── numerator: 1
        │   │           └── denominator: 1
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (27,15)-(27,21))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (27,15)-(27,17) = "do"
        │       └── closing_loc: (27,18)-(27,21) = "end"
        ├── @ CallNode (location: (29,0)-(29,19))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (29,0)-(29,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (29,2)-(29,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (29,2)-(29,8))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (29,2)-(29,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block:
        │   │       │       @ BlockNode (location: (29,3)-(29,8))
        │   │       │       ├── flags: ∅
        │   │       │       ├── locals: []
        │   │       │       ├── parameters: ∅
        │   │       │       ├── body:
        │   │       │       │   @ StatementsNode (location: (29,4)-(29,7))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ CallNode (location: (29,4)-(29,7))
        │   │       │       │           ├── flags: newline, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :c
        │   │       │       │           ├── message_loc: (29,4)-(29,5) = "c"
        │   │       │       │           ├── opening_loc: ∅
        │   │       │       │           ├── arguments:
        │   │       │       │           │   @ ArgumentsNode (location: (29,6)-(29,7))
        │   │       │       │           │   ├── flags: ∅
        │   │       │       │           │   └── arguments: (length: 1)
        │   │       │       │           │       └── @ CallNode (location: (29,6)-(29,7))
        │   │       │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           │           ├── receiver: ∅
        │   │       │       │           │           ├── call_operator_loc: ∅
        │   │       │       │           │           ├── name: :d
        │   │       │       │           │           ├── message_loc: (29,6)-(29,7) = "d"
        │   │       │       │           │           ├── opening_loc: ∅
        │   │       │       │           │           ├── arguments: ∅
        │   │       │       │           │           ├── closing_loc: ∅
        │   │       │       │           │           └── block: ∅
        │   │       │       │           ├── closing_loc: ∅
        │   │       │       │           └── block: ∅
        │   │       │       ├── opening_loc: (29,3)-(29,4) = "{"
        │   │       │       └── closing_loc: (29,7)-(29,8) = "}"
        │   │       └── @ SymbolNode (location: (29,10)-(29,12))
        │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │           ├── opening_loc: (29,10)-(29,11) = ":"
        │   │           ├── value_loc: (29,11)-(29,12) = "e"
        │   │           ├── closing_loc: ∅
        │   │           └── unescaped: "e"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (29,13)-(29,19))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (29,13)-(29,15) = "do"
        │       └── closing_loc: (29,16)-(29,19) = "end"
        ├── @ CallNode (location: (31,0)-(31,19))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (31,0)-(31,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (31,2)-(31,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (31,2)-(31,9))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (31,2)-(31,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block:
        │   │       │       @ BlockNode (location: (31,3)-(31,9))
        │   │       │       ├── flags: ∅
        │   │       │       ├── locals: []
        │   │       │       ├── parameters: ∅
        │   │       │       ├── body:
        │   │       │       │   @ StatementsNode (location: (31,4)-(31,8))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ CallNode (location: (31,4)-(31,8))
        │   │       │       │           ├── flags: newline, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :c
        │   │       │       │           ├── message_loc: (31,4)-(31,5) = "c"
        │   │       │       │           ├── opening_loc: (31,5)-(31,6) = "("
        │   │       │       │           ├── arguments:
        │   │       │       │           │   @ ArgumentsNode (location: (31,6)-(31,7))
        │   │       │       │           │   ├── flags: ∅
        │   │       │       │           │   └── arguments: (length: 1)
        │   │       │       │           │       └── @ CallNode (location: (31,6)-(31,7))
        │   │       │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           │           ├── receiver: ∅
        │   │       │       │           │           ├── call_operator_loc: ∅
        │   │       │       │           │           ├── name: :d
        │   │       │       │           │           ├── message_loc: (31,6)-(31,7) = "d"
        │   │       │       │           │           ├── opening_loc: ∅
        │   │       │       │           │           ├── arguments: ∅
        │   │       │       │           │           ├── closing_loc: ∅
        │   │       │       │           │           └── block: ∅
        │   │       │       │           ├── closing_loc: (31,7)-(31,8) = ")"
        │   │       │       │           └── block: ∅
        │   │       │       ├── opening_loc: (31,3)-(31,4) = "{"
        │   │       │       └── closing_loc: (31,8)-(31,9) = "}"
        │   │       └── @ IntegerNode (location: (31,11)-(31,12))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (31,13)-(31,19))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (31,13)-(31,15) = "do"
        │       └── closing_loc: (31,16)-(31,19) = "end"
        ├── @ CallNode (location: (33,0)-(33,21))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (33,0)-(33,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (33,2)-(33,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (33,2)-(33,9))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (33,2)-(33,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block:
        │   │       │       @ BlockNode (location: (33,3)-(33,9))
        │   │       │       ├── flags: ∅
        │   │       │       ├── locals: []
        │   │       │       ├── parameters: ∅
        │   │       │       ├── body:
        │   │       │       │   @ StatementsNode (location: (33,4)-(33,8))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ CallNode (location: (33,4)-(33,8))
        │   │       │       │           ├── flags: newline, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :c
        │   │       │       │           ├── message_loc: (33,4)-(33,5) = "c"
        │   │       │       │           ├── opening_loc: (33,5)-(33,6) = "("
        │   │       │       │           ├── arguments:
        │   │       │       │           │   @ ArgumentsNode (location: (33,6)-(33,7))
        │   │       │       │           │   ├── flags: ∅
        │   │       │       │           │   └── arguments: (length: 1)
        │   │       │       │           │       └── @ CallNode (location: (33,6)-(33,7))
        │   │       │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           │           ├── receiver: ∅
        │   │       │       │           │           ├── call_operator_loc: ∅
        │   │       │       │           │           ├── name: :d
        │   │       │       │           │           ├── message_loc: (33,6)-(33,7) = "d"
        │   │       │       │           │           ├── opening_loc: ∅
        │   │       │       │           │           ├── arguments: ∅
        │   │       │       │           │           ├── closing_loc: ∅
        │   │       │       │           │           └── block: ∅
        │   │       │       │           ├── closing_loc: (33,7)-(33,8) = ")"
        │   │       │       │           └── block: ∅
        │   │       │       ├── opening_loc: (33,3)-(33,4) = "{"
        │   │       │       └── closing_loc: (33,8)-(33,9) = "}"
        │   │       └── @ FloatNode (location: (33,11)-(33,14))
        │   │           ├── flags: static_literal
        │   │           └── value: 1.0
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (33,15)-(33,21))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (33,15)-(33,17) = "do"
        │       └── closing_loc: (33,18)-(33,21) = "end"
        ├── @ CallNode (location: (35,0)-(35,22))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (35,0)-(35,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (35,2)-(35,15))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (35,2)-(35,9))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (35,2)-(35,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block:
        │   │       │       @ BlockNode (location: (35,3)-(35,9))
        │   │       │       ├── flags: ∅
        │   │       │       ├── locals: []
        │   │       │       ├── parameters: ∅
        │   │       │       ├── body:
        │   │       │       │   @ StatementsNode (location: (35,4)-(35,8))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ CallNode (location: (35,4)-(35,8))
        │   │       │       │           ├── flags: newline, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :c
        │   │       │       │           ├── message_loc: (35,4)-(35,5) = "c"
        │   │       │       │           ├── opening_loc: (35,5)-(35,6) = "("
        │   │       │       │           ├── arguments:
        │   │       │       │           │   @ ArgumentsNode (location: (35,6)-(35,7))
        │   │       │       │           │   ├── flags: ∅
        │   │       │       │           │   └── arguments: (length: 1)
        │   │       │       │           │       └── @ CallNode (location: (35,6)-(35,7))
        │   │       │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           │           ├── receiver: ∅
        │   │       │       │           │           ├── call_operator_loc: ∅
        │   │       │       │           │           ├── name: :d
        │   │       │       │           │           ├── message_loc: (35,6)-(35,7) = "d"
        │   │       │       │           │           ├── opening_loc: ∅
        │   │       │       │           │           ├── arguments: ∅
        │   │       │       │           │           ├── closing_loc: ∅
        │   │       │       │           │           └── block: ∅
        │   │       │       │           ├── closing_loc: (35,7)-(35,8) = ")"
        │   │       │       │           └── block: ∅
        │   │       │       ├── opening_loc: (35,3)-(35,4) = "{"
        │   │       │       └── closing_loc: (35,8)-(35,9) = "}"
        │   │       └── @ ImaginaryNode (location: (35,11)-(35,15))
        │   │           ├── flags: static_literal
        │   │           └── numeric:
        │   │               @ FloatNode (location: (35,11)-(35,14))
        │   │               ├── flags: static_literal
        │   │               └── value: 1.0
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (35,16)-(35,22))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (35,16)-(35,18) = "do"
        │       └── closing_loc: (35,19)-(35,22) = "end"
        ├── @ CallNode (location: (37,0)-(37,22))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (37,0)-(37,1) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (37,2)-(37,15))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (37,2)-(37,9))
        │   │       │   ├── flags: ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :b
        │   │       │   ├── message_loc: (37,2)-(37,3) = "b"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block:
        │   │       │       @ BlockNode (location: (37,3)-(37,9))
        │   │       │       ├── flags: ∅
        │   │       │       ├── locals: []
        │   │       │       ├── parameters: ∅
        │   │       │       ├── body:
        │   │       │       │   @ StatementsNode (location: (37,4)-(37,8))
        │   │       │       │   ├── flags: ∅
        │   │       │       │   └── body: (length: 1)
        │   │       │       │       └── @ CallNode (location: (37,4)-(37,8))
        │   │       │       │           ├── flags: newline, ignore_visibility
        │   │       │       │           ├── receiver: ∅
        │   │       │       │           ├── call_operator_loc: ∅
        │   │       │       │           ├── name: :c
        │   │       │       │           ├── message_loc: (37,4)-(37,5) = "c"
        │   │       │       │           ├── opening_loc: (37,5)-(37,6) = "("
        │   │       │       │           ├── arguments:
        │   │       │       │           │   @ ArgumentsNode (location: (37,6)-(37,7))
        │   │       │       │           │   ├── flags: ∅
        │   │       │       │           │   └── arguments: (length: 1)
        │   │       │       │           │       └── @ CallNode (location: (37,6)-(37,7))
        │   │       │       │           │           ├── flags: variable_call, ignore_visibility
        │   │       │       │           │           ├── receiver: ∅
        │   │       │       │           │           ├── call_operator_loc: ∅
        │   │       │       │           │           ├── name: :d
        │   │       │       │           │           ├── message_loc: (37,6)-(37,7) = "d"
        │   │       │       │           │           ├── opening_loc: ∅
        │   │       │       │           │           ├── arguments: ∅
        │   │       │       │           │           ├── closing_loc: ∅
        │   │       │       │           │           └── block: ∅
        │   │       │       │           ├── closing_loc: (37,7)-(37,8) = ")"
        │   │       │       │           └── block: ∅
        │   │       │       ├── opening_loc: (37,3)-(37,4) = "{"
        │   │       │       └── closing_loc: (37,8)-(37,9) = "}"
        │   │       └── @ RationalNode (location: (37,11)-(37,15))
        │   │           ├── flags: static_literal, decimal
        │   │           ├── numerator: 1
        │   │           └── denominator: 1
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (37,16)-(37,22))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (37,16)-(37,18) = "do"
        │       └── closing_loc: (37,19)-(37,22) = "end"
        └── @ CallNode (location: (39,0)-(39,20))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :a
            ├── message_loc: (39,0)-(39,1) = "a"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (39,2)-(39,13))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ CallNode (location: (39,2)-(39,9))
            │       │   ├── flags: ignore_visibility
            │       │   ├── receiver: ∅
            │       │   ├── call_operator_loc: ∅
            │       │   ├── name: :b
            │       │   ├── message_loc: (39,2)-(39,3) = "b"
            │       │   ├── opening_loc: ∅
            │       │   ├── arguments: ∅
            │       │   ├── closing_loc: ∅
            │       │   └── block:
            │       │       @ BlockNode (location: (39,3)-(39,9))
            │       │       ├── flags: ∅
            │       │       ├── locals: []
            │       │       ├── parameters: ∅
            │       │       ├── body:
            │       │       │   @ StatementsNode (location: (39,4)-(39,8))
            │       │       │   ├── flags: ∅
            │       │       │   └── body: (length: 1)
            │       │       │       └── @ CallNode (location: (39,4)-(39,8))
            │       │       │           ├── flags: newline, ignore_visibility
            │       │       │           ├── receiver: ∅
            │       │       │           ├── call_operator_loc: ∅
            │       │       │           ├── name: :c
            │       │       │           ├── message_loc: (39,4)-(39,5) = "c"
            │       │       │           ├── opening_loc: (39,5)-(39,6) = "("
            │       │       │           ├── arguments:
            │       │       │           │   @ ArgumentsNode (location: (39,6)-(39,7))
            │       │       │           │   ├── flags: ∅
            │       │       │           │   └── arguments: (length: 1)
            │       │       │           │       └── @ CallNode (location: (39,6)-(39,7))
            │       │       │           │           ├── flags: variable_call, ignore_visibility
            │       │       │           │           ├── receiver: ∅
            │       │       │           │           ├── call_operator_loc: ∅
            │       │       │           │           ├── name: :d
            │       │       │           │           ├── message_loc: (39,6)-(39,7) = "d"
            │       │       │           │           ├── opening_loc: ∅
            │       │       │           │           ├── arguments: ∅
            │       │       │           │           ├── closing_loc: ∅
            │       │       │           │           └── block: ∅
            │       │       │           ├── closing_loc: (39,7)-(39,8) = ")"
            │       │       │           └── block: ∅
            │       │       ├── opening_loc: (39,3)-(39,4) = "{"
            │       │       └── closing_loc: (39,8)-(39,9) = "}"
            │       └── @ SymbolNode (location: (39,11)-(39,13))
            │           ├── flags: static_literal, forced_us_ascii_encoding
            │           ├── opening_loc: (39,11)-(39,12) = ":"
            │           ├── value_loc: (39,12)-(39,13) = "e"
            │           ├── closing_loc: ∅
            │           └── unescaped: "e"
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (39,14)-(39,20))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (39,14)-(39,16) = "do"
                └── closing_loc: (39,17)-(39,20) = "end"
prism-1.5.1/snapshots/whitequark/ruby_bug_11873_b.txt000066400000000000000000000152031506127434000225040ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,25))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,25))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,25))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :p
            ├── message_loc: (1,0)-(1,1) = "p"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,18))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ CallNode (location: (1,2)-(1,13))
            │       │   ├── flags: ignore_visibility
            │       │   ├── receiver: ∅
            │       │   ├── call_operator_loc: ∅
            │       │   ├── name: :p
            │       │   ├── message_loc: (1,2)-(1,3) = "p"
            │       │   ├── opening_loc: ∅
            │       │   ├── arguments: ∅
            │       │   ├── closing_loc: ∅
            │       │   └── block:
            │       │       @ BlockNode (location: (1,3)-(1,13))
            │       │       ├── flags: ∅
            │       │       ├── locals: []
            │       │       ├── parameters: ∅
            │       │       ├── body:
            │       │       │   @ StatementsNode (location: (1,4)-(1,12))
            │       │       │   ├── flags: ∅
            │       │       │   └── body: (length: 2)
            │       │       │       ├── @ CallNode (location: (1,4)-(1,8))
            │       │       │       │   ├── flags: newline, ignore_visibility
            │       │       │       │   ├── receiver: ∅
            │       │       │       │   ├── call_operator_loc: ∅
            │       │       │       │   ├── name: :p
            │       │       │       │   ├── message_loc: (1,4)-(1,5) = "p"
            │       │       │       │   ├── opening_loc: (1,5)-(1,6) = "("
            │       │       │       │   ├── arguments:
            │       │       │       │   │   @ ArgumentsNode (location: (1,6)-(1,7))
            │       │       │       │   │   ├── flags: ∅
            │       │       │       │   │   └── arguments: (length: 1)
            │       │       │       │   │       └── @ CallNode (location: (1,6)-(1,7))
            │       │       │       │   │           ├── flags: variable_call, ignore_visibility
            │       │       │       │   │           ├── receiver: ∅
            │       │       │       │   │           ├── call_operator_loc: ∅
            │       │       │       │   │           ├── name: :p
            │       │       │       │   │           ├── message_loc: (1,6)-(1,7) = "p"
            │       │       │       │   │           ├── opening_loc: ∅
            │       │       │       │   │           ├── arguments: ∅
            │       │       │       │   │           ├── closing_loc: ∅
            │       │       │       │   │           └── block: ∅
            │       │       │       │   ├── closing_loc: (1,7)-(1,8) = ")"
            │       │       │       │   └── block: ∅
            │       │       │       └── @ CallNode (location: (1,9)-(1,12))
            │       │       │           ├── flags: newline, ignore_visibility
            │       │       │           ├── receiver: ∅
            │       │       │           ├── call_operator_loc: ∅
            │       │       │           ├── name: :p
            │       │       │           ├── message_loc: (1,9)-(1,10) = "p"
            │       │       │           ├── opening_loc: ∅
            │       │       │           ├── arguments:
            │       │       │           │   @ ArgumentsNode (location: (1,11)-(1,12))
            │       │       │           │   ├── flags: ∅
            │       │       │           │   └── arguments: (length: 1)
            │       │       │           │       └── @ CallNode (location: (1,11)-(1,12))
            │       │       │           │           ├── flags: variable_call, ignore_visibility
            │       │       │           │           ├── receiver: ∅
            │       │       │           │           ├── call_operator_loc: ∅
            │       │       │           │           ├── name: :p
            │       │       │           │           ├── message_loc: (1,11)-(1,12) = "p"
            │       │       │           │           ├── opening_loc: ∅
            │       │       │           │           ├── arguments: ∅
            │       │       │           │           ├── closing_loc: ∅
            │       │       │           │           └── block: ∅
            │       │       │           ├── closing_loc: ∅
            │       │       │           └── block: ∅
            │       │       ├── opening_loc: (1,3)-(1,4) = "{"
            │       │       └── closing_loc: (1,12)-(1,13) = "}"
            │       └── @ CallNode (location: (1,15)-(1,18))
            │           ├── flags: variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :tap
            │           ├── message_loc: (1,15)-(1,18) = "tap"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,19)-(1,25))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (1,19)-(1,21) = "do"
                └── closing_loc: (1,22)-(1,25) = "end"
prism-1.5.1/snapshots/whitequark/ruby_bug_11989.txt000066400000000000000000000022161506127434000222130ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,8))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :p
            ├── message_loc: (1,0)-(1,1) = "p"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,8))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ StringNode (location: (1,2)-(1,8))
            │           ├── flags: ∅
            │           ├── opening_loc: (1,2)-(1,8) = "<<~\"E\""
            │           ├── content_loc: (2,0)-(3,0) = "  x\\n   y\n"
            │           ├── closing_loc: (3,0)-(4,0) = "E\n"
            │           └── unescaped: "x\n   y\n"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/ruby_bug_11990.txt000066400000000000000000000037201506127434000222040ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,12))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :p
            ├── message_loc: (1,0)-(1,1) = "p"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,12))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ InterpolatedStringNode (location: (1,2)-(1,12))
            │           ├── flags: static_literal
            │           ├── opening_loc: ∅
            │           ├── parts: (length: 2)
            │           │   ├── @ StringNode (location: (1,2)-(1,6))
            │           │   │   ├── flags: static_literal, frozen
            │           │   │   ├── opening_loc: (1,2)-(1,6) = "<<~E"
            │           │   │   ├── content_loc: (2,0)-(3,0) = "  x\n"
            │           │   │   ├── closing_loc: (3,0)-(4,0) = "E\n"
            │           │   │   └── unescaped: "x\n"
            │           │   └── @ StringNode (location: (1,7)-(1,12))
            │           │       ├── flags: static_literal, frozen
            │           │       ├── opening_loc: (1,7)-(1,8) = "\""
            │           │       ├── content_loc: (1,8)-(1,11) = "  y"
            │           │       ├── closing_loc: (1,11)-(1,12) = "\""
            │           │       └── unescaped: "  y"
            │           └── closing_loc: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/ruby_bug_12073.txt000066400000000000000000000131421506127434000221740ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,34))
├── flags: ∅
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (1,0)-(3,34))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ LocalVariableWriteNode (location: (1,0)-(1,5))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── depth: 0
        │   ├── name_loc: (1,0)-(1,1) = "a"
        │   ├── value:
        │   │   @ IntegerNode (location: (1,4)-(1,5))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (1,2)-(1,3) = "="
        ├── @ CallNode (location: (1,7)-(1,13))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :a
        │   ├── message_loc: (1,7)-(1,8) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,9)-(1,13))
        │   │   ├── flags: contains_keywords
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (1,9)-(1,13))
        │   │           ├── flags: symbol_keys
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocNode (location: (1,9)-(1,13))
        │   │                   ├── flags: static_literal
        │   │                   ├── key:
        │   │                   │   @ SymbolNode (location: (1,9)-(1,11))
        │   │                   │   ├── flags: static_literal, forced_us_ascii_encoding
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── value_loc: (1,9)-(1,10) = "b"
        │   │                   │   ├── closing_loc: (1,10)-(1,11) = ":"
        │   │                   │   └── unescaped: "b"
        │   │                   ├── value:
        │   │                   │   @ IntegerNode (location: (1,12)-(1,13))
        │   │                   │   ├── flags: static_literal, decimal
        │   │                   │   └── value: 1
        │   │                   └── operator_loc: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ DefNode (location: (3,0)-(3,34))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (3,4)-(3,7) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (3,8)-(3,13))
            │   ├── flags: ∅
            │   ├── requireds: (length: 1)
            │   │   └── @ RequiredParameterNode (location: (3,8)-(3,13))
            │   │       ├── flags: ∅
            │   │       └── name: :raise
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (3,15)-(3,29))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (3,15)-(3,29))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :raise
            │           ├── message_loc: (3,15)-(3,20) = "raise"
            │           ├── opening_loc: ∅
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (3,21)-(3,29))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 2)
            │           │       ├── @ ConstantPathNode (location: (3,21)-(3,25))
            │           │       │   ├── flags: ∅
            │           │       │   ├── parent:
            │           │       │   │   @ ConstantReadNode (location: (3,21)-(3,22))
            │           │       │   │   ├── flags: ∅
            │           │       │   │   └── name: :A
            │           │       │   ├── name: :B
            │           │       │   ├── delimiter_loc: (3,22)-(3,24) = "::"
            │           │       │   └── name_loc: (3,24)-(3,25) = "B"
            │           │       └── @ StringNode (location: (3,27)-(3,29))
            │           │           ├── flags: ∅
            │           │           ├── opening_loc: (3,27)-(3,28) = "'"
            │           │           ├── content_loc: (3,28)-(3,28) = ""
            │           │           ├── closing_loc: (3,28)-(3,29) = "'"
            │           │           └── unescaped: ""
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── locals: [:raise]
            ├── def_keyword_loc: (3,0)-(3,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (3,31)-(3,34) = "end"
prism-1.5.1/snapshots/whitequark/ruby_bug_12402.txt000066400000000000000000001036751506127434000222030ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(27,31))
├── flags: ∅
├── locals: [:foo]
└── statements:
    @ StatementsNode (location: (1,0)-(27,31))
    ├── flags: ∅
    └── body: (length: 14)
        ├── @ LocalVariableOperatorWriteNode (location: (1,0)-(1,27))
        │   ├── flags: newline
        │   ├── name_loc: (1,0)-(1,3) = "foo"
        │   ├── binary_operator_loc: (1,4)-(1,6) = "+="
        │   ├── value:
        │   │   @ RescueModifierNode (location: (1,7)-(1,27))
        │   │   ├── flags: ∅
        │   │   ├── expression:
        │   │   │   @ CallNode (location: (1,7)-(1,16))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :raise
        │   │   │   ├── message_loc: (1,7)-(1,12) = "raise"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (1,13)-(1,16))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ CallNode (location: (1,13)-(1,16))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :bar
        │   │   │   │           ├── message_loc: (1,13)-(1,16) = "bar"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── keyword_loc: (1,17)-(1,23) = "rescue"
        │   │   └── rescue_expression:
        │   │       @ NilNode (location: (1,24)-(1,27))
        │   │       └── flags: static_literal
        │   ├── name: :foo
        │   ├── binary_operator: :+
        │   └── depth: 0
        ├── @ LocalVariableOperatorWriteNode (location: (3,0)-(3,28))
        │   ├── flags: newline
        │   ├── name_loc: (3,0)-(3,3) = "foo"
        │   ├── binary_operator_loc: (3,4)-(3,6) = "+="
        │   ├── value:
        │   │   @ RescueModifierNode (location: (3,7)-(3,28))
        │   │   ├── flags: ∅
        │   │   ├── expression:
        │   │   │   @ CallNode (location: (3,7)-(3,17))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :raise
        │   │   │   ├── message_loc: (3,7)-(3,12) = "raise"
        │   │   │   ├── opening_loc: (3,12)-(3,13) = "("
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (3,13)-(3,16))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ CallNode (location: (3,13)-(3,16))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :bar
        │   │   │   │           ├── message_loc: (3,13)-(3,16) = "bar"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   ├── closing_loc: (3,16)-(3,17) = ")"
        │   │   │   └── block: ∅
        │   │   ├── keyword_loc: (3,18)-(3,24) = "rescue"
        │   │   └── rescue_expression:
        │   │       @ NilNode (location: (3,25)-(3,28))
        │   │       └── flags: static_literal
        │   ├── name: :foo
        │   ├── binary_operator: :+
        │   └── depth: 0
        ├── @ LocalVariableWriteNode (location: (5,0)-(5,26))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── depth: 0
        │   ├── name_loc: (5,0)-(5,3) = "foo"
        │   ├── value:
        │   │   @ RescueModifierNode (location: (5,6)-(5,26))
        │   │   ├── flags: ∅
        │   │   ├── expression:
        │   │   │   @ CallNode (location: (5,6)-(5,15))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :raise
        │   │   │   ├── message_loc: (5,6)-(5,11) = "raise"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (5,12)-(5,15))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ CallNode (location: (5,12)-(5,15))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :bar
        │   │   │   │           ├── message_loc: (5,12)-(5,15) = "bar"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── keyword_loc: (5,16)-(5,22) = "rescue"
        │   │   └── rescue_expression:
        │   │       @ NilNode (location: (5,23)-(5,26))
        │   │       └── flags: static_literal
        │   └── operator_loc: (5,4)-(5,5) = "="
        ├── @ LocalVariableWriteNode (location: (7,0)-(7,27))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── depth: 0
        │   ├── name_loc: (7,0)-(7,3) = "foo"
        │   ├── value:
        │   │   @ RescueModifierNode (location: (7,6)-(7,27))
        │   │   ├── flags: ∅
        │   │   ├── expression:
        │   │   │   @ CallNode (location: (7,6)-(7,16))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :raise
        │   │   │   ├── message_loc: (7,6)-(7,11) = "raise"
        │   │   │   ├── opening_loc: (7,11)-(7,12) = "("
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (7,12)-(7,15))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ CallNode (location: (7,12)-(7,15))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :bar
        │   │   │   │           ├── message_loc: (7,12)-(7,15) = "bar"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   ├── closing_loc: (7,15)-(7,16) = ")"
        │   │   │   └── block: ∅
        │   │   ├── keyword_loc: (7,17)-(7,23) = "rescue"
        │   │   └── rescue_expression:
        │   │       @ NilNode (location: (7,24)-(7,27))
        │   │       └── flags: static_literal
        │   └── operator_loc: (7,4)-(7,5) = "="
        ├── @ CallOperatorWriteNode (location: (9,0)-(9,29))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (9,0)-(9,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: (9,3)-(9,4) = "."
        │   ├── message_loc: (9,4)-(9,5) = "C"
        │   ├── read_name: :C
        │   ├── write_name: :C=
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (9,6)-(9,8) = "+="
        │   └── value:
        │       @ RescueModifierNode (location: (9,9)-(9,29))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (9,9)-(9,18))
        │       │   ├── flags: ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :raise
        │       │   ├── message_loc: (9,9)-(9,14) = "raise"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments:
        │       │   │   @ ArgumentsNode (location: (9,15)-(9,18))
        │       │   │   ├── flags: ∅
        │       │   │   └── arguments: (length: 1)
        │       │   │       └── @ CallNode (location: (9,15)-(9,18))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (9,15)-(9,18) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       ├── keyword_loc: (9,19)-(9,25) = "rescue"
        │       └── rescue_expression:
        │           @ NilNode (location: (9,26)-(9,29))
        │           └── flags: static_literal
        ├── @ CallOperatorWriteNode (location: (11,0)-(11,30))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (11,0)-(11,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: (11,3)-(11,4) = "."
        │   ├── message_loc: (11,4)-(11,5) = "C"
        │   ├── read_name: :C
        │   ├── write_name: :C=
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (11,6)-(11,8) = "+="
        │   └── value:
        │       @ RescueModifierNode (location: (11,9)-(11,30))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (11,9)-(11,19))
        │       │   ├── flags: ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :raise
        │       │   ├── message_loc: (11,9)-(11,14) = "raise"
        │       │   ├── opening_loc: (11,14)-(11,15) = "("
        │       │   ├── arguments:
        │       │   │   @ ArgumentsNode (location: (11,15)-(11,18))
        │       │   │   ├── flags: ∅
        │       │   │   └── arguments: (length: 1)
        │       │   │       └── @ CallNode (location: (11,15)-(11,18))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (11,15)-(11,18) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── closing_loc: (11,18)-(11,19) = ")"
        │       │   └── block: ∅
        │       ├── keyword_loc: (11,20)-(11,26) = "rescue"
        │       └── rescue_expression:
        │           @ NilNode (location: (11,27)-(11,30))
        │           └── flags: static_literal
        ├── @ CallOperatorWriteNode (location: (13,0)-(13,29))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (13,0)-(13,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: (13,3)-(13,4) = "."
        │   ├── message_loc: (13,4)-(13,5) = "m"
        │   ├── read_name: :m
        │   ├── write_name: :m=
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (13,6)-(13,8) = "+="
        │   └── value:
        │       @ RescueModifierNode (location: (13,9)-(13,29))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (13,9)-(13,18))
        │       │   ├── flags: ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :raise
        │       │   ├── message_loc: (13,9)-(13,14) = "raise"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments:
        │       │   │   @ ArgumentsNode (location: (13,15)-(13,18))
        │       │   │   ├── flags: ∅
        │       │   │   └── arguments: (length: 1)
        │       │   │       └── @ CallNode (location: (13,15)-(13,18))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (13,15)-(13,18) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       ├── keyword_loc: (13,19)-(13,25) = "rescue"
        │       └── rescue_expression:
        │           @ NilNode (location: (13,26)-(13,29))
        │           └── flags: static_literal
        ├── @ CallOperatorWriteNode (location: (15,0)-(15,30))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (15,0)-(15,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: (15,3)-(15,4) = "."
        │   ├── message_loc: (15,4)-(15,5) = "m"
        │   ├── read_name: :m
        │   ├── write_name: :m=
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (15,6)-(15,8) = "+="
        │   └── value:
        │       @ RescueModifierNode (location: (15,9)-(15,30))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (15,9)-(15,19))
        │       │   ├── flags: ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :raise
        │       │   ├── message_loc: (15,9)-(15,14) = "raise"
        │       │   ├── opening_loc: (15,14)-(15,15) = "("
        │       │   ├── arguments:
        │       │   │   @ ArgumentsNode (location: (15,15)-(15,18))
        │       │   │   ├── flags: ∅
        │       │   │   └── arguments: (length: 1)
        │       │   │       └── @ CallNode (location: (15,15)-(15,18))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (15,15)-(15,18) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── closing_loc: (15,18)-(15,19) = ")"
        │       │   └── block: ∅
        │       ├── keyword_loc: (15,20)-(15,26) = "rescue"
        │       └── rescue_expression:
        │           @ NilNode (location: (15,27)-(15,30))
        │           └── flags: static_literal
        ├── @ ConstantPathOrWriteNode (location: (17,0)-(17,31))
        │   ├── flags: newline
        │   ├── target:
        │   │   @ ConstantPathNode (location: (17,0)-(17,6))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ LocalVariableReadNode (location: (17,0)-(17,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :foo
        │   │   │   └── depth: 0
        │   │   ├── name: :C
        │   │   ├── delimiter_loc: (17,3)-(17,5) = "::"
        │   │   └── name_loc: (17,5)-(17,6) = "C"
        │   ├── operator_loc: (17,7)-(17,10) = "||="
        │   └── value:
        │       @ RescueModifierNode (location: (17,11)-(17,31))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (17,11)-(17,20))
        │       │   ├── flags: ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :raise
        │       │   ├── message_loc: (17,11)-(17,16) = "raise"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments:
        │       │   │   @ ArgumentsNode (location: (17,17)-(17,20))
        │       │   │   ├── flags: ∅
        │       │   │   └── arguments: (length: 1)
        │       │   │       └── @ CallNode (location: (17,17)-(17,20))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (17,17)-(17,20) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       ├── keyword_loc: (17,21)-(17,27) = "rescue"
        │       └── rescue_expression:
        │           @ NilNode (location: (17,28)-(17,31))
        │           └── flags: static_literal
        ├── @ ConstantPathOrWriteNode (location: (19,0)-(19,32))
        │   ├── flags: newline
        │   ├── target:
        │   │   @ ConstantPathNode (location: (19,0)-(19,6))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ LocalVariableReadNode (location: (19,0)-(19,3))
        │   │   │   ├── flags: ∅
        │   │   │   ├── name: :foo
        │   │   │   └── depth: 0
        │   │   ├── name: :C
        │   │   ├── delimiter_loc: (19,3)-(19,5) = "::"
        │   │   └── name_loc: (19,5)-(19,6) = "C"
        │   ├── operator_loc: (19,7)-(19,10) = "||="
        │   └── value:
        │       @ RescueModifierNode (location: (19,11)-(19,32))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (19,11)-(19,21))
        │       │   ├── flags: ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :raise
        │       │   ├── message_loc: (19,11)-(19,16) = "raise"
        │       │   ├── opening_loc: (19,16)-(19,17) = "("
        │       │   ├── arguments:
        │       │   │   @ ArgumentsNode (location: (19,17)-(19,20))
        │       │   │   ├── flags: ∅
        │       │   │   └── arguments: (length: 1)
        │       │   │       └── @ CallNode (location: (19,17)-(19,20))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (19,17)-(19,20) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── closing_loc: (19,20)-(19,21) = ")"
        │       │   └── block: ∅
        │       ├── keyword_loc: (19,22)-(19,28) = "rescue"
        │       └── rescue_expression:
        │           @ NilNode (location: (19,29)-(19,32))
        │           └── flags: static_literal
        ├── @ CallOperatorWriteNode (location: (21,0)-(21,30))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (21,0)-(21,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: (21,3)-(21,5) = "::"
        │   ├── message_loc: (21,5)-(21,6) = "m"
        │   ├── read_name: :m
        │   ├── write_name: :m=
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (21,7)-(21,9) = "+="
        │   └── value:
        │       @ RescueModifierNode (location: (21,10)-(21,30))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (21,10)-(21,19))
        │       │   ├── flags: ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :raise
        │       │   ├── message_loc: (21,10)-(21,15) = "raise"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments:
        │       │   │   @ ArgumentsNode (location: (21,16)-(21,19))
        │       │   │   ├── flags: ∅
        │       │   │   └── arguments: (length: 1)
        │       │   │       └── @ CallNode (location: (21,16)-(21,19))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (21,16)-(21,19) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       ├── keyword_loc: (21,20)-(21,26) = "rescue"
        │       └── rescue_expression:
        │           @ NilNode (location: (21,27)-(21,30))
        │           └── flags: static_literal
        ├── @ CallOperatorWriteNode (location: (23,0)-(23,31))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (23,0)-(23,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: (23,3)-(23,5) = "::"
        │   ├── message_loc: (23,5)-(23,6) = "m"
        │   ├── read_name: :m
        │   ├── write_name: :m=
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (23,7)-(23,9) = "+="
        │   └── value:
        │       @ RescueModifierNode (location: (23,10)-(23,31))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (23,10)-(23,20))
        │       │   ├── flags: ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :raise
        │       │   ├── message_loc: (23,10)-(23,15) = "raise"
        │       │   ├── opening_loc: (23,15)-(23,16) = "("
        │       │   ├── arguments:
        │       │   │   @ ArgumentsNode (location: (23,16)-(23,19))
        │       │   │   ├── flags: ∅
        │       │   │   └── arguments: (length: 1)
        │       │   │       └── @ CallNode (location: (23,16)-(23,19))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (23,16)-(23,19) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── closing_loc: (23,19)-(23,20) = ")"
        │       │   └── block: ∅
        │       ├── keyword_loc: (23,21)-(23,27) = "rescue"
        │       └── rescue_expression:
        │           @ NilNode (location: (23,28)-(23,31))
        │           └── flags: static_literal
        ├── @ IndexOperatorWriteNode (location: (25,0)-(25,30))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (25,0)-(25,3))
        │   │   ├── flags: ∅
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (25,3)-(25,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (25,4)-(25,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (25,4)-(25,5))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 0
        │   ├── closing_loc: (25,5)-(25,6) = "]"
        │   ├── block: ∅
        │   ├── binary_operator: :+
        │   ├── binary_operator_loc: (25,7)-(25,9) = "+="
        │   └── value:
        │       @ RescueModifierNode (location: (25,10)-(25,30))
        │       ├── flags: ∅
        │       ├── expression:
        │       │   @ CallNode (location: (25,10)-(25,19))
        │       │   ├── flags: ignore_visibility
        │       │   ├── receiver: ∅
        │       │   ├── call_operator_loc: ∅
        │       │   ├── name: :raise
        │       │   ├── message_loc: (25,10)-(25,15) = "raise"
        │       │   ├── opening_loc: ∅
        │       │   ├── arguments:
        │       │   │   @ ArgumentsNode (location: (25,16)-(25,19))
        │       │   │   ├── flags: ∅
        │       │   │   └── arguments: (length: 1)
        │       │   │       └── @ CallNode (location: (25,16)-(25,19))
        │       │   │           ├── flags: variable_call, ignore_visibility
        │       │   │           ├── receiver: ∅
        │       │   │           ├── call_operator_loc: ∅
        │       │   │           ├── name: :bar
        │       │   │           ├── message_loc: (25,16)-(25,19) = "bar"
        │       │   │           ├── opening_loc: ∅
        │       │   │           ├── arguments: ∅
        │       │   │           ├── closing_loc: ∅
        │       │   │           └── block: ∅
        │       │   ├── closing_loc: ∅
        │       │   └── block: ∅
        │       ├── keyword_loc: (25,20)-(25,26) = "rescue"
        │       └── rescue_expression:
        │           @ NilNode (location: (25,27)-(25,30))
        │           └── flags: static_literal
        └── @ IndexOperatorWriteNode (location: (27,0)-(27,31))
            ├── flags: newline
            ├── receiver:
            │   @ LocalVariableReadNode (location: (27,0)-(27,3))
            │   ├── flags: ∅
            │   ├── name: :foo
            │   └── depth: 0
            ├── call_operator_loc: ∅
            ├── opening_loc: (27,3)-(27,4) = "["
            ├── arguments:
            │   @ ArgumentsNode (location: (27,4)-(27,5))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (27,4)-(27,5))
            │           ├── flags: static_literal, decimal
            │           └── value: 0
            ├── closing_loc: (27,5)-(27,6) = "]"
            ├── block: ∅
            ├── binary_operator: :+
            ├── binary_operator_loc: (27,7)-(27,9) = "+="
            └── value:
                @ RescueModifierNode (location: (27,10)-(27,31))
                ├── flags: ∅
                ├── expression:
                │   @ CallNode (location: (27,10)-(27,20))
                │   ├── flags: ignore_visibility
                │   ├── receiver: ∅
                │   ├── call_operator_loc: ∅
                │   ├── name: :raise
                │   ├── message_loc: (27,10)-(27,15) = "raise"
                │   ├── opening_loc: (27,15)-(27,16) = "("
                │   ├── arguments:
                │   │   @ ArgumentsNode (location: (27,16)-(27,19))
                │   │   ├── flags: ∅
                │   │   └── arguments: (length: 1)
                │   │       └── @ CallNode (location: (27,16)-(27,19))
                │   │           ├── flags: variable_call, ignore_visibility
                │   │           ├── receiver: ∅
                │   │           ├── call_operator_loc: ∅
                │   │           ├── name: :bar
                │   │           ├── message_loc: (27,16)-(27,19) = "bar"
                │   │           ├── opening_loc: ∅
                │   │           ├── arguments: ∅
                │   │           ├── closing_loc: ∅
                │   │           └── block: ∅
                │   ├── closing_loc: (27,19)-(27,20) = ")"
                │   └── block: ∅
                ├── keyword_loc: (27,21)-(27,27) = "rescue"
                └── rescue_expression:
                    @ NilNode (location: (27,28)-(27,31))
                    └── flags: static_literal
prism-1.5.1/snapshots/whitequark/ruby_bug_12669.txt000066400000000000000000000173721506127434000222200ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,16))
├── flags: ∅
├── locals: [:a, :b]
└── statements:
    @ StatementsNode (location: (1,0)-(7,16))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ LocalVariableOperatorWriteNode (location: (1,0)-(1,18))
        │   ├── flags: newline
        │   ├── name_loc: (1,0)-(1,1) = "a"
        │   ├── binary_operator_loc: (1,2)-(1,4) = "+="
        │   ├── value:
        │   │   @ LocalVariableOperatorWriteNode (location: (1,5)-(1,18))
        │   │   ├── flags: ∅
        │   │   ├── name_loc: (1,5)-(1,6) = "b"
        │   │   ├── binary_operator_loc: (1,7)-(1,9) = "+="
        │   │   ├── value:
        │   │   │   @ CallNode (location: (1,10)-(1,18))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :raise
        │   │   │   ├── message_loc: (1,10)-(1,15) = "raise"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (1,16)-(1,18))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ SymbolNode (location: (1,16)-(1,18))
        │   │   │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │           ├── opening_loc: (1,16)-(1,17) = ":"
        │   │   │   │           ├── value_loc: (1,17)-(1,18) = "x"
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── unescaped: "x"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── name: :b
        │   │   ├── binary_operator: :+
        │   │   └── depth: 0
        │   ├── name: :a
        │   ├── binary_operator: :+
        │   └── depth: 0
        ├── @ LocalVariableOperatorWriteNode (location: (3,0)-(3,17))
        │   ├── flags: newline
        │   ├── name_loc: (3,0)-(3,1) = "a"
        │   ├── binary_operator_loc: (3,2)-(3,4) = "+="
        │   ├── value:
        │   │   @ LocalVariableWriteNode (location: (3,5)-(3,17))
        │   │   ├── flags: ∅
        │   │   ├── name: :b
        │   │   ├── depth: 0
        │   │   ├── name_loc: (3,5)-(3,6) = "b"
        │   │   ├── value:
        │   │   │   @ CallNode (location: (3,9)-(3,17))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :raise
        │   │   │   ├── message_loc: (3,9)-(3,14) = "raise"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (3,15)-(3,17))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ SymbolNode (location: (3,15)-(3,17))
        │   │   │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │           ├── opening_loc: (3,15)-(3,16) = ":"
        │   │   │   │           ├── value_loc: (3,16)-(3,17) = "x"
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── unescaped: "x"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── operator_loc: (3,7)-(3,8) = "="
        │   ├── name: :a
        │   ├── binary_operator: :+
        │   └── depth: 0
        ├── @ LocalVariableWriteNode (location: (5,0)-(5,17))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── depth: 0
        │   ├── name_loc: (5,0)-(5,1) = "a"
        │   ├── value:
        │   │   @ LocalVariableOperatorWriteNode (location: (5,4)-(5,17))
        │   │   ├── flags: ∅
        │   │   ├── name_loc: (5,4)-(5,5) = "b"
        │   │   ├── binary_operator_loc: (5,6)-(5,8) = "+="
        │   │   ├── value:
        │   │   │   @ CallNode (location: (5,9)-(5,17))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :raise
        │   │   │   ├── message_loc: (5,9)-(5,14) = "raise"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (5,15)-(5,17))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ SymbolNode (location: (5,15)-(5,17))
        │   │   │   │           ├── flags: static_literal, forced_us_ascii_encoding
        │   │   │   │           ├── opening_loc: (5,15)-(5,16) = ":"
        │   │   │   │           ├── value_loc: (5,16)-(5,17) = "x"
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── unescaped: "x"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── name: :b
        │   │   ├── binary_operator: :+
        │   │   └── depth: 0
        │   └── operator_loc: (5,2)-(5,3) = "="
        └── @ LocalVariableWriteNode (location: (7,0)-(7,16))
            ├── flags: newline
            ├── name: :a
            ├── depth: 0
            ├── name_loc: (7,0)-(7,1) = "a"
            ├── value:
            │   @ LocalVariableWriteNode (location: (7,4)-(7,16))
            │   ├── flags: ∅
            │   ├── name: :b
            │   ├── depth: 0
            │   ├── name_loc: (7,4)-(7,5) = "b"
            │   ├── value:
            │   │   @ CallNode (location: (7,8)-(7,16))
            │   │   ├── flags: ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :raise
            │   │   ├── message_loc: (7,8)-(7,13) = "raise"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments:
            │   │   │   @ ArgumentsNode (location: (7,14)-(7,16))
            │   │   │   ├── flags: ∅
            │   │   │   └── arguments: (length: 1)
            │   │   │       └── @ SymbolNode (location: (7,14)-(7,16))
            │   │   │           ├── flags: static_literal, forced_us_ascii_encoding
            │   │   │           ├── opening_loc: (7,14)-(7,15) = ":"
            │   │   │           ├── value_loc: (7,15)-(7,16) = "x"
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── unescaped: "x"
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   └── operator_loc: (7,6)-(7,7) = "="
            └── operator_loc: (7,2)-(7,3) = "="
prism-1.5.1/snapshots/whitequark/ruby_bug_12686.txt000066400000000000000000000047721506127434000222170ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,16))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,16))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,16))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :f
            ├── message_loc: (1,0)-(1,1) = "f"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,2)-(1,16))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ ParenthesesNode (location: (1,2)-(1,16))
            │           ├── flags: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (1,3)-(1,15))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ RescueModifierNode (location: (1,3)-(1,15))
            │           │           ├── flags: newline
            │           │           ├── expression:
            │           │           │   @ CallNode (location: (1,3)-(1,4))
            │           │           │   ├── flags: variable_call, ignore_visibility
            │           │           │   ├── receiver: ∅
            │           │           │   ├── call_operator_loc: ∅
            │           │           │   ├── name: :g
            │           │           │   ├── message_loc: (1,3)-(1,4) = "g"
            │           │           │   ├── opening_loc: ∅
            │           │           │   ├── arguments: ∅
            │           │           │   ├── closing_loc: ∅
            │           │           │   └── block: ∅
            │           │           ├── keyword_loc: (1,5)-(1,11) = "rescue"
            │           │           └── rescue_expression:
            │           │               @ NilNode (location: (1,12)-(1,15))
            │           │               └── flags: static_literal
            │           ├── opening_loc: (1,2)-(1,3) = "("
            │           └── closing_loc: (1,15)-(1,16) = ")"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/ruby_bug_13547.txt000066400000000000000000000026331506127434000222060ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,9))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,4))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :meth
            │   ├── message_loc: (1,0)-(1,4) = "meth"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :[]
            ├── message_loc: (1,4)-(1,6) = "[]"
            ├── opening_loc: (1,4)-(1,5) = "["
            ├── arguments: ∅
            ├── closing_loc: (1,5)-(1,6) = "]"
            └── block:
                @ BlockNode (location: (1,7)-(1,9))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (1,7)-(1,8) = "{"
                └── closing_loc: (1,8)-(1,9) = "}"
prism-1.5.1/snapshots/whitequark/ruby_bug_14690.txt000066400000000000000000000070011506127434000222000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,23))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,23))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,23))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :let
            ├── message_loc: (1,0)-(1,3) = "let"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,6))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ ParenthesesNode (location: (1,4)-(1,6))
            │           ├── flags: ∅
            │           ├── body: ∅
            │           ├── opening_loc: (1,4)-(1,5) = "("
            │           └── closing_loc: (1,5)-(1,6) = ")"
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,7)-(1,23))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body:
                │   @ StatementsNode (location: (1,9)-(1,21))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ CallNode (location: (1,9)-(1,21))
                │           ├── flags: newline, ignore_visibility
                │           ├── receiver: ∅
                │           ├── call_operator_loc: ∅
                │           ├── name: :m
                │           ├── message_loc: (1,9)-(1,10) = "m"
                │           ├── opening_loc: (1,10)-(1,11) = "("
                │           ├── arguments:
                │           │   @ ArgumentsNode (location: (1,11)-(1,12))
                │           │   ├── flags: ∅
                │           │   └── arguments: (length: 1)
                │           │       └── @ CallNode (location: (1,11)-(1,12))
                │           │           ├── flags: variable_call, ignore_visibility
                │           │           ├── receiver: ∅
                │           │           ├── call_operator_loc: ∅
                │           │           ├── name: :a
                │           │           ├── message_loc: (1,11)-(1,12) = "a"
                │           │           ├── opening_loc: ∅
                │           │           ├── arguments: ∅
                │           │           ├── closing_loc: ∅
                │           │           └── block: ∅
                │           ├── closing_loc: (1,12)-(1,13) = ")"
                │           └── block:
                │               @ BlockNode (location: (1,14)-(1,21))
                │               ├── flags: ∅
                │               ├── locals: []
                │               ├── parameters: ∅
                │               ├── body: ∅
                │               ├── opening_loc: (1,14)-(1,16) = "do"
                │               └── closing_loc: (1,18)-(1,21) = "end"
                ├── opening_loc: (1,7)-(1,8) = "{"
                └── closing_loc: (1,22)-(1,23) = "}"
prism-1.5.1/snapshots/whitequark/ruby_bug_15789.txt000066400000000000000000000221441506127434000222170ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,19))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(1,20))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :m
        │   ├── message_loc: (1,0)-(1,1) = "m"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,2)-(1,20))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ LambdaNode (location: (1,2)-(1,20))
        │   │           ├── flags: ∅
        │   │           ├── locals: [:a]
        │   │           ├── operator_loc: (1,2)-(1,4) = "->"
        │   │           ├── opening_loc: (1,17)-(1,18) = "{"
        │   │           ├── closing_loc: (1,19)-(1,20) = "}"
        │   │           ├── parameters:
        │   │           │   @ BlockParametersNode (location: (1,4)-(1,16))
        │   │           │   ├── flags: ∅
        │   │           │   ├── parameters:
        │   │           │   │   @ ParametersNode (location: (1,5)-(1,15))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   ├── requireds: (length: 0)
        │   │           │   │   ├── optionals: (length: 1)
        │   │           │   │   │   └── @ OptionalParameterNode (location: (1,5)-(1,15))
        │   │           │   │   │       ├── flags: ∅
        │   │           │   │   │       ├── name: :a
        │   │           │   │   │       ├── name_loc: (1,5)-(1,6) = "a"
        │   │           │   │   │       ├── operator_loc: (1,7)-(1,8) = "="
        │   │           │   │   │       └── value:
        │   │           │   │   │           @ LambdaNode (location: (1,9)-(1,15))
        │   │           │   │   │           ├── flags: ∅
        │   │           │   │   │           ├── locals: [:_1]
        │   │           │   │   │           ├── operator_loc: (1,9)-(1,11) = "->"
        │   │           │   │   │           ├── opening_loc: (1,11)-(1,12) = "{"
        │   │           │   │   │           ├── closing_loc: (1,14)-(1,15) = "}"
        │   │           │   │   │           ├── parameters:
        │   │           │   │   │           │   @ NumberedParametersNode (location: (1,9)-(1,15))
        │   │           │   │   │           │   ├── flags: ∅
        │   │           │   │   │           │   └── maximum: 1
        │   │           │   │   │           └── body:
        │   │           │   │   │               @ StatementsNode (location: (1,12)-(1,14))
        │   │           │   │   │               ├── flags: ∅
        │   │           │   │   │               └── body: (length: 1)
        │   │           │   │   │                   └── @ LocalVariableReadNode (location: (1,12)-(1,14))
        │   │           │   │   │                       ├── flags: newline
        │   │           │   │   │                       ├── name: :_1
        │   │           │   │   │                       └── depth: 0
        │   │           │   │   ├── rest: ∅
        │   │           │   │   ├── posts: (length: 0)
        │   │           │   │   ├── keywords: (length: 0)
        │   │           │   │   ├── keyword_rest: ∅
        │   │           │   │   └── block: ∅
        │   │           │   ├── locals: (length: 0)
        │   │           │   ├── opening_loc: (1,4)-(1,5) = "("
        │   │           │   └── closing_loc: (1,15)-(1,16) = ")"
        │   │           └── body:
        │   │               @ StatementsNode (location: (1,18)-(1,19))
        │   │               ├── flags: ∅
        │   │               └── body: (length: 1)
        │   │                   └── @ LocalVariableReadNode (location: (1,18)-(1,19))
        │   │                       ├── flags: newline
        │   │                       ├── name: :a
        │   │                       └── depth: 0
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (3,0)-(3,19))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :m
            ├── message_loc: (3,0)-(3,1) = "m"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (3,2)-(3,19))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ LambdaNode (location: (3,2)-(3,19))
            │           ├── flags: ∅
            │           ├── locals: [:a]
            │           ├── operator_loc: (3,2)-(3,4) = "->"
            │           ├── opening_loc: (3,16)-(3,17) = "{"
            │           ├── closing_loc: (3,18)-(3,19) = "}"
            │           ├── parameters:
            │           │   @ BlockParametersNode (location: (3,4)-(3,15))
            │           │   ├── flags: ∅
            │           │   ├── parameters:
            │           │   │   @ ParametersNode (location: (3,5)-(3,14))
            │           │   │   ├── flags: ∅
            │           │   │   ├── requireds: (length: 0)
            │           │   │   ├── optionals: (length: 0)
            │           │   │   ├── rest: ∅
            │           │   │   ├── posts: (length: 0)
            │           │   │   ├── keywords: (length: 1)
            │           │   │   │   └── @ OptionalKeywordParameterNode (location: (3,5)-(3,14))
            │           │   │   │       ├── flags: ∅
            │           │   │   │       ├── name: :a
            │           │   │   │       ├── name_loc: (3,5)-(3,7) = "a:"
            │           │   │   │       └── value:
            │           │   │   │           @ LambdaNode (location: (3,8)-(3,14))
            │           │   │   │           ├── flags: ∅
            │           │   │   │           ├── locals: [:_1]
            │           │   │   │           ├── operator_loc: (3,8)-(3,10) = "->"
            │           │   │   │           ├── opening_loc: (3,10)-(3,11) = "{"
            │           │   │   │           ├── closing_loc: (3,13)-(3,14) = "}"
            │           │   │   │           ├── parameters:
            │           │   │   │           │   @ NumberedParametersNode (location: (3,8)-(3,14))
            │           │   │   │           │   ├── flags: ∅
            │           │   │   │           │   └── maximum: 1
            │           │   │   │           └── body:
            │           │   │   │               @ StatementsNode (location: (3,11)-(3,13))
            │           │   │   │               ├── flags: ∅
            │           │   │   │               └── body: (length: 1)
            │           │   │   │                   └── @ LocalVariableReadNode (location: (3,11)-(3,13))
            │           │   │   │                       ├── flags: newline
            │           │   │   │                       ├── name: :_1
            │           │   │   │                       └── depth: 0
            │           │   │   ├── keyword_rest: ∅
            │           │   │   └── block: ∅
            │           │   ├── locals: (length: 0)
            │           │   ├── opening_loc: (3,4)-(3,5) = "("
            │           │   └── closing_loc: (3,14)-(3,15) = ")"
            │           └── body:
            │               @ StatementsNode (location: (3,17)-(3,18))
            │               ├── flags: ∅
            │               └── body: (length: 1)
            │                   └── @ LocalVariableReadNode (location: (3,17)-(3,18))
            │                       ├── flags: newline
            │                       ├── name: :a
            │                       └── depth: 0
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/ruby_bug_18878.txt000066400000000000000000000047051506127434000222240ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,19))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,19))
            ├── flags: newline
            ├── receiver:
            │   @ ConstantReadNode (location: (1,0)-(1,3))
            │   ├── flags: ∅
            │   └── name: :Foo
            ├── call_operator_loc: (1,3)-(1,5) = "::"
            ├── name: :Bar
            ├── message_loc: (1,5)-(1,8) = "Bar"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,9)-(1,19))
                ├── flags: ∅
                ├── locals: [:a]
                ├── parameters:
                │   @ BlockParametersNode (location: (1,11)-(1,14))
                │   ├── flags: ∅
                │   ├── parameters:
                │   │   @ ParametersNode (location: (1,12)-(1,13))
                │   │   ├── flags: ∅
                │   │   ├── requireds: (length: 1)
                │   │   │   └── @ RequiredParameterNode (location: (1,12)-(1,13))
                │   │   │       ├── flags: ∅
                │   │   │       └── name: :a
                │   │   ├── optionals: (length: 0)
                │   │   ├── rest: ∅
                │   │   ├── posts: (length: 0)
                │   │   ├── keywords: (length: 0)
                │   │   ├── keyword_rest: ∅
                │   │   └── block: ∅
                │   ├── locals: (length: 0)
                │   ├── opening_loc: (1,11)-(1,12) = "|"
                │   └── closing_loc: (1,13)-(1,14) = "|"
                ├── body:
                │   @ StatementsNode (location: (1,15)-(1,17))
                │   ├── flags: ∅
                │   └── body: (length: 1)
                │       └── @ IntegerNode (location: (1,15)-(1,17))
                │           ├── flags: newline, static_literal, decimal
                │           └── value: 42
                ├── opening_loc: (1,9)-(1,10) = "{"
                └── closing_loc: (1,18)-(1,19) = "}"
prism-1.5.1/snapshots/whitequark/ruby_bug_19281.txt000066400000000000000000000244311506127434000222070ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(7,11))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ CallNode (location: (1,0)-(1,17))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (1,0)-(1,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (1,1)-(1,2) = "."
        │   ├── name: :b
        │   ├── message_loc: (1,2)-(1,3) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,4)-(1,17))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 3)
        │   │       ├── @ ParenthesesNode (location: (1,4)-(1,9))
        │   │       │   ├── flags: multiple_statements
        │   │       │   ├── body:
        │   │       │   │   @ StatementsNode (location: (1,5)-(1,8))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 2)
        │   │       │   │       ├── @ IntegerNode (location: (1,5)-(1,6))
        │   │       │   │       │   ├── flags: newline, static_literal, decimal
        │   │       │   │       │   └── value: 1
        │   │       │   │       └── @ IntegerNode (location: (1,7)-(1,8))
        │   │       │   │           ├── flags: newline, static_literal, decimal
        │   │       │   │           └── value: 2
        │   │       │   ├── opening_loc: (1,4)-(1,5) = "("
        │   │       │   └── closing_loc: (1,8)-(1,9) = ")"
        │   │       ├── @ ParenthesesNode (location: (1,10)-(1,13))
        │   │       │   ├── flags: ∅
        │   │       │   ├── body:
        │   │       │   │   @ StatementsNode (location: (1,11)-(1,12))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ IntegerNode (location: (1,11)-(1,12))
        │   │       │   │           ├── flags: newline, static_literal, decimal
        │   │       │   │           └── value: 3
        │   │       │   ├── opening_loc: (1,10)-(1,11) = "("
        │   │       │   └── closing_loc: (1,12)-(1,13) = ")"
        │   │       └── @ ParenthesesNode (location: (1,14)-(1,17))
        │   │           ├── flags: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (1,15)-(1,16))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ IntegerNode (location: (1,15)-(1,16))
        │   │           │           ├── flags: newline, static_literal, decimal
        │   │           │           └── value: 4
        │   │           ├── opening_loc: (1,14)-(1,15) = "("
        │   │           └── closing_loc: (1,16)-(1,17) = ")"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,13))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,1))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :a
        │   │   ├── message_loc: (3,0)-(3,1) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (3,1)-(3,2) = "."
        │   ├── name: :b
        │   ├── message_loc: (3,2)-(3,3) = "b"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,4)-(3,13))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 3)
        │   │       ├── @ ParenthesesNode (location: (3,4)-(3,7))
        │   │       │   ├── flags: multiple_statements
        │   │       │   ├── body: ∅
        │   │       │   ├── opening_loc: (3,4)-(3,5) = "("
        │   │       │   └── closing_loc: (3,6)-(3,7) = ")"
        │   │       ├── @ ParenthesesNode (location: (3,8)-(3,10))
        │   │       │   ├── flags: ∅
        │   │       │   ├── body: ∅
        │   │       │   ├── opening_loc: (3,8)-(3,9) = "("
        │   │       │   └── closing_loc: (3,9)-(3,10) = ")"
        │   │       └── @ ParenthesesNode (location: (3,11)-(3,13))
        │   │           ├── flags: ∅
        │   │           ├── body: ∅
        │   │           ├── opening_loc: (3,11)-(3,12) = "("
        │   │           └── closing_loc: (3,12)-(3,13) = ")"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (5,0)-(5,15))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :p
        │   ├── message_loc: (5,0)-(5,1) = "p"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (5,2)-(5,15))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 3)
        │   │       ├── @ ParenthesesNode (location: (5,2)-(5,7))
        │   │       │   ├── flags: multiple_statements
        │   │       │   ├── body:
        │   │       │   │   @ StatementsNode (location: (5,3)-(5,6))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 2)
        │   │       │   │       ├── @ IntegerNode (location: (5,3)-(5,4))
        │   │       │   │       │   ├── flags: newline, static_literal, decimal
        │   │       │   │       │   └── value: 1
        │   │       │   │       └── @ IntegerNode (location: (5,5)-(5,6))
        │   │       │   │           ├── flags: newline, static_literal, decimal
        │   │       │   │           └── value: 2
        │   │       │   ├── opening_loc: (5,2)-(5,3) = "("
        │   │       │   └── closing_loc: (5,6)-(5,7) = ")"
        │   │       ├── @ ParenthesesNode (location: (5,8)-(5,11))
        │   │       │   ├── flags: ∅
        │   │       │   ├── body:
        │   │       │   │   @ StatementsNode (location: (5,9)-(5,10))
        │   │       │   │   ├── flags: ∅
        │   │       │   │   └── body: (length: 1)
        │   │       │   │       └── @ IntegerNode (location: (5,9)-(5,10))
        │   │       │   │           ├── flags: newline, static_literal, decimal
        │   │       │   │           └── value: 3
        │   │       │   ├── opening_loc: (5,8)-(5,9) = "("
        │   │       │   └── closing_loc: (5,10)-(5,11) = ")"
        │   │       └── @ ParenthesesNode (location: (5,12)-(5,15))
        │   │           ├── flags: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (5,13)-(5,14))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ IntegerNode (location: (5,13)-(5,14))
        │   │           │           ├── flags: newline, static_literal, decimal
        │   │           │           └── value: 4
        │   │           ├── opening_loc: (5,12)-(5,13) = "("
        │   │           └── closing_loc: (5,14)-(5,15) = ")"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (7,0)-(7,11))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :p
            ├── message_loc: (7,0)-(7,1) = "p"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (7,2)-(7,11))
            │   ├── flags: ∅
            │   └── arguments: (length: 3)
            │       ├── @ ParenthesesNode (location: (7,2)-(7,5))
            │       │   ├── flags: multiple_statements
            │       │   ├── body: ∅
            │       │   ├── opening_loc: (7,2)-(7,3) = "("
            │       │   └── closing_loc: (7,4)-(7,5) = ")"
            │       ├── @ ParenthesesNode (location: (7,6)-(7,8))
            │       │   ├── flags: ∅
            │       │   ├── body: ∅
            │       │   ├── opening_loc: (7,6)-(7,7) = "("
            │       │   └── closing_loc: (7,7)-(7,8) = ")"
            │       └── @ ParenthesesNode (location: (7,9)-(7,11))
            │           ├── flags: ∅
            │           ├── body: ∅
            │           ├── opening_loc: (7,9)-(7,10) = "("
            │           └── closing_loc: (7,10)-(7,11) = ")"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/ruby_bug_19539.txt000066400000000000000000000015431506127434000222140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(6,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(6,9))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ StringNode (location: (1,0)-(1,8))
        │   ├── flags: newline
        │   ├── opening_loc: (1,0)-(1,8) = "<<' FOO'"
        │   ├── content_loc: (2,0)-(3,0) = "[Bug #19539]\n"
        │   ├── closing_loc: (3,0)-(4,0) = " FOO\n"
        │   └── unescaped: "[Bug #19539]\n"
        └── @ StringNode (location: (6,0)-(6,9))
            ├── flags: newline
            ├── opening_loc: (6,0)-(6,9) = "<<-' FOO'"
            ├── content_loc: (7,0)-(8,0) = "[Bug #19539]\n"
            ├── closing_loc: (8,0)-(9,0) = " FOO\n"
            └── unescaped: "[Bug #19539]\n"
prism-1.5.1/snapshots/whitequark/ruby_bug_9669.txt000066400000000000000000000064641506127434000221460ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(8,1))
├── flags: ∅
├── locals: [:o]
└── statements:
    @ StatementsNode (location: (1,0)-(8,1))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ DefNode (location: (1,0)-(3,3))
        │   ├── flags: newline
        │   ├── name: :a
        │   ├── name_loc: (1,4)-(1,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters:
        │   │   @ ParametersNode (location: (1,6)-(1,8))
        │   │   ├── flags: ∅
        │   │   ├── requireds: (length: 0)
        │   │   ├── optionals: (length: 0)
        │   │   ├── rest: ∅
        │   │   ├── posts: (length: 0)
        │   │   ├── keywords: (length: 1)
        │   │   │   └── @ RequiredKeywordParameterNode (location: (1,6)-(1,8))
        │   │   │       ├── flags: ∅
        │   │   │       ├── name: :b
        │   │   │       └── name_loc: (1,6)-(1,8) = "b:"
        │   │   ├── keyword_rest: ∅
        │   │   └── block: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (2,0)-(2,6))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ ReturnNode (location: (2,0)-(2,6))
        │   │           ├── flags: newline
        │   │           ├── keyword_loc: (2,0)-(2,6) = "return"
        │   │           └── arguments: ∅
        │   ├── locals: [:b]
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (3,0)-(3,3) = "end"
        └── @ LocalVariableWriteNode (location: (5,0)-(8,1))
            ├── flags: newline
            ├── name: :o
            ├── depth: 0
            ├── name_loc: (5,0)-(5,1) = "o"
            ├── value:
            │   @ HashNode (location: (5,4)-(8,1))
            │   ├── flags: static_literal
            │   ├── opening_loc: (5,4)-(5,5) = "{"
            │   ├── elements: (length: 1)
            │   │   └── @ AssocNode (location: (6,0)-(7,1))
            │   │       ├── flags: static_literal
            │   │       ├── key:
            │   │       │   @ SymbolNode (location: (6,0)-(6,2))
            │   │       │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │       │   ├── opening_loc: ∅
            │   │       │   ├── value_loc: (6,0)-(6,1) = "a"
            │   │       │   ├── closing_loc: (6,1)-(6,2) = ":"
            │   │       │   └── unescaped: "a"
            │   │       ├── value:
            │   │       │   @ IntegerNode (location: (7,0)-(7,1))
            │   │       │   ├── flags: static_literal, decimal
            │   │       │   └── value: 1
            │   │       └── operator_loc: ∅
            │   └── closing_loc: (8,0)-(8,1) = "}"
            └── operator_loc: (5,2)-(5,3) = "="
prism-1.5.1/snapshots/whitequark/sclass.txt000066400000000000000000000025061506127434000211140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,22))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,22))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ SingletonClassNode (location: (1,0)-(1,22))
            ├── flags: newline
            ├── locals: []
            ├── class_keyword_loc: (1,0)-(1,5) = "class"
            ├── operator_loc: (1,6)-(1,8) = "<<"
            ├── expression:
            │   @ CallNode (location: (1,9)-(1,12))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,9)-(1,12) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,14)-(1,17))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ NilNode (location: (1,14)-(1,17))
            │           └── flags: newline, static_literal
            └── end_keyword_loc: (1,19)-(1,22) = "end"
prism-1.5.1/snapshots/whitequark/self.txt000066400000000000000000000004461506127434000205560ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ SelfNode (location: (1,0)-(1,4))
            └── flags: newline
prism-1.5.1/snapshots/whitequark/send_attr_asgn.txt000066400000000000000000000122461506127434000226210ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(7,10))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ CallNode (location: (1,0)-(1,9))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (1,3)-(1,4) = "."
        │   ├── name: :A=
        │   ├── message_loc: (1,4)-(1,5) = "A"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,8)-(1,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (1,8)-(1,9))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,9))
        │   ├── flags: newline, attribute_write
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (3,3)-(3,4) = "."
        │   ├── name: :a=
        │   ├── message_loc: (3,4)-(3,5) = "a"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,8)-(3,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (3,8)-(3,9))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ ConstantPathWriteNode (location: (5,0)-(5,10))
        │   ├── flags: newline
        │   ├── target:
        │   │   @ ConstantPathNode (location: (5,0)-(5,6))
        │   │   ├── flags: ∅
        │   │   ├── parent:
        │   │   │   @ CallNode (location: (5,0)-(5,3))
        │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (5,0)-(5,3) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── name: :A
        │   │   ├── delimiter_loc: (5,3)-(5,5) = "::"
        │   │   └── name_loc: (5,5)-(5,6) = "A"
        │   ├── operator_loc: (5,7)-(5,8) = "="
        │   └── value:
        │       @ IntegerNode (location: (5,9)-(5,10))
        │       ├── flags: static_literal, decimal
        │       └── value: 1
        └── @ CallNode (location: (7,0)-(7,10))
            ├── flags: newline, attribute_write
            ├── receiver:
            │   @ CallNode (location: (7,0)-(7,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (7,0)-(7,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (7,3)-(7,5) = "::"
            ├── name: :a=
            ├── message_loc: (7,5)-(7,6) = "a"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (7,9)-(7,10))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (7,9)-(7,10))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/send_attr_asgn_conditional.txt000066400000000000000000000026651506127434000252100ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,8))
            ├── flags: newline, safe_navigation, attribute_write
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (1,1)-(1,3) = "&."
            ├── name: :b=
            ├── message_loc: (1,3)-(1,4) = "b"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,7)-(1,8))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (1,7)-(1,8))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/send_binary_op.txt000066400000000000000000000643501506127434000226240ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(41,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(41,7))
    ├── flags: ∅
    └── body: (length: 21)
        ├── @ CallNode (location: (1,0)-(1,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :!=
        │   ├── message_loc: (1,4)-(1,6) = "!="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,7)-(1,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (1,7)-(1,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :!~
        │   ├── message_loc: (3,4)-(3,6) = "!~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,7)-(3,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (3,7)-(3,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (5,0)-(5,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (5,0)-(5,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (5,0)-(5,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :%
        │   ├── message_loc: (5,4)-(5,5) = "%"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (5,6)-(5,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (5,6)-(5,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (7,0)-(7,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (7,0)-(7,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (7,0)-(7,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :&
        │   ├── message_loc: (7,4)-(7,5) = "&"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (7,6)-(7,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (7,6)-(7,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (9,0)-(9,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (9,0)-(9,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (9,0)-(9,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :*
        │   ├── message_loc: (9,4)-(9,5) = "*"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (9,6)-(9,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (9,6)-(9,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (11,0)-(11,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (11,0)-(11,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (11,0)-(11,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :**
        │   ├── message_loc: (11,4)-(11,6) = "**"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (11,7)-(11,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (11,7)-(11,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (13,0)-(13,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (13,0)-(13,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (13,0)-(13,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :+
        │   ├── message_loc: (13,4)-(13,5) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (13,6)-(13,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (13,6)-(13,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (15,0)-(15,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (15,0)-(15,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (15,0)-(15,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :-
        │   ├── message_loc: (15,4)-(15,5) = "-"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (15,6)-(15,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (15,6)-(15,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (17,0)-(17,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (17,0)-(17,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (17,0)-(17,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :/
        │   ├── message_loc: (17,4)-(17,5) = "/"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (17,6)-(17,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (17,6)-(17,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (19,0)-(19,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (19,0)-(19,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (19,0)-(19,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :<
        │   ├── message_loc: (19,4)-(19,5) = "<"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (19,6)-(19,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (19,6)-(19,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (21,0)-(21,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (21,0)-(21,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (21,0)-(21,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :<<
        │   ├── message_loc: (21,4)-(21,6) = "<<"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (21,7)-(21,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (21,7)-(21,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (23,0)-(23,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (23,0)-(23,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (23,0)-(23,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :<=
        │   ├── message_loc: (23,4)-(23,6) = "<="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (23,7)-(23,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (23,7)-(23,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (25,0)-(25,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (25,0)-(25,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (25,0)-(25,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :<=>
        │   ├── message_loc: (25,4)-(25,7) = "<=>"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (25,8)-(25,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (25,8)-(25,9))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (27,0)-(27,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (27,0)-(27,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (27,0)-(27,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :==
        │   ├── message_loc: (27,4)-(27,6) = "=="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (27,7)-(27,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (27,7)-(27,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (29,0)-(29,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (29,0)-(29,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (29,0)-(29,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :===
        │   ├── message_loc: (29,4)-(29,7) = "==="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (29,8)-(29,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (29,8)-(29,9))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (31,0)-(31,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (31,0)-(31,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (31,0)-(31,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :=~
        │   ├── message_loc: (31,4)-(31,6) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (31,7)-(31,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (31,7)-(31,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (33,0)-(33,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (33,0)-(33,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (33,0)-(33,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :>
        │   ├── message_loc: (33,4)-(33,5) = ">"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (33,6)-(33,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (33,6)-(33,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (35,0)-(35,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (35,0)-(35,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (35,0)-(35,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :>=
        │   ├── message_loc: (35,4)-(35,6) = ">="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (35,7)-(35,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (35,7)-(35,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (37,0)-(37,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (37,0)-(37,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (37,0)-(37,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :>>
        │   ├── message_loc: (37,4)-(37,6) = ">>"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (37,7)-(37,8))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (37,7)-(37,8))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (39,0)-(39,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (39,0)-(39,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (39,0)-(39,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :^
        │   ├── message_loc: (39,4)-(39,5) = "^"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (39,6)-(39,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (39,6)-(39,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (41,0)-(41,7))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (41,0)-(41,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (41,0)-(41,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :|
            ├── message_loc: (41,4)-(41,5) = "|"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (41,6)-(41,7))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (41,6)-(41,7))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/send_block_chain_cmd.txt000066400000000000000000000422211506127434000237120ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(13,23))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(13,23))
    ├── flags: ∅
    └── body: (length: 7)
        ├── @ CallNode (location: (1,0)-(1,21))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,13))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :meth
        │   │   ├── message_loc: (1,0)-(1,4) = "meth"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (1,5)-(1,6))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (1,5)-(1,6))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (1,7)-(1,13))
        │   │       ├── flags: ∅
        │   │       ├── locals: []
        │   │       ├── parameters: ∅
        │   │       ├── body: ∅
        │   │       ├── opening_loc: (1,7)-(1,9) = "do"
        │   │       └── closing_loc: (1,10)-(1,13) = "end"
        │   ├── call_operator_loc: (1,13)-(1,14) = "."
        │   ├── name: :fun
        │   ├── message_loc: (1,14)-(1,17) = "fun"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,18)-(1,21))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (1,18)-(1,21))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (1,18)-(1,21) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,28))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,13))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :meth
        │   │   ├── message_loc: (3,0)-(3,4) = "meth"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (3,5)-(3,6))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (3,5)-(3,6))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (3,7)-(3,13))
        │   │       ├── flags: ∅
        │   │       ├── locals: []
        │   │       ├── parameters: ∅
        │   │       ├── body: ∅
        │   │       ├── opening_loc: (3,7)-(3,9) = "do"
        │   │       └── closing_loc: (3,10)-(3,13) = "end"
        │   ├── call_operator_loc: (3,13)-(3,14) = "."
        │   ├── name: :fun
        │   ├── message_loc: (3,14)-(3,17) = "fun"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,18)-(3,21))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (3,18)-(3,21))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (3,18)-(3,21) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (3,22)-(3,28))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (3,22)-(3,24) = "do"
        │       └── closing_loc: (3,25)-(3,28) = "end"
        ├── @ CallNode (location: (5,0)-(5,20))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (5,0)-(5,13))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :meth
        │   │   ├── message_loc: (5,0)-(5,4) = "meth"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (5,5)-(5,6))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (5,5)-(5,6))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (5,7)-(5,13))
        │   │       ├── flags: ∅
        │   │       ├── locals: []
        │   │       ├── parameters: ∅
        │   │       ├── body: ∅
        │   │       ├── opening_loc: (5,7)-(5,9) = "do"
        │   │       └── closing_loc: (5,10)-(5,13) = "end"
        │   ├── call_operator_loc: (5,13)-(5,14) = "."
        │   ├── name: :fun
        │   ├── message_loc: (5,14)-(5,17) = "fun"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (5,18)-(5,20))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (5,18)-(5,19) = "{"
        │       └── closing_loc: (5,19)-(5,20) = "}"
        ├── @ CallNode (location: (7,0)-(7,22))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (7,0)-(7,13))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :meth
        │   │   ├── message_loc: (7,0)-(7,4) = "meth"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (7,5)-(7,6))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (7,5)-(7,6))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (7,7)-(7,13))
        │   │       ├── flags: ∅
        │   │       ├── locals: []
        │   │       ├── parameters: ∅
        │   │       ├── body: ∅
        │   │       ├── opening_loc: (7,7)-(7,9) = "do"
        │   │       └── closing_loc: (7,10)-(7,13) = "end"
        │   ├── call_operator_loc: (7,13)-(7,14) = "."
        │   ├── name: :fun
        │   ├── message_loc: (7,14)-(7,17) = "fun"
        │   ├── opening_loc: (7,17)-(7,18) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (7,18)-(7,21))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (7,18)-(7,21))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (7,18)-(7,21) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (7,21)-(7,22) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (9,0)-(9,25))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (9,0)-(9,13))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :meth
        │   │   ├── message_loc: (9,0)-(9,4) = "meth"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (9,5)-(9,6))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (9,5)-(9,6))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (9,7)-(9,13))
        │   │       ├── flags: ∅
        │   │       ├── locals: []
        │   │       ├── parameters: ∅
        │   │       ├── body: ∅
        │   │       ├── opening_loc: (9,7)-(9,9) = "do"
        │   │       └── closing_loc: (9,10)-(9,13) = "end"
        │   ├── call_operator_loc: (9,13)-(9,14) = "."
        │   ├── name: :fun
        │   ├── message_loc: (9,14)-(9,17) = "fun"
        │   ├── opening_loc: (9,17)-(9,18) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (9,18)-(9,21))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (9,18)-(9,21))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (9,18)-(9,21) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (9,21)-(9,22) = ")"
        │   └── block:
        │       @ BlockNode (location: (9,23)-(9,25))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (9,23)-(9,24) = "{"
        │       └── closing_loc: (9,24)-(9,25) = "}"
        ├── @ CallNode (location: (11,0)-(11,22))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (11,0)-(11,13))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :meth
        │   │   ├── message_loc: (11,0)-(11,4) = "meth"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (11,5)-(11,6))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (11,5)-(11,6))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── closing_loc: ∅
        │   │   └── block:
        │   │       @ BlockNode (location: (11,7)-(11,13))
        │   │       ├── flags: ∅
        │   │       ├── locals: []
        │   │       ├── parameters: ∅
        │   │       ├── body: ∅
        │   │       ├── opening_loc: (11,7)-(11,9) = "do"
        │   │       └── closing_loc: (11,10)-(11,13) = "end"
        │   ├── call_operator_loc: (11,13)-(11,15) = "::"
        │   ├── name: :fun
        │   ├── message_loc: (11,15)-(11,18) = "fun"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (11,19)-(11,22))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (11,19)-(11,22))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (11,19)-(11,22) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (13,0)-(13,23))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (13,0)-(13,13))
            │   ├── flags: ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :meth
            │   ├── message_loc: (13,0)-(13,4) = "meth"
            │   ├── opening_loc: ∅
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (13,5)-(13,6))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 1)
            │   │       └── @ IntegerNode (location: (13,5)-(13,6))
            │   │           ├── flags: static_literal, decimal
            │   │           └── value: 1
            │   ├── closing_loc: ∅
            │   └── block:
            │       @ BlockNode (location: (13,7)-(13,13))
            │       ├── flags: ∅
            │       ├── locals: []
            │       ├── parameters: ∅
            │       ├── body: ∅
            │       ├── opening_loc: (13,7)-(13,9) = "do"
            │       └── closing_loc: (13,10)-(13,13) = "end"
            ├── call_operator_loc: (13,13)-(13,15) = "::"
            ├── name: :fun
            ├── message_loc: (13,15)-(13,18) = "fun"
            ├── opening_loc: (13,18)-(13,19) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (13,19)-(13,22))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ CallNode (location: (13,19)-(13,22))
            │           ├── flags: variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (13,19)-(13,22) = "bar"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── closing_loc: (13,22)-(13,23) = ")"
            └── block: ∅
prism-1.5.1/snapshots/whitequark/send_block_conditional.txt000066400000000000000000000026461506127434000243170ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,11))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,11))
            ├── flags: newline, safe_navigation
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,0)-(1,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (1,3)-(1,5) = "&."
            ├── name: :bar
            ├── message_loc: (1,5)-(1,8) = "bar"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,9)-(1,11))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (1,9)-(1,10) = "{"
                └── closing_loc: (1,10)-(1,11) = "}"
prism-1.5.1/snapshots/whitequark/send_call.txt000066400000000000000000000052631506127434000215530ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,8))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ CallNode (location: (1,0)-(1,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (1,3)-(1,4) = "."
        │   ├── name: :call
        │   ├── message_loc: ∅
        │   ├── opening_loc: (1,4)-(1,5) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,5)-(1,6))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (1,5)-(1,6))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: (1,6)-(1,7) = ")"
        │   └── block: ∅
        └── @ CallNode (location: (3,0)-(3,8))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (3,0)-(3,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (3,0)-(3,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (3,3)-(3,5) = "::"
            ├── name: :call
            ├── message_loc: ∅
            ├── opening_loc: (3,5)-(3,6) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (3,6)-(3,7))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (3,6)-(3,7))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: (3,7)-(3,8) = ")"
            └── block: ∅
prism-1.5.1/snapshots/whitequark/send_conditional.txt000066400000000000000000000021351506127434000231360ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,4))
            ├── flags: newline, safe_navigation
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (1,1)-(1,3) = "&."
            ├── name: :b
            ├── message_loc: (1,3)-(1,4) = "b"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/send_index.txt000066400000000000000000000031431506127434000217420ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,9))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,0)-(1,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :[]
            ├── message_loc: (1,3)-(1,9) = "[1, 2]"
            ├── opening_loc: (1,3)-(1,4) = "["
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,8))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ IntegerNode (location: (1,4)-(1,5))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 1
            │       └── @ IntegerNode (location: (1,7)-(1,8))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: (1,8)-(1,9) = "]"
            └── block: ∅
prism-1.5.1/snapshots/whitequark/send_index_asgn.txt000066400000000000000000000034651506127434000227610ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,13))
            ├── flags: newline, attribute_write
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,0)-(1,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :[]=
            ├── message_loc: (1,3)-(1,9) = "[1, 2]"
            ├── opening_loc: (1,3)-(1,4) = "["
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,13))
            │   ├── flags: ∅
            │   └── arguments: (length: 3)
            │       ├── @ IntegerNode (location: (1,4)-(1,5))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 1
            │       ├── @ IntegerNode (location: (1,7)-(1,8))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 2
            │       └── @ IntegerNode (location: (1,12)-(1,13))
            │           ├── flags: static_literal, decimal
            │           └── value: 3
            ├── closing_loc: (1,8)-(1,9) = "]"
            └── block: ∅
prism-1.5.1/snapshots/whitequark/send_index_asgn_legacy.txt000066400000000000000000000034651506127434000243050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,13))
            ├── flags: newline, attribute_write
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,0)-(1,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :[]=
            ├── message_loc: (1,3)-(1,9) = "[1, 2]"
            ├── opening_loc: (1,3)-(1,4) = "["
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,13))
            │   ├── flags: ∅
            │   └── arguments: (length: 3)
            │       ├── @ IntegerNode (location: (1,4)-(1,5))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 1
            │       ├── @ IntegerNode (location: (1,7)-(1,8))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 2
            │       └── @ IntegerNode (location: (1,12)-(1,13))
            │           ├── flags: static_literal, decimal
            │           └── value: 3
            ├── closing_loc: (1,8)-(1,9) = "]"
            └── block: ∅
prism-1.5.1/snapshots/whitequark/send_index_cmd.txt000066400000000000000000000052441506127434000225710ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,10))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,10))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,0)-(1,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :[]
            ├── message_loc: (1,3)-(1,10) = "[m bar]"
            ├── opening_loc: (1,3)-(1,4) = "["
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,9))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ CallNode (location: (1,4)-(1,9))
            │           ├── flags: ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :m
            │           ├── message_loc: (1,4)-(1,5) = "m"
            │           ├── opening_loc: ∅
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,6)-(1,9))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 1)
            │           │       └── @ CallNode (location: (1,6)-(1,9))
            │           │           ├── flags: variable_call, ignore_visibility
            │           │           ├── receiver: ∅
            │           │           ├── call_operator_loc: ∅
            │           │           ├── name: :bar
            │           │           ├── message_loc: (1,6)-(1,9) = "bar"
            │           │           ├── opening_loc: ∅
            │           │           ├── arguments: ∅
            │           │           ├── closing_loc: ∅
            │           │           └── block: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── closing_loc: (1,9)-(1,10) = "]"
            └── block: ∅
prism-1.5.1/snapshots/whitequark/send_index_legacy.txt000066400000000000000000000031431506127434000232660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,9))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,0)-(1,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :[]
            ├── message_loc: (1,3)-(1,9) = "[1, 2]"
            ├── opening_loc: (1,3)-(1,4) = "["
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,8))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ IntegerNode (location: (1,4)-(1,5))
            │       │   ├── flags: static_literal, decimal
            │       │   └── value: 1
            │       └── @ IntegerNode (location: (1,7)-(1,8))
            │           ├── flags: static_literal, decimal
            │           └── value: 2
            ├── closing_loc: (1,8)-(1,9) = "]"
            └── block: ∅
prism-1.5.1/snapshots/whitequark/send_lambda.txt000066400000000000000000000045271506127434000220620ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,5))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ LambdaNode (location: (1,0)-(1,8))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── operator_loc: (1,0)-(1,2) = "->"
        │   ├── opening_loc: (1,5)-(1,6) = "{"
        │   ├── closing_loc: (1,7)-(1,8) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (1,3)-(1,4))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (1,3)-(1,4))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 0)
        │   │   │   ├── optionals: (length: 0)
        │   │   │   ├── rest:
        │   │   │   │   @ RestParameterNode (location: (1,3)-(1,4))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   ├── name: ∅
        │   │   │   │   ├── name_loc: ∅
        │   │   │   │   └── operator_loc: (1,3)-(1,4) = "*"
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 0)
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── body: ∅
        ├── @ LambdaNode (location: (3,0)-(3,9))
        │   ├── flags: newline
        │   ├── locals: []
        │   ├── operator_loc: (3,0)-(3,2) = "->"
        │   ├── opening_loc: (3,3)-(3,5) = "do"
        │   ├── closing_loc: (3,6)-(3,9) = "end"
        │   ├── parameters: ∅
        │   └── body: ∅
        └── @ LambdaNode (location: (5,0)-(5,5))
            ├── flags: newline
            ├── locals: []
            ├── operator_loc: (5,0)-(5,2) = "->"
            ├── opening_loc: (5,2)-(5,3) = "{"
            ├── closing_loc: (5,4)-(5,5) = "}"
            ├── parameters: ∅
            └── body: ∅
prism-1.5.1/snapshots/whitequark/send_lambda_args.txt000066400000000000000000000055521506127434000230750ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,9))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ LambdaNode (location: (1,0)-(1,10))
        │   ├── flags: newline
        │   ├── locals: [:a]
        │   ├── operator_loc: (1,0)-(1,2) = "->"
        │   ├── opening_loc: (1,7)-(1,8) = "{"
        │   ├── closing_loc: (1,9)-(1,10) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (1,3)-(1,6))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (1,4)-(1,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 1)
        │   │   │   │   └── @ RequiredParameterNode (location: (1,4)-(1,5))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       └── name: :a
        │   │   │   ├── optionals: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 0)
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: (1,3)-(1,4) = "("
        │   │   └── closing_loc: (1,5)-(1,6) = ")"
        │   └── body: ∅
        └── @ LambdaNode (location: (3,0)-(3,9))
            ├── flags: newline
            ├── locals: [:a]
            ├── operator_loc: (3,0)-(3,2) = "->"
            ├── opening_loc: (3,6)-(3,7) = "{"
            ├── closing_loc: (3,8)-(3,9) = "}"
            ├── parameters:
            │   @ BlockParametersNode (location: (3,2)-(3,5))
            │   ├── flags: ∅
            │   ├── parameters:
            │   │   @ ParametersNode (location: (3,3)-(3,4))
            │   │   ├── flags: ∅
            │   │   ├── requireds: (length: 1)
            │   │   │   └── @ RequiredParameterNode (location: (3,3)-(3,4))
            │   │   │       ├── flags: ∅
            │   │   │       └── name: :a
            │   │   ├── optionals: (length: 0)
            │   │   ├── rest: ∅
            │   │   ├── posts: (length: 0)
            │   │   ├── keywords: (length: 0)
            │   │   ├── keyword_rest: ∅
            │   │   └── block: ∅
            │   ├── locals: (length: 0)
            │   ├── opening_loc: (3,2)-(3,3) = "("
            │   └── closing_loc: (3,4)-(3,5) = ")"
            └── body: ∅
prism-1.5.1/snapshots/whitequark/send_lambda_args_noparen.txt000066400000000000000000000063441506127434000246170ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,9))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ LambdaNode (location: (1,0)-(1,11))
        │   ├── flags: newline
        │   ├── locals: [:a]
        │   ├── operator_loc: (1,0)-(1,2) = "->"
        │   ├── opening_loc: (1,8)-(1,9) = "{"
        │   ├── closing_loc: (1,10)-(1,11) = "}"
        │   ├── parameters:
        │   │   @ BlockParametersNode (location: (1,3)-(1,7))
        │   │   ├── flags: ∅
        │   │   ├── parameters:
        │   │   │   @ ParametersNode (location: (1,3)-(1,7))
        │   │   │   ├── flags: ∅
        │   │   │   ├── requireds: (length: 0)
        │   │   │   ├── optionals: (length: 0)
        │   │   │   ├── rest: ∅
        │   │   │   ├── posts: (length: 0)
        │   │   │   ├── keywords: (length: 1)
        │   │   │   │   └── @ OptionalKeywordParameterNode (location: (1,3)-(1,7))
        │   │   │   │       ├── flags: ∅
        │   │   │   │       ├── name: :a
        │   │   │   │       ├── name_loc: (1,3)-(1,5) = "a:"
        │   │   │   │       └── value:
        │   │   │   │           @ IntegerNode (location: (1,6)-(1,7))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   ├── keyword_rest: ∅
        │   │   │   └── block: ∅
        │   │   ├── locals: (length: 0)
        │   │   ├── opening_loc: ∅
        │   │   └── closing_loc: ∅
        │   └── body: ∅
        └── @ LambdaNode (location: (3,0)-(3,9))
            ├── flags: newline
            ├── locals: [:a]
            ├── operator_loc: (3,0)-(3,2) = "->"
            ├── opening_loc: (3,6)-(3,7) = "{"
            ├── closing_loc: (3,8)-(3,9) = "}"
            ├── parameters:
            │   @ BlockParametersNode (location: (3,3)-(3,5))
            │   ├── flags: ∅
            │   ├── parameters:
            │   │   @ ParametersNode (location: (3,3)-(3,5))
            │   │   ├── flags: ∅
            │   │   ├── requireds: (length: 0)
            │   │   ├── optionals: (length: 0)
            │   │   ├── rest: ∅
            │   │   ├── posts: (length: 0)
            │   │   ├── keywords: (length: 1)
            │   │   │   └── @ RequiredKeywordParameterNode (location: (3,3)-(3,5))
            │   │   │       ├── flags: ∅
            │   │   │       ├── name: :a
            │   │   │       └── name_loc: (3,3)-(3,5) = "a:"
            │   │   ├── keyword_rest: ∅
            │   │   └── block: ∅
            │   ├── locals: (length: 0)
            │   ├── opening_loc: ∅
            │   └── closing_loc: ∅
            └── body: ∅
prism-1.5.1/snapshots/whitequark/send_lambda_args_shadow.txt000066400000000000000000000036071506127434000244410ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,19))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LambdaNode (location: (1,0)-(1,19))
            ├── flags: newline
            ├── locals: [:a, :foo, :bar]
            ├── operator_loc: (1,0)-(1,2) = "->"
            ├── opening_loc: (1,16)-(1,17) = "{"
            ├── closing_loc: (1,18)-(1,19) = "}"
            ├── parameters:
            │   @ BlockParametersNode (location: (1,2)-(1,15))
            │   ├── flags: ∅
            │   ├── parameters:
            │   │   @ ParametersNode (location: (1,3)-(1,4))
            │   │   ├── flags: ∅
            │   │   ├── requireds: (length: 1)
            │   │   │   └── @ RequiredParameterNode (location: (1,3)-(1,4))
            │   │   │       ├── flags: ∅
            │   │   │       └── name: :a
            │   │   ├── optionals: (length: 0)
            │   │   ├── rest: ∅
            │   │   ├── posts: (length: 0)
            │   │   ├── keywords: (length: 0)
            │   │   ├── keyword_rest: ∅
            │   │   └── block: ∅
            │   ├── locals: (length: 2)
            │   │   ├── @ BlockLocalVariableNode (location: (1,6)-(1,9))
            │   │   │   ├── flags: ∅
            │   │   │   └── name: :foo
            │   │   └── @ BlockLocalVariableNode (location: (1,11)-(1,14))
            │   │       ├── flags: ∅
            │   │       └── name: :bar
            │   ├── opening_loc: (1,2)-(1,3) = "("
            │   └── closing_loc: (1,14)-(1,15) = ")"
            └── body: ∅
prism-1.5.1/snapshots/whitequark/send_lambda_legacy.txt000066400000000000000000000010601506127434000233730ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LambdaNode (location: (1,0)-(1,5))
            ├── flags: newline
            ├── locals: []
            ├── operator_loc: (1,0)-(1,2) = "->"
            ├── opening_loc: (1,2)-(1,3) = "{"
            ├── closing_loc: (1,4)-(1,5) = "}"
            ├── parameters: ∅
            └── body: ∅
prism-1.5.1/snapshots/whitequark/send_op_asgn_conditional.txt000066400000000000000000000023471506127434000246510ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,10))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallAndWriteNode (location: (1,0)-(1,10))
            ├── flags: newline, safe_navigation
            ├── receiver:
            │   @ CallNode (location: (1,0)-(1,1))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :a
            │   ├── message_loc: (1,0)-(1,1) = "a"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (1,1)-(1,3) = "&."
            ├── message_loc: (1,3)-(1,4) = "b"
            ├── read_name: :b
            ├── write_name: :b=
            ├── operator_loc: (1,5)-(1,8) = "&&="
            └── value:
                @ IntegerNode (location: (1,9)-(1,10))
                ├── flags: static_literal, decimal
                └── value: 1
prism-1.5.1/snapshots/whitequark/send_plain.txt000066400000000000000000000057151506127434000217450ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,8))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ CallNode (location: (1,0)-(1,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (1,3)-(1,4) = "."
        │   ├── name: :fun
        │   ├── message_loc: (1,4)-(1,7) = "fun"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (3,3)-(3,5) = "::"
        │   ├── name: :Fun
        │   ├── message_loc: (3,5)-(3,8) = "Fun"
        │   ├── opening_loc: (3,8)-(3,9) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (3,9)-(3,10) = ")"
        │   └── block: ∅
        └── @ CallNode (location: (5,0)-(5,8))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (5,0)-(5,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (5,0)-(5,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (5,3)-(5,5) = "::"
            ├── name: :fun
            ├── message_loc: (5,5)-(5,8) = "fun"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/send_plain_cmd.txt000066400000000000000000000121251506127434000225610ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,12))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ CallNode (location: (1,0)-(1,11))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (1,3)-(1,4) = "."
        │   ├── name: :fun
        │   ├── message_loc: (1,4)-(1,7) = "fun"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,8)-(1,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (1,8)-(1,11))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (1,8)-(1,11) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,12))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (3,3)-(3,5) = "::"
        │   ├── name: :Fun
        │   ├── message_loc: (3,5)-(3,8) = "Fun"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,9)-(3,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (3,9)-(3,12))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (3,9)-(3,12) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (5,0)-(5,12))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (5,0)-(5,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (5,0)-(5,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: (5,3)-(5,5) = "::"
            ├── name: :fun
            ├── message_loc: (5,5)-(5,8) = "fun"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (5,9)-(5,12))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ CallNode (location: (5,9)-(5,12))
            │           ├── flags: variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (5,9)-(5,12) = "bar"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/send_self.txt000066400000000000000000000035411506127434000215660ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,6))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ CallNode (location: (1,0)-(1,3))
        │   ├── flags: newline, variable_call, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :fun
        │   ├── message_loc: (1,0)-(1,3) = "fun"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,4))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :fun!
        │   ├── message_loc: (3,0)-(3,4) = "fun!"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (5,0)-(5,6))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :fun
            ├── message_loc: (5,0)-(5,3) = "fun"
            ├── opening_loc: (5,3)-(5,4) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (5,4)-(5,5))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (5,4)-(5,5))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: (5,5)-(5,6) = ")"
            └── block: ∅
prism-1.5.1/snapshots/whitequark/send_self_block.txt000066400000000000000000000071051506127434000227400ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(7,10))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ CallNode (location: (1,0)-(1,10))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :fun
        │   ├── message_loc: (1,0)-(1,3) = "fun"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,4)-(1,10))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (1,4)-(1,6) = "do"
        │       └── closing_loc: (1,7)-(1,10) = "end"
        ├── @ CallNode (location: (3,0)-(3,7))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :fun
        │   ├── message_loc: (3,0)-(3,3) = "fun"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (3,4)-(3,7))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (3,4)-(3,5) = "{"
        │       └── closing_loc: (3,6)-(3,7) = "}"
        ├── @ CallNode (location: (5,0)-(5,9))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :fun
        │   ├── message_loc: (5,0)-(5,3) = "fun"
        │   ├── opening_loc: (5,3)-(5,4) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (5,4)-(5,5) = ")"
        │   └── block:
        │       @ BlockNode (location: (5,6)-(5,9))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (5,6)-(5,7) = "{"
        │       └── closing_loc: (5,8)-(5,9) = "}"
        └── @ CallNode (location: (7,0)-(7,10))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :fun
            ├── message_loc: (7,0)-(7,3) = "fun"
            ├── opening_loc: (7,3)-(7,4) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (7,4)-(7,5))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ IntegerNode (location: (7,4)-(7,5))
            │           ├── flags: static_literal, decimal
            │           └── value: 1
            ├── closing_loc: (7,5)-(7,6) = ")"
            └── block:
                @ BlockNode (location: (7,7)-(7,10))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (7,7)-(7,8) = "{"
                └── closing_loc: (7,9)-(7,10) = "}"
prism-1.5.1/snapshots/whitequark/send_unary_op.txt000066400000000000000000000055711506127434000224760ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,4))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ CallNode (location: (1,0)-(1,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,1)-(1,4))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,1)-(1,4) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :+@
        │   ├── message_loc: (1,0)-(1,1) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,4))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (3,1)-(3,4))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,1)-(3,4) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :-@
        │   ├── message_loc: (3,0)-(3,1) = "-"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (5,0)-(5,4))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (5,1)-(5,4))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (5,1)-(5,4) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :~
            ├── message_loc: (5,0)-(5,1) = "~"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/slash_newline_in_heredocs.txt000066400000000000000000000035341506127434000250230ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(8,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(8,4))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ StringNode (location: (1,0)-(1,4))
        │   ├── flags: newline
        │   ├── opening_loc: (1,0)-(1,4) = "<<-E"
        │   ├── content_loc: (2,0)-(5,0) = "    1 \\\n    2\n    3\n"
        │   ├── closing_loc: (5,0)-(6,0) = "E\n"
        │   └── unescaped: "    1     2\n    3\n"
        └── @ InterpolatedStringNode (location: (8,0)-(8,4))
            ├── flags: newline, static_literal
            ├── opening_loc: (8,0)-(8,4) = "<<~E"
            ├── parts: (length: 3)
            │   ├── @ StringNode (location: (9,0)-(10,0))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (9,0)-(10,0) = "    1 \\\n"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "1 "
            │   ├── @ StringNode (location: (10,0)-(11,0))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (10,0)-(11,0) = "    2\n"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "2\n"
            │   └── @ StringNode (location: (11,0)-(12,0))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (11,0)-(12,0) = "    3\n"
            │       ├── closing_loc: ∅
            │       └── unescaped: "3\n"
            └── closing_loc: (12,0)-(13,0) = "E\n"
prism-1.5.1/snapshots/whitequark/space_args_arg.txt000066400000000000000000000027221506127434000225640ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,7))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,7))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,7))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :fun
            ├── message_loc: (1,0)-(1,3) = "fun"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,7))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ ParenthesesNode (location: (1,4)-(1,7))
            │           ├── flags: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (1,5)-(1,6))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ IntegerNode (location: (1,5)-(1,6))
            │           │           ├── flags: newline, static_literal, decimal
            │           │           └── value: 1
            │           ├── opening_loc: (1,4)-(1,5) = "("
            │           └── closing_loc: (1,6)-(1,7) = ")"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/space_args_arg_block.txt000066400000000000000000000140111506127434000237300ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,10))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ CallNode (location: (1,0)-(1,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (1,0)-(1,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (1,3)-(1,4) = "."
        │   ├── name: :fun
        │   ├── message_loc: (1,4)-(1,7) = "fun"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,8)-(1,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ParenthesesNode (location: (1,8)-(1,11))
        │   │           ├── flags: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (1,9)-(1,10))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ IntegerNode (location: (1,9)-(1,10))
        │   │           │           ├── flags: newline, static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── opening_loc: (1,8)-(1,9) = "("
        │   │           └── closing_loc: (1,10)-(1,11) = ")"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (1,12)-(1,14))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (1,12)-(1,13) = "{"
        │       └── closing_loc: (1,13)-(1,14) = "}"
        ├── @ CallNode (location: (3,0)-(3,15))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (3,3)-(3,5) = "::"
        │   ├── name: :fun
        │   ├── message_loc: (3,5)-(3,8) = "fun"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,9)-(3,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ ParenthesesNode (location: (3,9)-(3,12))
        │   │           ├── flags: ∅
        │   │           ├── body:
        │   │           │   @ StatementsNode (location: (3,10)-(3,11))
        │   │           │   ├── flags: ∅
        │   │           │   └── body: (length: 1)
        │   │           │       └── @ IntegerNode (location: (3,10)-(3,11))
        │   │           │           ├── flags: newline, static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── opening_loc: (3,9)-(3,10) = "("
        │   │           └── closing_loc: (3,11)-(3,12) = ")"
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (3,13)-(3,15))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (3,13)-(3,14) = "{"
        │       └── closing_loc: (3,14)-(3,15) = "}"
        └── @ CallNode (location: (5,0)-(5,10))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :fun
            ├── message_loc: (5,0)-(5,3) = "fun"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (5,4)-(5,7))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ ParenthesesNode (location: (5,4)-(5,7))
            │           ├── flags: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (5,5)-(5,6))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ IntegerNode (location: (5,5)-(5,6))
            │           │           ├── flags: newline, static_literal, decimal
            │           │           └── value: 1
            │           ├── opening_loc: (5,4)-(5,5) = "("
            │           └── closing_loc: (5,6)-(5,7) = ")"
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (5,8)-(5,10))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (5,8)-(5,9) = "{"
                └── closing_loc: (5,9)-(5,10) = "}"
prism-1.5.1/snapshots/whitequark/space_args_arg_call.txt000066400000000000000000000040771506127434000235640ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,12))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :fun
            ├── message_loc: (1,0)-(1,3) = "fun"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,12))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ CallNode (location: (1,4)-(1,12))
            │           ├── flags: ∅
            │           ├── receiver:
            │           │   @ ParenthesesNode (location: (1,4)-(1,7))
            │           │   ├── flags: ∅
            │           │   ├── body:
            │           │   │   @ StatementsNode (location: (1,5)-(1,6))
            │           │   │   ├── flags: ∅
            │           │   │   └── body: (length: 1)
            │           │   │       └── @ IntegerNode (location: (1,5)-(1,6))
            │           │   │           ├── flags: newline, static_literal, decimal
            │           │   │           └── value: 1
            │           │   ├── opening_loc: (1,4)-(1,5) = "("
            │           │   └── closing_loc: (1,6)-(1,7) = ")"
            │           ├── call_operator_loc: (1,7)-(1,8) = "."
            │           ├── name: :to_i
            │           ├── message_loc: (1,8)-(1,12) = "to_i"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/space_args_arg_newline.txt000066400000000000000000000027221506127434000243050ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(2,1))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(2,1))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(2,1))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :fun
            ├── message_loc: (1,0)-(1,3) = "fun"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(2,1))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ ParenthesesNode (location: (1,4)-(2,1))
            │           ├── flags: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (1,5)-(1,6))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ IntegerNode (location: (1,5)-(1,6))
            │           │           ├── flags: newline, static_literal, decimal
            │           │           └── value: 1
            │           ├── opening_loc: (1,4)-(1,5) = "("
            │           └── closing_loc: (2,0)-(2,1) = ")"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/space_args_block.txt000066400000000000000000000025551506127434000231110ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,9))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,9))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,9))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :fun
            ├── message_loc: (1,0)-(1,3) = "fun"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,6))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ ParenthesesNode (location: (1,4)-(1,6))
            │           ├── flags: ∅
            │           ├── body: ∅
            │           ├── opening_loc: (1,4)-(1,5) = "("
            │           └── closing_loc: (1,5)-(1,6) = ")"
            ├── closing_loc: ∅
            └── block:
                @ BlockNode (location: (1,7)-(1,9))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (1,7)-(1,8) = "{"
                └── closing_loc: (1,8)-(1,9) = "}"
prism-1.5.1/snapshots/whitequark/space_args_cmd.txt000066400000000000000000000057531506127434000225650ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,11))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CallNode (location: (1,0)-(1,11))
            ├── flags: newline, ignore_visibility
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── name: :fun
            ├── message_loc: (1,0)-(1,3) = "fun"
            ├── opening_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (1,4)-(1,11))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ ParenthesesNode (location: (1,4)-(1,11))
            │           ├── flags: ∅
            │           ├── body:
            │           │   @ StatementsNode (location: (1,5)-(1,10))
            │           │   ├── flags: ∅
            │           │   └── body: (length: 1)
            │           │       └── @ CallNode (location: (1,5)-(1,10))
            │           │           ├── flags: newline, ignore_visibility
            │           │           ├── receiver: ∅
            │           │           ├── call_operator_loc: ∅
            │           │           ├── name: :f
            │           │           ├── message_loc: (1,5)-(1,6) = "f"
            │           │           ├── opening_loc: ∅
            │           │           ├── arguments:
            │           │           │   @ ArgumentsNode (location: (1,7)-(1,10))
            │           │           │   ├── flags: ∅
            │           │           │   └── arguments: (length: 1)
            │           │           │       └── @ CallNode (location: (1,7)-(1,10))
            │           │           │           ├── flags: variable_call, ignore_visibility
            │           │           │           ├── receiver: ∅
            │           │           │           ├── call_operator_loc: ∅
            │           │           │           ├── name: :bar
            │           │           │           ├── message_loc: (1,7)-(1,10) = "bar"
            │           │           │           ├── opening_loc: ∅
            │           │           │           ├── arguments: ∅
            │           │           │           ├── closing_loc: ∅
            │           │           │           └── block: ∅
            │           │           ├── closing_loc: ∅
            │           │           └── block: ∅
            │           ├── opening_loc: (1,4)-(1,5) = "("
            │           └── closing_loc: (1,10)-(1,11) = ")"
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/string___FILE__.txt000066400000000000000000000005551506127434000225270ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ SourceFileNode (location: (1,0)-(1,8))
            ├── flags: newline
            └── filepath: "whitequark/string___FILE__.txt"
prism-1.5.1/snapshots/whitequark/string_concat.txt000066400000000000000000000037331506127434000224640ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,14))
            ├── flags: newline
            ├── opening_loc: ∅
            ├── parts: (length: 2)
            │   ├── @ InterpolatedStringNode (location: (1,0)-(1,8))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (1,0)-(1,1) = "\""
            │   │   ├── parts: (length: 2)
            │   │   │   ├── @ StringNode (location: (1,1)-(1,4))
            │   │   │   │   ├── flags: static_literal, frozen
            │   │   │   │   ├── opening_loc: ∅
            │   │   │   │   ├── content_loc: (1,1)-(1,4) = "foo"
            │   │   │   │   ├── closing_loc: ∅
            │   │   │   │   └── unescaped: "foo"
            │   │   │   └── @ EmbeddedVariableNode (location: (1,4)-(1,7))
            │   │   │       ├── flags: ∅
            │   │   │       ├── operator_loc: (1,4)-(1,5) = "#"
            │   │   │       └── variable:
            │   │   │           @ InstanceVariableReadNode (location: (1,5)-(1,7))
            │   │   │           ├── flags: ∅
            │   │   │           └── name: :@a
            │   │   └── closing_loc: (1,7)-(1,8) = "\""
            │   └── @ StringNode (location: (1,9)-(1,14))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: (1,9)-(1,10) = "\""
            │       ├── content_loc: (1,10)-(1,13) = "bar"
            │       ├── closing_loc: (1,13)-(1,14) = "\""
            │       └── unescaped: "bar"
            └── closing_loc: ∅
prism-1.5.1/snapshots/whitequark/string_dvar.txt000066400000000000000000000044721506127434000221520ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,14))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "\""
            ├── parts: (length: 5)
            │   ├── @ EmbeddedVariableNode (location: (1,1)-(1,4))
            │   │   ├── flags: ∅
            │   │   ├── operator_loc: (1,1)-(1,2) = "#"
            │   │   └── variable:
            │   │       @ InstanceVariableReadNode (location: (1,2)-(1,4))
            │   │       ├── flags: ∅
            │   │       └── name: :@a
            │   ├── @ StringNode (location: (1,4)-(1,5))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (1,4)-(1,5) = " "
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: " "
            │   ├── @ EmbeddedVariableNode (location: (1,5)-(1,9))
            │   │   ├── flags: ∅
            │   │   ├── operator_loc: (1,5)-(1,6) = "#"
            │   │   └── variable:
            │   │       @ ClassVariableReadNode (location: (1,6)-(1,9))
            │   │       ├── flags: ∅
            │   │       └── name: :@@a
            │   ├── @ StringNode (location: (1,9)-(1,10))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (1,9)-(1,10) = " "
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: " "
            │   └── @ EmbeddedVariableNode (location: (1,10)-(1,13))
            │       ├── flags: ∅
            │       ├── operator_loc: (1,10)-(1,11) = "#"
            │       └── variable:
            │           @ GlobalVariableReadNode (location: (1,11)-(1,13))
            │           ├── flags: ∅
            │           └── name: :$a
            └── closing_loc: (1,13)-(1,14) = "\""
prism-1.5.1/snapshots/whitequark/string_interp.txt000066400000000000000000000044301506127434000225110ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedStringNode (location: (1,0)-(1,14))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "\""
            ├── parts: (length: 3)
            │   ├── @ StringNode (location: (1,1)-(1,4))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (1,1)-(1,4) = "foo"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "foo"
            │   ├── @ EmbeddedStatementsNode (location: (1,4)-(1,10))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (1,4)-(1,6) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (1,6)-(1,9))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ CallNode (location: (1,6)-(1,9))
            │   │   │           ├── flags: variable_call, ignore_visibility
            │   │   │           ├── receiver: ∅
            │   │   │           ├── call_operator_loc: ∅
            │   │   │           ├── name: :bar
            │   │   │           ├── message_loc: (1,6)-(1,9) = "bar"
            │   │   │           ├── opening_loc: ∅
            │   │   │           ├── arguments: ∅
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── block: ∅
            │   │   └── closing_loc: (1,9)-(1,10) = "}"
            │   └── @ StringNode (location: (1,10)-(1,13))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (1,10)-(1,13) = "baz"
            │       ├── closing_loc: ∅
            │       └── unescaped: "baz"
            └── closing_loc: (1,13)-(1,14) = "\""
prism-1.5.1/snapshots/whitequark/string_plain.txt000066400000000000000000000014561506127434000223200ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,8))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ StringNode (location: (1,0)-(1,10))
        │   ├── flags: newline
        │   ├── opening_loc: (1,0)-(1,3) = "%q("
        │   ├── content_loc: (1,3)-(1,9) = "foobar"
        │   ├── closing_loc: (1,9)-(1,10) = ")"
        │   └── unescaped: "foobar"
        └── @ StringNode (location: (3,0)-(3,8))
            ├── flags: newline
            ├── opening_loc: (3,0)-(3,1) = "'"
            ├── content_loc: (3,1)-(3,7) = "foobar"
            ├── closing_loc: (3,7)-(3,8) = "'"
            └── unescaped: "foobar"
prism-1.5.1/snapshots/whitequark/super.txt000066400000000000000000000051041506127434000207570ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,10))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ SuperNode (location: (1,0)-(1,9))
        │   ├── flags: newline
        │   ├── keyword_loc: (1,0)-(1,5) = "super"
        │   ├── lparen_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,6)-(1,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (1,6)-(1,9))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :foo
        │   │           ├── message_loc: (1,6)-(1,9) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rparen_loc: ∅
        │   └── block: ∅
        ├── @ SuperNode (location: (3,0)-(3,7))
        │   ├── flags: newline
        │   ├── keyword_loc: (3,0)-(3,5) = "super"
        │   ├── lparen_loc: (3,5)-(3,6) = "("
        │   ├── arguments: ∅
        │   ├── rparen_loc: (3,6)-(3,7) = ")"
        │   └── block: ∅
        └── @ SuperNode (location: (5,0)-(5,10))
            ├── flags: newline
            ├── keyword_loc: (5,0)-(5,5) = "super"
            ├── lparen_loc: (5,5)-(5,6) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (5,6)-(5,9))
            │   ├── flags: ∅
            │   └── arguments: (length: 1)
            │       └── @ CallNode (location: (5,6)-(5,9))
            │           ├── flags: variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :foo
            │           ├── message_loc: (5,6)-(5,9) = "foo"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── rparen_loc: (5,9)-(5,10) = ")"
            └── block: ∅
prism-1.5.1/snapshots/whitequark/super_block.txt000066400000000000000000000050571506127434000221400ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,21))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,21))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ ForwardingSuperNode (location: (1,0)-(1,12))
        │   ├── flags: newline
        │   └── block:
        │       @ BlockNode (location: (1,6)-(1,12))
        │       ├── flags: ∅
        │       ├── locals: []
        │       ├── parameters: ∅
        │       ├── body: ∅
        │       ├── opening_loc: (1,6)-(1,8) = "do"
        │       └── closing_loc: (1,9)-(1,12) = "end"
        └── @ SuperNode (location: (3,0)-(3,21))
            ├── flags: newline
            ├── keyword_loc: (3,0)-(3,5) = "super"
            ├── lparen_loc: ∅
            ├── arguments:
            │   @ ArgumentsNode (location: (3,6)-(3,14))
            │   ├── flags: ∅
            │   └── arguments: (length: 2)
            │       ├── @ CallNode (location: (3,6)-(3,9))
            │       │   ├── flags: variable_call, ignore_visibility
            │       │   ├── receiver: ∅
            │       │   ├── call_operator_loc: ∅
            │       │   ├── name: :foo
            │       │   ├── message_loc: (3,6)-(3,9) = "foo"
            │       │   ├── opening_loc: ∅
            │       │   ├── arguments: ∅
            │       │   ├── closing_loc: ∅
            │       │   └── block: ∅
            │       └── @ CallNode (location: (3,11)-(3,14))
            │           ├── flags: variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (3,11)-(3,14) = "bar"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── rparen_loc: ∅
            └── block:
                @ BlockNode (location: (3,15)-(3,21))
                ├── flags: ∅
                ├── locals: []
                ├── parameters: ∅
                ├── body: ∅
                ├── opening_loc: (3,15)-(3,17) = "do"
                └── closing_loc: (3,18)-(3,21) = "end"
prism-1.5.1/snapshots/whitequark/symbol_interp.txt000066400000000000000000000044351506127434000225150ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,15))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,15))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedSymbolNode (location: (1,0)-(1,15))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,2) = ":\""
            ├── parts: (length: 3)
            │   ├── @ StringNode (location: (1,2)-(1,5))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (1,2)-(1,5) = "foo"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "foo"
            │   ├── @ EmbeddedStatementsNode (location: (1,5)-(1,11))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (1,5)-(1,7) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (1,7)-(1,10))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ CallNode (location: (1,7)-(1,10))
            │   │   │           ├── flags: variable_call, ignore_visibility
            │   │   │           ├── receiver: ∅
            │   │   │           ├── call_operator_loc: ∅
            │   │   │           ├── name: :bar
            │   │   │           ├── message_loc: (1,7)-(1,10) = "bar"
            │   │   │           ├── opening_loc: ∅
            │   │   │           ├── arguments: ∅
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── block: ∅
            │   │   └── closing_loc: (1,10)-(1,11) = "}"
            │   └── @ StringNode (location: (1,11)-(1,14))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (1,11)-(1,14) = "baz"
            │       ├── closing_loc: ∅
            │       └── unescaped: "baz"
            └── closing_loc: (1,14)-(1,15) = "\""
prism-1.5.1/snapshots/whitequark/symbol_plain.txt000066400000000000000000000015411506127434000223120ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,4))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ SymbolNode (location: (1,0)-(1,6))
        │   ├── flags: newline, static_literal, forced_us_ascii_encoding
        │   ├── opening_loc: (1,0)-(1,2) = ":'"
        │   ├── value_loc: (1,2)-(1,5) = "foo"
        │   ├── closing_loc: (1,5)-(1,6) = "'"
        │   └── unescaped: "foo"
        └── @ SymbolNode (location: (3,0)-(3,4))
            ├── flags: newline, static_literal, forced_us_ascii_encoding
            ├── opening_loc: (3,0)-(3,1) = ":"
            ├── value_loc: (3,1)-(3,4) = "foo"
            ├── closing_loc: ∅
            └── unescaped: "foo"
prism-1.5.1/snapshots/whitequark/ternary.txt000066400000000000000000000036751506127434000213200ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,11))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,11))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ IfNode (location: (1,0)-(1,11))
            ├── flags: newline
            ├── if_keyword_loc: ∅
            ├── predicate:
            │   @ CallNode (location: (1,0)-(1,3))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,0)-(1,3) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── then_keyword_loc: (1,4)-(1,5) = "?"
            ├── statements:
            │   @ StatementsNode (location: (1,6)-(1,7))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ IntegerNode (location: (1,6)-(1,7))
            │           ├── flags: newline, static_literal, decimal
            │           └── value: 1
            ├── subsequent:
            │   @ ElseNode (location: (1,8)-(1,11))
            │   ├── flags: ∅
            │   ├── else_keyword_loc: (1,8)-(1,9) = ":"
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,10)-(1,11))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ IntegerNode (location: (1,10)-(1,11))
            │   │           ├── flags: newline, static_literal, decimal
            │   │           └── value: 2
            │   └── end_keyword_loc: ∅
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/whitequark/ternary_ambiguous_symbol.txt000066400000000000000000000057361506127434000247600ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,13))
├── flags: ∅
├── locals: [:t]
└── statements:
    @ StatementsNode (location: (1,0)-(1,13))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ LocalVariableWriteNode (location: (1,0)-(1,3))
        │   ├── flags: newline
        │   ├── name: :t
        │   ├── depth: 0
        │   ├── name_loc: (1,0)-(1,1) = "t"
        │   ├── value:
        │   │   @ IntegerNode (location: (1,2)-(1,3))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── operator_loc: (1,1)-(1,2) = "="
        └── @ IfNode (location: (1,4)-(1,13))
            ├── flags: newline
            ├── if_keyword_loc: ∅
            ├── predicate:
            │   @ ParenthesesNode (location: (1,4)-(1,9))
            │   ├── flags: ∅
            │   ├── body:
            │   │   @ StatementsNode (location: (1,5)-(1,8))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (1,5)-(1,8))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :foo
            │   │           ├── message_loc: (1,5)-(1,8) = "foo"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   ├── opening_loc: (1,4)-(1,5) = "("
            │   └── closing_loc: (1,8)-(1,9) = ")"
            ├── then_keyword_loc: (1,9)-(1,10) = "?"
            ├── statements:
            │   @ StatementsNode (location: (1,10)-(1,11))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ LocalVariableReadNode (location: (1,10)-(1,11))
            │           ├── flags: newline
            │           ├── name: :t
            │           └── depth: 0
            ├── subsequent:
            │   @ ElseNode (location: (1,11)-(1,13))
            │   ├── flags: ∅
            │   ├── else_keyword_loc: (1,11)-(1,12) = ":"
            │   ├── statements:
            │   │   @ StatementsNode (location: (1,12)-(1,13))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ ConstantReadNode (location: (1,12)-(1,13))
            │   │           ├── flags: newline
            │   │           └── name: :T
            │   └── end_keyword_loc: ∅
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/whitequark/trailing_forward_arg.txt000066400000000000000000000064201506127434000240110ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,40))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,40))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ DefNode (location: (1,0)-(1,40))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (1,4)-(1,7) = "foo"
            ├── receiver: ∅
            ├── parameters:
            │   @ ParametersNode (location: (1,8)-(1,17))
            │   ├── flags: ∅
            │   ├── requireds: (length: 2)
            │   │   ├── @ RequiredParameterNode (location: (1,8)-(1,9))
            │   │   │   ├── flags: ∅
            │   │   │   └── name: :a
            │   │   └── @ RequiredParameterNode (location: (1,11)-(1,12))
            │   │       ├── flags: ∅
            │   │       └── name: :b
            │   ├── optionals: (length: 0)
            │   ├── rest: ∅
            │   ├── posts: (length: 0)
            │   ├── keywords: (length: 0)
            │   ├── keyword_rest:
            │   │   @ ForwardingParameterNode (location: (1,14)-(1,17))
            │   │   └── flags: ∅
            │   └── block: ∅
            ├── body:
            │   @ StatementsNode (location: (1,20)-(1,35))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,20)-(1,35))
            │           ├── flags: newline, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (1,20)-(1,23) = "bar"
            │           ├── opening_loc: (1,23)-(1,24) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (1,24)-(1,34))
            │           │   ├── flags: contains_forwarding
            │           │   └── arguments: (length: 3)
            │           │       ├── @ LocalVariableReadNode (location: (1,24)-(1,25))
            │           │       │   ├── flags: ∅
            │           │       │   ├── name: :a
            │           │       │   └── depth: 0
            │           │       ├── @ IntegerNode (location: (1,27)-(1,29))
            │           │       │   ├── flags: static_literal, decimal
            │           │       │   └── value: 42
            │           │       └── @ ForwardingArgumentsNode (location: (1,31)-(1,34))
            │           │           └── flags: ∅
            │           ├── closing_loc: (1,34)-(1,35) = ")"
            │           └── block: ∅
            ├── locals: [:a, :b]
            ├── def_keyword_loc: (1,0)-(1,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: (1,7)-(1,8) = "("
            ├── rparen_loc: (1,17)-(1,18) = ")"
            ├── equal_loc: ∅
            └── end_keyword_loc: (1,37)-(1,40) = "end"
prism-1.5.1/snapshots/whitequark/true.txt000066400000000000000000000004661506127434000206060ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,4))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ TrueNode (location: (1,0)-(1,4))
            └── flags: newline, static_literal
prism-1.5.1/snapshots/whitequark/unary_num_pow_precedence.txt000066400000000000000000000075371506127434000247140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(5,10))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(5,10))
    ├── flags: ∅
    └── body: (length: 3)
        ├── @ CallNode (location: (1,0)-(1,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ FloatNode (location: (1,0)-(1,4))
        │   │   ├── flags: static_literal
        │   │   └── value: 2.0
        │   ├── call_operator_loc: ∅
        │   ├── name: :**
        │   ├── message_loc: (1,5)-(1,7) = "**"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,8)-(1,10))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (1,8)-(1,10))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 10
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,8))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (3,1)-(3,8))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ IntegerNode (location: (3,1)-(3,2))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 2
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :**
        │   │   ├── message_loc: (3,3)-(3,5) = "**"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (3,6)-(3,8))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (3,6)-(3,8))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 10
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :-@
        │   ├── message_loc: (3,0)-(3,1) = "-"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block: ∅
        └── @ CallNode (location: (5,0)-(5,10))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (5,1)-(5,10))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ FloatNode (location: (5,1)-(5,4))
            │   │   ├── flags: static_literal
            │   │   └── value: 2.0
            │   ├── call_operator_loc: ∅
            │   ├── name: :**
            │   ├── message_loc: (5,5)-(5,7) = "**"
            │   ├── opening_loc: ∅
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (5,8)-(5,10))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 1)
            │   │       └── @ IntegerNode (location: (5,8)-(5,10))
            │   │           ├── flags: static_literal, decimal
            │   │           └── value: 10
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :-@
            ├── message_loc: (5,0)-(5,1) = "-"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            └── block: ∅
prism-1.5.1/snapshots/whitequark/undef.txt000066400000000000000000000051471506127434000207310ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,27))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,27))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ UndefNode (location: (1,0)-(1,27))
            ├── flags: newline
            ├── names: (length: 3)
            │   ├── @ SymbolNode (location: (1,6)-(1,9))
            │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │   ├── opening_loc: ∅
            │   │   ├── value_loc: (1,6)-(1,9) = "foo"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "foo"
            │   ├── @ SymbolNode (location: (1,11)-(1,15))
            │   │   ├── flags: static_literal, forced_us_ascii_encoding
            │   │   ├── opening_loc: (1,11)-(1,12) = ":"
            │   │   ├── value_loc: (1,12)-(1,15) = "bar"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "bar"
            │   └── @ InterpolatedSymbolNode (location: (1,17)-(1,27))
            │       ├── flags: ∅
            │       ├── opening_loc: (1,17)-(1,19) = ":\""
            │       ├── parts: (length: 2)
            │       │   ├── @ StringNode (location: (1,19)-(1,22))
            │       │   │   ├── flags: static_literal, frozen
            │       │   │   ├── opening_loc: ∅
            │       │   │   ├── content_loc: (1,19)-(1,22) = "foo"
            │       │   │   ├── closing_loc: ∅
            │       │   │   └── unescaped: "foo"
            │       │   └── @ EmbeddedStatementsNode (location: (1,22)-(1,26))
            │       │       ├── flags: ∅
            │       │       ├── opening_loc: (1,22)-(1,24) = "\#{"
            │       │       ├── statements:
            │       │       │   @ StatementsNode (location: (1,24)-(1,25))
            │       │       │   ├── flags: ∅
            │       │       │   └── body: (length: 1)
            │       │       │       └── @ IntegerNode (location: (1,24)-(1,25))
            │       │       │           ├── flags: static_literal, decimal
            │       │       │           └── value: 1
            │       │       └── closing_loc: (1,25)-(1,26) = "}"
            │       └── closing_loc: (1,26)-(1,27) = "\""
            └── keyword_loc: (1,0)-(1,5) = "undef"
prism-1.5.1/snapshots/whitequark/unless.txt000066400000000000000000000065671506127434000211500ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,20))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,20))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ UnlessNode (location: (1,0)-(1,24))
        │   ├── flags: newline
        │   ├── keyword_loc: (1,0)-(1,6) = "unless"
        │   ├── predicate:
        │   │   @ CallNode (location: (1,7)-(1,10))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,7)-(1,10) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: (1,11)-(1,15) = "then"
        │   ├── statements:
        │   │   @ StatementsNode (location: (1,16)-(1,19))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (1,16)-(1,19))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (1,16)-(1,19) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── else_clause: ∅
        │   └── end_keyword_loc: (1,21)-(1,24) = "end"
        └── @ UnlessNode (location: (3,0)-(3,20))
            ├── flags: newline
            ├── keyword_loc: (3,0)-(3,6) = "unless"
            ├── predicate:
            │   @ CallNode (location: (3,7)-(3,10))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (3,7)-(3,10) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── then_keyword_loc: ∅
            ├── statements:
            │   @ StatementsNode (location: (3,12)-(3,15))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (3,12)-(3,15))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (3,12)-(3,15) = "bar"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── else_clause: ∅
            └── end_keyword_loc: (3,17)-(3,20) = "end"
prism-1.5.1/snapshots/whitequark/unless_else.txt000066400000000000000000000130011506127434000221350ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,30))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,30))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ UnlessNode (location: (1,0)-(1,34))
        │   ├── flags: newline
        │   ├── keyword_loc: (1,0)-(1,6) = "unless"
        │   ├── predicate:
        │   │   @ CallNode (location: (1,7)-(1,10))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,7)-(1,10) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: (1,11)-(1,15) = "then"
        │   ├── statements:
        │   │   @ StatementsNode (location: (1,16)-(1,19))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (1,16)-(1,19))
        │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (1,16)-(1,19) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── else_clause:
        │   │   @ ElseNode (location: (1,21)-(1,34))
        │   │   ├── flags: ∅
        │   │   ├── else_keyword_loc: (1,21)-(1,25) = "else"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (1,26)-(1,29))
        │   │   │   ├── flags: ∅
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (1,26)-(1,29))
        │   │   │           ├── flags: newline, variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :baz
        │   │   │           ├── message_loc: (1,26)-(1,29) = "baz"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   └── end_keyword_loc: (1,31)-(1,34) = "end"
        │   └── end_keyword_loc: (1,31)-(1,34) = "end"
        └── @ UnlessNode (location: (3,0)-(3,30))
            ├── flags: newline
            ├── keyword_loc: (3,0)-(3,6) = "unless"
            ├── predicate:
            │   @ CallNode (location: (3,7)-(3,10))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (3,7)-(3,10) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── then_keyword_loc: ∅
            ├── statements:
            │   @ StatementsNode (location: (3,12)-(3,15))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (3,12)-(3,15))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (3,12)-(3,15) = "bar"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── else_clause:
            │   @ ElseNode (location: (3,17)-(3,30))
            │   ├── flags: ∅
            │   ├── else_keyword_loc: (3,17)-(3,21) = "else"
            │   ├── statements:
            │   │   @ StatementsNode (location: (3,22)-(3,25))
            │   │   ├── flags: ∅
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (3,22)-(3,25))
            │   │           ├── flags: newline, variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :baz
            │   │           ├── message_loc: (3,22)-(3,25) = "baz"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   └── end_keyword_loc: (3,27)-(3,30) = "end"
            └── end_keyword_loc: (3,27)-(3,30) = "end"
prism-1.5.1/snapshots/whitequark/unless_mod.txt000066400000000000000000000033461506127434000217770ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ UnlessNode (location: (1,0)-(1,14))
            ├── flags: newline
            ├── keyword_loc: (1,4)-(1,10) = "unless"
            ├── predicate:
            │   @ CallNode (location: (1,11)-(1,14))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,11)-(1,14) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── then_keyword_loc: ∅
            ├── statements:
            │   @ StatementsNode (location: (1,0)-(1,3))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ CallNode (location: (1,0)-(1,3))
            │           ├── flags: newline, variable_call, ignore_visibility
            │           ├── receiver: ∅
            │           ├── call_operator_loc: ∅
            │           ├── name: :bar
            │           ├── message_loc: (1,0)-(1,3) = "bar"
            │           ├── opening_loc: ∅
            │           ├── arguments: ∅
            │           ├── closing_loc: ∅
            │           └── block: ∅
            ├── else_clause: ∅
            └── end_keyword_loc: ∅
prism-1.5.1/snapshots/whitequark/until.txt000066400000000000000000000063411506127434000207600ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,19))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ UntilNode (location: (1,0)-(1,21))
        │   ├── flags: newline
        │   ├── keyword_loc: (1,0)-(1,5) = "until"
        │   ├── do_keyword_loc: (1,10)-(1,12) = "do"
        │   ├── closing_loc: (1,18)-(1,21) = "end"
        │   ├── predicate:
        │   │   @ CallNode (location: (1,6)-(1,9))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,6)-(1,9) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── statements:
        │       @ StatementsNode (location: (1,13)-(1,17))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ CallNode (location: (1,13)-(1,17))
        │               ├── flags: newline, variable_call, ignore_visibility
        │               ├── receiver: ∅
        │               ├── call_operator_loc: ∅
        │               ├── name: :meth
        │               ├── message_loc: (1,13)-(1,17) = "meth"
        │               ├── opening_loc: ∅
        │               ├── arguments: ∅
        │               ├── closing_loc: ∅
        │               └── block: ∅
        └── @ UntilNode (location: (3,0)-(3,19))
            ├── flags: newline
            ├── keyword_loc: (3,0)-(3,5) = "until"
            ├── do_keyword_loc: ∅
            ├── closing_loc: (3,16)-(3,19) = "end"
            ├── predicate:
            │   @ CallNode (location: (3,6)-(3,9))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (3,6)-(3,9) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            └── statements:
                @ StatementsNode (location: (3,11)-(3,15))
                ├── flags: ∅
                └── body: (length: 1)
                    └── @ CallNode (location: (3,11)-(3,15))
                        ├── flags: newline, variable_call, ignore_visibility
                        ├── receiver: ∅
                        ├── call_operator_loc: ∅
                        ├── name: :meth
                        ├── message_loc: (3,11)-(3,15) = "meth"
                        ├── opening_loc: ∅
                        ├── arguments: ∅
                        ├── closing_loc: ∅
                        └── block: ∅
prism-1.5.1/snapshots/whitequark/until_mod.txt000066400000000000000000000032371506127434000216200ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ UntilNode (location: (1,0)-(1,14))
            ├── flags: newline
            ├── keyword_loc: (1,5)-(1,10) = "until"
            ├── do_keyword_loc: ∅
            ├── closing_loc: ∅
            ├── predicate:
            │   @ CallNode (location: (1,11)-(1,14))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,11)-(1,14) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            └── statements:
                @ StatementsNode (location: (1,0)-(1,4))
                ├── flags: ∅
                └── body: (length: 1)
                    └── @ CallNode (location: (1,0)-(1,4))
                        ├── flags: newline, variable_call, ignore_visibility
                        ├── receiver: ∅
                        ├── call_operator_loc: ∅
                        ├── name: :meth
                        ├── message_loc: (1,0)-(1,4) = "meth"
                        ├── opening_loc: ∅
                        ├── arguments: ∅
                        ├── closing_loc: ∅
                        └── block: ∅
prism-1.5.1/snapshots/whitequark/until_post.txt000066400000000000000000000047071506127434000220310ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,24))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,24))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ UntilNode (location: (1,0)-(1,24))
            ├── flags: newline, begin_modifier
            ├── keyword_loc: (1,15)-(1,20) = "until"
            ├── do_keyword_loc: ∅
            ├── closing_loc: ∅
            ├── predicate:
            │   @ CallNode (location: (1,21)-(1,24))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,21)-(1,24) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            └── statements:
                @ StatementsNode (location: (1,0)-(1,14))
                ├── flags: ∅
                └── body: (length: 1)
                    └── @ BeginNode (location: (1,0)-(1,14))
                        ├── flags: newline
                        ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
                        ├── statements:
                        │   @ StatementsNode (location: (1,6)-(1,10))
                        │   ├── flags: ∅
                        │   └── body: (length: 1)
                        │       └── @ CallNode (location: (1,6)-(1,10))
                        │           ├── flags: newline, variable_call, ignore_visibility
                        │           ├── receiver: ∅
                        │           ├── call_operator_loc: ∅
                        │           ├── name: :meth
                        │           ├── message_loc: (1,6)-(1,10) = "meth"
                        │           ├── opening_loc: ∅
                        │           ├── arguments: ∅
                        │           ├── closing_loc: ∅
                        │           └── block: ∅
                        ├── rescue_clause: ∅
                        ├── else_clause: ∅
                        ├── ensure_clause: ∅
                        └── end_keyword_loc: (1,11)-(1,14) = "end"
prism-1.5.1/snapshots/whitequark/var_and_asgn.txt000066400000000000000000000012261506127434000222440ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,7))
├── flags: ∅
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (1,0)-(1,7))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LocalVariableAndWriteNode (location: (1,0)-(1,7))
            ├── flags: newline
            ├── name_loc: (1,0)-(1,1) = "a"
            ├── operator_loc: (1,2)-(1,5) = "&&="
            ├── value:
            │   @ IntegerNode (location: (1,6)-(1,7))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── name: :a
            └── depth: 0
prism-1.5.1/snapshots/whitequark/var_op_asgn.txt000066400000000000000000000060361506127434000221240ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,23))
├── flags: ∅
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (1,0)-(7,23))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ ClassVariableOperatorWriteNode (location: (1,0)-(1,11))
        │   ├── flags: newline
        │   ├── name: :@@var
        │   ├── name_loc: (1,0)-(1,5) = "@@var"
        │   ├── binary_operator_loc: (1,6)-(1,8) = "|="
        │   ├── value:
        │   │   @ IntegerNode (location: (1,9)-(1,11))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 10
        │   └── binary_operator: :|
        ├── @ InstanceVariableOperatorWriteNode (location: (3,0)-(3,7))
        │   ├── flags: newline
        │   ├── name: :@a
        │   ├── name_loc: (3,0)-(3,2) = "@a"
        │   ├── binary_operator_loc: (3,3)-(3,5) = "|="
        │   ├── value:
        │   │   @ IntegerNode (location: (3,6)-(3,7))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   └── binary_operator: :|
        ├── @ LocalVariableOperatorWriteNode (location: (5,0)-(5,6))
        │   ├── flags: newline
        │   ├── name_loc: (5,0)-(5,1) = "a"
        │   ├── binary_operator_loc: (5,2)-(5,4) = "+="
        │   ├── value:
        │   │   @ IntegerNode (location: (5,5)-(5,6))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── name: :a
        │   ├── binary_operator: :+
        │   └── depth: 0
        └── @ DefNode (location: (7,0)-(7,23))
            ├── flags: newline
            ├── name: :a
            ├── name_loc: (7,4)-(7,5) = "a"
            ├── receiver: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (7,7)-(7,18))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ ClassVariableOperatorWriteNode (location: (7,7)-(7,18))
            │           ├── flags: newline
            │           ├── name: :@@var
            │           ├── name_loc: (7,7)-(7,12) = "@@var"
            │           ├── binary_operator_loc: (7,13)-(7,15) = "|="
            │           ├── value:
            │           │   @ IntegerNode (location: (7,16)-(7,18))
            │           │   ├── flags: static_literal, decimal
            │           │   └── value: 10
            │           └── binary_operator: :|
            ├── locals: []
            ├── def_keyword_loc: (7,0)-(7,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (7,20)-(7,23) = "end"
prism-1.5.1/snapshots/whitequark/var_op_asgn_cmd.txt000066400000000000000000000026471506127434000227530ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,12))
├── flags: ∅
├── locals: [:foo]
└── statements:
    @ StatementsNode (location: (1,0)-(1,12))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LocalVariableOperatorWriteNode (location: (1,0)-(1,12))
            ├── flags: newline
            ├── name_loc: (1,0)-(1,3) = "foo"
            ├── binary_operator_loc: (1,4)-(1,6) = "+="
            ├── value:
            │   @ CallNode (location: (1,7)-(1,12))
            │   ├── flags: ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :m
            │   ├── message_loc: (1,7)-(1,8) = "m"
            │   ├── opening_loc: ∅
            │   ├── arguments:
            │   │   @ ArgumentsNode (location: (1,9)-(1,12))
            │   │   ├── flags: ∅
            │   │   └── arguments: (length: 1)
            │   │       └── @ LocalVariableReadNode (location: (1,9)-(1,12))
            │   │           ├── flags: ∅
            │   │           ├── name: :foo
            │   │           └── depth: 0
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── name: :foo
            ├── binary_operator: :+
            └── depth: 0
prism-1.5.1/snapshots/whitequark/var_or_asgn.txt000066400000000000000000000012251506127434000221210ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,7))
├── flags: ∅
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (1,0)-(1,7))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ LocalVariableOrWriteNode (location: (1,0)-(1,7))
            ├── flags: newline
            ├── name_loc: (1,0)-(1,1) = "a"
            ├── operator_loc: (1,2)-(1,5) = "||="
            ├── value:
            │   @ IntegerNode (location: (1,6)-(1,7))
            │   ├── flags: static_literal, decimal
            │   └── value: 1
            ├── name: :a
            └── depth: 0
prism-1.5.1/snapshots/whitequark/when_multi.txt000066400000000000000000000057741506127434000220110ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,37))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,37))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseNode (location: (1,0)-(1,37))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (1,5)-(1,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,5)-(1,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ WhenNode (location: (1,10)-(1,32))
            │       ├── flags: ∅
            │       ├── keyword_loc: (1,10)-(1,14) = "when"
            │       ├── conditions: (length: 2)
            │       │   ├── @ StringNode (location: (1,15)-(1,20))
            │       │   │   ├── flags: static_literal, frozen
            │       │   │   ├── opening_loc: (1,15)-(1,16) = "'"
            │       │   │   ├── content_loc: (1,16)-(1,19) = "bar"
            │       │   │   ├── closing_loc: (1,19)-(1,20) = "'"
            │       │   │   └── unescaped: "bar"
            │       │   └── @ StringNode (location: (1,22)-(1,27))
            │       │       ├── flags: static_literal, frozen
            │       │       ├── opening_loc: (1,22)-(1,23) = "'"
            │       │       ├── content_loc: (1,23)-(1,26) = "baz"
            │       │       ├── closing_loc: (1,26)-(1,27) = "'"
            │       │       └── unescaped: "baz"
            │       ├── then_keyword_loc: ∅
            │       └── statements:
            │           @ StatementsNode (location: (1,29)-(1,32))
            │           ├── flags: ∅
            │           └── body: (length: 1)
            │               └── @ CallNode (location: (1,29)-(1,32))
            │                   ├── flags: newline, variable_call, ignore_visibility
            │                   ├── receiver: ∅
            │                   ├── call_operator_loc: ∅
            │                   ├── name: :bar
            │                   ├── message_loc: (1,29)-(1,32) = "bar"
            │                   ├── opening_loc: ∅
            │                   ├── arguments: ∅
            │                   ├── closing_loc: ∅
            │                   └── block: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,34)-(1,37) = "end"
prism-1.5.1/snapshots/whitequark/when_splat.txt000066400000000000000000000110601506127434000217630ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,43))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,43))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseNode (location: (1,0)-(1,43))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (1,5)-(1,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,5)-(1,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 2)
            │   ├── @ WhenNode (location: (1,10)-(1,27))
            │   │   ├── flags: ∅
            │   │   ├── keyword_loc: (1,10)-(1,14) = "when"
            │   │   ├── conditions: (length: 2)
            │   │   │   ├── @ IntegerNode (location: (1,15)-(1,16))
            │   │   │   │   ├── flags: static_literal, decimal
            │   │   │   │   └── value: 1
            │   │   │   └── @ SplatNode (location: (1,18)-(1,22))
            │   │   │       ├── flags: ∅
            │   │   │       ├── operator_loc: (1,18)-(1,19) = "*"
            │   │   │       └── expression:
            │   │   │           @ CallNode (location: (1,19)-(1,22))
            │   │   │           ├── flags: variable_call, ignore_visibility
            │   │   │           ├── receiver: ∅
            │   │   │           ├── call_operator_loc: ∅
            │   │   │           ├── name: :baz
            │   │   │           ├── message_loc: (1,19)-(1,22) = "baz"
            │   │   │           ├── opening_loc: ∅
            │   │   │           ├── arguments: ∅
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── block: ∅
            │   │   ├── then_keyword_loc: ∅
            │   │   └── statements:
            │   │       @ StatementsNode (location: (1,24)-(1,27))
            │   │       ├── flags: ∅
            │   │       └── body: (length: 1)
            │   │           └── @ CallNode (location: (1,24)-(1,27))
            │   │               ├── flags: newline, variable_call, ignore_visibility
            │   │               ├── receiver: ∅
            │   │               ├── call_operator_loc: ∅
            │   │               ├── name: :bar
            │   │               ├── message_loc: (1,24)-(1,27) = "bar"
            │   │               ├── opening_loc: ∅
            │   │               ├── arguments: ∅
            │   │               ├── closing_loc: ∅
            │   │               └── block: ∅
            │   └── @ WhenNode (location: (1,29)-(1,38))
            │       ├── flags: ∅
            │       ├── keyword_loc: (1,29)-(1,33) = "when"
            │       ├── conditions: (length: 1)
            │       │   └── @ SplatNode (location: (1,34)-(1,38))
            │       │       ├── flags: ∅
            │       │       ├── operator_loc: (1,34)-(1,35) = "*"
            │       │       └── expression:
            │       │           @ CallNode (location: (1,35)-(1,38))
            │       │           ├── flags: variable_call, ignore_visibility
            │       │           ├── receiver: ∅
            │       │           ├── call_operator_loc: ∅
            │       │           ├── name: :foo
            │       │           ├── message_loc: (1,35)-(1,38) = "foo"
            │       │           ├── opening_loc: ∅
            │       │           ├── arguments: ∅
            │       │           ├── closing_loc: ∅
            │       │           └── block: ∅
            │       ├── then_keyword_loc: ∅
            │       └── statements: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,40)-(1,43) = "end"
prism-1.5.1/snapshots/whitequark/when_then.txt000066400000000000000000000051221506127434000216000ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,34))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,34))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ CaseNode (location: (1,0)-(1,34))
            ├── flags: newline
            ├── predicate:
            │   @ CallNode (location: (1,5)-(1,8))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,5)-(1,8) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            ├── conditions: (length: 1)
            │   └── @ WhenNode (location: (1,10)-(1,29))
            │       ├── flags: ∅
            │       ├── keyword_loc: (1,10)-(1,14) = "when"
            │       ├── conditions: (length: 1)
            │       │   └── @ StringNode (location: (1,15)-(1,20))
            │       │       ├── flags: static_literal, frozen
            │       │       ├── opening_loc: (1,15)-(1,16) = "'"
            │       │       ├── content_loc: (1,16)-(1,19) = "bar"
            │       │       ├── closing_loc: (1,19)-(1,20) = "'"
            │       │       └── unescaped: "bar"
            │       ├── then_keyword_loc: (1,21)-(1,25) = "then"
            │       └── statements:
            │           @ StatementsNode (location: (1,26)-(1,29))
            │           ├── flags: ∅
            │           └── body: (length: 1)
            │               └── @ CallNode (location: (1,26)-(1,29))
            │                   ├── flags: newline, variable_call, ignore_visibility
            │                   ├── receiver: ∅
            │                   ├── call_operator_loc: ∅
            │                   ├── name: :bar
            │                   ├── message_loc: (1,26)-(1,29) = "bar"
            │                   ├── opening_loc: ∅
            │                   ├── arguments: ∅
            │                   ├── closing_loc: ∅
            │                   └── block: ∅
            ├── else_clause: ∅
            ├── case_keyword_loc: (1,0)-(1,4) = "case"
            └── end_keyword_loc: (1,31)-(1,34) = "end"
prism-1.5.1/snapshots/whitequark/while.txt000066400000000000000000000063411506127434000207350ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(3,19))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(3,19))
    ├── flags: ∅
    └── body: (length: 2)
        ├── @ WhileNode (location: (1,0)-(1,21))
        │   ├── flags: newline
        │   ├── keyword_loc: (1,0)-(1,5) = "while"
        │   ├── do_keyword_loc: (1,10)-(1,12) = "do"
        │   ├── closing_loc: (1,18)-(1,21) = "end"
        │   ├── predicate:
        │   │   @ CallNode (location: (1,6)-(1,9))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (1,6)-(1,9) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   └── statements:
        │       @ StatementsNode (location: (1,13)-(1,17))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ CallNode (location: (1,13)-(1,17))
        │               ├── flags: newline, variable_call, ignore_visibility
        │               ├── receiver: ∅
        │               ├── call_operator_loc: ∅
        │               ├── name: :meth
        │               ├── message_loc: (1,13)-(1,17) = "meth"
        │               ├── opening_loc: ∅
        │               ├── arguments: ∅
        │               ├── closing_loc: ∅
        │               └── block: ∅
        └── @ WhileNode (location: (3,0)-(3,19))
            ├── flags: newline
            ├── keyword_loc: (3,0)-(3,5) = "while"
            ├── do_keyword_loc: ∅
            ├── closing_loc: (3,16)-(3,19) = "end"
            ├── predicate:
            │   @ CallNode (location: (3,6)-(3,9))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (3,6)-(3,9) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            └── statements:
                @ StatementsNode (location: (3,11)-(3,15))
                ├── flags: ∅
                └── body: (length: 1)
                    └── @ CallNode (location: (3,11)-(3,15))
                        ├── flags: newline, variable_call, ignore_visibility
                        ├── receiver: ∅
                        ├── call_operator_loc: ∅
                        ├── name: :meth
                        ├── message_loc: (3,11)-(3,15) = "meth"
                        ├── opening_loc: ∅
                        ├── arguments: ∅
                        ├── closing_loc: ∅
                        └── block: ∅
prism-1.5.1/snapshots/whitequark/while_mod.txt000066400000000000000000000032371506127434000215750ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ WhileNode (location: (1,0)-(1,14))
            ├── flags: newline
            ├── keyword_loc: (1,5)-(1,10) = "while"
            ├── do_keyword_loc: ∅
            ├── closing_loc: ∅
            ├── predicate:
            │   @ CallNode (location: (1,11)-(1,14))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,11)-(1,14) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            └── statements:
                @ StatementsNode (location: (1,0)-(1,4))
                ├── flags: ∅
                └── body: (length: 1)
                    └── @ CallNode (location: (1,0)-(1,4))
                        ├── flags: newline, variable_call, ignore_visibility
                        ├── receiver: ∅
                        ├── call_operator_loc: ∅
                        ├── name: :meth
                        ├── message_loc: (1,0)-(1,4) = "meth"
                        ├── opening_loc: ∅
                        ├── arguments: ∅
                        ├── closing_loc: ∅
                        └── block: ∅
prism-1.5.1/snapshots/whitequark/while_post.txt000066400000000000000000000047071506127434000220060ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,24))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,24))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ WhileNode (location: (1,0)-(1,24))
            ├── flags: newline, begin_modifier
            ├── keyword_loc: (1,15)-(1,20) = "while"
            ├── do_keyword_loc: ∅
            ├── closing_loc: ∅
            ├── predicate:
            │   @ CallNode (location: (1,21)-(1,24))
            │   ├── flags: variable_call, ignore_visibility
            │   ├── receiver: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :foo
            │   ├── message_loc: (1,21)-(1,24) = "foo"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   └── block: ∅
            └── statements:
                @ StatementsNode (location: (1,0)-(1,14))
                ├── flags: ∅
                └── body: (length: 1)
                    └── @ BeginNode (location: (1,0)-(1,14))
                        ├── flags: newline
                        ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
                        ├── statements:
                        │   @ StatementsNode (location: (1,6)-(1,10))
                        │   ├── flags: ∅
                        │   └── body: (length: 1)
                        │       └── @ CallNode (location: (1,6)-(1,10))
                        │           ├── flags: newline, variable_call, ignore_visibility
                        │           ├── receiver: ∅
                        │           ├── call_operator_loc: ∅
                        │           ├── name: :meth
                        │           ├── message_loc: (1,6)-(1,10) = "meth"
                        │           ├── opening_loc: ∅
                        │           ├── arguments: ∅
                        │           ├── closing_loc: ∅
                        │           └── block: ∅
                        ├── rescue_clause: ∅
                        ├── else_clause: ∅
                        ├── ensure_clause: ∅
                        └── end_keyword_loc: (1,11)-(1,14) = "end"
prism-1.5.1/snapshots/whitequark/xstring_interp.txt000066400000000000000000000044271506127434000227070ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,14))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,14))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ InterpolatedXStringNode (location: (1,0)-(1,14))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "`"
            ├── parts: (length: 3)
            │   ├── @ StringNode (location: (1,1)-(1,4))
            │   │   ├── flags: static_literal, frozen
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (1,1)-(1,4) = "foo"
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "foo"
            │   ├── @ EmbeddedStatementsNode (location: (1,4)-(1,10))
            │   │   ├── flags: ∅
            │   │   ├── opening_loc: (1,4)-(1,6) = "\#{"
            │   │   ├── statements:
            │   │   │   @ StatementsNode (location: (1,6)-(1,9))
            │   │   │   ├── flags: ∅
            │   │   │   └── body: (length: 1)
            │   │   │       └── @ CallNode (location: (1,6)-(1,9))
            │   │   │           ├── flags: variable_call, ignore_visibility
            │   │   │           ├── receiver: ∅
            │   │   │           ├── call_operator_loc: ∅
            │   │   │           ├── name: :bar
            │   │   │           ├── message_loc: (1,6)-(1,9) = "bar"
            │   │   │           ├── opening_loc: ∅
            │   │   │           ├── arguments: ∅
            │   │   │           ├── closing_loc: ∅
            │   │   │           └── block: ∅
            │   │   └── closing_loc: (1,9)-(1,10) = "}"
            │   └── @ StringNode (location: (1,10)-(1,13))
            │       ├── flags: static_literal, frozen
            │       ├── opening_loc: ∅
            │       ├── content_loc: (1,10)-(1,13) = "baz"
            │       ├── closing_loc: ∅
            │       └── unescaped: "baz"
            └── closing_loc: (1,13)-(1,14) = "`"
prism-1.5.1/snapshots/whitequark/xstring_plain.txt000066400000000000000000000007671506127434000225140ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,8))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,8))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ XStringNode (location: (1,0)-(1,8))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "`"
            ├── content_loc: (1,1)-(1,7) = "foobar"
            ├── closing_loc: (1,7)-(1,8) = "`"
            └── unescaped: "foobar"
prism-1.5.1/snapshots/whitequark/zsuper.txt000066400000000000000000000005221506127434000211500ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,5))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,5))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ ForwardingSuperNode (location: (1,0)-(1,5))
            ├── flags: newline
            └── block: ∅
prism-1.5.1/snapshots/xstring.txt000066400000000000000000000107431506127434000171400ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(21,4))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(21,4))
    ├── flags: ∅
    └── body: (length: 8)
        ├── @ XStringNode (location: (1,0)-(1,7))
        │   ├── flags: newline
        │   ├── opening_loc: (1,0)-(1,3) = "%x["
        │   ├── content_loc: (1,3)-(1,6) = "foo"
        │   ├── closing_loc: (1,6)-(1,7) = "]"
        │   └── unescaped: "foo"
        ├── @ InterpolatedXStringNode (location: (3,0)-(3,16))
        │   ├── flags: newline
        │   ├── opening_loc: (3,0)-(3,1) = "`"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (3,1)-(3,5))
        │   │   │   ├── flags: static_literal, frozen
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (3,1)-(3,5) = "foo "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "foo "
        │   │   ├── @ EmbeddedStatementsNode (location: (3,5)-(3,11))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: (3,5)-(3,7) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (3,7)-(3,10))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (3,7)-(3,10))
        │   │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── name: :bar
        │   │   │   │           ├── message_loc: (3,7)-(3,10) = "bar"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           └── block: ∅
        │   │   │   └── closing_loc: (3,10)-(3,11) = "}"
        │   │   └── @ StringNode (location: (3,11)-(3,15))
        │   │       ├── flags: static_literal, frozen
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (3,11)-(3,15) = " baz"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: " baz"
        │   └── closing_loc: (3,15)-(3,16) = "`"
        ├── @ XStringNode (location: (5,0)-(5,5))
        │   ├── flags: newline
        │   ├── opening_loc: (5,0)-(5,1) = "`"
        │   ├── content_loc: (5,1)-(5,4) = "foo"
        │   ├── closing_loc: (5,4)-(5,5) = "`"
        │   └── unescaped: "foo"
        ├── @ XStringNode (location: (7,0)-(9,1))
        │   ├── flags: newline
        │   ├── opening_loc: (7,0)-(7,3) = "%x{"
        │   ├── content_loc: (7,3)-(9,0) = "\n  foo\n"
        │   ├── closing_loc: (9,0)-(9,1) = "}"
        │   └── unescaped: "\n  foo\n"
        ├── @ XStringNode (location: (11,0)-(11,2))
        │   ├── flags: newline
        │   ├── opening_loc: (11,0)-(11,1) = "`"
        │   ├── content_loc: (11,1)-(11,1) = ""
        │   ├── closing_loc: (11,1)-(11,2) = "`"
        │   └── unescaped: ""
        ├── @ XStringNode (location: (13,0)-(13,4))
        │   ├── flags: newline
        │   ├── opening_loc: (13,0)-(13,3) = "%x{"
        │   ├── content_loc: (13,3)-(13,3) = ""
        │   ├── closing_loc: (13,3)-(13,4) = "}"
        │   └── unescaped: ""
        ├── @ XStringNode (location: (15,0)-(18,1))
        │   ├── flags: newline
        │   ├── opening_loc: (15,0)-(15,1) = "`"
        │   ├── content_loc: (15,1)-(18,0) = "\nfoo\\\nb\\nar\n"
        │   ├── closing_loc: (18,0)-(18,1) = "`"
        │   └── unescaped: "\nfoob\nar\n"
        └── @ XStringNode (location: (20,0)-(21,4))
            ├── flags: newline
            ├── opening_loc: (20,0)-(20,1) = "`"
            ├── content_loc: (20,1)-(21,3) = "\n’"
            ├── closing_loc: (21,3)-(21,4) = "`"
            └── unescaped: "\n’"
prism-1.5.1/snapshots/xstring_with_backslash.txt000066400000000000000000000007631506127434000222070ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(1,6))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(1,6))
    ├── flags: ∅
    └── body: (length: 1)
        └── @ XStringNode (location: (1,0)-(1,6))
            ├── flags: newline
            ├── opening_loc: (1,0)-(1,1) = "`"
            ├── content_loc: (1,1)-(1,5) = "f\\oo"
            ├── closing_loc: (1,5)-(1,6) = "`"
            └── unescaped: "foo"
prism-1.5.1/snapshots/yield.txt000066400000000000000000000136221506127434000165470ustar00rootroot00000000000000@ ProgramNode (location: (1,0)-(7,28))
├── flags: ∅
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(7,28))
    ├── flags: ∅
    └── body: (length: 4)
        ├── @ DefNode (location: (1,0)-(1,19))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (1,4)-(1,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (1,9)-(1,14))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ YieldNode (location: (1,9)-(1,14))
        │   │           ├── flags: newline
        │   │           ├── keyword_loc: (1,9)-(1,14) = "yield"
        │   │           ├── lparen_loc: ∅
        │   │           ├── arguments: ∅
        │   │           └── rparen_loc: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (1,16)-(1,19) = "end"
        ├── @ DefNode (location: (3,0)-(3,21))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (3,4)-(3,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (3,9)-(3,16))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ YieldNode (location: (3,9)-(3,16))
        │   │           ├── flags: newline
        │   │           ├── keyword_loc: (3,9)-(3,14) = "yield"
        │   │           ├── lparen_loc: (3,14)-(3,15) = "("
        │   │           ├── arguments: ∅
        │   │           └── rparen_loc: (3,15)-(3,16) = ")"
        │   ├── locals: []
        │   ├── def_keyword_loc: (3,0)-(3,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (3,18)-(3,21) = "end"
        ├── @ DefNode (location: (5,0)-(5,22))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (5,4)-(5,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (5,9)-(5,17))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ YieldNode (location: (5,9)-(5,17))
        │   │           ├── flags: newline
        │   │           ├── keyword_loc: (5,9)-(5,14) = "yield"
        │   │           ├── lparen_loc: (5,14)-(5,15) = "("
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (5,15)-(5,16))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (5,15)-(5,16))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 1
        │   │           └── rparen_loc: (5,16)-(5,17) = ")"
        │   ├── locals: []
        │   ├── def_keyword_loc: (5,0)-(5,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (5,19)-(5,22) = "end"
        └── @ DefNode (location: (7,0)-(7,28))
            ├── flags: newline
            ├── name: :foo
            ├── name_loc: (7,4)-(7,7) = "foo"
            ├── receiver: ∅
            ├── parameters: ∅
            ├── body:
            │   @ StatementsNode (location: (7,9)-(7,23))
            │   ├── flags: ∅
            │   └── body: (length: 1)
            │       └── @ YieldNode (location: (7,9)-(7,23))
            │           ├── flags: newline
            │           ├── keyword_loc: (7,9)-(7,14) = "yield"
            │           ├── lparen_loc: (7,14)-(7,15) = "("
            │           ├── arguments:
            │           │   @ ArgumentsNode (location: (7,15)-(7,22))
            │           │   ├── flags: ∅
            │           │   └── arguments: (length: 3)
            │           │       ├── @ IntegerNode (location: (7,15)-(7,16))
            │           │       │   ├── flags: static_literal, decimal
            │           │       │   └── value: 1
            │           │       ├── @ IntegerNode (location: (7,18)-(7,19))
            │           │       │   ├── flags: static_literal, decimal
            │           │       │   └── value: 2
            │           │       └── @ IntegerNode (location: (7,21)-(7,22))
            │           │           ├── flags: static_literal, decimal
            │           │           └── value: 3
            │           └── rparen_loc: (7,22)-(7,23) = ")"
            ├── locals: []
            ├── def_keyword_loc: (7,0)-(7,3) = "def"
            ├── operator_loc: ∅
            ├── lparen_loc: ∅
            ├── rparen_loc: ∅
            ├── equal_loc: ∅
            └── end_keyword_loc: (7,25)-(7,28) = "end"
prism-1.5.1/src/000077500000000000000000000000001506127434000134415ustar00rootroot00000000000000prism-1.5.1/src/encoding.c000066400000000000000000005324361506127434000154100ustar00rootroot00000000000000#include "prism/encoding.h"

typedef uint32_t pm_unicode_codepoint_t;

#define UNICODE_ALPHA_CODEPOINTS_LENGTH 1450
static const pm_unicode_codepoint_t unicode_alpha_codepoints[UNICODE_ALPHA_CODEPOINTS_LENGTH] = {
    0x100, 0x2C1,
    0x2C6, 0x2D1,
    0x2E0, 0x2E4,
    0x2EC, 0x2EC,
    0x2EE, 0x2EE,
    0x345, 0x345,
    0x370, 0x374,
    0x376, 0x377,
    0x37A, 0x37D,
    0x37F, 0x37F,
    0x386, 0x386,
    0x388, 0x38A,
    0x38C, 0x38C,
    0x38E, 0x3A1,
    0x3A3, 0x3F5,
    0x3F7, 0x481,
    0x48A, 0x52F,
    0x531, 0x556,
    0x559, 0x559,
    0x560, 0x588,
    0x5B0, 0x5BD,
    0x5BF, 0x5BF,
    0x5C1, 0x5C2,
    0x5C4, 0x5C5,
    0x5C7, 0x5C7,
    0x5D0, 0x5EA,
    0x5EF, 0x5F2,
    0x610, 0x61A,
    0x620, 0x657,
    0x659, 0x65F,
    0x66E, 0x6D3,
    0x6D5, 0x6DC,
    0x6E1, 0x6E8,
    0x6ED, 0x6EF,
    0x6FA, 0x6FC,
    0x6FF, 0x6FF,
    0x710, 0x73F,
    0x74D, 0x7B1,
    0x7CA, 0x7EA,
    0x7F4, 0x7F5,
    0x7FA, 0x7FA,
    0x800, 0x817,
    0x81A, 0x82C,
    0x840, 0x858,
    0x860, 0x86A,
    0x870, 0x887,
    0x889, 0x88E,
    0x8A0, 0x8C9,
    0x8D4, 0x8DF,
    0x8E3, 0x8E9,
    0x8F0, 0x93B,
    0x93D, 0x94C,
    0x94E, 0x950,
    0x955, 0x963,
    0x971, 0x983,
    0x985, 0x98C,
    0x98F, 0x990,
    0x993, 0x9A8,
    0x9AA, 0x9B0,
    0x9B2, 0x9B2,
    0x9B6, 0x9B9,
    0x9BD, 0x9C4,
    0x9C7, 0x9C8,
    0x9CB, 0x9CC,
    0x9CE, 0x9CE,
    0x9D7, 0x9D7,
    0x9DC, 0x9DD,
    0x9DF, 0x9E3,
    0x9F0, 0x9F1,
    0x9FC, 0x9FC,
    0xA01, 0xA03,
    0xA05, 0xA0A,
    0xA0F, 0xA10,
    0xA13, 0xA28,
    0xA2A, 0xA30,
    0xA32, 0xA33,
    0xA35, 0xA36,
    0xA38, 0xA39,
    0xA3E, 0xA42,
    0xA47, 0xA48,
    0xA4B, 0xA4C,
    0xA51, 0xA51,
    0xA59, 0xA5C,
    0xA5E, 0xA5E,
    0xA70, 0xA75,
    0xA81, 0xA83,
    0xA85, 0xA8D,
    0xA8F, 0xA91,
    0xA93, 0xAA8,
    0xAAA, 0xAB0,
    0xAB2, 0xAB3,
    0xAB5, 0xAB9,
    0xABD, 0xAC5,
    0xAC7, 0xAC9,
    0xACB, 0xACC,
    0xAD0, 0xAD0,
    0xAE0, 0xAE3,
    0xAF9, 0xAFC,
    0xB01, 0xB03,
    0xB05, 0xB0C,
    0xB0F, 0xB10,
    0xB13, 0xB28,
    0xB2A, 0xB30,
    0xB32, 0xB33,
    0xB35, 0xB39,
    0xB3D, 0xB44,
    0xB47, 0xB48,
    0xB4B, 0xB4C,
    0xB56, 0xB57,
    0xB5C, 0xB5D,
    0xB5F, 0xB63,
    0xB71, 0xB71,
    0xB82, 0xB83,
    0xB85, 0xB8A,
    0xB8E, 0xB90,
    0xB92, 0xB95,
    0xB99, 0xB9A,
    0xB9C, 0xB9C,
    0xB9E, 0xB9F,
    0xBA3, 0xBA4,
    0xBA8, 0xBAA,
    0xBAE, 0xBB9,
    0xBBE, 0xBC2,
    0xBC6, 0xBC8,
    0xBCA, 0xBCC,
    0xBD0, 0xBD0,
    0xBD7, 0xBD7,
    0xC00, 0xC0C,
    0xC0E, 0xC10,
    0xC12, 0xC28,
    0xC2A, 0xC39,
    0xC3D, 0xC44,
    0xC46, 0xC48,
    0xC4A, 0xC4C,
    0xC55, 0xC56,
    0xC58, 0xC5A,
    0xC5D, 0xC5D,
    0xC60, 0xC63,
    0xC80, 0xC83,
    0xC85, 0xC8C,
    0xC8E, 0xC90,
    0xC92, 0xCA8,
    0xCAA, 0xCB3,
    0xCB5, 0xCB9,
    0xCBD, 0xCC4,
    0xCC6, 0xCC8,
    0xCCA, 0xCCC,
    0xCD5, 0xCD6,
    0xCDD, 0xCDE,
    0xCE0, 0xCE3,
    0xCF1, 0xCF3,
    0xD00, 0xD0C,
    0xD0E, 0xD10,
    0xD12, 0xD3A,
    0xD3D, 0xD44,
    0xD46, 0xD48,
    0xD4A, 0xD4C,
    0xD4E, 0xD4E,
    0xD54, 0xD57,
    0xD5F, 0xD63,
    0xD7A, 0xD7F,
    0xD81, 0xD83,
    0xD85, 0xD96,
    0xD9A, 0xDB1,
    0xDB3, 0xDBB,
    0xDBD, 0xDBD,
    0xDC0, 0xDC6,
    0xDCF, 0xDD4,
    0xDD6, 0xDD6,
    0xDD8, 0xDDF,
    0xDF2, 0xDF3,
    0xE01, 0xE3A,
    0xE40, 0xE46,
    0xE4D, 0xE4D,
    0xE81, 0xE82,
    0xE84, 0xE84,
    0xE86, 0xE8A,
    0xE8C, 0xEA3,
    0xEA5, 0xEA5,
    0xEA7, 0xEB9,
    0xEBB, 0xEBD,
    0xEC0, 0xEC4,
    0xEC6, 0xEC6,
    0xECD, 0xECD,
    0xEDC, 0xEDF,
    0xF00, 0xF00,
    0xF40, 0xF47,
    0xF49, 0xF6C,
    0xF71, 0xF83,
    0xF88, 0xF97,
    0xF99, 0xFBC,
    0x1000, 0x1036,
    0x1038, 0x1038,
    0x103B, 0x103F,
    0x1050, 0x108F,
    0x109A, 0x109D,
    0x10A0, 0x10C5,
    0x10C7, 0x10C7,
    0x10CD, 0x10CD,
    0x10D0, 0x10FA,
    0x10FC, 0x1248,
    0x124A, 0x124D,
    0x1250, 0x1256,
    0x1258, 0x1258,
    0x125A, 0x125D,
    0x1260, 0x1288,
    0x128A, 0x128D,
    0x1290, 0x12B0,
    0x12B2, 0x12B5,
    0x12B8, 0x12BE,
    0x12C0, 0x12C0,
    0x12C2, 0x12C5,
    0x12C8, 0x12D6,
    0x12D8, 0x1310,
    0x1312, 0x1315,
    0x1318, 0x135A,
    0x1380, 0x138F,
    0x13A0, 0x13F5,
    0x13F8, 0x13FD,
    0x1401, 0x166C,
    0x166F, 0x167F,
    0x1681, 0x169A,
    0x16A0, 0x16EA,
    0x16EE, 0x16F8,
    0x1700, 0x1713,
    0x171F, 0x1733,
    0x1740, 0x1753,
    0x1760, 0x176C,
    0x176E, 0x1770,
    0x1772, 0x1773,
    0x1780, 0x17B3,
    0x17B6, 0x17C8,
    0x17D7, 0x17D7,
    0x17DC, 0x17DC,
    0x1820, 0x1878,
    0x1880, 0x18AA,
    0x18B0, 0x18F5,
    0x1900, 0x191E,
    0x1920, 0x192B,
    0x1930, 0x1938,
    0x1950, 0x196D,
    0x1970, 0x1974,
    0x1980, 0x19AB,
    0x19B0, 0x19C9,
    0x1A00, 0x1A1B,
    0x1A20, 0x1A5E,
    0x1A61, 0x1A74,
    0x1AA7, 0x1AA7,
    0x1ABF, 0x1AC0,
    0x1ACC, 0x1ACE,
    0x1B00, 0x1B33,
    0x1B35, 0x1B43,
    0x1B45, 0x1B4C,
    0x1B80, 0x1BA9,
    0x1BAC, 0x1BAF,
    0x1BBA, 0x1BE5,
    0x1BE7, 0x1BF1,
    0x1C00, 0x1C36,
    0x1C4D, 0x1C4F,
    0x1C5A, 0x1C7D,
    0x1C80, 0x1C88,
    0x1C90, 0x1CBA,
    0x1CBD, 0x1CBF,
    0x1CE9, 0x1CEC,
    0x1CEE, 0x1CF3,
    0x1CF5, 0x1CF6,
    0x1CFA, 0x1CFA,
    0x1D00, 0x1DBF,
    0x1DE7, 0x1DF4,
    0x1E00, 0x1F15,
    0x1F18, 0x1F1D,
    0x1F20, 0x1F45,
    0x1F48, 0x1F4D,
    0x1F50, 0x1F57,
    0x1F59, 0x1F59,
    0x1F5B, 0x1F5B,
    0x1F5D, 0x1F5D,
    0x1F5F, 0x1F7D,
    0x1F80, 0x1FB4,
    0x1FB6, 0x1FBC,
    0x1FBE, 0x1FBE,
    0x1FC2, 0x1FC4,
    0x1FC6, 0x1FCC,
    0x1FD0, 0x1FD3,
    0x1FD6, 0x1FDB,
    0x1FE0, 0x1FEC,
    0x1FF2, 0x1FF4,
    0x1FF6, 0x1FFC,
    0x2071, 0x2071,
    0x207F, 0x207F,
    0x2090, 0x209C,
    0x2102, 0x2102,
    0x2107, 0x2107,
    0x210A, 0x2113,
    0x2115, 0x2115,
    0x2119, 0x211D,
    0x2124, 0x2124,
    0x2126, 0x2126,
    0x2128, 0x2128,
    0x212A, 0x212D,
    0x212F, 0x2139,
    0x213C, 0x213F,
    0x2145, 0x2149,
    0x214E, 0x214E,
    0x2160, 0x2188,
    0x24B6, 0x24E9,
    0x2C00, 0x2CE4,
    0x2CEB, 0x2CEE,
    0x2CF2, 0x2CF3,
    0x2D00, 0x2D25,
    0x2D27, 0x2D27,
    0x2D2D, 0x2D2D,
    0x2D30, 0x2D67,
    0x2D6F, 0x2D6F,
    0x2D80, 0x2D96,
    0x2DA0, 0x2DA6,
    0x2DA8, 0x2DAE,
    0x2DB0, 0x2DB6,
    0x2DB8, 0x2DBE,
    0x2DC0, 0x2DC6,
    0x2DC8, 0x2DCE,
    0x2DD0, 0x2DD6,
    0x2DD8, 0x2DDE,
    0x2DE0, 0x2DFF,
    0x2E2F, 0x2E2F,
    0x3005, 0x3007,
    0x3021, 0x3029,
    0x3031, 0x3035,
    0x3038, 0x303C,
    0x3041, 0x3096,
    0x309D, 0x309F,
    0x30A1, 0x30FA,
    0x30FC, 0x30FF,
    0x3105, 0x312F,
    0x3131, 0x318E,
    0x31A0, 0x31BF,
    0x31F0, 0x31FF,
    0x3400, 0x4DBF,
    0x4E00, 0xA48C,
    0xA4D0, 0xA4FD,
    0xA500, 0xA60C,
    0xA610, 0xA61F,
    0xA62A, 0xA62B,
    0xA640, 0xA66E,
    0xA674, 0xA67B,
    0xA67F, 0xA6EF,
    0xA717, 0xA71F,
    0xA722, 0xA788,
    0xA78B, 0xA7CA,
    0xA7D0, 0xA7D1,
    0xA7D3, 0xA7D3,
    0xA7D5, 0xA7D9,
    0xA7F2, 0xA805,
    0xA807, 0xA827,
    0xA840, 0xA873,
    0xA880, 0xA8C3,
    0xA8C5, 0xA8C5,
    0xA8F2, 0xA8F7,
    0xA8FB, 0xA8FB,
    0xA8FD, 0xA8FF,
    0xA90A, 0xA92A,
    0xA930, 0xA952,
    0xA960, 0xA97C,
    0xA980, 0xA9B2,
    0xA9B4, 0xA9BF,
    0xA9CF, 0xA9CF,
    0xA9E0, 0xA9EF,
    0xA9FA, 0xA9FE,
    0xAA00, 0xAA36,
    0xAA40, 0xAA4D,
    0xAA60, 0xAA76,
    0xAA7A, 0xAABE,
    0xAAC0, 0xAAC0,
    0xAAC2, 0xAAC2,
    0xAADB, 0xAADD,
    0xAAE0, 0xAAEF,
    0xAAF2, 0xAAF5,
    0xAB01, 0xAB06,
    0xAB09, 0xAB0E,
    0xAB11, 0xAB16,
    0xAB20, 0xAB26,
    0xAB28, 0xAB2E,
    0xAB30, 0xAB5A,
    0xAB5C, 0xAB69,
    0xAB70, 0xABEA,
    0xAC00, 0xD7A3,
    0xD7B0, 0xD7C6,
    0xD7CB, 0xD7FB,
    0xF900, 0xFA6D,
    0xFA70, 0xFAD9,
    0xFB00, 0xFB06,
    0xFB13, 0xFB17,
    0xFB1D, 0xFB28,
    0xFB2A, 0xFB36,
    0xFB38, 0xFB3C,
    0xFB3E, 0xFB3E,
    0xFB40, 0xFB41,
    0xFB43, 0xFB44,
    0xFB46, 0xFBB1,
    0xFBD3, 0xFD3D,
    0xFD50, 0xFD8F,
    0xFD92, 0xFDC7,
    0xFDF0, 0xFDFB,
    0xFE70, 0xFE74,
    0xFE76, 0xFEFC,
    0xFF21, 0xFF3A,
    0xFF41, 0xFF5A,
    0xFF66, 0xFFBE,
    0xFFC2, 0xFFC7,
    0xFFCA, 0xFFCF,
    0xFFD2, 0xFFD7,
    0xFFDA, 0xFFDC,
    0x10000, 0x1000B,
    0x1000D, 0x10026,
    0x10028, 0x1003A,
    0x1003C, 0x1003D,
    0x1003F, 0x1004D,
    0x10050, 0x1005D,
    0x10080, 0x100FA,
    0x10140, 0x10174,
    0x10280, 0x1029C,
    0x102A0, 0x102D0,
    0x10300, 0x1031F,
    0x1032D, 0x1034A,
    0x10350, 0x1037A,
    0x10380, 0x1039D,
    0x103A0, 0x103C3,
    0x103C8, 0x103CF,
    0x103D1, 0x103D5,
    0x10400, 0x1049D,
    0x104B0, 0x104D3,
    0x104D8, 0x104FB,
    0x10500, 0x10527,
    0x10530, 0x10563,
    0x10570, 0x1057A,
    0x1057C, 0x1058A,
    0x1058C, 0x10592,
    0x10594, 0x10595,
    0x10597, 0x105A1,
    0x105A3, 0x105B1,
    0x105B3, 0x105B9,
    0x105BB, 0x105BC,
    0x10600, 0x10736,
    0x10740, 0x10755,
    0x10760, 0x10767,
    0x10780, 0x10785,
    0x10787, 0x107B0,
    0x107B2, 0x107BA,
    0x10800, 0x10805,
    0x10808, 0x10808,
    0x1080A, 0x10835,
    0x10837, 0x10838,
    0x1083C, 0x1083C,
    0x1083F, 0x10855,
    0x10860, 0x10876,
    0x10880, 0x1089E,
    0x108E0, 0x108F2,
    0x108F4, 0x108F5,
    0x10900, 0x10915,
    0x10920, 0x10939,
    0x10980, 0x109B7,
    0x109BE, 0x109BF,
    0x10A00, 0x10A03,
    0x10A05, 0x10A06,
    0x10A0C, 0x10A13,
    0x10A15, 0x10A17,
    0x10A19, 0x10A35,
    0x10A60, 0x10A7C,
    0x10A80, 0x10A9C,
    0x10AC0, 0x10AC7,
    0x10AC9, 0x10AE4,
    0x10B00, 0x10B35,
    0x10B40, 0x10B55,
    0x10B60, 0x10B72,
    0x10B80, 0x10B91,
    0x10C00, 0x10C48,
    0x10C80, 0x10CB2,
    0x10CC0, 0x10CF2,
    0x10D00, 0x10D27,
    0x10E80, 0x10EA9,
    0x10EAB, 0x10EAC,
    0x10EB0, 0x10EB1,
    0x10F00, 0x10F1C,
    0x10F27, 0x10F27,
    0x10F30, 0x10F45,
    0x10F70, 0x10F81,
    0x10FB0, 0x10FC4,
    0x10FE0, 0x10FF6,
    0x11000, 0x11045,
    0x11071, 0x11075,
    0x11080, 0x110B8,
    0x110C2, 0x110C2,
    0x110D0, 0x110E8,
    0x11100, 0x11132,
    0x11144, 0x11147,
    0x11150, 0x11172,
    0x11176, 0x11176,
    0x11180, 0x111BF,
    0x111C1, 0x111C4,
    0x111CE, 0x111CF,
    0x111DA, 0x111DA,
    0x111DC, 0x111DC,
    0x11200, 0x11211,
    0x11213, 0x11234,
    0x11237, 0x11237,
    0x1123E, 0x11241,
    0x11280, 0x11286,
    0x11288, 0x11288,
    0x1128A, 0x1128D,
    0x1128F, 0x1129D,
    0x1129F, 0x112A8,
    0x112B0, 0x112E8,
    0x11300, 0x11303,
    0x11305, 0x1130C,
    0x1130F, 0x11310,
    0x11313, 0x11328,
    0x1132A, 0x11330,
    0x11332, 0x11333,
    0x11335, 0x11339,
    0x1133D, 0x11344,
    0x11347, 0x11348,
    0x1134B, 0x1134C,
    0x11350, 0x11350,
    0x11357, 0x11357,
    0x1135D, 0x11363,
    0x11400, 0x11441,
    0x11443, 0x11445,
    0x11447, 0x1144A,
    0x1145F, 0x11461,
    0x11480, 0x114C1,
    0x114C4, 0x114C5,
    0x114C7, 0x114C7,
    0x11580, 0x115B5,
    0x115B8, 0x115BE,
    0x115D8, 0x115DD,
    0x11600, 0x1163E,
    0x11640, 0x11640,
    0x11644, 0x11644,
    0x11680, 0x116B5,
    0x116B8, 0x116B8,
    0x11700, 0x1171A,
    0x1171D, 0x1172A,
    0x11740, 0x11746,
    0x11800, 0x11838,
    0x118A0, 0x118DF,
    0x118FF, 0x11906,
    0x11909, 0x11909,
    0x1190C, 0x11913,
    0x11915, 0x11916,
    0x11918, 0x11935,
    0x11937, 0x11938,
    0x1193B, 0x1193C,
    0x1193F, 0x11942,
    0x119A0, 0x119A7,
    0x119AA, 0x119D7,
    0x119DA, 0x119DF,
    0x119E1, 0x119E1,
    0x119E3, 0x119E4,
    0x11A00, 0x11A32,
    0x11A35, 0x11A3E,
    0x11A50, 0x11A97,
    0x11A9D, 0x11A9D,
    0x11AB0, 0x11AF8,
    0x11C00, 0x11C08,
    0x11C0A, 0x11C36,
    0x11C38, 0x11C3E,
    0x11C40, 0x11C40,
    0x11C72, 0x11C8F,
    0x11C92, 0x11CA7,
    0x11CA9, 0x11CB6,
    0x11D00, 0x11D06,
    0x11D08, 0x11D09,
    0x11D0B, 0x11D36,
    0x11D3A, 0x11D3A,
    0x11D3C, 0x11D3D,
    0x11D3F, 0x11D41,
    0x11D43, 0x11D43,
    0x11D46, 0x11D47,
    0x11D60, 0x11D65,
    0x11D67, 0x11D68,
    0x11D6A, 0x11D8E,
    0x11D90, 0x11D91,
    0x11D93, 0x11D96,
    0x11D98, 0x11D98,
    0x11EE0, 0x11EF6,
    0x11F00, 0x11F10,
    0x11F12, 0x11F3A,
    0x11F3E, 0x11F40,
    0x11FB0, 0x11FB0,
    0x12000, 0x12399,
    0x12400, 0x1246E,
    0x12480, 0x12543,
    0x12F90, 0x12FF0,
    0x13000, 0x1342F,
    0x13441, 0x13446,
    0x14400, 0x14646,
    0x16800, 0x16A38,
    0x16A40, 0x16A5E,
    0x16A70, 0x16ABE,
    0x16AD0, 0x16AED,
    0x16B00, 0x16B2F,
    0x16B40, 0x16B43,
    0x16B63, 0x16B77,
    0x16B7D, 0x16B8F,
    0x16E40, 0x16E7F,
    0x16F00, 0x16F4A,
    0x16F4F, 0x16F87,
    0x16F8F, 0x16F9F,
    0x16FE0, 0x16FE1,
    0x16FE3, 0x16FE3,
    0x16FF0, 0x16FF1,
    0x17000, 0x187F7,
    0x18800, 0x18CD5,
    0x18D00, 0x18D08,
    0x1AFF0, 0x1AFF3,
    0x1AFF5, 0x1AFFB,
    0x1AFFD, 0x1AFFE,
    0x1B000, 0x1B122,
    0x1B132, 0x1B132,
    0x1B150, 0x1B152,
    0x1B155, 0x1B155,
    0x1B164, 0x1B167,
    0x1B170, 0x1B2FB,
    0x1BC00, 0x1BC6A,
    0x1BC70, 0x1BC7C,
    0x1BC80, 0x1BC88,
    0x1BC90, 0x1BC99,
    0x1BC9E, 0x1BC9E,
    0x1D400, 0x1D454,
    0x1D456, 0x1D49C,
    0x1D49E, 0x1D49F,
    0x1D4A2, 0x1D4A2,
    0x1D4A5, 0x1D4A6,
    0x1D4A9, 0x1D4AC,
    0x1D4AE, 0x1D4B9,
    0x1D4BB, 0x1D4BB,
    0x1D4BD, 0x1D4C3,
    0x1D4C5, 0x1D505,
    0x1D507, 0x1D50A,
    0x1D50D, 0x1D514,
    0x1D516, 0x1D51C,
    0x1D51E, 0x1D539,
    0x1D53B, 0x1D53E,
    0x1D540, 0x1D544,
    0x1D546, 0x1D546,
    0x1D54A, 0x1D550,
    0x1D552, 0x1D6A5,
    0x1D6A8, 0x1D6C0,
    0x1D6C2, 0x1D6DA,
    0x1D6DC, 0x1D6FA,
    0x1D6FC, 0x1D714,
    0x1D716, 0x1D734,
    0x1D736, 0x1D74E,
    0x1D750, 0x1D76E,
    0x1D770, 0x1D788,
    0x1D78A, 0x1D7A8,
    0x1D7AA, 0x1D7C2,
    0x1D7C4, 0x1D7CB,
    0x1DF00, 0x1DF1E,
    0x1DF25, 0x1DF2A,
    0x1E000, 0x1E006,
    0x1E008, 0x1E018,
    0x1E01B, 0x1E021,
    0x1E023, 0x1E024,
    0x1E026, 0x1E02A,
    0x1E030, 0x1E06D,
    0x1E08F, 0x1E08F,
    0x1E100, 0x1E12C,
    0x1E137, 0x1E13D,
    0x1E14E, 0x1E14E,
    0x1E290, 0x1E2AD,
    0x1E2C0, 0x1E2EB,
    0x1E4D0, 0x1E4EB,
    0x1E7E0, 0x1E7E6,
    0x1E7E8, 0x1E7EB,
    0x1E7ED, 0x1E7EE,
    0x1E7F0, 0x1E7FE,
    0x1E800, 0x1E8C4,
    0x1E900, 0x1E943,
    0x1E947, 0x1E947,
    0x1E94B, 0x1E94B,
    0x1EE00, 0x1EE03,
    0x1EE05, 0x1EE1F,
    0x1EE21, 0x1EE22,
    0x1EE24, 0x1EE24,
    0x1EE27, 0x1EE27,
    0x1EE29, 0x1EE32,
    0x1EE34, 0x1EE37,
    0x1EE39, 0x1EE39,
    0x1EE3B, 0x1EE3B,
    0x1EE42, 0x1EE42,
    0x1EE47, 0x1EE47,
    0x1EE49, 0x1EE49,
    0x1EE4B, 0x1EE4B,
    0x1EE4D, 0x1EE4F,
    0x1EE51, 0x1EE52,
    0x1EE54, 0x1EE54,
    0x1EE57, 0x1EE57,
    0x1EE59, 0x1EE59,
    0x1EE5B, 0x1EE5B,
    0x1EE5D, 0x1EE5D,
    0x1EE5F, 0x1EE5F,
    0x1EE61, 0x1EE62,
    0x1EE64, 0x1EE64,
    0x1EE67, 0x1EE6A,
    0x1EE6C, 0x1EE72,
    0x1EE74, 0x1EE77,
    0x1EE79, 0x1EE7C,
    0x1EE7E, 0x1EE7E,
    0x1EE80, 0x1EE89,
    0x1EE8B, 0x1EE9B,
    0x1EEA1, 0x1EEA3,
    0x1EEA5, 0x1EEA9,
    0x1EEAB, 0x1EEBB,
    0x1F130, 0x1F149,
    0x1F150, 0x1F169,
    0x1F170, 0x1F189,
    0x20000, 0x2A6DF,
    0x2A700, 0x2B739,
    0x2B740, 0x2B81D,
    0x2B820, 0x2CEA1,
    0x2CEB0, 0x2EBE0,
    0x2F800, 0x2FA1D,
    0x30000, 0x3134A,
    0x31350, 0x323AF,
};

#define UNICODE_ALNUM_CODEPOINTS_LENGTH 1528
static const pm_unicode_codepoint_t unicode_alnum_codepoints[UNICODE_ALNUM_CODEPOINTS_LENGTH] = {
    0x100, 0x2C1,
    0x2C6, 0x2D1,
    0x2E0, 0x2E4,
    0x2EC, 0x2EC,
    0x2EE, 0x2EE,
    0x345, 0x345,
    0x370, 0x374,
    0x376, 0x377,
    0x37A, 0x37D,
    0x37F, 0x37F,
    0x386, 0x386,
    0x388, 0x38A,
    0x38C, 0x38C,
    0x38E, 0x3A1,
    0x3A3, 0x3F5,
    0x3F7, 0x481,
    0x48A, 0x52F,
    0x531, 0x556,
    0x559, 0x559,
    0x560, 0x588,
    0x5B0, 0x5BD,
    0x5BF, 0x5BF,
    0x5C1, 0x5C2,
    0x5C4, 0x5C5,
    0x5C7, 0x5C7,
    0x5D0, 0x5EA,
    0x5EF, 0x5F2,
    0x610, 0x61A,
    0x620, 0x657,
    0x659, 0x669,
    0x66E, 0x6D3,
    0x6D5, 0x6DC,
    0x6E1, 0x6E8,
    0x6ED, 0x6FC,
    0x6FF, 0x6FF,
    0x710, 0x73F,
    0x74D, 0x7B1,
    0x7C0, 0x7EA,
    0x7F4, 0x7F5,
    0x7FA, 0x7FA,
    0x800, 0x817,
    0x81A, 0x82C,
    0x840, 0x858,
    0x860, 0x86A,
    0x870, 0x887,
    0x889, 0x88E,
    0x8A0, 0x8C9,
    0x8D4, 0x8DF,
    0x8E3, 0x8E9,
    0x8F0, 0x93B,
    0x93D, 0x94C,
    0x94E, 0x950,
    0x955, 0x963,
    0x966, 0x96F,
    0x971, 0x983,
    0x985, 0x98C,
    0x98F, 0x990,
    0x993, 0x9A8,
    0x9AA, 0x9B0,
    0x9B2, 0x9B2,
    0x9B6, 0x9B9,
    0x9BD, 0x9C4,
    0x9C7, 0x9C8,
    0x9CB, 0x9CC,
    0x9CE, 0x9CE,
    0x9D7, 0x9D7,
    0x9DC, 0x9DD,
    0x9DF, 0x9E3,
    0x9E6, 0x9F1,
    0x9FC, 0x9FC,
    0xA01, 0xA03,
    0xA05, 0xA0A,
    0xA0F, 0xA10,
    0xA13, 0xA28,
    0xA2A, 0xA30,
    0xA32, 0xA33,
    0xA35, 0xA36,
    0xA38, 0xA39,
    0xA3E, 0xA42,
    0xA47, 0xA48,
    0xA4B, 0xA4C,
    0xA51, 0xA51,
    0xA59, 0xA5C,
    0xA5E, 0xA5E,
    0xA66, 0xA75,
    0xA81, 0xA83,
    0xA85, 0xA8D,
    0xA8F, 0xA91,
    0xA93, 0xAA8,
    0xAAA, 0xAB0,
    0xAB2, 0xAB3,
    0xAB5, 0xAB9,
    0xABD, 0xAC5,
    0xAC7, 0xAC9,
    0xACB, 0xACC,
    0xAD0, 0xAD0,
    0xAE0, 0xAE3,
    0xAE6, 0xAEF,
    0xAF9, 0xAFC,
    0xB01, 0xB03,
    0xB05, 0xB0C,
    0xB0F, 0xB10,
    0xB13, 0xB28,
    0xB2A, 0xB30,
    0xB32, 0xB33,
    0xB35, 0xB39,
    0xB3D, 0xB44,
    0xB47, 0xB48,
    0xB4B, 0xB4C,
    0xB56, 0xB57,
    0xB5C, 0xB5D,
    0xB5F, 0xB63,
    0xB66, 0xB6F,
    0xB71, 0xB71,
    0xB82, 0xB83,
    0xB85, 0xB8A,
    0xB8E, 0xB90,
    0xB92, 0xB95,
    0xB99, 0xB9A,
    0xB9C, 0xB9C,
    0xB9E, 0xB9F,
    0xBA3, 0xBA4,
    0xBA8, 0xBAA,
    0xBAE, 0xBB9,
    0xBBE, 0xBC2,
    0xBC6, 0xBC8,
    0xBCA, 0xBCC,
    0xBD0, 0xBD0,
    0xBD7, 0xBD7,
    0xBE6, 0xBEF,
    0xC00, 0xC0C,
    0xC0E, 0xC10,
    0xC12, 0xC28,
    0xC2A, 0xC39,
    0xC3D, 0xC44,
    0xC46, 0xC48,
    0xC4A, 0xC4C,
    0xC55, 0xC56,
    0xC58, 0xC5A,
    0xC5D, 0xC5D,
    0xC60, 0xC63,
    0xC66, 0xC6F,
    0xC80, 0xC83,
    0xC85, 0xC8C,
    0xC8E, 0xC90,
    0xC92, 0xCA8,
    0xCAA, 0xCB3,
    0xCB5, 0xCB9,
    0xCBD, 0xCC4,
    0xCC6, 0xCC8,
    0xCCA, 0xCCC,
    0xCD5, 0xCD6,
    0xCDD, 0xCDE,
    0xCE0, 0xCE3,
    0xCE6, 0xCEF,
    0xCF1, 0xCF3,
    0xD00, 0xD0C,
    0xD0E, 0xD10,
    0xD12, 0xD3A,
    0xD3D, 0xD44,
    0xD46, 0xD48,
    0xD4A, 0xD4C,
    0xD4E, 0xD4E,
    0xD54, 0xD57,
    0xD5F, 0xD63,
    0xD66, 0xD6F,
    0xD7A, 0xD7F,
    0xD81, 0xD83,
    0xD85, 0xD96,
    0xD9A, 0xDB1,
    0xDB3, 0xDBB,
    0xDBD, 0xDBD,
    0xDC0, 0xDC6,
    0xDCF, 0xDD4,
    0xDD6, 0xDD6,
    0xDD8, 0xDDF,
    0xDE6, 0xDEF,
    0xDF2, 0xDF3,
    0xE01, 0xE3A,
    0xE40, 0xE46,
    0xE4D, 0xE4D,
    0xE50, 0xE59,
    0xE81, 0xE82,
    0xE84, 0xE84,
    0xE86, 0xE8A,
    0xE8C, 0xEA3,
    0xEA5, 0xEA5,
    0xEA7, 0xEB9,
    0xEBB, 0xEBD,
    0xEC0, 0xEC4,
    0xEC6, 0xEC6,
    0xECD, 0xECD,
    0xED0, 0xED9,
    0xEDC, 0xEDF,
    0xF00, 0xF00,
    0xF20, 0xF29,
    0xF40, 0xF47,
    0xF49, 0xF6C,
    0xF71, 0xF83,
    0xF88, 0xF97,
    0xF99, 0xFBC,
    0x1000, 0x1036,
    0x1038, 0x1038,
    0x103B, 0x1049,
    0x1050, 0x109D,
    0x10A0, 0x10C5,
    0x10C7, 0x10C7,
    0x10CD, 0x10CD,
    0x10D0, 0x10FA,
    0x10FC, 0x1248,
    0x124A, 0x124D,
    0x1250, 0x1256,
    0x1258, 0x1258,
    0x125A, 0x125D,
    0x1260, 0x1288,
    0x128A, 0x128D,
    0x1290, 0x12B0,
    0x12B2, 0x12B5,
    0x12B8, 0x12BE,
    0x12C0, 0x12C0,
    0x12C2, 0x12C5,
    0x12C8, 0x12D6,
    0x12D8, 0x1310,
    0x1312, 0x1315,
    0x1318, 0x135A,
    0x1380, 0x138F,
    0x13A0, 0x13F5,
    0x13F8, 0x13FD,
    0x1401, 0x166C,
    0x166F, 0x167F,
    0x1681, 0x169A,
    0x16A0, 0x16EA,
    0x16EE, 0x16F8,
    0x1700, 0x1713,
    0x171F, 0x1733,
    0x1740, 0x1753,
    0x1760, 0x176C,
    0x176E, 0x1770,
    0x1772, 0x1773,
    0x1780, 0x17B3,
    0x17B6, 0x17C8,
    0x17D7, 0x17D7,
    0x17DC, 0x17DC,
    0x17E0, 0x17E9,
    0x1810, 0x1819,
    0x1820, 0x1878,
    0x1880, 0x18AA,
    0x18B0, 0x18F5,
    0x1900, 0x191E,
    0x1920, 0x192B,
    0x1930, 0x1938,
    0x1946, 0x196D,
    0x1970, 0x1974,
    0x1980, 0x19AB,
    0x19B0, 0x19C9,
    0x19D0, 0x19D9,
    0x1A00, 0x1A1B,
    0x1A20, 0x1A5E,
    0x1A61, 0x1A74,
    0x1A80, 0x1A89,
    0x1A90, 0x1A99,
    0x1AA7, 0x1AA7,
    0x1ABF, 0x1AC0,
    0x1ACC, 0x1ACE,
    0x1B00, 0x1B33,
    0x1B35, 0x1B43,
    0x1B45, 0x1B4C,
    0x1B50, 0x1B59,
    0x1B80, 0x1BA9,
    0x1BAC, 0x1BE5,
    0x1BE7, 0x1BF1,
    0x1C00, 0x1C36,
    0x1C40, 0x1C49,
    0x1C4D, 0x1C7D,
    0x1C80, 0x1C88,
    0x1C90, 0x1CBA,
    0x1CBD, 0x1CBF,
    0x1CE9, 0x1CEC,
    0x1CEE, 0x1CF3,
    0x1CF5, 0x1CF6,
    0x1CFA, 0x1CFA,
    0x1D00, 0x1DBF,
    0x1DE7, 0x1DF4,
    0x1E00, 0x1F15,
    0x1F18, 0x1F1D,
    0x1F20, 0x1F45,
    0x1F48, 0x1F4D,
    0x1F50, 0x1F57,
    0x1F59, 0x1F59,
    0x1F5B, 0x1F5B,
    0x1F5D, 0x1F5D,
    0x1F5F, 0x1F7D,
    0x1F80, 0x1FB4,
    0x1FB6, 0x1FBC,
    0x1FBE, 0x1FBE,
    0x1FC2, 0x1FC4,
    0x1FC6, 0x1FCC,
    0x1FD0, 0x1FD3,
    0x1FD6, 0x1FDB,
    0x1FE0, 0x1FEC,
    0x1FF2, 0x1FF4,
    0x1FF6, 0x1FFC,
    0x2071, 0x2071,
    0x207F, 0x207F,
    0x2090, 0x209C,
    0x2102, 0x2102,
    0x2107, 0x2107,
    0x210A, 0x2113,
    0x2115, 0x2115,
    0x2119, 0x211D,
    0x2124, 0x2124,
    0x2126, 0x2126,
    0x2128, 0x2128,
    0x212A, 0x212D,
    0x212F, 0x2139,
    0x213C, 0x213F,
    0x2145, 0x2149,
    0x214E, 0x214E,
    0x2160, 0x2188,
    0x24B6, 0x24E9,
    0x2C00, 0x2CE4,
    0x2CEB, 0x2CEE,
    0x2CF2, 0x2CF3,
    0x2D00, 0x2D25,
    0x2D27, 0x2D27,
    0x2D2D, 0x2D2D,
    0x2D30, 0x2D67,
    0x2D6F, 0x2D6F,
    0x2D80, 0x2D96,
    0x2DA0, 0x2DA6,
    0x2DA8, 0x2DAE,
    0x2DB0, 0x2DB6,
    0x2DB8, 0x2DBE,
    0x2DC0, 0x2DC6,
    0x2DC8, 0x2DCE,
    0x2DD0, 0x2DD6,
    0x2DD8, 0x2DDE,
    0x2DE0, 0x2DFF,
    0x2E2F, 0x2E2F,
    0x3005, 0x3007,
    0x3021, 0x3029,
    0x3031, 0x3035,
    0x3038, 0x303C,
    0x3041, 0x3096,
    0x309D, 0x309F,
    0x30A1, 0x30FA,
    0x30FC, 0x30FF,
    0x3105, 0x312F,
    0x3131, 0x318E,
    0x31A0, 0x31BF,
    0x31F0, 0x31FF,
    0x3400, 0x4DBF,
    0x4E00, 0xA48C,
    0xA4D0, 0xA4FD,
    0xA500, 0xA60C,
    0xA610, 0xA62B,
    0xA640, 0xA66E,
    0xA674, 0xA67B,
    0xA67F, 0xA6EF,
    0xA717, 0xA71F,
    0xA722, 0xA788,
    0xA78B, 0xA7CA,
    0xA7D0, 0xA7D1,
    0xA7D3, 0xA7D3,
    0xA7D5, 0xA7D9,
    0xA7F2, 0xA805,
    0xA807, 0xA827,
    0xA840, 0xA873,
    0xA880, 0xA8C3,
    0xA8C5, 0xA8C5,
    0xA8D0, 0xA8D9,
    0xA8F2, 0xA8F7,
    0xA8FB, 0xA8FB,
    0xA8FD, 0xA92A,
    0xA930, 0xA952,
    0xA960, 0xA97C,
    0xA980, 0xA9B2,
    0xA9B4, 0xA9BF,
    0xA9CF, 0xA9D9,
    0xA9E0, 0xA9FE,
    0xAA00, 0xAA36,
    0xAA40, 0xAA4D,
    0xAA50, 0xAA59,
    0xAA60, 0xAA76,
    0xAA7A, 0xAABE,
    0xAAC0, 0xAAC0,
    0xAAC2, 0xAAC2,
    0xAADB, 0xAADD,
    0xAAE0, 0xAAEF,
    0xAAF2, 0xAAF5,
    0xAB01, 0xAB06,
    0xAB09, 0xAB0E,
    0xAB11, 0xAB16,
    0xAB20, 0xAB26,
    0xAB28, 0xAB2E,
    0xAB30, 0xAB5A,
    0xAB5C, 0xAB69,
    0xAB70, 0xABEA,
    0xABF0, 0xABF9,
    0xAC00, 0xD7A3,
    0xD7B0, 0xD7C6,
    0xD7CB, 0xD7FB,
    0xF900, 0xFA6D,
    0xFA70, 0xFAD9,
    0xFB00, 0xFB06,
    0xFB13, 0xFB17,
    0xFB1D, 0xFB28,
    0xFB2A, 0xFB36,
    0xFB38, 0xFB3C,
    0xFB3E, 0xFB3E,
    0xFB40, 0xFB41,
    0xFB43, 0xFB44,
    0xFB46, 0xFBB1,
    0xFBD3, 0xFD3D,
    0xFD50, 0xFD8F,
    0xFD92, 0xFDC7,
    0xFDF0, 0xFDFB,
    0xFE70, 0xFE74,
    0xFE76, 0xFEFC,
    0xFF10, 0xFF19,
    0xFF21, 0xFF3A,
    0xFF41, 0xFF5A,
    0xFF66, 0xFFBE,
    0xFFC2, 0xFFC7,
    0xFFCA, 0xFFCF,
    0xFFD2, 0xFFD7,
    0xFFDA, 0xFFDC,
    0x10000, 0x1000B,
    0x1000D, 0x10026,
    0x10028, 0x1003A,
    0x1003C, 0x1003D,
    0x1003F, 0x1004D,
    0x10050, 0x1005D,
    0x10080, 0x100FA,
    0x10140, 0x10174,
    0x10280, 0x1029C,
    0x102A0, 0x102D0,
    0x10300, 0x1031F,
    0x1032D, 0x1034A,
    0x10350, 0x1037A,
    0x10380, 0x1039D,
    0x103A0, 0x103C3,
    0x103C8, 0x103CF,
    0x103D1, 0x103D5,
    0x10400, 0x1049D,
    0x104A0, 0x104A9,
    0x104B0, 0x104D3,
    0x104D8, 0x104FB,
    0x10500, 0x10527,
    0x10530, 0x10563,
    0x10570, 0x1057A,
    0x1057C, 0x1058A,
    0x1058C, 0x10592,
    0x10594, 0x10595,
    0x10597, 0x105A1,
    0x105A3, 0x105B1,
    0x105B3, 0x105B9,
    0x105BB, 0x105BC,
    0x10600, 0x10736,
    0x10740, 0x10755,
    0x10760, 0x10767,
    0x10780, 0x10785,
    0x10787, 0x107B0,
    0x107B2, 0x107BA,
    0x10800, 0x10805,
    0x10808, 0x10808,
    0x1080A, 0x10835,
    0x10837, 0x10838,
    0x1083C, 0x1083C,
    0x1083F, 0x10855,
    0x10860, 0x10876,
    0x10880, 0x1089E,
    0x108E0, 0x108F2,
    0x108F4, 0x108F5,
    0x10900, 0x10915,
    0x10920, 0x10939,
    0x10980, 0x109B7,
    0x109BE, 0x109BF,
    0x10A00, 0x10A03,
    0x10A05, 0x10A06,
    0x10A0C, 0x10A13,
    0x10A15, 0x10A17,
    0x10A19, 0x10A35,
    0x10A60, 0x10A7C,
    0x10A80, 0x10A9C,
    0x10AC0, 0x10AC7,
    0x10AC9, 0x10AE4,
    0x10B00, 0x10B35,
    0x10B40, 0x10B55,
    0x10B60, 0x10B72,
    0x10B80, 0x10B91,
    0x10C00, 0x10C48,
    0x10C80, 0x10CB2,
    0x10CC0, 0x10CF2,
    0x10D00, 0x10D27,
    0x10D30, 0x10D39,
    0x10E80, 0x10EA9,
    0x10EAB, 0x10EAC,
    0x10EB0, 0x10EB1,
    0x10F00, 0x10F1C,
    0x10F27, 0x10F27,
    0x10F30, 0x10F45,
    0x10F70, 0x10F81,
    0x10FB0, 0x10FC4,
    0x10FE0, 0x10FF6,
    0x11000, 0x11045,
    0x11066, 0x1106F,
    0x11071, 0x11075,
    0x11080, 0x110B8,
    0x110C2, 0x110C2,
    0x110D0, 0x110E8,
    0x110F0, 0x110F9,
    0x11100, 0x11132,
    0x11136, 0x1113F,
    0x11144, 0x11147,
    0x11150, 0x11172,
    0x11176, 0x11176,
    0x11180, 0x111BF,
    0x111C1, 0x111C4,
    0x111CE, 0x111DA,
    0x111DC, 0x111DC,
    0x11200, 0x11211,
    0x11213, 0x11234,
    0x11237, 0x11237,
    0x1123E, 0x11241,
    0x11280, 0x11286,
    0x11288, 0x11288,
    0x1128A, 0x1128D,
    0x1128F, 0x1129D,
    0x1129F, 0x112A8,
    0x112B0, 0x112E8,
    0x112F0, 0x112F9,
    0x11300, 0x11303,
    0x11305, 0x1130C,
    0x1130F, 0x11310,
    0x11313, 0x11328,
    0x1132A, 0x11330,
    0x11332, 0x11333,
    0x11335, 0x11339,
    0x1133D, 0x11344,
    0x11347, 0x11348,
    0x1134B, 0x1134C,
    0x11350, 0x11350,
    0x11357, 0x11357,
    0x1135D, 0x11363,
    0x11400, 0x11441,
    0x11443, 0x11445,
    0x11447, 0x1144A,
    0x11450, 0x11459,
    0x1145F, 0x11461,
    0x11480, 0x114C1,
    0x114C4, 0x114C5,
    0x114C7, 0x114C7,
    0x114D0, 0x114D9,
    0x11580, 0x115B5,
    0x115B8, 0x115BE,
    0x115D8, 0x115DD,
    0x11600, 0x1163E,
    0x11640, 0x11640,
    0x11644, 0x11644,
    0x11650, 0x11659,
    0x11680, 0x116B5,
    0x116B8, 0x116B8,
    0x116C0, 0x116C9,
    0x11700, 0x1171A,
    0x1171D, 0x1172A,
    0x11730, 0x11739,
    0x11740, 0x11746,
    0x11800, 0x11838,
    0x118A0, 0x118E9,
    0x118FF, 0x11906,
    0x11909, 0x11909,
    0x1190C, 0x11913,
    0x11915, 0x11916,
    0x11918, 0x11935,
    0x11937, 0x11938,
    0x1193B, 0x1193C,
    0x1193F, 0x11942,
    0x11950, 0x11959,
    0x119A0, 0x119A7,
    0x119AA, 0x119D7,
    0x119DA, 0x119DF,
    0x119E1, 0x119E1,
    0x119E3, 0x119E4,
    0x11A00, 0x11A32,
    0x11A35, 0x11A3E,
    0x11A50, 0x11A97,
    0x11A9D, 0x11A9D,
    0x11AB0, 0x11AF8,
    0x11C00, 0x11C08,
    0x11C0A, 0x11C36,
    0x11C38, 0x11C3E,
    0x11C40, 0x11C40,
    0x11C50, 0x11C59,
    0x11C72, 0x11C8F,
    0x11C92, 0x11CA7,
    0x11CA9, 0x11CB6,
    0x11D00, 0x11D06,
    0x11D08, 0x11D09,
    0x11D0B, 0x11D36,
    0x11D3A, 0x11D3A,
    0x11D3C, 0x11D3D,
    0x11D3F, 0x11D41,
    0x11D43, 0x11D43,
    0x11D46, 0x11D47,
    0x11D50, 0x11D59,
    0x11D60, 0x11D65,
    0x11D67, 0x11D68,
    0x11D6A, 0x11D8E,
    0x11D90, 0x11D91,
    0x11D93, 0x11D96,
    0x11D98, 0x11D98,
    0x11DA0, 0x11DA9,
    0x11EE0, 0x11EF6,
    0x11F00, 0x11F10,
    0x11F12, 0x11F3A,
    0x11F3E, 0x11F40,
    0x11F50, 0x11F59,
    0x11FB0, 0x11FB0,
    0x12000, 0x12399,
    0x12400, 0x1246E,
    0x12480, 0x12543,
    0x12F90, 0x12FF0,
    0x13000, 0x1342F,
    0x13441, 0x13446,
    0x14400, 0x14646,
    0x16800, 0x16A38,
    0x16A40, 0x16A5E,
    0x16A60, 0x16A69,
    0x16A70, 0x16ABE,
    0x16AC0, 0x16AC9,
    0x16AD0, 0x16AED,
    0x16B00, 0x16B2F,
    0x16B40, 0x16B43,
    0x16B50, 0x16B59,
    0x16B63, 0x16B77,
    0x16B7D, 0x16B8F,
    0x16E40, 0x16E7F,
    0x16F00, 0x16F4A,
    0x16F4F, 0x16F87,
    0x16F8F, 0x16F9F,
    0x16FE0, 0x16FE1,
    0x16FE3, 0x16FE3,
    0x16FF0, 0x16FF1,
    0x17000, 0x187F7,
    0x18800, 0x18CD5,
    0x18D00, 0x18D08,
    0x1AFF0, 0x1AFF3,
    0x1AFF5, 0x1AFFB,
    0x1AFFD, 0x1AFFE,
    0x1B000, 0x1B122,
    0x1B132, 0x1B132,
    0x1B150, 0x1B152,
    0x1B155, 0x1B155,
    0x1B164, 0x1B167,
    0x1B170, 0x1B2FB,
    0x1BC00, 0x1BC6A,
    0x1BC70, 0x1BC7C,
    0x1BC80, 0x1BC88,
    0x1BC90, 0x1BC99,
    0x1BC9E, 0x1BC9E,
    0x1D400, 0x1D454,
    0x1D456, 0x1D49C,
    0x1D49E, 0x1D49F,
    0x1D4A2, 0x1D4A2,
    0x1D4A5, 0x1D4A6,
    0x1D4A9, 0x1D4AC,
    0x1D4AE, 0x1D4B9,
    0x1D4BB, 0x1D4BB,
    0x1D4BD, 0x1D4C3,
    0x1D4C5, 0x1D505,
    0x1D507, 0x1D50A,
    0x1D50D, 0x1D514,
    0x1D516, 0x1D51C,
    0x1D51E, 0x1D539,
    0x1D53B, 0x1D53E,
    0x1D540, 0x1D544,
    0x1D546, 0x1D546,
    0x1D54A, 0x1D550,
    0x1D552, 0x1D6A5,
    0x1D6A8, 0x1D6C0,
    0x1D6C2, 0x1D6DA,
    0x1D6DC, 0x1D6FA,
    0x1D6FC, 0x1D714,
    0x1D716, 0x1D734,
    0x1D736, 0x1D74E,
    0x1D750, 0x1D76E,
    0x1D770, 0x1D788,
    0x1D78A, 0x1D7A8,
    0x1D7AA, 0x1D7C2,
    0x1D7C4, 0x1D7CB,
    0x1D7CE, 0x1D7FF,
    0x1DF00, 0x1DF1E,
    0x1DF25, 0x1DF2A,
    0x1E000, 0x1E006,
    0x1E008, 0x1E018,
    0x1E01B, 0x1E021,
    0x1E023, 0x1E024,
    0x1E026, 0x1E02A,
    0x1E030, 0x1E06D,
    0x1E08F, 0x1E08F,
    0x1E100, 0x1E12C,
    0x1E137, 0x1E13D,
    0x1E140, 0x1E149,
    0x1E14E, 0x1E14E,
    0x1E290, 0x1E2AD,
    0x1E2C0, 0x1E2EB,
    0x1E2F0, 0x1E2F9,
    0x1E4D0, 0x1E4EB,
    0x1E4F0, 0x1E4F9,
    0x1E7E0, 0x1E7E6,
    0x1E7E8, 0x1E7EB,
    0x1E7ED, 0x1E7EE,
    0x1E7F0, 0x1E7FE,
    0x1E800, 0x1E8C4,
    0x1E900, 0x1E943,
    0x1E947, 0x1E947,
    0x1E94B, 0x1E94B,
    0x1E950, 0x1E959,
    0x1EE00, 0x1EE03,
    0x1EE05, 0x1EE1F,
    0x1EE21, 0x1EE22,
    0x1EE24, 0x1EE24,
    0x1EE27, 0x1EE27,
    0x1EE29, 0x1EE32,
    0x1EE34, 0x1EE37,
    0x1EE39, 0x1EE39,
    0x1EE3B, 0x1EE3B,
    0x1EE42, 0x1EE42,
    0x1EE47, 0x1EE47,
    0x1EE49, 0x1EE49,
    0x1EE4B, 0x1EE4B,
    0x1EE4D, 0x1EE4F,
    0x1EE51, 0x1EE52,
    0x1EE54, 0x1EE54,
    0x1EE57, 0x1EE57,
    0x1EE59, 0x1EE59,
    0x1EE5B, 0x1EE5B,
    0x1EE5D, 0x1EE5D,
    0x1EE5F, 0x1EE5F,
    0x1EE61, 0x1EE62,
    0x1EE64, 0x1EE64,
    0x1EE67, 0x1EE6A,
    0x1EE6C, 0x1EE72,
    0x1EE74, 0x1EE77,
    0x1EE79, 0x1EE7C,
    0x1EE7E, 0x1EE7E,
    0x1EE80, 0x1EE89,
    0x1EE8B, 0x1EE9B,
    0x1EEA1, 0x1EEA3,
    0x1EEA5, 0x1EEA9,
    0x1EEAB, 0x1EEBB,
    0x1F130, 0x1F149,
    0x1F150, 0x1F169,
    0x1F170, 0x1F189,
    0x1FBF0, 0x1FBF9,
    0x20000, 0x2A6DF,
    0x2A700, 0x2B739,
    0x2B740, 0x2B81D,
    0x2B820, 0x2CEA1,
    0x2CEB0, 0x2EBE0,
    0x2F800, 0x2FA1D,
    0x30000, 0x3134A,
    0x31350, 0x323AF,
};

#define UNICODE_ISUPPER_CODEPOINTS_LENGTH 1302
static const pm_unicode_codepoint_t unicode_isupper_codepoints[UNICODE_ISUPPER_CODEPOINTS_LENGTH] = {
    0x100, 0x100,
    0x102, 0x102,
    0x104, 0x104,
    0x106, 0x106,
    0x108, 0x108,
    0x10A, 0x10A,
    0x10C, 0x10C,
    0x10E, 0x10E,
    0x110, 0x110,
    0x112, 0x112,
    0x114, 0x114,
    0x116, 0x116,
    0x118, 0x118,
    0x11A, 0x11A,
    0x11C, 0x11C,
    0x11E, 0x11E,
    0x120, 0x120,
    0x122, 0x122,
    0x124, 0x124,
    0x126, 0x126,
    0x128, 0x128,
    0x12A, 0x12A,
    0x12C, 0x12C,
    0x12E, 0x12E,
    0x130, 0x130,
    0x132, 0x132,
    0x134, 0x134,
    0x136, 0x136,
    0x139, 0x139,
    0x13B, 0x13B,
    0x13D, 0x13D,
    0x13F, 0x13F,
    0x141, 0x141,
    0x143, 0x143,
    0x145, 0x145,
    0x147, 0x147,
    0x14A, 0x14A,
    0x14C, 0x14C,
    0x14E, 0x14E,
    0x150, 0x150,
    0x152, 0x152,
    0x154, 0x154,
    0x156, 0x156,
    0x158, 0x158,
    0x15A, 0x15A,
    0x15C, 0x15C,
    0x15E, 0x15E,
    0x160, 0x160,
    0x162, 0x162,
    0x164, 0x164,
    0x166, 0x166,
    0x168, 0x168,
    0x16A, 0x16A,
    0x16C, 0x16C,
    0x16E, 0x16E,
    0x170, 0x170,
    0x172, 0x172,
    0x174, 0x174,
    0x176, 0x176,
    0x178, 0x179,
    0x17B, 0x17B,
    0x17D, 0x17D,
    0x181, 0x182,
    0x184, 0x184,
    0x186, 0x187,
    0x189, 0x18B,
    0x18E, 0x191,
    0x193, 0x194,
    0x196, 0x198,
    0x19C, 0x19D,
    0x19F, 0x1A0,
    0x1A2, 0x1A2,
    0x1A4, 0x1A4,
    0x1A6, 0x1A7,
    0x1A9, 0x1A9,
    0x1AC, 0x1AC,
    0x1AE, 0x1AF,
    0x1B1, 0x1B3,
    0x1B5, 0x1B5,
    0x1B7, 0x1B8,
    0x1BC, 0x1BC,
    0x1C4, 0x1C5,
    0x1C7, 0x1C8,
    0x1CA, 0x1CB,
    0x1CD, 0x1CD,
    0x1CF, 0x1CF,
    0x1D1, 0x1D1,
    0x1D3, 0x1D3,
    0x1D5, 0x1D5,
    0x1D7, 0x1D7,
    0x1D9, 0x1D9,
    0x1DB, 0x1DB,
    0x1DE, 0x1DE,
    0x1E0, 0x1E0,
    0x1E2, 0x1E2,
    0x1E4, 0x1E4,
    0x1E6, 0x1E6,
    0x1E8, 0x1E8,
    0x1EA, 0x1EA,
    0x1EC, 0x1EC,
    0x1EE, 0x1EE,
    0x1F1, 0x1F2,
    0x1F4, 0x1F4,
    0x1F6, 0x1F8,
    0x1FA, 0x1FA,
    0x1FC, 0x1FC,
    0x1FE, 0x1FE,
    0x200, 0x200,
    0x202, 0x202,
    0x204, 0x204,
    0x206, 0x206,
    0x208, 0x208,
    0x20A, 0x20A,
    0x20C, 0x20C,
    0x20E, 0x20E,
    0x210, 0x210,
    0x212, 0x212,
    0x214, 0x214,
    0x216, 0x216,
    0x218, 0x218,
    0x21A, 0x21A,
    0x21C, 0x21C,
    0x21E, 0x21E,
    0x220, 0x220,
    0x222, 0x222,
    0x224, 0x224,
    0x226, 0x226,
    0x228, 0x228,
    0x22A, 0x22A,
    0x22C, 0x22C,
    0x22E, 0x22E,
    0x230, 0x230,
    0x232, 0x232,
    0x23A, 0x23B,
    0x23D, 0x23E,
    0x241, 0x241,
    0x243, 0x246,
    0x248, 0x248,
    0x24A, 0x24A,
    0x24C, 0x24C,
    0x24E, 0x24E,
    0x370, 0x370,
    0x372, 0x372,
    0x376, 0x376,
    0x37F, 0x37F,
    0x386, 0x386,
    0x388, 0x38A,
    0x38C, 0x38C,
    0x38E, 0x38F,
    0x391, 0x3A1,
    0x3A3, 0x3AB,
    0x3CF, 0x3CF,
    0x3D2, 0x3D4,
    0x3D8, 0x3D8,
    0x3DA, 0x3DA,
    0x3DC, 0x3DC,
    0x3DE, 0x3DE,
    0x3E0, 0x3E0,
    0x3E2, 0x3E2,
    0x3E4, 0x3E4,
    0x3E6, 0x3E6,
    0x3E8, 0x3E8,
    0x3EA, 0x3EA,
    0x3EC, 0x3EC,
    0x3EE, 0x3EE,
    0x3F4, 0x3F4,
    0x3F7, 0x3F7,
    0x3F9, 0x3FA,
    0x3FD, 0x42F,
    0x460, 0x460,
    0x462, 0x462,
    0x464, 0x464,
    0x466, 0x466,
    0x468, 0x468,
    0x46A, 0x46A,
    0x46C, 0x46C,
    0x46E, 0x46E,
    0x470, 0x470,
    0x472, 0x472,
    0x474, 0x474,
    0x476, 0x476,
    0x478, 0x478,
    0x47A, 0x47A,
    0x47C, 0x47C,
    0x47E, 0x47E,
    0x480, 0x480,
    0x48A, 0x48A,
    0x48C, 0x48C,
    0x48E, 0x48E,
    0x490, 0x490,
    0x492, 0x492,
    0x494, 0x494,
    0x496, 0x496,
    0x498, 0x498,
    0x49A, 0x49A,
    0x49C, 0x49C,
    0x49E, 0x49E,
    0x4A0, 0x4A0,
    0x4A2, 0x4A2,
    0x4A4, 0x4A4,
    0x4A6, 0x4A6,
    0x4A8, 0x4A8,
    0x4AA, 0x4AA,
    0x4AC, 0x4AC,
    0x4AE, 0x4AE,
    0x4B0, 0x4B0,
    0x4B2, 0x4B2,
    0x4B4, 0x4B4,
    0x4B6, 0x4B6,
    0x4B8, 0x4B8,
    0x4BA, 0x4BA,
    0x4BC, 0x4BC,
    0x4BE, 0x4BE,
    0x4C0, 0x4C1,
    0x4C3, 0x4C3,
    0x4C5, 0x4C5,
    0x4C7, 0x4C7,
    0x4C9, 0x4C9,
    0x4CB, 0x4CB,
    0x4CD, 0x4CD,
    0x4D0, 0x4D0,
    0x4D2, 0x4D2,
    0x4D4, 0x4D4,
    0x4D6, 0x4D6,
    0x4D8, 0x4D8,
    0x4DA, 0x4DA,
    0x4DC, 0x4DC,
    0x4DE, 0x4DE,
    0x4E0, 0x4E0,
    0x4E2, 0x4E2,
    0x4E4, 0x4E4,
    0x4E6, 0x4E6,
    0x4E8, 0x4E8,
    0x4EA, 0x4EA,
    0x4EC, 0x4EC,
    0x4EE, 0x4EE,
    0x4F0, 0x4F0,
    0x4F2, 0x4F2,
    0x4F4, 0x4F4,
    0x4F6, 0x4F6,
    0x4F8, 0x4F8,
    0x4FA, 0x4FA,
    0x4FC, 0x4FC,
    0x4FE, 0x4FE,
    0x500, 0x500,
    0x502, 0x502,
    0x504, 0x504,
    0x506, 0x506,
    0x508, 0x508,
    0x50A, 0x50A,
    0x50C, 0x50C,
    0x50E, 0x50E,
    0x510, 0x510,
    0x512, 0x512,
    0x514, 0x514,
    0x516, 0x516,
    0x518, 0x518,
    0x51A, 0x51A,
    0x51C, 0x51C,
    0x51E, 0x51E,
    0x520, 0x520,
    0x522, 0x522,
    0x524, 0x524,
    0x526, 0x526,
    0x528, 0x528,
    0x52A, 0x52A,
    0x52C, 0x52C,
    0x52E, 0x52E,
    0x531, 0x556,
    0x10A0, 0x10C5,
    0x10C7, 0x10C7,
    0x10CD, 0x10CD,
    0x13A0, 0x13F5,
    0x1C90, 0x1CBA,
    0x1CBD, 0x1CBF,
    0x1E00, 0x1E00,
    0x1E02, 0x1E02,
    0x1E04, 0x1E04,
    0x1E06, 0x1E06,
    0x1E08, 0x1E08,
    0x1E0A, 0x1E0A,
    0x1E0C, 0x1E0C,
    0x1E0E, 0x1E0E,
    0x1E10, 0x1E10,
    0x1E12, 0x1E12,
    0x1E14, 0x1E14,
    0x1E16, 0x1E16,
    0x1E18, 0x1E18,
    0x1E1A, 0x1E1A,
    0x1E1C, 0x1E1C,
    0x1E1E, 0x1E1E,
    0x1E20, 0x1E20,
    0x1E22, 0x1E22,
    0x1E24, 0x1E24,
    0x1E26, 0x1E26,
    0x1E28, 0x1E28,
    0x1E2A, 0x1E2A,
    0x1E2C, 0x1E2C,
    0x1E2E, 0x1E2E,
    0x1E30, 0x1E30,
    0x1E32, 0x1E32,
    0x1E34, 0x1E34,
    0x1E36, 0x1E36,
    0x1E38, 0x1E38,
    0x1E3A, 0x1E3A,
    0x1E3C, 0x1E3C,
    0x1E3E, 0x1E3E,
    0x1E40, 0x1E40,
    0x1E42, 0x1E42,
    0x1E44, 0x1E44,
    0x1E46, 0x1E46,
    0x1E48, 0x1E48,
    0x1E4A, 0x1E4A,
    0x1E4C, 0x1E4C,
    0x1E4E, 0x1E4E,
    0x1E50, 0x1E50,
    0x1E52, 0x1E52,
    0x1E54, 0x1E54,
    0x1E56, 0x1E56,
    0x1E58, 0x1E58,
    0x1E5A, 0x1E5A,
    0x1E5C, 0x1E5C,
    0x1E5E, 0x1E5E,
    0x1E60, 0x1E60,
    0x1E62, 0x1E62,
    0x1E64, 0x1E64,
    0x1E66, 0x1E66,
    0x1E68, 0x1E68,
    0x1E6A, 0x1E6A,
    0x1E6C, 0x1E6C,
    0x1E6E, 0x1E6E,
    0x1E70, 0x1E70,
    0x1E72, 0x1E72,
    0x1E74, 0x1E74,
    0x1E76, 0x1E76,
    0x1E78, 0x1E78,
    0x1E7A, 0x1E7A,
    0x1E7C, 0x1E7C,
    0x1E7E, 0x1E7E,
    0x1E80, 0x1E80,
    0x1E82, 0x1E82,
    0x1E84, 0x1E84,
    0x1E86, 0x1E86,
    0x1E88, 0x1E88,
    0x1E8A, 0x1E8A,
    0x1E8C, 0x1E8C,
    0x1E8E, 0x1E8E,
    0x1E90, 0x1E90,
    0x1E92, 0x1E92,
    0x1E94, 0x1E94,
    0x1E9E, 0x1E9E,
    0x1EA0, 0x1EA0,
    0x1EA2, 0x1EA2,
    0x1EA4, 0x1EA4,
    0x1EA6, 0x1EA6,
    0x1EA8, 0x1EA8,
    0x1EAA, 0x1EAA,
    0x1EAC, 0x1EAC,
    0x1EAE, 0x1EAE,
    0x1EB0, 0x1EB0,
    0x1EB2, 0x1EB2,
    0x1EB4, 0x1EB4,
    0x1EB6, 0x1EB6,
    0x1EB8, 0x1EB8,
    0x1EBA, 0x1EBA,
    0x1EBC, 0x1EBC,
    0x1EBE, 0x1EBE,
    0x1EC0, 0x1EC0,
    0x1EC2, 0x1EC2,
    0x1EC4, 0x1EC4,
    0x1EC6, 0x1EC6,
    0x1EC8, 0x1EC8,
    0x1ECA, 0x1ECA,
    0x1ECC, 0x1ECC,
    0x1ECE, 0x1ECE,
    0x1ED0, 0x1ED0,
    0x1ED2, 0x1ED2,
    0x1ED4, 0x1ED4,
    0x1ED6, 0x1ED6,
    0x1ED8, 0x1ED8,
    0x1EDA, 0x1EDA,
    0x1EDC, 0x1EDC,
    0x1EDE, 0x1EDE,
    0x1EE0, 0x1EE0,
    0x1EE2, 0x1EE2,
    0x1EE4, 0x1EE4,
    0x1EE6, 0x1EE6,
    0x1EE8, 0x1EE8,
    0x1EEA, 0x1EEA,
    0x1EEC, 0x1EEC,
    0x1EEE, 0x1EEE,
    0x1EF0, 0x1EF0,
    0x1EF2, 0x1EF2,
    0x1EF4, 0x1EF4,
    0x1EF6, 0x1EF6,
    0x1EF8, 0x1EF8,
    0x1EFA, 0x1EFA,
    0x1EFC, 0x1EFC,
    0x1EFE, 0x1EFE,
    0x1F08, 0x1F0F,
    0x1F18, 0x1F1D,
    0x1F28, 0x1F2F,
    0x1F38, 0x1F3F,
    0x1F48, 0x1F4D,
    0x1F59, 0x1F59,
    0x1F5B, 0x1F5B,
    0x1F5D, 0x1F5D,
    0x1F5F, 0x1F5F,
    0x1F68, 0x1F6F,
    0x1F88, 0x1F8F,
    0x1F98, 0x1F9F,
    0x1FA8, 0x1FAF,
    0x1FB8, 0x1FBC,
    0x1FC8, 0x1FCC,
    0x1FD8, 0x1FDB,
    0x1FE8, 0x1FEC,
    0x1FF8, 0x1FFC,
    0x2102, 0x2102,
    0x2107, 0x2107,
    0x210B, 0x210D,
    0x2110, 0x2112,
    0x2115, 0x2115,
    0x2119, 0x211D,
    0x2124, 0x2124,
    0x2126, 0x2126,
    0x2128, 0x2128,
    0x212A, 0x212D,
    0x2130, 0x2133,
    0x213E, 0x213F,
    0x2145, 0x2145,
    0x2160, 0x216F,
    0x2183, 0x2183,
    0x24B6, 0x24CF,
    0x2C00, 0x2C2F,
    0x2C60, 0x2C60,
    0x2C62, 0x2C64,
    0x2C67, 0x2C67,
    0x2C69, 0x2C69,
    0x2C6B, 0x2C6B,
    0x2C6D, 0x2C70,
    0x2C72, 0x2C72,
    0x2C75, 0x2C75,
    0x2C7E, 0x2C80,
    0x2C82, 0x2C82,
    0x2C84, 0x2C84,
    0x2C86, 0x2C86,
    0x2C88, 0x2C88,
    0x2C8A, 0x2C8A,
    0x2C8C, 0x2C8C,
    0x2C8E, 0x2C8E,
    0x2C90, 0x2C90,
    0x2C92, 0x2C92,
    0x2C94, 0x2C94,
    0x2C96, 0x2C96,
    0x2C98, 0x2C98,
    0x2C9A, 0x2C9A,
    0x2C9C, 0x2C9C,
    0x2C9E, 0x2C9E,
    0x2CA0, 0x2CA0,
    0x2CA2, 0x2CA2,
    0x2CA4, 0x2CA4,
    0x2CA6, 0x2CA6,
    0x2CA8, 0x2CA8,
    0x2CAA, 0x2CAA,
    0x2CAC, 0x2CAC,
    0x2CAE, 0x2CAE,
    0x2CB0, 0x2CB0,
    0x2CB2, 0x2CB2,
    0x2CB4, 0x2CB4,
    0x2CB6, 0x2CB6,
    0x2CB8, 0x2CB8,
    0x2CBA, 0x2CBA,
    0x2CBC, 0x2CBC,
    0x2CBE, 0x2CBE,
    0x2CC0, 0x2CC0,
    0x2CC2, 0x2CC2,
    0x2CC4, 0x2CC4,
    0x2CC6, 0x2CC6,
    0x2CC8, 0x2CC8,
    0x2CCA, 0x2CCA,
    0x2CCC, 0x2CCC,
    0x2CCE, 0x2CCE,
    0x2CD0, 0x2CD0,
    0x2CD2, 0x2CD2,
    0x2CD4, 0x2CD4,
    0x2CD6, 0x2CD6,
    0x2CD8, 0x2CD8,
    0x2CDA, 0x2CDA,
    0x2CDC, 0x2CDC,
    0x2CDE, 0x2CDE,
    0x2CE0, 0x2CE0,
    0x2CE2, 0x2CE2,
    0x2CEB, 0x2CEB,
    0x2CED, 0x2CED,
    0x2CF2, 0x2CF2,
    0xA640, 0xA640,
    0xA642, 0xA642,
    0xA644, 0xA644,
    0xA646, 0xA646,
    0xA648, 0xA648,
    0xA64A, 0xA64A,
    0xA64C, 0xA64C,
    0xA64E, 0xA64E,
    0xA650, 0xA650,
    0xA652, 0xA652,
    0xA654, 0xA654,
    0xA656, 0xA656,
    0xA658, 0xA658,
    0xA65A, 0xA65A,
    0xA65C, 0xA65C,
    0xA65E, 0xA65E,
    0xA660, 0xA660,
    0xA662, 0xA662,
    0xA664, 0xA664,
    0xA666, 0xA666,
    0xA668, 0xA668,
    0xA66A, 0xA66A,
    0xA66C, 0xA66C,
    0xA680, 0xA680,
    0xA682, 0xA682,
    0xA684, 0xA684,
    0xA686, 0xA686,
    0xA688, 0xA688,
    0xA68A, 0xA68A,
    0xA68C, 0xA68C,
    0xA68E, 0xA68E,
    0xA690, 0xA690,
    0xA692, 0xA692,
    0xA694, 0xA694,
    0xA696, 0xA696,
    0xA698, 0xA698,
    0xA69A, 0xA69A,
    0xA722, 0xA722,
    0xA724, 0xA724,
    0xA726, 0xA726,
    0xA728, 0xA728,
    0xA72A, 0xA72A,
    0xA72C, 0xA72C,
    0xA72E, 0xA72E,
    0xA732, 0xA732,
    0xA734, 0xA734,
    0xA736, 0xA736,
    0xA738, 0xA738,
    0xA73A, 0xA73A,
    0xA73C, 0xA73C,
    0xA73E, 0xA73E,
    0xA740, 0xA740,
    0xA742, 0xA742,
    0xA744, 0xA744,
    0xA746, 0xA746,
    0xA748, 0xA748,
    0xA74A, 0xA74A,
    0xA74C, 0xA74C,
    0xA74E, 0xA74E,
    0xA750, 0xA750,
    0xA752, 0xA752,
    0xA754, 0xA754,
    0xA756, 0xA756,
    0xA758, 0xA758,
    0xA75A, 0xA75A,
    0xA75C, 0xA75C,
    0xA75E, 0xA75E,
    0xA760, 0xA760,
    0xA762, 0xA762,
    0xA764, 0xA764,
    0xA766, 0xA766,
    0xA768, 0xA768,
    0xA76A, 0xA76A,
    0xA76C, 0xA76C,
    0xA76E, 0xA76E,
    0xA779, 0xA779,
    0xA77B, 0xA77B,
    0xA77D, 0xA77E,
    0xA780, 0xA780,
    0xA782, 0xA782,
    0xA784, 0xA784,
    0xA786, 0xA786,
    0xA78B, 0xA78B,
    0xA78D, 0xA78D,
    0xA790, 0xA790,
    0xA792, 0xA792,
    0xA796, 0xA796,
    0xA798, 0xA798,
    0xA79A, 0xA79A,
    0xA79C, 0xA79C,
    0xA79E, 0xA79E,
    0xA7A0, 0xA7A0,
    0xA7A2, 0xA7A2,
    0xA7A4, 0xA7A4,
    0xA7A6, 0xA7A6,
    0xA7A8, 0xA7A8,
    0xA7AA, 0xA7AE,
    0xA7B0, 0xA7B4,
    0xA7B6, 0xA7B6,
    0xA7B8, 0xA7B8,
    0xA7BA, 0xA7BA,
    0xA7BC, 0xA7BC,
    0xA7BE, 0xA7BE,
    0xA7C0, 0xA7C0,
    0xA7C2, 0xA7C2,
    0xA7C4, 0xA7C7,
    0xA7C9, 0xA7C9,
    0xA7D0, 0xA7D0,
    0xA7D6, 0xA7D6,
    0xA7D8, 0xA7D8,
    0xA7F5, 0xA7F5,
    0xFF21, 0xFF3A,
    0x10400, 0x10427,
    0x104B0, 0x104D3,
    0x10570, 0x1057A,
    0x1057C, 0x1058A,
    0x1058C, 0x10592,
    0x10594, 0x10595,
    0x10C80, 0x10CB2,
    0x118A0, 0x118BF,
    0x16E40, 0x16E5F,
    0x1D400, 0x1D419,
    0x1D434, 0x1D44D,
    0x1D468, 0x1D481,
    0x1D49C, 0x1D49C,
    0x1D49E, 0x1D49F,
    0x1D4A2, 0x1D4A2,
    0x1D4A5, 0x1D4A6,
    0x1D4A9, 0x1D4AC,
    0x1D4AE, 0x1D4B5,
    0x1D4D0, 0x1D4E9,
    0x1D504, 0x1D505,
    0x1D507, 0x1D50A,
    0x1D50D, 0x1D514,
    0x1D516, 0x1D51C,
    0x1D538, 0x1D539,
    0x1D53B, 0x1D53E,
    0x1D540, 0x1D544,
    0x1D546, 0x1D546,
    0x1D54A, 0x1D550,
    0x1D56C, 0x1D585,
    0x1D5A0, 0x1D5B9,
    0x1D5D4, 0x1D5ED,
    0x1D608, 0x1D621,
    0x1D63C, 0x1D655,
    0x1D670, 0x1D689,
    0x1D6A8, 0x1D6C0,
    0x1D6E2, 0x1D6FA,
    0x1D71C, 0x1D734,
    0x1D756, 0x1D76E,
    0x1D790, 0x1D7A8,
    0x1D7CA, 0x1D7CA,
    0x1E900, 0x1E921,
    0x1F130, 0x1F149,
    0x1F150, 0x1F169,
    0x1F170, 0x1F189,
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding unicode codepoint. Note that
 * this table is different from other encodings where we used a lookup table
 * because the indices of those tables are the byte representations, not the
 * codepoints themselves.
 */
const uint8_t pm_encoding_unicode_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, // Fx
};

/**
 * Binary search through the given list of codepoints to see if the given
 * codepoint is in the list.
 */
static bool
pm_unicode_codepoint_match(pm_unicode_codepoint_t codepoint, const pm_unicode_codepoint_t *codepoints, size_t size) {
    size_t start = 0;
    size_t end = size;

    while (start < end) {
        size_t middle = start + (end - start) / 2;
        if ((middle % 2) != 0) middle--;

        if (codepoint >= codepoints[middle] && codepoint <= codepoints[middle + 1]) {
            return true;
        }

        if (codepoint < codepoints[middle]) {
            end = middle;
        } else {
            start = middle + 2;
        }
    }

    return false;
}

/**
 * A state transition table for decoding UTF-8.
 *
 * Copyright (c) 2008-2009 Bjoern Hoehrmann 
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
static const uint8_t pm_utf_8_dfa[] = {
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 00..1f
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 20..3f
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 40..5f
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 60..7f
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, // 80..9f
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, // a0..bf
    8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // c0..df
    0xa,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4,0x3,0x3, // e0..ef
    0xb,0x6,0x6,0x6,0x5,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8, // f0..ff
    0x0,0x1,0x2,0x3,0x5,0x8,0x7,0x1,0x1,0x1,0x4,0x6,0x1,0x1,0x1,0x1, // s0..s0
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1, // s1..s2
    1,2,1,1,1,1,1,2,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1, // s3..s4
    1,2,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,3,1,1,1,1,1,1, // s5..s6
    1,3,1,1,1,1,1,3,1,3,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // s7..s8
};

/**
 * Given a pointer to a string and the number of bytes remaining in the string,
 * decode the next UTF-8 codepoint and return it. The number of bytes consumed
 * is returned in the width out parameter.
 */
static pm_unicode_codepoint_t
pm_utf_8_codepoint(const uint8_t *b, ptrdiff_t n, size_t *width) {
    assert(n >= 0);

    size_t maximum = (n > 4) ? 4 : ((size_t) n);
    uint32_t codepoint;
    uint32_t state = 0;

    for (size_t index = 0; index < maximum; index++) {
        uint32_t byte = b[index];
        uint32_t type = pm_utf_8_dfa[byte];

        codepoint = (state != 0) ?
            (byte & 0x3fu) | (codepoint << 6) :
            (0xffu >> type) & (byte);

        state = pm_utf_8_dfa[256 + (state * 16) + type];
        if (state == 0) {
            *width = index + 1;
            return (pm_unicode_codepoint_t) codepoint;
        }
    }

    *width = 0;
    return 0;
}

/**
 * Return the size of the next character in the UTF-8 encoding.
 */
size_t
pm_encoding_utf_8_char_width(const uint8_t *b, ptrdiff_t n) {
    assert(n >= 0);

    size_t maximum = (n > 4) ? 4 : ((size_t) n);
    uint32_t state = 0;

    for (size_t index = 0; index < maximum; index++) {
        state = pm_utf_8_dfa[256 + (state * 16) + pm_utf_8_dfa[b[index]]];
        if (state == 0) return index + 1;
    }

    return 0;
}

/**
 * Return the size of the next character in the UTF-8 encoding if it is an
 * alphabetical character.
 */
size_t
pm_encoding_utf_8_alpha_char(const uint8_t *b, ptrdiff_t n) {
    if (*b < 0x80) {
        return (pm_encoding_unicode_table[*b] & PRISM_ENCODING_ALPHABETIC_BIT) ? 1 : 0;
    }

    size_t width;
    pm_unicode_codepoint_t codepoint = pm_utf_8_codepoint(b, n, &width);

    if (codepoint <= 0xFF) {
        return (pm_encoding_unicode_table[(uint8_t) codepoint] & PRISM_ENCODING_ALPHABETIC_BIT) ? width : 0;
    } else {
        return pm_unicode_codepoint_match(codepoint, unicode_alpha_codepoints, UNICODE_ALPHA_CODEPOINTS_LENGTH) ? width : 0;
    }
}

/**
 * Return the size of the next character in the UTF-8 encoding if it is an
 * alphanumeric character.
 */
size_t
pm_encoding_utf_8_alnum_char(const uint8_t *b, ptrdiff_t n) {
    if (*b < 0x80) {
        return (pm_encoding_unicode_table[*b] & (PRISM_ENCODING_ALPHANUMERIC_BIT)) ? 1 : 0;
    }

    size_t width;
    pm_unicode_codepoint_t codepoint = pm_utf_8_codepoint(b, n, &width);

    if (codepoint <= 0xFF) {
        return (pm_encoding_unicode_table[(uint8_t) codepoint] & (PRISM_ENCODING_ALPHANUMERIC_BIT)) ? width : 0;
    } else {
        return pm_unicode_codepoint_match(codepoint, unicode_alnum_codepoints, UNICODE_ALNUM_CODEPOINTS_LENGTH) ? width : 0;
    }
}

/**
 * Return true if the next character in the UTF-8 encoding if it is an uppercase
 * character.
 */
bool
pm_encoding_utf_8_isupper_char(const uint8_t *b, ptrdiff_t n) {
    if (*b < 0x80) {
        return (pm_encoding_unicode_table[*b] & PRISM_ENCODING_UPPERCASE_BIT) ? true : false;
    }

    size_t width;
    pm_unicode_codepoint_t codepoint = pm_utf_8_codepoint(b, n, &width);

    if (codepoint <= 0xFF) {
        return (pm_encoding_unicode_table[(uint8_t) codepoint] & PRISM_ENCODING_UPPERCASE_BIT) ? true : false;
    } else {
        return pm_unicode_codepoint_match(codepoint, unicode_isupper_codepoints, UNICODE_ISUPPER_CODEPOINTS_LENGTH) ? true : false;
    }
}

#ifndef PRISM_ENCODING_EXCLUDE_FULL

static pm_unicode_codepoint_t
pm_cesu_8_codepoint(const uint8_t *b, ptrdiff_t n, size_t *width) {
    if (b[0] < 0x80) {
        *width = 1;
        return (pm_unicode_codepoint_t) b[0];
    }

    if (n > 1 && b[0] >= 0xC2 && b[0] <= 0xDF && b[1] >= 0x80 && b[1] <= 0xBF) {
        *width = 2;

        // 110xxxxx 10xxxxxx
        return (pm_unicode_codepoint_t) (((b[0] & 0x1F) << 6) | (b[1] & 0x3F));
    }

    if (n > 5 && b[0] == 0xED && b[1] >= 0xA0 && b[1] <= 0xAF && b[2] >= 0x80 && b[2] <= 0xBF && b[3] == 0xED && b[4] >= 0xB0 && b[4] <= 0xBF && b[5] >= 0x80 && b[5] <= 0xBF) {
        *width = 6;

        // 11101101 1010xxxx 10xxxxxx 11101101 1011xxxx 10xxxxxx
        return (pm_unicode_codepoint_t) (0x10000 + (((b[1] & 0xF) << 16) | ((b[2] & 0x3F) << 10) | ((b[4] & 0xF) << 6) | (b[5] & 0x3F)));
    }

    if (n > 2 && b[0] == 0xED && b[1] >= 0xA0 && b[1] <= 0xBF) {
        *width = 3;

        // 11101101 1010xxxx 10xxxxx
        return (pm_unicode_codepoint_t) (0x10000 + (((b[0] & 0x03) << 16) | ((b[1] & 0x3F) << 10) | (b[2] & 0x3F)));
    }

    if (n > 2 && ((b[0] == 0xE0 && b[1] >= 0xA0) || (b[0] >= 0xE1 && b[0] <= 0xEF && b[1] >= 0x80)) && b[1] <= 0xBF && b[2] >= 0x80 && b[2] <= 0xBF) {
        *width = 3;

        // 1110xxxx 10xxxxxx 10xxxxx
        return (pm_unicode_codepoint_t) (((b[0] & 0xF) << 12) | ((b[1] & 0x3F) << 6) | (b[2] & 0x3F));
    }

    *width = 0;
    return 0;
}

static size_t
pm_encoding_cesu_8_char_width(const uint8_t *b, ptrdiff_t n) {
    size_t width;
    pm_cesu_8_codepoint(b, n, &width);
    return width;
}

static size_t
pm_encoding_cesu_8_alpha_char(const uint8_t *b, ptrdiff_t n) {
    if (*b < 0x80) {
        return (pm_encoding_unicode_table[*b] & PRISM_ENCODING_ALPHABETIC_BIT) ? 1 : 0;
    }

    size_t width;
    pm_unicode_codepoint_t codepoint = pm_cesu_8_codepoint(b, n, &width);

    if (codepoint <= 0xFF) {
        return (pm_encoding_unicode_table[(uint8_t) codepoint] & PRISM_ENCODING_ALPHABETIC_BIT) ? width : 0;
    } else {
        return pm_unicode_codepoint_match(codepoint, unicode_alpha_codepoints, UNICODE_ALPHA_CODEPOINTS_LENGTH) ? width : 0;
    }
}

static size_t
pm_encoding_cesu_8_alnum_char(const uint8_t *b, ptrdiff_t n) {
    if (*b < 0x80) {
        return (pm_encoding_unicode_table[*b] & (PRISM_ENCODING_ALPHANUMERIC_BIT)) ? 1 : 0;
    }

    size_t width;
    pm_unicode_codepoint_t codepoint = pm_cesu_8_codepoint(b, n, &width);

    if (codepoint <= 0xFF) {
        return (pm_encoding_unicode_table[(uint8_t) codepoint] & (PRISM_ENCODING_ALPHANUMERIC_BIT)) ? width : 0;
    } else {
        return pm_unicode_codepoint_match(codepoint, unicode_alnum_codepoints, UNICODE_ALNUM_CODEPOINTS_LENGTH) ? width : 0;
    }
}

static bool
pm_encoding_cesu_8_isupper_char(const uint8_t *b, ptrdiff_t n) {
    if (*b < 0x80) {
        return (pm_encoding_unicode_table[*b] & PRISM_ENCODING_UPPERCASE_BIT) ? true : false;
    }

    size_t width;
    pm_unicode_codepoint_t codepoint = pm_cesu_8_codepoint(b, n, &width);

    if (codepoint <= 0xFF) {
        return (pm_encoding_unicode_table[(uint8_t) codepoint] & PRISM_ENCODING_UPPERCASE_BIT) ? true : false;
    } else {
        return pm_unicode_codepoint_match(codepoint, unicode_isupper_codepoints, UNICODE_ISUPPER_CODEPOINTS_LENGTH) ? true : false;
    }
}

#endif

#undef UNICODE_ALPHA_CODEPOINTS_LENGTH
#undef UNICODE_ALNUM_CODEPOINTS_LENGTH
#undef UNICODE_ISUPPER_CODEPOINTS_LENGTH

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding US-ASCII character.
 */
static const uint8_t pm_encoding_ascii_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

#ifndef PRISM_ENCODING_EXCLUDE_FULL

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding CP850 character.
 */
static const uint8_t pm_encoding_cp850_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding CP852 character.
 */
static const uint8_t pm_encoding_cp852_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding CP855 character.
 */
static const uint8_t pm_encoding_cp855_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding GB1988 character.
 */
static const uint8_t pm_encoding_gb1988_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM437 character.
 */
static const uint8_t pm_encoding_ibm437_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM720 character.
 */
static const uint8_t pm_encoding_ibm720_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM737 character.
 */
static const uint8_t pm_encoding_ibm737_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM775 character.
 */
static const uint8_t pm_encoding_ibm775_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM852 character.
 */
static const uint8_t pm_encoding_ibm852_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM855 character.
 */
static const uint8_t pm_encoding_ibm855_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM857 character.
 */
static const uint8_t pm_encoding_ibm857_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM860 character.
 */
static const uint8_t pm_encoding_ibm860_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM861 character.
 */
static const uint8_t pm_encoding_ibm861_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM862 character.
 */
static const uint8_t pm_encoding_ibm862_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM863 character.
 */
static const uint8_t pm_encoding_ibm863_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM864 character.
 */
static const uint8_t pm_encoding_ibm864_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM865 character.
 */
static const uint8_t pm_encoding_ibm865_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM866 character.
 */
static const uint8_t pm_encoding_ibm866_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding IBM869 character.
 */
static const uint8_t pm_encoding_ibm869_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-1 character.
 */
static const uint8_t pm_encoding_iso_8859_1_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-2 character.
 */
static const uint8_t pm_encoding_iso_8859_2_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 7, 0, 7, 0, 7, 7, 0, 0, 7, 7, 7, 7, 0, 7, 7, // Ax
    0, 3, 0, 3, 0, 3, 3, 0, 0, 3, 3, 3, 3, 0, 3, 3, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-3 character.
 */
static const uint8_t pm_encoding_iso_8859_3_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 7, 0, 0, 0, 0, 7, 0, 0, 7, 7, 7, 7, 0, 0, 7, // Ax
    0, 3, 0, 0, 0, 3, 3, 0, 0, 3, 3, 3, 3, 0, 0, 3, // Bx
    7, 7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    0, 7, 7, 7, 7, 7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    0, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-4 character.
 */
static const uint8_t pm_encoding_iso_8859_4_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 7, 3, 7, 0, 7, 7, 0, 0, 7, 7, 7, 7, 0, 7, 0, // Ax
    0, 3, 0, 3, 0, 3, 3, 0, 0, 3, 3, 3, 3, 7, 3, 3, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-5 character.
 */
static const uint8_t pm_encoding_iso_8859_5_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 7, 7, // Ax
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 3, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-6 character.
 */
static const uint8_t pm_encoding_iso_8859_6_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Cx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-7 character.
 */
static const uint8_t pm_encoding_iso_8859_7_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 7, 0, 7, 7, 7, 0, 7, 0, 7, 7, // Bx
    3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 3, 3, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-8 character.
 */
static const uint8_t pm_encoding_iso_8859_8_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-9 character.
 */
static const uint8_t pm_encoding_iso_8859_9_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-10 character.
 */
static const uint8_t pm_encoding_iso_8859_10_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 7, 7, 7, 7, 7, 7, 0, 7, 7, 7, 7, 7, 0, 7, 7, // Ax
    0, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3, 0, 3, 3, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-11 character.
 */
static const uint8_t pm_encoding_iso_8859_11_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ax
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Bx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Cx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-13 character.
 */
static const uint8_t pm_encoding_iso_8859_13_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 0, 0, 0, 7, // Ax
    0, 0, 0, 0, 0, 3, 0, 0, 3, 0, 3, 0, 0, 0, 0, 3, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-14 character.
 */
static const uint8_t pm_encoding_iso_8859_14_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 7, 3, 0, 7, 3, 7, 0, 7, 0, 7, 3, 7, 0, 0, 7, // Ax
    7, 3, 7, 3, 7, 3, 0, 7, 3, 3, 3, 7, 3, 7, 3, 3, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-15 character.
 */
static const uint8_t pm_encoding_iso_8859_15_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 7, 0, 3, 0, 3, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 7, 3, 0, 0, 3, 0, 3, 0, 7, 3, 7, 0, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding ISO-8859-16 character.
 */
static const uint8_t pm_encoding_iso_8859_16_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 7, 3, 7, 0, 0, 7, 0, 3, 0, 7, 0, 7, 0, 3, 7, // Ax
    0, 0, 7, 3, 7, 0, 0, 0, 3, 3, 3, 0, 7, 3, 7, 3, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding KOI8-R character.
 */
static const uint8_t pm_encoding_koi8_r_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Cx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Dx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Ex
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding KOI8-U character.
 */
static const uint8_t pm_encoding_koi8_u_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 3, 3, 0, 3, 3, 0, 0, 0, 0, 0, 3, 0, 0, // Ax
    0, 0, 0, 7, 7, 0, 7, 7, 0, 0, 0, 0, 0, 7, 0, 0, // Bx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Cx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Dx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Ex
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding macCentEuro character.
 */
static const uint8_t pm_encoding_mac_cent_euro_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding macCroatian character.
 */
static const uint8_t pm_encoding_mac_croatian_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

 /**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding macCyrillic character.
 */
static const uint8_t pm_encoding_mac_cyrillic_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding macGreek character.
 */
static const uint8_t pm_encoding_mac_greek_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding macIceland character.
 */
static const uint8_t pm_encoding_mac_iceland_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding macRoman character.
 */
static const uint8_t pm_encoding_mac_roman_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding macRomania character.
 */
static const uint8_t pm_encoding_mac_romania_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding macThai character.
 */
static const uint8_t pm_encoding_mac_thai_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding TIS-620 character.
 */
static const uint8_t pm_encoding_tis_620_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ax
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Bx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Cx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding macTurkish character.
 */
static const uint8_t pm_encoding_mac_turkish_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding macUkraine character.
 */
static const uint8_t pm_encoding_mac_ukraine_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding windows-1250 character.
 */
static const uint8_t pm_encoding_windows_1250_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 7, 7, 7, 7, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, // 9x
    0, 0, 0, 7, 0, 7, 0, 0, 0, 0, 7, 0, 0, 0, 0, 7, // Ax
    0, 0, 0, 3, 0, 3, 0, 0, 0, 3, 3, 0, 7, 0, 3, 3, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding windows-1251 character.
 */
static const uint8_t pm_encoding_windows_1251_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    7, 7, 0, 3, 0, 0, 0, 0, 0, 0, 7, 0, 7, 7, 7, 7, // 8x
    3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, // 9x
    0, 7, 3, 7, 0, 7, 0, 0, 7, 0, 7, 0, 0, 0, 0, 7, // Ax
    0, 0, 7, 3, 3, 3, 0, 0, 3, 0, 3, 0, 3, 7, 3, 3, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding windows-1252 character.
 */
static const uint8_t pm_encoding_windows_1252_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 7, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, 3, 7, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding windows-1253 character.
 */
static const uint8_t pm_encoding_windows_1253_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 3, 7, 0, 7, 7, 7, 0, 7, 0, 7, 7, // Bx
    3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 3, 3, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding windows-1254 character.
 */
static const uint8_t pm_encoding_windows_1254_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, 0, 7, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding windows-1255 character.
 */
static const uint8_t pm_encoding_windows_1255_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding windows-1256 character.
 */
static const uint8_t pm_encoding_windows_1256_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Cx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding windows-1257 character.
 */
static const uint8_t pm_encoding_windows_1257_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 0, 0, 0, 7, // Ax
    0, 0, 0, 0, 0, 3, 0, 0, 3, 0, 3, 0, 0, 0, 0, 3, // Bx
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // Cx
    7, 7, 7, 7, 7, 7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 3, // Dx
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // Ex
    3, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding windows-1258 character.
 */
static const uint8_t pm_encoding_windows_1258_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

/**
 * Each element of the following table contains a bitfield that indicates a
 * piece of information about the corresponding windows-874 character.
 */
static const uint8_t pm_encoding_windows_874_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, // 3x
    0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // 4x
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, // 5x
    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 6x
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

#define PRISM_ENCODING_TABLE(name) \
    static size_t pm_encoding_ ##name ## _alpha_char(const uint8_t *b, PRISM_ATTRIBUTE_UNUSED ptrdiff_t n) {           \
        return (pm_encoding_ ##name ## _table[*b] & PRISM_ENCODING_ALPHABETIC_BIT);           \
    }                                                                                                         \
    static size_t pm_encoding_ ##name ## _alnum_char(const uint8_t *b, PRISM_ATTRIBUTE_UNUSED ptrdiff_t n) {           \
        return (pm_encoding_ ##name ## _table[*b] & PRISM_ENCODING_ALPHANUMERIC_BIT) ? 1 : 0; \
    }                                                                                                         \
    static bool pm_encoding_ ##name ## _isupper_char(const uint8_t *b, PRISM_ATTRIBUTE_UNUSED ptrdiff_t n) {           \
        return (pm_encoding_ ##name ## _table[*b] & PRISM_ENCODING_UPPERCASE_BIT);            \
    }

PRISM_ENCODING_TABLE(cp850)
PRISM_ENCODING_TABLE(cp852)
PRISM_ENCODING_TABLE(cp855)
PRISM_ENCODING_TABLE(gb1988)
PRISM_ENCODING_TABLE(ibm437)
PRISM_ENCODING_TABLE(ibm720)
PRISM_ENCODING_TABLE(ibm737)
PRISM_ENCODING_TABLE(ibm775)
PRISM_ENCODING_TABLE(ibm852)
PRISM_ENCODING_TABLE(ibm855)
PRISM_ENCODING_TABLE(ibm857)
PRISM_ENCODING_TABLE(ibm860)
PRISM_ENCODING_TABLE(ibm861)
PRISM_ENCODING_TABLE(ibm862)
PRISM_ENCODING_TABLE(ibm863)
PRISM_ENCODING_TABLE(ibm864)
PRISM_ENCODING_TABLE(ibm865)
PRISM_ENCODING_TABLE(ibm866)
PRISM_ENCODING_TABLE(ibm869)
PRISM_ENCODING_TABLE(iso_8859_1)
PRISM_ENCODING_TABLE(iso_8859_2)
PRISM_ENCODING_TABLE(iso_8859_3)
PRISM_ENCODING_TABLE(iso_8859_4)
PRISM_ENCODING_TABLE(iso_8859_5)
PRISM_ENCODING_TABLE(iso_8859_6)
PRISM_ENCODING_TABLE(iso_8859_7)
PRISM_ENCODING_TABLE(iso_8859_8)
PRISM_ENCODING_TABLE(iso_8859_9)
PRISM_ENCODING_TABLE(iso_8859_10)
PRISM_ENCODING_TABLE(iso_8859_11)
PRISM_ENCODING_TABLE(iso_8859_13)
PRISM_ENCODING_TABLE(iso_8859_14)
PRISM_ENCODING_TABLE(iso_8859_15)
PRISM_ENCODING_TABLE(iso_8859_16)
PRISM_ENCODING_TABLE(koi8_r)
PRISM_ENCODING_TABLE(koi8_u)
PRISM_ENCODING_TABLE(mac_cent_euro)
PRISM_ENCODING_TABLE(mac_croatian)
PRISM_ENCODING_TABLE(mac_cyrillic)
PRISM_ENCODING_TABLE(mac_greek)
PRISM_ENCODING_TABLE(mac_iceland)
PRISM_ENCODING_TABLE(mac_roman)
PRISM_ENCODING_TABLE(mac_romania)
PRISM_ENCODING_TABLE(mac_thai)
PRISM_ENCODING_TABLE(mac_turkish)
PRISM_ENCODING_TABLE(mac_ukraine)
PRISM_ENCODING_TABLE(tis_620)
PRISM_ENCODING_TABLE(windows_1250)
PRISM_ENCODING_TABLE(windows_1251)
PRISM_ENCODING_TABLE(windows_1252)
PRISM_ENCODING_TABLE(windows_1253)
PRISM_ENCODING_TABLE(windows_1254)
PRISM_ENCODING_TABLE(windows_1255)
PRISM_ENCODING_TABLE(windows_1256)
PRISM_ENCODING_TABLE(windows_1257)
PRISM_ENCODING_TABLE(windows_1258)
PRISM_ENCODING_TABLE(windows_874)

#undef PRISM_ENCODING_TABLE
#endif

/**
 * Returns the size of the next character in the ASCII encoding. This basically
 * means that if the top bit is not set, the character is 1 byte long.
 */
static size_t
pm_encoding_ascii_char_width(const uint8_t *b, PRISM_ATTRIBUTE_UNUSED ptrdiff_t n) {
    return *b < 0x80 ? 1 : 0;
}

/**
 * Return the size of the next character in the ASCII encoding if it is an
 * alphabetical character.
 */
static size_t
pm_encoding_ascii_alpha_char(const uint8_t *b, PRISM_ATTRIBUTE_UNUSED ptrdiff_t n) {
    return (pm_encoding_ascii_table[*b] & PRISM_ENCODING_ALPHABETIC_BIT);
}

/**
 * Certain encodings are equivalent to ASCII below 0x80, so it works for our
 * purposes to have a function here that first checks the bounds and then falls
 * back to checking the ASCII lookup table.
 */
static size_t
pm_encoding_ascii_alpha_char_7bit(const uint8_t *b, ptrdiff_t n) {
    return (*b < 0x80) ? pm_encoding_ascii_alpha_char(b, n) : 0;
}

/**
 * Return the size of the next character in the ASCII encoding if it is an
 * alphanumeric character.
 */
static size_t
pm_encoding_ascii_alnum_char(const uint8_t *b, PRISM_ATTRIBUTE_UNUSED ptrdiff_t n) {
    return (pm_encoding_ascii_table[*b] & PRISM_ENCODING_ALPHANUMERIC_BIT) ? 1 : 0;
}

/**
 * Certain encodings are equivalent to ASCII below 0x80, so it works for our
 * purposes to have a function here that first checks the bounds and then falls
 * back to checking the ASCII lookup table.
 */
static size_t
pm_encoding_ascii_alnum_char_7bit(const uint8_t *b, ptrdiff_t n) {
    return (*b < 0x80) ? pm_encoding_ascii_alnum_char(b, n) : 0;
}

/**
 * Return true if the next character in the ASCII encoding if it is an uppercase
 * character.
 */
static bool
pm_encoding_ascii_isupper_char(const uint8_t *b, PRISM_ATTRIBUTE_UNUSED ptrdiff_t n) {
    return (pm_encoding_ascii_table[*b] & PRISM_ENCODING_UPPERCASE_BIT);
}

/**
 * For a lot of encodings the default is that they are a single byte long no
 * matter what the codepoint, so this function is shared between them.
 */
static size_t
pm_encoding_single_char_width(PRISM_ATTRIBUTE_UNUSED const uint8_t *b, PRISM_ATTRIBUTE_UNUSED ptrdiff_t n) {
    return 1;
}

/**
 * Returns the size of the next character in the EUC-JP encoding, or 0 if a
 * character cannot be decoded from the given bytes.
 */
static size_t
pm_encoding_euc_jp_char_width(const uint8_t *b, ptrdiff_t n) {
    // These are the single byte characters.
    if (*b < 0x80) {
        return 1;
    }

    // These are the double byte characters.
    if ((n > 1) && ((b[0] == 0x8E) || (b[0] >= 0xA1 && b[0] <= 0xFE)) && (b[1] >= 0xA1 && b[1] <= 0xFE)) {
        return 2;
    }

    // These are the triple byte characters.
    if ((n > 2) && (b[0] == 0x8F) && (b[1] >= 0xA1 && b[2] <= 0xFE) && (b[2] >= 0xA1 && b[2] <= 0xFE)) {
        return 3;
    }

    return 0;
}

/**
 * Returns the size of the next character in the EUC-JP encoding if it is an
 * uppercase character.
 */
static bool
pm_encoding_euc_jp_isupper_char(const uint8_t *b, ptrdiff_t n) {
    size_t width = pm_encoding_euc_jp_char_width(b, n);

    if (width == 1) {
        return pm_encoding_ascii_isupper_char(b, n);
    } else if (width == 2) {
        return (
            (b[0] == 0xA3 && b[1] >= 0xC1 && b[1] <= 0xDA) ||
            (b[0] == 0xA6 && b[1] >= 0xA1 && b[1] <= 0xB8) ||
            (b[0] == 0xA7 && b[1] >= 0xA1 && b[1] <= 0xC1)
        );
    } else {
        return false;
    }
}

/**
 * Returns the size of the next character in the Shift_JIS encoding, or 0 if a
 * character cannot be decoded from the given bytes.
 */
static size_t
pm_encoding_shift_jis_char_width(const uint8_t *b, ptrdiff_t n) {
    // These are the single byte characters.
    if (b[0] < 0x80 || (b[0] >= 0xA1 && b[0] <= 0xDF)) {
        return 1;
    }

    // These are the double byte characters.
    if ((n > 1) && ((b[0] >= 0x81 && b[0] <= 0x9F) || (b[0] >= 0xE0 && b[0] <= 0xFC)) && (b[1] >= 0x40 && b[1] <= 0xFC && b[1] != 0x7F)) {
        return 2;
    }

    return 0;
}

/**
 * Returns the size of the next character in the Shift_JIS encoding if it is an
 * alphanumeric character.
 */
static size_t
pm_encoding_shift_jis_alnum_char(const uint8_t *b, ptrdiff_t n) {
    size_t width = pm_encoding_shift_jis_char_width(b, n);
    return width == 1 ? ((b[0] >= 0x80) || pm_encoding_ascii_alnum_char(b, n)) : width;
}

/**
 * Returns the size of the next character in the Shift_JIS encoding if it is an
 * alphabetical character.
 */
static size_t
pm_encoding_shift_jis_alpha_char(const uint8_t *b, ptrdiff_t n) {
    size_t width = pm_encoding_shift_jis_char_width(b, n);
    return width == 1 ? ((b[0] >= 0x80) || pm_encoding_ascii_alpha_char(b, n)) : width;
}

/**
 * Returns the size of the next character in the Shift_JIS encoding if it is an
 * uppercase character.
 */
static bool
pm_encoding_shift_jis_isupper_char(const uint8_t *b, ptrdiff_t n) {
    size_t width = pm_encoding_shift_jis_char_width(b, n);

    if (width == 1) {
        return pm_encoding_ascii_isupper_char(b, n);
    } else if (width == 2) {
        return (
            ((b[0] == 0x82) && (b[1] >= 0x60 && b[1] <= 0x79)) ||
            ((b[0] == 0x83) && (b[1] >= 0x9F && b[1] <= 0xB6)) ||
            ((b[0] == 0x84) && (b[1] >= 0x40 && b[1] <= 0x60))
        );
    } else {
        return width;
    }
}

#ifndef PRISM_ENCODING_EXCLUDE_FULL

/**
 * Certain encodings are equivalent to ASCII below 0x80, so it works for our
 * purposes to have a function here that first checks the bounds and then falls
 * back to checking the ASCII lookup table.
 */
static bool
pm_encoding_ascii_isupper_char_7bit(const uint8_t *b, ptrdiff_t n) {
    return (*b < 0x80) && pm_encoding_ascii_isupper_char(b, n);
}

/**
 * Returns the size of the next character in the Big5 encoding, or 0 if a
 * character cannot be decoded from the given bytes.
 */
static size_t
pm_encoding_big5_char_width(const uint8_t *b, ptrdiff_t n) {
    // These are the single byte characters.
    if (*b < 0x80) {
        return 1;
    }

    // These are the double byte characters.
    if ((n > 1) && (b[0] >= 0xA1 && b[0] <= 0xFE) && ((b[1] >= 0x40 && b[1] <= 0x7E) || (b[1] >= 0xA1 && b[1] <= 0xFE))) {
        return 2;
    }

    return 0;
}

/**
 * Returns the size of the next character in the CP949 encoding, or 0 if a
 * character cannot be decoded from the given bytes.
 */
static size_t
pm_encoding_cp949_char_width(const uint8_t *b, ptrdiff_t n) {
    // These are the single byte characters
    if (*b <= 0x80) {
        return 1;
    }

    // These are the double byte characters
    if ((n > 1) && (b[0] >= 0x81 && b[0] <= 0xFE) && ((b[1] >= 0x41 && b[1] <= 0x5A) || (b[1] >= 0x61 && b[1] <= 0x7A) || (b[1] >= 0x81 && b[1] <= 0xFE))) {
        return 2;
    }

    return 0;
}

/**
 * Returns the size of the next character in the Emacs MULE encoding, or 0 if a
 * character cannot be decoded from the given bytes.
 */
static size_t
pm_encoding_emacs_mule_char_width(const uint8_t *b, ptrdiff_t n) {
    // These are the 1 byte characters.
    if (*b < 0x80) {
        return 1;
    }

    // These are the 2 byte characters.
    if ((n > 1) && (b[0] >= 0x81 && b[0] <= 0x8F) && (b[1] >= 0xA0)) {
        return 2;
    }

    // These are the 3 byte characters.
    if (
        (n > 2) &&
        (
            ((b[0] >= 0x90 && b[0] <= 0x99) && (b[1] >= 0xA0)) ||
            ((b[0] == 0x9A || b[0] == 0x9B) && (b[1] >= 0xE0 && b[1] <= 0xEF))
        ) &&
        (b[2] >= 0xA0)
    ) {
        return 3;
    }

    // These are the 4 byte characters.
    if (
        (n > 3) &&
        (
            ((b[0] == 0x9C) && (b[1] >= 0xF0) && (b[1] <= 0xF4)) ||
            ((b[0] == 0x9D) && (b[1] >= 0xF5) && (b[1] <= 0xFE))
        ) &&
        (b[2] >= 0xA0) && (b[3] >= 0xA0)
    ) {
        return 4;
    }

    return 0;
}

/**
 * Returns the size of the next character in the EUC-KR encoding, or 0 if a
 * character cannot be decoded from the given bytes.
 */
static size_t
pm_encoding_euc_kr_char_width(const uint8_t *b, ptrdiff_t n) {
    // These are the single byte characters.
    if (*b < 0x80) {
        return 1;
    }

    // These are the double byte characters.
    if ((n > 1) && (b[0] >= 0xA1 && b[0] <= 0xFE) && (b[1] >= 0xA1 && b[1] <= 0xFE)) {
        return 2;
    }

    return 0;
}

/**
 * Returns the size of the next character in the EUC-TW encoding, or 0 if a
 * character cannot be decoded from the given bytes.
 */
static size_t
pm_encoding_euc_tw_char_width(const uint8_t *b, ptrdiff_t n) {
    // These are the single byte characters.
    if (*b < 0x80) {
        return 1;
    }

    // These are the double byte characters.
    if ((n > 1) && (b[0] >= 0xA1) && (b[0] <= 0xFE) && (b[1] >= 0xA1) && (b[1] <= 0xFE)) {
        return 2;
    }

    // These are the quadruple byte characters.
    if ((n > 3) && (b[0] == 0x8E) && (b[1] >= 0xA1) && (b[1] <= 0xB0) && (b[2] >= 0xA1) && (b[2] <= 0xFE) && (b[3] >= 0xA1) && (b[3] <= 0xFE)) {
        return 4;
    }

    return 0;
}

/**
 * Returns the size of the next character in the GB18030 encoding, or 0 if a
 * character cannot be decoded from the given bytes.
 */
static size_t
pm_encoding_gb18030_char_width(const uint8_t *b, ptrdiff_t n) {
    // These are the 1 byte characters.
    if (*b < 0x80) {
        return 1;
    }

    // These are the 2 byte characters.
    if ((n > 1) && (b[0] >= 0x81 && b[0] <= 0xFE) && (b[1] >= 0x40 && b[1] <= 0xFE && b[1] != 0x7F)) {
        return 2;
    }

    // These are the 4 byte characters.
    if ((n > 3) && ((b[0] >= 0x81 && b[0] <= 0xFE) && (b[1] >= 0x30 && b[1] <= 0x39) && (b[2] >= 0x81 && b[2] <= 0xFE) && (b[3] >= 0x30 && b[3] <= 0x39))) {
        return 4;
    }

    return 0;
}

/**
 * Returns the size of the next character in the GBK encoding, or 0 if a
 * character cannot be decoded from the given bytes.
 */
static size_t
pm_encoding_gbk_char_width(const uint8_t *b, ptrdiff_t n) {
    // These are the single byte characters.
    if (*b <= 0x80) {
        return 1;
    }

    // These are the double byte characters.
    if (
        (n > 1) &&
        (
            ((b[0] >= 0xA1 && b[0] <= 0xA9) && (b[1] >= 0xA1 && b[1] <= 0xFE)) || // GBK/1
            ((b[0] >= 0xB0 && b[0] <= 0xF7) && (b[1] >= 0xA1 && b[1] <= 0xFE)) || // GBK/2
            ((b[0] >= 0x81 && b[0] <= 0xA0) && (b[1] >= 0x40 && b[1] <= 0xFE) && (b[1] != 0x7F)) || // GBK/3
            ((b[0] >= 0xAA && b[0] <= 0xFE) && (b[1] >= 0x40 && b[1] <= 0xA0) && (b[1] != 0x7F)) || // GBK/4
            ((b[0] >= 0xA8 && b[0] <= 0xA9) && (b[1] >= 0x40 && b[1] <= 0xA0) && (b[1] != 0x7F)) || // GBK/5
            ((b[0] >= 0xAA && b[0] <= 0xAF) && (b[1] >= 0xA1 && b[1] <= 0xFE)) || // user-defined 1
            ((b[0] >= 0xF8 && b[0] <= 0xFE) && (b[1] >= 0xA1 && b[1] <= 0xFE)) || // user-defined 2
            ((b[0] >= 0xA1 && b[0] <= 0xA7) && (b[1] >= 0x40 && b[1] <= 0xA0) && (b[1] != 0x7F)) // user-defined 3
        )
    ) {
        return 2;
    }

    return 0;
}

#endif

/**
 * This is the table of all of the encodings that prism supports.
 */
const pm_encoding_t pm_encodings[] = {
    [PM_ENCODING_UTF_8] = {
        .name = "UTF-8",
        .char_width = pm_encoding_utf_8_char_width,
        .alnum_char = pm_encoding_utf_8_alnum_char,
        .alpha_char = pm_encoding_utf_8_alpha_char,
        .isupper_char = pm_encoding_utf_8_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_US_ASCII] = {
        .name = "US-ASCII",
        .char_width = pm_encoding_ascii_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char,
        .alpha_char = pm_encoding_ascii_alpha_char,
        .isupper_char = pm_encoding_ascii_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ASCII_8BIT] = {
        .name = "ASCII-8BIT",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char,
        .alpha_char = pm_encoding_ascii_alpha_char,
        .isupper_char = pm_encoding_ascii_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_EUC_JP] = {
        .name = "EUC-JP",
        .char_width = pm_encoding_euc_jp_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_euc_jp_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_WINDOWS_31J] = {
        .name = "Windows-31J",
        .char_width = pm_encoding_shift_jis_char_width,
        .alnum_char = pm_encoding_shift_jis_alnum_char,
        .alpha_char = pm_encoding_shift_jis_alpha_char,
        .isupper_char = pm_encoding_shift_jis_isupper_char,
        .multibyte = true
    },

#ifndef PRISM_ENCODING_EXCLUDE_FULL
    [PM_ENCODING_BIG5] = {
        .name = "Big5",
        .char_width = pm_encoding_big5_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_BIG5_HKSCS] = {
        .name = "Big5-HKSCS",
        .char_width = pm_encoding_big5_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_BIG5_UAO] = {
        .name = "Big5-UAO",
        .char_width = pm_encoding_big5_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_CESU_8] = {
        .name = "CESU-8",
        .char_width = pm_encoding_cesu_8_char_width,
        .alnum_char = pm_encoding_cesu_8_alnum_char,
        .alpha_char = pm_encoding_cesu_8_alpha_char,
        .isupper_char = pm_encoding_cesu_8_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_CP51932] = {
        .name = "CP51932",
        .char_width = pm_encoding_euc_jp_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_euc_jp_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_CP850] = {
        .name = "CP850",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_cp850_alnum_char,
        .alpha_char = pm_encoding_cp850_alpha_char,
        .isupper_char = pm_encoding_cp850_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_CP852] = {
        .name = "CP852",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_cp852_alnum_char,
        .alpha_char = pm_encoding_cp852_alpha_char,
        .isupper_char = pm_encoding_cp852_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_CP855] = {
        .name = "CP855",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_cp855_alnum_char,
        .alpha_char = pm_encoding_cp855_alpha_char,
        .isupper_char = pm_encoding_cp855_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_CP949] = {
        .name = "CP949",
        .char_width = pm_encoding_cp949_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_CP950] = {
        .name = "CP950",
        .char_width = pm_encoding_big5_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_CP951] = {
        .name = "CP951",
        .char_width = pm_encoding_big5_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_EMACS_MULE] = {
        .name = "Emacs-Mule",
        .char_width = pm_encoding_emacs_mule_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_EUC_JP_MS] = {
        .name = "eucJP-ms",
        .char_width = pm_encoding_euc_jp_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_euc_jp_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_EUC_JIS_2004] = {
        .name = "EUC-JIS-2004",
        .char_width = pm_encoding_euc_jp_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_euc_jp_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_EUC_KR] = {
        .name = "EUC-KR",
        .char_width = pm_encoding_euc_kr_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_EUC_TW] = {
        .name = "EUC-TW",
        .char_width = pm_encoding_euc_tw_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_GB12345] = {
        .name = "GB12345",
        .char_width = pm_encoding_euc_kr_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_GB18030] = {
        .name = "GB18030",
        .char_width = pm_encoding_gb18030_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_GB1988] = {
        .name = "GB1988",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_gb1988_alnum_char,
        .alpha_char = pm_encoding_gb1988_alpha_char,
        .isupper_char = pm_encoding_gb1988_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_GB2312] = {
        .name = "GB2312",
        .char_width = pm_encoding_euc_kr_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_GBK] = {
        .name = "GBK",
        .char_width = pm_encoding_gbk_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_IBM437] = {
        .name = "IBM437",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm437_alnum_char,
        .alpha_char = pm_encoding_ibm437_alpha_char,
        .isupper_char = pm_encoding_ibm437_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_IBM720] = {
        .name = "IBM720",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm720_alnum_char,
        .alpha_char = pm_encoding_ibm720_alpha_char,
        .isupper_char = pm_encoding_ibm720_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_IBM737] = {
        .name = "IBM737",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm737_alnum_char,
        .alpha_char = pm_encoding_ibm737_alpha_char,
        .isupper_char = pm_encoding_ibm737_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_IBM775] = {
        .name = "IBM775",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm775_alnum_char,
        .alpha_char = pm_encoding_ibm775_alpha_char,
        .isupper_char = pm_encoding_ibm775_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_IBM852] = {
        .name = "IBM852",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm852_alnum_char,
        .alpha_char = pm_encoding_ibm852_alpha_char,
        .isupper_char = pm_encoding_ibm852_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_IBM855] = {
        .name = "IBM855",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm855_alnum_char,
        .alpha_char = pm_encoding_ibm855_alpha_char,
        .isupper_char = pm_encoding_ibm855_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_IBM857] = {
        .name = "IBM857",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm857_alnum_char,
        .alpha_char = pm_encoding_ibm857_alpha_char,
        .isupper_char = pm_encoding_ibm857_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_IBM860] = {
        .name = "IBM860",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm860_alnum_char,
        .alpha_char = pm_encoding_ibm860_alpha_char,
        .isupper_char = pm_encoding_ibm860_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_IBM861] = {
        .name = "IBM861",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm861_alnum_char,
        .alpha_char = pm_encoding_ibm861_alpha_char,
        .isupper_char = pm_encoding_ibm861_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_IBM862] = {
        .name = "IBM862",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm862_alnum_char,
        .alpha_char = pm_encoding_ibm862_alpha_char,
        .isupper_char = pm_encoding_ibm862_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_IBM863] = {
        .name = "IBM863",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm863_alnum_char,
        .alpha_char = pm_encoding_ibm863_alpha_char,
        .isupper_char = pm_encoding_ibm863_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_IBM864] = {
        .name = "IBM864",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm864_alnum_char,
        .alpha_char = pm_encoding_ibm864_alpha_char,
        .isupper_char = pm_encoding_ibm864_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_IBM865] = {
        .name = "IBM865",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm865_alnum_char,
        .alpha_char = pm_encoding_ibm865_alpha_char,
        .isupper_char = pm_encoding_ibm865_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_IBM866] = {
        .name = "IBM866",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm866_alnum_char,
        .alpha_char = pm_encoding_ibm866_alpha_char,
        .isupper_char = pm_encoding_ibm866_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_IBM869] = {
        .name = "IBM869",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_ibm869_alnum_char,
        .alpha_char = pm_encoding_ibm869_alpha_char,
        .isupper_char = pm_encoding_ibm869_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_1] = {
        .name = "ISO-8859-1",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_1_alnum_char,
        .alpha_char = pm_encoding_iso_8859_1_alpha_char,
        .isupper_char = pm_encoding_iso_8859_1_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_2] = {
        .name = "ISO-8859-2",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_2_alnum_char,
        .alpha_char = pm_encoding_iso_8859_2_alpha_char,
        .isupper_char = pm_encoding_iso_8859_2_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_3] = {
        .name = "ISO-8859-3",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_3_alnum_char,
        .alpha_char = pm_encoding_iso_8859_3_alpha_char,
        .isupper_char = pm_encoding_iso_8859_3_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_4] = {
        .name = "ISO-8859-4",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_4_alnum_char,
        .alpha_char = pm_encoding_iso_8859_4_alpha_char,
        .isupper_char = pm_encoding_iso_8859_4_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_5] = {
        .name = "ISO-8859-5",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_5_alnum_char,
        .alpha_char = pm_encoding_iso_8859_5_alpha_char,
        .isupper_char = pm_encoding_iso_8859_5_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_6] = {
        .name = "ISO-8859-6",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_6_alnum_char,
        .alpha_char = pm_encoding_iso_8859_6_alpha_char,
        .isupper_char = pm_encoding_iso_8859_6_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_7] = {
        .name = "ISO-8859-7",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_7_alnum_char,
        .alpha_char = pm_encoding_iso_8859_7_alpha_char,
        .isupper_char = pm_encoding_iso_8859_7_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_8] = {
        .name = "ISO-8859-8",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_8_alnum_char,
        .alpha_char = pm_encoding_iso_8859_8_alpha_char,
        .isupper_char = pm_encoding_iso_8859_8_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_9] = {
        .name = "ISO-8859-9",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_9_alnum_char,
        .alpha_char = pm_encoding_iso_8859_9_alpha_char,
        .isupper_char = pm_encoding_iso_8859_9_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_10] = {
        .name = "ISO-8859-10",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_10_alnum_char,
        .alpha_char = pm_encoding_iso_8859_10_alpha_char,
        .isupper_char = pm_encoding_iso_8859_10_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_11] = {
        .name = "ISO-8859-11",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_11_alnum_char,
        .alpha_char = pm_encoding_iso_8859_11_alpha_char,
        .isupper_char = pm_encoding_iso_8859_11_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_13] = {
        .name = "ISO-8859-13",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_13_alnum_char,
        .alpha_char = pm_encoding_iso_8859_13_alpha_char,
        .isupper_char = pm_encoding_iso_8859_13_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_14] = {
        .name = "ISO-8859-14",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_14_alnum_char,
        .alpha_char = pm_encoding_iso_8859_14_alpha_char,
        .isupper_char = pm_encoding_iso_8859_14_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_15] = {
        .name = "ISO-8859-15",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_15_alnum_char,
        .alpha_char = pm_encoding_iso_8859_15_alpha_char,
        .isupper_char = pm_encoding_iso_8859_15_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_ISO_8859_16] = {
        .name = "ISO-8859-16",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_iso_8859_16_alnum_char,
        .alpha_char = pm_encoding_iso_8859_16_alpha_char,
        .isupper_char = pm_encoding_iso_8859_16_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_KOI8_R] = {
        .name = "KOI8-R",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_koi8_r_alnum_char,
        .alpha_char = pm_encoding_koi8_r_alpha_char,
        .isupper_char = pm_encoding_koi8_r_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_KOI8_U] = {
        .name = "KOI8-U",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_koi8_u_alnum_char,
        .alpha_char = pm_encoding_koi8_u_alpha_char,
        .isupper_char = pm_encoding_koi8_u_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_MAC_CENT_EURO] = {
        .name = "macCentEuro",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_mac_cent_euro_alnum_char,
        .alpha_char = pm_encoding_mac_cent_euro_alpha_char,
        .isupper_char = pm_encoding_mac_cent_euro_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_MAC_CROATIAN] = {
        .name = "macCroatian",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_mac_croatian_alnum_char,
        .alpha_char = pm_encoding_mac_croatian_alpha_char,
        .isupper_char = pm_encoding_mac_croatian_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_MAC_CYRILLIC] = {
        .name = "macCyrillic",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_mac_cyrillic_alnum_char,
        .alpha_char = pm_encoding_mac_cyrillic_alpha_char,
        .isupper_char = pm_encoding_mac_cyrillic_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_MAC_GREEK] = {
        .name = "macGreek",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_mac_greek_alnum_char,
        .alpha_char = pm_encoding_mac_greek_alpha_char,
        .isupper_char = pm_encoding_mac_greek_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_MAC_ICELAND] = {
        .name = "macIceland",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_mac_iceland_alnum_char,
        .alpha_char = pm_encoding_mac_iceland_alpha_char,
        .isupper_char = pm_encoding_mac_iceland_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_MAC_JAPANESE] = {
        .name = "MacJapanese",
        .char_width = pm_encoding_shift_jis_char_width,
        .alnum_char = pm_encoding_shift_jis_alnum_char,
        .alpha_char = pm_encoding_shift_jis_alpha_char,
        .isupper_char = pm_encoding_shift_jis_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_MAC_ROMAN] = {
        .name = "macRoman",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_mac_roman_alnum_char,
        .alpha_char = pm_encoding_mac_roman_alpha_char,
        .isupper_char = pm_encoding_mac_roman_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_MAC_ROMANIA] = {
        .name = "macRomania",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_mac_romania_alnum_char,
        .alpha_char = pm_encoding_mac_romania_alpha_char,
        .isupper_char = pm_encoding_mac_romania_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_MAC_THAI] = {
        .name = "macThai",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_mac_thai_alnum_char,
        .alpha_char = pm_encoding_mac_thai_alpha_char,
        .isupper_char = pm_encoding_mac_thai_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_MAC_TURKISH] = {
        .name = "macTurkish",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_mac_turkish_alnum_char,
        .alpha_char = pm_encoding_mac_turkish_alpha_char,
        .isupper_char = pm_encoding_mac_turkish_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_MAC_UKRAINE] = {
        .name = "macUkraine",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_mac_ukraine_alnum_char,
        .alpha_char = pm_encoding_mac_ukraine_alpha_char,
        .isupper_char = pm_encoding_mac_ukraine_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_SHIFT_JIS] = {
        .name = "Shift_JIS",
        .char_width = pm_encoding_shift_jis_char_width,
        .alnum_char = pm_encoding_shift_jis_alnum_char,
        .alpha_char = pm_encoding_shift_jis_alpha_char,
        .isupper_char = pm_encoding_shift_jis_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_SJIS_DOCOMO] = {
        .name = "SJIS-DoCoMo",
        .char_width = pm_encoding_shift_jis_char_width,
        .alnum_char = pm_encoding_shift_jis_alnum_char,
        .alpha_char = pm_encoding_shift_jis_alpha_char,
        .isupper_char = pm_encoding_shift_jis_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_SJIS_KDDI] = {
        .name = "SJIS-KDDI",
        .char_width = pm_encoding_shift_jis_char_width,
        .alnum_char = pm_encoding_shift_jis_alnum_char,
        .alpha_char = pm_encoding_shift_jis_alpha_char,
        .isupper_char = pm_encoding_shift_jis_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_SJIS_SOFTBANK] = {
        .name = "SJIS-SoftBank",
        .char_width = pm_encoding_shift_jis_char_width,
        .alnum_char = pm_encoding_shift_jis_alnum_char,
        .alpha_char = pm_encoding_shift_jis_alpha_char,
        .isupper_char = pm_encoding_shift_jis_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_STATELESS_ISO_2022_JP] = {
        .name = "stateless-ISO-2022-JP",
        .char_width = pm_encoding_emacs_mule_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_STATELESS_ISO_2022_JP_KDDI] = {
        .name = "stateless-ISO-2022-JP-KDDI",
        .char_width = pm_encoding_emacs_mule_char_width,
        .alnum_char = pm_encoding_ascii_alnum_char_7bit,
        .alpha_char = pm_encoding_ascii_alpha_char_7bit,
        .isupper_char = pm_encoding_ascii_isupper_char_7bit,
        .multibyte = true
    },
    [PM_ENCODING_TIS_620] = {
        .name = "TIS-620",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_tis_620_alnum_char,
        .alpha_char = pm_encoding_tis_620_alpha_char,
        .isupper_char = pm_encoding_tis_620_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_UTF8_MAC] = {
        .name = "UTF8-MAC",
        .char_width = pm_encoding_utf_8_char_width,
        .alnum_char = pm_encoding_utf_8_alnum_char,
        .alpha_char = pm_encoding_utf_8_alpha_char,
        .isupper_char = pm_encoding_utf_8_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_UTF8_DOCOMO] = {
        .name = "UTF8-DoCoMo",
        .char_width = pm_encoding_utf_8_char_width,
        .alnum_char = pm_encoding_utf_8_alnum_char,
        .alpha_char = pm_encoding_utf_8_alpha_char,
        .isupper_char = pm_encoding_utf_8_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_UTF8_KDDI] = {
        .name = "UTF8-KDDI",
        .char_width = pm_encoding_utf_8_char_width,
        .alnum_char = pm_encoding_utf_8_alnum_char,
        .alpha_char = pm_encoding_utf_8_alpha_char,
        .isupper_char = pm_encoding_utf_8_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_UTF8_SOFTBANK] = {
        .name = "UTF8-SoftBank",
        .char_width = pm_encoding_utf_8_char_width,
        .alnum_char = pm_encoding_utf_8_alnum_char,
        .alpha_char = pm_encoding_utf_8_alpha_char,
        .isupper_char = pm_encoding_utf_8_isupper_char,
        .multibyte = true
    },
    [PM_ENCODING_WINDOWS_1250] = {
        .name = "Windows-1250",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_windows_1250_alnum_char,
        .alpha_char = pm_encoding_windows_1250_alpha_char,
        .isupper_char = pm_encoding_windows_1250_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_WINDOWS_1251] = {
        .name = "Windows-1251",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_windows_1251_alnum_char,
        .alpha_char = pm_encoding_windows_1251_alpha_char,
        .isupper_char = pm_encoding_windows_1251_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_WINDOWS_1252] = {
        .name = "Windows-1252",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_windows_1252_alnum_char,
        .alpha_char = pm_encoding_windows_1252_alpha_char,
        .isupper_char = pm_encoding_windows_1252_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_WINDOWS_1253] = {
        .name = "Windows-1253",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_windows_1253_alnum_char,
        .alpha_char = pm_encoding_windows_1253_alpha_char,
        .isupper_char = pm_encoding_windows_1253_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_WINDOWS_1254] = {
        .name = "Windows-1254",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_windows_1254_alnum_char,
        .alpha_char = pm_encoding_windows_1254_alpha_char,
        .isupper_char = pm_encoding_windows_1254_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_WINDOWS_1255] = {
        .name = "Windows-1255",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_windows_1255_alnum_char,
        .alpha_char = pm_encoding_windows_1255_alpha_char,
        .isupper_char = pm_encoding_windows_1255_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_WINDOWS_1256] = {
        .name = "Windows-1256",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_windows_1256_alnum_char,
        .alpha_char = pm_encoding_windows_1256_alpha_char,
        .isupper_char = pm_encoding_windows_1256_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_WINDOWS_1257] = {
        .name = "Windows-1257",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_windows_1257_alnum_char,
        .alpha_char = pm_encoding_windows_1257_alpha_char,
        .isupper_char = pm_encoding_windows_1257_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_WINDOWS_1258] = {
        .name = "Windows-1258",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_windows_1258_alnum_char,
        .alpha_char = pm_encoding_windows_1258_alpha_char,
        .isupper_char = pm_encoding_windows_1258_isupper_char,
        .multibyte = false
    },
    [PM_ENCODING_WINDOWS_874] = {
        .name = "Windows-874",
        .char_width = pm_encoding_single_char_width,
        .alnum_char = pm_encoding_windows_874_alnum_char,
        .alpha_char = pm_encoding_windows_874_alpha_char,
        .isupper_char = pm_encoding_windows_874_isupper_char,
        .multibyte = false
    }
#endif
};

/**
 * Parse the given name of an encoding and return a pointer to the corresponding
 * encoding struct if one can be found, otherwise return NULL.
 */
const pm_encoding_t *
pm_encoding_find(const uint8_t *start, const uint8_t *end) {
    size_t width = (size_t) (end - start);

    // First, we're going to check for UTF-8. This is the most common encoding.
    // UTF-8 can contain extra information at the end about the platform it is
    // encoded on, such as UTF-8-MAC or UTF-8-UNIX. We'll ignore those suffixes.
    if ((start + 5 <= end) && (pm_strncasecmp(start, (const uint8_t *) "UTF-8", 5) == 0)) {
#ifndef PRISM_ENCODING_EXCLUDE_FULL
        // We need to explicitly handle UTF-8-HFS, as that one needs to switch
        // over to being UTF8-MAC.
        if (width == 9 && (pm_strncasecmp(start + 5, (const uint8_t *) "-HFS", 4) == 0)) {
            return &pm_encodings[PM_ENCODING_UTF8_MAC];
        }
#endif

        // Otherwise we'll return the default UTF-8 encoding.
        return PM_ENCODING_UTF_8_ENTRY;
    }

    // Next, we're going to loop through each of the encodings that we handle
    // explicitly. If we found one that we understand, we'll use that value.
#define ENCODING1(name, encoding) if (width == sizeof(name) - 1 && pm_strncasecmp(start, (const uint8_t *) name, width) == 0) return &pm_encodings[encoding];
#define ENCODING2(name1, name2, encoding) ENCODING1(name1, encoding) ENCODING1(name2, encoding)

    if (width >= 3) {
        switch (*start) {
            case 'A': case 'a':
                ENCODING1("ASCII", PM_ENCODING_US_ASCII);
                ENCODING1("ASCII-8BIT", PM_ENCODING_ASCII_8BIT);
                ENCODING1("ANSI_X3.4-1968", PM_ENCODING_US_ASCII);
                break;
            case 'B': case 'b':
                ENCODING1("BINARY", PM_ENCODING_ASCII_8BIT);
#ifndef PRISM_ENCODING_EXCLUDE_FULL
                ENCODING1("Big5", PM_ENCODING_BIG5);
                ENCODING2("Big5-HKSCS", "Big5-HKSCS:2008", PM_ENCODING_BIG5_HKSCS);
                ENCODING1("Big5-UAO", PM_ENCODING_BIG5_UAO);
#endif
                break;
            case 'C': case 'c':
                ENCODING1("CP65001", PM_ENCODING_UTF_8);
                ENCODING2("CP932", "csWindows31J", PM_ENCODING_WINDOWS_31J);
#ifndef PRISM_ENCODING_EXCLUDE_FULL
                ENCODING1("CESU-8", PM_ENCODING_CESU_8);
                ENCODING1("CP437", PM_ENCODING_IBM437);
                ENCODING1("CP720", PM_ENCODING_IBM720);
                ENCODING1("CP737", PM_ENCODING_IBM737);
                ENCODING1("CP775", PM_ENCODING_IBM775);
                ENCODING1("CP850", PM_ENCODING_CP850);
                ENCODING1("CP852", PM_ENCODING_CP852);
                ENCODING1("CP855", PM_ENCODING_CP855);
                ENCODING1("CP857", PM_ENCODING_IBM857);
                ENCODING1("CP860", PM_ENCODING_IBM860);
                ENCODING1("CP861", PM_ENCODING_IBM861);
                ENCODING1("CP862", PM_ENCODING_IBM862);
                ENCODING1("CP864", PM_ENCODING_IBM864);
                ENCODING1("CP865", PM_ENCODING_IBM865);
                ENCODING1("CP866", PM_ENCODING_IBM866);
                ENCODING1("CP869", PM_ENCODING_IBM869);
                ENCODING1("CP874", PM_ENCODING_WINDOWS_874);
                ENCODING1("CP878", PM_ENCODING_KOI8_R);
                ENCODING1("CP863", PM_ENCODING_IBM863);
                ENCODING1("CP936", PM_ENCODING_GBK);
                ENCODING1("CP949", PM_ENCODING_CP949);
                ENCODING1("CP950", PM_ENCODING_CP950);
                ENCODING1("CP951", PM_ENCODING_CP951);
                ENCODING1("CP1250", PM_ENCODING_WINDOWS_1250);
                ENCODING1("CP1251", PM_ENCODING_WINDOWS_1251);
                ENCODING1("CP1252", PM_ENCODING_WINDOWS_1252);
                ENCODING1("CP1253", PM_ENCODING_WINDOWS_1253);
                ENCODING1("CP1254", PM_ENCODING_WINDOWS_1254);
                ENCODING1("CP1255", PM_ENCODING_WINDOWS_1255);
                ENCODING1("CP1256", PM_ENCODING_WINDOWS_1256);
                ENCODING1("CP1257", PM_ENCODING_WINDOWS_1257);
                ENCODING1("CP1258", PM_ENCODING_WINDOWS_1258);
                ENCODING1("CP51932", PM_ENCODING_CP51932);
#endif
                break;
            case 'E': case 'e':
                ENCODING2("EUC-JP", "eucJP", PM_ENCODING_EUC_JP);
#ifndef PRISM_ENCODING_EXCLUDE_FULL
                ENCODING2("eucJP-ms", "euc-jp-ms", PM_ENCODING_EUC_JP_MS);
                ENCODING2("EUC-JIS-2004", "EUC-JISX0213", PM_ENCODING_EUC_JIS_2004);
                ENCODING2("EUC-KR", "eucKR", PM_ENCODING_EUC_KR);
                ENCODING2("EUC-CN", "eucCN", PM_ENCODING_GB2312);
                ENCODING2("EUC-TW", "eucTW", PM_ENCODING_EUC_TW);
                ENCODING1("Emacs-Mule", PM_ENCODING_EMACS_MULE);
#endif
                break;
            case 'G': case 'g':
#ifndef PRISM_ENCODING_EXCLUDE_FULL
                ENCODING1("GBK", PM_ENCODING_GBK);
                ENCODING1("GB12345", PM_ENCODING_GB12345);
                ENCODING1("GB18030", PM_ENCODING_GB18030);
                ENCODING1("GB1988", PM_ENCODING_GB1988);
                ENCODING1("GB2312", PM_ENCODING_GB2312);
#endif
                break;
            case 'I': case 'i':
#ifndef PRISM_ENCODING_EXCLUDE_FULL
                ENCODING1("IBM437", PM_ENCODING_IBM437);
                ENCODING1("IBM720", PM_ENCODING_IBM720);
                ENCODING1("IBM737", PM_ENCODING_IBM737);
                ENCODING1("IBM775", PM_ENCODING_IBM775);
                ENCODING1("IBM850", PM_ENCODING_CP850);
                ENCODING1("IBM852", PM_ENCODING_IBM852);
                ENCODING1("IBM855", PM_ENCODING_IBM855);
                ENCODING1("IBM857", PM_ENCODING_IBM857);
                ENCODING1("IBM860", PM_ENCODING_IBM860);
                ENCODING1("IBM861", PM_ENCODING_IBM861);
                ENCODING1("IBM862", PM_ENCODING_IBM862);
                ENCODING1("IBM863", PM_ENCODING_IBM863);
                ENCODING1("IBM864", PM_ENCODING_IBM864);
                ENCODING1("IBM865", PM_ENCODING_IBM865);
                ENCODING1("IBM866", PM_ENCODING_IBM866);
                ENCODING1("IBM869", PM_ENCODING_IBM869);
                ENCODING2("ISO-8859-1", "ISO8859-1", PM_ENCODING_ISO_8859_1);
                ENCODING2("ISO-8859-2", "ISO8859-2", PM_ENCODING_ISO_8859_2);
                ENCODING2("ISO-8859-3", "ISO8859-3", PM_ENCODING_ISO_8859_3);
                ENCODING2("ISO-8859-4", "ISO8859-4", PM_ENCODING_ISO_8859_4);
                ENCODING2("ISO-8859-5", "ISO8859-5", PM_ENCODING_ISO_8859_5);
                ENCODING2("ISO-8859-6", "ISO8859-6", PM_ENCODING_ISO_8859_6);
                ENCODING2("ISO-8859-7", "ISO8859-7", PM_ENCODING_ISO_8859_7);
                ENCODING2("ISO-8859-8", "ISO8859-8", PM_ENCODING_ISO_8859_8);
                ENCODING2("ISO-8859-9", "ISO8859-9", PM_ENCODING_ISO_8859_9);
                ENCODING2("ISO-8859-10", "ISO8859-10", PM_ENCODING_ISO_8859_10);
                ENCODING2("ISO-8859-11", "ISO8859-11", PM_ENCODING_ISO_8859_11);
                ENCODING2("ISO-8859-13", "ISO8859-13", PM_ENCODING_ISO_8859_13);
                ENCODING2("ISO-8859-14", "ISO8859-14", PM_ENCODING_ISO_8859_14);
                ENCODING2("ISO-8859-15", "ISO8859-15", PM_ENCODING_ISO_8859_15);
                ENCODING2("ISO-8859-16", "ISO8859-16", PM_ENCODING_ISO_8859_16);
#endif
                break;
            case 'K': case 'k':
#ifndef PRISM_ENCODING_EXCLUDE_FULL
                ENCODING1("KOI8-R", PM_ENCODING_KOI8_R);
                ENCODING1("KOI8-U", PM_ENCODING_KOI8_U);
#endif
                break;
            case 'M': case 'm':
#ifndef PRISM_ENCODING_EXCLUDE_FULL
                ENCODING1("macCentEuro", PM_ENCODING_MAC_CENT_EURO);
                ENCODING1("macCroatian", PM_ENCODING_MAC_CROATIAN);
                ENCODING1("macCyrillic", PM_ENCODING_MAC_CYRILLIC);
                ENCODING1("macGreek", PM_ENCODING_MAC_GREEK);
                ENCODING1("macIceland", PM_ENCODING_MAC_ICELAND);
                ENCODING1("MacJapanese", PM_ENCODING_MAC_JAPANESE);
                ENCODING1("MacJapan", PM_ENCODING_MAC_JAPANESE);
                ENCODING1("macRoman", PM_ENCODING_MAC_ROMAN);
                ENCODING1("macRomania", PM_ENCODING_MAC_ROMANIA);
                ENCODING1("macThai", PM_ENCODING_MAC_THAI);
                ENCODING1("macTurkish", PM_ENCODING_MAC_TURKISH);
                ENCODING1("macUkraine", PM_ENCODING_MAC_UKRAINE);
#endif
                break;
            case 'P': case 'p':
                ENCODING1("PCK", PM_ENCODING_WINDOWS_31J);
                break;
            case 'S': case 's':
                ENCODING1("SJIS", PM_ENCODING_WINDOWS_31J);
#ifndef PRISM_ENCODING_EXCLUDE_FULL
                ENCODING1("Shift_JIS", PM_ENCODING_SHIFT_JIS);
                ENCODING1("SJIS-DoCoMo", PM_ENCODING_SJIS_DOCOMO);
                ENCODING1("SJIS-KDDI", PM_ENCODING_SJIS_KDDI);
                ENCODING1("SJIS-SoftBank", PM_ENCODING_SJIS_SOFTBANK);
                ENCODING1("stateless-ISO-2022-JP", PM_ENCODING_STATELESS_ISO_2022_JP);
                ENCODING1("stateless-ISO-2022-JP-KDDI", PM_ENCODING_STATELESS_ISO_2022_JP_KDDI);
#endif
                break;
            case 'T': case 't':
#ifndef PRISM_ENCODING_EXCLUDE_FULL
                ENCODING1("TIS-620", PM_ENCODING_TIS_620);
#endif
                break;
            case 'U': case 'u':
                ENCODING1("US-ASCII", PM_ENCODING_US_ASCII);
#ifndef PRISM_ENCODING_EXCLUDE_FULL
                ENCODING2("UTF8-MAC", "UTF-8-HFS", PM_ENCODING_UTF8_MAC);
                ENCODING1("UTF8-DoCoMo", PM_ENCODING_UTF8_DOCOMO);
                ENCODING1("UTF8-KDDI", PM_ENCODING_UTF8_KDDI);
                ENCODING1("UTF8-SoftBank", PM_ENCODING_UTF8_SOFTBANK);
#endif
                break;
            case 'W': case 'w':
                ENCODING1("Windows-31J", PM_ENCODING_WINDOWS_31J);
#ifndef PRISM_ENCODING_EXCLUDE_FULL
                ENCODING1("Windows-874", PM_ENCODING_WINDOWS_874);
                ENCODING1("Windows-1250", PM_ENCODING_WINDOWS_1250);
                ENCODING1("Windows-1251", PM_ENCODING_WINDOWS_1251);
                ENCODING1("Windows-1252", PM_ENCODING_WINDOWS_1252);
                ENCODING1("Windows-1253", PM_ENCODING_WINDOWS_1253);
                ENCODING1("Windows-1254", PM_ENCODING_WINDOWS_1254);
                ENCODING1("Windows-1255", PM_ENCODING_WINDOWS_1255);
                ENCODING1("Windows-1256", PM_ENCODING_WINDOWS_1256);
                ENCODING1("Windows-1257", PM_ENCODING_WINDOWS_1257);
                ENCODING1("Windows-1258", PM_ENCODING_WINDOWS_1258);
#endif
                break;
            case '6':
                ENCODING1("646", PM_ENCODING_US_ASCII);
                break;
        }
    }

#undef ENCODING2
#undef ENCODING1

    // If we didn't match any encodings, return NULL.
    return NULL;
}
prism-1.5.1/src/options.c000066400000000000000000000237131506127434000153060ustar00rootroot00000000000000#include "prism/options.h"

/**
 * Set the shebang callback option on the given options struct.
 */
PRISM_EXPORTED_FUNCTION void
pm_options_shebang_callback_set(pm_options_t *options, pm_options_shebang_callback_t shebang_callback, void *shebang_callback_data) {
    options->shebang_callback = shebang_callback;
    options->shebang_callback_data = shebang_callback_data;
}

/**
 * Set the filepath option on the given options struct.
 */
PRISM_EXPORTED_FUNCTION void
pm_options_filepath_set(pm_options_t *options, const char *filepath) {
    pm_string_constant_init(&options->filepath, filepath, strlen(filepath));
}

/**
 * Set the encoding option on the given options struct.
 */
PRISM_EXPORTED_FUNCTION void
pm_options_encoding_set(pm_options_t *options, const char *encoding) {
    pm_string_constant_init(&options->encoding, encoding, strlen(encoding));
}

/**
 * Set the encoding_locked option on the given options struct.
 */
PRISM_EXPORTED_FUNCTION void
pm_options_encoding_locked_set(pm_options_t *options, bool encoding_locked) {
    options->encoding_locked = encoding_locked;
}

/**
 * Set the line option on the given options struct.
 */
PRISM_EXPORTED_FUNCTION void
pm_options_line_set(pm_options_t *options, int32_t line) {
    options->line = line;
}

/**
 * Set the frozen string literal option on the given options struct.
 */
PRISM_EXPORTED_FUNCTION void
pm_options_frozen_string_literal_set(pm_options_t *options, bool frozen_string_literal) {
    options->frozen_string_literal = frozen_string_literal ? PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED : PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED;
}

/**
 * Sets the command line option on the given options struct.
 */
PRISM_EXPORTED_FUNCTION void
pm_options_command_line_set(pm_options_t *options, uint8_t command_line) {
    options->command_line = command_line;
}

/**
 * Checks if the given slice represents a number.
 */
static inline bool
is_number(const char *string, size_t length) {
    return pm_strspn_decimal_digit((const uint8_t *) string, (ptrdiff_t) length) == length;
}

/**
 * Set the version option on the given options struct by parsing the given
 * string. If the string contains an invalid option, this returns false.
 * Otherwise, it returns true.
 */
PRISM_EXPORTED_FUNCTION bool
pm_options_version_set(pm_options_t *options, const char *version, size_t length) {
    if (version == NULL) {
        options->version = PM_OPTIONS_VERSION_LATEST;
        return true;
    }

    if (length == 3) {
        if (strncmp(version, "3.3", 3) == 0) {
            options->version = PM_OPTIONS_VERSION_CRUBY_3_3;
            return true;
        }

        if (strncmp(version, "3.4", 3) == 0) {
            options->version = PM_OPTIONS_VERSION_CRUBY_3_4;
            return true;
        }

        if (strncmp(version, "3.5", 3) == 0) {
            options->version = PM_OPTIONS_VERSION_CRUBY_3_5;
            return true;
        }

        return false;
    }

    if (length >= 4) {
        if (strncmp(version, "3.3.", 4) == 0 && is_number(version + 4, length - 4)) {
            options->version = PM_OPTIONS_VERSION_CRUBY_3_3;
            return true;
        }

        if (strncmp(version, "3.4.", 4) == 0 && is_number(version + 4, length - 4)) {
            options->version = PM_OPTIONS_VERSION_CRUBY_3_4;
            return true;
        }

        if (strncmp(version, "3.5.", 4) == 0 && is_number(version + 4, length - 4)) {
            options->version = PM_OPTIONS_VERSION_CRUBY_3_5;
            return true;
        }
    }

    if (length >= 6) {
        if (strncmp(version, "latest", 7) == 0) { // 7 to compare the \0 as well
            options->version = PM_OPTIONS_VERSION_LATEST;
            return true;
        }
    }

    return false;
}

/**
 * Set the main script option on the given options struct.
 */
PRISM_EXPORTED_FUNCTION void
pm_options_main_script_set(pm_options_t *options, bool main_script) {
    options->main_script = main_script;
}

/**
 * Set the partial script option on the given options struct.
 */
PRISM_EXPORTED_FUNCTION void
pm_options_partial_script_set(pm_options_t *options, bool partial_script) {
    options->partial_script = partial_script;
}

/**
 * Set the freeze option on the given options struct.
 */
PRISM_EXPORTED_FUNCTION void
pm_options_freeze_set(pm_options_t *options, bool freeze) {
    options->freeze = freeze;
}

// For some reason, GCC analyzer thinks we're leaking allocated scopes and
// locals here, even though we definitely aren't. This is a false positive.
// Ideally we wouldn't need to suppress this.
#if defined(__GNUC__) && (__GNUC__ >= 10)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wanalyzer-malloc-leak"
#endif

/**
 * Allocate and zero out the scopes array on the given options struct.
 */
PRISM_EXPORTED_FUNCTION bool
pm_options_scopes_init(pm_options_t *options, size_t scopes_count) {
    options->scopes_count = scopes_count;
    options->scopes = xcalloc(scopes_count, sizeof(pm_options_scope_t));
    return options->scopes != NULL;
}

/**
 * Return a pointer to the scope at the given index within the given options.
 */
PRISM_EXPORTED_FUNCTION const pm_options_scope_t *
pm_options_scope_get(const pm_options_t *options, size_t index) {
    return &options->scopes[index];
}

/**
 * Create a new options scope struct. This will hold a set of locals that are in
 * scope surrounding the code that is being parsed.
 */
PRISM_EXPORTED_FUNCTION bool
pm_options_scope_init(pm_options_scope_t *scope, size_t locals_count) {
    scope->locals_count = locals_count;
    scope->locals = xcalloc(locals_count, sizeof(pm_string_t));
    scope->forwarding = PM_OPTIONS_SCOPE_FORWARDING_NONE;
    return scope->locals != NULL;
}

/**
 * Return a pointer to the local at the given index within the given scope.
 */
PRISM_EXPORTED_FUNCTION const pm_string_t *
pm_options_scope_local_get(const pm_options_scope_t *scope, size_t index) {
    return &scope->locals[index];
}

/**
 * Set the forwarding option on the given scope struct.
 */
PRISM_EXPORTED_FUNCTION void
pm_options_scope_forwarding_set(pm_options_scope_t *scope, uint8_t forwarding) {
    scope->forwarding = forwarding;
}

/**
 * Free the internal memory associated with the options.
 */
PRISM_EXPORTED_FUNCTION void
pm_options_free(pm_options_t *options) {
    pm_string_free(&options->filepath);
    pm_string_free(&options->encoding);

    for (size_t scope_index = 0; scope_index < options->scopes_count; scope_index++) {
        pm_options_scope_t *scope = &options->scopes[scope_index];

        for (size_t local_index = 0; local_index < scope->locals_count; local_index++) {
            pm_string_free(&scope->locals[local_index]);
        }

        xfree(scope->locals);
    }

    xfree(options->scopes);
}

/**
 * Read a 32-bit unsigned integer from a pointer. This function is used to read
 * the options that are passed into the parser from the Ruby implementation. It
 * handles aligned and unaligned reads.
 */
static uint32_t
pm_options_read_u32(const char *data) {
    if (((uintptr_t) data) % sizeof(uint32_t) == 0) {
        return *((uint32_t *) data);
    } else {
        uint32_t value;
        memcpy(&value, data, sizeof(uint32_t));
        return value;
    }
}

/**
 * Read a 32-bit signed integer from a pointer. This function is used to read
 * the options that are passed into the parser from the Ruby implementation. It
 * handles aligned and unaligned reads.
 */
static int32_t
pm_options_read_s32(const char *data) {
    if (((uintptr_t) data) % sizeof(int32_t) == 0) {
        return *((int32_t *) data);
    } else {
        int32_t value;
        memcpy(&value, data, sizeof(int32_t));
        return value;
    }
}

/**
 * Deserialize an options struct from the given binary string. This is used to
 * pass options to the parser from an FFI call so that consumers of the library
 * from an FFI perspective don't have to worry about the structure of our
 * options structs. Since the source of these calls will be from Ruby
 * implementation internals we assume it is from a trusted source.
 */
void
pm_options_read(pm_options_t *options, const char *data) {
    options->line = 1; // default
    if (data == NULL) return;

    uint32_t filepath_length = pm_options_read_u32(data);
    data += 4;

    if (filepath_length > 0) {
        pm_string_constant_init(&options->filepath, data, filepath_length);
        data += filepath_length;
    }

    options->line = pm_options_read_s32(data);
    data += 4;

    uint32_t encoding_length = pm_options_read_u32(data);
    data += 4;

    if (encoding_length > 0) {
        pm_string_constant_init(&options->encoding, data, encoding_length);
        data += encoding_length;
    }

    options->frozen_string_literal = (int8_t) *data++;
    options->command_line = (uint8_t) *data++;
    options->version = (pm_options_version_t) *data++;
    options->encoding_locked = ((uint8_t) *data++) > 0;
    options->main_script = ((uint8_t) *data++) > 0;
    options->partial_script = ((uint8_t) *data++) > 0;
    options->freeze = ((uint8_t) *data++) > 0;

    uint32_t scopes_count = pm_options_read_u32(data);
    data += 4;

    if (scopes_count > 0) {
        if (!pm_options_scopes_init(options, scopes_count)) return;

        for (size_t scope_index = 0; scope_index < scopes_count; scope_index++) {
            uint32_t locals_count = pm_options_read_u32(data);
            data += 4;

            pm_options_scope_t *scope = &options->scopes[scope_index];
            if (!pm_options_scope_init(scope, locals_count)) {
                pm_options_free(options);
                return;
            }

            uint8_t forwarding = (uint8_t) *data++;
            pm_options_scope_forwarding_set(&options->scopes[scope_index], forwarding);

            for (size_t local_index = 0; local_index < locals_count; local_index++) {
                uint32_t local_length = pm_options_read_u32(data);
                data += 4;

                pm_string_constant_init(&scope->locals[local_index], data, local_length);
                data += local_length;
            }
        }
    }
}

#if defined(__GNUC__) && (__GNUC__ >= 10)
#pragma GCC diagnostic pop
#endif
prism-1.5.1/src/pack.c000066400000000000000000000375621506127434000145400ustar00rootroot00000000000000#include "prism/pack.h"

// We optionally support parsing String#pack templates. For systems that don't
// want or need this functionality, it can be turned off with the
// PRISM_EXCLUDE_PACK define.
#ifdef PRISM_EXCLUDE_PACK

void pm_pack_parse(void) {}

#else

#include 
#include 

static uintmax_t
strtoumaxc(const char **format) {
    uintmax_t value = 0;
    while (**format >= '0' && **format <= '9') {
        if (value > UINTMAX_MAX / 10) {
            errno = ERANGE;
        }
        value = value * 10 + ((uintmax_t) (**format - '0'));
        (*format)++;
    }
    return value;
}

PRISM_EXPORTED_FUNCTION pm_pack_result
pm_pack_parse(
    pm_pack_variant variant,
    const char **format,
    const char *format_end,
    pm_pack_type *type,
    pm_pack_signed *signed_type,
    pm_pack_endian *endian,
    pm_pack_size *size,
    pm_pack_length_type *length_type,
    uint64_t *length,
    pm_pack_encoding *encoding
) {
    if (*encoding == PM_PACK_ENCODING_START) {
        *encoding = PM_PACK_ENCODING_US_ASCII;
    }

    if (*format == format_end) {
            *type = PM_PACK_END;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            *length_type = PM_PACK_LENGTH_NA;
            return PM_PACK_OK;
    }

    *length_type = PM_PACK_LENGTH_FIXED;
    *length = 1;
    bool length_changed_allowed = true;

    char directive = **format;
    (*format)++;
    switch (directive) {
        case ' ':
        case '\t':
        case '\n':
        case '\v':
        case '\f':
        case '\r':
            *type = PM_PACK_SPACE;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            *length_type = PM_PACK_LENGTH_NA;
            *length = 0;
            return PM_PACK_OK;
        case '#':
            while ((*format < format_end) && (**format != '\n')) {
                (*format)++;
            }
            *type = PM_PACK_COMMENT;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            *length_type = PM_PACK_LENGTH_NA;
            *length = 0;
            return PM_PACK_OK;
        case 'C':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_UNSIGNED;
            *endian = PM_PACK_AGNOSTIC_ENDIAN;
            *size = PM_PACK_SIZE_8;
            break;
        case 'S':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_UNSIGNED;
            *endian = PM_PACK_NATIVE_ENDIAN;
            *size = PM_PACK_SIZE_16;
            break;
        case 'L':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_UNSIGNED;
            *endian = PM_PACK_NATIVE_ENDIAN;
            *size = PM_PACK_SIZE_32;
            break;
        case 'Q':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_UNSIGNED;
            *endian = PM_PACK_NATIVE_ENDIAN;
            *size = PM_PACK_SIZE_64;
            break;
        case 'J':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_UNSIGNED;
            *endian = PM_PACK_NATIVE_ENDIAN;
            *size = PM_PACK_SIZE_P;
            break;
        case 'c':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_SIGNED;
            *endian = PM_PACK_AGNOSTIC_ENDIAN;
            *size = PM_PACK_SIZE_8;
            break;
        case 's':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_SIGNED;
            *endian = PM_PACK_NATIVE_ENDIAN;
            *size = PM_PACK_SIZE_16;
            break;
        case 'l':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_SIGNED;
            *endian = PM_PACK_NATIVE_ENDIAN;
            *size = PM_PACK_SIZE_32;
            break;
        case 'q':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_SIGNED;
            *endian = PM_PACK_NATIVE_ENDIAN;
            *size = PM_PACK_SIZE_64;
            break;
        case 'j':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_SIGNED;
            *endian = PM_PACK_NATIVE_ENDIAN;
            *size = PM_PACK_SIZE_P;
            break;
        case 'I':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_UNSIGNED;
            *endian = PM_PACK_NATIVE_ENDIAN;
            *size = PM_PACK_SIZE_INT;
            break;
        case 'i':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_SIGNED;
            *endian = PM_PACK_NATIVE_ENDIAN;
            *size = PM_PACK_SIZE_INT;
            break;
        case 'n':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_UNSIGNED;
            *endian = PM_PACK_BIG_ENDIAN;
            *size = PM_PACK_SIZE_16;
            length_changed_allowed = false;
            break;
        case 'N':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_UNSIGNED;
            *endian = PM_PACK_BIG_ENDIAN;
            *size = PM_PACK_SIZE_32;
            length_changed_allowed = false;
            break;
        case 'v':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_UNSIGNED;
            *endian = PM_PACK_LITTLE_ENDIAN;
            *size = PM_PACK_SIZE_16;
            length_changed_allowed = false;
            break;
        case 'V':
            *type = PM_PACK_INTEGER;
            *signed_type = PM_PACK_UNSIGNED;
            *endian = PM_PACK_LITTLE_ENDIAN;
            *size = PM_PACK_SIZE_32;
            length_changed_allowed = false;
            break;
        case 'U':
            *type = PM_PACK_UTF8;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'w':
            *type = PM_PACK_BER;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'D':
        case 'd':
            *type = PM_PACK_FLOAT;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_NATIVE_ENDIAN;
            *size = PM_PACK_SIZE_64;
            break;
        case 'F':
        case 'f':
            *type = PM_PACK_FLOAT;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_NATIVE_ENDIAN;
            *size = PM_PACK_SIZE_32;
            break;
        case 'E':
            *type = PM_PACK_FLOAT;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_LITTLE_ENDIAN;
            *size = PM_PACK_SIZE_64;
            break;
        case 'e':
            *type = PM_PACK_FLOAT;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_LITTLE_ENDIAN;
            *size = PM_PACK_SIZE_32;
            break;
        case 'G':
            *type = PM_PACK_FLOAT;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_BIG_ENDIAN;
            *size = PM_PACK_SIZE_64;
            break;
        case 'g':
            *type = PM_PACK_FLOAT;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_BIG_ENDIAN;
            *size = PM_PACK_SIZE_32;
            break;
        case 'A':
            *type = PM_PACK_STRING_SPACE_PADDED;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'a':
            *type = PM_PACK_STRING_NULL_PADDED;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'Z':
            *type = PM_PACK_STRING_NULL_TERMINATED;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'B':
            *type = PM_PACK_STRING_MSB;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'b':
            *type = PM_PACK_STRING_LSB;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'H':
            *type = PM_PACK_STRING_HEX_HIGH;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'h':
            *type = PM_PACK_STRING_HEX_LOW;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'u':
            *type = PM_PACK_STRING_UU;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'M':
            *type = PM_PACK_STRING_MIME;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'm':
            *type = PM_PACK_STRING_BASE64;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'P':
            *type = PM_PACK_STRING_FIXED;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'p':
            *type = PM_PACK_STRING_POINTER;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case '@':
            *type = PM_PACK_MOVE;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'X':
            *type = PM_PACK_BACK;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case 'x':
            *type = PM_PACK_NULL;
            *signed_type = PM_PACK_SIGNED_NA;
            *endian = PM_PACK_ENDIAN_NA;
            *size = PM_PACK_SIZE_NA;
            break;
        case '%':
            return PM_PACK_ERROR_UNSUPPORTED_DIRECTIVE;
        default:
            return PM_PACK_ERROR_UNKNOWN_DIRECTIVE;
    }

    bool explicit_endian = false;

    while (*format < format_end) {
        switch (**format) {
            case '_':
            case '!':
                (*format)++;
                if (*type != PM_PACK_INTEGER || !length_changed_allowed) {
                    return PM_PACK_ERROR_BANG_NOT_ALLOWED;
                }
                switch (*size) {
                    case PM_PACK_SIZE_SHORT:
                    case PM_PACK_SIZE_INT:
                    case PM_PACK_SIZE_LONG:
                    case PM_PACK_SIZE_LONG_LONG:
                        break;
                    case PM_PACK_SIZE_16:
                        *size = PM_PACK_SIZE_SHORT;
                        break;
                    case PM_PACK_SIZE_32:
                        *size = PM_PACK_SIZE_LONG;
                        break;
                    case PM_PACK_SIZE_64:
                        *size = PM_PACK_SIZE_LONG_LONG;
                        break;
                    case PM_PACK_SIZE_P:
                        break;
                    default:
                        return PM_PACK_ERROR_BANG_NOT_ALLOWED;
                }
                break;
            case '<':
                (*format)++;
                if (explicit_endian) {
                    return PM_PACK_ERROR_DOUBLE_ENDIAN;
                }
                *endian = PM_PACK_LITTLE_ENDIAN;
                explicit_endian = true;
                break;
            case '>':
                (*format)++;
                if (explicit_endian) {
                    return PM_PACK_ERROR_DOUBLE_ENDIAN;
                }
                *endian = PM_PACK_BIG_ENDIAN;
                explicit_endian = true;
                break;
            default:
                goto exit_modifier_loop;
        }
    }

exit_modifier_loop:

    if (variant == PM_PACK_VARIANT_UNPACK && *type == PM_PACK_MOVE) {
        *length = 0;
    }

    if (*format < format_end) {
        if (**format == '*') {
            switch (*type) {
                case PM_PACK_NULL:
                case PM_PACK_BACK:
                    switch (variant) {
                        case PM_PACK_VARIANT_PACK:
                            *length_type = PM_PACK_LENGTH_FIXED;
                            break;
                        case PM_PACK_VARIANT_UNPACK:
                            *length_type = PM_PACK_LENGTH_MAX;
                            break;
                    }
                    *length = 0;
                    break;

                case PM_PACK_MOVE:
                    switch (variant) {
                        case PM_PACK_VARIANT_PACK:
                            *length_type = PM_PACK_LENGTH_FIXED;
                            break;
                        case PM_PACK_VARIANT_UNPACK:
                            *length_type = PM_PACK_LENGTH_RELATIVE;
                            break;
                    }
                    *length = 0;
                    break;

                case PM_PACK_STRING_UU:
                    *length_type = PM_PACK_LENGTH_FIXED;
                    *length = 0;
                    break;

                case PM_PACK_STRING_FIXED:
                    switch (variant) {
                        case PM_PACK_VARIANT_PACK:
                            *length_type = PM_PACK_LENGTH_FIXED;
                            *length = 1;
                            break;
                        case PM_PACK_VARIANT_UNPACK:
                            *length_type = PM_PACK_LENGTH_MAX;
                            *length = 0;
                            break;
                    }
                    break;

                case PM_PACK_STRING_MIME:
                case PM_PACK_STRING_BASE64:
                    *length_type = PM_PACK_LENGTH_FIXED;
                    *length = 1;
                    break;

                default:
                    *length_type = PM_PACK_LENGTH_MAX;
                    *length = 0;
                    break;
            }

            (*format)++;
        } else if (**format >= '0' && **format <= '9') {
            errno = 0;
            *length_type = PM_PACK_LENGTH_FIXED;
            #if UINTMAX_MAX < UINT64_MAX
                #error "prism's design assumes uintmax_t is at least as large as uint64_t"
            #endif
            uintmax_t length_max = strtoumaxc(format);
            if (errno || length_max > UINT64_MAX) {
                return PM_PACK_ERROR_LENGTH_TOO_BIG;
            }
            *length = (uint64_t) length_max;
        }
    }

    switch (*type) {
        case PM_PACK_UTF8:
            /* if encoding is US-ASCII, upgrade to UTF-8 */
            if (*encoding == PM_PACK_ENCODING_US_ASCII) {
                *encoding = PM_PACK_ENCODING_UTF_8;
            }
            break;
        case PM_PACK_STRING_MIME:
        case PM_PACK_STRING_BASE64:
        case PM_PACK_STRING_UU:
            /* keep US-ASCII (do nothing) */
            break;
        default:
            /* fall back to BINARY */
            *encoding = PM_PACK_ENCODING_ASCII_8BIT;
            break;
    }

    return PM_PACK_OK;
}

PRISM_EXPORTED_FUNCTION size_t
pm_size_to_native(pm_pack_size size) {
    switch (size) {
        case PM_PACK_SIZE_SHORT:
            return sizeof(short);
        case PM_PACK_SIZE_INT:
            return sizeof(int);
        case PM_PACK_SIZE_LONG:
            return sizeof(long);
        case PM_PACK_SIZE_LONG_LONG:
            return sizeof(long long);
        case PM_PACK_SIZE_8:
            return 1;
        case PM_PACK_SIZE_16:
            return 2;
        case PM_PACK_SIZE_32:
            return 4;
        case PM_PACK_SIZE_64:
            return 8;
        case PM_PACK_SIZE_P:
            return sizeof(void *);
        default:
            return 0;
    }
}

#endif
prism-1.5.1/src/prism.c000066400000000000000000036227161506127434000147600ustar00rootroot00000000000000#include "prism.h"

/**
 * The prism version and the serialization format.
 */
const char *
pm_version(void) {
    return PRISM_VERSION;
}

/**
 * In heredocs, tabs automatically complete up to the next 8 spaces. This is
 * defined in CRuby as TAB_WIDTH.
 */
#define PM_TAB_WHITESPACE_SIZE 8

// Macros for min/max.
#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))

/******************************************************************************/
/* Lex mode manipulations                                                     */
/******************************************************************************/

/**
 * Returns the incrementor character that should be used to increment the
 * nesting count if one is possible.
 */
static inline uint8_t
lex_mode_incrementor(const uint8_t start) {
    switch (start) {
        case '(':
        case '[':
        case '{':
        case '<':
            return start;
        default:
            return '\0';
    }
}

/**
 * Returns the matching character that should be used to terminate a list
 * beginning with the given character.
 */
static inline uint8_t
lex_mode_terminator(const uint8_t start) {
    switch (start) {
        case '(':
            return ')';
        case '[':
            return ']';
        case '{':
            return '}';
        case '<':
            return '>';
        default:
            return start;
    }
}

/**
 * Push a new lex state onto the stack. If we're still within the pre-allocated
 * space of the lex state stack, then we'll just use a new slot. Otherwise we'll
 * allocate a new pointer and use that.
 */
static bool
lex_mode_push(pm_parser_t *parser, pm_lex_mode_t lex_mode) {
    lex_mode.prev = parser->lex_modes.current;
    parser->lex_modes.index++;

    if (parser->lex_modes.index > PM_LEX_STACK_SIZE - 1) {
        parser->lex_modes.current = (pm_lex_mode_t *) xmalloc(sizeof(pm_lex_mode_t));
        if (parser->lex_modes.current == NULL) return false;

        *parser->lex_modes.current = lex_mode;
    } else {
        parser->lex_modes.stack[parser->lex_modes.index] = lex_mode;
        parser->lex_modes.current = &parser->lex_modes.stack[parser->lex_modes.index];
    }

    return true;
}

/**
 * Push on a new list lex mode.
 */
static inline bool
lex_mode_push_list(pm_parser_t *parser, bool interpolation, uint8_t delimiter) {
    uint8_t incrementor = lex_mode_incrementor(delimiter);
    uint8_t terminator = lex_mode_terminator(delimiter);

    pm_lex_mode_t lex_mode = {
        .mode = PM_LEX_LIST,
        .as.list = {
            .nesting = 0,
            .interpolation = interpolation,
            .incrementor = incrementor,
            .terminator = terminator
        }
    };

    // These are the places where we need to split up the content of the list.
    // We'll use strpbrk to find the first of these characters.
    uint8_t *breakpoints = lex_mode.as.list.breakpoints;
    memcpy(breakpoints, "\\ \t\f\r\v\n\0\0\0", sizeof(lex_mode.as.list.breakpoints));
    size_t index = 7;

    // Now we'll add the terminator to the list of breakpoints. If the
    // terminator is not already a NULL byte, add it to the list.
    if (terminator != '\0') {
        breakpoints[index++] = terminator;
    }

    // If interpolation is allowed, then we're going to check for the #
    // character. Otherwise we'll only look for escapes and the terminator.
    if (interpolation) {
        breakpoints[index++] = '#';
    }

    // If there is an incrementor, then we'll check for that as well.
    if (incrementor != '\0') {
        breakpoints[index++] = incrementor;
    }

    parser->explicit_encoding = NULL;
    return lex_mode_push(parser, lex_mode);
}

/**
 * Push on a new list lex mode that is only used for compatibility. This is
 * called when we're at the end of the file. We want the parser to be able to
 * perform its normal error tolerance.
 */
static inline bool
lex_mode_push_list_eof(pm_parser_t *parser) {
    return lex_mode_push_list(parser, false, '\0');
}

/**
 * Push on a new regexp lex mode.
 */
static inline bool
lex_mode_push_regexp(pm_parser_t *parser, uint8_t incrementor, uint8_t terminator) {
    pm_lex_mode_t lex_mode = {
        .mode = PM_LEX_REGEXP,
        .as.regexp = {
            .nesting = 0,
            .incrementor = incrementor,
            .terminator = terminator
        }
    };

    // These are the places where we need to split up the content of the
    // regular expression. We'll use strpbrk to find the first of these
    // characters.
    uint8_t *breakpoints = lex_mode.as.regexp.breakpoints;
    memcpy(breakpoints, "\r\n\\#\0\0", sizeof(lex_mode.as.regexp.breakpoints));
    size_t index = 4;

    // First we'll add the terminator.
    if (terminator != '\0') {
        breakpoints[index++] = terminator;
    }

    // Next, if there is an incrementor, then we'll check for that as well.
    if (incrementor != '\0') {
        breakpoints[index++] = incrementor;
    }

    parser->explicit_encoding = NULL;
    return lex_mode_push(parser, lex_mode);
}

/**
 * Push on a new string lex mode.
 */
static inline bool
lex_mode_push_string(pm_parser_t *parser, bool interpolation, bool label_allowed, uint8_t incrementor, uint8_t terminator) {
    pm_lex_mode_t lex_mode = {
        .mode = PM_LEX_STRING,
        .as.string = {
            .nesting = 0,
            .interpolation = interpolation,
            .label_allowed = label_allowed,
            .incrementor = incrementor,
            .terminator = terminator
        }
    };

    // These are the places where we need to split up the content of the
    // string. We'll use strpbrk to find the first of these characters.
    uint8_t *breakpoints = lex_mode.as.string.breakpoints;
    memcpy(breakpoints, "\r\n\\\0\0\0", sizeof(lex_mode.as.string.breakpoints));
    size_t index = 3;

    // Now add in the terminator. If the terminator is not already a NULL byte,
    // then we'll add it.
    if (terminator != '\0') {
        breakpoints[index++] = terminator;
    }

    // If interpolation is allowed, then we're going to check for the #
    // character. Otherwise we'll only look for escapes and the terminator.
    if (interpolation) {
        breakpoints[index++] = '#';
    }

    // If we have an incrementor, then we'll add that in as a breakpoint as
    // well.
    if (incrementor != '\0') {
        breakpoints[index++] = incrementor;
    }

    parser->explicit_encoding = NULL;
    return lex_mode_push(parser, lex_mode);
}

/**
 * Push on a new string lex mode that is only used for compatibility. This is
 * called when we're at the end of the file. We want the parser to be able to
 * perform its normal error tolerance.
 */
static inline bool
lex_mode_push_string_eof(pm_parser_t *parser) {
    return lex_mode_push_string(parser, false, false, '\0', '\0');
}

/**
 * Pop the current lex state off the stack. If we're within the pre-allocated
 * space of the lex state stack, then we'll just decrement the index. Otherwise
 * we'll free the current pointer and use the previous pointer.
 */
static void
lex_mode_pop(pm_parser_t *parser) {
    if (parser->lex_modes.index == 0) {
        parser->lex_modes.current->mode = PM_LEX_DEFAULT;
    } else if (parser->lex_modes.index < PM_LEX_STACK_SIZE) {
        parser->lex_modes.index--;
        parser->lex_modes.current = &parser->lex_modes.stack[parser->lex_modes.index];
    } else {
        parser->lex_modes.index--;
        pm_lex_mode_t *prev = parser->lex_modes.current->prev;
        xfree(parser->lex_modes.current);
        parser->lex_modes.current = prev;
    }
}

/**
 * This is the equivalent of IS_lex_state is CRuby.
 */
static inline bool
lex_state_p(const pm_parser_t *parser, pm_lex_state_t state) {
    return parser->lex_state & state;
}

typedef enum {
    PM_IGNORED_NEWLINE_NONE = 0,
    PM_IGNORED_NEWLINE_ALL,
    PM_IGNORED_NEWLINE_PATTERN
} pm_ignored_newline_type_t;

static inline pm_ignored_newline_type_t
lex_state_ignored_p(pm_parser_t *parser) {
    bool ignored = lex_state_p(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_CLASS | PM_LEX_STATE_FNAME | PM_LEX_STATE_DOT) && !lex_state_p(parser, PM_LEX_STATE_LABELED);

    if (ignored) {
        return PM_IGNORED_NEWLINE_ALL;
    } else if ((parser->lex_state & ~((unsigned int) PM_LEX_STATE_LABEL)) == (PM_LEX_STATE_ARG | PM_LEX_STATE_LABELED)) {
        return PM_IGNORED_NEWLINE_PATTERN;
    } else {
        return PM_IGNORED_NEWLINE_NONE;
    }
}

static inline bool
lex_state_beg_p(pm_parser_t *parser) {
    return lex_state_p(parser, PM_LEX_STATE_BEG_ANY) || ((parser->lex_state & (PM_LEX_STATE_ARG | PM_LEX_STATE_LABELED)) == (PM_LEX_STATE_ARG | PM_LEX_STATE_LABELED));
}

static inline bool
lex_state_arg_p(pm_parser_t *parser) {
    return lex_state_p(parser, PM_LEX_STATE_ARG_ANY);
}

static inline bool
lex_state_spcarg_p(pm_parser_t *parser, bool space_seen) {
    if (parser->current.end >= parser->end) {
        return false;
    }
    return lex_state_arg_p(parser) && space_seen && !pm_char_is_whitespace(*parser->current.end);
}

static inline bool
lex_state_end_p(pm_parser_t *parser) {
    return lex_state_p(parser, PM_LEX_STATE_END_ANY);
}

/**
 * This is the equivalent of IS_AFTER_OPERATOR in CRuby.
 */
static inline bool
lex_state_operator_p(pm_parser_t *parser) {
    return lex_state_p(parser, PM_LEX_STATE_FNAME | PM_LEX_STATE_DOT);
}

/**
 * Set the state of the lexer. This is defined as a function to be able to put a
 * breakpoint in it.
 */
static inline void
lex_state_set(pm_parser_t *parser, pm_lex_state_t state) {
    parser->lex_state = state;
}

#ifndef PM_DEBUG_LOGGING
/**
 * Debugging logging will print additional information to stdout whenever the
 * lexer state changes.
 */
#define PM_DEBUG_LOGGING 0
#endif

#if PM_DEBUG_LOGGING
PRISM_ATTRIBUTE_UNUSED static void
debug_state(pm_parser_t *parser) {
    fprintf(stderr, "STATE: ");
    bool first = true;

    if (parser->lex_state == PM_LEX_STATE_NONE) {
        fprintf(stderr, "NONE\n");
        return;
    }

#define CHECK_STATE(state) \
    if (parser->lex_state & state) { \
        if (!first) fprintf(stderr, "|"); \
        fprintf(stderr, "%s", #state); \
        first = false; \
    }

    CHECK_STATE(PM_LEX_STATE_BEG)
    CHECK_STATE(PM_LEX_STATE_END)
    CHECK_STATE(PM_LEX_STATE_ENDARG)
    CHECK_STATE(PM_LEX_STATE_ENDFN)
    CHECK_STATE(PM_LEX_STATE_ARG)
    CHECK_STATE(PM_LEX_STATE_CMDARG)
    CHECK_STATE(PM_LEX_STATE_MID)
    CHECK_STATE(PM_LEX_STATE_FNAME)
    CHECK_STATE(PM_LEX_STATE_DOT)
    CHECK_STATE(PM_LEX_STATE_CLASS)
    CHECK_STATE(PM_LEX_STATE_LABEL)
    CHECK_STATE(PM_LEX_STATE_LABELED)
    CHECK_STATE(PM_LEX_STATE_FITEM)

#undef CHECK_STATE

    fprintf(stderr, "\n");
}

static void
debug_lex_state_set(pm_parser_t *parser, pm_lex_state_t state, char const * caller_name, int line_number) {
    fprintf(stderr, "Caller: %s:%d\nPrevious: ", caller_name, line_number);
    debug_state(parser);
    lex_state_set(parser, state);
    fprintf(stderr, "Now: ");
    debug_state(parser);
    fprintf(stderr, "\n");
}

#define lex_state_set(parser, state) debug_lex_state_set(parser, state, __func__, __LINE__)
#endif

/******************************************************************************/
/* Command-line macro helpers                                                 */
/******************************************************************************/

/** True if the parser has the given command-line option. */
#define PM_PARSER_COMMAND_LINE_OPTION(parser, option) ((parser)->command_line & (option))

/** True if the -a command line option was given. */
#define PM_PARSER_COMMAND_LINE_OPTION_A(parser) PM_PARSER_COMMAND_LINE_OPTION(parser, PM_OPTIONS_COMMAND_LINE_A)

/** True if the -e command line option was given. */
#define PM_PARSER_COMMAND_LINE_OPTION_E(parser) PM_PARSER_COMMAND_LINE_OPTION(parser, PM_OPTIONS_COMMAND_LINE_E)

/** True if the -l command line option was given. */
#define PM_PARSER_COMMAND_LINE_OPTION_L(parser) PM_PARSER_COMMAND_LINE_OPTION(parser, PM_OPTIONS_COMMAND_LINE_L)

/** True if the -n command line option was given. */
#define PM_PARSER_COMMAND_LINE_OPTION_N(parser) PM_PARSER_COMMAND_LINE_OPTION(parser, PM_OPTIONS_COMMAND_LINE_N)

/** True if the -p command line option was given. */
#define PM_PARSER_COMMAND_LINE_OPTION_P(parser) PM_PARSER_COMMAND_LINE_OPTION(parser, PM_OPTIONS_COMMAND_LINE_P)

/** True if the -x command line option was given. */
#define PM_PARSER_COMMAND_LINE_OPTION_X(parser) PM_PARSER_COMMAND_LINE_OPTION(parser, PM_OPTIONS_COMMAND_LINE_X)

/******************************************************************************/
/* Diagnostic-related functions                                               */
/******************************************************************************/

/**
 * Append an error to the list of errors on the parser.
 */
static inline void
pm_parser_err(pm_parser_t *parser, const uint8_t *start, const uint8_t *end, pm_diagnostic_id_t diag_id) {
    pm_diagnostic_list_append(&parser->error_list, start, end, diag_id);
}

/**
 * Append an error to the list of errors on the parser using a format string.
 */
#define PM_PARSER_ERR_FORMAT(parser, start, end, diag_id, ...) \
    pm_diagnostic_list_append_format(&parser->error_list, start, end, diag_id, __VA_ARGS__)

/**
 * Append an error to the list of errors on the parser using the location of the
 * current token.
 */
static inline void
pm_parser_err_current(pm_parser_t *parser, pm_diagnostic_id_t diag_id) {
    pm_parser_err(parser, parser->current.start, parser->current.end, diag_id);
}

/**
 * Append an error to the list of errors on the parser using the given location
 * using a format string.
 */
#define PM_PARSER_ERR_LOCATION_FORMAT(parser, location, diag_id, ...) \
    PM_PARSER_ERR_FORMAT(parser, (location)->start, (location)->end, diag_id, __VA_ARGS__)

/**
 * Append an error to the list of errors on the parser using the location of the
 * given node.
 */
static inline void
pm_parser_err_node(pm_parser_t *parser, const pm_node_t *node, pm_diagnostic_id_t diag_id) {
    pm_parser_err(parser, node->location.start, node->location.end, diag_id);
}

/**
 * Append an error to the list of errors on the parser using the location of the
 * given node and a format string.
 */
#define PM_PARSER_ERR_NODE_FORMAT(parser, node, diag_id, ...) \
    PM_PARSER_ERR_FORMAT(parser, (node)->location.start, (node)->location.end, diag_id, __VA_ARGS__)

/**
 * Append an error to the list of errors on the parser using the location of the
 * given node and a format string, and add on the content of the node.
 */
#define PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, node, diag_id) \
    PM_PARSER_ERR_NODE_FORMAT(parser, node, diag_id, (int) ((node)->location.end - (node)->location.start), (const char *) (node)->location.start)

/**
 * Append an error to the list of errors on the parser using the location of the
 * previous token.
 */
static inline void
pm_parser_err_previous(pm_parser_t *parser, pm_diagnostic_id_t diag_id) {
    pm_parser_err(parser, parser->previous.start, parser->previous.end, diag_id);
}

/**
 * Append an error to the list of errors on the parser using the location of the
 * given token.
 */
static inline void
pm_parser_err_token(pm_parser_t *parser, const pm_token_t *token, pm_diagnostic_id_t diag_id) {
    pm_parser_err(parser, token->start, token->end, diag_id);
}

/**
 * Append an error to the list of errors on the parser using the location of the
 * given token and a format string.
 */
#define PM_PARSER_ERR_TOKEN_FORMAT(parser, token, diag_id, ...) \
    PM_PARSER_ERR_FORMAT(parser, (token).start, (token).end, diag_id, __VA_ARGS__)

/**
 * Append an error to the list of errors on the parser using the location of the
 * given token and a format string, and add on the content of the token.
 */
#define PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, token, diag_id) \
    PM_PARSER_ERR_TOKEN_FORMAT(parser, token, diag_id, (int) ((token).end - (token).start), (const char *) (token).start)

/**
 * Append a warning to the list of warnings on the parser.
 */
static inline void
pm_parser_warn(pm_parser_t *parser, const uint8_t *start, const uint8_t *end, pm_diagnostic_id_t diag_id) {
    pm_diagnostic_list_append(&parser->warning_list, start, end, diag_id);
}

/**
 * Append a warning to the list of warnings on the parser using the location of
 * the given token.
 */
static inline void
pm_parser_warn_token(pm_parser_t *parser, const pm_token_t *token, pm_diagnostic_id_t diag_id) {
    pm_parser_warn(parser, token->start, token->end, diag_id);
}

/**
 * Append a warning to the list of warnings on the parser using the location of
 * the given node.
 */
static inline void
pm_parser_warn_node(pm_parser_t *parser, const pm_node_t *node, pm_diagnostic_id_t diag_id) {
    pm_parser_warn(parser, node->location.start, node->location.end, diag_id);
}

/**
 * Append a warning to the list of warnings on the parser using a format string.
 */
#define PM_PARSER_WARN_FORMAT(parser, start, end, diag_id, ...) \
    pm_diagnostic_list_append_format(&parser->warning_list, start, end, diag_id, __VA_ARGS__)

/**
 * Append a warning to the list of warnings on the parser using the location of
 * the given token and a format string.
 */
#define PM_PARSER_WARN_TOKEN_FORMAT(parser, token, diag_id, ...) \
    PM_PARSER_WARN_FORMAT(parser, (token).start, (token).end, diag_id, __VA_ARGS__)

/**
 * Append a warning to the list of warnings on the parser using the location of
 * the given token and a format string, and add on the content of the token.
 */
#define PM_PARSER_WARN_TOKEN_FORMAT_CONTENT(parser, token, diag_id) \
    PM_PARSER_WARN_TOKEN_FORMAT(parser, token, diag_id, (int) ((token).end - (token).start), (const char *) (token).start)

/**
 * Append a warning to the list of warnings on the parser using the location of
 * the given node and a format string.
 */
#define PM_PARSER_WARN_NODE_FORMAT(parser, node, diag_id, ...) \
    PM_PARSER_WARN_FORMAT(parser, (node)->location.start, (node)->location.end, diag_id, __VA_ARGS__)

/**
 * Add an error for an expected heredoc terminator. This is a special function
 * only because it grabs its location off of a lex mode instead of a node or a
 * token.
 */
static void
pm_parser_err_heredoc_term(pm_parser_t *parser, const uint8_t *ident_start, size_t ident_length) {
    PM_PARSER_ERR_FORMAT(
        parser,
        ident_start,
        ident_start + ident_length,
        PM_ERR_HEREDOC_TERM,
        (int) ident_length,
        (const char *) ident_start
    );
}

/******************************************************************************/
/* Scope-related functions                                                    */
/******************************************************************************/

/**
 * Allocate and initialize a new scope. Push it onto the scope stack.
 */
static bool
pm_parser_scope_push(pm_parser_t *parser, bool closed) {
    pm_scope_t *scope = (pm_scope_t *) xmalloc(sizeof(pm_scope_t));
    if (scope == NULL) return false;

    *scope = (pm_scope_t) {
        .previous = parser->current_scope,
        .locals = { 0 },
        .parameters = PM_SCOPE_PARAMETERS_NONE,
        .implicit_parameters = { 0 },
        .shareable_constant = parser->current_scope == NULL ? PM_SCOPE_SHAREABLE_CONSTANT_NONE : parser->current_scope->shareable_constant,
        .closed = closed
    };

    parser->current_scope = scope;
    return true;
}

/**
 * Determine if the current scope is at the top level. This means it is either
 * the top-level scope or it is open to the top-level.
 */
static bool
pm_parser_scope_toplevel_p(pm_parser_t *parser) {
    pm_scope_t *scope = parser->current_scope;

    do {
        if (scope->previous == NULL) return true;
        if (scope->closed) return false;
    } while ((scope = scope->previous) != NULL);

    assert(false && "unreachable");
    return true;
}

/**
 * Retrieve the scope at the given depth.
 */
static pm_scope_t *
pm_parser_scope_find(pm_parser_t *parser, uint32_t depth) {
    pm_scope_t *scope = parser->current_scope;

    while (depth-- > 0) {
        assert(scope != NULL);
        scope = scope->previous;
    }

    return scope;
}

typedef enum {
    PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_PASS,
    PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_CONFLICT,
    PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_FAIL
} pm_scope_forwarding_param_check_result_t;

static pm_scope_forwarding_param_check_result_t
pm_parser_scope_forwarding_param_check(pm_parser_t *parser, const uint8_t mask) {
    pm_scope_t *scope = parser->current_scope;
    bool conflict = false;

    while (scope != NULL) {
        if (scope->parameters & mask) {
            if (scope->closed) {
                if (conflict) {
                    return PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_CONFLICT;
                } else {
                    return PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_PASS;
                }
            }

            conflict = true;
        }

        if (scope->closed) break;
        scope = scope->previous;
    }

    return PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_FAIL;
}

static void
pm_parser_scope_forwarding_block_check(pm_parser_t *parser, const pm_token_t * token) {
    switch (pm_parser_scope_forwarding_param_check(parser, PM_SCOPE_PARAMETERS_FORWARDING_BLOCK)) {
        case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_PASS:
            // Pass.
            break;
        case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_CONFLICT:
            pm_parser_err_token(parser, token, PM_ERR_ARGUMENT_CONFLICT_AMPERSAND);
            break;
        case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_FAIL:
            pm_parser_err_token(parser, token, PM_ERR_ARGUMENT_NO_FORWARDING_AMPERSAND);
            break;
    }
}

static void
pm_parser_scope_forwarding_positionals_check(pm_parser_t *parser, const pm_token_t * token) {
    switch (pm_parser_scope_forwarding_param_check(parser, PM_SCOPE_PARAMETERS_FORWARDING_POSITIONALS)) {
        case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_PASS:
            // Pass.
            break;
        case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_CONFLICT:
            pm_parser_err_token(parser, token, PM_ERR_ARGUMENT_CONFLICT_STAR);
            break;
        case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_FAIL:
            pm_parser_err_token(parser, token, PM_ERR_ARGUMENT_NO_FORWARDING_STAR);
            break;
    }
}

static void
pm_parser_scope_forwarding_all_check(pm_parser_t *parser, const pm_token_t *token) {
    switch (pm_parser_scope_forwarding_param_check(parser, PM_SCOPE_PARAMETERS_FORWARDING_ALL)) {
        case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_PASS:
            // Pass.
            break;
        case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_CONFLICT:
            // This shouldn't happen, because ... is not allowed in the
            // declaration of blocks. If we get here, we assume we already have
            // an error for this.
            break;
        case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_FAIL:
            pm_parser_err_token(parser, token, PM_ERR_ARGUMENT_NO_FORWARDING_ELLIPSES);
            break;
    }
}

static void
pm_parser_scope_forwarding_keywords_check(pm_parser_t *parser, const pm_token_t * token) {
    switch (pm_parser_scope_forwarding_param_check(parser, PM_SCOPE_PARAMETERS_FORWARDING_KEYWORDS)) {
        case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_PASS:
            // Pass.
            break;
        case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_CONFLICT:
            pm_parser_err_token(parser, token, PM_ERR_ARGUMENT_CONFLICT_STAR_STAR);
            break;
        case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_FAIL:
            pm_parser_err_token(parser, token, PM_ERR_ARGUMENT_NO_FORWARDING_STAR_STAR);
            break;
    }
}

/**
 * Get the current state of constant shareability.
 */
static inline pm_shareable_constant_value_t
pm_parser_scope_shareable_constant_get(pm_parser_t *parser) {
    return parser->current_scope->shareable_constant;
}

/**
 * Set the current state of constant shareability. We'll set it on all of the
 * open scopes so that reads are quick.
 */
static void
pm_parser_scope_shareable_constant_set(pm_parser_t *parser, pm_shareable_constant_value_t shareable_constant) {
    pm_scope_t *scope = parser->current_scope;

    do {
        scope->shareable_constant = shareable_constant;
    } while (!scope->closed && (scope = scope->previous) != NULL);
}

/******************************************************************************/
/* Local variable-related functions                                           */
/******************************************************************************/

/**
 * The point at which the set of locals switches from being a list to a hash.
 */
#define PM_LOCALS_HASH_THRESHOLD 9

static void
pm_locals_free(pm_locals_t *locals) {
    if (locals->capacity > 0) {
        xfree(locals->locals);
    }
}

/**
 * Use as simple and fast a hash function as we can that still properly mixes
 * the bits.
 */
static uint32_t
pm_locals_hash(pm_constant_id_t name) {
    name = ((name >> 16) ^ name) * 0x45d9f3b;
    name = ((name >> 16) ^ name) * 0x45d9f3b;
    name = (name >> 16) ^ name;
    return name;
}

/**
 * Resize the locals list to be twice its current size. If the next capacity is
 * above the threshold for switching to a hash, then we'll switch to a hash.
 */
static void
pm_locals_resize(pm_locals_t *locals) {
    uint32_t next_capacity = locals->capacity == 0 ? 4 : (locals->capacity * 2);
    assert(next_capacity > locals->capacity);

    pm_local_t *next_locals = xcalloc(next_capacity, sizeof(pm_local_t));
    if (next_locals == NULL) abort();

    if (next_capacity < PM_LOCALS_HASH_THRESHOLD) {
        if (locals->size > 0) {
            memcpy(next_locals, locals->locals, locals->size * sizeof(pm_local_t));
        }
    } else {
        // If we just switched from a list to a hash, then we need to fill in
        // the hash values of all of the locals.
        bool hash_needed = (locals->capacity <= PM_LOCALS_HASH_THRESHOLD);
        uint32_t mask = next_capacity - 1;

        for (uint32_t index = 0; index < locals->capacity; index++) {
            pm_local_t *local = &locals->locals[index];

            if (local->name != PM_CONSTANT_ID_UNSET) {
                if (hash_needed) local->hash = pm_locals_hash(local->name);

                uint32_t hash = local->hash;
                while (next_locals[hash & mask].name != PM_CONSTANT_ID_UNSET) hash++;
                next_locals[hash & mask] = *local;
            }
        }
    }

    pm_locals_free(locals);
    locals->locals = next_locals;
    locals->capacity = next_capacity;
}

/**
 * Add a new local to the set of locals. This will automatically rehash the
 * locals if the size is greater than 3/4 of the capacity.
 *
 * @param locals The set of locals to add to.
 * @param name The name of the local.
 * @param start The source location that represents the start of the local. This
 *   is used for the location of the warning in case this local is not read.
 * @param end The source location that represents the end of the local. This is
 *   used for the location of the warning in case this local is not read.
 * @param reads The initial number of reads for this local. Usually this is set
 *   to 0, but for some locals (like parameters) we want to initialize it with
 *   1 so that we never warn on unused parameters.
 * @return True if the local was added, and false if the local already exists.
 */
static bool
pm_locals_write(pm_locals_t *locals, pm_constant_id_t name, const uint8_t *start, const uint8_t *end, uint32_t reads) {
    if (locals->size >= (locals->capacity / 4 * 3)) {
        pm_locals_resize(locals);
    }

    if (locals->capacity < PM_LOCALS_HASH_THRESHOLD) {
        for (uint32_t index = 0; index < locals->capacity; index++) {
            pm_local_t *local = &locals->locals[index];

            if (local->name == PM_CONSTANT_ID_UNSET) {
                *local = (pm_local_t) {
                    .name = name,
                    .location = { .start = start, .end = end },
                    .index = locals->size++,
                    .reads = reads,
                    .hash = 0
                };
                return true;
            } else if (local->name == name) {
                return false;
            }
        }
    } else {
        uint32_t mask = locals->capacity - 1;
        uint32_t hash = pm_locals_hash(name);
        uint32_t initial_hash = hash;

        do {
            pm_local_t *local = &locals->locals[hash & mask];

            if (local->name == PM_CONSTANT_ID_UNSET) {
                *local = (pm_local_t) {
                    .name = name,
                    .location = { .start = start, .end = end },
                    .index = locals->size++,
                    .reads = reads,
                    .hash = initial_hash
                };
                return true;
            } else if (local->name == name) {
                return false;
            } else {
                hash++;
            }
        } while ((hash & mask) != initial_hash);
    }

    assert(false && "unreachable");
    return true;
}

/**
 * Finds the index of a local variable in the locals set. If it is not found,
 * this returns UINT32_MAX.
 */
static uint32_t
pm_locals_find(pm_locals_t *locals, pm_constant_id_t name) {
    if (locals->capacity < PM_LOCALS_HASH_THRESHOLD) {
        for (uint32_t index = 0; index < locals->size; index++) {
            pm_local_t *local = &locals->locals[index];
            if (local->name == name) return index;
        }
    } else {
        uint32_t mask = locals->capacity - 1;
        uint32_t hash = pm_locals_hash(name);
        uint32_t initial_hash = hash & mask;

        do {
            pm_local_t *local = &locals->locals[hash & mask];

            if (local->name == PM_CONSTANT_ID_UNSET) {
                return UINT32_MAX;
            } else if (local->name == name) {
                return hash & mask;
            } else {
                hash++;
            }
        } while ((hash & mask) != initial_hash);
    }

    return UINT32_MAX;
}

/**
 * Called when a variable is read in a certain lexical context. Tracks the read
 * by adding to the reads count.
 */
static void
pm_locals_read(pm_locals_t *locals, pm_constant_id_t name) {
    uint32_t index = pm_locals_find(locals, name);
    assert(index != UINT32_MAX);

    pm_local_t *local = &locals->locals[index];
    assert(local->reads < UINT32_MAX);

    local->reads++;
}

/**
 * Called when a variable read is transformed into a variable write, because a
 * write operator is found after the variable name.
 */
static void
pm_locals_unread(pm_locals_t *locals, pm_constant_id_t name) {
    uint32_t index = pm_locals_find(locals, name);
    assert(index != UINT32_MAX);

    pm_local_t *local = &locals->locals[index];
    assert(local->reads > 0);

    local->reads--;
}

/**
 * Returns the current number of reads for a local variable.
 */
static uint32_t
pm_locals_reads(pm_locals_t *locals, pm_constant_id_t name) {
    uint32_t index = pm_locals_find(locals, name);
    assert(index != UINT32_MAX);

    return locals->locals[index].reads;
}

/**
 * Write out the locals into the given list of constant ids in the correct
 * order. This is used to set the list of locals on the nodes in the tree once
 * we're sure no additional locals will be added to the set.
 *
 * This function is also responsible for warning when a local variable has been
 * written but not read in certain contexts.
 */
static void
pm_locals_order(PRISM_ATTRIBUTE_UNUSED pm_parser_t *parser, pm_locals_t *locals, pm_constant_id_list_t *list, bool toplevel) {
    pm_constant_id_list_init_capacity(list, locals->size);

    // If we're still below the threshold for switching to a hash, then we only
    // need to loop over the locals until we hit the size because the locals are
    // stored in a list.
    uint32_t capacity = locals->capacity < PM_LOCALS_HASH_THRESHOLD ? locals->size : locals->capacity;

    // We will only warn for unused variables if we're not at the top level, or
    // if we're parsing a file outside of eval or -e.
    bool warn_unused = !toplevel || (!parser->parsing_eval && !PM_PARSER_COMMAND_LINE_OPTION_E(parser));

    for (uint32_t index = 0; index < capacity; index++) {
        pm_local_t *local = &locals->locals[index];

        if (local->name != PM_CONSTANT_ID_UNSET) {
            pm_constant_id_list_insert(list, (size_t) local->index, local->name);

            if (warn_unused && local->reads == 0 && ((parser->start_line >= 0) || (pm_newline_list_line(&parser->newline_list, local->location.start, parser->start_line) >= 0))) {
                pm_constant_t *constant = pm_constant_pool_id_to_constant(&parser->constant_pool, local->name);

                if (constant->length >= 1 && *constant->start != '_') {
                    PM_PARSER_WARN_FORMAT(
                        parser,
                        local->location.start,
                        local->location.end,
                        PM_WARN_UNUSED_LOCAL_VARIABLE,
                        (int) constant->length,
                        (const char *) constant->start
                    );
                }
            }
        }
    }
}

/******************************************************************************/
/* Node-related functions                                                     */
/******************************************************************************/

/**
 * Retrieve the constant pool id for the given location.
 */
static inline pm_constant_id_t
pm_parser_constant_id_location(pm_parser_t *parser, const uint8_t *start, const uint8_t *end) {
    return pm_constant_pool_insert_shared(&parser->constant_pool, start, (size_t) (end - start));
}

/**
 * Retrieve the constant pool id for the given string.
 */
static inline pm_constant_id_t
pm_parser_constant_id_owned(pm_parser_t *parser, uint8_t *start, size_t length) {
    return pm_constant_pool_insert_owned(&parser->constant_pool, start, length);
}

/**
 * Retrieve the constant pool id for the given static literal C string.
 */
static inline pm_constant_id_t
pm_parser_constant_id_constant(pm_parser_t *parser, const char *start, size_t length) {
    return pm_constant_pool_insert_constant(&parser->constant_pool, (const uint8_t *) start, length);
}

/**
 * Retrieve the constant pool id for the given token.
 */
static inline pm_constant_id_t
pm_parser_constant_id_token(pm_parser_t *parser, const pm_token_t *token) {
    return pm_parser_constant_id_location(parser, token->start, token->end);
}

/**
 * Retrieve the constant pool id for the given token. If the token is not
 * provided, then return 0.
 */
static inline pm_constant_id_t
pm_parser_optional_constant_id_token(pm_parser_t *parser, const pm_token_t *token) {
    return token->type == PM_TOKEN_NOT_PROVIDED ? 0 : pm_parser_constant_id_token(parser, token);
}

/**
 * Check whether or not the given node is value expression.
 * If the node is value node, it returns NULL.
 * If not, it returns the pointer to the node to be inspected as "void expression".
 */
static pm_node_t *
pm_check_value_expression(pm_parser_t *parser, pm_node_t *node) {
    pm_node_t *void_node = NULL;

    while (node != NULL) {
        switch (PM_NODE_TYPE(node)) {
            case PM_RETURN_NODE:
            case PM_BREAK_NODE:
            case PM_NEXT_NODE:
            case PM_REDO_NODE:
            case PM_RETRY_NODE:
            case PM_MATCH_REQUIRED_NODE:
                return void_node != NULL ? void_node : node;
            case PM_MATCH_PREDICATE_NODE:
                return NULL;
            case PM_BEGIN_NODE: {
                pm_begin_node_t *cast = (pm_begin_node_t *) node;

                if (cast->ensure_clause != NULL) {
                    if (cast->rescue_clause != NULL) {
                        pm_node_t *vn = pm_check_value_expression(parser, (pm_node_t *) cast->rescue_clause);
                        if (vn != NULL) return vn;
                    }

                    if (cast->statements != NULL) {
                        pm_node_t *vn = pm_check_value_expression(parser, (pm_node_t *) cast->statements);
                        if (vn != NULL) return vn;
                    }

                    node = (pm_node_t *) cast->ensure_clause;
                } else if (cast->rescue_clause != NULL) {
                    if (cast->statements == NULL) return NULL;

                    pm_node_t *vn = pm_check_value_expression(parser, (pm_node_t *) cast->statements);
                    if (vn == NULL) return NULL;
                    if (void_node == NULL) void_node = vn;

                    for (pm_rescue_node_t *rescue_clause = cast->rescue_clause; rescue_clause != NULL; rescue_clause = rescue_clause->subsequent) {
                        pm_node_t *vn = pm_check_value_expression(parser, (pm_node_t *) rescue_clause->statements);
                        if (vn == NULL) {
                            void_node = NULL;
                            break;
                        }
                        if (void_node == NULL) {
                            void_node = vn;
                        }
                    }

                    if (cast->else_clause != NULL) {
                        node = (pm_node_t *) cast->else_clause;
                    } else {
                        return void_node;
                    }
                } else {
                    node = (pm_node_t *) cast->statements;
                }

                break;
            }
            case PM_ENSURE_NODE: {
                pm_ensure_node_t *cast = (pm_ensure_node_t *) node;
                node = (pm_node_t *) cast->statements;
                break;
            }
            case PM_PARENTHESES_NODE: {
                pm_parentheses_node_t *cast = (pm_parentheses_node_t *) node;
                node = (pm_node_t *) cast->body;
                break;
            }
            case PM_STATEMENTS_NODE: {
                pm_statements_node_t *cast = (pm_statements_node_t *) node;
                node = cast->body.nodes[cast->body.size - 1];
                break;
            }
            case PM_IF_NODE: {
                pm_if_node_t *cast = (pm_if_node_t *) node;
                if (cast->statements == NULL || cast->subsequent == NULL) {
                    return NULL;
                }
                pm_node_t *vn = pm_check_value_expression(parser, (pm_node_t *) cast->statements);
                if (vn == NULL) {
                    return NULL;
                }
                if (void_node == NULL) {
                    void_node = vn;
                }
                node = cast->subsequent;
                break;
            }
            case PM_UNLESS_NODE: {
                pm_unless_node_t *cast = (pm_unless_node_t *) node;
                if (cast->statements == NULL || cast->else_clause == NULL) {
                    return NULL;
                }
                pm_node_t *vn = pm_check_value_expression(parser, (pm_node_t *) cast->statements);
                if (vn == NULL) {
                    return NULL;
                }
                if (void_node == NULL) {
                    void_node = vn;
                }
                node = (pm_node_t *) cast->else_clause;
                break;
            }
            case PM_ELSE_NODE: {
                pm_else_node_t *cast = (pm_else_node_t *) node;
                node = (pm_node_t *) cast->statements;
                break;
            }
            case PM_AND_NODE: {
                pm_and_node_t *cast = (pm_and_node_t *) node;
                node = cast->left;
                break;
            }
            case PM_OR_NODE: {
                pm_or_node_t *cast = (pm_or_node_t *) node;
                node = cast->left;
                break;
            }
            case PM_LOCAL_VARIABLE_WRITE_NODE: {
                pm_local_variable_write_node_t *cast = (pm_local_variable_write_node_t *) node;

                pm_scope_t *scope = parser->current_scope;
                for (uint32_t depth = 0; depth < cast->depth; depth++) scope = scope->previous;

                pm_locals_read(&scope->locals, cast->name);
                return NULL;
            }
            default:
                return NULL;
        }
    }

    return NULL;
}

static inline void
pm_assert_value_expression(pm_parser_t *parser, pm_node_t *node) {
    pm_node_t *void_node = pm_check_value_expression(parser, node);
    if (void_node != NULL) {
        pm_parser_err_node(parser, void_node, PM_ERR_VOID_EXPRESSION);
    }
}

/**
 * Warn if the given node is a "void" statement.
 */
static void
pm_void_statement_check(pm_parser_t *parser, const pm_node_t *node) {
    const char *type = NULL;
    int length = 0;

    switch (PM_NODE_TYPE(node)) {
        case PM_BACK_REFERENCE_READ_NODE:
        case PM_CLASS_VARIABLE_READ_NODE:
        case PM_GLOBAL_VARIABLE_READ_NODE:
        case PM_INSTANCE_VARIABLE_READ_NODE:
        case PM_LOCAL_VARIABLE_READ_NODE:
        case PM_NUMBERED_REFERENCE_READ_NODE:
            type = "a variable";
            length = 10;
            break;
        case PM_CALL_NODE: {
            const pm_call_node_t *cast = (const pm_call_node_t *) node;
            if (cast->call_operator_loc.start != NULL || cast->message_loc.start == NULL) break;

            const pm_constant_t *message = pm_constant_pool_id_to_constant(&parser->constant_pool, cast->name);
            switch (message->length) {
                case 1:
                    switch (message->start[0]) {
                        case '+':
                        case '-':
                        case '*':
                        case '/':
                        case '%':
                        case '|':
                        case '^':
                        case '&':
                        case '>':
                        case '<':
                            type = (const char *) message->start;
                            length = 1;
                            break;
                    }
                    break;
                case 2:
                    switch (message->start[1]) {
                        case '=':
                            if (message->start[0] == '<' || message->start[0] == '>' || message->start[0] == '!' || message->start[0] == '=') {
                                type = (const char *) message->start;
                                length = 2;
                            }
                            break;
                        case '@':
                            if (message->start[0] == '+' || message->start[0] == '-') {
                                type = (const char *) message->start;
                                length = 2;
                            }
                            break;
                        case '*':
                            if (message->start[0] == '*') {
                                type = (const char *) message->start;
                                length = 2;
                            }
                            break;
                    }
                    break;
                case 3:
                    if (memcmp(message->start, "<=>", 3) == 0) {
                        type = "<=>";
                        length = 3;
                    }
                    break;
            }

            break;
        }
        case PM_CONSTANT_PATH_NODE:
            type = "::";
            length = 2;
            break;
        case PM_CONSTANT_READ_NODE:
            type = "a constant";
            length = 10;
            break;
        case PM_DEFINED_NODE:
            type = "defined?";
            length = 8;
            break;
        case PM_FALSE_NODE:
            type = "false";
            length = 5;
            break;
        case PM_FLOAT_NODE:
        case PM_IMAGINARY_NODE:
        case PM_INTEGER_NODE:
        case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE:
        case PM_INTERPOLATED_STRING_NODE:
        case PM_RATIONAL_NODE:
        case PM_REGULAR_EXPRESSION_NODE:
        case PM_SOURCE_ENCODING_NODE:
        case PM_SOURCE_FILE_NODE:
        case PM_SOURCE_LINE_NODE:
        case PM_STRING_NODE:
        case PM_SYMBOL_NODE:
            type = "a literal";
            length = 9;
            break;
        case PM_NIL_NODE:
            type = "nil";
            length = 3;
            break;
        case PM_RANGE_NODE: {
            const pm_range_node_t *cast = (const pm_range_node_t *) node;

            if (PM_NODE_FLAG_P(cast, PM_RANGE_FLAGS_EXCLUDE_END)) {
                type = "...";
                length = 3;
            } else {
                type = "..";
                length = 2;
            }

            break;
        }
        case PM_SELF_NODE:
            type = "self";
            length = 4;
            break;
        case PM_TRUE_NODE:
            type = "true";
            length = 4;
            break;
        default:
            break;
    }

    if (type != NULL) {
        PM_PARSER_WARN_NODE_FORMAT(parser, node, PM_WARN_VOID_STATEMENT, length, type);
    }
}

/**
 * Warn if any of the statements that are not the last statement in the list are
 * a "void" statement.
 */
static void
pm_void_statements_check(pm_parser_t *parser, const pm_statements_node_t *node, bool last_value) {
    assert(node->body.size > 0);
    const size_t size = node->body.size - (last_value ? 1 : 0);
    for (size_t index = 0; index < size; index++) {
        pm_void_statement_check(parser, node->body.nodes[index]);
    }
}

/**
 * When we're handling the predicate of a conditional, we need to know our
 * context in order to determine the kind of warning we should deliver to the
 * user.
 */
typedef enum {
    PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL,
    PM_CONDITIONAL_PREDICATE_TYPE_FLIP_FLOP,
    PM_CONDITIONAL_PREDICATE_TYPE_NOT
} pm_conditional_predicate_type_t;

/**
 * Add a warning to the parser if the predicate of a conditional is a literal.
 */
static void
pm_parser_warn_conditional_predicate_literal(pm_parser_t *parser, pm_node_t *node, pm_conditional_predicate_type_t type, pm_diagnostic_id_t diag_id, const char *prefix) {
    switch (type) {
        case PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL:
            PM_PARSER_WARN_NODE_FORMAT(parser, node, diag_id, prefix, "condition");
            break;
        case PM_CONDITIONAL_PREDICATE_TYPE_FLIP_FLOP:
            PM_PARSER_WARN_NODE_FORMAT(parser, node, diag_id, prefix, "flip-flop");
            break;
        case PM_CONDITIONAL_PREDICATE_TYPE_NOT:
            break;
    }
}

/**
 * Return true if the value being written within the predicate of a conditional
 * is a literal value.
 */
static bool
pm_conditional_predicate_warn_write_literal_p(const pm_node_t *node) {
    switch (PM_NODE_TYPE(node)) {
        case PM_ARRAY_NODE: {
            if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) return true;

            const pm_array_node_t *cast = (const pm_array_node_t *) node;
            for (size_t index = 0; index < cast->elements.size; index++) {
                if (!pm_conditional_predicate_warn_write_literal_p(cast->elements.nodes[index])) return false;
            }

            return true;
        }
        case PM_HASH_NODE: {
            if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) return true;

            const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
            for (size_t index = 0; index < cast->elements.size; index++) {
                const pm_node_t *element = cast->elements.nodes[index];
                if (!PM_NODE_TYPE_P(element, PM_ASSOC_NODE)) return false;

                const pm_assoc_node_t *assoc = (const pm_assoc_node_t *) element;
                if (!pm_conditional_predicate_warn_write_literal_p(assoc->key) || !pm_conditional_predicate_warn_write_literal_p(assoc->value)) return false;
            }

            return true;
        }
        case PM_FALSE_NODE:
        case PM_FLOAT_NODE:
        case PM_IMAGINARY_NODE:
        case PM_INTEGER_NODE:
        case PM_NIL_NODE:
        case PM_RATIONAL_NODE:
        case PM_REGULAR_EXPRESSION_NODE:
        case PM_SOURCE_ENCODING_NODE:
        case PM_SOURCE_FILE_NODE:
        case PM_SOURCE_LINE_NODE:
        case PM_STRING_NODE:
        case PM_SYMBOL_NODE:
        case PM_TRUE_NODE:
            return true;
        default:
            return false;
    }
}

/**
 * Add a warning to the parser if the value that is being written inside of a
 * predicate to a conditional is a literal.
 */
static inline void
pm_conditional_predicate_warn_write_literal(pm_parser_t *parser, const pm_node_t *node) {
    if (pm_conditional_predicate_warn_write_literal_p(node)) {
        pm_parser_warn_node(parser, node, parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3 ? PM_WARN_EQUAL_IN_CONDITIONAL_3_3 : PM_WARN_EQUAL_IN_CONDITIONAL);
    }
}

/**
 * The predicate of conditional nodes can change what would otherwise be regular
 * nodes into specialized nodes. For example:
 *
 * if foo .. bar         => RangeNode becomes FlipFlopNode
 * if foo and bar .. baz => RangeNode becomes FlipFlopNode
 * if /foo/              => RegularExpressionNode becomes MatchLastLineNode
 * if /foo #{bar}/       => InterpolatedRegularExpressionNode becomes InterpolatedMatchLastLineNode
 *
 * We also want to warn the user if they're using a static literal as a
 * predicate or writing a static literal as the predicate.
 */
static void
pm_conditional_predicate(pm_parser_t *parser, pm_node_t *node, pm_conditional_predicate_type_t type) {
    switch (PM_NODE_TYPE(node)) {
        case PM_AND_NODE: {
            pm_and_node_t *cast = (pm_and_node_t *) node;
            pm_conditional_predicate(parser, cast->left, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
            pm_conditional_predicate(parser, cast->right, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
            break;
        }
        case PM_OR_NODE: {
            pm_or_node_t *cast = (pm_or_node_t *) node;
            pm_conditional_predicate(parser, cast->left, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
            pm_conditional_predicate(parser, cast->right, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
            break;
        }
        case PM_PARENTHESES_NODE: {
            pm_parentheses_node_t *cast = (pm_parentheses_node_t *) node;

            if ((cast->body != NULL) && PM_NODE_TYPE_P(cast->body, PM_STATEMENTS_NODE)) {
                pm_statements_node_t *statements = (pm_statements_node_t *) cast->body;
                if (statements->body.size == 1) pm_conditional_predicate(parser, statements->body.nodes[0], type);
            }

            break;
        }
        case PM_BEGIN_NODE: {
            pm_begin_node_t *cast = (pm_begin_node_t *) node;
            if (cast->statements != NULL) {
                pm_statements_node_t *statements = cast->statements;
                if (statements->body.size == 1) pm_conditional_predicate(parser, statements->body.nodes[0], type);
            }
            break;
        }
        case PM_RANGE_NODE: {
            pm_range_node_t *cast = (pm_range_node_t *) node;

            if (cast->left != NULL) pm_conditional_predicate(parser, cast->left, PM_CONDITIONAL_PREDICATE_TYPE_FLIP_FLOP);
            if (cast->right != NULL) pm_conditional_predicate(parser, cast->right, PM_CONDITIONAL_PREDICATE_TYPE_FLIP_FLOP);

            // Here we change the range node into a flip flop node. We can do
            // this since the nodes are exactly the same except for the type.
            // We're only asserting against the size when we should probably
            // assert against the entire layout, but we'll assume tests will
            // catch this.
            assert(sizeof(pm_range_node_t) == sizeof(pm_flip_flop_node_t));
            node->type = PM_FLIP_FLOP_NODE;

            break;
        }
        case PM_REGULAR_EXPRESSION_NODE:
            // Here we change the regular expression node into a match last line
            // node. We can do this since the nodes are exactly the same except
            // for the type.
            assert(sizeof(pm_regular_expression_node_t) == sizeof(pm_match_last_line_node_t));
            node->type = PM_MATCH_LAST_LINE_NODE;

            if (!PM_PARSER_COMMAND_LINE_OPTION_E(parser)) {
                pm_parser_warn_conditional_predicate_literal(parser, node, type, PM_WARN_LITERAL_IN_CONDITION_DEFAULT, "regex ");
            }

            break;
        case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE:
            // Here we change the interpolated regular expression node into an
            // interpolated match last line node. We can do this since the nodes
            // are exactly the same except for the type.
            assert(sizeof(pm_interpolated_regular_expression_node_t) == sizeof(pm_interpolated_match_last_line_node_t));
            node->type = PM_INTERPOLATED_MATCH_LAST_LINE_NODE;

            if (!PM_PARSER_COMMAND_LINE_OPTION_E(parser)) {
                pm_parser_warn_conditional_predicate_literal(parser, node, type, PM_WARN_LITERAL_IN_CONDITION_VERBOSE, "regex ");
            }

            break;
        case PM_INTEGER_NODE:
            if (type == PM_CONDITIONAL_PREDICATE_TYPE_FLIP_FLOP) {
                if (!PM_PARSER_COMMAND_LINE_OPTION_E(parser)) {
                    pm_parser_warn_node(parser, node, PM_WARN_INTEGER_IN_FLIP_FLOP);
                }
            } else {
                pm_parser_warn_conditional_predicate_literal(parser, node, type, PM_WARN_LITERAL_IN_CONDITION_VERBOSE, "");
            }
            break;
        case PM_STRING_NODE:
        case PM_SOURCE_FILE_NODE:
        case PM_INTERPOLATED_STRING_NODE:
            pm_parser_warn_conditional_predicate_literal(parser, node, type, PM_WARN_LITERAL_IN_CONDITION_DEFAULT, "string ");
            break;
        case PM_SYMBOL_NODE:
        case PM_INTERPOLATED_SYMBOL_NODE:
            pm_parser_warn_conditional_predicate_literal(parser, node, type, PM_WARN_LITERAL_IN_CONDITION_VERBOSE, "symbol ");
            break;
        case PM_SOURCE_LINE_NODE:
        case PM_SOURCE_ENCODING_NODE:
        case PM_FLOAT_NODE:
        case PM_RATIONAL_NODE:
        case PM_IMAGINARY_NODE:
            pm_parser_warn_conditional_predicate_literal(parser, node, type, PM_WARN_LITERAL_IN_CONDITION_VERBOSE, "");
            break;
        case PM_CLASS_VARIABLE_WRITE_NODE:
            pm_conditional_predicate_warn_write_literal(parser, ((pm_class_variable_write_node_t *) node)->value);
            break;
        case PM_CONSTANT_WRITE_NODE:
            pm_conditional_predicate_warn_write_literal(parser, ((pm_constant_write_node_t *) node)->value);
            break;
        case PM_GLOBAL_VARIABLE_WRITE_NODE:
            pm_conditional_predicate_warn_write_literal(parser, ((pm_global_variable_write_node_t *) node)->value);
            break;
        case PM_INSTANCE_VARIABLE_WRITE_NODE:
            pm_conditional_predicate_warn_write_literal(parser, ((pm_instance_variable_write_node_t *) node)->value);
            break;
        case PM_LOCAL_VARIABLE_WRITE_NODE:
            pm_conditional_predicate_warn_write_literal(parser, ((pm_local_variable_write_node_t *) node)->value);
            break;
        case PM_MULTI_WRITE_NODE:
            pm_conditional_predicate_warn_write_literal(parser, ((pm_multi_write_node_t *) node)->value);
            break;
        default:
            break;
    }
}

/**
 * In a lot of places in the tree you can have tokens that are not provided but
 * that do not cause an error. For example, this happens in a method call
 * without parentheses. In these cases we set the token to the "not provided" type.
 * For example:
 *
 *     pm_token_t token = not_provided(parser);
 */
static inline pm_token_t
not_provided(pm_parser_t *parser) {
    return (pm_token_t) { .type = PM_TOKEN_NOT_PROVIDED, .start = parser->start, .end = parser->start };
}

#define PM_LOCATION_NULL_VALUE(parser) ((pm_location_t) { .start = (parser)->start, .end = (parser)->start })
#define PM_LOCATION_TOKEN_VALUE(token) ((pm_location_t) { .start = (token)->start, .end = (token)->end })
#define PM_LOCATION_NODE_VALUE(node) ((pm_location_t) { .start = (node)->location.start, .end = (node)->location.end })
#define PM_LOCATION_NODE_BASE_VALUE(node) ((pm_location_t) { .start = (node)->base.location.start, .end = (node)->base.location.end })
#define PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE ((pm_location_t) { .start = NULL, .end = NULL })
#define PM_OPTIONAL_LOCATION_TOKEN_VALUE(token) ((token)->type == PM_TOKEN_NOT_PROVIDED ? PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE : PM_LOCATION_TOKEN_VALUE(token))

/**
 * This is a special out parameter to the parse_arguments_list function that
 * includes opening and closing parentheses in addition to the arguments since
 * it's so common. It is handy to use when passing argument information to one
 * of the call node creation functions.
 */
typedef struct {
    /** The optional location of the opening parenthesis or bracket. */
    pm_location_t opening_loc;

    /** The lazily-allocated optional arguments node. */
    pm_arguments_node_t *arguments;

    /** The optional location of the closing parenthesis or bracket. */
    pm_location_t closing_loc;

    /** The optional block attached to the call. */
    pm_node_t *block;

    /** The flag indicating whether this arguments list has forwarding argument. */
    bool has_forwarding;
} pm_arguments_t;

/**
 * Retrieve the end location of a `pm_arguments_t` object.
 */
static inline const uint8_t *
pm_arguments_end(pm_arguments_t *arguments) {
    if (arguments->block != NULL) {
        const uint8_t *end = arguments->block->location.end;
        if (arguments->closing_loc.start != NULL && arguments->closing_loc.end > end) {
            end = arguments->closing_loc.end;
        }
        return end;
    }
    if (arguments->closing_loc.start != NULL) {
        return arguments->closing_loc.end;
    }
    if (arguments->arguments != NULL) {
        return arguments->arguments->base.location.end;
    }
    return arguments->closing_loc.end;
}

/**
 * Check that we're not about to attempt to attach a brace block to a call that
 * has arguments without parentheses.
 */
static void
pm_arguments_validate_block(pm_parser_t *parser, pm_arguments_t *arguments, pm_block_node_t *block) {
    // First, check that we have arguments and that we don't have a closing
    // location for them.
    if (arguments->arguments == NULL || arguments->closing_loc.start != NULL) {
        return;
    }

    // Next, check that we don't have a single parentheses argument. This would
    // look like:
    //
    //     foo (1) {}
    //
    // In this case, it's actually okay for the block to be attached to the
    // call, even though it looks like it's attached to the argument.
    if (arguments->arguments->arguments.size == 1 && PM_NODE_TYPE_P(arguments->arguments->arguments.nodes[0], PM_PARENTHESES_NODE)) {
        return;
    }

    // If we didn't hit a case before this check, then at this point we need to
    // add a syntax error.
    pm_parser_err_node(parser, (pm_node_t *) block, PM_ERR_ARGUMENT_UNEXPECTED_BLOCK);
}

/******************************************************************************/
/* Basic character checks                                                     */
/******************************************************************************/

/**
 * This function is used extremely frequently to lex all of the identifiers in a
 * source file, so it's important that it be as fast as possible. For this
 * reason we have the encoding_changed boolean to check if we need to go through
 * the function pointer or can just directly use the UTF-8 functions.
 */
static inline size_t
char_is_identifier_start(const pm_parser_t *parser, const uint8_t *b, ptrdiff_t n) {
    if (n <= 0) return 0;

    if (parser->encoding_changed) {
        size_t width;

        if ((width = parser->encoding->alpha_char(b, n)) != 0) {
            return width;
        } else if (*b == '_') {
            return 1;
        } else if (*b >= 0x80) {
            return parser->encoding->char_width(b, n);
        } else {
            return 0;
        }
    } else if (*b < 0x80) {
        return (pm_encoding_unicode_table[*b] & PRISM_ENCODING_ALPHABETIC_BIT ? 1 : 0) || (*b == '_');
    } else {
        return pm_encoding_utf_8_char_width(b, n);
    }
}

/**
 * Similar to char_is_identifier but this function assumes that the encoding
 * has not been changed.
 */
static inline size_t
char_is_identifier_utf8(const uint8_t *b, ptrdiff_t n) {
    if (n <= 0) {
        return 0;
    } else if (*b < 0x80) {
        return (*b == '_') || (pm_encoding_unicode_table[*b] & PRISM_ENCODING_ALPHANUMERIC_BIT ? 1 : 0);
    } else {
        return pm_encoding_utf_8_char_width(b, n);
    }
}

/**
 * Like the above, this function is also used extremely frequently to lex all of
 * the identifiers in a source file once the first character has been found. So
 * it's important that it be as fast as possible.
 */
static inline size_t
char_is_identifier(const pm_parser_t *parser, const uint8_t *b, ptrdiff_t n) {
    if (n <= 0) {
        return 0;
    } else if (parser->encoding_changed) {
        size_t width;

        if ((width = parser->encoding->alnum_char(b, n)) != 0) {
            return width;
        } else if (*b == '_') {
            return 1;
        } else if (*b >= 0x80) {
            return parser->encoding->char_width(b, n);
        } else {
            return 0;
        }
    } else {
        return char_is_identifier_utf8(b, n);
    }
}

// Here we're defining a perfect hash for the characters that are allowed in
// global names. This is used to quickly check the next character after a $ to
// see if it's a valid character for a global name.
#define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
#define PUNCT(idx) ( \
                BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
                BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
                BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
                BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
                BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
                BIT('0', idx))

const unsigned int pm_global_name_punctuation_hash[(0x7e - 0x20 + 31) / 32] = { PUNCT(0), PUNCT(1), PUNCT(2) };

#undef BIT
#undef PUNCT

static inline bool
char_is_global_name_punctuation(const uint8_t b) {
    const unsigned int i = (const unsigned int) b;
    if (i <= 0x20 || 0x7e < i) return false;

    return (pm_global_name_punctuation_hash[(i - 0x20) / 32] >> (i % 32)) & 1;
}

static inline bool
token_is_setter_name(pm_token_t *token) {
    return (
        (token->type == PM_TOKEN_BRACKET_LEFT_RIGHT_EQUAL) ||
        ((token->type == PM_TOKEN_IDENTIFIER) &&
        (token->end - token->start >= 2) &&
        (token->end[-1] == '='))
    );
}

/**
 * Returns true if the given local variable is a keyword.
 */
static bool
pm_local_is_keyword(const char *source, size_t length) {
#define KEYWORD(name) if (memcmp(source, name, length) == 0) return true

    switch (length) {
        case 2:
            switch (source[0]) {
                case 'd': KEYWORD("do"); return false;
                case 'i': KEYWORD("if"); KEYWORD("in"); return false;
                case 'o': KEYWORD("or"); return false;
                default: return false;
            }
        case 3:
            switch (source[0]) {
                case 'a': KEYWORD("and"); return false;
                case 'd': KEYWORD("def"); return false;
                case 'e': KEYWORD("end"); return false;
                case 'f': KEYWORD("for"); return false;
                case 'n': KEYWORD("nil"); KEYWORD("not"); return false;
                default: return false;
            }
        case 4:
            switch (source[0]) {
                case 'c': KEYWORD("case"); return false;
                case 'e': KEYWORD("else"); return false;
                case 'n': KEYWORD("next"); return false;
                case 'r': KEYWORD("redo"); return false;
                case 's': KEYWORD("self"); return false;
                case 't': KEYWORD("then");  KEYWORD("true"); return false;
                case 'w': KEYWORD("when"); return false;
                default: return false;
            }
        case 5:
            switch (source[0]) {
                case 'a': KEYWORD("alias"); return false;
                case 'b': KEYWORD("begin"); KEYWORD("break"); return false;
                case 'c': KEYWORD("class"); return false;
                case 'e': KEYWORD("elsif"); return false;
                case 'f': KEYWORD("false"); return false;
                case 'r': KEYWORD("retry"); return false;
                case 's': KEYWORD("super"); return false;
                case 'u': KEYWORD("undef"); KEYWORD("until"); return false;
                case 'w': KEYWORD("while"); return false;
                case 'y': KEYWORD("yield"); return false;
                default: return false;
            }
        case 6:
            switch (source[0]) {
                case 'e': KEYWORD("ensure"); return false;
                case 'm': KEYWORD("module"); return false;
                case 'r': KEYWORD("rescue"); KEYWORD("return"); return false;
                case 'u': KEYWORD("unless"); return false;
                default: return false;
            }
        case 8:
            KEYWORD("__LINE__");
            KEYWORD("__FILE__");
            return false;
        case 12:
            KEYWORD("__ENCODING__");
            return false;
        default:
            return false;
    }

#undef KEYWORD
}

/******************************************************************************/
/* Node flag handling functions                                               */
/******************************************************************************/

/**
 * Set the given flag on the given node.
 */
static inline void
pm_node_flag_set(pm_node_t *node, pm_node_flags_t flag) {
    node->flags |= flag;
}

/**
 * Remove the given flag from the given node.
 */
static inline void
pm_node_flag_unset(pm_node_t *node, pm_node_flags_t flag) {
    node->flags &= (pm_node_flags_t) ~flag;
}

/**
 * Set the repeated parameter flag on the given node.
 */
static inline void
pm_node_flag_set_repeated_parameter(pm_node_t *node) {
    assert(PM_NODE_TYPE(node) == PM_BLOCK_LOCAL_VARIABLE_NODE ||
            PM_NODE_TYPE(node) == PM_BLOCK_PARAMETER_NODE ||
            PM_NODE_TYPE(node) == PM_KEYWORD_REST_PARAMETER_NODE ||
            PM_NODE_TYPE(node) == PM_OPTIONAL_KEYWORD_PARAMETER_NODE ||
            PM_NODE_TYPE(node) == PM_OPTIONAL_PARAMETER_NODE ||
            PM_NODE_TYPE(node) == PM_REQUIRED_KEYWORD_PARAMETER_NODE ||
            PM_NODE_TYPE(node) == PM_REQUIRED_PARAMETER_NODE ||
            PM_NODE_TYPE(node) == PM_REST_PARAMETER_NODE);

    pm_node_flag_set(node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER);
}

/******************************************************************************/
/* Node creation functions                                                    */
/******************************************************************************/

/**
 * When you have an encoding flag on a regular expression, it takes precedence
 * over all of the previously set encoding flags. So we need to mask off any
 * previously set encoding flags before setting the new one.
 */
#define PM_REGULAR_EXPRESSION_ENCODING_MASK ~(PM_REGULAR_EXPRESSION_FLAGS_EUC_JP | PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT | PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J | PM_REGULAR_EXPRESSION_FLAGS_UTF_8)

/**
 * Parse out the options for a regular expression.
 */
static inline pm_node_flags_t
pm_regular_expression_flags_create(pm_parser_t *parser, const pm_token_t *closing) {
    pm_node_flags_t flags = 0;

    if (closing->type == PM_TOKEN_REGEXP_END) {
        pm_buffer_t unknown_flags = { 0 };

        for (const uint8_t *flag = closing->start + 1; flag < closing->end; flag++) {
            switch (*flag) {
                case 'i': flags |= PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE; break;
                case 'm': flags |= PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE; break;
                case 'x': flags |= PM_REGULAR_EXPRESSION_FLAGS_EXTENDED; break;
                case 'o': flags |= PM_REGULAR_EXPRESSION_FLAGS_ONCE; break;

                case 'e': flags = (pm_node_flags_t) (((pm_node_flags_t) (flags & PM_REGULAR_EXPRESSION_ENCODING_MASK)) | PM_REGULAR_EXPRESSION_FLAGS_EUC_JP); break;
                case 'n': flags = (pm_node_flags_t) (((pm_node_flags_t) (flags & PM_REGULAR_EXPRESSION_ENCODING_MASK)) | PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT); break;
                case 's': flags = (pm_node_flags_t) (((pm_node_flags_t) (flags & PM_REGULAR_EXPRESSION_ENCODING_MASK)) | PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J); break;
                case 'u': flags = (pm_node_flags_t) (((pm_node_flags_t) (flags & PM_REGULAR_EXPRESSION_ENCODING_MASK)) | PM_REGULAR_EXPRESSION_FLAGS_UTF_8); break;

                default: pm_buffer_append_byte(&unknown_flags, *flag);
            }
        }

        size_t unknown_flags_length = pm_buffer_length(&unknown_flags);
        if (unknown_flags_length != 0) {
            const char *word = unknown_flags_length >= 2 ? "options" : "option";
            PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->previous, PM_ERR_REGEXP_UNKNOWN_OPTIONS, word, unknown_flags_length, pm_buffer_value(&unknown_flags));
        }
        pm_buffer_free(&unknown_flags);
    }

    return flags;
}

#undef PM_REGULAR_EXPRESSION_ENCODING_MASK

static pm_statements_node_t *
pm_statements_node_create(pm_parser_t *parser);

static void
pm_statements_node_body_append(pm_parser_t *parser, pm_statements_node_t *node, pm_node_t *statement, bool newline);

static size_t
pm_statements_node_body_length(pm_statements_node_t *node);

/**
 * This function is here to allow us a place to extend in the future when we
 * implement our own arena allocation.
 */
static inline void *
pm_node_alloc(PRISM_ATTRIBUTE_UNUSED pm_parser_t *parser, size_t size) {
    void *memory = xcalloc(1, size);
    if (memory == NULL) {
        fprintf(stderr, "Failed to allocate %d bytes\n", (int) size);
        abort();
    }
    return memory;
}

#define PM_NODE_ALLOC(parser, type) (type *) pm_node_alloc(parser, sizeof(type))
#define PM_NODE_IDENTIFY(parser) (++parser->node_id)

/**
 * Allocate a new MissingNode node.
 */
static pm_missing_node_t *
pm_missing_node_create(pm_parser_t *parser, const uint8_t *start, const uint8_t *end) {
    pm_missing_node_t *node = PM_NODE_ALLOC(parser, pm_missing_node_t);

    *node = (pm_missing_node_t) {{
        .type = PM_MISSING_NODE,
        .node_id = PM_NODE_IDENTIFY(parser),
        .location = { .start = start, .end = end }
    }};

    return node;
}

/**
 * Allocate and initialize a new AliasGlobalVariableNode node.
 */
static pm_alias_global_variable_node_t *
pm_alias_global_variable_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *new_name, pm_node_t *old_name) {
    assert(keyword->type == PM_TOKEN_KEYWORD_ALIAS);
    pm_alias_global_variable_node_t *node = PM_NODE_ALLOC(parser, pm_alias_global_variable_node_t);

    *node = (pm_alias_global_variable_node_t) {
        {
            .type = PM_ALIAS_GLOBAL_VARIABLE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = keyword->start,
                .end = old_name->location.end
            },
        },
        .new_name = new_name,
        .old_name = old_name,
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword)
    };

    return node;
}

/**
 * Allocate and initialize a new AliasMethodNode node.
 */
static pm_alias_method_node_t *
pm_alias_method_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *new_name, pm_node_t *old_name) {
    assert(keyword->type == PM_TOKEN_KEYWORD_ALIAS);
    pm_alias_method_node_t *node = PM_NODE_ALLOC(parser, pm_alias_method_node_t);

    *node = (pm_alias_method_node_t) {
        {
            .type = PM_ALIAS_METHOD_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = keyword->start,
                .end = old_name->location.end
            },
        },
        .new_name = new_name,
        .old_name = old_name,
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword)
    };

    return node;
}

/**
 * Allocate a new AlternationPatternNode node.
 */
static pm_alternation_pattern_node_t *
pm_alternation_pattern_node_create(pm_parser_t *parser, pm_node_t *left, pm_node_t *right, const pm_token_t *operator) {
    pm_alternation_pattern_node_t *node = PM_NODE_ALLOC(parser, pm_alternation_pattern_node_t);

    *node = (pm_alternation_pattern_node_t) {
        {
            .type = PM_ALTERNATION_PATTERN_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = left->location.start,
                .end = right->location.end
            },
        },
        .left = left,
        .right = right,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator)
    };

    return node;
}

/**
 * Allocate and initialize a new and node.
 */
static pm_and_node_t *
pm_and_node_create(pm_parser_t *parser, pm_node_t *left, const pm_token_t *operator, pm_node_t *right) {
    pm_assert_value_expression(parser, left);

    pm_and_node_t *node = PM_NODE_ALLOC(parser, pm_and_node_t);

    *node = (pm_and_node_t) {
        {
            .type = PM_AND_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = left->location.start,
                .end = right->location.end
            },
        },
        .left = left,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .right = right
    };

    return node;
}

/**
 * Allocate an initialize a new arguments node.
 */
static pm_arguments_node_t *
pm_arguments_node_create(pm_parser_t *parser) {
    pm_arguments_node_t *node = PM_NODE_ALLOC(parser, pm_arguments_node_t);

    *node = (pm_arguments_node_t) {
        {
            .type = PM_ARGUMENTS_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_NULL_VALUE(parser)
        },
        .arguments = { 0 }
    };

    return node;
}

/**
 * Return the size of the given arguments node.
 */
static size_t
pm_arguments_node_size(pm_arguments_node_t *node) {
    return node->arguments.size;
}

/**
 * Append an argument to an arguments node.
 */
static void
pm_arguments_node_arguments_append(pm_arguments_node_t *node, pm_node_t *argument) {
    if (pm_arguments_node_size(node) == 0) {
        node->base.location.start = argument->location.start;
    }

    node->base.location.end = argument->location.end;
    pm_node_list_append(&node->arguments, argument);

    if (PM_NODE_TYPE_P(argument, PM_SPLAT_NODE)) {
        if (PM_NODE_FLAG_P(node, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT)) {
            pm_node_flag_set((pm_node_t *) node, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS);
        } else {
            pm_node_flag_set((pm_node_t *) node, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT);
        }
    }
}

/**
 * Allocate and initialize a new ArrayNode node.
 */
static pm_array_node_t *
pm_array_node_create(pm_parser_t *parser, const pm_token_t *opening) {
    pm_array_node_t *node = PM_NODE_ALLOC(parser, pm_array_node_t);

    *node = (pm_array_node_t) {
        {
            .type = PM_ARRAY_NODE,
            .flags = PM_NODE_FLAG_STATIC_LITERAL,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(opening)
        },
        .opening_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(opening),
        .elements = { 0 }
    };

    return node;
}

/**
 * Append an argument to an array node.
 */
static inline void
pm_array_node_elements_append(pm_array_node_t *node, pm_node_t *element) {
    if (!node->elements.size && !node->opening_loc.start) {
        node->base.location.start = element->location.start;
    }

    pm_node_list_append(&node->elements, element);
    node->base.location.end = element->location.end;

    // If the element is not a static literal, then the array is not a static
    // literal. Turn that flag off.
    if (PM_NODE_TYPE_P(element, PM_ARRAY_NODE) || PM_NODE_TYPE_P(element, PM_HASH_NODE) || PM_NODE_TYPE_P(element, PM_RANGE_NODE) || !PM_NODE_FLAG_P(element, PM_NODE_FLAG_STATIC_LITERAL)) {
        pm_node_flag_unset((pm_node_t *)node, PM_NODE_FLAG_STATIC_LITERAL);
    }

    if (PM_NODE_TYPE_P(element, PM_SPLAT_NODE)) {
        pm_node_flag_set((pm_node_t *)node, PM_ARRAY_NODE_FLAGS_CONTAINS_SPLAT);
    }
}

/**
 * Set the closing token and end location of an array node.
 */
static void
pm_array_node_close_set(pm_array_node_t *node, const pm_token_t *closing) {
    assert(closing->type == PM_TOKEN_BRACKET_RIGHT || closing->type == PM_TOKEN_STRING_END || closing->type == PM_TOKEN_MISSING || closing->type == PM_TOKEN_NOT_PROVIDED);
    node->base.location.end = closing->end;
    node->closing_loc = PM_LOCATION_TOKEN_VALUE(closing);
}

/**
 * Allocate and initialize a new array pattern node. The node list given in the
 * nodes parameter is guaranteed to have at least two nodes.
 */
static pm_array_pattern_node_t *
pm_array_pattern_node_node_list_create(pm_parser_t *parser, pm_node_list_t *nodes) {
    pm_array_pattern_node_t *node = PM_NODE_ALLOC(parser, pm_array_pattern_node_t);

    *node = (pm_array_pattern_node_t) {
        {
            .type = PM_ARRAY_PATTERN_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = nodes->nodes[0]->location.start,
                .end = nodes->nodes[nodes->size - 1]->location.end
            },
        },
        .constant = NULL,
        .rest = NULL,
        .requireds = { 0 },
        .posts = { 0 },
        .opening_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .closing_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE
    };

    // For now we're going to just copy over each pointer manually. This could be
    // much more efficient, as we could instead resize the node list.
    bool found_rest = false;
    pm_node_t *child;

    PM_NODE_LIST_FOREACH(nodes, index, child) {
        if (!found_rest && (PM_NODE_TYPE_P(child, PM_SPLAT_NODE) || PM_NODE_TYPE_P(child, PM_IMPLICIT_REST_NODE))) {
            node->rest = child;
            found_rest = true;
        } else if (found_rest) {
            pm_node_list_append(&node->posts, child);
        } else {
            pm_node_list_append(&node->requireds, child);
        }
    }

    return node;
}

/**
 * Allocate and initialize a new array pattern node from a single rest node.
 */
static pm_array_pattern_node_t *
pm_array_pattern_node_rest_create(pm_parser_t *parser, pm_node_t *rest) {
    pm_array_pattern_node_t *node = PM_NODE_ALLOC(parser, pm_array_pattern_node_t);

    *node = (pm_array_pattern_node_t) {
        {
            .type = PM_ARRAY_PATTERN_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = rest->location,
        },
        .constant = NULL,
        .rest = rest,
        .requireds = { 0 },
        .posts = { 0 },
        .opening_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .closing_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE
    };

    return node;
}

/**
 * Allocate and initialize a new array pattern node from a constant and opening
 * and closing tokens.
 */
static pm_array_pattern_node_t *
pm_array_pattern_node_constant_create(pm_parser_t *parser, pm_node_t *constant, const pm_token_t *opening, const pm_token_t *closing) {
    pm_array_pattern_node_t *node = PM_NODE_ALLOC(parser, pm_array_pattern_node_t);

    *node = (pm_array_pattern_node_t) {
        {
            .type = PM_ARRAY_PATTERN_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = constant->location.start,
                .end = closing->end
            },
        },
        .constant = constant,
        .rest = NULL,
        .opening_loc = PM_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_LOCATION_TOKEN_VALUE(closing),
        .requireds = { 0 },
        .posts = { 0 }
    };

    return node;
}

/**
 * Allocate and initialize a new array pattern node from an opening and closing
 * token.
 */
static pm_array_pattern_node_t *
pm_array_pattern_node_empty_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *closing) {
    pm_array_pattern_node_t *node = PM_NODE_ALLOC(parser, pm_array_pattern_node_t);

    *node = (pm_array_pattern_node_t) {
        {
            .type = PM_ARRAY_PATTERN_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = opening->start,
                .end = closing->end
            },
        },
        .constant = NULL,
        .rest = NULL,
        .opening_loc = PM_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_LOCATION_TOKEN_VALUE(closing),
        .requireds = { 0 },
        .posts = { 0 }
    };

    return node;
}

static inline void
pm_array_pattern_node_requireds_append(pm_array_pattern_node_t *node, pm_node_t *inner) {
    pm_node_list_append(&node->requireds, inner);
}

/**
 * Allocate and initialize a new assoc node.
 */
static pm_assoc_node_t *
pm_assoc_node_create(pm_parser_t *parser, pm_node_t *key, const pm_token_t *operator, pm_node_t *value) {
    pm_assoc_node_t *node = PM_NODE_ALLOC(parser, pm_assoc_node_t);
    const uint8_t *end;

    if (value != NULL && value->location.end > key->location.end) {
        end = value->location.end;
    } else if (operator->type != PM_TOKEN_NOT_PROVIDED) {
        end = operator->end;
    } else {
        end = key->location.end;
    }

    // Hash string keys will be frozen, so we can mark them as frozen here so
    // that the compiler picks them up and also when we check for static literal
    // on the keys it gets factored in.
    if (PM_NODE_TYPE_P(key, PM_STRING_NODE)) {
        key->flags |= PM_STRING_FLAGS_FROZEN | PM_NODE_FLAG_STATIC_LITERAL;
    }

    // If the key and value of this assoc node are both static literals, then
    // we can mark this node as a static literal.
    pm_node_flags_t flags = 0;
    if (
        !PM_NODE_TYPE_P(key, PM_ARRAY_NODE) && !PM_NODE_TYPE_P(key, PM_HASH_NODE) && !PM_NODE_TYPE_P(key, PM_RANGE_NODE) &&
        value && !PM_NODE_TYPE_P(value, PM_ARRAY_NODE) && !PM_NODE_TYPE_P(value, PM_HASH_NODE) && !PM_NODE_TYPE_P(value, PM_RANGE_NODE)
    ) {
        flags = key->flags & value->flags & PM_NODE_FLAG_STATIC_LITERAL;
    }

    *node = (pm_assoc_node_t) {
        {
            .type = PM_ASSOC_NODE,
            .flags = flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = key->location.start,
                .end = end
            },
        },
        .key = key,
        .operator_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new assoc splat node.
 */
static pm_assoc_splat_node_t *
pm_assoc_splat_node_create(pm_parser_t *parser, pm_node_t *value, const pm_token_t *operator) {
    assert(operator->type == PM_TOKEN_USTAR_STAR);
    pm_assoc_splat_node_t *node = PM_NODE_ALLOC(parser, pm_assoc_splat_node_t);

    *node = (pm_assoc_splat_node_t) {
        {
            .type = PM_ASSOC_SPLAT_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = operator->start,
                .end = value == NULL ? operator->end : value->location.end
            },
        },
        .value = value,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator)
    };

    return node;
}

/**
 * Allocate a new BackReferenceReadNode node.
 */
static pm_back_reference_read_node_t *
pm_back_reference_read_node_create(pm_parser_t *parser, const pm_token_t *name) {
    assert(name->type == PM_TOKEN_BACK_REFERENCE);
    pm_back_reference_read_node_t *node = PM_NODE_ALLOC(parser, pm_back_reference_read_node_t);

    *node = (pm_back_reference_read_node_t) {
        {
            .type = PM_BACK_REFERENCE_READ_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(name),
        },
        .name = pm_parser_constant_id_token(parser, name)
    };

    return node;
}

/**
 * Allocate and initialize new a begin node.
 */
static pm_begin_node_t *
pm_begin_node_create(pm_parser_t *parser, const pm_token_t *begin_keyword, pm_statements_node_t *statements) {
    pm_begin_node_t *node = PM_NODE_ALLOC(parser, pm_begin_node_t);

    *node = (pm_begin_node_t) {
        {
            .type = PM_BEGIN_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = begin_keyword->start,
                .end = statements == NULL ? begin_keyword->end : statements->base.location.end
            },
        },
        .begin_keyword_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(begin_keyword),
        .statements = statements,
        .end_keyword_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE
    };

    return node;
}

/**
 * Set the rescue clause, optionally start, and end location of a begin node.
 */
static void
pm_begin_node_rescue_clause_set(pm_begin_node_t *node, pm_rescue_node_t *rescue_clause) {
    // If the begin keyword doesn't exist, we set the start on the begin_node
    if (!node->begin_keyword_loc.start) {
        node->base.location.start = rescue_clause->base.location.start;
    }
    node->base.location.end = rescue_clause->base.location.end;
    node->rescue_clause = rescue_clause;
}

/**
 * Set the else clause and end location of a begin node.
 */
static void
pm_begin_node_else_clause_set(pm_begin_node_t *node, pm_else_node_t *else_clause) {
    node->base.location.end = else_clause->base.location.end;
    node->else_clause = else_clause;
}

/**
 * Set the ensure clause and end location of a begin node.
 */
static void
pm_begin_node_ensure_clause_set(pm_begin_node_t *node, pm_ensure_node_t *ensure_clause) {
    node->base.location.end = ensure_clause->base.location.end;
    node->ensure_clause = ensure_clause;
}

/**
 * Set the end keyword and end location of a begin node.
 */
static void
pm_begin_node_end_keyword_set(pm_begin_node_t *node, const pm_token_t *end_keyword) {
    assert(end_keyword->type == PM_TOKEN_KEYWORD_END || end_keyword->type == PM_TOKEN_MISSING);

    node->base.location.end = end_keyword->end;
    node->end_keyword_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(end_keyword);
}

/**
 * Allocate and initialize a new BlockArgumentNode node.
 */
static pm_block_argument_node_t *
pm_block_argument_node_create(pm_parser_t *parser, const pm_token_t *operator, pm_node_t *expression) {
    pm_block_argument_node_t *node = PM_NODE_ALLOC(parser, pm_block_argument_node_t);

    *node = (pm_block_argument_node_t) {
        {
            .type = PM_BLOCK_ARGUMENT_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = operator->start,
                .end = expression == NULL ? operator->end : expression->location.end
            },
        },
        .expression = expression,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator)
    };

    return node;
}

/**
 * Allocate and initialize a new BlockNode node.
 */
static pm_block_node_t *
pm_block_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, const pm_token_t *opening, pm_node_t *parameters, pm_node_t *body, const pm_token_t *closing) {
    pm_block_node_t *node = PM_NODE_ALLOC(parser, pm_block_node_t);

    *node = (pm_block_node_t) {
        {
            .type = PM_BLOCK_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = { .start = opening->start, .end = closing->end },
        },
        .locals = *locals,
        .parameters = parameters,
        .body = body,
        .opening_loc = PM_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_LOCATION_TOKEN_VALUE(closing)
    };

    return node;
}

/**
 * Allocate and initialize a new BlockParameterNode node.
 */
static pm_block_parameter_node_t *
pm_block_parameter_node_create(pm_parser_t *parser, const pm_token_t *name, const pm_token_t *operator) {
    assert(operator->type == PM_TOKEN_NOT_PROVIDED || operator->type == PM_TOKEN_UAMPERSAND || operator->type == PM_TOKEN_AMPERSAND);
    pm_block_parameter_node_t *node = PM_NODE_ALLOC(parser, pm_block_parameter_node_t);

    *node = (pm_block_parameter_node_t) {
        {
            .type = PM_BLOCK_PARAMETER_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = operator->start,
                .end = (name->type == PM_TOKEN_NOT_PROVIDED ? operator->end : name->end)
            },
        },
        .name = pm_parser_optional_constant_id_token(parser, name),
        .name_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(name),
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator)
    };

    return node;
}

/**
 * Allocate and initialize a new BlockParametersNode node.
 */
static pm_block_parameters_node_t *
pm_block_parameters_node_create(pm_parser_t *parser, pm_parameters_node_t *parameters, const pm_token_t *opening) {
    pm_block_parameters_node_t *node = PM_NODE_ALLOC(parser, pm_block_parameters_node_t);

    const uint8_t *start;
    if (opening->type != PM_TOKEN_NOT_PROVIDED) {
        start = opening->start;
    } else if (parameters != NULL) {
        start = parameters->base.location.start;
    } else {
        start = NULL;
    }

    const uint8_t *end;
    if (parameters != NULL) {
        end = parameters->base.location.end;
    } else if (opening->type != PM_TOKEN_NOT_PROVIDED) {
        end = opening->end;
    } else {
        end = NULL;
    }

    *node = (pm_block_parameters_node_t) {
        {
            .type = PM_BLOCK_PARAMETERS_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = start,
                .end = end
            }
        },
        .parameters = parameters,
        .opening_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .locals = { 0 }
    };

    return node;
}

/**
 * Set the closing location of a BlockParametersNode node.
 */
static void
pm_block_parameters_node_closing_set(pm_block_parameters_node_t *node, const pm_token_t *closing) {
    assert(closing->type == PM_TOKEN_PIPE || closing->type == PM_TOKEN_PARENTHESIS_RIGHT || closing->type == PM_TOKEN_MISSING);

    node->base.location.end = closing->end;
    node->closing_loc = PM_LOCATION_TOKEN_VALUE(closing);
}

/**
 * Allocate and initialize a new BlockLocalVariableNode node.
 */
static pm_block_local_variable_node_t *
pm_block_local_variable_node_create(pm_parser_t *parser, const pm_token_t *name) {
    pm_block_local_variable_node_t *node = PM_NODE_ALLOC(parser, pm_block_local_variable_node_t);

    *node = (pm_block_local_variable_node_t) {
        {
            .type = PM_BLOCK_LOCAL_VARIABLE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(name),
        },
        .name = pm_parser_constant_id_token(parser, name)
    };

    return node;
}

/**
 * Append a new block-local variable to a BlockParametersNode node.
 */
static void
pm_block_parameters_node_append_local(pm_block_parameters_node_t *node, const pm_block_local_variable_node_t *local) {
    pm_node_list_append(&node->locals, (pm_node_t *) local);

    if (node->base.location.start == NULL) node->base.location.start = local->base.location.start;
    node->base.location.end = local->base.location.end;
}

/**
 * Allocate and initialize a new BreakNode node.
 */
static pm_break_node_t *
pm_break_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_arguments_node_t *arguments) {
    assert(keyword->type == PM_TOKEN_KEYWORD_BREAK);
    pm_break_node_t *node = PM_NODE_ALLOC(parser, pm_break_node_t);

    *node = (pm_break_node_t) {
        {
            .type = PM_BREAK_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = keyword->start,
                .end = (arguments == NULL ? keyword->end : arguments->base.location.end)
            },
        },
        .arguments = arguments,
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword)
    };

    return node;
}

// There are certain flags that we want to use internally but don't want to
// expose because they are not relevant beyond parsing. Therefore we'll define
// them here and not define them in config.yml/a header file.
static const pm_node_flags_t PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY = 0x4;
static const pm_node_flags_t PM_CALL_NODE_FLAGS_IMPLICIT_ARRAY = 0x40;
static const pm_node_flags_t PM_CALL_NODE_FLAGS_COMPARISON = 0x80;
static const pm_node_flags_t PM_CALL_NODE_FLAGS_INDEX = 0x100;

/**
 * Allocate and initialize a new CallNode node. This sets everything to NULL or
 * PM_TOKEN_NOT_PROVIDED as appropriate such that its values can be overridden
 * in the various specializations of this function.
 */
static pm_call_node_t *
pm_call_node_create(pm_parser_t *parser, pm_node_flags_t flags) {
    pm_call_node_t *node = PM_NODE_ALLOC(parser, pm_call_node_t);

    *node = (pm_call_node_t) {
        {
            .type = PM_CALL_NODE,
            .flags = flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_NULL_VALUE(parser),
        },
        .receiver = NULL,
        .call_operator_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .message_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .opening_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .arguments = NULL,
        .closing_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .block = NULL,
        .name = 0
    };

    return node;
}

/**
 * Returns the value that the ignore visibility flag should be set to for the
 * given receiver.
 */
static inline pm_node_flags_t
pm_call_node_ignore_visibility_flag(const pm_node_t *receiver) {
    return PM_NODE_TYPE_P(receiver, PM_SELF_NODE) ? PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY : 0;
}

/**
 * Allocate and initialize a new CallNode node from an aref or an aset
 * expression.
 */
static pm_call_node_t *
pm_call_node_aref_create(pm_parser_t *parser, pm_node_t *receiver, pm_arguments_t *arguments) {
    pm_assert_value_expression(parser, receiver);

    pm_node_flags_t flags = pm_call_node_ignore_visibility_flag(receiver);
    if (arguments->block == NULL || PM_NODE_TYPE_P(arguments->block, PM_BLOCK_ARGUMENT_NODE)) {
        flags |= PM_CALL_NODE_FLAGS_INDEX;
    }

    pm_call_node_t *node = pm_call_node_create(parser, flags);

    node->base.location.start = receiver->location.start;
    node->base.location.end = pm_arguments_end(arguments);

    node->receiver = receiver;
    node->message_loc.start = arguments->opening_loc.start;
    node->message_loc.end = arguments->closing_loc.end;

    node->opening_loc = arguments->opening_loc;
    node->arguments = arguments->arguments;
    node->closing_loc = arguments->closing_loc;
    node->block = arguments->block;

    node->name = pm_parser_constant_id_constant(parser, "[]", 2);
    return node;
}

/**
 * Allocate and initialize a new CallNode node from a binary expression.
 */
static pm_call_node_t *
pm_call_node_binary_create(pm_parser_t *parser, pm_node_t *receiver, pm_token_t *operator, pm_node_t *argument, pm_node_flags_t flags) {
    pm_assert_value_expression(parser, receiver);
    pm_assert_value_expression(parser, argument);

    pm_call_node_t *node = pm_call_node_create(parser, pm_call_node_ignore_visibility_flag(receiver) | flags);

    node->base.location.start = MIN(receiver->location.start, argument->location.start);
    node->base.location.end = MAX(receiver->location.end, argument->location.end);

    node->receiver = receiver;
    node->message_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(operator);

    pm_arguments_node_t *arguments = pm_arguments_node_create(parser);
    pm_arguments_node_arguments_append(arguments, argument);
    node->arguments = arguments;

    node->name = pm_parser_constant_id_token(parser, operator);
    return node;
}

/**
 * Allocate and initialize a new CallNode node from a call expression.
 */
static pm_call_node_t *
pm_call_node_call_create(pm_parser_t *parser, pm_node_t *receiver, pm_token_t *operator, pm_token_t *message, pm_arguments_t *arguments) {
    pm_assert_value_expression(parser, receiver);

    pm_call_node_t *node = pm_call_node_create(parser, pm_call_node_ignore_visibility_flag(receiver));

    node->base.location.start = receiver->location.start;
    const uint8_t *end = pm_arguments_end(arguments);
    if (end == NULL) {
        end = message->end;
    }
    node->base.location.end = end;

    node->receiver = receiver;
    node->call_operator_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(operator);
    node->message_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(message);
    node->opening_loc = arguments->opening_loc;
    node->arguments = arguments->arguments;
    node->closing_loc = arguments->closing_loc;
    node->block = arguments->block;

    if (operator->type == PM_TOKEN_AMPERSAND_DOT) {
        pm_node_flag_set((pm_node_t *)node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION);
    }

    node->name = pm_parser_constant_id_token(parser, message);
    return node;
}

/**
 * Allocate and initialize a new synthesized CallNode node from a call expression.
 */
static pm_call_node_t *
pm_call_node_call_synthesized_create(pm_parser_t *parser, pm_node_t *receiver, const char *message, pm_arguments_node_t *arguments) {
    pm_call_node_t *node = pm_call_node_create(parser, 0);
    node->base.location.start = parser->start;
    node->base.location.end = parser->end;

    node->receiver = receiver;
    node->call_operator_loc = (pm_location_t) { .start = NULL, .end = NULL };
    node->message_loc = (pm_location_t) { .start = NULL, .end = NULL };
    node->arguments = arguments;

    node->name = pm_parser_constant_id_constant(parser, message, strlen(message));
    return node;
}

/**
 * Allocate and initialize a new CallNode node from a call to a method name
 * without a receiver that could not have been a local variable read.
 */
static pm_call_node_t *
pm_call_node_fcall_create(pm_parser_t *parser, pm_token_t *message, pm_arguments_t *arguments) {
    pm_call_node_t *node = pm_call_node_create(parser, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY);

    node->base.location.start = message->start;
    node->base.location.end = pm_arguments_end(arguments);

    node->message_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(message);
    node->opening_loc = arguments->opening_loc;
    node->arguments = arguments->arguments;
    node->closing_loc = arguments->closing_loc;
    node->block = arguments->block;

    node->name = pm_parser_constant_id_token(parser, message);
    return node;
}

/**
 * Allocate and initialize a new CallNode node from a synthesized call to a
 * method name with the given arguments.
 */
static pm_call_node_t *
pm_call_node_fcall_synthesized_create(pm_parser_t *parser, pm_arguments_node_t *arguments, pm_constant_id_t name) {
    pm_call_node_t *node = pm_call_node_create(parser, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY);

    node->base.location = PM_LOCATION_NULL_VALUE(parser);
    node->arguments = arguments;

    node->name = name;
    return node;
}

/**
 * Allocate and initialize a new CallNode node from a not expression.
 */
static pm_call_node_t *
pm_call_node_not_create(pm_parser_t *parser, pm_node_t *receiver, pm_token_t *message, pm_arguments_t *arguments) {
    pm_assert_value_expression(parser, receiver);
    if (receiver != NULL) pm_conditional_predicate(parser, receiver, PM_CONDITIONAL_PREDICATE_TYPE_NOT);

    pm_call_node_t *node = pm_call_node_create(parser, receiver == NULL ? 0 : pm_call_node_ignore_visibility_flag(receiver));

    node->base.location.start = message->start;
    if (arguments->closing_loc.start != NULL) {
        node->base.location.end = arguments->closing_loc.end;
    } else {
        assert(receiver != NULL);
        node->base.location.end = receiver->location.end;
    }

    node->receiver = receiver;
    node->message_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(message);
    node->opening_loc = arguments->opening_loc;
    node->arguments = arguments->arguments;
    node->closing_loc = arguments->closing_loc;

    node->name = pm_parser_constant_id_constant(parser, "!", 1);
    return node;
}

/**
 * Allocate and initialize a new CallNode node from a call shorthand expression.
 */
static pm_call_node_t *
pm_call_node_shorthand_create(pm_parser_t *parser, pm_node_t *receiver, pm_token_t *operator, pm_arguments_t *arguments) {
    pm_assert_value_expression(parser, receiver);

    pm_call_node_t *node = pm_call_node_create(parser, pm_call_node_ignore_visibility_flag(receiver));

    node->base.location.start = receiver->location.start;
    node->base.location.end = pm_arguments_end(arguments);

    node->receiver = receiver;
    node->call_operator_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(operator);
    node->opening_loc = arguments->opening_loc;
    node->arguments = arguments->arguments;
    node->closing_loc = arguments->closing_loc;
    node->block = arguments->block;

    if (operator->type == PM_TOKEN_AMPERSAND_DOT) {
        pm_node_flag_set((pm_node_t *)node, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION);
    }

    node->name = pm_parser_constant_id_constant(parser, "call", 4);
    return node;
}

/**
 * Allocate and initialize a new CallNode node from a unary operator expression.
 */
static pm_call_node_t *
pm_call_node_unary_create(pm_parser_t *parser, pm_token_t *operator, pm_node_t *receiver, const char *name) {
    pm_assert_value_expression(parser, receiver);

    pm_call_node_t *node = pm_call_node_create(parser, pm_call_node_ignore_visibility_flag(receiver));

    node->base.location.start = operator->start;
    node->base.location.end = receiver->location.end;

    node->receiver = receiver;
    node->message_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(operator);

    node->name = pm_parser_constant_id_constant(parser, name, strlen(name));
    return node;
}

/**
 * Allocate and initialize a new CallNode node from a call to a method name
 * without a receiver that could also have been a local variable read.
 */
static pm_call_node_t *
pm_call_node_variable_call_create(pm_parser_t *parser, pm_token_t *message) {
    pm_call_node_t *node = pm_call_node_create(parser, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY);

    node->base.location = PM_LOCATION_TOKEN_VALUE(message);
    node->message_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(message);

    node->name = pm_parser_constant_id_token(parser, message);
    return node;
}

/**
 * Returns whether or not this call can be used on the left-hand side of an
 * operator assignment.
 */
static inline bool
pm_call_node_writable_p(const pm_parser_t *parser, const pm_call_node_t *node) {
    return (
        (node->message_loc.start != NULL) &&
        (node->message_loc.end[-1] != '!') &&
        (node->message_loc.end[-1] != '?') &&
        char_is_identifier_start(parser, node->message_loc.start, parser->end - node->message_loc.start) &&
        (node->opening_loc.start == NULL) &&
        (node->arguments == NULL) &&
        (node->block == NULL)
    );
}

/**
 * Initialize the read name by reading the write name and chopping off the '='.
 */
static void
pm_call_write_read_name_init(pm_parser_t *parser, pm_constant_id_t *read_name, pm_constant_id_t *write_name) {
    pm_constant_t *write_constant = pm_constant_pool_id_to_constant(&parser->constant_pool, *write_name);

    if (write_constant->length > 0) {
        size_t length = write_constant->length - 1;

        void *memory = xmalloc(length);
        memcpy(memory, write_constant->start, length);

        *read_name = pm_constant_pool_insert_owned(&parser->constant_pool, (uint8_t *) memory, length);
    } else {
        // We can get here if the message was missing because of a syntax error.
        *read_name = pm_parser_constant_id_constant(parser, "", 0);
    }
}

/**
 * Allocate and initialize a new CallAndWriteNode node.
 */
static pm_call_and_write_node_t *
pm_call_and_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(target->block == NULL);
    assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
    pm_call_and_write_node_t *node = PM_NODE_ALLOC(parser, pm_call_and_write_node_t);

    *node = (pm_call_and_write_node_t) {
        {
            .type = PM_CALL_AND_WRITE_NODE,
            .flags = target->base.flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .receiver = target->receiver,
        .call_operator_loc = target->call_operator_loc,
        .message_loc = target->message_loc,
        .read_name = 0,
        .write_name = target->name,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    pm_call_write_read_name_init(parser, &node->read_name, &node->write_name);

    // Here we're going to free the target, since it is no longer necessary.
    // However, we don't want to call `pm_node_destroy` because we want to keep
    // around all of its children since we just reused them.
    xfree(target);

    return node;
}

/**
 * Validate that index expressions do not have keywords or blocks if we are
 * parsing as Ruby 3.4+.
 */
static void
pm_index_arguments_check(pm_parser_t *parser, const pm_arguments_node_t *arguments, const pm_node_t *block) {
    if (parser->version >= PM_OPTIONS_VERSION_CRUBY_3_4) {
        if (arguments != NULL && PM_NODE_FLAG_P(arguments, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS)) {
            pm_node_t *node;
            PM_NODE_LIST_FOREACH(&arguments->arguments, index, node) {
                if (PM_NODE_TYPE_P(node, PM_KEYWORD_HASH_NODE)) {
                    pm_parser_err_node(parser, node, PM_ERR_UNEXPECTED_INDEX_KEYWORDS);
                    break;
                }
            }
        }

        if (block != NULL) {
            pm_parser_err_node(parser, block, PM_ERR_UNEXPECTED_INDEX_BLOCK);
        }
    }
}

/**
 * Allocate and initialize a new IndexAndWriteNode node.
 */
static pm_index_and_write_node_t *
pm_index_and_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
    pm_index_and_write_node_t *node = PM_NODE_ALLOC(parser, pm_index_and_write_node_t);

    pm_index_arguments_check(parser, target->arguments, target->block);

    assert(!target->block || PM_NODE_TYPE_P(target->block, PM_BLOCK_ARGUMENT_NODE));
    *node = (pm_index_and_write_node_t) {
        {
            .type = PM_INDEX_AND_WRITE_NODE,
            .flags = target->base.flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .receiver = target->receiver,
        .call_operator_loc = target->call_operator_loc,
        .opening_loc = target->opening_loc,
        .arguments = target->arguments,
        .closing_loc = target->closing_loc,
        .block = (pm_block_argument_node_t *) target->block,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    // Here we're going to free the target, since it is no longer necessary.
    // However, we don't want to call `pm_node_destroy` because we want to keep
    // around all of its children since we just reused them.
    xfree(target);

    return node;
}

/**
 * Allocate a new CallOperatorWriteNode node.
 */
static pm_call_operator_write_node_t *
pm_call_operator_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(target->block == NULL);
    pm_call_operator_write_node_t *node = PM_NODE_ALLOC(parser, pm_call_operator_write_node_t);

    *node = (pm_call_operator_write_node_t) {
        {
            .type = PM_CALL_OPERATOR_WRITE_NODE,
            .flags = target->base.flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .receiver = target->receiver,
        .call_operator_loc = target->call_operator_loc,
        .message_loc = target->message_loc,
        .read_name = 0,
        .write_name = target->name,
        .binary_operator = pm_parser_constant_id_location(parser, operator->start, operator->end - 1),
        .binary_operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    pm_call_write_read_name_init(parser, &node->read_name, &node->write_name);

    // Here we're going to free the target, since it is no longer necessary.
    // However, we don't want to call `pm_node_destroy` because we want to keep
    // around all of its children since we just reused them.
    xfree(target);

    return node;
}

/**
 * Allocate a new IndexOperatorWriteNode node.
 */
static pm_index_operator_write_node_t *
pm_index_operator_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    pm_index_operator_write_node_t *node = PM_NODE_ALLOC(parser, pm_index_operator_write_node_t);

    pm_index_arguments_check(parser, target->arguments, target->block);

    assert(!target->block || PM_NODE_TYPE_P(target->block, PM_BLOCK_ARGUMENT_NODE));
    *node = (pm_index_operator_write_node_t) {
        {
            .type = PM_INDEX_OPERATOR_WRITE_NODE,
            .flags = target->base.flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .receiver = target->receiver,
        .call_operator_loc = target->call_operator_loc,
        .opening_loc = target->opening_loc,
        .arguments = target->arguments,
        .closing_loc = target->closing_loc,
        .block = (pm_block_argument_node_t *) target->block,
        .binary_operator = pm_parser_constant_id_location(parser, operator->start, operator->end - 1),
        .binary_operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    // Here we're going to free the target, since it is no longer necessary.
    // However, we don't want to call `pm_node_destroy` because we want to keep
    // around all of its children since we just reused them.
    xfree(target);

    return node;
}

/**
 * Allocate and initialize a new CallOrWriteNode node.
 */
static pm_call_or_write_node_t *
pm_call_or_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(target->block == NULL);
    assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
    pm_call_or_write_node_t *node = PM_NODE_ALLOC(parser, pm_call_or_write_node_t);

    *node = (pm_call_or_write_node_t) {
        {
            .type = PM_CALL_OR_WRITE_NODE,
            .flags = target->base.flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .receiver = target->receiver,
        .call_operator_loc = target->call_operator_loc,
        .message_loc = target->message_loc,
        .read_name = 0,
        .write_name = target->name,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    pm_call_write_read_name_init(parser, &node->read_name, &node->write_name);

    // Here we're going to free the target, since it is no longer necessary.
    // However, we don't want to call `pm_node_destroy` because we want to keep
    // around all of its children since we just reused them.
    xfree(target);

    return node;
}

/**
 * Allocate and initialize a new IndexOrWriteNode node.
 */
static pm_index_or_write_node_t *
pm_index_or_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
    pm_index_or_write_node_t *node = PM_NODE_ALLOC(parser, pm_index_or_write_node_t);

    pm_index_arguments_check(parser, target->arguments, target->block);

    assert(!target->block || PM_NODE_TYPE_P(target->block, PM_BLOCK_ARGUMENT_NODE));
    *node = (pm_index_or_write_node_t) {
        {
            .type = PM_INDEX_OR_WRITE_NODE,
            .flags = target->base.flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .receiver = target->receiver,
        .call_operator_loc = target->call_operator_loc,
        .opening_loc = target->opening_loc,
        .arguments = target->arguments,
        .closing_loc = target->closing_loc,
        .block = (pm_block_argument_node_t *) target->block,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    // Here we're going to free the target, since it is no longer necessary.
    // However, we don't want to call `pm_node_destroy` because we want to keep
    // around all of its children since we just reused them.
    xfree(target);

    return node;
}

/**
 * Allocate and initialize a new CallTargetNode node from an existing call
 * node.
 */
static pm_call_target_node_t *
pm_call_target_node_create(pm_parser_t *parser, pm_call_node_t *target) {
    pm_call_target_node_t *node = PM_NODE_ALLOC(parser, pm_call_target_node_t);

    *node = (pm_call_target_node_t) {
        {
            .type = PM_CALL_TARGET_NODE,
            .flags = target->base.flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = target->base.location
        },
        .receiver = target->receiver,
        .call_operator_loc = target->call_operator_loc,
        .name = target->name,
        .message_loc = target->message_loc
    };

    // Here we're going to free the target, since it is no longer necessary.
    // However, we don't want to call `pm_node_destroy` because we want to keep
    // around all of its children since we just reused them.
    xfree(target);

    return node;
}

/**
 * Allocate and initialize a new IndexTargetNode node from an existing call
 * node.
 */
static pm_index_target_node_t *
pm_index_target_node_create(pm_parser_t *parser, pm_call_node_t *target) {
    pm_index_target_node_t *node = PM_NODE_ALLOC(parser, pm_index_target_node_t);
    pm_node_flags_t flags = target->base.flags;

    pm_index_arguments_check(parser, target->arguments, target->block);

    assert(!target->block || PM_NODE_TYPE_P(target->block, PM_BLOCK_ARGUMENT_NODE));
    *node = (pm_index_target_node_t) {
        {
            .type = PM_INDEX_TARGET_NODE,
            .flags = flags | PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = target->base.location
        },
        .receiver = target->receiver,
        .opening_loc = target->opening_loc,
        .arguments = target->arguments,
        .closing_loc = target->closing_loc,
        .block = (pm_block_argument_node_t *) target->block,
    };

    // Here we're going to free the target, since it is no longer necessary.
    // However, we don't want to call `pm_node_destroy` because we want to keep
    // around all of its children since we just reused them.
    xfree(target);

    return node;
}

/**
 * Allocate and initialize a new CapturePatternNode node.
 */
static pm_capture_pattern_node_t *
pm_capture_pattern_node_create(pm_parser_t *parser, pm_node_t *value, pm_local_variable_target_node_t *target, const pm_token_t *operator) {
    pm_capture_pattern_node_t *node = PM_NODE_ALLOC(parser, pm_capture_pattern_node_t);

    *node = (pm_capture_pattern_node_t) {
        {
            .type = PM_CAPTURE_PATTERN_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = value->location.start,
                .end = target->base.location.end
            },
        },
        .value = value,
        .target = target,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator)
    };

    return node;
}

/**
 * Allocate and initialize a new CaseNode node.
 */
static pm_case_node_t *
pm_case_node_create(pm_parser_t *parser, const pm_token_t *case_keyword, pm_node_t *predicate, const pm_token_t *end_keyword) {
    pm_case_node_t *node = PM_NODE_ALLOC(parser, pm_case_node_t);

    *node = (pm_case_node_t) {
        {
            .type = PM_CASE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = case_keyword->start,
                .end = end_keyword->end
            },
        },
        .predicate = predicate,
        .else_clause = NULL,
        .case_keyword_loc = PM_LOCATION_TOKEN_VALUE(case_keyword),
        .end_keyword_loc = PM_LOCATION_TOKEN_VALUE(end_keyword),
        .conditions = { 0 }
    };

    return node;
}

/**
 * Append a new condition to a CaseNode node.
 */
static void
pm_case_node_condition_append(pm_case_node_t *node, pm_node_t *condition) {
    assert(PM_NODE_TYPE_P(condition, PM_WHEN_NODE));

    pm_node_list_append(&node->conditions, condition);
    node->base.location.end = condition->location.end;
}

/**
 * Set the else clause of a CaseNode node.
 */
static void
pm_case_node_else_clause_set(pm_case_node_t *node, pm_else_node_t *else_clause) {
    node->else_clause = else_clause;
    node->base.location.end = else_clause->base.location.end;
}

/**
 * Set the end location for a CaseNode node.
 */
static void
pm_case_node_end_keyword_loc_set(pm_case_node_t *node, const pm_token_t *end_keyword) {
    node->base.location.end = end_keyword->end;
    node->end_keyword_loc = PM_LOCATION_TOKEN_VALUE(end_keyword);
}

/**
 * Allocate and initialize a new CaseMatchNode node.
 */
static pm_case_match_node_t *
pm_case_match_node_create(pm_parser_t *parser, const pm_token_t *case_keyword, pm_node_t *predicate, const pm_token_t *end_keyword) {
    pm_case_match_node_t *node = PM_NODE_ALLOC(parser, pm_case_match_node_t);

    *node = (pm_case_match_node_t) {
        {
            .type = PM_CASE_MATCH_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = case_keyword->start,
                .end = end_keyword->end
            },
        },
        .predicate = predicate,
        .else_clause = NULL,
        .case_keyword_loc = PM_LOCATION_TOKEN_VALUE(case_keyword),
        .end_keyword_loc = PM_LOCATION_TOKEN_VALUE(end_keyword),
        .conditions = { 0 }
    };

    return node;
}

/**
 * Append a new condition to a CaseMatchNode node.
 */
static void
pm_case_match_node_condition_append(pm_case_match_node_t *node, pm_node_t *condition) {
    assert(PM_NODE_TYPE_P(condition, PM_IN_NODE));

    pm_node_list_append(&node->conditions, condition);
    node->base.location.end = condition->location.end;
}

/**
 * Set the else clause of a CaseMatchNode node.
 */
static void
pm_case_match_node_else_clause_set(pm_case_match_node_t *node, pm_else_node_t *else_clause) {
    node->else_clause = else_clause;
    node->base.location.end = else_clause->base.location.end;
}

/**
 * Set the end location for a CaseMatchNode node.
 */
static void
pm_case_match_node_end_keyword_loc_set(pm_case_match_node_t *node, const pm_token_t *end_keyword) {
    node->base.location.end = end_keyword->end;
    node->end_keyword_loc = PM_LOCATION_TOKEN_VALUE(end_keyword);
}

/**
 * Allocate a new ClassNode node.
 */
static pm_class_node_t *
pm_class_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, const pm_token_t *class_keyword, pm_node_t *constant_path, const pm_token_t *name, const pm_token_t *inheritance_operator, pm_node_t *superclass, pm_node_t *body, const pm_token_t *end_keyword) {
    pm_class_node_t *node = PM_NODE_ALLOC(parser, pm_class_node_t);

    *node = (pm_class_node_t) {
        {
            .type = PM_CLASS_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = { .start = class_keyword->start, .end = end_keyword->end },
        },
        .locals = *locals,
        .class_keyword_loc = PM_LOCATION_TOKEN_VALUE(class_keyword),
        .constant_path = constant_path,
        .inheritance_operator_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(inheritance_operator),
        .superclass = superclass,
        .body = body,
        .end_keyword_loc = PM_LOCATION_TOKEN_VALUE(end_keyword),
        .name = pm_parser_constant_id_token(parser, name)
    };

    return node;
}

/**
 * Allocate and initialize a new ClassVariableAndWriteNode node.
 */
static pm_class_variable_and_write_node_t *
pm_class_variable_and_write_node_create(pm_parser_t *parser, pm_class_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
    pm_class_variable_and_write_node_t *node = PM_NODE_ALLOC(parser, pm_class_variable_and_write_node_t);

    *node = (pm_class_variable_and_write_node_t) {
        {
            .type = PM_CLASS_VARIABLE_AND_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .name = target->name,
        .name_loc = target->base.location,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new ClassVariableOperatorWriteNode node.
 */
static pm_class_variable_operator_write_node_t *
pm_class_variable_operator_write_node_create(pm_parser_t *parser, pm_class_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    pm_class_variable_operator_write_node_t *node = PM_NODE_ALLOC(parser, pm_class_variable_operator_write_node_t);

    *node = (pm_class_variable_operator_write_node_t) {
        {
            .type = PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .name = target->name,
        .name_loc = target->base.location,
        .binary_operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value,
        .binary_operator = pm_parser_constant_id_location(parser, operator->start, operator->end - 1)
    };

    return node;
}

/**
 * Allocate and initialize a new ClassVariableOrWriteNode node.
 */
static pm_class_variable_or_write_node_t *
pm_class_variable_or_write_node_create(pm_parser_t *parser, pm_class_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
    pm_class_variable_or_write_node_t *node = PM_NODE_ALLOC(parser, pm_class_variable_or_write_node_t);

    *node = (pm_class_variable_or_write_node_t) {
        {
            .type = PM_CLASS_VARIABLE_OR_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .name = target->name,
        .name_loc = target->base.location,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new ClassVariableReadNode node.
 */
static pm_class_variable_read_node_t *
pm_class_variable_read_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_CLASS_VARIABLE);
    pm_class_variable_read_node_t *node = PM_NODE_ALLOC(parser, pm_class_variable_read_node_t);

    *node = (pm_class_variable_read_node_t) {
        {
            .type = PM_CLASS_VARIABLE_READ_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(token)
        },
        .name = pm_parser_constant_id_token(parser, token)
    };

    return node;
}

/**
 * True if the given node is an implicit array node on a write, as in:
 *
 *     a = *b
 *     a = 1, 2, 3
 */
static inline pm_node_flags_t
pm_implicit_array_write_flags(const pm_node_t *node, pm_node_flags_t flags) {
    if (PM_NODE_TYPE_P(node, PM_ARRAY_NODE) && ((const pm_array_node_t *) node)->opening_loc.start == NULL) {
        return flags;
    }
    return 0;
}

/**
 * Initialize a new ClassVariableWriteNode node from a ClassVariableRead node.
 */
static pm_class_variable_write_node_t *
pm_class_variable_write_node_create(pm_parser_t *parser, pm_class_variable_read_node_t *read_node, pm_token_t *operator, pm_node_t *value) {
    pm_class_variable_write_node_t *node = PM_NODE_ALLOC(parser, pm_class_variable_write_node_t);

    *node = (pm_class_variable_write_node_t) {
        {
            .type = PM_CLASS_VARIABLE_WRITE_NODE,
            .flags = pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = read_node->base.location.start,
                .end = value->location.end
            },
        },
        .name = read_node->name,
        .name_loc = PM_LOCATION_NODE_VALUE((pm_node_t *) read_node),
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new ConstantPathAndWriteNode node.
 */
static pm_constant_path_and_write_node_t *
pm_constant_path_and_write_node_create(pm_parser_t *parser, pm_constant_path_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
    pm_constant_path_and_write_node_t *node = PM_NODE_ALLOC(parser, pm_constant_path_and_write_node_t);

    *node = (pm_constant_path_and_write_node_t) {
        {
            .type = PM_CONSTANT_PATH_AND_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .target = target,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new ConstantPathOperatorWriteNode node.
 */
static pm_constant_path_operator_write_node_t *
pm_constant_path_operator_write_node_create(pm_parser_t *parser, pm_constant_path_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    pm_constant_path_operator_write_node_t *node = PM_NODE_ALLOC(parser, pm_constant_path_operator_write_node_t);

    *node = (pm_constant_path_operator_write_node_t) {
        {
            .type = PM_CONSTANT_PATH_OPERATOR_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .target = target,
        .binary_operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value,
        .binary_operator = pm_parser_constant_id_location(parser, operator->start, operator->end - 1)
    };

    return node;
}

/**
 * Allocate and initialize a new ConstantPathOrWriteNode node.
 */
static pm_constant_path_or_write_node_t *
pm_constant_path_or_write_node_create(pm_parser_t *parser, pm_constant_path_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
    pm_constant_path_or_write_node_t *node = PM_NODE_ALLOC(parser, pm_constant_path_or_write_node_t);

    *node = (pm_constant_path_or_write_node_t) {
        {
            .type = PM_CONSTANT_PATH_OR_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .target = target,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new ConstantPathNode node.
 */
static pm_constant_path_node_t *
pm_constant_path_node_create(pm_parser_t *parser, pm_node_t *parent, const pm_token_t *delimiter, const pm_token_t *name_token) {
    pm_assert_value_expression(parser, parent);
    pm_constant_path_node_t *node = PM_NODE_ALLOC(parser, pm_constant_path_node_t);

    pm_constant_id_t name = PM_CONSTANT_ID_UNSET;
    if (name_token->type == PM_TOKEN_CONSTANT) {
        name = pm_parser_constant_id_token(parser, name_token);
    }

    *node = (pm_constant_path_node_t) {
        {
            .type = PM_CONSTANT_PATH_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = parent == NULL ? delimiter->start : parent->location.start,
                .end = name_token->end
            },
        },
        .parent = parent,
        .name = name,
        .delimiter_loc = PM_LOCATION_TOKEN_VALUE(delimiter),
        .name_loc = PM_LOCATION_TOKEN_VALUE(name_token)
    };

    return node;
}

/**
 * Allocate a new ConstantPathWriteNode node.
 */
static pm_constant_path_write_node_t *
pm_constant_path_write_node_create(pm_parser_t *parser, pm_constant_path_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    pm_constant_path_write_node_t *node = PM_NODE_ALLOC(parser, pm_constant_path_write_node_t);

    *node = (pm_constant_path_write_node_t) {
        {
            .type = PM_CONSTANT_PATH_WRITE_NODE,
            .flags = pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            },
        },
        .target = target,
        .operator_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new ConstantAndWriteNode node.
 */
static pm_constant_and_write_node_t *
pm_constant_and_write_node_create(pm_parser_t *parser, pm_constant_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
    pm_constant_and_write_node_t *node = PM_NODE_ALLOC(parser, pm_constant_and_write_node_t);

    *node = (pm_constant_and_write_node_t) {
        {
            .type = PM_CONSTANT_AND_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .name = target->name,
        .name_loc = target->base.location,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new ConstantOperatorWriteNode node.
 */
static pm_constant_operator_write_node_t *
pm_constant_operator_write_node_create(pm_parser_t *parser, pm_constant_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    pm_constant_operator_write_node_t *node = PM_NODE_ALLOC(parser, pm_constant_operator_write_node_t);

    *node = (pm_constant_operator_write_node_t) {
        {
            .type = PM_CONSTANT_OPERATOR_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .name = target->name,
        .name_loc = target->base.location,
        .binary_operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value,
        .binary_operator = pm_parser_constant_id_location(parser, operator->start, operator->end - 1)
    };

    return node;
}

/**
 * Allocate and initialize a new ConstantOrWriteNode node.
 */
static pm_constant_or_write_node_t *
pm_constant_or_write_node_create(pm_parser_t *parser, pm_constant_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
    pm_constant_or_write_node_t *node = PM_NODE_ALLOC(parser, pm_constant_or_write_node_t);

    *node = (pm_constant_or_write_node_t) {
        {
            .type = PM_CONSTANT_OR_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .name = target->name,
        .name_loc = target->base.location,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new ConstantReadNode node.
 */
static pm_constant_read_node_t *
pm_constant_read_node_create(pm_parser_t *parser, const pm_token_t *name) {
    assert(name->type == PM_TOKEN_CONSTANT || name->type == PM_TOKEN_MISSING);
    pm_constant_read_node_t *node = PM_NODE_ALLOC(parser, pm_constant_read_node_t);

    *node = (pm_constant_read_node_t) {
        {
            .type = PM_CONSTANT_READ_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(name)
        },
        .name = pm_parser_constant_id_token(parser, name)
    };

    return node;
}

/**
 * Allocate a new ConstantWriteNode node.
 */
static pm_constant_write_node_t *
pm_constant_write_node_create(pm_parser_t *parser, pm_constant_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    pm_constant_write_node_t *node = PM_NODE_ALLOC(parser, pm_constant_write_node_t);

    *node = (pm_constant_write_node_t) {
        {
            .type = PM_CONSTANT_WRITE_NODE,
            .flags = pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .name = target->name,
        .name_loc = target->base.location,
        .operator_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Check if the receiver of a `def` node is allowed.
 */
static void
pm_def_node_receiver_check(pm_parser_t *parser, const pm_node_t *node) {
    switch (PM_NODE_TYPE(node)) {
        case PM_BEGIN_NODE: {
            const pm_begin_node_t *cast = (pm_begin_node_t *) node;
            if (cast->statements != NULL) pm_def_node_receiver_check(parser, (pm_node_t *) cast->statements);
            break;
        }
        case PM_PARENTHESES_NODE: {
            const pm_parentheses_node_t *cast = (const pm_parentheses_node_t *) node;
            if (cast->body != NULL) pm_def_node_receiver_check(parser, cast->body);
            break;
        }
        case PM_STATEMENTS_NODE: {
            const pm_statements_node_t *cast = (const pm_statements_node_t *) node;
            pm_def_node_receiver_check(parser, cast->body.nodes[cast->body.size - 1]);
            break;
        }
        case PM_ARRAY_NODE:
        case PM_FLOAT_NODE:
        case PM_IMAGINARY_NODE:
        case PM_INTEGER_NODE:
        case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE:
        case PM_INTERPOLATED_STRING_NODE:
        case PM_INTERPOLATED_SYMBOL_NODE:
        case PM_INTERPOLATED_X_STRING_NODE:
        case PM_RATIONAL_NODE:
        case PM_REGULAR_EXPRESSION_NODE:
        case PM_SOURCE_ENCODING_NODE:
        case PM_SOURCE_FILE_NODE:
        case PM_SOURCE_LINE_NODE:
        case PM_STRING_NODE:
        case PM_SYMBOL_NODE:
        case PM_X_STRING_NODE:
            pm_parser_err_node(parser, node, PM_ERR_SINGLETON_FOR_LITERALS);
            break;
        default:
            break;
    }
}

/**
 * Allocate and initialize a new DefNode node.
 */
static pm_def_node_t *
pm_def_node_create(
    pm_parser_t *parser,
    pm_constant_id_t name,
    const pm_token_t *name_loc,
    pm_node_t *receiver,
    pm_parameters_node_t *parameters,
    pm_node_t *body,
    pm_constant_id_list_t *locals,
    const pm_token_t *def_keyword,
    const pm_token_t *operator,
    const pm_token_t *lparen,
    const pm_token_t *rparen,
    const pm_token_t *equal,
    const pm_token_t *end_keyword
) {
    pm_def_node_t *node = PM_NODE_ALLOC(parser, pm_def_node_t);
    const uint8_t *end;

    if (end_keyword->type == PM_TOKEN_NOT_PROVIDED) {
        end = body->location.end;
    } else {
        end = end_keyword->end;
    }

    if (receiver != NULL) {
        pm_def_node_receiver_check(parser, receiver);
    }

    *node = (pm_def_node_t) {
        {
            .type = PM_DEF_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = { .start = def_keyword->start, .end = end },
        },
        .name = name,
        .name_loc = PM_LOCATION_TOKEN_VALUE(name_loc),
        .receiver = receiver,
        .parameters = parameters,
        .body = body,
        .locals = *locals,
        .def_keyword_loc = PM_LOCATION_TOKEN_VALUE(def_keyword),
        .operator_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(operator),
        .lparen_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(lparen),
        .rparen_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(rparen),
        .equal_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(equal),
        .end_keyword_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(end_keyword)
    };

    return node;
}

/**
 * Allocate a new DefinedNode node.
 */
static pm_defined_node_t *
pm_defined_node_create(pm_parser_t *parser, const pm_token_t *lparen, pm_node_t *value, const pm_token_t *rparen, const pm_location_t *keyword_loc) {
    pm_defined_node_t *node = PM_NODE_ALLOC(parser, pm_defined_node_t);

    *node = (pm_defined_node_t) {
        {
            .type = PM_DEFINED_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = keyword_loc->start,
                .end = (rparen->type == PM_TOKEN_NOT_PROVIDED ? value->location.end : rparen->end)
            },
        },
        .lparen_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(lparen),
        .value = value,
        .rparen_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(rparen),
        .keyword_loc = *keyword_loc
    };

    return node;
}

/**
 * Allocate and initialize a new ElseNode node.
 */
static pm_else_node_t *
pm_else_node_create(pm_parser_t *parser, const pm_token_t *else_keyword, pm_statements_node_t *statements, const pm_token_t *end_keyword) {
    pm_else_node_t *node = PM_NODE_ALLOC(parser, pm_else_node_t);
    const uint8_t *end = NULL;
    if ((end_keyword->type == PM_TOKEN_NOT_PROVIDED) && (statements != NULL)) {
        end = statements->base.location.end;
    } else {
        end = end_keyword->end;
    }

    *node = (pm_else_node_t) {
        {
            .type = PM_ELSE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = else_keyword->start,
                .end = end,
            },
        },
        .else_keyword_loc = PM_LOCATION_TOKEN_VALUE(else_keyword),
        .statements = statements,
        .end_keyword_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(end_keyword)
    };

    return node;
}

/**
 * Allocate and initialize a new EmbeddedStatementsNode node.
 */
static pm_embedded_statements_node_t *
pm_embedded_statements_node_create(pm_parser_t *parser, const pm_token_t *opening, pm_statements_node_t *statements, const pm_token_t *closing) {
    pm_embedded_statements_node_t *node = PM_NODE_ALLOC(parser, pm_embedded_statements_node_t);

    *node = (pm_embedded_statements_node_t) {
        {
            .type = PM_EMBEDDED_STATEMENTS_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = opening->start,
                .end = closing->end
            }
        },
        .opening_loc = PM_LOCATION_TOKEN_VALUE(opening),
        .statements = statements,
        .closing_loc = PM_LOCATION_TOKEN_VALUE(closing)
    };

    return node;
}

/**
 * Allocate and initialize a new EmbeddedVariableNode node.
 */
static pm_embedded_variable_node_t *
pm_embedded_variable_node_create(pm_parser_t *parser, const pm_token_t *operator, pm_node_t *variable) {
    pm_embedded_variable_node_t *node = PM_NODE_ALLOC(parser, pm_embedded_variable_node_t);

    *node = (pm_embedded_variable_node_t) {
        {
            .type = PM_EMBEDDED_VARIABLE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = operator->start,
                .end = variable->location.end
            }
        },
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .variable = variable
    };

    return node;
}

/**
 * Allocate a new EnsureNode node.
 */
static pm_ensure_node_t *
pm_ensure_node_create(pm_parser_t *parser, const pm_token_t *ensure_keyword, pm_statements_node_t *statements, const pm_token_t *end_keyword) {
    pm_ensure_node_t *node = PM_NODE_ALLOC(parser, pm_ensure_node_t);

    *node = (pm_ensure_node_t) {
        {
            .type = PM_ENSURE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = ensure_keyword->start,
                .end = end_keyword->end
            },
        },
        .ensure_keyword_loc = PM_LOCATION_TOKEN_VALUE(ensure_keyword),
        .statements = statements,
        .end_keyword_loc = PM_LOCATION_TOKEN_VALUE(end_keyword)
    };

    return node;
}

/**
 * Allocate and initialize a new FalseNode node.
 */
static pm_false_node_t *
pm_false_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_KEYWORD_FALSE);
    pm_false_node_t *node = PM_NODE_ALLOC(parser, pm_false_node_t);

    *node = (pm_false_node_t) {{
        .type = PM_FALSE_NODE,
        .flags = PM_NODE_FLAG_STATIC_LITERAL,
        .node_id = PM_NODE_IDENTIFY(parser),
        .location = PM_LOCATION_TOKEN_VALUE(token)
    }};

    return node;
}

/**
 * Allocate and initialize a new find pattern node. The node list given in the
 * nodes parameter is guaranteed to have at least two nodes.
 */
static pm_find_pattern_node_t *
pm_find_pattern_node_create(pm_parser_t *parser, pm_node_list_t *nodes) {
    pm_find_pattern_node_t *node = PM_NODE_ALLOC(parser, pm_find_pattern_node_t);

    pm_node_t *left = nodes->nodes[0];
    assert(PM_NODE_TYPE_P(left, PM_SPLAT_NODE));
    pm_splat_node_t *left_splat_node = (pm_splat_node_t *) left;

    pm_node_t *right;

    if (nodes->size == 1) {
        right = (pm_node_t *) pm_missing_node_create(parser, left->location.end, left->location.end);
    } else {
        right = nodes->nodes[nodes->size - 1];
        assert(PM_NODE_TYPE_P(right, PM_SPLAT_NODE));
    }

#if PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS
    // FindPatternNode#right is typed as SplatNode in this case, so replace the potential MissingNode with a SplatNode.
    // The resulting AST will anyway be ignored, but this file still needs to compile.
    pm_splat_node_t *right_splat_node = PM_NODE_TYPE_P(right, PM_SPLAT_NODE) ? (pm_splat_node_t *) right : left_splat_node;
#else
    pm_node_t *right_splat_node = right;
#endif
    *node = (pm_find_pattern_node_t) {
        {
            .type = PM_FIND_PATTERN_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = left->location.start,
                .end = right->location.end,
            },
        },
        .constant = NULL,
        .left = left_splat_node,
        .right = right_splat_node,
        .requireds = { 0 },
        .opening_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .closing_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE
    };

    // For now we're going to just copy over each pointer manually. This could be
    // much more efficient, as we could instead resize the node list to only point
    // to 1...-1.
    for (size_t index = 1; index < nodes->size - 1; index++) {
        pm_node_list_append(&node->requireds, nodes->nodes[index]);
    }

    return node;
}

/**
 * Parse the value of a double, add appropriate errors if there is an issue, and
 * return the value that should be saved on the PM_FLOAT_NODE node.
 */
static double
pm_double_parse(pm_parser_t *parser, const pm_token_t *token) {
    ptrdiff_t diff = token->end - token->start;
    if (diff <= 0) return 0.0;

    // First, get a buffer of the content.
    size_t length = (size_t) diff;
    char *buffer = xmalloc(sizeof(char) * (length + 1));
    memcpy((void *) buffer, token->start, length);

    // Next, determine if we need to replace the decimal point because of
    // locale-specific options, and then normalize them if we have to.
    char decimal_point = *localeconv()->decimal_point;
    if (decimal_point != '.') {
        for (size_t index = 0; index < length; index++) {
            if (buffer[index] == '.') buffer[index] = decimal_point;
        }
    }

    // Next, handle underscores by removing them from the buffer.
    for (size_t index = 0; index < length; index++) {
        if (buffer[index] == '_') {
            memmove((void *) (buffer + index), (void *) (buffer + index + 1), length - index);
            length--;
        }
    }

    // Null-terminate the buffer so that strtod cannot read off the end.
    buffer[length] = '\0';

    // Now, call strtod to parse the value. Note that CRuby has their own
    // version of strtod which avoids locales. We're okay using the locale-aware
    // version because we've already validated through the parser that the token
    // is in a valid format.
    errno = 0;
    char *eptr;
    double value = strtod(buffer, &eptr);

    // This should never happen, because we've already checked that the token
    // is in a valid format. However it's good to be safe.
    if ((eptr != buffer + length) || (errno != 0 && errno != ERANGE)) {
        PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, (*token), PM_ERR_FLOAT_PARSE);
        xfree((void *) buffer);
        return 0.0;
    }

    // If errno is set, then it should only be ERANGE. At this point we need to
    // check if it's infinity (it should be).
    if (errno == ERANGE && PRISM_ISINF(value)) {
        int warn_width;
        const char *ellipsis;

        if (length > 20) {
            warn_width = 20;
            ellipsis = "...";
        } else {
            warn_width = (int) length;
            ellipsis = "";
        }

        pm_diagnostic_list_append_format(&parser->warning_list, token->start, token->end, PM_WARN_FLOAT_OUT_OF_RANGE, warn_width, (const char *) token->start, ellipsis);
        value = (value < 0.0) ? -HUGE_VAL : HUGE_VAL;
    }

    // Finally we can free the buffer and return the value.
    xfree((void *) buffer);
    return value;
}

/**
 * Allocate and initialize a new FloatNode node.
 */
static pm_float_node_t *
pm_float_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_FLOAT);
    pm_float_node_t *node = PM_NODE_ALLOC(parser, pm_float_node_t);

    *node = (pm_float_node_t) {
        {
            .type = PM_FLOAT_NODE,
            .flags = PM_NODE_FLAG_STATIC_LITERAL,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(token)
        },
        .value = pm_double_parse(parser, token)
    };

    return node;
}

/**
 * Allocate and initialize a new FloatNode node from a FLOAT_IMAGINARY token.
 */
static pm_imaginary_node_t *
pm_float_node_imaginary_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_FLOAT_IMAGINARY);

    pm_imaginary_node_t *node = PM_NODE_ALLOC(parser, pm_imaginary_node_t);
    *node = (pm_imaginary_node_t) {
        {
            .type = PM_IMAGINARY_NODE,
            .flags = PM_NODE_FLAG_STATIC_LITERAL,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(token)
        },
        .numeric = (pm_node_t *) pm_float_node_create(parser, &((pm_token_t) {
            .type = PM_TOKEN_FLOAT,
            .start = token->start,
            .end = token->end - 1
        }))
    };

    return node;
}

/**
 * Allocate and initialize a new RationalNode node from a FLOAT_RATIONAL token.
 */
static pm_rational_node_t *
pm_float_node_rational_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_FLOAT_RATIONAL);

    pm_rational_node_t *node = PM_NODE_ALLOC(parser, pm_rational_node_t);
    *node = (pm_rational_node_t) {
        {
            .type = PM_RATIONAL_NODE,
            .flags = PM_INTEGER_BASE_FLAGS_DECIMAL | PM_NODE_FLAG_STATIC_LITERAL,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(token)
        },
        .numerator = { 0 },
        .denominator = { 0 }
    };

    const uint8_t *start = token->start;
    const uint8_t *end = token->end - 1; // r

    while (start < end && *start == '0') start++; // 0.1 -> .1
    while (end > start && end[-1] == '0') end--; // 1.0 -> 1.

    size_t length = (size_t) (end - start);
    if (length == 1) {
        node->denominator.value = 1;
        return node;
    }

    const uint8_t *point = memchr(start, '.', length);
    assert(point && "should have a decimal point");

    uint8_t *digits = xmalloc(length);
    if (digits == NULL) {
        fputs("[pm_float_node_rational_create] Failed to allocate memory", stderr);
        abort();
    }

    memcpy(digits, start, (unsigned long) (point - start));
    memcpy(digits + (point - start), point + 1, (unsigned long) (end - point - 1));
    pm_integer_parse(&node->numerator, PM_INTEGER_BASE_DEFAULT, digits, digits + length - 1);

    digits[0] = '1';
    if (end - point > 1) memset(digits + 1, '0', (size_t) (end - point - 1));
    pm_integer_parse(&node->denominator, PM_INTEGER_BASE_DEFAULT, digits, digits + (end - point));
    xfree(digits);

    pm_integers_reduce(&node->numerator, &node->denominator);
    return node;
}

/**
 * Allocate and initialize a new FloatNode node from a FLOAT_RATIONAL_IMAGINARY
 * token.
 */
static pm_imaginary_node_t *
pm_float_node_rational_imaginary_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_FLOAT_RATIONAL_IMAGINARY);

    pm_imaginary_node_t *node = PM_NODE_ALLOC(parser, pm_imaginary_node_t);
    *node = (pm_imaginary_node_t) {
        {
            .type = PM_IMAGINARY_NODE,
            .flags = PM_NODE_FLAG_STATIC_LITERAL,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(token)
        },
        .numeric = (pm_node_t *) pm_float_node_rational_create(parser, &((pm_token_t) {
            .type = PM_TOKEN_FLOAT_RATIONAL,
            .start = token->start,
            .end = token->end - 1
        }))
    };

    return node;
}

/**
 * Allocate and initialize a new ForNode node.
 */
static pm_for_node_t *
pm_for_node_create(
    pm_parser_t *parser,
    pm_node_t *index,
    pm_node_t *collection,
    pm_statements_node_t *statements,
    const pm_token_t *for_keyword,
    const pm_token_t *in_keyword,
    const pm_token_t *do_keyword,
    const pm_token_t *end_keyword
) {
    pm_for_node_t *node = PM_NODE_ALLOC(parser, pm_for_node_t);

    *node = (pm_for_node_t) {
        {
            .type = PM_FOR_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = for_keyword->start,
                .end = end_keyword->end
            },
        },
        .index = index,
        .collection = collection,
        .statements = statements,
        .for_keyword_loc = PM_LOCATION_TOKEN_VALUE(for_keyword),
        .in_keyword_loc = PM_LOCATION_TOKEN_VALUE(in_keyword),
        .do_keyword_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(do_keyword),
        .end_keyword_loc = PM_LOCATION_TOKEN_VALUE(end_keyword)
    };

    return node;
}

/**
 * Allocate and initialize a new ForwardingArgumentsNode node.
 */
static pm_forwarding_arguments_node_t *
pm_forwarding_arguments_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_UDOT_DOT_DOT);
    pm_forwarding_arguments_node_t *node = PM_NODE_ALLOC(parser, pm_forwarding_arguments_node_t);

    *node = (pm_forwarding_arguments_node_t) {{
        .type = PM_FORWARDING_ARGUMENTS_NODE,
        .node_id = PM_NODE_IDENTIFY(parser),
        .location = PM_LOCATION_TOKEN_VALUE(token)
    }};

    return node;
}

/**
 * Allocate and initialize a new ForwardingParameterNode node.
 */
static pm_forwarding_parameter_node_t *
pm_forwarding_parameter_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_UDOT_DOT_DOT);
    pm_forwarding_parameter_node_t *node = PM_NODE_ALLOC(parser, pm_forwarding_parameter_node_t);

    *node = (pm_forwarding_parameter_node_t) {{
        .type = PM_FORWARDING_PARAMETER_NODE,
        .node_id = PM_NODE_IDENTIFY(parser),
        .location = PM_LOCATION_TOKEN_VALUE(token)
    }};

    return node;
}

/**
 * Allocate and initialize a new ForwardingSuper node.
 */
static pm_forwarding_super_node_t *
pm_forwarding_super_node_create(pm_parser_t *parser, const pm_token_t *token, pm_arguments_t *arguments) {
    assert(arguments->block == NULL || PM_NODE_TYPE_P(arguments->block, PM_BLOCK_NODE));
    assert(token->type == PM_TOKEN_KEYWORD_SUPER);
    pm_forwarding_super_node_t *node = PM_NODE_ALLOC(parser, pm_forwarding_super_node_t);

    pm_block_node_t *block = NULL;
    if (arguments->block != NULL) {
        block = (pm_block_node_t *) arguments->block;
    }

    *node = (pm_forwarding_super_node_t) {
        {
            .type = PM_FORWARDING_SUPER_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = token->start,
                .end = block != NULL ? block->base.location.end : token->end
            },
        },
        .block = block
    };

    return node;
}

/**
 * Allocate and initialize a new hash pattern node from an opening and closing
 * token.
 */
static pm_hash_pattern_node_t *
pm_hash_pattern_node_empty_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *closing) {
    pm_hash_pattern_node_t *node = PM_NODE_ALLOC(parser, pm_hash_pattern_node_t);

    *node = (pm_hash_pattern_node_t) {
        {
            .type = PM_HASH_PATTERN_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = opening->start,
                .end = closing->end
            },
        },
        .constant = NULL,
        .opening_loc = PM_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_LOCATION_TOKEN_VALUE(closing),
        .elements = { 0 },
        .rest = NULL
    };

    return node;
}

/**
 * Allocate and initialize a new hash pattern node.
 */
static pm_hash_pattern_node_t *
pm_hash_pattern_node_node_list_create(pm_parser_t *parser, pm_node_list_t *elements, pm_node_t *rest) {
    pm_hash_pattern_node_t *node = PM_NODE_ALLOC(parser, pm_hash_pattern_node_t);

    const uint8_t *start;
    const uint8_t *end;

    if (elements->size > 0) {
        if (rest) {
            start = elements->nodes[0]->location.start;
            end = rest->location.end;
        } else {
            start = elements->nodes[0]->location.start;
            end = elements->nodes[elements->size - 1]->location.end;
        }
    } else {
        assert(rest != NULL);
        start = rest->location.start;
        end = rest->location.end;
    }

    *node = (pm_hash_pattern_node_t) {
        {
            .type = PM_HASH_PATTERN_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = start,
                .end = end
            },
        },
        .constant = NULL,
        .elements = { 0 },
        .rest = rest,
        .opening_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .closing_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE
    };

    pm_node_t *element;
    PM_NODE_LIST_FOREACH(elements, index, element) {
        pm_node_list_append(&node->elements, element);
    }

    return node;
}

/**
 * Retrieve the name from a node that will become a global variable write node.
 */
static pm_constant_id_t
pm_global_variable_write_name(pm_parser_t *parser, const pm_node_t *target) {
    switch (PM_NODE_TYPE(target)) {
        case PM_GLOBAL_VARIABLE_READ_NODE:
            return ((pm_global_variable_read_node_t *) target)->name;
        case PM_BACK_REFERENCE_READ_NODE:
            return ((pm_back_reference_read_node_t *) target)->name;
        case PM_NUMBERED_REFERENCE_READ_NODE:
            // This will only ever happen in the event of a syntax error, but we
            // still need to provide something for the node.
            return pm_parser_constant_id_location(parser, target->location.start, target->location.end);
        default:
            assert(false && "unreachable");
            return (pm_constant_id_t) -1;
    }
}

/**
 * Allocate and initialize a new GlobalVariableAndWriteNode node.
 */
static pm_global_variable_and_write_node_t *
pm_global_variable_and_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
    pm_global_variable_and_write_node_t *node = PM_NODE_ALLOC(parser, pm_global_variable_and_write_node_t);

    *node = (pm_global_variable_and_write_node_t) {
        {
            .type = PM_GLOBAL_VARIABLE_AND_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->location.start,
                .end = value->location.end
            }
        },
        .name = pm_global_variable_write_name(parser, target),
        .name_loc = target->location,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new GlobalVariableOperatorWriteNode node.
 */
static pm_global_variable_operator_write_node_t *
pm_global_variable_operator_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    pm_global_variable_operator_write_node_t *node = PM_NODE_ALLOC(parser, pm_global_variable_operator_write_node_t);

    *node = (pm_global_variable_operator_write_node_t) {
        {
            .type = PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->location.start,
                .end = value->location.end
            }
        },
        .name = pm_global_variable_write_name(parser, target),
        .name_loc = target->location,
        .binary_operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value,
        .binary_operator = pm_parser_constant_id_location(parser, operator->start, operator->end - 1)
    };

    return node;
}

/**
 * Allocate and initialize a new GlobalVariableOrWriteNode node.
 */
static pm_global_variable_or_write_node_t *
pm_global_variable_or_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
    pm_global_variable_or_write_node_t *node = PM_NODE_ALLOC(parser, pm_global_variable_or_write_node_t);

    *node = (pm_global_variable_or_write_node_t) {
        {
            .type = PM_GLOBAL_VARIABLE_OR_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->location.start,
                .end = value->location.end
            }
        },
        .name = pm_global_variable_write_name(parser, target),
        .name_loc = target->location,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate a new GlobalVariableReadNode node.
 */
static pm_global_variable_read_node_t *
pm_global_variable_read_node_create(pm_parser_t *parser, const pm_token_t *name) {
    pm_global_variable_read_node_t *node = PM_NODE_ALLOC(parser, pm_global_variable_read_node_t);

    *node = (pm_global_variable_read_node_t) {
        {
            .type = PM_GLOBAL_VARIABLE_READ_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(name),
        },
        .name = pm_parser_constant_id_token(parser, name)
    };

    return node;
}

/**
 * Allocate and initialize a new synthesized GlobalVariableReadNode node.
 */
static pm_global_variable_read_node_t *
pm_global_variable_read_node_synthesized_create(pm_parser_t *parser, pm_constant_id_t name) {
    pm_global_variable_read_node_t *node = PM_NODE_ALLOC(parser, pm_global_variable_read_node_t);

    *node = (pm_global_variable_read_node_t) {
        {
            .type = PM_GLOBAL_VARIABLE_READ_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_NULL_VALUE(parser)
        },
        .name = name
    };

    return node;
}

/**
 * Allocate and initialize a new GlobalVariableWriteNode node.
 */
static pm_global_variable_write_node_t *
pm_global_variable_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    pm_global_variable_write_node_t *node = PM_NODE_ALLOC(parser, pm_global_variable_write_node_t);

    *node = (pm_global_variable_write_node_t) {
        {
            .type = PM_GLOBAL_VARIABLE_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .flags = pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),
            .location = {
                .start = target->location.start,
                .end = value->location.end
            },
        },
        .name = pm_global_variable_write_name(parser, target),
        .name_loc = PM_LOCATION_NODE_VALUE(target),
        .operator_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new synthesized GlobalVariableWriteNode node.
 */
static pm_global_variable_write_node_t *
pm_global_variable_write_node_synthesized_create(pm_parser_t *parser, pm_constant_id_t name, pm_node_t *value) {
    pm_global_variable_write_node_t *node = PM_NODE_ALLOC(parser, pm_global_variable_write_node_t);

    *node = (pm_global_variable_write_node_t) {
        {
            .type = PM_GLOBAL_VARIABLE_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_NULL_VALUE(parser)
        },
        .name = name,
        .name_loc = PM_LOCATION_NULL_VALUE(parser),
        .operator_loc = PM_LOCATION_NULL_VALUE(parser),
        .value = value
    };

    return node;
}

/**
 * Allocate a new HashNode node.
 */
static pm_hash_node_t *
pm_hash_node_create(pm_parser_t *parser, const pm_token_t *opening) {
    assert(opening != NULL);
    pm_hash_node_t *node = PM_NODE_ALLOC(parser, pm_hash_node_t);

    *node = (pm_hash_node_t) {
        {
            .type = PM_HASH_NODE,
            .flags = PM_NODE_FLAG_STATIC_LITERAL,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(opening)
        },
        .opening_loc = PM_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_LOCATION_NULL_VALUE(parser),
        .elements = { 0 }
    };

    return node;
}

/**
 * Append a new element to a hash node.
 */
static inline void
pm_hash_node_elements_append(pm_hash_node_t *hash, pm_node_t *element) {
    pm_node_list_append(&hash->elements, element);

    bool static_literal = PM_NODE_TYPE_P(element, PM_ASSOC_NODE);
    if (static_literal) {
        pm_assoc_node_t *assoc = (pm_assoc_node_t *) element;
        static_literal = !PM_NODE_TYPE_P(assoc->key, PM_ARRAY_NODE) && !PM_NODE_TYPE_P(assoc->key, PM_HASH_NODE) && !PM_NODE_TYPE_P(assoc->key, PM_RANGE_NODE);
        static_literal = static_literal && PM_NODE_FLAG_P(assoc->key, PM_NODE_FLAG_STATIC_LITERAL);
        static_literal = static_literal && PM_NODE_FLAG_P(assoc, PM_NODE_FLAG_STATIC_LITERAL);
    }

    if (!static_literal) {
        pm_node_flag_unset((pm_node_t *)hash, PM_NODE_FLAG_STATIC_LITERAL);
    }
}

static inline void
pm_hash_node_closing_loc_set(pm_hash_node_t *hash, pm_token_t *token) {
    hash->base.location.end = token->end;
    hash->closing_loc = PM_LOCATION_TOKEN_VALUE(token);
}

/**
 * Allocate a new IfNode node.
 */
static pm_if_node_t *
pm_if_node_create(pm_parser_t *parser,
    const pm_token_t *if_keyword,
    pm_node_t *predicate,
    const pm_token_t *then_keyword,
    pm_statements_node_t *statements,
    pm_node_t *subsequent,
    const pm_token_t *end_keyword
) {
    pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
    pm_if_node_t *node = PM_NODE_ALLOC(parser, pm_if_node_t);

    const uint8_t *end;
    if (end_keyword->type != PM_TOKEN_NOT_PROVIDED) {
        end = end_keyword->end;
    } else if (subsequent != NULL) {
        end = subsequent->location.end;
    } else if (pm_statements_node_body_length(statements) != 0) {
        end = statements->base.location.end;
    } else {
        end = predicate->location.end;
    }

    *node = (pm_if_node_t) {
        {
            .type = PM_IF_NODE,
            .flags = PM_NODE_FLAG_NEWLINE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = if_keyword->start,
                .end = end
            },
        },
        .if_keyword_loc = PM_LOCATION_TOKEN_VALUE(if_keyword),
        .predicate = predicate,
        .then_keyword_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(then_keyword),
        .statements = statements,
        .subsequent = subsequent,
        .end_keyword_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(end_keyword)
    };

    return node;
}

/**
 * Allocate and initialize new IfNode node in the modifier form.
 */
static pm_if_node_t *
pm_if_node_modifier_create(pm_parser_t *parser, pm_node_t *statement, const pm_token_t *if_keyword, pm_node_t *predicate) {
    pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
    pm_if_node_t *node = PM_NODE_ALLOC(parser, pm_if_node_t);

    pm_statements_node_t *statements = pm_statements_node_create(parser);
    pm_statements_node_body_append(parser, statements, statement, true);

    *node = (pm_if_node_t) {
        {
            .type = PM_IF_NODE,
            .flags = PM_NODE_FLAG_NEWLINE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = statement->location.start,
                .end = predicate->location.end
            },
        },
        .if_keyword_loc = PM_LOCATION_TOKEN_VALUE(if_keyword),
        .predicate = predicate,
        .then_keyword_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .statements = statements,
        .subsequent = NULL,
        .end_keyword_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE
    };

    return node;
}

/**
 * Allocate and initialize an if node from a ternary expression.
 */
static pm_if_node_t *
pm_if_node_ternary_create(pm_parser_t *parser, pm_node_t *predicate, const pm_token_t *qmark, pm_node_t *true_expression, const pm_token_t *colon, pm_node_t *false_expression) {
    pm_assert_value_expression(parser, predicate);
    pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);

    pm_statements_node_t *if_statements = pm_statements_node_create(parser);
    pm_statements_node_body_append(parser, if_statements, true_expression, true);

    pm_statements_node_t *else_statements = pm_statements_node_create(parser);
    pm_statements_node_body_append(parser, else_statements, false_expression, true);

    pm_token_t end_keyword = not_provided(parser);
    pm_else_node_t *else_node = pm_else_node_create(parser, colon, else_statements, &end_keyword);

    pm_if_node_t *node = PM_NODE_ALLOC(parser, pm_if_node_t);

    *node = (pm_if_node_t) {
        {
            .type = PM_IF_NODE,
            .flags = PM_NODE_FLAG_NEWLINE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = predicate->location.start,
                .end = false_expression->location.end,
            },
        },
        .if_keyword_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .predicate = predicate,
        .then_keyword_loc = PM_LOCATION_TOKEN_VALUE(qmark),
        .statements = if_statements,
        .subsequent = (pm_node_t *) else_node,
        .end_keyword_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE
    };

    return node;

}

static inline void
pm_if_node_end_keyword_loc_set(pm_if_node_t *node, const pm_token_t *keyword) {
    node->base.location.end = keyword->end;
    node->end_keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword);
}

static inline void
pm_else_node_end_keyword_loc_set(pm_else_node_t *node, const pm_token_t *keyword) {
    node->base.location.end = keyword->end;
    node->end_keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword);
}

/**
 * Allocate and initialize a new ImplicitNode node.
 */
static pm_implicit_node_t *
pm_implicit_node_create(pm_parser_t *parser, pm_node_t *value) {
    pm_implicit_node_t *node = PM_NODE_ALLOC(parser, pm_implicit_node_t);

    *node = (pm_implicit_node_t) {
        {
            .type = PM_IMPLICIT_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = value->location
        },
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new ImplicitRestNode node.
 */
static pm_implicit_rest_node_t *
pm_implicit_rest_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_COMMA);

    pm_implicit_rest_node_t *node = PM_NODE_ALLOC(parser, pm_implicit_rest_node_t);

    *node = (pm_implicit_rest_node_t) {
        {
            .type = PM_IMPLICIT_REST_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(token)
        }
    };

    return node;
}

/**
 * Allocate and initialize a new IntegerNode node.
 */
static pm_integer_node_t *
pm_integer_node_create(pm_parser_t *parser, pm_node_flags_t base, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_INTEGER);
    pm_integer_node_t *node = PM_NODE_ALLOC(parser, pm_integer_node_t);

    *node = (pm_integer_node_t) {
        {
            .type = PM_INTEGER_NODE,
            .flags = base | PM_NODE_FLAG_STATIC_LITERAL,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(token)
        },
        .value = { 0 }
    };

    pm_integer_base_t integer_base = PM_INTEGER_BASE_DECIMAL;
    switch (base) {
        case PM_INTEGER_BASE_FLAGS_BINARY: integer_base = PM_INTEGER_BASE_BINARY; break;
        case PM_INTEGER_BASE_FLAGS_OCTAL: integer_base = PM_INTEGER_BASE_OCTAL; break;
        case PM_INTEGER_BASE_FLAGS_DECIMAL: break;
        case PM_INTEGER_BASE_FLAGS_HEXADECIMAL: integer_base = PM_INTEGER_BASE_HEXADECIMAL; break;
        default: assert(false && "unreachable"); break;
    }

    pm_integer_parse(&node->value, integer_base, token->start, token->end);
    return node;
}

/**
 * Allocate and initialize a new IntegerNode node from an INTEGER_IMAGINARY
 * token.
 */
static pm_imaginary_node_t *
pm_integer_node_imaginary_create(pm_parser_t *parser, pm_node_flags_t base, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_INTEGER_IMAGINARY);

    pm_imaginary_node_t *node = PM_NODE_ALLOC(parser, pm_imaginary_node_t);
    *node = (pm_imaginary_node_t) {
        {
            .type = PM_IMAGINARY_NODE,
            .flags = PM_NODE_FLAG_STATIC_LITERAL,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(token)
        },
        .numeric = (pm_node_t *) pm_integer_node_create(parser, base, &((pm_token_t) {
            .type = PM_TOKEN_INTEGER,
            .start = token->start,
            .end = token->end - 1
        }))
    };

    return node;
}

/**
 * Allocate and initialize a new RationalNode node from an INTEGER_RATIONAL
 * token.
 */
static pm_rational_node_t *
pm_integer_node_rational_create(pm_parser_t *parser, pm_node_flags_t base, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_INTEGER_RATIONAL);

    pm_rational_node_t *node = PM_NODE_ALLOC(parser, pm_rational_node_t);
    *node = (pm_rational_node_t) {
        {
            .type = PM_RATIONAL_NODE,
            .flags = base | PM_NODE_FLAG_STATIC_LITERAL,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(token)
        },
        .numerator = { 0 },
        .denominator = { .value = 1, 0 }
    };

    pm_integer_base_t integer_base = PM_INTEGER_BASE_DECIMAL;
    switch (base) {
        case PM_INTEGER_BASE_FLAGS_BINARY: integer_base = PM_INTEGER_BASE_BINARY; break;
        case PM_INTEGER_BASE_FLAGS_OCTAL: integer_base = PM_INTEGER_BASE_OCTAL; break;
        case PM_INTEGER_BASE_FLAGS_DECIMAL: break;
        case PM_INTEGER_BASE_FLAGS_HEXADECIMAL: integer_base = PM_INTEGER_BASE_HEXADECIMAL; break;
        default: assert(false && "unreachable"); break;
    }

    pm_integer_parse(&node->numerator, integer_base, token->start, token->end - 1);

    return node;
}

/**
 * Allocate and initialize a new IntegerNode node from an
 * INTEGER_RATIONAL_IMAGINARY token.
 */
static pm_imaginary_node_t *
pm_integer_node_rational_imaginary_create(pm_parser_t *parser, pm_node_flags_t base, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_INTEGER_RATIONAL_IMAGINARY);

    pm_imaginary_node_t *node = PM_NODE_ALLOC(parser, pm_imaginary_node_t);
    *node = (pm_imaginary_node_t) {
        {
            .type = PM_IMAGINARY_NODE,
            .flags = PM_NODE_FLAG_STATIC_LITERAL,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(token)
        },
        .numeric = (pm_node_t *) pm_integer_node_rational_create(parser, base, &((pm_token_t) {
            .type = PM_TOKEN_INTEGER_RATIONAL,
            .start = token->start,
            .end = token->end - 1
        }))
    };

    return node;
}

/**
 * Allocate and initialize a new InNode node.
 */
static pm_in_node_t *
pm_in_node_create(pm_parser_t *parser, pm_node_t *pattern, pm_statements_node_t *statements, const pm_token_t *in_keyword, const pm_token_t *then_keyword) {
    pm_in_node_t *node = PM_NODE_ALLOC(parser, pm_in_node_t);

    const uint8_t *end;
    if (statements != NULL) {
        end = statements->base.location.end;
    } else if (then_keyword->type != PM_TOKEN_NOT_PROVIDED) {
        end = then_keyword->end;
    } else {
        end = pattern->location.end;
    }

    *node = (pm_in_node_t) {
        {
            .type = PM_IN_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = in_keyword->start,
                .end = end
            },
        },
        .pattern = pattern,
        .statements = statements,
        .in_loc = PM_LOCATION_TOKEN_VALUE(in_keyword),
        .then_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(then_keyword)
    };

    return node;
}

/**
 * Allocate and initialize a new InstanceVariableAndWriteNode node.
 */
static pm_instance_variable_and_write_node_t *
pm_instance_variable_and_write_node_create(pm_parser_t *parser, pm_instance_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
    pm_instance_variable_and_write_node_t *node = PM_NODE_ALLOC(parser, pm_instance_variable_and_write_node_t);

    *node = (pm_instance_variable_and_write_node_t) {
        {
            .type = PM_INSTANCE_VARIABLE_AND_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .name = target->name,
        .name_loc = target->base.location,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new InstanceVariableOperatorWriteNode node.
 */
static pm_instance_variable_operator_write_node_t *
pm_instance_variable_operator_write_node_create(pm_parser_t *parser, pm_instance_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    pm_instance_variable_operator_write_node_t *node = PM_NODE_ALLOC(parser, pm_instance_variable_operator_write_node_t);

    *node = (pm_instance_variable_operator_write_node_t) {
        {
            .type = PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .name = target->name,
        .name_loc = target->base.location,
        .binary_operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value,
        .binary_operator = pm_parser_constant_id_location(parser, operator->start, operator->end - 1)
    };

    return node;
}

/**
 * Allocate and initialize a new InstanceVariableOrWriteNode node.
 */
static pm_instance_variable_or_write_node_t *
pm_instance_variable_or_write_node_create(pm_parser_t *parser, pm_instance_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
    pm_instance_variable_or_write_node_t *node = PM_NODE_ALLOC(parser, pm_instance_variable_or_write_node_t);

    *node = (pm_instance_variable_or_write_node_t) {
        {
            .type = PM_INSTANCE_VARIABLE_OR_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .name = target->name,
        .name_loc = target->base.location,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new InstanceVariableReadNode node.
 */
static pm_instance_variable_read_node_t *
pm_instance_variable_read_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_INSTANCE_VARIABLE);
    pm_instance_variable_read_node_t *node = PM_NODE_ALLOC(parser, pm_instance_variable_read_node_t);

    *node = (pm_instance_variable_read_node_t) {
        {
            .type = PM_INSTANCE_VARIABLE_READ_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(token)
        },
        .name = pm_parser_constant_id_token(parser, token)
    };

    return node;
}

/**
 * Initialize a new InstanceVariableWriteNode node from an InstanceVariableRead
 * node.
 */
static pm_instance_variable_write_node_t *
pm_instance_variable_write_node_create(pm_parser_t *parser, pm_instance_variable_read_node_t *read_node, pm_token_t *operator, pm_node_t *value) {
    pm_instance_variable_write_node_t *node = PM_NODE_ALLOC(parser, pm_instance_variable_write_node_t);
    *node = (pm_instance_variable_write_node_t) {
        {
            .type = PM_INSTANCE_VARIABLE_WRITE_NODE,
            .flags = pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = read_node->base.location.start,
                .end = value->location.end
            }
        },
        .name = read_node->name,
        .name_loc = PM_LOCATION_NODE_BASE_VALUE(read_node),
        .operator_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Append a part into a list of string parts. Importantly this handles nested
 * interpolated strings by not necessarily removing the marker for static
 * literals.
 */
static void
pm_interpolated_node_append(pm_node_t *node, pm_node_list_t *parts, pm_node_t *part) {
    switch (PM_NODE_TYPE(part)) {
        case PM_STRING_NODE:
            pm_node_flag_set(part, PM_NODE_FLAG_STATIC_LITERAL | PM_STRING_FLAGS_FROZEN);
            break;
        case PM_EMBEDDED_STATEMENTS_NODE: {
            pm_embedded_statements_node_t *cast = (pm_embedded_statements_node_t *) part;
            pm_node_t *embedded = (cast->statements != NULL && cast->statements->body.size == 1) ? cast->statements->body.nodes[0] : NULL;

            if (embedded == NULL) {
                // If there are no statements or more than one statement, then
                // we lose the static literal flag.
                pm_node_flag_unset(node, PM_NODE_FLAG_STATIC_LITERAL);
            } else if (PM_NODE_TYPE_P(embedded, PM_STRING_NODE)) {
                // If the embedded statement is a string, then we can keep the
                // static literal flag and mark the string as frozen.
                pm_node_flag_set(embedded, PM_NODE_FLAG_STATIC_LITERAL | PM_STRING_FLAGS_FROZEN);
            } else if (PM_NODE_TYPE_P(embedded, PM_INTERPOLATED_STRING_NODE) && PM_NODE_FLAG_P(embedded, PM_NODE_FLAG_STATIC_LITERAL)) {
                // If the embedded statement is an interpolated string and it's
                // a static literal, then we can keep the static literal flag.
            } else {
                // Otherwise we lose the static literal flag.
                pm_node_flag_unset(node, PM_NODE_FLAG_STATIC_LITERAL);
            }

            break;
        }
        case PM_EMBEDDED_VARIABLE_NODE:
            pm_node_flag_unset((pm_node_t *) node, PM_NODE_FLAG_STATIC_LITERAL);
            break;
        default:
            assert(false && "unexpected node type");
            break;
    }

    pm_node_list_append(parts, part);
}

/**
 * Allocate a new InterpolatedRegularExpressionNode node.
 */
static pm_interpolated_regular_expression_node_t *
pm_interpolated_regular_expression_node_create(pm_parser_t *parser, const pm_token_t *opening) {
    pm_interpolated_regular_expression_node_t *node = PM_NODE_ALLOC(parser, pm_interpolated_regular_expression_node_t);

    *node = (pm_interpolated_regular_expression_node_t) {
        {
            .type = PM_INTERPOLATED_REGULAR_EXPRESSION_NODE,
            .flags = PM_NODE_FLAG_STATIC_LITERAL,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = opening->start,
                .end = NULL,
            },
        },
        .opening_loc = PM_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_LOCATION_TOKEN_VALUE(opening),
        .parts = { 0 }
    };

    return node;
}

static inline void
pm_interpolated_regular_expression_node_append(pm_interpolated_regular_expression_node_t *node, pm_node_t *part) {
    if (node->base.location.start > part->location.start) {
        node->base.location.start = part->location.start;
    }
    if (node->base.location.end < part->location.end) {
        node->base.location.end = part->location.end;
    }

    pm_interpolated_node_append((pm_node_t *) node, &node->parts, part);
}

static inline void
pm_interpolated_regular_expression_node_closing_set(pm_parser_t *parser, pm_interpolated_regular_expression_node_t *node, const pm_token_t *closing) {
    node->closing_loc = PM_LOCATION_TOKEN_VALUE(closing);
    node->base.location.end = closing->end;
    pm_node_flag_set((pm_node_t *) node, pm_regular_expression_flags_create(parser, closing));
}

/**
 * Append a part to an InterpolatedStringNode node.
 *
 * This has some somewhat complicated semantics, because we need to update
 * multiple flags that have somewhat confusing interactions.
 *
 * PM_NODE_FLAG_STATIC_LITERAL indicates that the node should be treated as a
 * single static literal string that can be pushed onto the stack on its own.
 * Note that this doesn't necessarily mean that the string will be frozen or
 * not; the instructions in CRuby will be either putobject or putstring,
 * depending on the combination of `--enable-frozen-string-literal`,
 * `# frozen_string_literal: true`, and whether or not there is interpolation.
 *
 * PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN indicates that the string should be
 * explicitly frozen. This will only happen if the string is comprised entirely
 * of string parts that are themselves static literals and frozen.
 *
 * PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE indicates that the string should
 * be explicitly marked as mutable. This will happen from
 * `--disable-frozen-string-literal` or `# frozen_string_literal: false`. This
 * is necessary to indicate that the string should be left up to the runtime,
 * which could potentially use a chilled string otherwise.
 */
static inline void
pm_interpolated_string_node_append(pm_interpolated_string_node_t *node, pm_node_t *part) {
#define CLEAR_FLAGS(node) \
    node->base.flags = (pm_node_flags_t) (node->base.flags & ~(PM_NODE_FLAG_STATIC_LITERAL | PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN | PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE))

#define MUTABLE_FLAGS(node) \
    node->base.flags = (pm_node_flags_t) ((node->base.flags | PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE) & ~PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN);

    if (node->parts.size == 0 && node->opening_loc.start == NULL) {
        node->base.location.start = part->location.start;
    }

    node->base.location.end = MAX(node->base.location.end, part->location.end);

    switch (PM_NODE_TYPE(part)) {
        case PM_STRING_NODE:
            part->flags = (pm_node_flags_t) ((part->flags | PM_NODE_FLAG_STATIC_LITERAL | PM_STRING_FLAGS_FROZEN) & ~PM_STRING_FLAGS_MUTABLE);
            break;
        case PM_INTERPOLATED_STRING_NODE:
            if (PM_NODE_FLAG_P(part, PM_NODE_FLAG_STATIC_LITERAL)) {
                // If the string that we're concatenating is a static literal,
                // then we can keep the static literal flag for this string.
            } else {
                // Otherwise, we lose the static literal flag here and we should
                // also clear the mutability flags.
                CLEAR_FLAGS(node);
            }
            break;
        case PM_EMBEDDED_STATEMENTS_NODE: {
            pm_embedded_statements_node_t *cast = (pm_embedded_statements_node_t *) part;
            pm_node_t *embedded = (cast->statements != NULL && cast->statements->body.size == 1) ? cast->statements->body.nodes[0] : NULL;

            if (embedded == NULL) {
                // If we're embedding multiple statements or no statements, then
                // the string is not longer a static literal.
                CLEAR_FLAGS(node);
            } else if (PM_NODE_TYPE_P(embedded, PM_STRING_NODE)) {
                // If the embedded statement is a string, then we can make that
                // string as frozen and static literal, and not touch the static
                // literal status of this string.
                embedded->flags = (pm_node_flags_t) ((embedded->flags | PM_NODE_FLAG_STATIC_LITERAL | PM_STRING_FLAGS_FROZEN) & ~PM_STRING_FLAGS_MUTABLE);

                if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
                    MUTABLE_FLAGS(node);
                }
            } else if (PM_NODE_TYPE_P(embedded, PM_INTERPOLATED_STRING_NODE) && PM_NODE_FLAG_P(embedded, PM_NODE_FLAG_STATIC_LITERAL)) {
                // If the embedded statement is an interpolated string, but that
                // string is marked as static literal, then we can keep our
                // static literal status for this string.
                if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL)) {
                    MUTABLE_FLAGS(node);
                }
            } else {
                // In all other cases, we lose the static literal flag here and
                // become mutable.
                CLEAR_FLAGS(node);
            }

            break;
        }
        case PM_EMBEDDED_VARIABLE_NODE:
            // Embedded variables clear static literal, which means we also
            // should clear the mutability flags.
            CLEAR_FLAGS(node);
            break;
        case PM_X_STRING_NODE:
        case PM_INTERPOLATED_X_STRING_NODE:
            // If this is an x string, then this is a syntax error. But we want
            // to handle it here so that we don't fail the assertion.
            CLEAR_FLAGS(node);
            break;
        default:
            assert(false && "unexpected node type");
            break;
    }

    pm_node_list_append(&node->parts, part);

#undef CLEAR_FLAGS
#undef MUTABLE_FLAGS
}

/**
 * Allocate and initialize a new InterpolatedStringNode node.
 */
static pm_interpolated_string_node_t *
pm_interpolated_string_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_node_list_t *parts, const pm_token_t *closing) {
    pm_interpolated_string_node_t *node = PM_NODE_ALLOC(parser, pm_interpolated_string_node_t);
    pm_node_flags_t flags = PM_NODE_FLAG_STATIC_LITERAL;

    switch (parser->frozen_string_literal) {
        case PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED:
            flags |= PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE;
            break;
        case PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED:
            flags |= PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN;
            break;
    }

    *node = (pm_interpolated_string_node_t) {
        {
            .type = PM_INTERPOLATED_STRING_NODE,
            .flags = flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = opening->start,
                .end = closing->end,
            },
        },
        .opening_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(closing),
        .parts = { 0 }
    };

    if (parts != NULL) {
        pm_node_t *part;
        PM_NODE_LIST_FOREACH(parts, index, part) {
            pm_interpolated_string_node_append(node, part);
        }
    }

    return node;
}

/**
 * Set the closing token of the given InterpolatedStringNode node.
 */
static void
pm_interpolated_string_node_closing_set(pm_interpolated_string_node_t *node, const pm_token_t *closing) {
    node->closing_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(closing);
    node->base.location.end = closing->end;
}

static void
pm_interpolated_symbol_node_append(pm_interpolated_symbol_node_t *node, pm_node_t *part) {
    if (node->parts.size == 0 && node->opening_loc.start == NULL) {
        node->base.location.start = part->location.start;
    }

    pm_interpolated_node_append((pm_node_t *) node, &node->parts, part);
    node->base.location.end = MAX(node->base.location.end, part->location.end);
}

static void
pm_interpolated_symbol_node_closing_loc_set(pm_interpolated_symbol_node_t *node, const pm_token_t *closing) {
    node->closing_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(closing);
    node->base.location.end = closing->end;
}

/**
 * Allocate and initialize a new InterpolatedSymbolNode node.
 */
static pm_interpolated_symbol_node_t *
pm_interpolated_symbol_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_node_list_t *parts, const pm_token_t *closing) {
    pm_interpolated_symbol_node_t *node = PM_NODE_ALLOC(parser, pm_interpolated_symbol_node_t);

    *node = (pm_interpolated_symbol_node_t) {
        {
            .type = PM_INTERPOLATED_SYMBOL_NODE,
            .flags = PM_NODE_FLAG_STATIC_LITERAL,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = opening->start,
                .end = closing->end,
            },
        },
        .opening_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(closing),
        .parts = { 0 }
    };

    if (parts != NULL) {
        pm_node_t *part;
        PM_NODE_LIST_FOREACH(parts, index, part) {
            pm_interpolated_symbol_node_append(node, part);
        }
    }

    return node;
}

/**
 * Allocate a new InterpolatedXStringNode node.
 */
static pm_interpolated_x_string_node_t *
pm_interpolated_xstring_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *closing) {
    pm_interpolated_x_string_node_t *node = PM_NODE_ALLOC(parser, pm_interpolated_x_string_node_t);

    *node = (pm_interpolated_x_string_node_t) {
        {
            .type = PM_INTERPOLATED_X_STRING_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = opening->start,
                .end = closing->end
            },
        },
        .opening_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(closing),
        .parts = { 0 }
    };

    return node;
}

static inline void
pm_interpolated_xstring_node_append(pm_interpolated_x_string_node_t *node, pm_node_t *part) {
    pm_interpolated_node_append((pm_node_t *) node, &node->parts, part);
    node->base.location.end = part->location.end;
}

static inline void
pm_interpolated_xstring_node_closing_set(pm_interpolated_x_string_node_t *node, const pm_token_t *closing) {
    node->closing_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(closing);
    node->base.location.end = closing->end;
}

/**
 * Create a local variable read that is reading the implicit 'it' variable.
 */
static pm_it_local_variable_read_node_t *
pm_it_local_variable_read_node_create(pm_parser_t *parser, const pm_token_t *name) {
    pm_it_local_variable_read_node_t *node = PM_NODE_ALLOC(parser, pm_it_local_variable_read_node_t);

    *node = (pm_it_local_variable_read_node_t) {
        {
            .type = PM_IT_LOCAL_VARIABLE_READ_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(name)
        }
    };

    return node;
}

/**
 * Allocate and initialize a new ItParametersNode node.
 */
static pm_it_parameters_node_t *
pm_it_parameters_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *closing) {
    pm_it_parameters_node_t *node = PM_NODE_ALLOC(parser, pm_it_parameters_node_t);

    *node = (pm_it_parameters_node_t) {
        {
            .type = PM_IT_PARAMETERS_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = opening->start,
                .end = closing->end
            }
        }
    };

    return node;
}

/**
 * Allocate a new KeywordHashNode node.
 */
static pm_keyword_hash_node_t *
pm_keyword_hash_node_create(pm_parser_t *parser) {
    pm_keyword_hash_node_t *node = PM_NODE_ALLOC(parser, pm_keyword_hash_node_t);

    *node = (pm_keyword_hash_node_t) {
        .base = {
            .type = PM_KEYWORD_HASH_NODE,
            .flags = PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE
        },
        .elements = { 0 }
    };

    return node;
}

/**
 * Append an element to a KeywordHashNode node.
 */
static void
pm_keyword_hash_node_elements_append(pm_keyword_hash_node_t *hash, pm_node_t *element) {
    // If the element being added is not an AssocNode or does not have a symbol
    // key, then we want to turn the SYMBOL_KEYS flag off.
    if (!PM_NODE_TYPE_P(element, PM_ASSOC_NODE) || !PM_NODE_TYPE_P(((pm_assoc_node_t *) element)->key, PM_SYMBOL_NODE)) {
        pm_node_flag_unset((pm_node_t *)hash, PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS);
    }

    pm_node_list_append(&hash->elements, element);
    if (hash->base.location.start == NULL) {
        hash->base.location.start = element->location.start;
    }
    hash->base.location.end = element->location.end;
}

/**
 * Allocate and initialize a new RequiredKeywordParameterNode node.
 */
static pm_required_keyword_parameter_node_t *
pm_required_keyword_parameter_node_create(pm_parser_t *parser, const pm_token_t *name) {
    pm_required_keyword_parameter_node_t *node = PM_NODE_ALLOC(parser, pm_required_keyword_parameter_node_t);

    *node = (pm_required_keyword_parameter_node_t) {
        {
            .type = PM_REQUIRED_KEYWORD_PARAMETER_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = name->start,
                .end = name->end
            },
        },
        .name = pm_parser_constant_id_location(parser, name->start, name->end - 1),
        .name_loc = PM_LOCATION_TOKEN_VALUE(name),
    };

    return node;
}

/**
 * Allocate a new OptionalKeywordParameterNode node.
 */
static pm_optional_keyword_parameter_node_t *
pm_optional_keyword_parameter_node_create(pm_parser_t *parser, const pm_token_t *name, pm_node_t *value) {
    pm_optional_keyword_parameter_node_t *node = PM_NODE_ALLOC(parser, pm_optional_keyword_parameter_node_t);

    *node = (pm_optional_keyword_parameter_node_t) {
        {
            .type = PM_OPTIONAL_KEYWORD_PARAMETER_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = name->start,
                .end = value->location.end
            },
        },
        .name = pm_parser_constant_id_location(parser, name->start, name->end - 1),
        .name_loc = PM_LOCATION_TOKEN_VALUE(name),
        .value = value
    };

    return node;
}

/**
 * Allocate a new KeywordRestParameterNode node.
 */
static pm_keyword_rest_parameter_node_t *
pm_keyword_rest_parameter_node_create(pm_parser_t *parser, const pm_token_t *operator, const pm_token_t *name) {
    pm_keyword_rest_parameter_node_t *node = PM_NODE_ALLOC(parser, pm_keyword_rest_parameter_node_t);

    *node = (pm_keyword_rest_parameter_node_t) {
        {
            .type = PM_KEYWORD_REST_PARAMETER_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = operator->start,
                .end = (name->type == PM_TOKEN_NOT_PROVIDED ? operator->end : name->end)
            },
        },
        .name = pm_parser_optional_constant_id_token(parser, name),
        .name_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(name),
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator)
    };

    return node;
}

/**
 * Allocate a new LambdaNode node.
 */
static pm_lambda_node_t *
pm_lambda_node_create(
    pm_parser_t *parser,
    pm_constant_id_list_t *locals,
    const pm_token_t *operator,
    const pm_token_t *opening,
    const pm_token_t *closing,
    pm_node_t *parameters,
    pm_node_t *body
) {
    pm_lambda_node_t *node = PM_NODE_ALLOC(parser, pm_lambda_node_t);

    *node = (pm_lambda_node_t) {
        {
            .type = PM_LAMBDA_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = operator->start,
                .end = closing->end
            },
        },
        .locals = *locals,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .opening_loc = PM_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_LOCATION_TOKEN_VALUE(closing),
        .parameters = parameters,
        .body = body
    };

    return node;
}

/**
 * Allocate and initialize a new LocalVariableAndWriteNode node.
 */
static pm_local_variable_and_write_node_t *
pm_local_variable_and_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value, pm_constant_id_t name, uint32_t depth) {
    assert(PM_NODE_TYPE_P(target, PM_LOCAL_VARIABLE_READ_NODE) || PM_NODE_TYPE_P(target, PM_IT_LOCAL_VARIABLE_READ_NODE) || PM_NODE_TYPE_P(target, PM_CALL_NODE));
    assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
    pm_local_variable_and_write_node_t *node = PM_NODE_ALLOC(parser, pm_local_variable_and_write_node_t);

    *node = (pm_local_variable_and_write_node_t) {
        {
            .type = PM_LOCAL_VARIABLE_AND_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->location.start,
                .end = value->location.end
            }
        },
        .name_loc = target->location,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value,
        .name = name,
        .depth = depth
    };

    return node;
}

/**
 * Allocate and initialize a new LocalVariableOperatorWriteNode node.
 */
static pm_local_variable_operator_write_node_t *
pm_local_variable_operator_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value, pm_constant_id_t name, uint32_t depth) {
    pm_local_variable_operator_write_node_t *node = PM_NODE_ALLOC(parser, pm_local_variable_operator_write_node_t);

    *node = (pm_local_variable_operator_write_node_t) {
        {
            .type = PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->location.start,
                .end = value->location.end
            }
        },
        .name_loc = target->location,
        .binary_operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value,
        .name = name,
        .binary_operator = pm_parser_constant_id_location(parser, operator->start, operator->end - 1),
        .depth = depth
    };

    return node;
}

/**
 * Allocate and initialize a new LocalVariableOrWriteNode node.
 */
static pm_local_variable_or_write_node_t *
pm_local_variable_or_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value, pm_constant_id_t name, uint32_t depth) {
    assert(PM_NODE_TYPE_P(target, PM_LOCAL_VARIABLE_READ_NODE) || PM_NODE_TYPE_P(target, PM_IT_LOCAL_VARIABLE_READ_NODE) || PM_NODE_TYPE_P(target, PM_CALL_NODE));
    assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
    pm_local_variable_or_write_node_t *node = PM_NODE_ALLOC(parser, pm_local_variable_or_write_node_t);

    *node = (pm_local_variable_or_write_node_t) {
        {
            .type = PM_LOCAL_VARIABLE_OR_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->location.start,
                .end = value->location.end
            }
        },
        .name_loc = target->location,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value,
        .name = name,
        .depth = depth
    };

    return node;
}

/**
 * Allocate a new LocalVariableReadNode node with constant_id.
 */
static pm_local_variable_read_node_t *
pm_local_variable_read_node_create_constant_id(pm_parser_t *parser, const pm_token_t *name, pm_constant_id_t name_id, uint32_t depth, bool missing) {
    if (!missing) pm_locals_read(&pm_parser_scope_find(parser, depth)->locals, name_id);

    pm_local_variable_read_node_t *node = PM_NODE_ALLOC(parser, pm_local_variable_read_node_t);

    *node = (pm_local_variable_read_node_t) {
        {
            .type = PM_LOCAL_VARIABLE_READ_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(name)
        },
        .name = name_id,
        .depth = depth
    };

    return node;
}

/**
 * Allocate and initialize a new LocalVariableReadNode node.
 */
static pm_local_variable_read_node_t *
pm_local_variable_read_node_create(pm_parser_t *parser, const pm_token_t *name, uint32_t depth) {
    pm_constant_id_t name_id = pm_parser_constant_id_token(parser, name);
    return pm_local_variable_read_node_create_constant_id(parser, name, name_id, depth, false);
}

/**
 * Allocate and initialize a new LocalVariableReadNode node for a missing local
 * variable. (This will only happen when there is a syntax error.)
 */
static pm_local_variable_read_node_t *
pm_local_variable_read_node_missing_create(pm_parser_t *parser, const pm_token_t *name, uint32_t depth) {
    pm_constant_id_t name_id = pm_parser_constant_id_token(parser, name);
    return pm_local_variable_read_node_create_constant_id(parser, name, name_id, depth, true);
}

/**
 * Allocate and initialize a new LocalVariableWriteNode node.
 */
static pm_local_variable_write_node_t *
pm_local_variable_write_node_create(pm_parser_t *parser, pm_constant_id_t name, uint32_t depth, pm_node_t *value, const pm_location_t *name_loc, const pm_token_t *operator) {
    pm_local_variable_write_node_t *node = PM_NODE_ALLOC(parser, pm_local_variable_write_node_t);

    *node = (pm_local_variable_write_node_t) {
        {
            .type = PM_LOCAL_VARIABLE_WRITE_NODE,
            .flags = pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = name_loc->start,
                .end = value->location.end
            }
        },
        .name = name,
        .depth = depth,
        .value = value,
        .name_loc = *name_loc,
        .operator_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(operator)
    };

    return node;
}

/**
 * Returns true if the given bounds comprise `it`.
 */
static inline bool
pm_token_is_it(const uint8_t *start, const uint8_t *end) {
    return (end - start == 2) && (start[0] == 'i') && (start[1] == 't');
}

/**
 * Returns true if the given bounds comprise a numbered parameter (i.e., they
 * are of the form /^_\d$/).
 */
static inline bool
pm_token_is_numbered_parameter(const uint8_t *start, const uint8_t *end) {
    return (end - start == 2) && (start[0] == '_') && (start[1] != '0') && (pm_char_is_decimal_digit(start[1]));
}

/**
 * Ensure the given bounds do not comprise a numbered parameter. If they do, add
 * an appropriate error message to the parser.
 */
static inline void
pm_refute_numbered_parameter(pm_parser_t *parser, const uint8_t *start, const uint8_t *end) {
    if (pm_token_is_numbered_parameter(start, end)) {
        PM_PARSER_ERR_FORMAT(parser, start, end, PM_ERR_PARAMETER_NUMBERED_RESERVED, start);
    }
}

/**
 * Allocate and initialize a new LocalVariableTargetNode node with the given
 * name and depth.
 */
static pm_local_variable_target_node_t *
pm_local_variable_target_node_create(pm_parser_t *parser, const pm_location_t *location, pm_constant_id_t name, uint32_t depth) {
    pm_refute_numbered_parameter(parser, location->start, location->end);
    pm_local_variable_target_node_t *node = PM_NODE_ALLOC(parser, pm_local_variable_target_node_t);

    *node = (pm_local_variable_target_node_t) {
        {
            .type = PM_LOCAL_VARIABLE_TARGET_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = *location
        },
        .name = name,
        .depth = depth
    };

    return node;
}

/**
 * Allocate and initialize a new MatchPredicateNode node.
 */
static pm_match_predicate_node_t *
pm_match_predicate_node_create(pm_parser_t *parser, pm_node_t *value, pm_node_t *pattern, const pm_token_t *operator) {
    pm_assert_value_expression(parser, value);

    pm_match_predicate_node_t *node = PM_NODE_ALLOC(parser, pm_match_predicate_node_t);

    *node = (pm_match_predicate_node_t) {
        {
            .type = PM_MATCH_PREDICATE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = value->location.start,
                .end = pattern->location.end
            }
        },
        .value = value,
        .pattern = pattern,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator)
    };

    return node;
}

/**
 * Allocate and initialize a new MatchRequiredNode node.
 */
static pm_match_required_node_t *
pm_match_required_node_create(pm_parser_t *parser, pm_node_t *value, pm_node_t *pattern, const pm_token_t *operator) {
    pm_assert_value_expression(parser, value);

    pm_match_required_node_t *node = PM_NODE_ALLOC(parser, pm_match_required_node_t);

    *node = (pm_match_required_node_t) {
        {
            .type = PM_MATCH_REQUIRED_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = value->location.start,
                .end = pattern->location.end
            }
        },
        .value = value,
        .pattern = pattern,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator)
    };

    return node;
}

/**
 * Allocate and initialize a new MatchWriteNode node.
 */
static pm_match_write_node_t *
pm_match_write_node_create(pm_parser_t *parser, pm_call_node_t *call) {
    pm_match_write_node_t *node = PM_NODE_ALLOC(parser, pm_match_write_node_t);

    *node = (pm_match_write_node_t) {
        {
            .type = PM_MATCH_WRITE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = call->base.location
        },
        .call = call,
        .targets = { 0 }
    };

    return node;
}

/**
 * Allocate a new ModuleNode node.
 */
static pm_module_node_t *
pm_module_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, const pm_token_t *module_keyword, pm_node_t *constant_path, const pm_token_t *name, pm_node_t *body, const pm_token_t *end_keyword) {
    pm_module_node_t *node = PM_NODE_ALLOC(parser, pm_module_node_t);

    *node = (pm_module_node_t) {
        {
            .type = PM_MODULE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = module_keyword->start,
                .end = end_keyword->end
            }
        },
        .locals = (locals == NULL ? ((pm_constant_id_list_t) { .ids = NULL, .size = 0, .capacity = 0 }) : *locals),
        .module_keyword_loc = PM_LOCATION_TOKEN_VALUE(module_keyword),
        .constant_path = constant_path,
        .body = body,
        .end_keyword_loc = PM_LOCATION_TOKEN_VALUE(end_keyword),
        .name = pm_parser_constant_id_token(parser, name)
    };

    return node;
}

/**
 * Allocate and initialize new MultiTargetNode node.
 */
static pm_multi_target_node_t *
pm_multi_target_node_create(pm_parser_t *parser) {
    pm_multi_target_node_t *node = PM_NODE_ALLOC(parser, pm_multi_target_node_t);

    *node = (pm_multi_target_node_t) {
        {
            .type = PM_MULTI_TARGET_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = { .start = NULL, .end = NULL }
        },
        .lefts = { 0 },
        .rest = NULL,
        .rights = { 0 },
        .lparen_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .rparen_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE
    };

    return node;
}

/**
 * Append a target to a MultiTargetNode node.
 */
static void
pm_multi_target_node_targets_append(pm_parser_t *parser, pm_multi_target_node_t *node, pm_node_t *target) {
    if (PM_NODE_TYPE_P(target, PM_SPLAT_NODE)) {
        if (node->rest == NULL) {
            node->rest = target;
        } else {
            pm_parser_err_node(parser, target, PM_ERR_MULTI_ASSIGN_MULTI_SPLATS);
            pm_node_list_append(&node->rights, target);
        }
    } else if (PM_NODE_TYPE_P(target, PM_IMPLICIT_REST_NODE)) {
        if (node->rest == NULL) {
            node->rest = target;
        } else {
            PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, parser->current, PM_ERR_MULTI_ASSIGN_UNEXPECTED_REST);
            pm_node_list_append(&node->rights, target);
        }
    } else if (node->rest == NULL) {
        pm_node_list_append(&node->lefts, target);
    } else {
        pm_node_list_append(&node->rights, target);
    }

    if (node->base.location.start == NULL || (node->base.location.start > target->location.start)) {
        node->base.location.start = target->location.start;
    }

    if (node->base.location.end == NULL || (node->base.location.end < target->location.end)) {
        node->base.location.end = target->location.end;
    }
}

/**
 * Set the opening of a MultiTargetNode node.
 */
static void
pm_multi_target_node_opening_set(pm_multi_target_node_t *node, const pm_token_t *lparen) {
    node->base.location.start = lparen->start;
    node->lparen_loc = PM_LOCATION_TOKEN_VALUE(lparen);
}

/**
 * Set the closing of a MultiTargetNode node.
 */
static void
pm_multi_target_node_closing_set(pm_multi_target_node_t *node, const pm_token_t *rparen) {
    node->base.location.end = rparen->end;
    node->rparen_loc = PM_LOCATION_TOKEN_VALUE(rparen);
}

/**
 * Allocate a new MultiWriteNode node.
 */
static pm_multi_write_node_t *
pm_multi_write_node_create(pm_parser_t *parser, pm_multi_target_node_t *target, const pm_token_t *operator, pm_node_t *value) {
    pm_multi_write_node_t *node = PM_NODE_ALLOC(parser, pm_multi_write_node_t);

    *node = (pm_multi_write_node_t) {
        {
            .type = PM_MULTI_WRITE_NODE,
            .flags = pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = target->base.location.start,
                .end = value->location.end
            }
        },
        .lefts = target->lefts,
        .rest = target->rest,
        .rights = target->rights,
        .lparen_loc = target->lparen_loc,
        .rparen_loc = target->rparen_loc,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    // Explicitly do not call pm_node_destroy here because we want to keep
    // around all of the information within the MultiWriteNode node.
    xfree(target);

    return node;
}

/**
 * Allocate and initialize a new NextNode node.
 */
static pm_next_node_t *
pm_next_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_arguments_node_t *arguments) {
    assert(keyword->type == PM_TOKEN_KEYWORD_NEXT);
    pm_next_node_t *node = PM_NODE_ALLOC(parser, pm_next_node_t);

    *node = (pm_next_node_t) {
        {
            .type = PM_NEXT_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = keyword->start,
                .end = (arguments == NULL ? keyword->end : arguments->base.location.end)
            }
        },
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),
        .arguments = arguments
    };

    return node;
}

/**
 * Allocate and initialize a new NilNode node.
 */
static pm_nil_node_t *
pm_nil_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_KEYWORD_NIL);
    pm_nil_node_t *node = PM_NODE_ALLOC(parser, pm_nil_node_t);

    *node = (pm_nil_node_t) {{
        .type = PM_NIL_NODE,
        .flags = PM_NODE_FLAG_STATIC_LITERAL,
        .node_id = PM_NODE_IDENTIFY(parser),
        .location = PM_LOCATION_TOKEN_VALUE(token)
    }};

    return node;
}

/**
 * Allocate and initialize a new NoKeywordsParameterNode node.
 */
static pm_no_keywords_parameter_node_t *
pm_no_keywords_parameter_node_create(pm_parser_t *parser, const pm_token_t *operator, const pm_token_t *keyword) {
    assert(operator->type == PM_TOKEN_USTAR_STAR || operator->type == PM_TOKEN_STAR_STAR);
    assert(keyword->type == PM_TOKEN_KEYWORD_NIL);
    pm_no_keywords_parameter_node_t *node = PM_NODE_ALLOC(parser, pm_no_keywords_parameter_node_t);

    *node = (pm_no_keywords_parameter_node_t) {
        {
            .type = PM_NO_KEYWORDS_PARAMETER_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = operator->start,
                .end = keyword->end
            }
        },
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword)
    };

    return node;
}

/**
 * Allocate and initialize a new NumberedParametersNode node.
 */
static pm_numbered_parameters_node_t *
pm_numbered_parameters_node_create(pm_parser_t *parser, const pm_location_t *location, uint8_t maximum) {
    pm_numbered_parameters_node_t *node = PM_NODE_ALLOC(parser, pm_numbered_parameters_node_t);

    *node = (pm_numbered_parameters_node_t) {
        {
            .type = PM_NUMBERED_PARAMETERS_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = *location
        },
        .maximum = maximum
    };

    return node;
}

/**
 * The maximum numbered reference value is defined as the maximum value that an
 * integer can hold minus 1 bit for CRuby instruction sequence operand tagging.
 */
#define NTH_REF_MAX ((uint32_t) (INT_MAX >> 1))

/**
 * Parse the decimal number represented by the range of bytes. Returns
 * 0 if the number fails to parse or if the number is greater than the maximum
 * value representable by a numbered reference. This function assumes that the
 * range of bytes has already been validated to contain only decimal digits.
 */
static uint32_t
pm_numbered_reference_read_node_number(pm_parser_t *parser, const pm_token_t *token) {
    const uint8_t *start = token->start + 1;
    const uint8_t *end = token->end;

    ptrdiff_t diff = end - start;
    assert(diff > 0);
#if PTRDIFF_MAX > SIZE_MAX
    assert(diff < (ptrdiff_t) SIZE_MAX);
#endif
    size_t length = (size_t) diff;

    char *digits = xcalloc(length + 1, sizeof(char));
    memcpy(digits, start, length);
    digits[length] = '\0';

    char *endptr;
    errno = 0;
    unsigned long value = strtoul(digits, &endptr, 10);

    if ((digits == endptr) || (*endptr != '\0')) {
        pm_parser_err(parser, start, end, PM_ERR_INVALID_NUMBER_DECIMAL);
        value = 0;
    }

    xfree(digits);

    if ((errno == ERANGE) || (value > NTH_REF_MAX)) {
        PM_PARSER_WARN_FORMAT(parser, start, end, PM_WARN_INVALID_NUMBERED_REFERENCE, (int) (length + 1), (const char *) token->start);
        value = 0;
    }

    return (uint32_t) value;
}

#undef NTH_REF_MAX

/**
 * Allocate and initialize a new NthReferenceReadNode node.
 */
static pm_numbered_reference_read_node_t *
pm_numbered_reference_read_node_create(pm_parser_t *parser, const pm_token_t *name) {
    assert(name->type == PM_TOKEN_NUMBERED_REFERENCE);
    pm_numbered_reference_read_node_t *node = PM_NODE_ALLOC(parser, pm_numbered_reference_read_node_t);

    *node = (pm_numbered_reference_read_node_t) {
        {
            .type = PM_NUMBERED_REFERENCE_READ_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(name),
        },
        .number = pm_numbered_reference_read_node_number(parser, name)
    };

    return node;
}

/**
 * Allocate a new OptionalParameterNode node.
 */
static pm_optional_parameter_node_t *
pm_optional_parameter_node_create(pm_parser_t *parser, const pm_token_t *name, const pm_token_t *operator, pm_node_t *value) {
    pm_optional_parameter_node_t *node = PM_NODE_ALLOC(parser, pm_optional_parameter_node_t);

    *node = (pm_optional_parameter_node_t) {
        {
            .type = PM_OPTIONAL_PARAMETER_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = name->start,
                .end = value->location.end
            }
        },
        .name = pm_parser_constant_id_token(parser, name),
        .name_loc = PM_LOCATION_TOKEN_VALUE(name),
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .value = value
    };

    return node;
}

/**
 * Allocate and initialize a new OrNode node.
 */
static pm_or_node_t *
pm_or_node_create(pm_parser_t *parser, pm_node_t *left, const pm_token_t *operator, pm_node_t *right) {
    pm_assert_value_expression(parser, left);

    pm_or_node_t *node = PM_NODE_ALLOC(parser, pm_or_node_t);

    *node = (pm_or_node_t) {
        {
            .type = PM_OR_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = left->location.start,
                .end = right->location.end
            }
        },
        .left = left,
        .right = right,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator)
    };

    return node;
}

/**
 * Allocate and initialize a new ParametersNode node.
 */
static pm_parameters_node_t *
pm_parameters_node_create(pm_parser_t *parser) {
    pm_parameters_node_t *node = PM_NODE_ALLOC(parser, pm_parameters_node_t);

    *node = (pm_parameters_node_t) {
        {
            .type = PM_PARAMETERS_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(&parser->current)
        },
        .rest = NULL,
        .keyword_rest = NULL,
        .block = NULL,
        .requireds = { 0 },
        .optionals = { 0 },
        .posts = { 0 },
        .keywords = { 0 }
    };

    return node;
}

/**
 * Set the location properly for the parameters node.
 */
static void
pm_parameters_node_location_set(pm_parameters_node_t *params, pm_node_t *param) {
    if (params->base.location.start == NULL) {
        params->base.location.start = param->location.start;
    } else {
        params->base.location.start = params->base.location.start < param->location.start ? params->base.location.start : param->location.start;
    }

    if (params->base.location.end == NULL) {
        params->base.location.end = param->location.end;
    } else {
        params->base.location.end = params->base.location.end > param->location.end ? params->base.location.end : param->location.end;
    }
}

/**
 * Append a required parameter to a ParametersNode node.
 */
static void
pm_parameters_node_requireds_append(pm_parameters_node_t *params, pm_node_t *param) {
    pm_parameters_node_location_set(params, param);
    pm_node_list_append(¶ms->requireds, param);
}

/**
 * Append an optional parameter to a ParametersNode node.
 */
static void
pm_parameters_node_optionals_append(pm_parameters_node_t *params, pm_optional_parameter_node_t *param) {
    pm_parameters_node_location_set(params, (pm_node_t *) param);
    pm_node_list_append(¶ms->optionals, (pm_node_t *) param);
}

/**
 * Append a post optional arguments parameter to a ParametersNode node.
 */
static void
pm_parameters_node_posts_append(pm_parameters_node_t *params, pm_node_t *param) {
    pm_parameters_node_location_set(params, param);
    pm_node_list_append(¶ms->posts, param);
}

/**
 * Set the rest parameter on a ParametersNode node.
 */
static void
pm_parameters_node_rest_set(pm_parameters_node_t *params, pm_node_t *param) {
    pm_parameters_node_location_set(params, param);
    params->rest = param;
}

/**
 * Append a keyword parameter to a ParametersNode node.
 */
static void
pm_parameters_node_keywords_append(pm_parameters_node_t *params, pm_node_t *param) {
    pm_parameters_node_location_set(params, param);
    pm_node_list_append(¶ms->keywords, param);
}

/**
 * Set the keyword rest parameter on a ParametersNode node.
 */
static void
pm_parameters_node_keyword_rest_set(pm_parameters_node_t *params, pm_node_t *param) {
    assert(params->keyword_rest == NULL);
    pm_parameters_node_location_set(params, param);
    params->keyword_rest = param;
}

/**
 * Set the block parameter on a ParametersNode node.
 */
static void
pm_parameters_node_block_set(pm_parameters_node_t *params, pm_block_parameter_node_t *param) {
    assert(params->block == NULL);
    pm_parameters_node_location_set(params, (pm_node_t *) param);
    params->block = param;
}

/**
 * Allocate a new ProgramNode node.
 */
static pm_program_node_t *
pm_program_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, pm_statements_node_t *statements) {
    pm_program_node_t *node = PM_NODE_ALLOC(parser, pm_program_node_t);

    *node = (pm_program_node_t) {
        {
            .type = PM_PROGRAM_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = statements == NULL ? parser->start : statements->base.location.start,
                .end = statements == NULL ? parser->end : statements->base.location.end
            }
        },
        .locals = *locals,
        .statements = statements
    };

    return node;
}

/**
 * Allocate and initialize new ParenthesesNode node.
 */
static pm_parentheses_node_t *
pm_parentheses_node_create(pm_parser_t *parser, const pm_token_t *opening, pm_node_t *body, const pm_token_t *closing, pm_node_flags_t flags) {
    pm_parentheses_node_t *node = PM_NODE_ALLOC(parser, pm_parentheses_node_t);

    *node = (pm_parentheses_node_t) {
        {
            .type = PM_PARENTHESES_NODE,
            .flags = flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = opening->start,
                .end = closing->end
            }
        },
        .body = body,
        .opening_loc = PM_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_LOCATION_TOKEN_VALUE(closing)
    };

    return node;
}

/**
 * Allocate and initialize a new PinnedExpressionNode node.
 */
static pm_pinned_expression_node_t *
pm_pinned_expression_node_create(pm_parser_t *parser, pm_node_t *expression, const pm_token_t *operator, const pm_token_t *lparen, const pm_token_t *rparen) {
    pm_pinned_expression_node_t *node = PM_NODE_ALLOC(parser, pm_pinned_expression_node_t);

    *node = (pm_pinned_expression_node_t) {
        {
            .type = PM_PINNED_EXPRESSION_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = operator->start,
                .end = rparen->end
            }
        },
        .expression = expression,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .lparen_loc = PM_LOCATION_TOKEN_VALUE(lparen),
        .rparen_loc = PM_LOCATION_TOKEN_VALUE(rparen)
    };

    return node;
}

/**
 * Allocate and initialize a new PinnedVariableNode node.
 */
static pm_pinned_variable_node_t *
pm_pinned_variable_node_create(pm_parser_t *parser, const pm_token_t *operator, pm_node_t *variable) {
    pm_pinned_variable_node_t *node = PM_NODE_ALLOC(parser, pm_pinned_variable_node_t);

    *node = (pm_pinned_variable_node_t) {
        {
            .type = PM_PINNED_VARIABLE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = operator->start,
                .end = variable->location.end
            }
        },
        .variable = variable,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator)
    };

    return node;
}

/**
 * Allocate and initialize a new PostExecutionNode node.
 */
static pm_post_execution_node_t *
pm_post_execution_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_token_t *opening, pm_statements_node_t *statements, const pm_token_t *closing) {
    pm_post_execution_node_t *node = PM_NODE_ALLOC(parser, pm_post_execution_node_t);

    *node = (pm_post_execution_node_t) {
        {
            .type = PM_POST_EXECUTION_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = keyword->start,
                .end = closing->end
            }
        },
        .statements = statements,
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),
        .opening_loc = PM_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_LOCATION_TOKEN_VALUE(closing)
    };

    return node;
}

/**
 * Allocate and initialize a new PreExecutionNode node.
 */
static pm_pre_execution_node_t *
pm_pre_execution_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_token_t *opening, pm_statements_node_t *statements, const pm_token_t *closing) {
    pm_pre_execution_node_t *node = PM_NODE_ALLOC(parser, pm_pre_execution_node_t);

    *node = (pm_pre_execution_node_t) {
        {
            .type = PM_PRE_EXECUTION_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = keyword->start,
                .end = closing->end
            }
        },
        .statements = statements,
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),
        .opening_loc = PM_LOCATION_TOKEN_VALUE(opening),
        .closing_loc = PM_LOCATION_TOKEN_VALUE(closing)
    };

    return node;
}

/**
 * Allocate and initialize new RangeNode node.
 */
static pm_range_node_t *
pm_range_node_create(pm_parser_t *parser, pm_node_t *left, const pm_token_t *operator, pm_node_t *right) {
    pm_assert_value_expression(parser, left);
    pm_assert_value_expression(parser, right);

    pm_range_node_t *node = PM_NODE_ALLOC(parser, pm_range_node_t);
    pm_node_flags_t flags = 0;

    // Indicate that this node is an exclusive range if the operator is `...`.
    if (operator->type == PM_TOKEN_DOT_DOT_DOT || operator->type == PM_TOKEN_UDOT_DOT_DOT) {
        flags |= PM_RANGE_FLAGS_EXCLUDE_END;
    }

    // Indicate that this node is a static literal (i.e., can be compiled with
    // a putobject in CRuby) if the left and right are implicit nil, explicit
    // nil, or integers.
    if (
        (left == NULL || PM_NODE_TYPE_P(left, PM_NIL_NODE) || PM_NODE_TYPE_P(left, PM_INTEGER_NODE)) &&
        (right == NULL || PM_NODE_TYPE_P(right, PM_NIL_NODE) || PM_NODE_TYPE_P(right, PM_INTEGER_NODE))
    ) {
        flags |= PM_NODE_FLAG_STATIC_LITERAL;
    }

    *node = (pm_range_node_t) {
        {
            .type = PM_RANGE_NODE,
            .flags = flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = (left == NULL ? operator->start : left->location.start),
                .end = (right == NULL ? operator->end : right->location.end)
            }
        },
        .left = left,
        .right = right,
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator)
    };

    return node;
}

/**
 * Allocate and initialize a new RedoNode node.
 */
static pm_redo_node_t *
pm_redo_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_KEYWORD_REDO);
    pm_redo_node_t *node = PM_NODE_ALLOC(parser, pm_redo_node_t);

    *node = (pm_redo_node_t) {{
        .type = PM_REDO_NODE,
        .node_id = PM_NODE_IDENTIFY(parser),
        .location = PM_LOCATION_TOKEN_VALUE(token)
    }};

    return node;
}

/**
 * Allocate a new initialize a new RegularExpressionNode node with the given
 * unescaped string.
 */
static pm_regular_expression_node_t *
pm_regular_expression_node_create_unescaped(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing, const pm_string_t *unescaped) {
    pm_regular_expression_node_t *node = PM_NODE_ALLOC(parser, pm_regular_expression_node_t);

    *node = (pm_regular_expression_node_t) {
        {
            .type = PM_REGULAR_EXPRESSION_NODE,
            .flags = pm_regular_expression_flags_create(parser, closing) | PM_NODE_FLAG_STATIC_LITERAL,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = MIN(opening->start, closing->start),
                .end = MAX(opening->end, closing->end)
            }
        },
        .opening_loc = PM_LOCATION_TOKEN_VALUE(opening),
        .content_loc = PM_LOCATION_TOKEN_VALUE(content),
        .closing_loc = PM_LOCATION_TOKEN_VALUE(closing),
        .unescaped = *unescaped
    };

    return node;
}

/**
 * Allocate a new initialize a new RegularExpressionNode node.
 */
static inline pm_regular_expression_node_t *
pm_regular_expression_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing) {
    return pm_regular_expression_node_create_unescaped(parser, opening, content, closing, &PM_STRING_EMPTY);
}

/**
 * Allocate a new RequiredParameterNode node.
 */
static pm_required_parameter_node_t *
pm_required_parameter_node_create(pm_parser_t *parser, const pm_token_t *token) {
    pm_required_parameter_node_t *node = PM_NODE_ALLOC(parser, pm_required_parameter_node_t);

    *node = (pm_required_parameter_node_t) {
        {
            .type = PM_REQUIRED_PARAMETER_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(token)
        },
        .name = pm_parser_constant_id_token(parser, token)
    };

    return node;
}

/**
 * Allocate a new RescueModifierNode node.
 */
static pm_rescue_modifier_node_t *
pm_rescue_modifier_node_create(pm_parser_t *parser, pm_node_t *expression, const pm_token_t *keyword, pm_node_t *rescue_expression) {
    pm_rescue_modifier_node_t *node = PM_NODE_ALLOC(parser, pm_rescue_modifier_node_t);

    *node = (pm_rescue_modifier_node_t) {
        {
            .type = PM_RESCUE_MODIFIER_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = expression->location.start,
                .end = rescue_expression->location.end
            }
        },
        .expression = expression,
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),
        .rescue_expression = rescue_expression
    };

    return node;
}

/**
 * Allocate and initialize a new RescueNode node.
 */
static pm_rescue_node_t *
pm_rescue_node_create(pm_parser_t *parser, const pm_token_t *keyword) {
    pm_rescue_node_t *node = PM_NODE_ALLOC(parser, pm_rescue_node_t);

    *node = (pm_rescue_node_t) {
        {
            .type = PM_RESCUE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(keyword)
        },
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),
        .operator_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .then_keyword_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .reference = NULL,
        .statements = NULL,
        .subsequent = NULL,
        .exceptions = { 0 }
    };

    return node;
}

static inline void
pm_rescue_node_operator_set(pm_rescue_node_t *node, const pm_token_t *operator) {
    node->operator_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(operator);
}

/**
 * Set the reference of a rescue node, and update the location of the node.
 */
static void
pm_rescue_node_reference_set(pm_rescue_node_t *node, pm_node_t *reference) {
    node->reference = reference;
    node->base.location.end = reference->location.end;
}

/**
 * Set the statements of a rescue node, and update the location of the node.
 */
static void
pm_rescue_node_statements_set(pm_rescue_node_t *node, pm_statements_node_t *statements) {
    node->statements = statements;
    if (pm_statements_node_body_length(statements) > 0) {
        node->base.location.end = statements->base.location.end;
    }
}

/**
 * Set the subsequent of a rescue node, and update the location.
 */
static void
pm_rescue_node_subsequent_set(pm_rescue_node_t *node, pm_rescue_node_t *subsequent) {
    node->subsequent = subsequent;
    node->base.location.end = subsequent->base.location.end;
}

/**
 * Append an exception node to a rescue node, and update the location.
 */
static void
pm_rescue_node_exceptions_append(pm_rescue_node_t *node, pm_node_t *exception) {
    pm_node_list_append(&node->exceptions, exception);
    node->base.location.end = exception->location.end;
}

/**
 * Allocate a new RestParameterNode node.
 */
static pm_rest_parameter_node_t *
pm_rest_parameter_node_create(pm_parser_t *parser, const pm_token_t *operator, const pm_token_t *name) {
    pm_rest_parameter_node_t *node = PM_NODE_ALLOC(parser, pm_rest_parameter_node_t);

    *node = (pm_rest_parameter_node_t) {
        {
            .type = PM_REST_PARAMETER_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = operator->start,
                .end = (name->type == PM_TOKEN_NOT_PROVIDED ? operator->end : name->end)
            }
        },
        .name = pm_parser_optional_constant_id_token(parser, name),
        .name_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(name),
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator)
    };

    return node;
}

/**
 * Allocate and initialize a new RetryNode node.
 */
static pm_retry_node_t *
pm_retry_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_KEYWORD_RETRY);
    pm_retry_node_t *node = PM_NODE_ALLOC(parser, pm_retry_node_t);

    *node = (pm_retry_node_t) {{
        .type = PM_RETRY_NODE,
        .node_id = PM_NODE_IDENTIFY(parser),
        .location = PM_LOCATION_TOKEN_VALUE(token)
    }};

    return node;
}

/**
 * Allocate a new ReturnNode node.
 */
static pm_return_node_t *
pm_return_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_arguments_node_t *arguments) {
    pm_return_node_t *node = PM_NODE_ALLOC(parser, pm_return_node_t);

    *node = (pm_return_node_t) {
        {
            .type = PM_RETURN_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = keyword->start,
                .end = (arguments == NULL ? keyword->end : arguments->base.location.end)
            }
        },
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),
        .arguments = arguments
    };

    return node;
}

/**
 * Allocate and initialize a new SelfNode node.
 */
static pm_self_node_t *
pm_self_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_KEYWORD_SELF);
    pm_self_node_t *node = PM_NODE_ALLOC(parser, pm_self_node_t);

    *node = (pm_self_node_t) {{
        .type = PM_SELF_NODE,
        .node_id = PM_NODE_IDENTIFY(parser),
        .location = PM_LOCATION_TOKEN_VALUE(token)
    }};

    return node;
}

/**
 * Allocate and initialize a new ShareableConstantNode node.
 */
static pm_shareable_constant_node_t *
pm_shareable_constant_node_create(pm_parser_t *parser, pm_node_t *write, pm_shareable_constant_value_t value) {
    pm_shareable_constant_node_t *node = PM_NODE_ALLOC(parser, pm_shareable_constant_node_t);

    *node = (pm_shareable_constant_node_t) {
        {
            .type = PM_SHAREABLE_CONSTANT_NODE,
            .flags = (pm_node_flags_t) value,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_NODE_VALUE(write)
        },
        .write = write
    };

    return node;
}

/**
 * Allocate a new SingletonClassNode node.
 */
static pm_singleton_class_node_t *
pm_singleton_class_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, const pm_token_t *class_keyword, const pm_token_t *operator, pm_node_t *expression, pm_node_t *body, const pm_token_t *end_keyword) {
    pm_singleton_class_node_t *node = PM_NODE_ALLOC(parser, pm_singleton_class_node_t);

    *node = (pm_singleton_class_node_t) {
        {
            .type = PM_SINGLETON_CLASS_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = class_keyword->start,
                .end = end_keyword->end
            }
        },
        .locals = *locals,
        .class_keyword_loc = PM_LOCATION_TOKEN_VALUE(class_keyword),
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .expression = expression,
        .body = body,
        .end_keyword_loc = PM_LOCATION_TOKEN_VALUE(end_keyword)
    };

    return node;
}

/**
 * Allocate and initialize a new SourceEncodingNode node.
 */
static pm_source_encoding_node_t *
pm_source_encoding_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_KEYWORD___ENCODING__);
    pm_source_encoding_node_t *node = PM_NODE_ALLOC(parser, pm_source_encoding_node_t);

    *node = (pm_source_encoding_node_t) {{
        .type = PM_SOURCE_ENCODING_NODE,
        .flags = PM_NODE_FLAG_STATIC_LITERAL,
        .node_id = PM_NODE_IDENTIFY(parser),
        .location = PM_LOCATION_TOKEN_VALUE(token)
    }};

    return node;
}

/**
 * Allocate and initialize a new SourceFileNode node.
 */
static pm_source_file_node_t*
pm_source_file_node_create(pm_parser_t *parser, const pm_token_t *file_keyword) {
    pm_source_file_node_t *node = PM_NODE_ALLOC(parser, pm_source_file_node_t);
    assert(file_keyword->type == PM_TOKEN_KEYWORD___FILE__);

    pm_node_flags_t flags = 0;

    switch (parser->frozen_string_literal) {
        case PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED:
            flags |= PM_STRING_FLAGS_MUTABLE;
            break;
        case PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED:
            flags |= PM_NODE_FLAG_STATIC_LITERAL | PM_STRING_FLAGS_FROZEN;
            break;
    }

    *node = (pm_source_file_node_t) {
        {
            .type = PM_SOURCE_FILE_NODE,
            .flags = flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(file_keyword),
        },
        .filepath = parser->filepath
    };

    return node;
}

/**
 * Allocate and initialize a new SourceLineNode node.
 */
static pm_source_line_node_t *
pm_source_line_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_KEYWORD___LINE__);
    pm_source_line_node_t *node = PM_NODE_ALLOC(parser, pm_source_line_node_t);

    *node = (pm_source_line_node_t) {{
        .type = PM_SOURCE_LINE_NODE,
        .flags = PM_NODE_FLAG_STATIC_LITERAL,
        .node_id = PM_NODE_IDENTIFY(parser),
        .location = PM_LOCATION_TOKEN_VALUE(token)
    }};

    return node;
}

/**
 * Allocate a new SplatNode node.
 */
static pm_splat_node_t *
pm_splat_node_create(pm_parser_t *parser, const pm_token_t *operator, pm_node_t *expression) {
    pm_splat_node_t *node = PM_NODE_ALLOC(parser, pm_splat_node_t);

    *node = (pm_splat_node_t) {
        {
            .type = PM_SPLAT_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = operator->start,
                .end = (expression == NULL ? operator->end : expression->location.end)
            }
        },
        .operator_loc = PM_LOCATION_TOKEN_VALUE(operator),
        .expression = expression
    };

    return node;
}

/**
 * Allocate and initialize a new StatementsNode node.
 */
static pm_statements_node_t *
pm_statements_node_create(pm_parser_t *parser) {
    pm_statements_node_t *node = PM_NODE_ALLOC(parser, pm_statements_node_t);

    *node = (pm_statements_node_t) {
        {
            .type = PM_STATEMENTS_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_NULL_VALUE(parser)
        },
        .body = { 0 }
    };

    return node;
}

/**
 * Get the length of the given StatementsNode node's body.
 */
static size_t
pm_statements_node_body_length(pm_statements_node_t *node) {
    return node && node->body.size;
}

/**
 * Set the location of the given StatementsNode.
 */
static void
pm_statements_node_location_set(pm_statements_node_t *node, const uint8_t *start, const uint8_t *end) {
    node->base.location = (pm_location_t) { .start = start, .end = end };
}

/**
 * Update the location of the statements node based on the statement that is
 * being added to the list.
 */
static inline void
pm_statements_node_body_update(pm_statements_node_t *node, pm_node_t *statement) {
    if (pm_statements_node_body_length(node) == 0 || statement->location.start < node->base.location.start) {
        node->base.location.start = statement->location.start;
    }

    if (statement->location.end > node->base.location.end) {
        node->base.location.end = statement->location.end;
    }
}

/**
 * Append a new node to the given StatementsNode node's body.
 */
static void
pm_statements_node_body_append(pm_parser_t *parser, pm_statements_node_t *node, pm_node_t *statement, bool newline) {
    pm_statements_node_body_update(node, statement);

    if (node->body.size > 0) {
        const pm_node_t *previous = node->body.nodes[node->body.size - 1];

        switch (PM_NODE_TYPE(previous)) {
            case PM_BREAK_NODE:
            case PM_NEXT_NODE:
            case PM_REDO_NODE:
            case PM_RETRY_NODE:
            case PM_RETURN_NODE:
                pm_parser_warn_node(parser, statement, PM_WARN_UNREACHABLE_STATEMENT);
                break;
            default:
                break;
        }
    }

    pm_node_list_append(&node->body, statement);
    if (newline) pm_node_flag_set(statement, PM_NODE_FLAG_NEWLINE);
}

/**
 * Prepend a new node to the given StatementsNode node's body.
 */
static void
pm_statements_node_body_prepend(pm_statements_node_t *node, pm_node_t *statement) {
    pm_statements_node_body_update(node, statement);
    pm_node_list_prepend(&node->body, statement);
    pm_node_flag_set(statement, PM_NODE_FLAG_NEWLINE);
}

/**
 * Allocate a new StringNode node with the current string on the parser.
 */
static inline pm_string_node_t *
pm_string_node_create_unescaped(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing, const pm_string_t *string) {
    pm_string_node_t *node = PM_NODE_ALLOC(parser, pm_string_node_t);
    pm_node_flags_t flags = 0;

    switch (parser->frozen_string_literal) {
        case PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED:
            flags = PM_STRING_FLAGS_MUTABLE;
            break;
        case PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED:
            flags = PM_NODE_FLAG_STATIC_LITERAL | PM_STRING_FLAGS_FROZEN;
            break;
    }

    *node = (pm_string_node_t) {
        {
            .type = PM_STRING_NODE,
            .flags = flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = (opening->type == PM_TOKEN_NOT_PROVIDED ? content->start : opening->start),
                .end = (closing->type == PM_TOKEN_NOT_PROVIDED ? content->end : closing->end)
            }
        },
        .opening_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(opening),
        .content_loc = PM_LOCATION_TOKEN_VALUE(content),
        .closing_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(closing),
        .unescaped = *string
    };

    return node;
}

/**
 * Allocate a new StringNode node.
 */
static pm_string_node_t *
pm_string_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing) {
    return pm_string_node_create_unescaped(parser, opening, content, closing, &PM_STRING_EMPTY);
}

/**
 * Allocate a new StringNode node and create it using the current string on the
 * parser.
 */
static pm_string_node_t *
pm_string_node_create_current_string(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing) {
    pm_string_node_t *node = pm_string_node_create_unescaped(parser, opening, content, closing, &parser->current_string);
    parser->current_string = PM_STRING_EMPTY;
    return node;
}

/**
 * Allocate and initialize a new SuperNode node.
 */
static pm_super_node_t *
pm_super_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_arguments_t *arguments) {
    assert(keyword->type == PM_TOKEN_KEYWORD_SUPER);
    pm_super_node_t *node = PM_NODE_ALLOC(parser, pm_super_node_t);

    const uint8_t *end = pm_arguments_end(arguments);
    if (end == NULL) {
        assert(false && "unreachable");
    }

    *node = (pm_super_node_t) {
        {
            .type = PM_SUPER_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = keyword->start,
                .end = end,
            }
        },
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),
        .lparen_loc = arguments->opening_loc,
        .arguments = arguments->arguments,
        .rparen_loc = arguments->closing_loc,
        .block = arguments->block
    };

    return node;
}

/**
 * Read through the contents of a string and check if it consists solely of
 * US-ASCII code points.
 */
static bool
pm_ascii_only_p(const pm_string_t *contents) {
    const size_t length = pm_string_length(contents);
    const uint8_t *source = pm_string_source(contents);

    for (size_t index = 0; index < length; index++) {
        if (source[index] & 0x80) return false;
    }

    return true;
}

/**
 * Validate that the contents of the given symbol are all valid UTF-8.
 */
static void
parse_symbol_encoding_validate_utf8(pm_parser_t *parser, const pm_token_t *location, const pm_string_t *contents) {
    for (const uint8_t *cursor = pm_string_source(contents), *end = cursor + pm_string_length(contents); cursor < end;) {
        size_t width = pm_encoding_utf_8_char_width(cursor, end - cursor);

        if (width == 0) {
            pm_parser_err(parser, location->start, location->end, PM_ERR_INVALID_SYMBOL);
            break;
        }

        cursor += width;
    }
}

/**
 * Validate that the contents of the given symbol are all valid in the encoding
 * of the parser.
 */
static void
parse_symbol_encoding_validate_other(pm_parser_t *parser, const pm_token_t *location, const pm_string_t *contents) {
    const pm_encoding_t *encoding = parser->encoding;

    for (const uint8_t *cursor = pm_string_source(contents), *end = cursor + pm_string_length(contents); cursor < end;) {
        size_t width = encoding->char_width(cursor, end - cursor);

        if (width == 0) {
            pm_parser_err(parser, location->start, location->end, PM_ERR_INVALID_SYMBOL);
            break;
        }

        cursor += width;
    }
}

/**
 * Ruby "downgrades" the encoding of Symbols to US-ASCII if the associated
 * encoding is ASCII-compatible and the Symbol consists only of US-ASCII code
 * points. Otherwise, the encoding may be explicitly set with an escape
 * sequence.
 *
 * If the validate flag is set, then it will check the contents of the symbol
 * to ensure that all characters are valid in the encoding.
 */
static inline pm_node_flags_t
parse_symbol_encoding(pm_parser_t *parser, const pm_token_t *location, const pm_string_t *contents, bool validate) {
    if (parser->explicit_encoding != NULL) {
        // A Symbol may optionally have its encoding explicitly set. This will
        // happen if an escape sequence results in a non-ASCII code point.
        if (parser->explicit_encoding == PM_ENCODING_UTF_8_ENTRY) {
            if (validate) parse_symbol_encoding_validate_utf8(parser, location, contents);
            return PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING;
        } else if (parser->encoding == PM_ENCODING_US_ASCII_ENTRY) {
            return PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING;
        } else if (validate) {
            parse_symbol_encoding_validate_other(parser, location, contents);
        }
    } else if (pm_ascii_only_p(contents)) {
        // Ruby stipulates that all source files must use an ASCII-compatible
        // encoding. Thus, all symbols appearing in source are eligible for
        // "downgrading" to US-ASCII.
        return PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING;
    } else if (validate) {
        parse_symbol_encoding_validate_other(parser, location, contents);
    }

    return 0;
}

static pm_node_flags_t
parse_and_validate_regular_expression_encoding_modifier(pm_parser_t *parser, const pm_string_t *source, bool ascii_only, pm_node_flags_t flags, char modifier, const pm_encoding_t *modifier_encoding) {
    assert ((modifier == 'n' && modifier_encoding == PM_ENCODING_ASCII_8BIT_ENTRY) ||
            (modifier == 'u' && modifier_encoding == PM_ENCODING_UTF_8_ENTRY) ||
            (modifier == 'e' && modifier_encoding == PM_ENCODING_EUC_JP_ENTRY) ||
            (modifier == 's' && modifier_encoding == PM_ENCODING_WINDOWS_31J_ENTRY));

    // There's special validation logic used if a string does not contain any character escape sequences.
    if (parser->explicit_encoding == NULL) {
        // If an ASCII-only string without character escapes is used with an encoding modifier, then resulting Regexp
        // has the modifier encoding, unless the ASCII-8BIT modifier is used, in which case the Regexp "downgrades" to
        // the US-ASCII encoding.
        if (ascii_only) {
            return modifier == 'n' ? PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING : flags;
        }

        if (parser->encoding == PM_ENCODING_US_ASCII_ENTRY) {
            if (!ascii_only) {
                PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_INVALID_MULTIBYTE_CHAR, parser->encoding->name);
            }
        } else if (parser->encoding != modifier_encoding) {
            PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_REGEXP_ENCODING_OPTION_MISMATCH, modifier, parser->encoding->name);

            if (modifier == 'n' && !ascii_only) {
                PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_REGEXP_NON_ESCAPED_MBC, (int) pm_string_length(source), (const char *) pm_string_source(source));
            }
        }

        return flags;
    }

    // TODO (nirvdrum 21-Feb-2024): To validate regexp sources with character escape sequences we need to know whether hex or Unicode escape sequences were used and Prism doesn't currently provide that data. We handle a subset of unambiguous cases in the meanwhile.
    bool mixed_encoding = false;

    if (mixed_encoding) {
        PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_INVALID_MULTIBYTE_ESCAPE, (int) pm_string_length(source), (const char *) pm_string_source(source));
    } else if (modifier != 'n' && parser->explicit_encoding == PM_ENCODING_ASCII_8BIT_ENTRY) {
        // TODO (nirvdrum 21-Feb-2024): Validate the content is valid in the modifier encoding. Do this on-demand so we don't pay the cost of computation unnecessarily.
        bool valid_string_in_modifier_encoding = true;

        if (!valid_string_in_modifier_encoding) {
            PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_INVALID_MULTIBYTE_ESCAPE, (int) pm_string_length(source), (const char *) pm_string_source(source));
        }
    } else if (modifier != 'u' && parser->explicit_encoding == PM_ENCODING_UTF_8_ENTRY) {
        // TODO (nirvdrum 21-Feb-2024): There's currently no way to tell if the source used hex or Unicode character escapes from `explicit_encoding` alone. If the source encoding was already UTF-8, both character escape types would set `explicit_encoding` to UTF-8, but need to be processed differently. Skip for now.
        if (parser->encoding != PM_ENCODING_UTF_8_ENTRY) {
            PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_REGEXP_INCOMPAT_CHAR_ENCODING, (int) pm_string_length(source), (const char *) pm_string_source(source));
        }
    }

    // We've determined the encoding would naturally be EUC-JP and there is no need to force the encoding to anything else.
    return flags;
}

/**
 * Ruby "downgrades" the encoding of Regexps to US-ASCII if the associated encoding is ASCII-compatible and
 * the unescaped representation of a Regexp source consists only of US-ASCII code points. This is true even
 * when the Regexp is explicitly given an ASCII-8BIT encoding via the (/n) modifier. Otherwise, the encoding
 * may be explicitly set with an escape sequence.
 */
static pm_node_flags_t
parse_and_validate_regular_expression_encoding(pm_parser_t *parser, const pm_string_t *source, bool ascii_only, pm_node_flags_t flags) {
    // TODO (nirvdrum 22-Feb-2024): CRuby reports a special Regexp-specific error for invalid Unicode ranges. We either need to scan again or modify the "invalid Unicode escape sequence" message we already report.
    bool valid_unicode_range = true;
    if (parser->explicit_encoding == PM_ENCODING_UTF_8_ENTRY && !valid_unicode_range) {
        PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_REGEXP_INVALID_UNICODE_RANGE, (int) pm_string_length(source), (const char *) pm_string_source(source));
        return flags;
    }

    // US-ASCII strings do not admit multi-byte character literals. However, character escape sequences corresponding
    // to multi-byte characters are allowed.
    if (parser->encoding == PM_ENCODING_US_ASCII_ENTRY && parser->explicit_encoding == NULL && !ascii_only) {
        // CRuby will continue processing even though a SyntaxError has already been detected. It may result in the
        // following error message appearing twice. We do the same for compatibility.
        PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_INVALID_MULTIBYTE_CHAR, parser->encoding->name);
    }

    /**
     * Start checking modifier flags. We need to process these before considering any explicit encodings that may have
     * been set by character literals. The order in which the encoding modifiers is checked does not matter. In the
     * event that both an encoding modifier and an explicit encoding would result in the same encoding we do not set
     * the corresponding "forced_" flag. Instead, the caller should check the encoding modifier flag and
     * determine the encoding that way.
     */

    if (flags & PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT) {
        return parse_and_validate_regular_expression_encoding_modifier(parser, source, ascii_only, flags, 'n', PM_ENCODING_ASCII_8BIT_ENTRY);
    }

    if (flags & PM_REGULAR_EXPRESSION_FLAGS_UTF_8) {
        return parse_and_validate_regular_expression_encoding_modifier(parser, source, ascii_only, flags, 'u', PM_ENCODING_UTF_8_ENTRY);
    }

    if (flags & PM_REGULAR_EXPRESSION_FLAGS_EUC_JP) {
        return parse_and_validate_regular_expression_encoding_modifier(parser, source, ascii_only, flags, 'e', PM_ENCODING_EUC_JP_ENTRY);
    }

    if (flags & PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J) {
        return parse_and_validate_regular_expression_encoding_modifier(parser, source, ascii_only, flags, 's', PM_ENCODING_WINDOWS_31J_ENTRY);
    }

    // At this point no encoding modifiers will be present on the regular expression as they would have already
    // been processed. Ruby stipulates that all source files must use an ASCII-compatible encoding. Thus, all
    // regular expressions without an encoding modifier appearing in source are eligible for "downgrading" to US-ASCII.
    if (ascii_only) {
        return PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING;
    }

    // A Regexp may optionally have its encoding explicitly set via a character escape sequence in the source string
    // or by specifying a modifier.
    //
    // NB: an explicitly set encoding is ignored by Ruby if the Regexp consists of only US ASCII code points.
    if (parser->explicit_encoding != NULL) {
        if (parser->explicit_encoding == PM_ENCODING_UTF_8_ENTRY) {
            return PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING;
        } else if (parser->encoding == PM_ENCODING_US_ASCII_ENTRY) {
            return PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING;
        }
    }

    return 0;
}

/**
 * Allocate and initialize a new SymbolNode node with the given unescaped
 * string.
 */
static pm_symbol_node_t *
pm_symbol_node_create_unescaped(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *value, const pm_token_t *closing, const pm_string_t *unescaped, pm_node_flags_t flags) {
    pm_symbol_node_t *node = PM_NODE_ALLOC(parser, pm_symbol_node_t);

    *node = (pm_symbol_node_t) {
        {
            .type = PM_SYMBOL_NODE,
            .flags = PM_NODE_FLAG_STATIC_LITERAL | flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = (opening->type == PM_TOKEN_NOT_PROVIDED ? value->start : opening->start),
                .end = (closing->type == PM_TOKEN_NOT_PROVIDED ? value->end : closing->end)
            }
        },
        .opening_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(opening),
        .value_loc = PM_LOCATION_TOKEN_VALUE(value),
        .closing_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(closing),
        .unescaped = *unescaped
    };

    return node;
}

/**
 * Allocate and initialize a new SymbolNode node.
 */
static inline pm_symbol_node_t *
pm_symbol_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *value, const pm_token_t *closing) {
    return pm_symbol_node_create_unescaped(parser, opening, value, closing, &PM_STRING_EMPTY, 0);
}

/**
 * Allocate and initialize a new SymbolNode node with the current string.
 */
static pm_symbol_node_t *
pm_symbol_node_create_current_string(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *value, const pm_token_t *closing) {
    pm_symbol_node_t *node = pm_symbol_node_create_unescaped(parser, opening, value, closing, &parser->current_string, parse_symbol_encoding(parser, value, &parser->current_string, false));
    parser->current_string = PM_STRING_EMPTY;
    return node;
}

/**
 * Allocate and initialize a new SymbolNode node from a label.
 */
static pm_symbol_node_t *
pm_symbol_node_label_create(pm_parser_t *parser, const pm_token_t *token) {
    pm_symbol_node_t *node;

    switch (token->type) {
        case PM_TOKEN_LABEL: {
            pm_token_t opening = not_provided(parser);
            pm_token_t closing = { .type = PM_TOKEN_LABEL_END, .start = token->end - 1, .end = token->end };

            pm_token_t label = { .type = PM_TOKEN_LABEL, .start = token->start, .end = token->end - 1 };
            node = pm_symbol_node_create(parser, &opening, &label, &closing);

            assert((label.end - label.start) >= 0);
            pm_string_shared_init(&node->unescaped, label.start, label.end);
            pm_node_flag_set((pm_node_t *) node, parse_symbol_encoding(parser, &label, &node->unescaped, false));

            break;
        }
        case PM_TOKEN_MISSING: {
            pm_token_t opening = not_provided(parser);
            pm_token_t closing = not_provided(parser);

            pm_token_t label = { .type = PM_TOKEN_LABEL, .start = token->start, .end = token->end };
            node = pm_symbol_node_create(parser, &opening, &label, &closing);
            break;
        }
        default:
            assert(false && "unreachable");
            node = NULL;
            break;
    }

    return node;
}

/**
 * Allocate and initialize a new synthesized SymbolNode node.
 */
static pm_symbol_node_t *
pm_symbol_node_synthesized_create(pm_parser_t *parser, const char *content) {
    pm_symbol_node_t *node = PM_NODE_ALLOC(parser, pm_symbol_node_t);

    *node = (pm_symbol_node_t) {
        {
            .type = PM_SYMBOL_NODE,
            .flags = PM_NODE_FLAG_STATIC_LITERAL | PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_NULL_VALUE(parser)
        },
        .value_loc = PM_LOCATION_NULL_VALUE(parser),
        .unescaped = { 0 }
    };

    pm_string_constant_init(&node->unescaped, content, strlen(content));
    return node;
}

/**
 * Check if the given node is a label in a hash.
 */
static bool
pm_symbol_node_label_p(pm_node_t *node) {
    const uint8_t *end = NULL;

    switch (PM_NODE_TYPE(node)) {
        case PM_SYMBOL_NODE:
            end = ((pm_symbol_node_t *) node)->closing_loc.end;
            break;
        case PM_INTERPOLATED_SYMBOL_NODE:
            end = ((pm_interpolated_symbol_node_t *) node)->closing_loc.end;
            break;
        default:
            return false;
    }

    return (end != NULL) && (end[-1] == ':');
}

/**
 * Convert the given StringNode node to a SymbolNode node.
 */
static pm_symbol_node_t *
pm_string_node_to_symbol_node(pm_parser_t *parser, pm_string_node_t *node, const pm_token_t *opening, const pm_token_t *closing) {
    pm_symbol_node_t *new_node = PM_NODE_ALLOC(parser, pm_symbol_node_t);

    *new_node = (pm_symbol_node_t) {
        {
            .type = PM_SYMBOL_NODE,
            .flags = PM_NODE_FLAG_STATIC_LITERAL,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = opening->start,
                .end = closing->end
            }
        },
        .opening_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(opening),
        .value_loc = node->content_loc,
        .closing_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(closing),
        .unescaped = node->unescaped
    };

    pm_token_t content = { .type = PM_TOKEN_IDENTIFIER, .start = node->content_loc.start, .end = node->content_loc.end };
    pm_node_flag_set((pm_node_t *) new_node, parse_symbol_encoding(parser, &content, &node->unescaped, true));

    // We are explicitly _not_ using pm_node_destroy here because we don't want
    // to trash the unescaped string. We could instead copy the string if we
    // know that it is owned, but we're taking the fast path for now.
    xfree(node);

    return new_node;
}

/**
 * Convert the given SymbolNode node to a StringNode node.
 */
static pm_string_node_t *
pm_symbol_node_to_string_node(pm_parser_t *parser, pm_symbol_node_t *node) {
    pm_string_node_t *new_node = PM_NODE_ALLOC(parser, pm_string_node_t);
    pm_node_flags_t flags = 0;

    switch (parser->frozen_string_literal) {
        case PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED:
            flags = PM_STRING_FLAGS_MUTABLE;
            break;
        case PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED:
            flags = PM_NODE_FLAG_STATIC_LITERAL | PM_STRING_FLAGS_FROZEN;
            break;
    }

    *new_node = (pm_string_node_t) {
        {
            .type = PM_STRING_NODE,
            .flags = flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = node->base.location
        },
        .opening_loc = node->opening_loc,
        .content_loc = node->value_loc,
        .closing_loc = node->closing_loc,
        .unescaped = node->unescaped
    };

    // We are explicitly _not_ using pm_node_destroy here because we don't want
    // to trash the unescaped string. We could instead copy the string if we
    // know that it is owned, but we're taking the fast path for now.
    xfree(node);

    return new_node;
}

/**
 * Allocate and initialize a new TrueNode node.
 */
static pm_true_node_t *
pm_true_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_KEYWORD_TRUE);
    pm_true_node_t *node = PM_NODE_ALLOC(parser, pm_true_node_t);

    *node = (pm_true_node_t) {{
        .type = PM_TRUE_NODE,
        .flags = PM_NODE_FLAG_STATIC_LITERAL,
        .node_id = PM_NODE_IDENTIFY(parser),
        .location = PM_LOCATION_TOKEN_VALUE(token)
    }};

    return node;
}

/**
 * Allocate and initialize a new synthesized TrueNode node.
 */
static pm_true_node_t *
pm_true_node_synthesized_create(pm_parser_t *parser) {
    pm_true_node_t *node = PM_NODE_ALLOC(parser, pm_true_node_t);

    *node = (pm_true_node_t) {{
        .type = PM_TRUE_NODE,
        .flags = PM_NODE_FLAG_STATIC_LITERAL,
        .node_id = PM_NODE_IDENTIFY(parser),
        .location = { .start = parser->start, .end = parser->end }
    }};

    return node;
}

/**
 * Allocate and initialize a new UndefNode node.
 */
static pm_undef_node_t *
pm_undef_node_create(pm_parser_t *parser, const pm_token_t *token) {
    assert(token->type == PM_TOKEN_KEYWORD_UNDEF);
    pm_undef_node_t *node = PM_NODE_ALLOC(parser, pm_undef_node_t);

    *node = (pm_undef_node_t) {
        {
            .type = PM_UNDEF_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_TOKEN_VALUE(token),
        },
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(token),
        .names = { 0 }
    };

    return node;
}

/**
 * Append a name to an undef node.
 */
static void
pm_undef_node_append(pm_undef_node_t *node, pm_node_t *name) {
    node->base.location.end = name->location.end;
    pm_node_list_append(&node->names, name);
}

/**
 * Allocate a new UnlessNode node.
 */
static pm_unless_node_t *
pm_unless_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *predicate, const pm_token_t *then_keyword, pm_statements_node_t *statements) {
    pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
    pm_unless_node_t *node = PM_NODE_ALLOC(parser, pm_unless_node_t);

    const uint8_t *end;
    if (statements != NULL) {
        end = statements->base.location.end;
    } else {
        end = predicate->location.end;
    }

    *node = (pm_unless_node_t) {
        {
            .type = PM_UNLESS_NODE,
            .flags = PM_NODE_FLAG_NEWLINE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = keyword->start,
                .end = end
            },
        },
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),
        .predicate = predicate,
        .then_keyword_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(then_keyword),
        .statements = statements,
        .else_clause = NULL,
        .end_keyword_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE
    };

    return node;
}

/**
 * Allocate and initialize new UnlessNode node in the modifier form.
 */
static pm_unless_node_t *
pm_unless_node_modifier_create(pm_parser_t *parser, pm_node_t *statement, const pm_token_t *unless_keyword, pm_node_t *predicate) {
    pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
    pm_unless_node_t *node = PM_NODE_ALLOC(parser, pm_unless_node_t);

    pm_statements_node_t *statements = pm_statements_node_create(parser);
    pm_statements_node_body_append(parser, statements, statement, true);

    *node = (pm_unless_node_t) {
        {
            .type = PM_UNLESS_NODE,
            .flags = PM_NODE_FLAG_NEWLINE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = statement->location.start,
                .end = predicate->location.end
            },
        },
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(unless_keyword),
        .predicate = predicate,
        .then_keyword_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .statements = statements,
        .else_clause = NULL,
        .end_keyword_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE
    };

    return node;
}

static inline void
pm_unless_node_end_keyword_loc_set(pm_unless_node_t *node, const pm_token_t *end_keyword) {
    node->end_keyword_loc = PM_LOCATION_TOKEN_VALUE(end_keyword);
    node->base.location.end = end_keyword->end;
}

/**
 * Loop modifiers could potentially modify an expression that contains block
 * exits. In this case we need to loop through them and remove them from the
 * list of block exits so that they do not later get marked as invalid.
 */
static void
pm_loop_modifier_block_exits(pm_parser_t *parser, pm_statements_node_t *statements) {
    assert(parser->current_block_exits != NULL);

    // All of the block exits that we want to remove should be within the
    // statements, and since we are modifying the statements, we shouldn't have
    // to check the end location.
    const uint8_t *start = statements->base.location.start;

    for (size_t index = parser->current_block_exits->size; index > 0; index--) {
        pm_node_t *block_exit = parser->current_block_exits->nodes[index - 1];
        if (block_exit->location.start < start) break;

        // Implicitly remove from the list by lowering the size.
        parser->current_block_exits->size--;
    }
}

/**
 * Allocate a new UntilNode node.
 */
static pm_until_node_t *
pm_until_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_token_t *do_keyword, const pm_token_t *closing, pm_node_t *predicate, pm_statements_node_t *statements, pm_node_flags_t flags) {
    pm_until_node_t *node = PM_NODE_ALLOC(parser, pm_until_node_t);
    pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);

    *node = (pm_until_node_t) {
        {
            .type = PM_UNTIL_NODE,
            .flags = flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = keyword->start,
                .end = closing->end,
            },
        },
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),
        .do_keyword_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(do_keyword),
        .closing_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(closing),
        .predicate = predicate,
        .statements = statements
    };

    return node;
}

/**
 * Allocate a new UntilNode node.
 */
static pm_until_node_t *
pm_until_node_modifier_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *predicate, pm_statements_node_t *statements, pm_node_flags_t flags) {
    pm_until_node_t *node = PM_NODE_ALLOC(parser, pm_until_node_t);
    pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
    pm_loop_modifier_block_exits(parser, statements);

    *node = (pm_until_node_t) {
        {
            .type = PM_UNTIL_NODE,
            .flags = flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = statements->base.location.start,
                .end = predicate->location.end,
            },
        },
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),
        .do_keyword_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .closing_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .predicate = predicate,
        .statements = statements
    };

    return node;
}

/**
 * Allocate and initialize a new WhenNode node.
 */
static pm_when_node_t *
pm_when_node_create(pm_parser_t *parser, const pm_token_t *keyword) {
    pm_when_node_t *node = PM_NODE_ALLOC(parser, pm_when_node_t);

    *node = (pm_when_node_t) {
        {
            .type = PM_WHEN_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = keyword->start,
                .end = NULL
            }
        },
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),
        .statements = NULL,
        .then_keyword_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .conditions = { 0 }
    };

    return node;
}

/**
 * Append a new condition to a when node.
 */
static void
pm_when_node_conditions_append(pm_when_node_t *node, pm_node_t *condition) {
    node->base.location.end = condition->location.end;
    pm_node_list_append(&node->conditions, condition);
}

/**
 * Set the location of the then keyword of a when node.
 */
static inline void
pm_when_node_then_keyword_loc_set(pm_when_node_t *node, const pm_token_t *then_keyword) {
    node->base.location.end = then_keyword->end;
    node->then_keyword_loc = PM_LOCATION_TOKEN_VALUE(then_keyword);
}

/**
 * Set the statements list of a when node.
 */
static void
pm_when_node_statements_set(pm_when_node_t *node, pm_statements_node_t *statements) {
    if (statements->base.location.end > node->base.location.end) {
        node->base.location.end = statements->base.location.end;
    }

    node->statements = statements;
}

/**
 * Allocate a new WhileNode node.
 */
static pm_while_node_t *
pm_while_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_token_t *do_keyword, const pm_token_t *closing, pm_node_t *predicate, pm_statements_node_t *statements, pm_node_flags_t flags) {
    pm_while_node_t *node = PM_NODE_ALLOC(parser, pm_while_node_t);
    pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);

    *node = (pm_while_node_t) {
        {
            .type = PM_WHILE_NODE,
            .flags = flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = keyword->start,
                .end = closing->end
            },
        },
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),
        .do_keyword_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(do_keyword),
        .closing_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(closing),
        .predicate = predicate,
        .statements = statements
    };

    return node;
}

/**
 * Allocate a new WhileNode node.
 */
static pm_while_node_t *
pm_while_node_modifier_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *predicate, pm_statements_node_t *statements, pm_node_flags_t flags) {
    pm_while_node_t *node = PM_NODE_ALLOC(parser, pm_while_node_t);
    pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
    pm_loop_modifier_block_exits(parser, statements);

    *node = (pm_while_node_t) {
        {
            .type = PM_WHILE_NODE,
            .flags = flags,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = statements->base.location.start,
                .end = predicate->location.end
            },
        },
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),
        .do_keyword_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .closing_loc = PM_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
        .predicate = predicate,
        .statements = statements
    };

    return node;
}

/**
 * Allocate and initialize a new synthesized while loop.
 */
static pm_while_node_t *
pm_while_node_synthesized_create(pm_parser_t *parser, pm_node_t *predicate, pm_statements_node_t *statements) {
    pm_while_node_t *node = PM_NODE_ALLOC(parser, pm_while_node_t);

    *node = (pm_while_node_t) {
        {
            .type = PM_WHILE_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = PM_LOCATION_NULL_VALUE(parser)
        },
        .keyword_loc = PM_LOCATION_NULL_VALUE(parser),
        .do_keyword_loc = PM_LOCATION_NULL_VALUE(parser),
        .closing_loc = PM_LOCATION_NULL_VALUE(parser),
        .predicate = predicate,
        .statements = statements
    };

    return node;
}

/**
 * Allocate and initialize a new XStringNode node with the given unescaped
 * string.
 */
static pm_x_string_node_t *
pm_xstring_node_create_unescaped(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing, const pm_string_t *unescaped) {
    pm_x_string_node_t *node = PM_NODE_ALLOC(parser, pm_x_string_node_t);

    *node = (pm_x_string_node_t) {
        {
            .type = PM_X_STRING_NODE,
            .flags = PM_STRING_FLAGS_FROZEN,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = opening->start,
                .end = closing->end
            },
        },
        .opening_loc = PM_LOCATION_TOKEN_VALUE(opening),
        .content_loc = PM_LOCATION_TOKEN_VALUE(content),
        .closing_loc = PM_LOCATION_TOKEN_VALUE(closing),
        .unescaped = *unescaped
    };

    return node;
}

/**
 * Allocate and initialize a new XStringNode node.
 */
static inline pm_x_string_node_t *
pm_xstring_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing) {
    return pm_xstring_node_create_unescaped(parser, opening, content, closing, &PM_STRING_EMPTY);
}

/**
 * Allocate a new YieldNode node.
 */
static pm_yield_node_t *
pm_yield_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_location_t *lparen_loc, pm_arguments_node_t *arguments, const pm_location_t *rparen_loc) {
    pm_yield_node_t *node = PM_NODE_ALLOC(parser, pm_yield_node_t);

    const uint8_t *end;
    if (rparen_loc->start != NULL) {
        end = rparen_loc->end;
    } else if (arguments != NULL) {
        end = arguments->base.location.end;
    } else if (lparen_loc->start != NULL) {
        end = lparen_loc->end;
    } else {
        end = keyword->end;
    }

    *node = (pm_yield_node_t) {
        {
            .type = PM_YIELD_NODE,
            .node_id = PM_NODE_IDENTIFY(parser),
            .location = {
                .start = keyword->start,
                .end = end
            },
        },
        .keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),
        .lparen_loc = *lparen_loc,
        .arguments = arguments,
        .rparen_loc = *rparen_loc
    };

    return node;
}

#undef PM_NODE_ALLOC
#undef PM_NODE_IDENTIFY

/**
 * Check if any of the currently visible scopes contain a local variable
 * described by the given constant id.
 */
static int
pm_parser_local_depth_constant_id(pm_parser_t *parser, pm_constant_id_t constant_id) {
    pm_scope_t *scope = parser->current_scope;
    int depth = 0;

    while (scope != NULL) {
        if (pm_locals_find(&scope->locals, constant_id) != UINT32_MAX) return depth;
        if (scope->closed) break;

        scope = scope->previous;
        depth++;
    }

    return -1;
}

/**
 * Check if any of the currently visible scopes contain a local variable
 * described by the given token. This function implicitly inserts a constant
 * into the constant pool.
 */
static inline int
pm_parser_local_depth(pm_parser_t *parser, pm_token_t *token) {
    return pm_parser_local_depth_constant_id(parser, pm_parser_constant_id_token(parser, token));
}

/**
 * Add a constant id to the local table of the current scope.
 */
static inline void
pm_parser_local_add(pm_parser_t *parser, pm_constant_id_t constant_id, const uint8_t *start, const uint8_t *end, uint32_t reads) {
    pm_locals_write(&parser->current_scope->locals, constant_id, start, end, reads);
}

/**
 * Add a local variable from a location to the current scope.
 */
static pm_constant_id_t
pm_parser_local_add_location(pm_parser_t *parser, const uint8_t *start, const uint8_t *end, uint32_t reads) {
    pm_constant_id_t constant_id = pm_parser_constant_id_location(parser, start, end);
    if (constant_id != 0) pm_parser_local_add(parser, constant_id, start, end, reads);
    return constant_id;
}

/**
 * Add a local variable from a token to the current scope.
 */
static inline pm_constant_id_t
pm_parser_local_add_token(pm_parser_t *parser, pm_token_t *token, uint32_t reads) {
    return pm_parser_local_add_location(parser, token->start, token->end, reads);
}

/**
 * Add a local variable from an owned string to the current scope.
 */
static pm_constant_id_t
pm_parser_local_add_owned(pm_parser_t *parser, uint8_t *start, size_t length) {
    pm_constant_id_t constant_id = pm_parser_constant_id_owned(parser, start, length);
    if (constant_id != 0) pm_parser_local_add(parser, constant_id, parser->start, parser->start, 1);
    return constant_id;
}

/**
 * Add a local variable from a constant string to the current scope.
 */
static pm_constant_id_t
pm_parser_local_add_constant(pm_parser_t *parser, const char *start, size_t length) {
    pm_constant_id_t constant_id = pm_parser_constant_id_constant(parser, start, length);
    if (constant_id != 0) pm_parser_local_add(parser, constant_id, parser->start, parser->start, 1);
    return constant_id;
}

/**
 * Add a parameter name to the current scope and check whether the name of the
 * parameter is unique or not.
 *
 * Returns `true` if this is a duplicate parameter name, otherwise returns
 * false.
 */
static bool
pm_parser_parameter_name_check(pm_parser_t *parser, const pm_token_t *name) {
    // We want to check whether the parameter name is a numbered parameter or
    // not.
    pm_refute_numbered_parameter(parser, name->start, name->end);

    // Otherwise we'll fetch the constant id for the parameter name and check
    // whether it's already in the current scope.
    pm_constant_id_t constant_id = pm_parser_constant_id_token(parser, name);

    if (pm_locals_find(&parser->current_scope->locals, constant_id) != UINT32_MAX) {
        // Add an error if the parameter doesn't start with _ and has been seen before
        if ((name->start < name->end) && (*name->start != '_')) {
            pm_parser_err_token(parser, name, PM_ERR_PARAMETER_NAME_DUPLICATED);
        }
        return true;
    }
    return false;
}

/**
 * Pop the current scope off the scope stack.
 */
static void
pm_parser_scope_pop(pm_parser_t *parser) {
    pm_scope_t *scope = parser->current_scope;
    parser->current_scope = scope->previous;
    pm_locals_free(&scope->locals);
    pm_node_list_free(&scope->implicit_parameters);
    xfree(scope);
}

/******************************************************************************/
/* Stack helpers                                                              */
/******************************************************************************/

/**
 * Pushes a value onto the stack.
 */
static inline void
pm_state_stack_push(pm_state_stack_t *stack, bool value) {
    *stack = (*stack << 1) | (value & 1);
}

/**
 * Pops a value off the stack.
 */
static inline void
pm_state_stack_pop(pm_state_stack_t *stack) {
    *stack >>= 1;
}

/**
 * Returns the value at the top of the stack.
 */
static inline bool
pm_state_stack_p(const pm_state_stack_t *stack) {
    return *stack & 1;
}

static inline void
pm_accepts_block_stack_push(pm_parser_t *parser, bool value) {
    // Use the negation of the value to prevent stack overflow.
    pm_state_stack_push(&parser->accepts_block_stack, !value);
}

static inline void
pm_accepts_block_stack_pop(pm_parser_t *parser) {
    pm_state_stack_pop(&parser->accepts_block_stack);
}

static inline bool
pm_accepts_block_stack_p(pm_parser_t *parser) {
    return !pm_state_stack_p(&parser->accepts_block_stack);
}

static inline void
pm_do_loop_stack_push(pm_parser_t *parser, bool value) {
    pm_state_stack_push(&parser->do_loop_stack, value);
}

static inline void
pm_do_loop_stack_pop(pm_parser_t *parser) {
    pm_state_stack_pop(&parser->do_loop_stack);
}

static inline bool
pm_do_loop_stack_p(pm_parser_t *parser) {
    return pm_state_stack_p(&parser->do_loop_stack);
}

/******************************************************************************/
/* Lexer check helpers                                                        */
/******************************************************************************/

/**
 * Get the next character in the source starting from +cursor+. If that position
 * is beyond the end of the source then return '\0'.
 */
static inline uint8_t
peek_at(const pm_parser_t *parser, const uint8_t *cursor) {
    if (cursor < parser->end) {
        return *cursor;
    } else {
        return '\0';
    }
}

/**
 * Get the next character in the source starting from parser->current.end and
 * adding the given offset. If that position is beyond the end of the source
 * then return '\0'.
 */
static inline uint8_t
peek_offset(pm_parser_t *parser, ptrdiff_t offset) {
    return peek_at(parser, parser->current.end + offset);
}

/**
 * Get the next character in the source starting from parser->current.end. If
 * that position is beyond the end of the source then return '\0'.
 */
static inline uint8_t
peek(const pm_parser_t *parser) {
    return peek_at(parser, parser->current.end);
}

/**
 * If the character to be read matches the given value, then returns true and
 * advances the current pointer.
 */
static inline bool
match(pm_parser_t *parser, uint8_t value) {
    if (peek(parser) == value) {
        parser->current.end++;
        return true;
    }
    return false;
}

/**
 * Return the length of the line ending string starting at +cursor+, or 0 if it
 * is not a line ending. This function is intended to be CRLF/LF agnostic.
 */
static inline size_t
match_eol_at(pm_parser_t *parser, const uint8_t *cursor) {
    if (peek_at(parser, cursor) == '\n') {
        return 1;
    }
    if (peek_at(parser, cursor) == '\r' && peek_at(parser, cursor + 1) == '\n') {
        return 2;
    }
    return 0;
}

/**
 * Return the length of the line ending string starting at
 * `parser->current.end + offset`, or 0 if it is not a line ending. This
 * function is intended to be CRLF/LF agnostic.
 */
static inline size_t
match_eol_offset(pm_parser_t *parser, ptrdiff_t offset) {
    return match_eol_at(parser, parser->current.end + offset);
}

/**
 * Return the length of the line ending string starting at parser->current.end,
 * or 0 if it is not a line ending. This function is intended to be CRLF/LF
 * agnostic.
 */
static inline size_t
match_eol(pm_parser_t *parser) {
    return match_eol_at(parser, parser->current.end);
}

/**
 * Skip to the next newline character or NUL byte.
 */
static inline const uint8_t *
next_newline(const uint8_t *cursor, ptrdiff_t length) {
    assert(length >= 0);

    // Note that it's okay for us to use memchr here to look for \n because none
    // of the encodings that we support have \n as a component of a multi-byte
    // character.
    return memchr(cursor, '\n', (size_t) length);
}

/**
 * This is equivalent to the predicate of warn_balanced in CRuby.
 */
static inline bool
ambiguous_operator_p(const pm_parser_t *parser, bool space_seen) {
    return !lex_state_p(parser, PM_LEX_STATE_CLASS | PM_LEX_STATE_DOT | PM_LEX_STATE_FNAME | PM_LEX_STATE_ENDFN) && space_seen && !pm_char_is_whitespace(peek(parser));
}

/**
 * Here we're going to check if this is a "magic" comment, and perform whatever
 * actions are necessary for it here.
 */
static bool
parser_lex_magic_comment_encoding_value(pm_parser_t *parser, const uint8_t *start, const uint8_t *end) {
    const pm_encoding_t *encoding = pm_encoding_find(start, end);

    if (encoding != NULL) {
        if (parser->encoding != encoding) {
            parser->encoding = encoding;
            if (parser->encoding_changed_callback != NULL) parser->encoding_changed_callback(parser);
        }

        parser->encoding_changed = (encoding != PM_ENCODING_UTF_8_ENTRY);
        return true;
    }

    return false;
}

/**
 * Look for a specific pattern of "coding" and potentially set the encoding on
 * the parser.
 */
static void
parser_lex_magic_comment_encoding(pm_parser_t *parser) {
    const uint8_t *cursor = parser->current.start + 1;
    const uint8_t *end = parser->current.end;

    bool separator = false;
    while (true) {
        if (end - cursor <= 6) return;
        switch (cursor[6]) {
            case 'C': case 'c': cursor += 6; continue;
            case 'O': case 'o': cursor += 5; continue;
            case 'D': case 'd': cursor += 4; continue;
            case 'I': case 'i': cursor += 3; continue;
            case 'N': case 'n': cursor += 2; continue;
            case 'G': case 'g': cursor += 1; continue;
            case '=': case ':':
                separator = true;
                cursor += 6;
                break;
            default:
                cursor += 6;
                if (pm_char_is_whitespace(*cursor)) break;
                continue;
        }
        if (pm_strncasecmp(cursor - 6, (const uint8_t *) "coding", 6) == 0) break;
        separator = false;
    }

    while (true) {
        do {
            if (++cursor >= end) return;
        } while (pm_char_is_whitespace(*cursor));

        if (separator) break;
        if (*cursor != '=' && *cursor != ':') return;

        separator = true;
        cursor++;
    }

    const uint8_t *value_start = cursor;
    while ((*cursor == '-' || *cursor == '_' || parser->encoding->alnum_char(cursor, 1)) && ++cursor < end);

    if (!parser_lex_magic_comment_encoding_value(parser, value_start, cursor)) {
        // If we were unable to parse the encoding value, then we've got an
        // issue because we didn't understand the encoding that the user was
        // trying to use. In this case we'll keep using the default encoding but
        // add an error to the parser to indicate an unsuccessful parse.
        pm_parser_err(parser, value_start, cursor, PM_ERR_INVALID_ENCODING_MAGIC_COMMENT);
    }
}

typedef enum {
    PM_MAGIC_COMMENT_BOOLEAN_VALUE_TRUE,
    PM_MAGIC_COMMENT_BOOLEAN_VALUE_FALSE,
    PM_MAGIC_COMMENT_BOOLEAN_VALUE_INVALID
} pm_magic_comment_boolean_value_t;

/**
 * Check if this is a magic comment that includes the frozen_string_literal
 * pragma. If it does, set that field on the parser.
 */
static pm_magic_comment_boolean_value_t
parser_lex_magic_comment_boolean_value(const uint8_t *value_start, uint32_t value_length) {
    if (value_length == 4 && pm_strncasecmp(value_start, (const uint8_t *) "true", 4) == 0) {
        return PM_MAGIC_COMMENT_BOOLEAN_VALUE_TRUE;
    } else if (value_length == 5 && pm_strncasecmp(value_start, (const uint8_t *) "false", 5) == 0) {
        return PM_MAGIC_COMMENT_BOOLEAN_VALUE_FALSE;
    } else {
        return PM_MAGIC_COMMENT_BOOLEAN_VALUE_INVALID;
    }
}

static inline bool
pm_char_is_magic_comment_key_delimiter(const uint8_t b) {
    return b == '\'' || b == '"' || b == ':' || b == ';';
}

/**
 * Find an emacs magic comment marker (-*-) within the given bounds. If one is
 * found, it returns a pointer to the start of the marker. Otherwise it returns
 * NULL.
 */
static inline const uint8_t *
parser_lex_magic_comment_emacs_marker(pm_parser_t *parser, const uint8_t *cursor, const uint8_t *end) {
    while ((cursor + 3 <= end) && (cursor = pm_memchr(cursor, '-', (size_t) (end - cursor), parser->encoding_changed, parser->encoding)) != NULL) {
        if (cursor + 3 <= end && cursor[1] == '*' && cursor[2] == '-') {
            return cursor;
        }
        cursor++;
    }
    return NULL;
}

/**
 * Parse the current token on the parser to see if it's a magic comment and
 * potentially perform some action based on that. A regular expression that this
 * function is effectively matching is:
 *
 *     %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*"
 *
 * It returns true if it consumes the entire comment. Otherwise it returns
 * false.
 */
static inline bool
parser_lex_magic_comment(pm_parser_t *parser, bool semantic_token_seen) {
    bool result = true;

    const uint8_t *start = parser->current.start + 1;
    const uint8_t *end = parser->current.end;
    if (end - start <= 7) return false;

    const uint8_t *cursor;
    bool indicator = false;

    if ((cursor = parser_lex_magic_comment_emacs_marker(parser, start, end)) != NULL) {
        start = cursor + 3;

        if ((cursor = parser_lex_magic_comment_emacs_marker(parser, start, end)) != NULL) {
            end = cursor;
            indicator = true;
        } else {
            // If we have a start marker but not an end marker, then we cannot
            // have a magic comment.
            return false;
        }
    }

    cursor = start;
    while (cursor < end) {
        while (cursor < end && (pm_char_is_magic_comment_key_delimiter(*cursor) || pm_char_is_whitespace(*cursor))) cursor++;

        const uint8_t *key_start = cursor;
        while (cursor < end && (!pm_char_is_magic_comment_key_delimiter(*cursor) && !pm_char_is_whitespace(*cursor))) cursor++;

        const uint8_t *key_end = cursor;
        while (cursor < end && pm_char_is_whitespace(*cursor)) cursor++;
        if (cursor == end) break;

        if (*cursor == ':') {
            cursor++;
        } else {
            if (!indicator) return false;
            continue;
        }

        while (cursor < end && pm_char_is_whitespace(*cursor)) cursor++;
        if (cursor == end) break;

        const uint8_t *value_start;
        const uint8_t *value_end;

        if (*cursor == '"') {
            value_start = ++cursor;
            for (; cursor < end && *cursor != '"'; cursor++) {
                if (*cursor == '\\' && (cursor + 1 < end)) cursor++;
            }
            value_end = cursor;
            if (*cursor == '"') cursor++;
        } else {
            value_start = cursor;
            while (cursor < end && *cursor != '"' && *cursor != ';' && !pm_char_is_whitespace(*cursor)) cursor++;
            value_end = cursor;
        }

        if (indicator) {
            while (cursor < end && (*cursor == ';' || pm_char_is_whitespace(*cursor))) cursor++;
        } else {
            while (cursor < end && pm_char_is_whitespace(*cursor)) cursor++;
            if (cursor != end) return false;
        }

        // Here, we need to do some processing on the key to swap out dashes for
        // underscores. We only need to do this if there _is_ a dash in the key.
        pm_string_t key;
        const size_t key_length = (size_t) (key_end - key_start);
        const uint8_t *dash = pm_memchr(key_start, '-', key_length, parser->encoding_changed, parser->encoding);

        if (dash == NULL) {
            pm_string_shared_init(&key, key_start, key_end);
        } else {
            uint8_t *buffer = xmalloc(key_length);
            if (buffer == NULL) break;

            memcpy(buffer, key_start, key_length);
            buffer[dash - key_start] = '_';

            while ((dash = pm_memchr(dash + 1, '-', (size_t) (key_end - dash - 1), parser->encoding_changed, parser->encoding)) != NULL) {
                buffer[dash - key_start] = '_';
            }

            pm_string_owned_init(&key, buffer, key_length);
        }

        // Finally, we can start checking the key against the list of known
        // magic comment keys, and potentially change state based on that.
        const uint8_t *key_source = pm_string_source(&key);
        uint32_t value_length = (uint32_t) (value_end - value_start);

        // We only want to attempt to compare against encoding comments if it's
        // the first line in the file (or the second in the case of a shebang).
        if (parser->current.start == parser->encoding_comment_start && !parser->encoding_locked) {
            if (
                (key_length == 8 && pm_strncasecmp(key_source, (const uint8_t *) "encoding", 8) == 0) ||
                (key_length == 6 && pm_strncasecmp(key_source, (const uint8_t *) "coding", 6) == 0)
            ) {
                result = parser_lex_magic_comment_encoding_value(parser, value_start, value_end);
            }
        }

        if (key_length == 11) {
            if (pm_strncasecmp(key_source, (const uint8_t *) "warn_indent", 11) == 0) {
                switch (parser_lex_magic_comment_boolean_value(value_start, value_length)) {
                    case PM_MAGIC_COMMENT_BOOLEAN_VALUE_INVALID:
                        PM_PARSER_WARN_TOKEN_FORMAT(
                            parser,
                            parser->current,
                            PM_WARN_INVALID_MAGIC_COMMENT_VALUE,
                            (int) key_length,
                            (const char *) key_source,
                            (int) value_length,
                            (const char *) value_start
                        );
                        break;
                    case PM_MAGIC_COMMENT_BOOLEAN_VALUE_FALSE:
                        parser->warn_mismatched_indentation = false;
                        break;
                    case PM_MAGIC_COMMENT_BOOLEAN_VALUE_TRUE:
                        parser->warn_mismatched_indentation = true;
                        break;
                }
            }
        } else if (key_length == 21) {
            if (pm_strncasecmp(key_source, (const uint8_t *) "frozen_string_literal", 21) == 0) {
                // We only want to handle frozen string literal comments if it's
                // before any semantic tokens have been seen.
                if (semantic_token_seen) {
                    pm_parser_warn_token(parser, &parser->current, PM_WARN_IGNORED_FROZEN_STRING_LITERAL);
                } else {
                    switch (parser_lex_magic_comment_boolean_value(value_start, value_length)) {
                        case PM_MAGIC_COMMENT_BOOLEAN_VALUE_INVALID:
                            PM_PARSER_WARN_TOKEN_FORMAT(
                                parser,
                                parser->current,
                                PM_WARN_INVALID_MAGIC_COMMENT_VALUE,
                                (int) key_length,
                                (const char *) key_source,
                                (int) value_length,
                                (const char *) value_start
                            );
                            break;
                        case PM_MAGIC_COMMENT_BOOLEAN_VALUE_FALSE:
                            parser->frozen_string_literal = PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED;
                            break;
                        case PM_MAGIC_COMMENT_BOOLEAN_VALUE_TRUE:
                            parser->frozen_string_literal = PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED;
                            break;
                    }
                }
            }
        } else if (key_length == 24) {
            if (pm_strncasecmp(key_source, (const uint8_t *) "shareable_constant_value", 24) == 0) {
                const uint8_t *cursor = parser->current.start;
                while ((cursor > parser->start) && ((cursor[-1] == ' ') || (cursor[-1] == '\t'))) cursor--;

                if (!((cursor == parser->start) || (cursor[-1] == '\n'))) {
                    pm_parser_warn_token(parser, &parser->current, PM_WARN_SHAREABLE_CONSTANT_VALUE_LINE);
                } else if (value_length == 4 && pm_strncasecmp(value_start, (const uint8_t *) "none", 4) == 0) {
                    pm_parser_scope_shareable_constant_set(parser, PM_SCOPE_SHAREABLE_CONSTANT_NONE);
                } else if (value_length == 7 && pm_strncasecmp(value_start, (const uint8_t *) "literal", 7) == 0) {
                    pm_parser_scope_shareable_constant_set(parser, PM_SCOPE_SHAREABLE_CONSTANT_LITERAL);
                } else if (value_length == 23 && pm_strncasecmp(value_start, (const uint8_t *) "experimental_everything", 23) == 0) {
                    pm_parser_scope_shareable_constant_set(parser, PM_SCOPE_SHAREABLE_CONSTANT_EXPERIMENTAL_EVERYTHING);
                } else if (value_length == 17 && pm_strncasecmp(value_start, (const uint8_t *) "experimental_copy", 17) == 0) {
                    pm_parser_scope_shareable_constant_set(parser, PM_SCOPE_SHAREABLE_CONSTANT_EXPERIMENTAL_COPY);
                } else {
                    PM_PARSER_WARN_TOKEN_FORMAT(
                        parser,
                        parser->current,
                        PM_WARN_INVALID_MAGIC_COMMENT_VALUE,
                        (int) key_length,
                        (const char *) key_source,
                        (int) value_length,
                        (const char *) value_start
                    );
                }
            }
        }

        // When we're done, we want to free the string in case we had to
        // allocate memory for it.
        pm_string_free(&key);

        // Allocate a new magic comment node to append to the parser's list.
        pm_magic_comment_t *magic_comment;
        if ((magic_comment = (pm_magic_comment_t *) xcalloc(1, sizeof(pm_magic_comment_t))) != NULL) {
            magic_comment->key_start = key_start;
            magic_comment->value_start = value_start;
            magic_comment->key_length = (uint32_t) key_length;
            magic_comment->value_length = value_length;
            pm_list_append(&parser->magic_comment_list, (pm_list_node_t *) magic_comment);
        }
    }

    return result;
}

/******************************************************************************/
/* Context manipulations                                                      */
/******************************************************************************/

static const uint32_t context_terminators[] = {
    [PM_CONTEXT_NONE] = 0,
    [PM_CONTEXT_BEGIN] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_RESCUE) | (1 << PM_TOKEN_KEYWORD_ELSE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_BEGIN_ENSURE] = (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_BEGIN_ELSE] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_BEGIN_RESCUE] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_RESCUE) | (1 << PM_TOKEN_KEYWORD_ELSE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_BLOCK_BRACES] = (1 << PM_TOKEN_BRACE_RIGHT),
    [PM_CONTEXT_BLOCK_KEYWORDS] = (1 << PM_TOKEN_KEYWORD_END) | (1 << PM_TOKEN_KEYWORD_RESCUE) | (1 << PM_TOKEN_KEYWORD_ENSURE),
    [PM_CONTEXT_BLOCK_ENSURE] = (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_BLOCK_ELSE] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_BLOCK_RESCUE] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_RESCUE) | (1 << PM_TOKEN_KEYWORD_ELSE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_CASE_WHEN] = (1 << PM_TOKEN_KEYWORD_WHEN) | (1 << PM_TOKEN_KEYWORD_END) | (1 << PM_TOKEN_KEYWORD_ELSE),
    [PM_CONTEXT_CASE_IN] = (1 << PM_TOKEN_KEYWORD_IN) | (1 << PM_TOKEN_KEYWORD_END) | (1 << PM_TOKEN_KEYWORD_ELSE),
    [PM_CONTEXT_CLASS] = (1 << PM_TOKEN_KEYWORD_END) | (1 << PM_TOKEN_KEYWORD_RESCUE) | (1 << PM_TOKEN_KEYWORD_ENSURE),
    [PM_CONTEXT_CLASS_ENSURE] = (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_CLASS_ELSE] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_CLASS_RESCUE] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_RESCUE) | (1 << PM_TOKEN_KEYWORD_ELSE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_DEF] = (1 << PM_TOKEN_KEYWORD_END) | (1 << PM_TOKEN_KEYWORD_RESCUE) | (1 << PM_TOKEN_KEYWORD_ENSURE),
    [PM_CONTEXT_DEF_ENSURE] = (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_DEF_ELSE] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_DEF_RESCUE] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_RESCUE) | (1 << PM_TOKEN_KEYWORD_ELSE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_DEF_PARAMS] = (1 << PM_TOKEN_EOF),
    [PM_CONTEXT_DEFINED] = (1 << PM_TOKEN_EOF),
    [PM_CONTEXT_DEFAULT_PARAMS] = (1 << PM_TOKEN_COMMA) | (1 << PM_TOKEN_PARENTHESIS_RIGHT),
    [PM_CONTEXT_ELSE] = (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_ELSIF] = (1 << PM_TOKEN_KEYWORD_ELSE) | (1 << PM_TOKEN_KEYWORD_ELSIF) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_EMBEXPR] = (1 << PM_TOKEN_EMBEXPR_END),
    [PM_CONTEXT_FOR] = (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_FOR_INDEX] = (1 << PM_TOKEN_KEYWORD_IN),
    [PM_CONTEXT_IF] = (1 << PM_TOKEN_KEYWORD_ELSE) | (1 << PM_TOKEN_KEYWORD_ELSIF) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_LAMBDA_BRACES] = (1 << PM_TOKEN_BRACE_RIGHT),
    [PM_CONTEXT_LAMBDA_DO_END] = (1 << PM_TOKEN_KEYWORD_END) | (1 << PM_TOKEN_KEYWORD_RESCUE) | (1 << PM_TOKEN_KEYWORD_ENSURE),
    [PM_CONTEXT_LAMBDA_ENSURE] = (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_LAMBDA_ELSE] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_LAMBDA_RESCUE] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_RESCUE) | (1 << PM_TOKEN_KEYWORD_ELSE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_LOOP_PREDICATE] = (1 << PM_TOKEN_KEYWORD_DO) | (1 << PM_TOKEN_KEYWORD_THEN),
    [PM_CONTEXT_MAIN] = (1 << PM_TOKEN_EOF),
    [PM_CONTEXT_MODULE] = (1 << PM_TOKEN_KEYWORD_END) | (1 << PM_TOKEN_KEYWORD_RESCUE) | (1 << PM_TOKEN_KEYWORD_ENSURE),
    [PM_CONTEXT_MODULE_ENSURE] = (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_MODULE_ELSE] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_MODULE_RESCUE] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_RESCUE) | (1 << PM_TOKEN_KEYWORD_ELSE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_MULTI_TARGET] = (1 << PM_TOKEN_EOF),
    [PM_CONTEXT_PARENS] = (1 << PM_TOKEN_PARENTHESIS_RIGHT),
    [PM_CONTEXT_POSTEXE] = (1 << PM_TOKEN_BRACE_RIGHT),
    [PM_CONTEXT_PREDICATE] = (1 << PM_TOKEN_KEYWORD_THEN) | (1 << PM_TOKEN_NEWLINE) | (1 << PM_TOKEN_SEMICOLON),
    [PM_CONTEXT_PREEXE] = (1 << PM_TOKEN_BRACE_RIGHT),
    [PM_CONTEXT_RESCUE_MODIFIER] = (1 << PM_TOKEN_EOF),
    [PM_CONTEXT_SCLASS] = (1 << PM_TOKEN_KEYWORD_END) | (1 << PM_TOKEN_KEYWORD_RESCUE) | (1 << PM_TOKEN_KEYWORD_ENSURE),
    [PM_CONTEXT_SCLASS_ENSURE] = (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_SCLASS_ELSE] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_SCLASS_RESCUE] = (1 << PM_TOKEN_KEYWORD_ENSURE) | (1 << PM_TOKEN_KEYWORD_RESCUE) | (1 << PM_TOKEN_KEYWORD_ELSE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_TERNARY] = (1 << PM_TOKEN_EOF),
    [PM_CONTEXT_UNLESS] = (1 << PM_TOKEN_KEYWORD_ELSE) | (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_UNTIL] = (1 << PM_TOKEN_KEYWORD_END),
    [PM_CONTEXT_WHILE] = (1 << PM_TOKEN_KEYWORD_END),
};

static inline bool
context_terminator(pm_context_t context, pm_token_t *token) {
    return token->type < 32 && (context_terminators[context] & (1 << token->type));
}

/**
 * Returns the context that the given token is found to be terminating, or
 * returns PM_CONTEXT_NONE.
 */
static pm_context_t
context_recoverable(const pm_parser_t *parser, pm_token_t *token) {
    pm_context_node_t *context_node = parser->current_context;

    while (context_node != NULL) {
        if (context_terminator(context_node->context, token)) return context_node->context;
        context_node = context_node->prev;
    }

    return PM_CONTEXT_NONE;
}

static bool
context_push(pm_parser_t *parser, pm_context_t context) {
    pm_context_node_t *context_node = (pm_context_node_t *) xmalloc(sizeof(pm_context_node_t));
    if (context_node == NULL) return false;

    *context_node = (pm_context_node_t) { .context = context, .prev = NULL };

    if (parser->current_context == NULL) {
        parser->current_context = context_node;
    } else {
        context_node->prev = parser->current_context;
        parser->current_context = context_node;
    }

    return true;
}

static void
context_pop(pm_parser_t *parser) {
    pm_context_node_t *prev = parser->current_context->prev;
    xfree(parser->current_context);
    parser->current_context = prev;
}

static bool
context_p(const pm_parser_t *parser, pm_context_t context) {
    pm_context_node_t *context_node = parser->current_context;

    while (context_node != NULL) {
        if (context_node->context == context) return true;
        context_node = context_node->prev;
    }

    return false;
}

static bool
context_def_p(const pm_parser_t *parser) {
    pm_context_node_t *context_node = parser->current_context;

    while (context_node != NULL) {
        switch (context_node->context) {
            case PM_CONTEXT_DEF:
            case PM_CONTEXT_DEF_PARAMS:
            case PM_CONTEXT_DEF_ENSURE:
            case PM_CONTEXT_DEF_RESCUE:
            case PM_CONTEXT_DEF_ELSE:
                return true;
            case PM_CONTEXT_CLASS:
            case PM_CONTEXT_CLASS_ENSURE:
            case PM_CONTEXT_CLASS_RESCUE:
            case PM_CONTEXT_CLASS_ELSE:
            case PM_CONTEXT_MODULE:
            case PM_CONTEXT_MODULE_ENSURE:
            case PM_CONTEXT_MODULE_RESCUE:
            case PM_CONTEXT_MODULE_ELSE:
            case PM_CONTEXT_SCLASS:
            case PM_CONTEXT_SCLASS_ENSURE:
            case PM_CONTEXT_SCLASS_RESCUE:
            case PM_CONTEXT_SCLASS_ELSE:
                return false;
            default:
                context_node = context_node->prev;
        }
    }

    return false;
}

/**
 * Returns a human readable string for the given context, used in error
 * messages.
 */
static const char *
context_human(pm_context_t context) {
    switch (context) {
        case PM_CONTEXT_NONE:
            assert(false && "unreachable");
            return "";
        case PM_CONTEXT_BEGIN: return "begin statement";
        case PM_CONTEXT_BLOCK_BRACES: return "'{'..'}' block";
        case PM_CONTEXT_BLOCK_KEYWORDS: return "'do'..'end' block";
        case PM_CONTEXT_CASE_WHEN: return "'when' clause";
        case PM_CONTEXT_CASE_IN: return "'in' clause";
        case PM_CONTEXT_CLASS: return "class definition";
        case PM_CONTEXT_DEF: return "method definition";
        case PM_CONTEXT_DEF_PARAMS: return "method parameters";
        case PM_CONTEXT_DEFAULT_PARAMS: return "parameter default value";
        case PM_CONTEXT_DEFINED: return "'defined?' expression";
        case PM_CONTEXT_ELSE:
        case PM_CONTEXT_BEGIN_ELSE:
        case PM_CONTEXT_BLOCK_ELSE:
        case PM_CONTEXT_CLASS_ELSE:
        case PM_CONTEXT_DEF_ELSE:
        case PM_CONTEXT_LAMBDA_ELSE:
        case PM_CONTEXT_MODULE_ELSE:
        case PM_CONTEXT_SCLASS_ELSE: return "'else' clause";
        case PM_CONTEXT_ELSIF: return "'elsif' clause";
        case PM_CONTEXT_EMBEXPR: return "embedded expression";
        case PM_CONTEXT_BEGIN_ENSURE:
        case PM_CONTEXT_BLOCK_ENSURE:
        case PM_CONTEXT_CLASS_ENSURE:
        case PM_CONTEXT_DEF_ENSURE:
        case PM_CONTEXT_LAMBDA_ENSURE:
        case PM_CONTEXT_MODULE_ENSURE:
        case PM_CONTEXT_SCLASS_ENSURE: return "'ensure' clause";
        case PM_CONTEXT_FOR: return "for loop";
        case PM_CONTEXT_FOR_INDEX: return "for loop index";
        case PM_CONTEXT_IF: return "if statement";
        case PM_CONTEXT_LAMBDA_BRACES: return "'{'..'}' lambda block";
        case PM_CONTEXT_LAMBDA_DO_END: return "'do'..'end' lambda block";
        case PM_CONTEXT_LOOP_PREDICATE: return "loop predicate";
        case PM_CONTEXT_MAIN: return "top level context";
        case PM_CONTEXT_MODULE: return "module definition";
        case PM_CONTEXT_MULTI_TARGET: return "multiple targets";
        case PM_CONTEXT_PARENS: return "parentheses";
        case PM_CONTEXT_POSTEXE: return "'END' block";
        case PM_CONTEXT_PREDICATE: return "predicate";
        case PM_CONTEXT_PREEXE: return "'BEGIN' block";
        case PM_CONTEXT_BEGIN_RESCUE:
        case PM_CONTEXT_BLOCK_RESCUE:
        case PM_CONTEXT_CLASS_RESCUE:
        case PM_CONTEXT_DEF_RESCUE:
        case PM_CONTEXT_LAMBDA_RESCUE:
        case PM_CONTEXT_MODULE_RESCUE:
        case PM_CONTEXT_RESCUE_MODIFIER:
        case PM_CONTEXT_SCLASS_RESCUE: return "'rescue' clause";
        case PM_CONTEXT_SCLASS: return "singleton class definition";
        case PM_CONTEXT_TERNARY: return "ternary expression";
        case PM_CONTEXT_UNLESS: return "unless statement";
        case PM_CONTEXT_UNTIL: return "until statement";
        case PM_CONTEXT_WHILE: return "while statement";
    }

    assert(false && "unreachable");
    return "";
}

/******************************************************************************/
/* Specific token lexers                                                      */
/******************************************************************************/

static inline void
pm_strspn_number_validate(pm_parser_t *parser, const uint8_t *string, size_t length, const uint8_t *invalid) {
    if (invalid != NULL) {
        pm_diagnostic_id_t diag_id = (invalid == (string + length - 1)) ? PM_ERR_INVALID_NUMBER_UNDERSCORE_TRAILING : PM_ERR_INVALID_NUMBER_UNDERSCORE_INNER;
        pm_parser_err(parser, invalid, invalid + 1, diag_id);
    }
}

static size_t
pm_strspn_binary_number_validate(pm_parser_t *parser, const uint8_t *string) {
    const uint8_t *invalid = NULL;
    size_t length = pm_strspn_binary_number(string, parser->end - string, &invalid);
    pm_strspn_number_validate(parser, string, length, invalid);
    return length;
}

static size_t
pm_strspn_octal_number_validate(pm_parser_t *parser, const uint8_t *string) {
    const uint8_t *invalid = NULL;
    size_t length = pm_strspn_octal_number(string, parser->end - string, &invalid);
    pm_strspn_number_validate(parser, string, length, invalid);
    return length;
}

static size_t
pm_strspn_decimal_number_validate(pm_parser_t *parser, const uint8_t *string) {
    const uint8_t *invalid = NULL;
    size_t length = pm_strspn_decimal_number(string, parser->end - string, &invalid);
    pm_strspn_number_validate(parser, string, length, invalid);
    return length;
}

static size_t
pm_strspn_hexadecimal_number_validate(pm_parser_t *parser, const uint8_t *string) {
    const uint8_t *invalid = NULL;
    size_t length = pm_strspn_hexadecimal_number(string, parser->end - string, &invalid);
    pm_strspn_number_validate(parser, string, length, invalid);
    return length;
}

static pm_token_type_t
lex_optional_float_suffix(pm_parser_t *parser, bool* seen_e) {
    pm_token_type_t type = PM_TOKEN_INTEGER;

    // Here we're going to attempt to parse the optional decimal portion of a
    // float. If it's not there, then it's okay and we'll just continue on.
    if (peek(parser) == '.') {
        if (pm_char_is_decimal_digit(peek_offset(parser, 1))) {
            parser->current.end += 2;
            parser->current.end += pm_strspn_decimal_number_validate(parser, parser->current.end);
            type = PM_TOKEN_FLOAT;
        } else {
            // If we had a . and then something else, then it's not a float
            // suffix on a number it's a method call or something else.
            return type;
        }
    }

    // Here we're going to attempt to parse the optional exponent portion of a
    // float. If it's not there, it's okay and we'll just continue on.
    if ((peek(parser) == 'e') || (peek(parser) == 'E')) {
        if ((peek_offset(parser, 1) == '+') || (peek_offset(parser, 1) == '-')) {
            parser->current.end += 2;

            if (pm_char_is_decimal_digit(peek(parser))) {
                parser->current.end++;
                parser->current.end += pm_strspn_decimal_number_validate(parser, parser->current.end);
            } else {
                pm_parser_err_current(parser, PM_ERR_INVALID_FLOAT_EXPONENT);
            }
        } else if (pm_char_is_decimal_digit(peek_offset(parser, 1))) {
            parser->current.end++;
            parser->current.end += pm_strspn_decimal_number_validate(parser, parser->current.end);
        } else {
            return type;
        }

        *seen_e = true;
        type = PM_TOKEN_FLOAT;
    }

    return type;
}

static pm_token_type_t
lex_numeric_prefix(pm_parser_t *parser, bool* seen_e) {
    pm_token_type_t type = PM_TOKEN_INTEGER;
    *seen_e = false;

    if (peek_offset(parser, -1) == '0') {
        switch (*parser->current.end) {
            // 0d1111 is a decimal number
            case 'd':
            case 'D':
                parser->current.end++;
                if (pm_char_is_decimal_digit(peek(parser))) {
                    parser->current.end += pm_strspn_decimal_number_validate(parser, parser->current.end);
                } else {
                    match(parser, '_');
                    pm_parser_err_current(parser, PM_ERR_INVALID_NUMBER_DECIMAL);
                }

                break;

            // 0b1111 is a binary number
            case 'b':
            case 'B':
                parser->current.end++;
                if (pm_char_is_binary_digit(peek(parser))) {
                    parser->current.end += pm_strspn_binary_number_validate(parser, parser->current.end);
                } else {
                    match(parser, '_');
                    pm_parser_err_current(parser, PM_ERR_INVALID_NUMBER_BINARY);
                }

                parser->integer_base = PM_INTEGER_BASE_FLAGS_BINARY;
                break;

            // 0o1111 is an octal number
            case 'o':
            case 'O':
                parser->current.end++;
                if (pm_char_is_octal_digit(peek(parser))) {
                    parser->current.end += pm_strspn_octal_number_validate(parser, parser->current.end);
                } else {
                    match(parser, '_');
                    pm_parser_err_current(parser, PM_ERR_INVALID_NUMBER_OCTAL);
                }

                parser->integer_base = PM_INTEGER_BASE_FLAGS_OCTAL;
                break;

            // 01111 is an octal number
            case '_':
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
                parser->current.end += pm_strspn_octal_number_validate(parser, parser->current.end);
                parser->integer_base = PM_INTEGER_BASE_FLAGS_OCTAL;
                break;

            // 0x1111 is a hexadecimal number
            case 'x':
            case 'X':
                parser->current.end++;
                if (pm_char_is_hexadecimal_digit(peek(parser))) {
                    parser->current.end += pm_strspn_hexadecimal_number_validate(parser, parser->current.end);
                } else {
                    match(parser, '_');
                    pm_parser_err_current(parser, PM_ERR_INVALID_NUMBER_HEXADECIMAL);
                }

                parser->integer_base = PM_INTEGER_BASE_FLAGS_HEXADECIMAL;
                break;

            // 0.xxx is a float
            case '.': {
                type = lex_optional_float_suffix(parser, seen_e);
                break;
            }

            // 0exxx is a float
            case 'e':
            case 'E': {
                type = lex_optional_float_suffix(parser, seen_e);
                break;
            }
        }
    } else {
        // If it didn't start with a 0, then we'll lex as far as we can into a
        // decimal number.
        parser->current.end += pm_strspn_decimal_number_validate(parser, parser->current.end);

        // Afterward, we'll lex as far as we can into an optional float suffix.
        type = lex_optional_float_suffix(parser, seen_e);
    }

    // At this point we have a completed number, but we want to provide the user
    // with a good experience if they put an additional .xxx fractional
    // component on the end, so we'll check for that here.
    if (peek_offset(parser, 0) == '.' && pm_char_is_decimal_digit(peek_offset(parser, 1))) {
        const uint8_t *fraction_start = parser->current.end;
        const uint8_t *fraction_end = parser->current.end + 2;
        fraction_end += pm_strspn_decimal_digit(fraction_end, parser->end - fraction_end);
        pm_parser_err(parser, fraction_start, fraction_end, PM_ERR_INVALID_NUMBER_FRACTION);
    }

    return type;
}

static pm_token_type_t
lex_numeric(pm_parser_t *parser) {
    pm_token_type_t type = PM_TOKEN_INTEGER;
    parser->integer_base = PM_INTEGER_BASE_FLAGS_DECIMAL;

    if (parser->current.end < parser->end) {
        bool seen_e = false;
        type = lex_numeric_prefix(parser, &seen_e);

        const uint8_t *end = parser->current.end;
        pm_token_type_t suffix_type = type;

        if (type == PM_TOKEN_INTEGER) {
            if (match(parser, 'r')) {
                suffix_type = PM_TOKEN_INTEGER_RATIONAL;

                if (match(parser, 'i')) {
                    suffix_type = PM_TOKEN_INTEGER_RATIONAL_IMAGINARY;
                }
            } else if (match(parser, 'i')) {
                suffix_type = PM_TOKEN_INTEGER_IMAGINARY;
            }
        } else {
            if (!seen_e && match(parser, 'r')) {
                suffix_type = PM_TOKEN_FLOAT_RATIONAL;

                if (match(parser, 'i')) {
                    suffix_type = PM_TOKEN_FLOAT_RATIONAL_IMAGINARY;
                }
            } else if (match(parser, 'i')) {
                suffix_type = PM_TOKEN_FLOAT_IMAGINARY;
            }
        }

        const uint8_t b = peek(parser);
        if (b != '\0' && (b >= 0x80 || ((b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')) || b == '_')) {
            parser->current.end = end;
        } else {
            type = suffix_type;
        }
    }

    return type;
}

static pm_token_type_t
lex_global_variable(pm_parser_t *parser) {
    if (parser->current.end >= parser->end) {
        pm_parser_err_token(parser, &parser->current, PM_ERR_GLOBAL_VARIABLE_BARE);
        return PM_TOKEN_GLOBAL_VARIABLE;
    }

    // True if multiple characters are allowed after the declaration of the
    // global variable. Not true when it starts with "$-".
    bool allow_multiple = true;

    switch (*parser->current.end) {
        case '~':  // $~: match-data
        case '*':  // $*: argv
        case '$':  // $$: pid
        case '?':  // $?: last status
        case '!':  // $!: error string
        case '@':  // $@: error position
        case '/':  // $/: input record separator
        case '\\': // $\: output record separator
        case ';':  // $;: field separator
        case ',':  // $,: output field separator
        case '.':  // $.: last read line number
        case '=':  // $=: ignorecase
        case ':':  // $:: load path
        case '<':  // $<: reading filename
        case '>':  // $>: default output handle
        case '\"': // $": already loaded files
            parser->current.end++;
            return PM_TOKEN_GLOBAL_VARIABLE;

        case '&':  // $&: last match
        case '`':  // $`: string before last match
        case '\'': // $': string after last match
        case '+':  // $+: string matches last paren.
            parser->current.end++;
            return lex_state_p(parser, PM_LEX_STATE_FNAME) ? PM_TOKEN_GLOBAL_VARIABLE : PM_TOKEN_BACK_REFERENCE;

        case '0': {
            parser->current.end++;
            size_t width;

            if ((width = char_is_identifier(parser, parser->current.end, parser->end - parser->current.end)) > 0) {
                do {
                    parser->current.end += width;
                } while ((width = char_is_identifier(parser, parser->current.end, parser->end - parser->current.end)) > 0);

                // $0 isn't allowed to be followed by anything.
                pm_diagnostic_id_t diag_id = parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3 ? PM_ERR_INVALID_VARIABLE_GLOBAL_3_3 : PM_ERR_INVALID_VARIABLE_GLOBAL;
                PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, parser->current, diag_id);
            }

            return PM_TOKEN_GLOBAL_VARIABLE;
        }

        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            parser->current.end += pm_strspn_decimal_digit(parser->current.end, parser->end - parser->current.end);
            return lex_state_p(parser, PM_LEX_STATE_FNAME) ? PM_TOKEN_GLOBAL_VARIABLE : PM_TOKEN_NUMBERED_REFERENCE;

        case '-':
            parser->current.end++;
            allow_multiple = false;
            PRISM_FALLTHROUGH
        default: {
            size_t width;

            if ((width = char_is_identifier(parser, parser->current.end, parser->end - parser->current.end)) > 0) {
                do {
                    parser->current.end += width;
                } while (allow_multiple && (width = char_is_identifier(parser, parser->current.end, parser->end - parser->current.end)) > 0);
            } else if (pm_char_is_whitespace(peek(parser))) {
                // If we get here, then we have a $ followed by whitespace,
                // which is not allowed.
                pm_parser_err_token(parser, &parser->current, PM_ERR_GLOBAL_VARIABLE_BARE);
            } else {
                // If we get here, then we have a $ followed by something that
                // isn't recognized as a global variable.
                pm_diagnostic_id_t diag_id = parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3 ? PM_ERR_INVALID_VARIABLE_GLOBAL_3_3 : PM_ERR_INVALID_VARIABLE_GLOBAL;
                const uint8_t *end = parser->current.end + parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);
                PM_PARSER_ERR_FORMAT(parser, parser->current.start, end, diag_id, (int) (end - parser->current.start), (const char *) parser->current.start);
            }

            return PM_TOKEN_GLOBAL_VARIABLE;
        }
    }
}

/**
 * This function checks if the current token matches a keyword. If it does, it
 * returns the token type. Otherwise, it returns PM_TOKEN_EOF. The arguments are as follows:
 *
 * * `parser` - the parser object
 * * `current_start` - pointer to the start of the current token
 * * `value` - the literal string that we're checking for
 * * `vlen` - the length of the token
 * * `state` - the state that we should transition to if the token matches
 * * `type` - the expected token type
 * * `modifier_type` - the expected modifier token type
 */
static inline pm_token_type_t
lex_keyword(pm_parser_t *parser, const uint8_t *current_start, const char *value, size_t vlen, pm_lex_state_t state, pm_token_type_t type, pm_token_type_t modifier_type) {
    if (memcmp(current_start, value, vlen) == 0) {
        pm_lex_state_t last_state = parser->lex_state;

        if (parser->lex_state & PM_LEX_STATE_FNAME) {
            lex_state_set(parser, PM_LEX_STATE_ENDFN);
        } else {
            lex_state_set(parser, state);
            if (state == PM_LEX_STATE_BEG) {
                parser->command_start = true;
            }

            if ((modifier_type != PM_TOKEN_EOF) && !(last_state & (PM_LEX_STATE_BEG | PM_LEX_STATE_LABELED | PM_LEX_STATE_CLASS))) {
                lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
                return modifier_type;
            }
        }

        return type;
    }

    return PM_TOKEN_EOF;
}

static pm_token_type_t
lex_identifier(pm_parser_t *parser, bool previous_command_start) {
    // Lex as far as we can into the current identifier.
    size_t width;
    const uint8_t *end = parser->end;
    const uint8_t *current_start = parser->current.start;
    const uint8_t *current_end = parser->current.end;
    bool encoding_changed = parser->encoding_changed;

    if (encoding_changed) {
        while ((width = char_is_identifier(parser, current_end, end - current_end)) > 0) {
            current_end += width;
        }
    } else {
        while ((width = char_is_identifier_utf8(current_end, end - current_end)) > 0) {
            current_end += width;
        }
    }
    parser->current.end = current_end;

    // Now cache the length of the identifier so that we can quickly compare it
    // against known keywords.
    width = (size_t) (current_end - current_start);

    if (current_end < end) {
        if (((current_end + 1 >= end) || (current_end[1] != '=')) && (match(parser, '!') || match(parser, '?'))) {
            // First we'll attempt to extend the identifier by a ! or ?. Then we'll
            // check if we're returning the defined? keyword or just an identifier.
            width++;

            if (
                ((lex_state_p(parser, PM_LEX_STATE_LABEL | PM_LEX_STATE_ENDFN) && !previous_command_start) || lex_state_arg_p(parser)) &&
                (peek(parser) == ':') && (peek_offset(parser, 1) != ':')
            ) {
                // If we're in a position where we can accept a : at the end of an
                // identifier, then we'll optionally accept it.
                lex_state_set(parser, PM_LEX_STATE_ARG | PM_LEX_STATE_LABELED);
                (void) match(parser, ':');
                return PM_TOKEN_LABEL;
            }

            if (parser->lex_state != PM_LEX_STATE_DOT) {
                if (width == 8 && (lex_keyword(parser, current_start, "defined?", width, PM_LEX_STATE_ARG, PM_TOKEN_KEYWORD_DEFINED, PM_TOKEN_EOF) != PM_TOKEN_EOF)) {
                    return PM_TOKEN_KEYWORD_DEFINED;
                }
            }

            return PM_TOKEN_METHOD_NAME;
        }

        if (lex_state_p(parser, PM_LEX_STATE_FNAME) && peek_offset(parser, 1) != '~' && peek_offset(parser, 1) != '>' && (peek_offset(parser, 1) != '=' || peek_offset(parser, 2) == '>') && match(parser, '=')) {
            // If we're in a position where we can accept a = at the end of an
            // identifier, then we'll optionally accept it.
            return PM_TOKEN_IDENTIFIER;
        }

        if (
            ((lex_state_p(parser, PM_LEX_STATE_LABEL | PM_LEX_STATE_ENDFN) && !previous_command_start) || lex_state_arg_p(parser)) &&
            peek(parser) == ':' && peek_offset(parser, 1) != ':'
        ) {
            // If we're in a position where we can accept a : at the end of an
            // identifier, then we'll optionally accept it.
            lex_state_set(parser, PM_LEX_STATE_ARG | PM_LEX_STATE_LABELED);
            (void) match(parser, ':');
            return PM_TOKEN_LABEL;
        }
    }

    if (parser->lex_state != PM_LEX_STATE_DOT) {
        pm_token_type_t type;
        switch (width) {
            case 2:
                if (lex_keyword(parser, current_start, "do", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_DO, PM_TOKEN_EOF) != PM_TOKEN_EOF) {
                    if (pm_do_loop_stack_p(parser)) {
                        return PM_TOKEN_KEYWORD_DO_LOOP;
                    }
                    return PM_TOKEN_KEYWORD_DO;
                }

                if ((type = lex_keyword(parser, current_start, "if", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_IF, PM_TOKEN_KEYWORD_IF_MODIFIER)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "in", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_IN, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "or", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_OR, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                break;
            case 3:
                if ((type = lex_keyword(parser, current_start, "and", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_AND, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "def", width, PM_LEX_STATE_FNAME, PM_TOKEN_KEYWORD_DEF, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "end", width, PM_LEX_STATE_END, PM_TOKEN_KEYWORD_END, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "END", width, PM_LEX_STATE_END, PM_TOKEN_KEYWORD_END_UPCASE, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "for", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_FOR, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "nil", width, PM_LEX_STATE_END, PM_TOKEN_KEYWORD_NIL, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "not", width, PM_LEX_STATE_ARG, PM_TOKEN_KEYWORD_NOT, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                break;
            case 4:
                if ((type = lex_keyword(parser, current_start, "case", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_CASE, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "else", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "next", width, PM_LEX_STATE_MID, PM_TOKEN_KEYWORD_NEXT, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "redo", width, PM_LEX_STATE_END, PM_TOKEN_KEYWORD_REDO, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "self", width, PM_LEX_STATE_END, PM_TOKEN_KEYWORD_SELF, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "then", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_THEN, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "true", width, PM_LEX_STATE_END, PM_TOKEN_KEYWORD_TRUE, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "when", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_WHEN, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                break;
            case 5:
                if ((type = lex_keyword(parser, current_start, "alias", width, PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM, PM_TOKEN_KEYWORD_ALIAS, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "begin", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_BEGIN, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "BEGIN", width, PM_LEX_STATE_END, PM_TOKEN_KEYWORD_BEGIN_UPCASE, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "break", width, PM_LEX_STATE_MID, PM_TOKEN_KEYWORD_BREAK, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "class", width, PM_LEX_STATE_CLASS, PM_TOKEN_KEYWORD_CLASS, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "elsif", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_ELSIF, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "false", width, PM_LEX_STATE_END, PM_TOKEN_KEYWORD_FALSE, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "retry", width, PM_LEX_STATE_END, PM_TOKEN_KEYWORD_RETRY, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "super", width, PM_LEX_STATE_ARG, PM_TOKEN_KEYWORD_SUPER, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "undef", width, PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM, PM_TOKEN_KEYWORD_UNDEF, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "until", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_UNTIL, PM_TOKEN_KEYWORD_UNTIL_MODIFIER)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "while", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_WHILE, PM_TOKEN_KEYWORD_WHILE_MODIFIER)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "yield", width, PM_LEX_STATE_ARG, PM_TOKEN_KEYWORD_YIELD, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                break;
            case 6:
                if ((type = lex_keyword(parser, current_start, "ensure", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "module", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_MODULE, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "rescue", width, PM_LEX_STATE_MID, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_RESCUE_MODIFIER)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "return", width, PM_LEX_STATE_MID, PM_TOKEN_KEYWORD_RETURN, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "unless", width, PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_UNLESS, PM_TOKEN_KEYWORD_UNLESS_MODIFIER)) != PM_TOKEN_EOF) return type;
                break;
            case 8:
                if ((type = lex_keyword(parser, current_start, "__LINE__", width, PM_LEX_STATE_END, PM_TOKEN_KEYWORD___LINE__, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                if ((type = lex_keyword(parser, current_start, "__FILE__", width, PM_LEX_STATE_END, PM_TOKEN_KEYWORD___FILE__, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                break;
            case 12:
                if ((type = lex_keyword(parser, current_start, "__ENCODING__", width, PM_LEX_STATE_END, PM_TOKEN_KEYWORD___ENCODING__, PM_TOKEN_EOF)) != PM_TOKEN_EOF) return type;
                break;
        }
    }

    if (encoding_changed) {
        return parser->encoding->isupper_char(current_start, end - current_start) ? PM_TOKEN_CONSTANT : PM_TOKEN_IDENTIFIER;
    }
    return pm_encoding_utf_8_isupper_char(current_start, end - current_start) ? PM_TOKEN_CONSTANT : PM_TOKEN_IDENTIFIER;
}

/**
 * Returns true if the current token that the parser is considering is at the
 * beginning of a line or the beginning of the source.
 */
static bool
current_token_starts_line(pm_parser_t *parser) {
    return (parser->current.start == parser->start) || (parser->current.start[-1] == '\n');
}

/**
 * When we hit a # while lexing something like a string, we need to potentially
 * handle interpolation. This function performs that check. It returns a token
 * type representing what it found. Those cases are:
 *
 * * PM_TOKEN_NOT_PROVIDED - No interpolation was found at this point. The
 *     caller should keep lexing.
 * * PM_TOKEN_STRING_CONTENT - No interpolation was found at this point. The
 *     caller should return this token type.
 * * PM_TOKEN_EMBEXPR_BEGIN - An embedded expression was found. The caller
 *     should return this token type.
 * * PM_TOKEN_EMBVAR - An embedded variable was found. The caller should return
 *     this token type.
 */
static pm_token_type_t
lex_interpolation(pm_parser_t *parser, const uint8_t *pound) {
    // If there is no content following this #, then we're at the end of
    // the string and we can safely return string content.
    if (pound + 1 >= parser->end) {
        parser->current.end = pound + 1;
        return PM_TOKEN_STRING_CONTENT;
    }

    // Now we'll check against the character that follows the #. If it constitutes
    // valid interplation, we'll handle that, otherwise we'll return
    // PM_TOKEN_NOT_PROVIDED.
    switch (pound[1]) {
        case '@': {
            // In this case we may have hit an embedded instance or class variable.
            if (pound + 2 >= parser->end) {
                parser->current.end = pound + 1;
                return PM_TOKEN_STRING_CONTENT;
            }

            // If we're looking at a @ and there's another @, then we'll skip past the
            // second @.
            const uint8_t *variable = pound + 2;
            if (*variable == '@' && pound + 3 < parser->end) variable++;

            if (char_is_identifier_start(parser, variable, parser->end - variable)) {
                // At this point we're sure that we've either hit an embedded instance
                // or class variable. In this case we'll first need to check if we've
                // already consumed content.
                if (pound > parser->current.start) {
                    parser->current.end = pound;
                    return PM_TOKEN_STRING_CONTENT;
                }

                // Otherwise we need to return the embedded variable token
                // and then switch to the embedded variable lex mode.
                lex_mode_push(parser, (pm_lex_mode_t) { .mode = PM_LEX_EMBVAR });
                parser->current.end = pound + 1;
                return PM_TOKEN_EMBVAR;
            }

            // If we didn't get a valid interpolation, then this is just regular
            // string content. This is like if we get "#@-". In this case the caller
            // should keep lexing.
            parser->current.end = pound + 1;
            return PM_TOKEN_NOT_PROVIDED;
        }
        case '$':
            // In this case we may have hit an embedded global variable. If there's
            // not enough room, then we'll just return string content.
            if (pound + 2 >= parser->end) {
                parser->current.end = pound + 1;
                return PM_TOKEN_STRING_CONTENT;
            }

            // This is the character that we're going to check to see if it is the
            // start of an identifier that would indicate that this is a global
            // variable.
            const uint8_t *check = pound + 2;

            if (pound[2] == '-') {
                if (pound + 3 >= parser->end) {
                    parser->current.end = pound + 2;
                    return PM_TOKEN_STRING_CONTENT;
                }

                check++;
            }

            // If the character that we're going to check is the start of an
            // identifier, or we don't have a - and the character is a decimal number
            // or a global name punctuation character, then we've hit an embedded
            // global variable.
            if (
                char_is_identifier_start(parser, check, parser->end - check) ||
                (pound[2] != '-' && (pm_char_is_decimal_digit(pound[2]) || char_is_global_name_punctuation(pound[2])))
            ) {
                // In this case we've hit an embedded global variable. First check to
                // see if we've already consumed content. If we have, then we need to
                // return that content as string content first.
                if (pound > parser->current.start) {
                    parser->current.end = pound;
                    return PM_TOKEN_STRING_CONTENT;
                }

                // Otherwise, we need to return the embedded variable token and switch
                // to the embedded variable lex mode.
                lex_mode_push(parser, (pm_lex_mode_t) { .mode = PM_LEX_EMBVAR });
                parser->current.end = pound + 1;
                return PM_TOKEN_EMBVAR;
            }

            // In this case we've hit a #$ that does not indicate a global variable.
            // In this case we'll continue lexing past it.
            parser->current.end = pound + 1;
            return PM_TOKEN_NOT_PROVIDED;
        case '{':
            // In this case it's the start of an embedded expression. If we have
            // already consumed content, then we need to return that content as string
            // content first.
            if (pound > parser->current.start) {
                parser->current.end = pound;
                return PM_TOKEN_STRING_CONTENT;
            }

            parser->enclosure_nesting++;

            // Otherwise we'll skip past the #{ and begin lexing the embedded
            // expression.
            lex_mode_push(parser, (pm_lex_mode_t) { .mode = PM_LEX_EMBEXPR });
            parser->current.end = pound + 2;
            parser->command_start = true;
            pm_do_loop_stack_push(parser, false);
            return PM_TOKEN_EMBEXPR_BEGIN;
        default:
            // In this case we've hit a # that doesn't constitute interpolation. We'll
            // mark that by returning the not provided token type. This tells the
            // consumer to keep lexing forward.
            parser->current.end = pound + 1;
            return PM_TOKEN_NOT_PROVIDED;
    }
}

static const uint8_t PM_ESCAPE_FLAG_NONE = 0x0;
static const uint8_t PM_ESCAPE_FLAG_CONTROL = 0x1;
static const uint8_t PM_ESCAPE_FLAG_META = 0x2;
static const uint8_t PM_ESCAPE_FLAG_SINGLE = 0x4;
static const uint8_t PM_ESCAPE_FLAG_REGEXP = 0x8;

/**
 * This is a lookup table for whether or not an ASCII character is printable.
 */
static const bool ascii_printable_chars[] = {
    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0
};

static inline bool
char_is_ascii_printable(const uint8_t b) {
    return (b < 0x80) && ascii_printable_chars[b];
}

/**
 * Return the value that a hexadecimal digit character represents. For example,
 * transform 'a' into 10, 'b' into 11, etc.
 */
static inline uint8_t
escape_hexadecimal_digit(const uint8_t value) {
    return (uint8_t) ((value <= '9') ? (value - '0') : (value & 0x7) + 9);
}

/**
 * Scan the 4 digits of a Unicode escape into the value. Returns the number of
 * digits scanned. This function assumes that the characters have already been
 * validated.
 */
static inline uint32_t
escape_unicode(pm_parser_t *parser, const uint8_t *string, size_t length) {
    uint32_t value = 0;
    for (size_t index = 0; index < length; index++) {
        if (index != 0) value <<= 4;
        value |= escape_hexadecimal_digit(string[index]);
    }

    // Here we're going to verify that the value is actually a valid Unicode
    // codepoint and not a surrogate pair.
    if (value >= 0xD800 && value <= 0xDFFF) {
        pm_parser_err(parser, string, string + length, PM_ERR_ESCAPE_INVALID_UNICODE);
        return 0xFFFD;
    }

    return value;
}

/**
 * Escape a single character value based on the given flags.
 */
static inline uint8_t
escape_byte(uint8_t value, const uint8_t flags) {
    if (flags & PM_ESCAPE_FLAG_CONTROL) value &= 0x9f;
    if (flags & PM_ESCAPE_FLAG_META) value |= 0x80;
    return value;
}

/**
 * Write a unicode codepoint to the given buffer.
 */
static inline void
escape_write_unicode(pm_parser_t *parser, pm_buffer_t *buffer, const uint8_t flags, const uint8_t *start, const uint8_t *end, uint32_t value) {
    // \u escape sequences in string-like structures implicitly change the
    // encoding to UTF-8 if they are >= 0x80 or if they are used in a character
    // literal.
    if (value >= 0x80 || flags & PM_ESCAPE_FLAG_SINGLE) {
        if (parser->explicit_encoding != NULL && parser->explicit_encoding != PM_ENCODING_UTF_8_ENTRY) {
            PM_PARSER_ERR_FORMAT(parser, start, end, PM_ERR_MIXED_ENCODING, parser->explicit_encoding->name);
        }

        parser->explicit_encoding = PM_ENCODING_UTF_8_ENTRY;
    }

    if (!pm_buffer_append_unicode_codepoint(buffer, value)) {
        pm_parser_err(parser, start, end, PM_ERR_ESCAPE_INVALID_UNICODE);
        pm_buffer_append_byte(buffer, 0xEF);
        pm_buffer_append_byte(buffer, 0xBF);
        pm_buffer_append_byte(buffer, 0xBD);
    }
}

/**
 * When you're writing a byte to the unescape buffer, if the byte is non-ASCII
 * (i.e., the top bit is set) then it locks in the encoding.
 */
static inline void
escape_write_byte_encoded(pm_parser_t *parser, pm_buffer_t *buffer, uint8_t byte) {
    if (byte >= 0x80) {
        if (parser->explicit_encoding != NULL && parser->explicit_encoding == PM_ENCODING_UTF_8_ENTRY && parser->encoding != PM_ENCODING_UTF_8_ENTRY) {
            PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_MIXED_ENCODING, parser->encoding->name);
        }

        parser->explicit_encoding = parser->encoding;
    }

    pm_buffer_append_byte(buffer, byte);
}

/**
 * The regular expression engine doesn't support the same escape sequences as
 * Ruby does. So first we have to read the escape sequence, and then we have to
 * format it like the regular expression engine expects it. For example, in Ruby
 * if we have:
 *
 *     /\M-\C-?/
 *
 * then the first byte is actually 255, so we have to rewrite this as:
 *
 *     /\xFF/
 *
 * Note that in this case there is a literal \ byte in the regular expression
 * source so that the regular expression engine will perform its own unescaping.
 */
static inline void
escape_write_byte(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expression_buffer, uint8_t flags, uint8_t byte) {
    if (flags & PM_ESCAPE_FLAG_REGEXP) {
        pm_buffer_append_format(regular_expression_buffer, "\\x%02X", byte);
    }

    escape_write_byte_encoded(parser, buffer, byte);
}

/**
 * Write each byte of the given escaped character into the buffer.
 */
static inline void
escape_write_escape_encoded(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expression_buffer, uint8_t flags) {
    size_t width;
    if (parser->encoding_changed) {
        width = parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);
    } else {
        width = pm_encoding_utf_8_char_width(parser->current.end, parser->end - parser->current.end);
    }

    if (width == 1) {
        escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte(*parser->current.end++, flags));
    } else if (width > 1) {
        // Valid multibyte character.  Just ignore escape.
        pm_buffer_t *b = (flags & PM_ESCAPE_FLAG_REGEXP) ? regular_expression_buffer : buffer;
        pm_buffer_append_bytes(b, parser->current.end, width);
        parser->current.end += width;
    } else {
        // Assume the next character wasn't meant to be part of this escape
        // sequence since it is invalid. Add an error and move on.
        parser->current.end++;
        pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_CONTROL);
    }
}

/**
 * Warn about using a space or a tab character in an escape, as opposed to using
 * \\s or \\t. Note that we can quite copy the source because the warning
 * message replaces \\c with \\C.
 */
static void
escape_read_warn(pm_parser_t *parser, uint8_t flags, uint8_t flag, const char *type) {
#define FLAG(value) ((value & PM_ESCAPE_FLAG_CONTROL) ? "\\C-" : (value & PM_ESCAPE_FLAG_META) ? "\\M-" : "")

    PM_PARSER_WARN_TOKEN_FORMAT(
        parser,
        parser->current,
        PM_WARN_INVALID_CHARACTER,
        FLAG(flags),
        FLAG(flag),
        type
    );

#undef FLAG
}

/**
 * Read the value of an escape into the buffer.
 */
static void
escape_read(pm_parser_t *parser, pm_buffer_t *buffer, pm_buffer_t *regular_expression_buffer, uint8_t flags) {
    uint8_t peeked = peek(parser);
    switch (peeked) {
        case '\\': {
            parser->current.end++;
            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\\', flags));
            return;
        }
        case '\'': {
            parser->current.end++;
            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\'', flags));
            return;
        }
        case 'a': {
            parser->current.end++;
            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\a', flags));
            return;
        }
        case 'b': {
            parser->current.end++;
            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\b', flags));
            return;
        }
        case 'e': {
            parser->current.end++;
            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\033', flags));
            return;
        }
        case 'f': {
            parser->current.end++;
            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\f', flags));
            return;
        }
        case 'n': {
            parser->current.end++;
            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\n', flags));
            return;
        }
        case 'r': {
            parser->current.end++;
            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\r', flags));
            return;
        }
        case 's': {
            parser->current.end++;
            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte(' ', flags));
            return;
        }
        case 't': {
            parser->current.end++;
            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\t', flags));
            return;
        }
        case 'v': {
            parser->current.end++;
            escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte('\v', flags));
            return;
        }
        case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': {
            uint8_t value = (uint8_t) (*parser->current.end - '0');
            parser->current.end++;

            if (pm_char_is_octal_digit(peek(parser))) {
                value = ((uint8_t) (value << 3)) | ((uint8_t) (*parser->current.end - '0'));
                parser->current.end++;

                if (pm_char_is_octal_digit(peek(parser))) {
                    value = ((uint8_t) (value << 3)) | ((uint8_t) (*parser->current.end - '0'));
                    parser->current.end++;
                }
            }

            value = escape_byte(value, flags);
            escape_write_byte(parser, buffer, regular_expression_buffer, flags, value);
            return;
        }
        case 'x': {
            const uint8_t *start = parser->current.end - 1;

            parser->current.end++;
            uint8_t byte = peek(parser);

            if (pm_char_is_hexadecimal_digit(byte)) {
                uint8_t value = escape_hexadecimal_digit(byte);
                parser->current.end++;

                byte = peek(parser);
                if (pm_char_is_hexadecimal_digit(byte)) {
                    value = (uint8_t) ((value << 4) | escape_hexadecimal_digit(byte));
                    parser->current.end++;
                }

                value = escape_byte(value, flags);
                if (flags & PM_ESCAPE_FLAG_REGEXP) {
                    if (flags & (PM_ESCAPE_FLAG_CONTROL | PM_ESCAPE_FLAG_META)) {
                        pm_buffer_append_format(regular_expression_buffer, "\\x%02X", value);
                    } else {
                        pm_buffer_append_bytes(regular_expression_buffer, start, (size_t) (parser->current.end - start));
                    }
                }

                escape_write_byte_encoded(parser, buffer, value);
            } else {
                pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_HEXADECIMAL);
            }

            return;
        }
        case 'u': {
            const uint8_t *start = parser->current.end - 1;
            parser->current.end++;

            if (parser->current.end == parser->end) {
                const uint8_t *start = parser->current.end - 2;
                PM_PARSER_ERR_FORMAT(parser, start, parser->current.end, PM_ERR_ESCAPE_INVALID_UNICODE_SHORT, 2, start);
            } else if (peek(parser) == '{') {
                const uint8_t *unicode_codepoints_start = parser->current.end - 2;
                parser->current.end++;

                size_t whitespace;
                while (true) {
                    if ((whitespace = pm_strspn_inline_whitespace(parser->current.end, parser->end - parser->current.end)) > 0) {
                        parser->current.end += whitespace;
                    } else if (peek(parser) == '\\' && peek_offset(parser, 1) == 'n') {
                        // This is super hacky, but it gets us nicer error
                        // messages because we can still pass it off to the
                        // regular expression engine even if we hit an
                        // unterminated regular expression.
                        parser->current.end += 2;
                    } else {
                        break;
                    }
                }

                const uint8_t *extra_codepoints_start = NULL;
                int codepoints_count = 0;

                while ((parser->current.end < parser->end) && (*parser->current.end != '}')) {
                    const uint8_t *unicode_start = parser->current.end;
                    size_t hexadecimal_length = pm_strspn_hexadecimal_digit(parser->current.end, parser->end - parser->current.end);

                    if (hexadecimal_length > 6) {
                        // \u{nnnn} character literal allows only 1-6 hexadecimal digits
                        pm_parser_err(parser, unicode_start, unicode_start + hexadecimal_length, PM_ERR_ESCAPE_INVALID_UNICODE_LONG);
                    } else if (hexadecimal_length == 0) {
                        // there are not hexadecimal characters

                        if (flags & PM_ESCAPE_FLAG_REGEXP) {
                            // If this is a regular expression, we are going to
                            // let the regular expression engine handle this
                            // error instead of us.
                            pm_buffer_append_bytes(regular_expression_buffer, start, (size_t) (parser->current.end - start));
                        } else {
                            pm_parser_err(parser, parser->current.end, parser->current.end, PM_ERR_ESCAPE_INVALID_UNICODE);
                            pm_parser_err(parser, parser->current.end, parser->current.end, PM_ERR_ESCAPE_INVALID_UNICODE_TERM);
                        }

                        return;
                    }

                    parser->current.end += hexadecimal_length;
                    codepoints_count++;
                    if (flags & PM_ESCAPE_FLAG_SINGLE && codepoints_count == 2) {
                        extra_codepoints_start = unicode_start;
                    }

                    uint32_t value = escape_unicode(parser, unicode_start, hexadecimal_length);
                    escape_write_unicode(parser, buffer, flags, unicode_start, parser->current.end, value);

                    parser->current.end += pm_strspn_inline_whitespace(parser->current.end, parser->end - parser->current.end);
                }

                // ?\u{nnnn} character literal should contain only one codepoint
                // and cannot be like ?\u{nnnn mmmm}.
                if (flags & PM_ESCAPE_FLAG_SINGLE && codepoints_count > 1) {
                    pm_parser_err(parser, extra_codepoints_start, parser->current.end - 1, PM_ERR_ESCAPE_INVALID_UNICODE_LITERAL);
                }

                if (parser->current.end == parser->end) {
                    PM_PARSER_ERR_FORMAT(parser, start, parser->current.end, PM_ERR_ESCAPE_INVALID_UNICODE_LIST, (int) (parser->current.end - start), start);
                } else if (peek(parser) == '}') {
                    parser->current.end++;
                } else {
                    if (flags & PM_ESCAPE_FLAG_REGEXP) {
                        // If this is a regular expression, we are going to let
                        // the regular expression engine handle this error
                        // instead of us.
                        pm_buffer_append_bytes(regular_expression_buffer, start, (size_t) (parser->current.end - start));
                    } else {
                        pm_parser_err(parser, unicode_codepoints_start, parser->current.end, PM_ERR_ESCAPE_INVALID_UNICODE_TERM);
                    }
                }

                if (flags & PM_ESCAPE_FLAG_REGEXP) {
                    pm_buffer_append_bytes(regular_expression_buffer, unicode_codepoints_start, (size_t) (parser->current.end - unicode_codepoints_start));
                }
            } else {
                size_t length = pm_strspn_hexadecimal_digit(parser->current.end, MIN(parser->end - parser->current.end, 4));

                if (length == 0) {
                    if (flags & PM_ESCAPE_FLAG_REGEXP) {
                        pm_buffer_append_bytes(regular_expression_buffer, start, (size_t) (parser->current.end - start));
                    } else {
                        const uint8_t *start = parser->current.end - 2;
                        PM_PARSER_ERR_FORMAT(parser, start, parser->current.end, PM_ERR_ESCAPE_INVALID_UNICODE_SHORT, 2, start);
                    }
                } else if (length == 4) {
                    uint32_t value = escape_unicode(parser, parser->current.end, 4);

                    if (flags & PM_ESCAPE_FLAG_REGEXP) {
                        pm_buffer_append_bytes(regular_expression_buffer, start, (size_t) (parser->current.end + 4 - start));
                    }

                    escape_write_unicode(parser, buffer, flags, start, parser->current.end + 4, value);
                    parser->current.end += 4;
                } else {
                    parser->current.end += length;

                    if (flags & PM_ESCAPE_FLAG_REGEXP) {
                        // If this is a regular expression, we are going to let
                        // the regular expression engine handle this error
                        // instead of us.
                        pm_buffer_append_bytes(regular_expression_buffer, start, (size_t) (parser->current.end - start));
                    } else {
                        pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_UNICODE);
                    }
                }
            }

            return;
        }
        case 'c': {
            parser->current.end++;
            if (flags & PM_ESCAPE_FLAG_CONTROL) {
                pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_CONTROL_REPEAT);
            }

            if (parser->current.end == parser->end) {
                pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_CONTROL);
                return;
            }

            uint8_t peeked = peek(parser);
            switch (peeked) {
                case '?': {
                    parser->current.end++;
                    escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte(0x7f, flags));
                    return;
                }
                case '\\':
                    parser->current.end++;

                    if (match(parser, 'u') || match(parser, 'U')) {
                        pm_parser_err(parser, parser->current.start, parser->current.end, PM_ERR_INVALID_ESCAPE_CHARACTER);
                        return;
                    }

                    escape_read(parser, buffer, regular_expression_buffer, flags | PM_ESCAPE_FLAG_CONTROL);
                    return;
                case ' ':
                    parser->current.end++;
                    escape_read_warn(parser, flags, PM_ESCAPE_FLAG_CONTROL, "\\s");
                    escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte(peeked, flags | PM_ESCAPE_FLAG_CONTROL));
                    return;
                case '\t':
                    parser->current.end++;
                    escape_read_warn(parser, flags, 0, "\\t");
                    escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte(peeked, flags | PM_ESCAPE_FLAG_CONTROL));
                    return;
                default: {
                    if (!char_is_ascii_printable(peeked)) {
                        pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_CONTROL);
                        return;
                    }

                    parser->current.end++;
                    escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte(peeked, flags | PM_ESCAPE_FLAG_CONTROL));
                    return;
                }
            }
        }
        case 'C': {
            parser->current.end++;
            if (flags & PM_ESCAPE_FLAG_CONTROL) {
                pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_CONTROL_REPEAT);
            }

            if (peek(parser) != '-') {
                size_t width = parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);
                pm_parser_err(parser, parser->current.start, parser->current.end + width, PM_ERR_ESCAPE_INVALID_CONTROL);
                return;
            }

            parser->current.end++;
            if (parser->current.end == parser->end) {
                pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_CONTROL);
                return;
            }

            uint8_t peeked = peek(parser);
            switch (peeked) {
                case '?': {
                    parser->current.end++;
                    escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte(0x7f, flags));
                    return;
                }
                case '\\':
                    parser->current.end++;

                    if (match(parser, 'u') || match(parser, 'U')) {
                        pm_parser_err(parser, parser->current.start, parser->current.end, PM_ERR_INVALID_ESCAPE_CHARACTER);
                        return;
                    }

                    escape_read(parser, buffer, regular_expression_buffer, flags | PM_ESCAPE_FLAG_CONTROL);
                    return;
                case ' ':
                    parser->current.end++;
                    escape_read_warn(parser, flags, PM_ESCAPE_FLAG_CONTROL, "\\s");
                    escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte(peeked, flags | PM_ESCAPE_FLAG_CONTROL));
                    return;
                case '\t':
                    parser->current.end++;
                    escape_read_warn(parser, flags, 0, "\\t");
                    escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte(peeked, flags | PM_ESCAPE_FLAG_CONTROL));
                    return;
                default: {
                    if (!char_is_ascii_printable(peeked)) {
                        size_t width = parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);
                        pm_parser_err(parser, parser->current.start, parser->current.end + width, PM_ERR_ESCAPE_INVALID_CONTROL);
                        return;
                    }

                    parser->current.end++;
                    escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte(peeked, flags | PM_ESCAPE_FLAG_CONTROL));
                    return;
                }
            }
        }
        case 'M': {
            parser->current.end++;
            if (flags & PM_ESCAPE_FLAG_META) {
                pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_META_REPEAT);
            }

            if (peek(parser) != '-') {
                size_t width = parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);
                pm_parser_err(parser, parser->current.start, parser->current.end + width, PM_ERR_ESCAPE_INVALID_META);
                return;
            }

            parser->current.end++;
            if (parser->current.end == parser->end) {
                pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_META);
                return;
            }

            uint8_t peeked = peek(parser);
            switch (peeked) {
                case '\\':
                    parser->current.end++;

                    if (match(parser, 'u') || match(parser, 'U')) {
                        pm_parser_err(parser, parser->current.start, parser->current.end, PM_ERR_INVALID_ESCAPE_CHARACTER);
                        return;
                    }

                    escape_read(parser, buffer, regular_expression_buffer, flags | PM_ESCAPE_FLAG_META);
                    return;
                case ' ':
                    parser->current.end++;
                    escape_read_warn(parser, flags, PM_ESCAPE_FLAG_META, "\\s");
                    escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte(peeked, flags | PM_ESCAPE_FLAG_META));
                    return;
                case '\t':
                    parser->current.end++;
                    escape_read_warn(parser, flags & ((uint8_t) ~PM_ESCAPE_FLAG_CONTROL), PM_ESCAPE_FLAG_META, "\\t");
                    escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte(peeked, flags | PM_ESCAPE_FLAG_META));
                    return;
                default:
                    if (!char_is_ascii_printable(peeked)) {
                        size_t width = parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);
                        pm_parser_err(parser, parser->current.start, parser->current.end + width, PM_ERR_ESCAPE_INVALID_META);
                        return;
                    }

                    parser->current.end++;
                    escape_write_byte(parser, buffer, regular_expression_buffer, flags, escape_byte(peeked, flags | PM_ESCAPE_FLAG_META));
                    return;
            }
        }
        case '\r': {
            if (peek_offset(parser, 1) == '\n') {
                parser->current.end += 2;
                escape_write_byte_encoded(parser, buffer, escape_byte('\n', flags));
                return;
            }
            PRISM_FALLTHROUGH
        }
        default: {
            if ((flags & (PM_ESCAPE_FLAG_CONTROL | PM_ESCAPE_FLAG_META)) && !char_is_ascii_printable(peeked)) {
                size_t width = parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);
                pm_parser_err(parser, parser->current.start, parser->current.end + width, PM_ERR_ESCAPE_INVALID_META);
                return;
            }
            if (parser->current.end < parser->end) {
                escape_write_escape_encoded(parser, buffer, regular_expression_buffer, flags);
            } else {
                pm_parser_err_current(parser, PM_ERR_INVALID_ESCAPE_CHARACTER);
            }
            return;
        }
    }
}

/**
 * This function is responsible for lexing either a character literal or the ?
 * operator. The supported character literals are described below.
 *
 * \\a            bell, ASCII 07h (BEL)
 * \\b            backspace, ASCII 08h (BS)
 * \t             horizontal tab, ASCII 09h (TAB)
 * \\n            newline (line feed), ASCII 0Ah (LF)
 * \v             vertical tab, ASCII 0Bh (VT)
 * \f             form feed, ASCII 0Ch (FF)
 * \r             carriage return, ASCII 0Dh (CR)
 * \\e            escape, ASCII 1Bh (ESC)
 * \s             space, ASCII 20h (SPC)
 * \\             backslash
 * \nnn           octal bit pattern, where nnn is 1-3 octal digits ([0-7])
 * \xnn           hexadecimal bit pattern, where nn is 1-2 hexadecimal digits ([0-9a-fA-F])
 * \unnnn         Unicode character, where nnnn is exactly 4 hexadecimal digits ([0-9a-fA-F])
 * \u{nnnn ...}   Unicode character(s), where each nnnn is 1-6 hexadecimal digits ([0-9a-fA-F])
 * \cx or \C-x    control character, where x is an ASCII printable character
 * \M-x           meta character, where x is an ASCII printable character
 * \M-\C-x        meta control character, where x is an ASCII printable character
 * \M-\cx         same as above
 * \\c\M-x        same as above
 * \\c? or \C-?   delete, ASCII 7Fh (DEL)
 */
static pm_token_type_t
lex_question_mark(pm_parser_t *parser) {
    if (lex_state_end_p(parser)) {
        lex_state_set(parser, PM_LEX_STATE_BEG);
        return PM_TOKEN_QUESTION_MARK;
    }

    if (parser->current.end >= parser->end) {
        pm_parser_err_current(parser, PM_ERR_INCOMPLETE_QUESTION_MARK);
        pm_string_shared_init(&parser->current_string, parser->current.start + 1, parser->current.end);
        return PM_TOKEN_CHARACTER_LITERAL;
    }

    if (pm_char_is_whitespace(*parser->current.end)) {
        lex_state_set(parser, PM_LEX_STATE_BEG);
        return PM_TOKEN_QUESTION_MARK;
    }

    lex_state_set(parser, PM_LEX_STATE_BEG);

    if (match(parser, '\\')) {
        lex_state_set(parser, PM_LEX_STATE_END);

        pm_buffer_t buffer;
        pm_buffer_init_capacity(&buffer, 3);

        escape_read(parser, &buffer, NULL, PM_ESCAPE_FLAG_SINGLE);
        pm_string_owned_init(&parser->current_string, (uint8_t *) buffer.value, buffer.length);

        return PM_TOKEN_CHARACTER_LITERAL;
    } else {
        size_t encoding_width = parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);

        // Ternary operators can have a ? immediately followed by an identifier
        // which starts with an underscore. We check for this case here.
        if (
            !(parser->encoding->alnum_char(parser->current.end, parser->end - parser->current.end) || peek(parser) == '_') ||
            (
                (parser->current.end + encoding_width >= parser->end) ||
                !char_is_identifier(parser, parser->current.end + encoding_width, parser->end - (parser->current.end + encoding_width))
            )
        ) {
            lex_state_set(parser, PM_LEX_STATE_END);
            parser->current.end += encoding_width;
            pm_string_shared_init(&parser->current_string, parser->current.start + 1, parser->current.end);
            return PM_TOKEN_CHARACTER_LITERAL;
        }
    }

    return PM_TOKEN_QUESTION_MARK;
}

/**
 * Lex a variable that starts with an @ sign (either an instance or class
 * variable).
 */
static pm_token_type_t
lex_at_variable(pm_parser_t *parser) {
    pm_token_type_t type = match(parser, '@') ? PM_TOKEN_CLASS_VARIABLE : PM_TOKEN_INSTANCE_VARIABLE;
    const uint8_t *end = parser->end;

    size_t width;
    if ((width = char_is_identifier_start(parser, parser->current.end, end - parser->current.end)) > 0) {
        parser->current.end += width;

        while ((width = char_is_identifier(parser, parser->current.end, end - parser->current.end)) > 0) {
            parser->current.end += width;
        }
    } else if (parser->current.end < end && pm_char_is_decimal_digit(*parser->current.end)) {
        pm_diagnostic_id_t diag_id = (type == PM_TOKEN_CLASS_VARIABLE) ? PM_ERR_INCOMPLETE_VARIABLE_CLASS : PM_ERR_INCOMPLETE_VARIABLE_INSTANCE;
        if (parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3) {
            diag_id = (type == PM_TOKEN_CLASS_VARIABLE) ? PM_ERR_INCOMPLETE_VARIABLE_CLASS_3_3 : PM_ERR_INCOMPLETE_VARIABLE_INSTANCE_3_3;
        }

        size_t width = parser->encoding->char_width(parser->current.end, end - parser->current.end);
        PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, diag_id, (int) ((parser->current.end + width) - parser->current.start), (const char *) parser->current.start);
    } else {
        pm_diagnostic_id_t diag_id = (type == PM_TOKEN_CLASS_VARIABLE) ? PM_ERR_CLASS_VARIABLE_BARE : PM_ERR_INSTANCE_VARIABLE_BARE;
        pm_parser_err_token(parser, &parser->current, diag_id);
    }

    // If we're lexing an embedded variable, then we need to pop back into the
    // parent lex context.
    if (parser->lex_modes.current->mode == PM_LEX_EMBVAR) {
        lex_mode_pop(parser);
    }

    return type;
}

/**
 * Optionally call out to the lex callback if one is provided.
 */
static inline void
parser_lex_callback(pm_parser_t *parser) {
    if (parser->lex_callback) {
        parser->lex_callback->callback(parser->lex_callback->data, parser, &parser->current);
    }
}

/**
 * Return a new comment node of the specified type.
 */
static inline pm_comment_t *
parser_comment(pm_parser_t *parser, pm_comment_type_t type) {
    pm_comment_t *comment = (pm_comment_t *) xcalloc(1, sizeof(pm_comment_t));
    if (comment == NULL) return NULL;

    *comment = (pm_comment_t) {
        .type = type,
        .location = { parser->current.start, parser->current.end }
    };

    return comment;
}

/**
 * Lex out embedded documentation, and return when we have either hit the end of
 * the file or the end of the embedded documentation. This calls the callback
 * manually because only the lexer should see these tokens, not the parser.
 */
static pm_token_type_t
lex_embdoc(pm_parser_t *parser) {
    // First, lex out the EMBDOC_BEGIN token.
    const uint8_t *newline = next_newline(parser->current.end, parser->end - parser->current.end);

    if (newline == NULL) {
        parser->current.end = parser->end;
    } else {
        pm_newline_list_append(&parser->newline_list, newline);
        parser->current.end = newline + 1;
    }

    parser->current.type = PM_TOKEN_EMBDOC_BEGIN;
    parser_lex_callback(parser);

    // Now, create a comment that is going to be attached to the parser.
    pm_comment_t *comment = parser_comment(parser, PM_COMMENT_EMBDOC);
    if (comment == NULL) return PM_TOKEN_EOF;

    // Now, loop until we find the end of the embedded documentation or the end
    // of the file.
    while (parser->current.end + 4 <= parser->end) {
        parser->current.start = parser->current.end;

        // If we've hit the end of the embedded documentation then we'll return
        // that token here.
        if (
            (memcmp(parser->current.end, "=end", 4) == 0) &&
            (
                (parser->current.end + 4 == parser->end) || // end of file
                pm_char_is_whitespace(parser->current.end[4]) || // whitespace
                (parser->current.end[4] == '\0') || // NUL or end of script
                (parser->current.end[4] == '\004') || // ^D
                (parser->current.end[4] == '\032') // ^Z
            )
        ) {
            const uint8_t *newline = next_newline(parser->current.end, parser->end - parser->current.end);

            if (newline == NULL) {
                parser->current.end = parser->end;
            } else {
                pm_newline_list_append(&parser->newline_list, newline);
                parser->current.end = newline + 1;
            }

            parser->current.type = PM_TOKEN_EMBDOC_END;
            parser_lex_callback(parser);

            comment->location.end = parser->current.end;
            pm_list_append(&parser->comment_list, (pm_list_node_t *) comment);

            return PM_TOKEN_EMBDOC_END;
        }

        // Otherwise, we'll parse until the end of the line and return a line of
        // embedded documentation.
        const uint8_t *newline = next_newline(parser->current.end, parser->end - parser->current.end);

        if (newline == NULL) {
            parser->current.end = parser->end;
        } else {
            pm_newline_list_append(&parser->newline_list, newline);
            parser->current.end = newline + 1;
        }

        parser->current.type = PM_TOKEN_EMBDOC_LINE;
        parser_lex_callback(parser);
    }

    pm_parser_err_current(parser, PM_ERR_EMBDOC_TERM);

    comment->location.end = parser->current.end;
    pm_list_append(&parser->comment_list, (pm_list_node_t *) comment);

    return PM_TOKEN_EOF;
}

/**
 * Set the current type to an ignored newline and then call the lex callback.
 * This happens in a couple places depending on whether or not we have already
 * lexed a comment.
 */
static inline void
parser_lex_ignored_newline(pm_parser_t *parser) {
    parser->current.type = PM_TOKEN_IGNORED_NEWLINE;
    parser_lex_callback(parser);
}

/**
 * This function will be called when a newline is encountered. In some newlines,
 * we need to check if there is a heredoc or heredocs that we have already lexed
 * the body of that we need to now skip past. That will be indicated by the
 * heredoc_end field on the parser.
 *
 * If it is set, then we need to skip past the heredoc body and then clear the
 * heredoc_end field.
 */
static inline void
parser_flush_heredoc_end(pm_parser_t *parser) {
    assert(parser->heredoc_end <= parser->end);
    parser->next_start = parser->heredoc_end;
    parser->heredoc_end = NULL;
}

/**
 * Returns true if the parser has lexed the last token on the current line.
*/
static bool
parser_end_of_line_p(const pm_parser_t *parser) {
    const uint8_t *cursor = parser->current.end;

    while (cursor < parser->end && *cursor != '\n' && *cursor != '#') {
        if (!pm_char_is_inline_whitespace(*cursor++)) return false;
    }

    return true;
}

/**
 * When we're lexing certain types (strings, symbols, lists, etc.) we have
 * string content associated with the tokens. For example:
 *
 *     "foo"
 *
 * In this case, the string content is foo. Since there is no escaping, there's
 * no need to track additional information and the token can be returned as
 * normal. However, if we have escape sequences:
 *
 *     "foo\n"
 *
 * then the bytes in the string are "f", "o", "o", "\", "n", but we want to
 * provide our consumers with the string content "f", "o", "o", "\n". In these
 * cases, when we find the first escape sequence, we initialize a pm_buffer_t
 * to keep track of the string content. Then in the parser, it will
 * automatically attach the string content to the node that it belongs to.
 */
typedef struct {
    /**
     * The buffer that we're using to keep track of the string content. It will
     * only be initialized if we receive an escape sequence.
     */
    pm_buffer_t buffer;

    /**
     * The cursor into the source string that points to how far we have
     * currently copied into the buffer.
     */
    const uint8_t *cursor;
} pm_token_buffer_t;

/**
 * In order to properly set a regular expression's encoding and to validate
 * the byte sequence for the underlying encoding we must process any escape
 * sequences. The unescaped byte sequence will be stored in `buffer` just like
 * for other string-like types. However, we also need to store the regular
 * expression's source string. That string may be different from what we see
 * during lexing because some escape sequences rewrite the source.
 *
 * This value will only be initialized for regular expressions and only if we
 * receive an escape sequence. It will contain the regular expression's source
 * string's byte sequence.
 */
typedef struct {
    /** The embedded base buffer. */
    pm_token_buffer_t base;

    /** The buffer holding the regexp source. */
    pm_buffer_t regexp_buffer;
} pm_regexp_token_buffer_t;

/**
 * Push the given byte into the token buffer.
 */
static inline void
pm_token_buffer_push_byte(pm_token_buffer_t *token_buffer, uint8_t byte) {
    pm_buffer_append_byte(&token_buffer->buffer, byte);
}

static inline void
pm_regexp_token_buffer_push_byte(pm_regexp_token_buffer_t *token_buffer, uint8_t byte) {
    pm_buffer_append_byte(&token_buffer->regexp_buffer, byte);
}

/**
 * Return the width of the character at the end of the current token.
 */
static inline size_t
parser_char_width(const pm_parser_t *parser) {
    size_t width;
    if (parser->encoding_changed) {
        width = parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);
    } else {
        width = pm_encoding_utf_8_char_width(parser->current.end, parser->end - parser->current.end);
    }

    // TODO: If the character is invalid in the given encoding, then we'll just
    // push one byte into the buffer. This should actually be an error.
    return (width == 0 ? 1 : width);
}

/**
 * Push an escaped character into the token buffer.
 */
static void
pm_token_buffer_push_escaped(pm_token_buffer_t *token_buffer, pm_parser_t *parser) {
    size_t width = parser_char_width(parser);
    pm_buffer_append_bytes(&token_buffer->buffer, parser->current.end, width);
    parser->current.end += width;
}

static void
pm_regexp_token_buffer_push_escaped(pm_regexp_token_buffer_t *token_buffer, pm_parser_t *parser) {
    size_t width = parser_char_width(parser);
    pm_buffer_append_bytes(&token_buffer->base.buffer, parser->current.end, width);
    pm_buffer_append_bytes(&token_buffer->regexp_buffer, parser->current.end, width);
    parser->current.end += width;
}

static bool
pm_slice_ascii_only_p(const uint8_t *value, size_t length) {
    for (size_t index = 0; index < length; index++) {
        if (value[index] & 0x80) return false;
    }

    return true;
}

/**
 * When we're about to return from lexing the current token and we know for sure
 * that we have found an escape sequence, this function is called to copy the
 * contents of the token buffer into the current string on the parser so that it
 * can be attached to the correct node.
 */
static inline void
pm_token_buffer_copy(pm_parser_t *parser, pm_token_buffer_t *token_buffer) {
    pm_string_owned_init(&parser->current_string, (uint8_t *) pm_buffer_value(&token_buffer->buffer), pm_buffer_length(&token_buffer->buffer));
}

static inline void
pm_regexp_token_buffer_copy(pm_parser_t *parser, pm_regexp_token_buffer_t *token_buffer) {
    pm_string_owned_init(&parser->current_string, (uint8_t *) pm_buffer_value(&token_buffer->base.buffer), pm_buffer_length(&token_buffer->base.buffer));
    parser->current_regular_expression_ascii_only = pm_slice_ascii_only_p((const uint8_t *) pm_buffer_value(&token_buffer->regexp_buffer), pm_buffer_length(&token_buffer->regexp_buffer));
    pm_buffer_free(&token_buffer->regexp_buffer);
}

/**
 * When we're about to return from lexing the current token, we need to flush
 * all of the content that we have pushed into the buffer into the current
 * string. If we haven't pushed anything into the buffer, this means that we
 * never found an escape sequence, so we can directly reference the bounds of
 * the current string. Either way, at the return of this function it is expected
 * that parser->current_string is established in such a way that it can be
 * attached to a node.
 */
static void
pm_token_buffer_flush(pm_parser_t *parser, pm_token_buffer_t *token_buffer) {
    if (token_buffer->cursor == NULL) {
        pm_string_shared_init(&parser->current_string, parser->current.start, parser->current.end);
    } else {
        pm_buffer_append_bytes(&token_buffer->buffer, token_buffer->cursor, (size_t) (parser->current.end - token_buffer->cursor));
        pm_token_buffer_copy(parser, token_buffer);
    }
}

static void
pm_regexp_token_buffer_flush(pm_parser_t *parser, pm_regexp_token_buffer_t *token_buffer) {
    if (token_buffer->base.cursor == NULL) {
        pm_string_shared_init(&parser->current_string, parser->current.start, parser->current.end);
        parser->current_regular_expression_ascii_only = pm_slice_ascii_only_p(parser->current.start, (size_t) (parser->current.end - parser->current.start));
    } else {
        pm_buffer_append_bytes(&token_buffer->base.buffer, token_buffer->base.cursor, (size_t) (parser->current.end - token_buffer->base.cursor));
        pm_buffer_append_bytes(&token_buffer->regexp_buffer, token_buffer->base.cursor, (size_t) (parser->current.end - token_buffer->base.cursor));
        pm_regexp_token_buffer_copy(parser, token_buffer);
    }
}

#define PM_TOKEN_BUFFER_DEFAULT_SIZE 16

/**
 * When we've found an escape sequence, we need to copy everything up to this
 * point into the buffer because we're about to provide a string that has
 * different content than a direct slice of the source.
 *
 * It is expected that the parser's current token end will be pointing at one
 * byte past the backslash that starts the escape sequence.
 */
static void
pm_token_buffer_escape(pm_parser_t *parser, pm_token_buffer_t *token_buffer) {
    const uint8_t *start;
    if (token_buffer->cursor == NULL) {
        pm_buffer_init_capacity(&token_buffer->buffer, PM_TOKEN_BUFFER_DEFAULT_SIZE);
        start = parser->current.start;
    } else {
        start = token_buffer->cursor;
    }

    const uint8_t *end = parser->current.end - 1;
    assert(end >= start);
    pm_buffer_append_bytes(&token_buffer->buffer, start, (size_t) (end - start));

    token_buffer->cursor = end;
}

static void
pm_regexp_token_buffer_escape(pm_parser_t *parser, pm_regexp_token_buffer_t *token_buffer) {
    const uint8_t *start;
    if (token_buffer->base.cursor == NULL) {
        pm_buffer_init_capacity(&token_buffer->base.buffer, PM_TOKEN_BUFFER_DEFAULT_SIZE);
        pm_buffer_init_capacity(&token_buffer->regexp_buffer, PM_TOKEN_BUFFER_DEFAULT_SIZE);
        start = parser->current.start;
    } else {
        start = token_buffer->base.cursor;
    }

    const uint8_t *end = parser->current.end - 1;
    pm_buffer_append_bytes(&token_buffer->base.buffer, start, (size_t) (end - start));
    pm_buffer_append_bytes(&token_buffer->regexp_buffer, start, (size_t) (end - start));

    token_buffer->base.cursor = end;
}

#undef PM_TOKEN_BUFFER_DEFAULT_SIZE

/**
 * Effectively the same thing as pm_strspn_inline_whitespace, but in the case of
 * a tilde heredoc expands out tab characters to the nearest tab boundaries.
 */
static inline size_t
pm_heredoc_strspn_inline_whitespace(pm_parser_t *parser, const uint8_t **cursor, pm_heredoc_indent_t indent) {
    size_t whitespace = 0;

    switch (indent) {
        case PM_HEREDOC_INDENT_NONE:
            // Do nothing, we can't match a terminator with
            // indentation and there's no need to calculate common
            // whitespace.
            break;
        case PM_HEREDOC_INDENT_DASH:
            // Skip past inline whitespace.
            *cursor += pm_strspn_inline_whitespace(*cursor, parser->end - *cursor);
            break;
        case PM_HEREDOC_INDENT_TILDE:
            // Skip past inline whitespace and calculate common
            // whitespace.
            while (*cursor < parser->end && pm_char_is_inline_whitespace(**cursor)) {
                if (**cursor == '\t') {
                    whitespace = (whitespace / PM_TAB_WHITESPACE_SIZE + 1) * PM_TAB_WHITESPACE_SIZE;
                } else {
                    whitespace++;
                }
                (*cursor)++;
            }

            break;
    }

    return whitespace;
}

/**
 * Lex past the delimiter of a percent literal. Handle newlines and heredocs
 * appropriately.
 */
static uint8_t
pm_lex_percent_delimiter(pm_parser_t *parser) {
    size_t eol_length = match_eol(parser);

    if (eol_length) {
        if (parser->heredoc_end) {
            // If we have already lexed a heredoc, then the newline has already
            // been added to the list. In this case we want to just flush the
            // heredoc end.
            parser_flush_heredoc_end(parser);
        } else {
            // Otherwise, we'll add the newline to the list of newlines.
            pm_newline_list_append(&parser->newline_list, parser->current.end + eol_length - 1);
        }

        uint8_t delimiter = *parser->current.end;

        // If our delimiter is \r\n, we want to treat it as if it's \n.
        // For example, %\r\nfoo\r\n should be "foo"
        if (eol_length == 2) {
            delimiter = *(parser->current.end + 1);
        }

        parser->current.end += eol_length;
        return delimiter;
    }

    return *parser->current.end++;
}

/**
 * This is a convenience macro that will set the current token type, call the
 * lex callback, and then return from the parser_lex function.
 */
#define LEX(token_type) parser->current.type = token_type; parser_lex_callback(parser); return

/**
 * Called when the parser requires a new token. The parser maintains a moving
 * window of two tokens at a time: parser.previous and parser.current. This
 * function will move the current token into the previous token and then
 * lex a new token into the current token.
 */
static void
parser_lex(pm_parser_t *parser) {
    assert(parser->current.end <= parser->end);
    parser->previous = parser->current;

    // This value mirrors cmd_state from CRuby.
    bool previous_command_start = parser->command_start;
    parser->command_start = false;

    // This is used to communicate to the newline lexing function that we've
    // already seen a comment.
    bool lexed_comment = false;

    // Here we cache the current value of the semantic token seen flag. This is
    // used to reset it in case we find a token that shouldn't flip this flag.
    unsigned int semantic_token_seen = parser->semantic_token_seen;
    parser->semantic_token_seen = true;

    switch (parser->lex_modes.current->mode) {
        case PM_LEX_DEFAULT:
        case PM_LEX_EMBEXPR:
        case PM_LEX_EMBVAR:

        // We have a specific named label here because we are going to jump back to
        // this location in the event that we have lexed a token that should not be
        // returned to the parser. This includes comments, ignored newlines, and
        // invalid tokens of some form.
        lex_next_token: {
            // If we have the special next_start pointer set, then we're going to jump
            // to that location and start lexing from there.
            if (parser->next_start != NULL) {
                parser->current.end = parser->next_start;
                parser->next_start = NULL;
            }

            // This value mirrors space_seen from CRuby. It tracks whether or not
            // space has been eaten before the start of the next token.
            bool space_seen = false;

            // First, we're going to skip past any whitespace at the front of the next
            // token.
            bool chomping = true;
            while (parser->current.end < parser->end && chomping) {
                switch (*parser->current.end) {
                    case ' ':
                    case '\t':
                    case '\f':
                    case '\v':
                        parser->current.end++;
                        space_seen = true;
                        break;
                    case '\r':
                        if (match_eol_offset(parser, 1)) {
                            chomping = false;
                        } else {
                            pm_parser_warn(parser, parser->current.end, parser->current.end + 1, PM_WARN_UNEXPECTED_CARRIAGE_RETURN);
                            parser->current.end++;
                            space_seen = true;
                        }
                        break;
                    case '\\': {
                        size_t eol_length = match_eol_offset(parser, 1);
                        if (eol_length) {
                            if (parser->heredoc_end) {
                                parser->current.end = parser->heredoc_end;
                                parser->heredoc_end = NULL;
                            } else {
                                parser->current.end += eol_length + 1;
                                pm_newline_list_append(&parser->newline_list, parser->current.end - 1);
                                space_seen = true;
                            }
                        } else if (pm_char_is_inline_whitespace(*parser->current.end)) {
                            parser->current.end += 2;
                        } else {
                            chomping = false;
                        }

                        break;
                    }
                    default:
                        chomping = false;
                        break;
                }
            }

            // Next, we'll set to start of this token to be the current end.
            parser->current.start = parser->current.end;

            // We'll check if we're at the end of the file. If we are, then we
            // need to return the EOF token.
            if (parser->current.end >= parser->end) {
                // If we hit EOF, but the EOF came immediately after a newline,
                // set the start of the token to the newline.  This way any EOF
                // errors will be reported as happening on that line rather than
                // a line after.  For example "foo(\n" should report an error
                // on line 1 even though EOF technically occurs on line 2.
                if (parser->current.start > parser->start && (*(parser->current.start - 1) == '\n')) {
                    parser->current.start -= 1;
                }
                LEX(PM_TOKEN_EOF);
            }

            // Finally, we'll check the current character to determine the next
            // token.
            switch (*parser->current.end++) {
                case '\0':   // NUL or end of script
                case '\004': // ^D
                case '\032': // ^Z
                    parser->current.end--;
                    LEX(PM_TOKEN_EOF);

                case '#': { // comments
                    const uint8_t *ending = next_newline(parser->current.end, parser->end - parser->current.end);
                    parser->current.end = ending == NULL ? parser->end : ending;

                    // If we found a comment while lexing, then we're going to
                    // add it to the list of comments in the file and keep
                    // lexing.
                    pm_comment_t *comment = parser_comment(parser, PM_COMMENT_INLINE);
                    pm_list_append(&parser->comment_list, (pm_list_node_t *) comment);

                    if (ending) parser->current.end++;
                    parser->current.type = PM_TOKEN_COMMENT;
                    parser_lex_callback(parser);

                    // Here, parse the comment to see if it's a magic comment
                    // and potentially change state on the parser.
                    if (!parser_lex_magic_comment(parser, semantic_token_seen) && (parser->current.start == parser->encoding_comment_start)) {
                        ptrdiff_t length = parser->current.end - parser->current.start;

                        // If we didn't find a magic comment within the first
                        // pass and we're at the start of the file, then we need
                        // to do another pass to potentially find other patterns
                        // for encoding comments.
                        if (length >= 10 && !parser->encoding_locked) {
                            parser_lex_magic_comment_encoding(parser);
                        }
                    }

                    lexed_comment = true;
                }
                PRISM_FALLTHROUGH
                case '\r':
                case '\n': {
                    parser->semantic_token_seen = semantic_token_seen & 0x1;
                    size_t eol_length = match_eol_at(parser, parser->current.end - 1);

                    if (eol_length) {
                        // The only way you can have carriage returns in this
                        // particular loop is if you have a carriage return
                        // followed by a newline. In that case we'll just skip
                        // over the carriage return and continue lexing, in
                        // order to make it so that the newline token
                        // encapsulates both the carriage return and the
                        // newline. Note that we need to check that we haven't
                        // already lexed a comment here because that falls
                        // through into here as well.
                        if (!lexed_comment) {
                            parser->current.end += eol_length - 1; // skip CR
                        }

                        if (parser->heredoc_end == NULL) {
                            pm_newline_list_append(&parser->newline_list, parser->current.end - 1);
                        }
                    }

                    if (parser->heredoc_end) {
                        parser_flush_heredoc_end(parser);
                    }

                    // If this is an ignored newline, then we can continue lexing after
                    // calling the callback with the ignored newline token.
                    switch (lex_state_ignored_p(parser)) {
                        case PM_IGNORED_NEWLINE_NONE:
                            break;
                        case PM_IGNORED_NEWLINE_PATTERN:
                            if (parser->pattern_matching_newlines || parser->in_keyword_arg) {
                                if (!lexed_comment) parser_lex_ignored_newline(parser);
                                lex_state_set(parser, PM_LEX_STATE_BEG);
                                parser->command_start = true;
                                parser->current.type = PM_TOKEN_NEWLINE;
                                return;
                            }
                            PRISM_FALLTHROUGH
                        case PM_IGNORED_NEWLINE_ALL:
                            if (!lexed_comment) parser_lex_ignored_newline(parser);
                            lexed_comment = false;
                            goto lex_next_token;
                    }

                    // Here we need to look ahead and see if there is a call operator
                    // (either . or &.) that starts the next line. If there is, then this
                    // is going to become an ignored newline and we're going to instead
                    // return the call operator.
                    const uint8_t *next_content = parser->next_start == NULL ? parser->current.end : parser->next_start;
                    next_content += pm_strspn_inline_whitespace(next_content, parser->end - next_content);

                    if (next_content < parser->end) {
                        // If we hit a comment after a newline, then we're going to check
                        // if it's ignored or if it's followed by a method call ('.').
                        // If it is, then we're going to call the
                        // callback with an ignored newline and then continue lexing.
                        // Otherwise we'll return a regular newline.
                        if (next_content[0] == '#') {
                            // Here we look for a "." or "&." following a "\n".
                            const uint8_t *following = next_newline(next_content, parser->end - next_content);

                            while (following && (following + 1 < parser->end)) {
                                following++;
                                following += pm_strspn_inline_whitespace(following, parser->end - following);

                                // If this is not followed by a comment, then we can break out
                                // of this loop.
                                if (peek_at(parser, following) != '#') break;

                                // If there is a comment, then we need to find the end of the
                                // comment and continue searching from there.
                                following = next_newline(following, parser->end - following);
                            }

                            // If the lex state was ignored, we will lex the
                            // ignored newline.
                            if (lex_state_ignored_p(parser)) {
                                if (!lexed_comment) parser_lex_ignored_newline(parser);
                                lexed_comment = false;
                                goto lex_next_token;
                            }

                            // If we hit a '.' or a '&.' we will lex the ignored
                            // newline.
                            if (following && (
                                (peek_at(parser, following) == '.') ||
                                (peek_at(parser, following) == '&' && peek_at(parser, following + 1) == '.')
                            )) {
                                if (!lexed_comment) parser_lex_ignored_newline(parser);
                                lexed_comment = false;
                                goto lex_next_token;
                            }


                            // If we are parsing as CRuby 3.5 or later and we
                            // hit a '&&' or a '||' then we will lex the ignored
                            // newline.
                            if (
                                (parser->version >= PM_OPTIONS_VERSION_CRUBY_3_5) &&
                                following && (
                                    (peek_at(parser, following) == '&' && peek_at(parser, following + 1) == '&') ||
                                    (peek_at(parser, following) == '|' && peek_at(parser, following + 1) == '|') ||
                                    (peek_at(parser, following) == 'a' && peek_at(parser, following + 1) == 'n' && peek_at(parser, following + 2) == 'd' && !char_is_identifier(parser, following + 3, parser->end - (following + 3))) ||
                                    (peek_at(parser, following) == 'o' && peek_at(parser, following + 1) == 'r' && !char_is_identifier(parser, following + 2, parser->end - (following + 2)))
                                )
                            ) {
                                if (!lexed_comment) parser_lex_ignored_newline(parser);
                                lexed_comment = false;
                                goto lex_next_token;
                            }
                        }

                        // If we hit a . after a newline, then we're in a call chain and
                        // we need to return the call operator.
                        if (next_content[0] == '.') {
                            // To match ripper, we need to emit an ignored newline even though
                            // it's a real newline in the case that we have a beginless range
                            // on a subsequent line.
                            if (peek_at(parser, next_content + 1) == '.') {
                                if (!lexed_comment) parser_lex_ignored_newline(parser);
                                lex_state_set(parser, PM_LEX_STATE_BEG);
                                parser->command_start = true;
                                parser->current.type = PM_TOKEN_NEWLINE;
                                return;
                            }

                            if (!lexed_comment) parser_lex_ignored_newline(parser);
                            lex_state_set(parser, PM_LEX_STATE_DOT);
                            parser->current.start = next_content;
                            parser->current.end = next_content + 1;
                            parser->next_start = NULL;
                            LEX(PM_TOKEN_DOT);
                        }

                        // If we hit a &. after a newline, then we're in a call chain and
                        // we need to return the call operator.
                        if (peek_at(parser, next_content) == '&' && peek_at(parser, next_content + 1) == '.') {
                            if (!lexed_comment) parser_lex_ignored_newline(parser);
                            lex_state_set(parser, PM_LEX_STATE_DOT);
                            parser->current.start = next_content;
                            parser->current.end = next_content + 2;
                            parser->next_start = NULL;
                            LEX(PM_TOKEN_AMPERSAND_DOT);
                        }

                        if (parser->version >= PM_OPTIONS_VERSION_CRUBY_3_5) {
                            // If we hit an && then we are in a logical chain
                            // and we need to return the logical operator.
                            if (peek_at(parser, next_content) == '&' && peek_at(parser, next_content + 1) == '&') {
                                if (!lexed_comment) parser_lex_ignored_newline(parser);
                                lex_state_set(parser, PM_LEX_STATE_BEG);
                                parser->current.start = next_content;
                                parser->current.end = next_content + 2;
                                parser->next_start = NULL;
                                LEX(PM_TOKEN_AMPERSAND_AMPERSAND);
                            }

                            // If we hit a || then we are in a logical chain and
                            // we need to return the logical operator.
                            if (peek_at(parser, next_content) == '|' && peek_at(parser, next_content + 1) == '|') {
                                if (!lexed_comment) parser_lex_ignored_newline(parser);
                                lex_state_set(parser, PM_LEX_STATE_BEG);
                                parser->current.start = next_content;
                                parser->current.end = next_content + 2;
                                parser->next_start = NULL;
                                LEX(PM_TOKEN_PIPE_PIPE);
                            }

                            // If we hit an 'and' then we are in a logical chain
                            // and we need to return the logical operator.
                            if (
                                peek_at(parser, next_content) == 'a' &&
                                peek_at(parser, next_content + 1) == 'n' &&
                                peek_at(parser, next_content + 2) == 'd' &&
                                !char_is_identifier(parser, next_content + 3, parser->end - (next_content + 3))
                            ) {
                                if (!lexed_comment) parser_lex_ignored_newline(parser);
                                lex_state_set(parser, PM_LEX_STATE_BEG);
                                parser->current.start = next_content;
                                parser->current.end = next_content + 3;
                                parser->next_start = NULL;
                                parser->command_start = true;
                                LEX(PM_TOKEN_KEYWORD_AND);
                            }

                            // If we hit a 'or' then we are in a logical chain
                            // and we need to return the logical operator.
                            if (
                                peek_at(parser, next_content) == 'o' &&
                                peek_at(parser, next_content + 1) == 'r' &&
                                !char_is_identifier(parser, next_content + 2, parser->end - (next_content + 2))
                            ) {
                                if (!lexed_comment) parser_lex_ignored_newline(parser);
                                lex_state_set(parser, PM_LEX_STATE_BEG);
                                parser->current.start = next_content;
                                parser->current.end = next_content + 2;
                                parser->next_start = NULL;
                                parser->command_start = true;
                                LEX(PM_TOKEN_KEYWORD_OR);
                            }
                        }
                    }

                    // At this point we know this is a regular newline, and we can set the
                    // necessary state and return the token.
                    lex_state_set(parser, PM_LEX_STATE_BEG);
                    parser->command_start = true;
                    parser->current.type = PM_TOKEN_NEWLINE;
                    if (!lexed_comment) parser_lex_callback(parser);
                    return;
                }

                // ,
                case ',':
                    if ((parser->previous.type == PM_TOKEN_COMMA) && (parser->enclosure_nesting > 0)) {
                        PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_ARRAY_TERM, pm_token_type_human(parser->current.type));
                    }

                    lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
                    LEX(PM_TOKEN_COMMA);

                // (
                case '(': {
                    pm_token_type_t type = PM_TOKEN_PARENTHESIS_LEFT;

                    if (space_seen && (lex_state_arg_p(parser) || parser->lex_state == (PM_LEX_STATE_END | PM_LEX_STATE_LABEL))) {
                        type = PM_TOKEN_PARENTHESIS_LEFT_PARENTHESES;
                    }

                    parser->enclosure_nesting++;
                    lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
                    pm_do_loop_stack_push(parser, false);
                    LEX(type);
                }

                // )
                case ')':
                    parser->enclosure_nesting--;
                    lex_state_set(parser, PM_LEX_STATE_ENDFN);
                    pm_do_loop_stack_pop(parser);
                    LEX(PM_TOKEN_PARENTHESIS_RIGHT);

                // ;
                case ';':
                    lex_state_set(parser, PM_LEX_STATE_BEG);
                    parser->command_start = true;
                    LEX(PM_TOKEN_SEMICOLON);

                // [ [] []=
                case '[':
                    parser->enclosure_nesting++;
                    pm_token_type_t type = PM_TOKEN_BRACKET_LEFT;

                    if (lex_state_operator_p(parser)) {
                        if (match(parser, ']')) {
                            parser->enclosure_nesting--;
                            lex_state_set(parser, PM_LEX_STATE_ARG);
                            LEX(match(parser, '=') ? PM_TOKEN_BRACKET_LEFT_RIGHT_EQUAL : PM_TOKEN_BRACKET_LEFT_RIGHT);
                        }

                        lex_state_set(parser, PM_LEX_STATE_ARG | PM_LEX_STATE_LABEL);
                        LEX(type);
                    }

                    if (lex_state_beg_p(parser) || (lex_state_arg_p(parser) && (space_seen || lex_state_p(parser, PM_LEX_STATE_LABELED)))) {
                        type = PM_TOKEN_BRACKET_LEFT_ARRAY;
                    }

                    lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
                    pm_do_loop_stack_push(parser, false);
                    LEX(type);

                // ]
                case ']':
                    parser->enclosure_nesting--;
                    lex_state_set(parser, PM_LEX_STATE_END);
                    pm_do_loop_stack_pop(parser);
                    LEX(PM_TOKEN_BRACKET_RIGHT);

                // {
                case '{': {
                    pm_token_type_t type = PM_TOKEN_BRACE_LEFT;

                    if (parser->enclosure_nesting == parser->lambda_enclosure_nesting) {
                        // This { begins a lambda
                        parser->command_start = true;
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                        type = PM_TOKEN_LAMBDA_BEGIN;
                    } else if (lex_state_p(parser, PM_LEX_STATE_LABELED)) {
                        // This { begins a hash literal
                        lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
                    } else if (lex_state_p(parser, PM_LEX_STATE_ARG_ANY | PM_LEX_STATE_END | PM_LEX_STATE_ENDFN)) {
                        // This { begins a block
                        parser->command_start = true;
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                    } else if (lex_state_p(parser, PM_LEX_STATE_ENDARG)) {
                        // This { begins a block on a command
                        parser->command_start = true;
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                    } else {
                        // This { begins a hash literal
                        lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
                    }

                    parser->enclosure_nesting++;
                    parser->brace_nesting++;
                    pm_do_loop_stack_push(parser, false);

                    LEX(type);
                }

                // }
                case '}':
                    parser->enclosure_nesting--;
                    pm_do_loop_stack_pop(parser);

                    if ((parser->lex_modes.current->mode == PM_LEX_EMBEXPR) && (parser->brace_nesting == 0)) {
                        lex_mode_pop(parser);
                        LEX(PM_TOKEN_EMBEXPR_END);
                    }

                    parser->brace_nesting--;
                    lex_state_set(parser, PM_LEX_STATE_END);
                    LEX(PM_TOKEN_BRACE_RIGHT);

                // * ** **= *=
                case '*': {
                    if (match(parser, '*')) {
                        if (match(parser, '=')) {
                            lex_state_set(parser, PM_LEX_STATE_BEG);
                            LEX(PM_TOKEN_STAR_STAR_EQUAL);
                        }

                        pm_token_type_t type = PM_TOKEN_STAR_STAR;

                        if (lex_state_spcarg_p(parser, space_seen)) {
                            pm_parser_warn_token(parser, &parser->current, PM_WARN_AMBIGUOUS_PREFIX_STAR_STAR);
                            type = PM_TOKEN_USTAR_STAR;
                        } else if (lex_state_beg_p(parser)) {
                            type = PM_TOKEN_USTAR_STAR;
                        } else if (ambiguous_operator_p(parser, space_seen)) {
                            PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "**", "argument prefix");
                        }

                        if (lex_state_operator_p(parser)) {
                            lex_state_set(parser, PM_LEX_STATE_ARG);
                        } else {
                            lex_state_set(parser, PM_LEX_STATE_BEG);
                        }

                        LEX(type);
                    }

                    if (match(parser, '=')) {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                        LEX(PM_TOKEN_STAR_EQUAL);
                    }

                    pm_token_type_t type = PM_TOKEN_STAR;

                    if (lex_state_spcarg_p(parser, space_seen)) {
                        pm_parser_warn_token(parser, &parser->current, PM_WARN_AMBIGUOUS_PREFIX_STAR);
                        type = PM_TOKEN_USTAR;
                    } else if (lex_state_beg_p(parser)) {
                        type = PM_TOKEN_USTAR;
                    } else if (ambiguous_operator_p(parser, space_seen)) {
                        PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "*", "argument prefix");
                    }

                    if (lex_state_operator_p(parser)) {
                        lex_state_set(parser, PM_LEX_STATE_ARG);
                    } else {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                    }

                    LEX(type);
                }

                // ! != !~ !@
                case '!':
                    if (lex_state_operator_p(parser)) {
                        lex_state_set(parser, PM_LEX_STATE_ARG);
                        if (match(parser, '@')) {
                            LEX(PM_TOKEN_BANG);
                        }
                    } else {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                    }

                    if (match(parser, '=')) {
                        LEX(PM_TOKEN_BANG_EQUAL);
                    }

                    if (match(parser, '~')) {
                        LEX(PM_TOKEN_BANG_TILDE);
                    }

                    LEX(PM_TOKEN_BANG);

                // = => =~ == === =begin
                case '=':
                    if (
                        current_token_starts_line(parser) &&
                        (parser->current.end + 5 <= parser->end) &&
                        memcmp(parser->current.end, "begin", 5) == 0 &&
                        (pm_char_is_whitespace(peek_offset(parser, 5)) || (peek_offset(parser, 5) == '\0'))
                    ) {
                        pm_token_type_t type = lex_embdoc(parser);
                        if (type == PM_TOKEN_EOF) {
                            LEX(type);
                        }

                        goto lex_next_token;
                    }

                    if (lex_state_operator_p(parser)) {
                        lex_state_set(parser, PM_LEX_STATE_ARG);
                    } else {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                    }

                    if (match(parser, '>')) {
                        LEX(PM_TOKEN_EQUAL_GREATER);
                    }

                    if (match(parser, '~')) {
                        LEX(PM_TOKEN_EQUAL_TILDE);
                    }

                    if (match(parser, '=')) {
                        LEX(match(parser, '=') ? PM_TOKEN_EQUAL_EQUAL_EQUAL : PM_TOKEN_EQUAL_EQUAL);
                    }

                    LEX(PM_TOKEN_EQUAL);

                // < << <<= <= <=>
                case '<':
                    if (match(parser, '<')) {
                        if (
                            !lex_state_p(parser, PM_LEX_STATE_DOT | PM_LEX_STATE_CLASS) &&
                            !lex_state_end_p(parser) &&
                            (!lex_state_p(parser, PM_LEX_STATE_ARG_ANY) || lex_state_p(parser, PM_LEX_STATE_LABELED) || space_seen)
                        ) {
                            const uint8_t *end = parser->current.end;

                            pm_heredoc_quote_t quote = PM_HEREDOC_QUOTE_NONE;
                            pm_heredoc_indent_t indent = PM_HEREDOC_INDENT_NONE;

                            if (match(parser, '-')) {
                                indent = PM_HEREDOC_INDENT_DASH;
                            }
                            else if (match(parser, '~')) {
                                indent = PM_HEREDOC_INDENT_TILDE;
                            }

                            if (match(parser, '`')) {
                                quote = PM_HEREDOC_QUOTE_BACKTICK;
                            }
                            else if (match(parser, '"')) {
                                quote = PM_HEREDOC_QUOTE_DOUBLE;
                            }
                            else if (match(parser, '\'')) {
                                quote = PM_HEREDOC_QUOTE_SINGLE;
                            }

                            const uint8_t *ident_start = parser->current.end;
                            size_t width = 0;

                            if (parser->current.end >= parser->end) {
                                parser->current.end = end;
                            } else if (quote == PM_HEREDOC_QUOTE_NONE && (width = char_is_identifier(parser, parser->current.end, parser->end - parser->current.end)) == 0) {
                                parser->current.end = end;
                            } else {
                                if (quote == PM_HEREDOC_QUOTE_NONE) {
                                    parser->current.end += width;

                                    while ((width = char_is_identifier(parser, parser->current.end, parser->end - parser->current.end))) {
                                        parser->current.end += width;
                                    }
                                } else {
                                    // If we have quotes, then we're going to go until we find the
                                    // end quote.
                                    while ((parser->current.end < parser->end) && quote != (pm_heredoc_quote_t) (*parser->current.end)) {
                                        if (*parser->current.end == '\r' || *parser->current.end == '\n') break;
                                        parser->current.end++;
                                    }
                                }

                                size_t ident_length = (size_t) (parser->current.end - ident_start);
                                bool ident_error = false;

                                if (quote != PM_HEREDOC_QUOTE_NONE && !match(parser, (uint8_t) quote)) {
                                    pm_parser_err(parser, ident_start, ident_start + ident_length, PM_ERR_HEREDOC_IDENTIFIER);
                                    ident_error = true;
                                }

                                parser->explicit_encoding = NULL;
                                lex_mode_push(parser, (pm_lex_mode_t) {
                                    .mode = PM_LEX_HEREDOC,
                                    .as.heredoc = {
                                        .base = {
                                            .ident_start = ident_start,
                                            .ident_length = ident_length,
                                            .quote = quote,
                                            .indent = indent
                                        },
                                        .next_start = parser->current.end,
                                        .common_whitespace = NULL,
                                        .line_continuation = false
                                    }
                                });

                                if (parser->heredoc_end == NULL) {
                                    const uint8_t *body_start = next_newline(parser->current.end, parser->end - parser->current.end);

                                    if (body_start == NULL) {
                                        // If there is no newline after the heredoc identifier, then
                                        // this is not a valid heredoc declaration. In this case we
                                        // will add an error, but we will still return a heredoc
                                        // start.
                                        if (!ident_error) pm_parser_err_heredoc_term(parser, ident_start, ident_length);
                                        body_start = parser->end;
                                    } else {
                                        // Otherwise, we want to indicate that the body of the
                                        // heredoc starts on the character after the next newline.
                                        pm_newline_list_append(&parser->newline_list, body_start);
                                        body_start++;
                                    }

                                    parser->next_start = body_start;
                                } else {
                                    parser->next_start = parser->heredoc_end;
                                }

                                LEX(PM_TOKEN_HEREDOC_START);
                            }
                        }

                        if (match(parser, '=')) {
                            lex_state_set(parser, PM_LEX_STATE_BEG);
                            LEX(PM_TOKEN_LESS_LESS_EQUAL);
                        }

                        if (ambiguous_operator_p(parser, space_seen)) {
                            PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "<<", "here document");
                        }

                        if (lex_state_operator_p(parser)) {
                            lex_state_set(parser, PM_LEX_STATE_ARG);
                        } else {
                            if (lex_state_p(parser, PM_LEX_STATE_CLASS)) parser->command_start = true;
                            lex_state_set(parser, PM_LEX_STATE_BEG);
                        }

                        LEX(PM_TOKEN_LESS_LESS);
                    }

                    if (lex_state_operator_p(parser)) {
                        lex_state_set(parser, PM_LEX_STATE_ARG);
                    } else {
                        if (lex_state_p(parser, PM_LEX_STATE_CLASS)) parser->command_start = true;
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                    }

                    if (match(parser, '=')) {
                        if (match(parser, '>')) {
                            LEX(PM_TOKEN_LESS_EQUAL_GREATER);
                        }

                        LEX(PM_TOKEN_LESS_EQUAL);
                    }

                    LEX(PM_TOKEN_LESS);

                // > >> >>= >=
                case '>':
                    if (match(parser, '>')) {
                        if (lex_state_operator_p(parser)) {
                            lex_state_set(parser, PM_LEX_STATE_ARG);
                        } else {
                            lex_state_set(parser, PM_LEX_STATE_BEG);
                        }
                        LEX(match(parser, '=') ? PM_TOKEN_GREATER_GREATER_EQUAL : PM_TOKEN_GREATER_GREATER);
                    }

                    if (lex_state_operator_p(parser)) {
                        lex_state_set(parser, PM_LEX_STATE_ARG);
                    } else {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                    }

                    LEX(match(parser, '=') ? PM_TOKEN_GREATER_EQUAL : PM_TOKEN_GREATER);

                // double-quoted string literal
                case '"': {
                    bool label_allowed = (lex_state_p(parser, PM_LEX_STATE_LABEL | PM_LEX_STATE_ENDFN) && !previous_command_start) || lex_state_arg_p(parser);
                    lex_mode_push_string(parser, true, label_allowed, '\0', '"');
                    LEX(PM_TOKEN_STRING_BEGIN);
                }

                // xstring literal
                case '`': {
                    if (lex_state_p(parser, PM_LEX_STATE_FNAME)) {
                        lex_state_set(parser, PM_LEX_STATE_ENDFN);
                        LEX(PM_TOKEN_BACKTICK);
                    }

                    if (lex_state_p(parser, PM_LEX_STATE_DOT)) {
                        if (previous_command_start) {
                            lex_state_set(parser, PM_LEX_STATE_CMDARG);
                        } else {
                            lex_state_set(parser, PM_LEX_STATE_ARG);
                        }

                        LEX(PM_TOKEN_BACKTICK);
                    }

                    lex_mode_push_string(parser, true, false, '\0', '`');
                    LEX(PM_TOKEN_BACKTICK);
                }

                // single-quoted string literal
                case '\'': {
                    bool label_allowed = (lex_state_p(parser, PM_LEX_STATE_LABEL | PM_LEX_STATE_ENDFN) && !previous_command_start) || lex_state_arg_p(parser);
                    lex_mode_push_string(parser, false, label_allowed, '\0', '\'');
                    LEX(PM_TOKEN_STRING_BEGIN);
                }

                // ? character literal
                case '?':
                    LEX(lex_question_mark(parser));

                // & && &&= &=
                case '&': {
                    if (match(parser, '&')) {
                        lex_state_set(parser, PM_LEX_STATE_BEG);

                        if (match(parser, '=')) {
                            LEX(PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
                        }

                        LEX(PM_TOKEN_AMPERSAND_AMPERSAND);
                    }

                    if (match(parser, '=')) {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                        LEX(PM_TOKEN_AMPERSAND_EQUAL);
                    }

                    if (match(parser, '.')) {
                        lex_state_set(parser, PM_LEX_STATE_DOT);
                        LEX(PM_TOKEN_AMPERSAND_DOT);
                    }

                    pm_token_type_t type = PM_TOKEN_AMPERSAND;
                    if (lex_state_spcarg_p(parser, space_seen)) {
                        if ((peek(parser) != ':') || (peek_offset(parser, 1) == '\0')) {
                            pm_parser_warn_token(parser, &parser->current, PM_WARN_AMBIGUOUS_PREFIX_AMPERSAND);
                        } else {
                            const uint8_t delim = peek_offset(parser, 1);

                            if ((delim != '\'') && (delim != '"') && !char_is_identifier(parser, parser->current.end + 1, parser->end - (parser->current.end + 1))) {
                                pm_parser_warn_token(parser, &parser->current, PM_WARN_AMBIGUOUS_PREFIX_AMPERSAND);
                            }
                        }

                        type = PM_TOKEN_UAMPERSAND;
                    } else if (lex_state_beg_p(parser)) {
                        type = PM_TOKEN_UAMPERSAND;
                    } else if (ambiguous_operator_p(parser, space_seen)) {
                        PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "&", "argument prefix");
                    }

                    if (lex_state_operator_p(parser)) {
                        lex_state_set(parser, PM_LEX_STATE_ARG);
                    } else {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                    }

                    LEX(type);
                }

                // | || ||= |=
                case '|':
                    if (match(parser, '|')) {
                        if (match(parser, '=')) {
                            lex_state_set(parser, PM_LEX_STATE_BEG);
                            LEX(PM_TOKEN_PIPE_PIPE_EQUAL);
                        }

                        if (lex_state_p(parser, PM_LEX_STATE_BEG)) {
                            parser->current.end--;
                            LEX(PM_TOKEN_PIPE);
                        }

                        lex_state_set(parser, PM_LEX_STATE_BEG);
                        LEX(PM_TOKEN_PIPE_PIPE);
                    }

                    if (match(parser, '=')) {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                        LEX(PM_TOKEN_PIPE_EQUAL);
                    }

                    if (lex_state_operator_p(parser)) {
                        lex_state_set(parser, PM_LEX_STATE_ARG);
                    } else {
                        lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
                    }

                    LEX(PM_TOKEN_PIPE);

                // + += +@
                case '+': {
                    if (lex_state_operator_p(parser)) {
                        lex_state_set(parser, PM_LEX_STATE_ARG);

                        if (match(parser, '@')) {
                            LEX(PM_TOKEN_UPLUS);
                        }

                        LEX(PM_TOKEN_PLUS);
                    }

                    if (match(parser, '=')) {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                        LEX(PM_TOKEN_PLUS_EQUAL);
                    }

                    if (
                        lex_state_beg_p(parser) ||
                        (lex_state_spcarg_p(parser, space_seen) ? (pm_parser_warn_token(parser, &parser->current, PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_PLUS), true) : false)
                    ) {
                        lex_state_set(parser, PM_LEX_STATE_BEG);

                        if (pm_char_is_decimal_digit(peek(parser))) {
                            parser->current.end++;
                            pm_token_type_t type = lex_numeric(parser);
                            lex_state_set(parser, PM_LEX_STATE_END);
                            LEX(type);
                        }

                        LEX(PM_TOKEN_UPLUS);
                    }

                    if (ambiguous_operator_p(parser, space_seen)) {
                        PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "+", "unary operator");
                    }

                    lex_state_set(parser, PM_LEX_STATE_BEG);
                    LEX(PM_TOKEN_PLUS);
                }

                // - -= -@
                case '-': {
                    if (lex_state_operator_p(parser)) {
                        lex_state_set(parser, PM_LEX_STATE_ARG);

                        if (match(parser, '@')) {
                            LEX(PM_TOKEN_UMINUS);
                        }

                        LEX(PM_TOKEN_MINUS);
                    }

                    if (match(parser, '=')) {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                        LEX(PM_TOKEN_MINUS_EQUAL);
                    }

                    if (match(parser, '>')) {
                        lex_state_set(parser, PM_LEX_STATE_ENDFN);
                        LEX(PM_TOKEN_MINUS_GREATER);
                    }

                    bool spcarg = lex_state_spcarg_p(parser, space_seen);
                    bool is_beg = lex_state_beg_p(parser);
                    if (!is_beg && spcarg) {
                        pm_parser_warn_token(parser, &parser->current, PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_MINUS);
                    }

                    if (is_beg || spcarg) {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                        LEX(pm_char_is_decimal_digit(peek(parser)) ? PM_TOKEN_UMINUS_NUM : PM_TOKEN_UMINUS);
                    }

                    if (ambiguous_operator_p(parser, space_seen)) {
                        PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "-", "unary operator");
                    }

                    lex_state_set(parser, PM_LEX_STATE_BEG);
                    LEX(PM_TOKEN_MINUS);
                }

                // . .. ...
                case '.': {
                    bool beg_p = lex_state_beg_p(parser);

                    if (match(parser, '.')) {
                        if (match(parser, '.')) {
                            // If we're _not_ inside a range within default parameters
                            if (!context_p(parser, PM_CONTEXT_DEFAULT_PARAMS) && context_p(parser, PM_CONTEXT_DEF_PARAMS)) {
                                if (lex_state_p(parser, PM_LEX_STATE_END)) {
                                    lex_state_set(parser, PM_LEX_STATE_BEG);
                                } else {
                                    lex_state_set(parser, PM_LEX_STATE_ENDARG);
                                }
                                LEX(PM_TOKEN_UDOT_DOT_DOT);
                            }

                            if (parser->enclosure_nesting == 0 && parser_end_of_line_p(parser)) {
                                pm_parser_warn_token(parser, &parser->current, PM_WARN_DOT_DOT_DOT_EOL);
                            }

                            lex_state_set(parser, PM_LEX_STATE_BEG);
                            LEX(beg_p ? PM_TOKEN_UDOT_DOT_DOT : PM_TOKEN_DOT_DOT_DOT);
                        }

                        lex_state_set(parser, PM_LEX_STATE_BEG);
                        LEX(beg_p ? PM_TOKEN_UDOT_DOT : PM_TOKEN_DOT_DOT);
                    }

                    lex_state_set(parser, PM_LEX_STATE_DOT);
                    LEX(PM_TOKEN_DOT);
                }

                // integer
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9': {
                    pm_token_type_t type = lex_numeric(parser);
                    lex_state_set(parser, PM_LEX_STATE_END);
                    LEX(type);
                }

                // :: symbol
                case ':':
                    if (match(parser, ':')) {
                        if (lex_state_beg_p(parser) || lex_state_p(parser, PM_LEX_STATE_CLASS) || (lex_state_p(parser, PM_LEX_STATE_ARG_ANY) && space_seen)) {
                            lex_state_set(parser, PM_LEX_STATE_BEG);
                            LEX(PM_TOKEN_UCOLON_COLON);
                        }

                        lex_state_set(parser, PM_LEX_STATE_DOT);
                        LEX(PM_TOKEN_COLON_COLON);
                    }

                    if (lex_state_end_p(parser) || pm_char_is_whitespace(peek(parser)) || peek(parser) == '#') {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                        LEX(PM_TOKEN_COLON);
                    }

                    if (peek(parser) == '"' || peek(parser) == '\'') {
                        lex_mode_push_string(parser, peek(parser) == '"', false, '\0', *parser->current.end);
                        parser->current.end++;
                    }

                    lex_state_set(parser, PM_LEX_STATE_FNAME);
                    LEX(PM_TOKEN_SYMBOL_BEGIN);

                // / /=
                case '/':
                    if (lex_state_beg_p(parser)) {
                        lex_mode_push_regexp(parser, '\0', '/');
                        LEX(PM_TOKEN_REGEXP_BEGIN);
                    }

                    if (match(parser, '=')) {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                        LEX(PM_TOKEN_SLASH_EQUAL);
                    }

                    if (lex_state_spcarg_p(parser, space_seen)) {
                        pm_parser_warn_token(parser, &parser->current, PM_WARN_AMBIGUOUS_SLASH);
                        lex_mode_push_regexp(parser, '\0', '/');
                        LEX(PM_TOKEN_REGEXP_BEGIN);
                    }

                    if (ambiguous_operator_p(parser, space_seen)) {
                        PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "/", "regexp literal");
                    }

                    if (lex_state_operator_p(parser)) {
                        lex_state_set(parser, PM_LEX_STATE_ARG);
                    } else {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                    }

                    LEX(PM_TOKEN_SLASH);

                // ^ ^=
                case '^':
                    if (lex_state_operator_p(parser)) {
                        lex_state_set(parser, PM_LEX_STATE_ARG);
                    } else {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                    }
                    LEX(match(parser, '=') ? PM_TOKEN_CARET_EQUAL : PM_TOKEN_CARET);

                // ~ ~@
                case '~':
                    if (lex_state_operator_p(parser)) {
                        (void) match(parser, '@');
                        lex_state_set(parser, PM_LEX_STATE_ARG);
                    } else {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                    }

                    LEX(PM_TOKEN_TILDE);

                // % %= %i %I %q %Q %w %W
                case '%': {
                    // If there is no subsequent character then we have an
                    // invalid token. We're going to say it's the percent
                    // operator because we don't want to move into the string
                    // lex mode unnecessarily.
                    if ((lex_state_beg_p(parser) || lex_state_arg_p(parser)) && (parser->current.end >= parser->end)) {
                        pm_parser_err_current(parser, PM_ERR_INVALID_PERCENT_EOF);
                        LEX(PM_TOKEN_PERCENT);
                    }

                    if (!lex_state_beg_p(parser) && match(parser, '=')) {
                        lex_state_set(parser, PM_LEX_STATE_BEG);
                        LEX(PM_TOKEN_PERCENT_EQUAL);
                    } else if (
                        lex_state_beg_p(parser) ||
                        (lex_state_p(parser, PM_LEX_STATE_FITEM) && (peek(parser) == 's')) ||
                        lex_state_spcarg_p(parser, space_seen)
                    ) {
                        if (!parser->encoding->alnum_char(parser->current.end, parser->end - parser->current.end)) {
                            if (*parser->current.end >= 0x80) {
                                pm_parser_err_current(parser, PM_ERR_INVALID_PERCENT);
                            }

                            const uint8_t delimiter = pm_lex_percent_delimiter(parser);
                            lex_mode_push_string(parser, true, false, lex_mode_incrementor(delimiter), lex_mode_terminator(delimiter));
                            LEX(PM_TOKEN_STRING_BEGIN);
                        }

                        // Delimiters for %-literals cannot be alphanumeric. We
                        // validate that here.
                        uint8_t delimiter = peek_offset(parser, 1);
                        if (delimiter >= 0x80 || parser->encoding->alnum_char(&delimiter, 1)) {
                            pm_parser_err_current(parser, PM_ERR_INVALID_PERCENT);
                            goto lex_next_token;
                        }

                        switch (peek(parser)) {
                            case 'i': {
                                parser->current.end++;

                                if (parser->current.end < parser->end) {
                                    lex_mode_push_list(parser, false, pm_lex_percent_delimiter(parser));
                                } else {
                                    lex_mode_push_list_eof(parser);
                                }

                                LEX(PM_TOKEN_PERCENT_LOWER_I);
                            }
                            case 'I': {
                                parser->current.end++;

                                if (parser->current.end < parser->end) {
                                    lex_mode_push_list(parser, true, pm_lex_percent_delimiter(parser));
                                } else {
                                    lex_mode_push_list_eof(parser);
                                }

                                LEX(PM_TOKEN_PERCENT_UPPER_I);
                            }
                            case 'r': {
                                parser->current.end++;

                                if (parser->current.end < parser->end) {
                                    const uint8_t delimiter = pm_lex_percent_delimiter(parser);
                                    lex_mode_push_regexp(parser, lex_mode_incrementor(delimiter), lex_mode_terminator(delimiter));
                                } else {
                                    lex_mode_push_regexp(parser, '\0', '\0');
                                }

                                LEX(PM_TOKEN_REGEXP_BEGIN);
                            }
                            case 'q': {
                                parser->current.end++;

                                if (parser->current.end < parser->end) {
                                    const uint8_t delimiter = pm_lex_percent_delimiter(parser);
                                    lex_mode_push_string(parser, false, false, lex_mode_incrementor(delimiter), lex_mode_terminator(delimiter));
                                } else {
                                    lex_mode_push_string_eof(parser);
                                }

                                LEX(PM_TOKEN_STRING_BEGIN);
                            }
                            case 'Q': {
                                parser->current.end++;

                                if (parser->current.end < parser->end) {
                                    const uint8_t delimiter = pm_lex_percent_delimiter(parser);
                                    lex_mode_push_string(parser, true, false, lex_mode_incrementor(delimiter), lex_mode_terminator(delimiter));
                                } else {
                                    lex_mode_push_string_eof(parser);
                                }

                                LEX(PM_TOKEN_STRING_BEGIN);
                            }
                            case 's': {
                                parser->current.end++;

                                if (parser->current.end < parser->end) {
                                    const uint8_t delimiter = pm_lex_percent_delimiter(parser);
                                    lex_mode_push_string(parser, false, false, lex_mode_incrementor(delimiter), lex_mode_terminator(delimiter));
                                    lex_state_set(parser, PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM);
                                } else {
                                    lex_mode_push_string_eof(parser);
                                }

                                LEX(PM_TOKEN_SYMBOL_BEGIN);
                            }
                            case 'w': {
                                parser->current.end++;

                                if (parser->current.end < parser->end) {
                                    lex_mode_push_list(parser, false, pm_lex_percent_delimiter(parser));
                                } else {
                                    lex_mode_push_list_eof(parser);
                                }

                                LEX(PM_TOKEN_PERCENT_LOWER_W);
                            }
                            case 'W': {
                                parser->current.end++;

                                if (parser->current.end < parser->end) {
                                    lex_mode_push_list(parser, true, pm_lex_percent_delimiter(parser));
                                } else {
                                    lex_mode_push_list_eof(parser);
                                }

                                LEX(PM_TOKEN_PERCENT_UPPER_W);
                            }
                            case 'x': {
                                parser->current.end++;

                                if (parser->current.end < parser->end) {
                                    const uint8_t delimiter = pm_lex_percent_delimiter(parser);
                                    lex_mode_push_string(parser, true, false, lex_mode_incrementor(delimiter), lex_mode_terminator(delimiter));
                                } else {
                                    lex_mode_push_string_eof(parser);
                                }

                                LEX(PM_TOKEN_PERCENT_LOWER_X);
                            }
                            default:
                                // If we get to this point, then we have a % that is completely
                                // unparsable. In this case we'll just drop it from the parser
                                // and skip past it and hope that the next token is something
                                // that we can parse.
                                pm_parser_err_current(parser, PM_ERR_INVALID_PERCENT);
                                goto lex_next_token;
                        }
                    }

                    if (ambiguous_operator_p(parser, space_seen)) {
                        PM_PARSER_WARN_TOKEN_FORMAT(parser, parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR, "%", "string literal");
                    }

                    lex_state_set(parser, lex_state_operator_p(parser) ? PM_LEX_STATE_ARG : PM_LEX_STATE_BEG);
                    LEX(PM_TOKEN_PERCENT);
                }

                // global variable
                case '$': {
                    pm_token_type_t type = lex_global_variable(parser);

                    // If we're lexing an embedded variable, then we need to pop back into
                    // the parent lex context.
                    if (parser->lex_modes.current->mode == PM_LEX_EMBVAR) {
                        lex_mode_pop(parser);
                    }

                    lex_state_set(parser, PM_LEX_STATE_END);
                    LEX(type);
                }

                // instance variable, class variable
                case '@':
                    lex_state_set(parser, parser->lex_state & PM_LEX_STATE_FNAME ? PM_LEX_STATE_ENDFN : PM_LEX_STATE_END);
                    LEX(lex_at_variable(parser));

                default: {
                    if (*parser->current.start != '_') {
                        size_t width = char_is_identifier_start(parser, parser->current.start, parser->end - parser->current.start);

                        // If this isn't the beginning of an identifier, then
                        // it's an invalid token as we've exhausted all of the
                        // other options. We'll skip past it and return the next
                        // token after adding an appropriate error message.
                        if (!width) {
                            if (*parser->current.start >= 0x80) {
                                PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_INVALID_MULTIBYTE_CHARACTER, *parser->current.start);
                            } else if (*parser->current.start == '\\') {
                                switch (peek_at(parser, parser->current.start + 1)) {
                                    case ' ':
                                        parser->current.end++;
                                        PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE, "escaped space");
                                        break;
                                    case '\f':
                                        parser->current.end++;
                                        PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE, "escaped form feed");
                                        break;
                                    case '\t':
                                        parser->current.end++;
                                        PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE, "escaped horizontal tab");
                                        break;
                                    case '\v':
                                        parser->current.end++;
                                        PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE, "escaped vertical tab");
                                        break;
                                    case '\r':
                                        if (peek_at(parser, parser->current.start + 2) != '\n') {
                                            parser->current.end++;
                                            PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE, "escaped carriage return");
                                            break;
                                        }
                                        PRISM_FALLTHROUGH
                                    default:
                                        PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE, "backslash");
                                        break;
                                }
                            } else if (char_is_ascii_printable(*parser->current.start)) {
                                PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_INVALID_PRINTABLE_CHARACTER, *parser->current.start);
                            } else {
                                PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_INVALID_CHARACTER, *parser->current.start);
                            }

                            goto lex_next_token;
                        }

                        parser->current.end = parser->current.start + width;
                    }

                    pm_token_type_t type = lex_identifier(parser, previous_command_start);

                    // If we've hit a __END__ and it was at the start of the
                    // line or the start of the file and it is followed by
                    // either a \n or a \r\n, then this is the last token of the
                    // file.
                    if (
                        ((parser->current.end - parser->current.start) == 7) &&
                        current_token_starts_line(parser) &&
                        (memcmp(parser->current.start, "__END__", 7) == 0) &&
                        (parser->current.end == parser->end || match_eol(parser))
                    ) {
                        // Since we know we're about to add an __END__ comment,
                        // we know we need to add all of the newlines to get the
                        // correct column information for it.
                        const uint8_t *cursor = parser->current.end;
                        while ((cursor = next_newline(cursor, parser->end - cursor)) != NULL) {
                            pm_newline_list_append(&parser->newline_list, cursor++);
                        }

                        parser->current.end = parser->end;
                        parser->current.type = PM_TOKEN___END__;
                        parser_lex_callback(parser);

                        parser->data_loc.start = parser->current.start;
                        parser->data_loc.end = parser->current.end;

                        LEX(PM_TOKEN_EOF);
                    }

                    pm_lex_state_t last_state = parser->lex_state;

                    if (type == PM_TOKEN_IDENTIFIER || type == PM_TOKEN_CONSTANT || type == PM_TOKEN_METHOD_NAME) {
                        if (lex_state_p(parser, PM_LEX_STATE_BEG_ANY | PM_LEX_STATE_ARG_ANY | PM_LEX_STATE_DOT)) {
                            if (previous_command_start) {
                                lex_state_set(parser, PM_LEX_STATE_CMDARG);
                            } else {
                                lex_state_set(parser, PM_LEX_STATE_ARG);
                            }
                        } else if (parser->lex_state == PM_LEX_STATE_FNAME) {
                            lex_state_set(parser, PM_LEX_STATE_ENDFN);
                        } else {
                            lex_state_set(parser, PM_LEX_STATE_END);
                        }
                    }

                    if (
                        !(last_state & (PM_LEX_STATE_DOT | PM_LEX_STATE_FNAME)) &&
                        (type == PM_TOKEN_IDENTIFIER) &&
                        ((pm_parser_local_depth(parser, &parser->current) != -1) ||
                         pm_token_is_numbered_parameter(parser->current.start, parser->current.end))
                    ) {
                        lex_state_set(parser, PM_LEX_STATE_END | PM_LEX_STATE_LABEL);
                    }

                    LEX(type);
                }
            }
        }
        case PM_LEX_LIST: {
            if (parser->next_start != NULL) {
                parser->current.end = parser->next_start;
                parser->next_start = NULL;
            }

            // First we'll set the beginning of the token.
            parser->current.start = parser->current.end;

            // If there's any whitespace at the start of the list, then we're
            // going to trim it off the beginning and create a new token.
            size_t whitespace;

            if (parser->heredoc_end) {
                whitespace = pm_strspn_inline_whitespace(parser->current.end, parser->end - parser->current.end);
                if (peek_offset(parser, (ptrdiff_t)whitespace) == '\n') {
                    whitespace += 1;
                }
            } else {
                whitespace = pm_strspn_whitespace_newlines(parser->current.end, parser->end - parser->current.end, &parser->newline_list);
            }

            if (whitespace > 0) {
                parser->current.end += whitespace;
                if (peek_offset(parser, -1) == '\n') {
                    // mutates next_start
                    parser_flush_heredoc_end(parser);
                }
                LEX(PM_TOKEN_WORDS_SEP);
            }

            // We'll check if we're at the end of the file. If we are, then we
            // need to return the EOF token.
            if (parser->current.end >= parser->end) {
                LEX(PM_TOKEN_EOF);
            }

            // Here we'll get a list of the places where strpbrk should break,
            // and then find the first one.
            pm_lex_mode_t *lex_mode = parser->lex_modes.current;
            const uint8_t *breakpoints = lex_mode->as.list.breakpoints;
            const uint8_t *breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);

            // If we haven't found an escape yet, then this buffer will be
            // unallocated since we can refer directly to the source string.
            pm_token_buffer_t token_buffer = { 0 };

            while (breakpoint != NULL) {
                // If we hit whitespace, then we must have received content by
                // now, so we can return an element of the list.
                if (pm_char_is_whitespace(*breakpoint)) {
                    parser->current.end = breakpoint;
                    pm_token_buffer_flush(parser, &token_buffer);
                    LEX(PM_TOKEN_STRING_CONTENT);
                }

                // If we hit the terminator, we need to check which token to
                // return.
                if (*breakpoint == lex_mode->as.list.terminator) {
                    // If this terminator doesn't actually close the list, then
                    // we need to continue on past it.
                    if (lex_mode->as.list.nesting > 0) {
                        parser->current.end = breakpoint + 1;
                        breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                        lex_mode->as.list.nesting--;
                        continue;
                    }

                    // If we've hit the terminator and we've already skipped
                    // past content, then we can return a list node.
                    if (breakpoint > parser->current.start) {
                        parser->current.end = breakpoint;
                        pm_token_buffer_flush(parser, &token_buffer);
                        LEX(PM_TOKEN_STRING_CONTENT);
                    }

                    // Otherwise, switch back to the default state and return
                    // the end of the list.
                    parser->current.end = breakpoint + 1;
                    lex_mode_pop(parser);
                    lex_state_set(parser, PM_LEX_STATE_END);
                    LEX(PM_TOKEN_STRING_END);
                }

                // If we hit a null byte, skip directly past it.
                if (*breakpoint == '\0') {
                    breakpoint = pm_strpbrk(parser, breakpoint + 1, breakpoints, parser->end - (breakpoint + 1), true);
                    continue;
                }

                // If we hit escapes, then we need to treat the next token
                // literally. In this case we'll skip past the next character
                // and find the next breakpoint.
                if (*breakpoint == '\\') {
                    parser->current.end = breakpoint + 1;

                    // If we've hit the end of the file, then break out of the
                    // loop by setting the breakpoint to NULL.
                    if (parser->current.end == parser->end) {
                        breakpoint = NULL;
                        continue;
                    }

                    pm_token_buffer_escape(parser, &token_buffer);
                    uint8_t peeked = peek(parser);

                    switch (peeked) {
                        case ' ':
                        case '\f':
                        case '\t':
                        case '\v':
                        case '\\':
                            pm_token_buffer_push_byte(&token_buffer, peeked);
                            parser->current.end++;
                            break;
                        case '\r':
                            parser->current.end++;
                            if (peek(parser) != '\n') {
                                pm_token_buffer_push_byte(&token_buffer, '\r');
                                break;
                            }
                        PRISM_FALLTHROUGH
                        case '\n':
                            pm_token_buffer_push_byte(&token_buffer, '\n');

                            if (parser->heredoc_end) {
                                // ... if we are on the same line as a heredoc,
                                // flush the heredoc and continue parsing after
                                // heredoc_end.
                                parser_flush_heredoc_end(parser);
                                pm_token_buffer_copy(parser, &token_buffer);
                                LEX(PM_TOKEN_STRING_CONTENT);
                            } else {
                                // ... else track the newline.
                                pm_newline_list_append(&parser->newline_list, parser->current.end);
                            }

                            parser->current.end++;
                            break;
                        default:
                            if (peeked == lex_mode->as.list.incrementor || peeked == lex_mode->as.list.terminator) {
                                pm_token_buffer_push_byte(&token_buffer, peeked);
                                parser->current.end++;
                            } else if (lex_mode->as.list.interpolation) {
                                escape_read(parser, &token_buffer.buffer, NULL, PM_ESCAPE_FLAG_NONE);
                            } else {
                                pm_token_buffer_push_byte(&token_buffer, '\\');
                                pm_token_buffer_push_escaped(&token_buffer, parser);
                            }

                            break;
                    }

                    token_buffer.cursor = parser->current.end;
                    breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                    continue;
                }

                // If we hit a #, then we will attempt to lex interpolation.
                if (*breakpoint == '#') {
                    pm_token_type_t type = lex_interpolation(parser, breakpoint);

                    if (type == PM_TOKEN_NOT_PROVIDED) {
                        // If we haven't returned at this point then we had something
                        // that looked like an interpolated class or instance variable
                        // like "#@" but wasn't actually. In this case we'll just skip
                        // to the next breakpoint.
                        breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                        continue;
                    }

                    if (type == PM_TOKEN_STRING_CONTENT) {
                        pm_token_buffer_flush(parser, &token_buffer);
                    }

                    LEX(type);
                }

                // If we've hit the incrementor, then we need to skip past it
                // and find the next breakpoint.
                assert(*breakpoint == lex_mode->as.list.incrementor);
                parser->current.end = breakpoint + 1;
                breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                lex_mode->as.list.nesting++;
                continue;
            }

            if (parser->current.end > parser->current.start) {
                pm_token_buffer_flush(parser, &token_buffer);
                LEX(PM_TOKEN_STRING_CONTENT);
            }

            // If we were unable to find a breakpoint, then this token hits the
            // end of the file.
            parser->current.end = parser->end;
            pm_token_buffer_flush(parser, &token_buffer);
            LEX(PM_TOKEN_STRING_CONTENT);
        }
        case PM_LEX_REGEXP: {
            // First, we'll set to start of this token to be the current end.
            if (parser->next_start == NULL) {
                parser->current.start = parser->current.end;
            } else {
                parser->current.start = parser->next_start;
                parser->current.end = parser->next_start;
                parser->next_start = NULL;
            }

            // We'll check if we're at the end of the file. If we are, then we
            // need to return the EOF token.
            if (parser->current.end >= parser->end) {
                LEX(PM_TOKEN_EOF);
            }

            // Get a reference to the current mode.
            pm_lex_mode_t *lex_mode = parser->lex_modes.current;

            // These are the places where we need to split up the content of the
            // regular expression. We'll use strpbrk to find the first of these
            // characters.
            const uint8_t *breakpoints = lex_mode->as.regexp.breakpoints;
            const uint8_t *breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, false);
            pm_regexp_token_buffer_t token_buffer = { 0 };

            while (breakpoint != NULL) {
                uint8_t term = lex_mode->as.regexp.terminator;
                bool is_terminator = (*breakpoint == term);

                // If the terminator is newline, we need to consider \r\n _also_ a newline
                // For example: `%\nfoo\r\n`
                // The string should be "foo", not "foo\r"
                if (*breakpoint == '\r' && peek_at(parser, breakpoint + 1) == '\n') {
                    if (term == '\n') {
                        is_terminator = true;
                    }

                    // If the terminator is a CR, but we see a CRLF, we need to
                    // treat the CRLF as a newline, meaning this is _not_ the
                    // terminator
                    if (term == '\r') {
                        is_terminator = false;
                    }
                }

                // If we hit the terminator, we need to determine what kind of
                // token to return.
                if (is_terminator) {
                    if (lex_mode->as.regexp.nesting > 0) {
                        parser->current.end = breakpoint + 1;
                        breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, false);
                        lex_mode->as.regexp.nesting--;
                        continue;
                    }

                    // Here we've hit the terminator. If we have already consumed
                    // content then we need to return that content as string content
                    // first.
                    if (breakpoint > parser->current.start) {
                        parser->current.end = breakpoint;
                        pm_regexp_token_buffer_flush(parser, &token_buffer);
                        LEX(PM_TOKEN_STRING_CONTENT);
                    }

                    // Check here if we need to track the newline.
                    size_t eol_length = match_eol_at(parser, breakpoint);
                    if (eol_length) {
                        parser->current.end = breakpoint + eol_length;
                        pm_newline_list_append(&parser->newline_list, parser->current.end - 1);
                    } else {
                        parser->current.end = breakpoint + 1;
                    }

                    // Since we've hit the terminator of the regular expression,
                    // we now need to parse the options.
                    parser->current.end += pm_strspn_regexp_option(parser->current.end, parser->end - parser->current.end);

                    lex_mode_pop(parser);
                    lex_state_set(parser, PM_LEX_STATE_END);
                    LEX(PM_TOKEN_REGEXP_END);
                }

                // If we've hit the incrementor, then we need to skip past it
                // and find the next breakpoint.
                if (*breakpoint && *breakpoint == lex_mode->as.regexp.incrementor) {
                    parser->current.end = breakpoint + 1;
                    breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, false);
                    lex_mode->as.regexp.nesting++;
                    continue;
                }

                switch (*breakpoint) {
                    case '\0':
                        // If we hit a null byte, skip directly past it.
                        parser->current.end = breakpoint + 1;
                        breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, false);
                        break;
                    case '\r':
                        if (peek_at(parser, breakpoint + 1) != '\n') {
                            parser->current.end = breakpoint + 1;
                            breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, false);
                            break;
                        }

                        breakpoint++;
                        parser->current.end = breakpoint;
                        pm_regexp_token_buffer_escape(parser, &token_buffer);
                        token_buffer.base.cursor = breakpoint;

                        PRISM_FALLTHROUGH
                    case '\n':
                        // If we've hit a newline, then we need to track that in
                        // the list of newlines.
                        if (parser->heredoc_end == NULL) {
                            pm_newline_list_append(&parser->newline_list, breakpoint);
                            parser->current.end = breakpoint + 1;
                            breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, false);
                            break;
                        }

                        parser->current.end = breakpoint + 1;
                        parser_flush_heredoc_end(parser);
                        pm_regexp_token_buffer_flush(parser, &token_buffer);
                        LEX(PM_TOKEN_STRING_CONTENT);
                    case '\\': {
                        // If we hit escapes, then we need to treat the next
                        // token literally. In this case we'll skip past the
                        // next character and find the next breakpoint.
                        parser->current.end = breakpoint + 1;

                        // If we've hit the end of the file, then break out of
                        // the loop by setting the breakpoint to NULL.
                        if (parser->current.end == parser->end) {
                            breakpoint = NULL;
                            break;
                        }

                        pm_regexp_token_buffer_escape(parser, &token_buffer);
                        uint8_t peeked = peek(parser);

                        switch (peeked) {
                            case '\r':
                                parser->current.end++;
                                if (peek(parser) != '\n') {
                                    if (lex_mode->as.regexp.terminator != '\r') {
                                        pm_token_buffer_push_byte(&token_buffer.base, '\\');
                                    }
                                    pm_regexp_token_buffer_push_byte(&token_buffer, '\r');
                                    pm_token_buffer_push_byte(&token_buffer.base, '\r');
                                    break;
                                }
                            PRISM_FALLTHROUGH
                            case '\n':
                                if (parser->heredoc_end) {
                                    // ... if we are on the same line as a heredoc,
                                    // flush the heredoc and continue parsing after
                                    // heredoc_end.
                                    parser_flush_heredoc_end(parser);
                                    pm_regexp_token_buffer_copy(parser, &token_buffer);
                                    LEX(PM_TOKEN_STRING_CONTENT);
                                } else {
                                    // ... else track the newline.
                                    pm_newline_list_append(&parser->newline_list, parser->current.end);
                                }

                                parser->current.end++;
                                break;
                            case 'c':
                            case 'C':
                            case 'M':
                            case 'u':
                            case 'x':
                                escape_read(parser, &token_buffer.regexp_buffer, &token_buffer.base.buffer, PM_ESCAPE_FLAG_REGEXP);
                                break;
                            default:
                                if (lex_mode->as.regexp.terminator == peeked) {
                                    // Some characters when they are used as the
                                    // terminator also receive an escape. They are
                                    // enumerated here.
                                    switch (peeked) {
                                        case '$': case ')': case '*': case '+':
                                        case '.': case '>': case '?': case ']':
                                        case '^': case '|': case '}':
                                            pm_token_buffer_push_byte(&token_buffer.base, '\\');
                                            break;
                                        default:
                                            break;
                                    }

                                    pm_regexp_token_buffer_push_byte(&token_buffer, peeked);
                                    pm_token_buffer_push_byte(&token_buffer.base, peeked);
                                    parser->current.end++;
                                    break;
                                }

                                if (peeked < 0x80) pm_token_buffer_push_byte(&token_buffer.base, '\\');
                                pm_regexp_token_buffer_push_escaped(&token_buffer, parser);
                                break;
                        }

                        token_buffer.base.cursor = parser->current.end;
                        breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, false);
                        break;
                    }
                    case '#': {
                        // If we hit a #, then we will attempt to lex
                        // interpolation.
                        pm_token_type_t type = lex_interpolation(parser, breakpoint);

                        if (type == PM_TOKEN_NOT_PROVIDED) {
                            // If we haven't returned at this point then we had
                            // something that looked like an interpolated class or
                            // instance variable like "#@" but wasn't actually. In
                            // this case we'll just skip to the next breakpoint.
                            breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, false);
                            break;
                        }

                        if (type == PM_TOKEN_STRING_CONTENT) {
                            pm_regexp_token_buffer_flush(parser, &token_buffer);
                        }

                        LEX(type);
                    }
                    default:
                        assert(false && "unreachable");
                        break;
                }
            }

            if (parser->current.end > parser->current.start) {
                pm_regexp_token_buffer_flush(parser, &token_buffer);
                LEX(PM_TOKEN_STRING_CONTENT);
            }

            // If we were unable to find a breakpoint, then this token hits the
            // end of the file.
            parser->current.end = parser->end;
            pm_regexp_token_buffer_flush(parser, &token_buffer);
            LEX(PM_TOKEN_STRING_CONTENT);
        }
        case PM_LEX_STRING: {
            // First, we'll set to start of this token to be the current end.
            if (parser->next_start == NULL) {
                parser->current.start = parser->current.end;
            } else {
                parser->current.start = parser->next_start;
                parser->current.end = parser->next_start;
                parser->next_start = NULL;
            }

            // We'll check if we're at the end of the file. If we are, then we need to
            // return the EOF token.
            if (parser->current.end >= parser->end) {
                LEX(PM_TOKEN_EOF);
            }

            // These are the places where we need to split up the content of the
            // string. We'll use strpbrk to find the first of these characters.
            pm_lex_mode_t *lex_mode = parser->lex_modes.current;
            const uint8_t *breakpoints = lex_mode->as.string.breakpoints;
            const uint8_t *breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);

            // If we haven't found an escape yet, then this buffer will be
            // unallocated since we can refer directly to the source string.
            pm_token_buffer_t token_buffer = { 0 };

            while (breakpoint != NULL) {
                // If we hit the incrementor, then we'll increment then nesting and
                // continue lexing.
                if (lex_mode->as.string.incrementor != '\0' && *breakpoint == lex_mode->as.string.incrementor) {
                    lex_mode->as.string.nesting++;
                    parser->current.end = breakpoint + 1;
                    breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                    continue;
                }

                uint8_t term = lex_mode->as.string.terminator;
                bool is_terminator = (*breakpoint == term);

                // If the terminator is newline, we need to consider \r\n _also_ a newline
                // For example: `%r\nfoo\r\n`
                // The string should be /foo/, not /foo\r/
                if (*breakpoint == '\r' && peek_at(parser, breakpoint + 1) == '\n') {
                    if (term == '\n') {
                        is_terminator = true;
                    }

                    // If the terminator is a CR, but we see a CRLF, we need to
                    // treat the CRLF as a newline, meaning this is _not_ the
                    // terminator
                    if (term == '\r') {
                        is_terminator = false;
                    }
                }

                // Note that we have to check the terminator here first because we could
                // potentially be parsing a % string that has a # character as the
                // terminator.
                if (is_terminator) {
                    // If this terminator doesn't actually close the string, then we need
                    // to continue on past it.
                    if (lex_mode->as.string.nesting > 0) {
                        parser->current.end = breakpoint + 1;
                        breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                        lex_mode->as.string.nesting--;
                        continue;
                    }

                    // Here we've hit the terminator. If we have already consumed content
                    // then we need to return that content as string content first.
                    if (breakpoint > parser->current.start) {
                        parser->current.end = breakpoint;
                        pm_token_buffer_flush(parser, &token_buffer);
                        LEX(PM_TOKEN_STRING_CONTENT);
                    }

                    // Otherwise we need to switch back to the parent lex mode and
                    // return the end of the string.
                    size_t eol_length = match_eol_at(parser, breakpoint);
                    if (eol_length) {
                        parser->current.end = breakpoint + eol_length;
                        pm_newline_list_append(&parser->newline_list, parser->current.end - 1);
                    } else {
                        parser->current.end = breakpoint + 1;
                    }

                    if (lex_mode->as.string.label_allowed && (peek(parser) == ':') && (peek_offset(parser, 1) != ':')) {
                        parser->current.end++;
                        lex_state_set(parser, PM_LEX_STATE_ARG | PM_LEX_STATE_LABELED);
                        lex_mode_pop(parser);
                        LEX(PM_TOKEN_LABEL_END);
                    }

                    lex_state_set(parser, PM_LEX_STATE_END);
                    lex_mode_pop(parser);
                    LEX(PM_TOKEN_STRING_END);
                }

                switch (*breakpoint) {
                    case '\0':
                        // Skip directly past the null character.
                        parser->current.end = breakpoint + 1;
                        breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                        break;
                    case '\r':
                        if (peek_at(parser, breakpoint + 1) != '\n') {
                            parser->current.end = breakpoint + 1;
                            breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                            break;
                        }

                        // If we hit a \r\n sequence, then we need to treat it
                        // as a newline.
                        breakpoint++;
                        parser->current.end = breakpoint;
                        pm_token_buffer_escape(parser, &token_buffer);
                        token_buffer.cursor = breakpoint;

                        PRISM_FALLTHROUGH
                    case '\n':
                        // When we hit a newline, we need to flush any potential
                        // heredocs. Note that this has to happen after we check
                        // for the terminator in case the terminator is a
                        // newline character.
                        if (parser->heredoc_end == NULL) {
                            pm_newline_list_append(&parser->newline_list, breakpoint);
                            parser->current.end = breakpoint + 1;
                            breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                            break;
                        }

                        parser->current.end = breakpoint + 1;
                        parser_flush_heredoc_end(parser);
                        pm_token_buffer_flush(parser, &token_buffer);
                        LEX(PM_TOKEN_STRING_CONTENT);
                    case '\\': {
                        // Here we hit escapes.
                        parser->current.end = breakpoint + 1;

                        // If we've hit the end of the file, then break out of
                        // the loop by setting the breakpoint to NULL.
                        if (parser->current.end == parser->end) {
                            breakpoint = NULL;
                            continue;
                        }

                        pm_token_buffer_escape(parser, &token_buffer);
                        uint8_t peeked = peek(parser);

                        switch (peeked) {
                            case '\\':
                                pm_token_buffer_push_byte(&token_buffer, '\\');
                                parser->current.end++;
                                break;
                            case '\r':
                                parser->current.end++;
                                if (peek(parser) != '\n') {
                                    if (!lex_mode->as.string.interpolation) {
                                        pm_token_buffer_push_byte(&token_buffer, '\\');
                                    }
                                    pm_token_buffer_push_byte(&token_buffer, '\r');
                                    break;
                                }
                            PRISM_FALLTHROUGH
                            case '\n':
                                if (!lex_mode->as.string.interpolation) {
                                    pm_token_buffer_push_byte(&token_buffer, '\\');
                                    pm_token_buffer_push_byte(&token_buffer, '\n');
                                }

                                if (parser->heredoc_end) {
                                    // ... if we are on the same line as a heredoc,
                                    // flush the heredoc and continue parsing after
                                    // heredoc_end.
                                    parser_flush_heredoc_end(parser);
                                    pm_token_buffer_copy(parser, &token_buffer);
                                    LEX(PM_TOKEN_STRING_CONTENT);
                                } else {
                                    // ... else track the newline.
                                    pm_newline_list_append(&parser->newline_list, parser->current.end);
                                }

                                parser->current.end++;
                                break;
                            default:
                                if (lex_mode->as.string.incrementor != '\0' && peeked == lex_mode->as.string.incrementor) {
                                    pm_token_buffer_push_byte(&token_buffer, peeked);
                                    parser->current.end++;
                                } else if (lex_mode->as.string.terminator != '\0' && peeked == lex_mode->as.string.terminator) {
                                    pm_token_buffer_push_byte(&token_buffer, peeked);
                                    parser->current.end++;
                                } else if (lex_mode->as.string.interpolation) {
                                    escape_read(parser, &token_buffer.buffer, NULL, PM_ESCAPE_FLAG_NONE);
                                } else {
                                    pm_token_buffer_push_byte(&token_buffer, '\\');
                                    pm_token_buffer_push_escaped(&token_buffer, parser);
                                }

                                break;
                        }

                        token_buffer.cursor = parser->current.end;
                        breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                        break;
                    }
                    case '#': {
                        pm_token_type_t type = lex_interpolation(parser, breakpoint);

                        if (type == PM_TOKEN_NOT_PROVIDED) {
                            // If we haven't returned at this point then we had something that
                            // looked like an interpolated class or instance variable like "#@"
                            // but wasn't actually. In this case we'll just skip to the next
                            // breakpoint.
                            breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                            break;
                        }

                        if (type == PM_TOKEN_STRING_CONTENT) {
                            pm_token_buffer_flush(parser, &token_buffer);
                        }

                        LEX(type);
                    }
                    default:
                        assert(false && "unreachable");
                }
            }

            if (parser->current.end > parser->current.start) {
                pm_token_buffer_flush(parser, &token_buffer);
                LEX(PM_TOKEN_STRING_CONTENT);
            }

            // If we've hit the end of the string, then this is an unterminated
            // string. In that case we'll return a string content token.
            parser->current.end = parser->end;
            pm_token_buffer_flush(parser, &token_buffer);
            LEX(PM_TOKEN_STRING_CONTENT);
        }
        case PM_LEX_HEREDOC: {
            // First, we'll set to start of this token.
            if (parser->next_start == NULL) {
                parser->current.start = parser->current.end;
            } else {
                parser->current.start = parser->next_start;
                parser->current.end = parser->next_start;
                parser->heredoc_end = NULL;
                parser->next_start = NULL;
            }

            // Now let's grab the information about the identifier off of the
            // current lex mode.
            pm_lex_mode_t *lex_mode = parser->lex_modes.current;
            pm_heredoc_lex_mode_t *heredoc_lex_mode = &lex_mode->as.heredoc.base;

            bool line_continuation = lex_mode->as.heredoc.line_continuation;
            lex_mode->as.heredoc.line_continuation = false;

            // We'll check if we're at the end of the file. If we are, then we
            // will add an error (because we weren't able to find the
            // terminator) but still continue parsing so that content after the
            // declaration of the heredoc can be parsed.
            if (parser->current.end >= parser->end) {
                pm_parser_err_heredoc_term(parser, heredoc_lex_mode->ident_start, heredoc_lex_mode->ident_length);
                parser->next_start = lex_mode->as.heredoc.next_start;
                parser->heredoc_end = parser->current.end;
                lex_state_set(parser, PM_LEX_STATE_END);
                lex_mode_pop(parser);
                LEX(PM_TOKEN_HEREDOC_END);
            }

            const uint8_t *ident_start = heredoc_lex_mode->ident_start;
            size_t ident_length = heredoc_lex_mode->ident_length;

            // If we are immediately following a newline and we have hit the
            // terminator, then we need to return the ending of the heredoc.
            if (current_token_starts_line(parser)) {
                const uint8_t *start = parser->current.start;

                if (!line_continuation && (start + ident_length <= parser->end)) {
                    const uint8_t *newline = next_newline(start, parser->end - start);
                    const uint8_t *ident_end = newline;
                    const uint8_t *terminator_end = newline;

                    if (newline == NULL) {
                        terminator_end = parser->end;
                        ident_end = parser->end;
                    } else {
                        terminator_end++;
                        if (newline[-1] == '\r') {
                            ident_end--; // Remove \r
                        }
                    }

                    const uint8_t *terminator_start = ident_end - ident_length;
                    const uint8_t *cursor = start;

                    if (heredoc_lex_mode->indent == PM_HEREDOC_INDENT_DASH || heredoc_lex_mode->indent == PM_HEREDOC_INDENT_TILDE) {
                        while (cursor < terminator_start && pm_char_is_inline_whitespace(*cursor)) {
                            cursor++;
                        }
                    }

                    if (
                        (cursor == terminator_start) &&
                        (memcmp(terminator_start, ident_start, ident_length) == 0)
                    ) {
                        if (newline != NULL) {
                            pm_newline_list_append(&parser->newline_list, newline);
                        }

                        parser->current.end = terminator_end;
                        if (*lex_mode->as.heredoc.next_start == '\\') {
                            parser->next_start = NULL;
                        } else {
                            parser->next_start = lex_mode->as.heredoc.next_start;
                            parser->heredoc_end = parser->current.end;
                        }

                        lex_state_set(parser, PM_LEX_STATE_END);
                        lex_mode_pop(parser);
                        LEX(PM_TOKEN_HEREDOC_END);
                    }
                }

                size_t whitespace = pm_heredoc_strspn_inline_whitespace(parser, &start, heredoc_lex_mode->indent);
                if (
                    heredoc_lex_mode->indent == PM_HEREDOC_INDENT_TILDE &&
                    lex_mode->as.heredoc.common_whitespace != NULL &&
                    (*lex_mode->as.heredoc.common_whitespace > whitespace) &&
                    peek_at(parser, start) != '\n'
                ) {
                    *lex_mode->as.heredoc.common_whitespace = whitespace;
                }
            }

            // Otherwise we'll be parsing string content. These are the places
            // where we need to split up the content of the heredoc. We'll use
            // strpbrk to find the first of these characters.
            uint8_t breakpoints[] = "\r\n\\#";

            pm_heredoc_quote_t quote = heredoc_lex_mode->quote;
            if (quote == PM_HEREDOC_QUOTE_SINGLE) {
                breakpoints[3] = '\0';
            }

            const uint8_t *breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
            pm_token_buffer_t token_buffer = { 0 };
            bool was_line_continuation = false;

            while (breakpoint != NULL) {
                switch (*breakpoint) {
                    case '\0':
                        // Skip directly past the null character.
                        parser->current.end = breakpoint + 1;
                        breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                        break;
                    case '\r':
                        parser->current.end = breakpoint + 1;

                        if (peek_at(parser, breakpoint + 1) != '\n') {
                            breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                            break;
                        }

                        // If we hit a \r\n sequence, then we want to replace it
                        // with a single \n character in the final string.
                        breakpoint++;
                        pm_token_buffer_escape(parser, &token_buffer);
                        token_buffer.cursor = breakpoint;

                        PRISM_FALLTHROUGH
                    case '\n': {
                        if (parser->heredoc_end != NULL && (parser->heredoc_end > breakpoint)) {
                            parser_flush_heredoc_end(parser);
                            parser->current.end = breakpoint + 1;
                            pm_token_buffer_flush(parser, &token_buffer);
                            LEX(PM_TOKEN_STRING_CONTENT);
                        }

                        pm_newline_list_append(&parser->newline_list, breakpoint);

                        // If we have a - or ~ heredoc, then we can match after
                        // some leading whitespace.
                        const uint8_t *start = breakpoint + 1;

                        if (!was_line_continuation && (start + ident_length <= parser->end)) {
                            // We want to match the terminator starting from the end of the line in case
                            // there is whitespace in the ident such as <<-'   DOC' or <<~'   DOC'.
                            const uint8_t *newline = next_newline(start, parser->end - start);

                            if (newline == NULL) {
                                newline = parser->end;
                            } else if (newline[-1] == '\r') {
                                newline--; // Remove \r
                            }

                            // Start of a possible terminator.
                            const uint8_t *terminator_start = newline - ident_length;

                            // Cursor to check for the leading whitespace. We skip the
                            // leading whitespace if we have a - or ~ heredoc.
                            const uint8_t *cursor = start;

                            if (heredoc_lex_mode->indent == PM_HEREDOC_INDENT_DASH || heredoc_lex_mode->indent == PM_HEREDOC_INDENT_TILDE) {
                                while (cursor < terminator_start && pm_char_is_inline_whitespace(*cursor)) {
                                    cursor++;
                                }
                            }

                            if (
                                cursor == terminator_start &&
                                (memcmp(terminator_start, ident_start, ident_length) == 0)
                            ) {
                                parser->current.end = breakpoint + 1;
                                pm_token_buffer_flush(parser, &token_buffer);
                                LEX(PM_TOKEN_STRING_CONTENT);
                            }
                        }

                        size_t whitespace = pm_heredoc_strspn_inline_whitespace(parser, &start, lex_mode->as.heredoc.base.indent);

                        // If we have hit a newline that is followed by a valid
                        // terminator, then we need to return the content of the
                        // heredoc here as string content. Then, the next time a
                        // token is lexed, it will match again and return the
                        // end of the heredoc.
                        if (lex_mode->as.heredoc.base.indent == PM_HEREDOC_INDENT_TILDE) {
                            if ((lex_mode->as.heredoc.common_whitespace != NULL) && (*lex_mode->as.heredoc.common_whitespace > whitespace) && peek_at(parser, start) != '\n') {
                                *lex_mode->as.heredoc.common_whitespace = whitespace;
                            }

                            parser->current.end = breakpoint + 1;
                            pm_token_buffer_flush(parser, &token_buffer);
                            LEX(PM_TOKEN_STRING_CONTENT);
                        }

                        // Otherwise we hit a newline and it wasn't followed by
                        // a terminator, so we can continue parsing.
                        parser->current.end = breakpoint + 1;
                        breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                        break;
                    }
                    case '\\': {
                        // If we hit an escape, then we need to skip past
                        // however many characters the escape takes up. However
                        // it's important that if \n or \r\n are escaped, we
                        // stop looping before the newline and not after the
                        // newline so that we can still potentially find the
                        // terminator of the heredoc.
                        parser->current.end = breakpoint + 1;

                        // If we've hit the end of the file, then break out of
                        // the loop by setting the breakpoint to NULL.
                        if (parser->current.end == parser->end) {
                            breakpoint = NULL;
                            continue;
                        }

                        pm_token_buffer_escape(parser, &token_buffer);
                        uint8_t peeked = peek(parser);

                        if (quote == PM_HEREDOC_QUOTE_SINGLE) {
                            switch (peeked) {
                                case '\r':
                                    parser->current.end++;
                                    if (peek(parser) != '\n') {
                                        pm_token_buffer_push_byte(&token_buffer, '\\');
                                        pm_token_buffer_push_byte(&token_buffer, '\r');
                                        break;
                                    }
                                PRISM_FALLTHROUGH
                                case '\n':
                                    pm_token_buffer_push_byte(&token_buffer, '\\');
                                    pm_token_buffer_push_byte(&token_buffer, '\n');
                                    token_buffer.cursor = parser->current.end + 1;
                                    breakpoint = parser->current.end;
                                    continue;
                                default:
                                    pm_token_buffer_push_byte(&token_buffer, '\\');
                                    pm_token_buffer_push_escaped(&token_buffer, parser);
                                    break;
                            }
                        } else {
                            switch (peeked) {
                                case '\r':
                                    parser->current.end++;
                                    if (peek(parser) != '\n') {
                                        pm_token_buffer_push_byte(&token_buffer, '\r');
                                        break;
                                    }
                                PRISM_FALLTHROUGH
                                case '\n':
                                    // If we are in a tilde here, we should
                                    // break out of the loop and return the
                                    // string content.
                                    if (heredoc_lex_mode->indent == PM_HEREDOC_INDENT_TILDE) {
                                        const uint8_t *end = parser->current.end;
                                        pm_newline_list_append(&parser->newline_list, end);

                                        // Here we want the buffer to only
                                        // include up to the backslash.
                                        parser->current.end = breakpoint;
                                        pm_token_buffer_flush(parser, &token_buffer);

                                        // Now we can advance the end of the
                                        // token past the newline.
                                        parser->current.end = end + 1;
                                        lex_mode->as.heredoc.line_continuation = true;
                                        LEX(PM_TOKEN_STRING_CONTENT);
                                    }

                                    was_line_continuation = true;
                                    token_buffer.cursor = parser->current.end + 1;
                                    breakpoint = parser->current.end;
                                    continue;
                                default:
                                    escape_read(parser, &token_buffer.buffer, NULL, PM_ESCAPE_FLAG_NONE);
                                    break;
                            }
                        }

                        token_buffer.cursor = parser->current.end;
                        breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                        break;
                    }
                    case '#': {
                        pm_token_type_t type = lex_interpolation(parser, breakpoint);

                        if (type == PM_TOKEN_NOT_PROVIDED) {
                            // If we haven't returned at this point then we had
                            // something that looked like an interpolated class
                            // or instance variable like "#@" but wasn't
                            // actually. In this case we'll just skip to the
                            // next breakpoint.
                            breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, true);
                            break;
                        }

                        if (type == PM_TOKEN_STRING_CONTENT) {
                            pm_token_buffer_flush(parser, &token_buffer);
                        }

                        LEX(type);
                    }
                    default:
                        assert(false && "unreachable");
                }

                was_line_continuation = false;
            }

            if (parser->current.end > parser->current.start) {
                parser->current.end = parser->end;
                pm_token_buffer_flush(parser, &token_buffer);
                LEX(PM_TOKEN_STRING_CONTENT);
            }

            // If we've hit the end of the string, then this is an unterminated
            // heredoc. In that case we'll return a string content token.
            parser->current.end = parser->end;
            pm_token_buffer_flush(parser, &token_buffer);
            LEX(PM_TOKEN_STRING_CONTENT);
        }
    }

    assert(false && "unreachable");
}

#undef LEX

/******************************************************************************/
/* Parse functions                                                            */
/******************************************************************************/

/**
 * These are the various precedence rules. Because we are using a Pratt parser,
 * they are named binding power to represent the manner in which nodes are bound
 * together in the stack.
 *
 * We increment by 2 because we want to leave room for the infix operators to
 * specify their associativity by adding or subtracting one.
 */
typedef enum {
    PM_BINDING_POWER_UNSET =             0, // used to indicate this token cannot be used as an infix operator
    PM_BINDING_POWER_STATEMENT =         2,
    PM_BINDING_POWER_MODIFIER_RESCUE =   4, // rescue
    PM_BINDING_POWER_MODIFIER =          6, // if unless until while
    PM_BINDING_POWER_COMPOSITION =       8, // and or
    PM_BINDING_POWER_NOT =              10, // not
    PM_BINDING_POWER_MATCH =            12, // => in
    PM_BINDING_POWER_DEFINED =          14, // defined?
    PM_BINDING_POWER_MULTI_ASSIGNMENT = 16, // =
    PM_BINDING_POWER_ASSIGNMENT =       18, // = += -= *= /= %= &= |= ^= &&= ||= <<= >>= **=
    PM_BINDING_POWER_TERNARY =          20, // ?:
    PM_BINDING_POWER_RANGE =            22, // .. ...
    PM_BINDING_POWER_LOGICAL_OR =       24, // ||
    PM_BINDING_POWER_LOGICAL_AND =      26, // &&
    PM_BINDING_POWER_EQUALITY =         28, // <=> == === != =~ !~
    PM_BINDING_POWER_COMPARISON =       30, // > >= < <=
    PM_BINDING_POWER_BITWISE_OR =       32, // | ^
    PM_BINDING_POWER_BITWISE_AND =      34, // &
    PM_BINDING_POWER_SHIFT =            36, // << >>
    PM_BINDING_POWER_TERM =             38, // + -
    PM_BINDING_POWER_FACTOR =           40, // * / %
    PM_BINDING_POWER_UMINUS =           42, // -@
    PM_BINDING_POWER_EXPONENT =         44, // **
    PM_BINDING_POWER_UNARY =            46, // ! ~ +@
    PM_BINDING_POWER_INDEX =            48, // [] []=
    PM_BINDING_POWER_CALL =             50, // :: .
    PM_BINDING_POWER_MAX =              52
} pm_binding_power_t;

/**
 * This struct represents a set of binding powers used for a given token. They
 * are combined in this way to make it easier to represent associativity.
 */
typedef struct {
    /** The left binding power. */
    pm_binding_power_t left;

    /** The right binding power. */
    pm_binding_power_t right;

    /** Whether or not this token can be used as a binary operator. */
    bool binary;

    /**
     * Whether or not this token can be used as non-associative binary operator.
     * Non-associative operators (e.g. in and =>) need special treatment in parse_expression.
     */
    bool nonassoc;
} pm_binding_powers_t;

#define BINDING_POWER_ASSIGNMENT { PM_BINDING_POWER_UNARY, PM_BINDING_POWER_ASSIGNMENT, true, false }
#define LEFT_ASSOCIATIVE(precedence) { precedence, precedence + 1, true, false }
#define RIGHT_ASSOCIATIVE(precedence) { precedence, precedence, true, false }
#define NON_ASSOCIATIVE(precedence) { precedence, precedence + 1, true, true }
#define RIGHT_ASSOCIATIVE_UNARY(precedence) { precedence, precedence, false, false }

pm_binding_powers_t pm_binding_powers[PM_TOKEN_MAXIMUM] = {
    // rescue
    [PM_TOKEN_KEYWORD_RESCUE_MODIFIER] = { PM_BINDING_POWER_MODIFIER_RESCUE, PM_BINDING_POWER_COMPOSITION, true, false },

    // if unless until while
    [PM_TOKEN_KEYWORD_IF_MODIFIER] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_MODIFIER),
    [PM_TOKEN_KEYWORD_UNLESS_MODIFIER] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_MODIFIER),
    [PM_TOKEN_KEYWORD_UNTIL_MODIFIER] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_MODIFIER),
    [PM_TOKEN_KEYWORD_WHILE_MODIFIER] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_MODIFIER),

    // and or
    [PM_TOKEN_KEYWORD_AND] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_COMPOSITION),
    [PM_TOKEN_KEYWORD_OR] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_COMPOSITION),

    // => in
    [PM_TOKEN_EQUAL_GREATER] = NON_ASSOCIATIVE(PM_BINDING_POWER_MATCH),
    [PM_TOKEN_KEYWORD_IN] = NON_ASSOCIATIVE(PM_BINDING_POWER_MATCH),

    // &&= &= ^= = >>= <<= -= %= |= ||= += /= *= **=
    [PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL] = BINDING_POWER_ASSIGNMENT,
    [PM_TOKEN_AMPERSAND_EQUAL] = BINDING_POWER_ASSIGNMENT,
    [PM_TOKEN_CARET_EQUAL] = BINDING_POWER_ASSIGNMENT,
    [PM_TOKEN_EQUAL] = BINDING_POWER_ASSIGNMENT,
    [PM_TOKEN_GREATER_GREATER_EQUAL] = BINDING_POWER_ASSIGNMENT,
    [PM_TOKEN_LESS_LESS_EQUAL] = BINDING_POWER_ASSIGNMENT,
    [PM_TOKEN_MINUS_EQUAL] = BINDING_POWER_ASSIGNMENT,
    [PM_TOKEN_PERCENT_EQUAL] = BINDING_POWER_ASSIGNMENT,
    [PM_TOKEN_PIPE_EQUAL] = BINDING_POWER_ASSIGNMENT,
    [PM_TOKEN_PIPE_PIPE_EQUAL] = BINDING_POWER_ASSIGNMENT,
    [PM_TOKEN_PLUS_EQUAL] = BINDING_POWER_ASSIGNMENT,
    [PM_TOKEN_SLASH_EQUAL] = BINDING_POWER_ASSIGNMENT,
    [PM_TOKEN_STAR_EQUAL] = BINDING_POWER_ASSIGNMENT,
    [PM_TOKEN_STAR_STAR_EQUAL] = BINDING_POWER_ASSIGNMENT,

    // ?:
    [PM_TOKEN_QUESTION_MARK] = RIGHT_ASSOCIATIVE(PM_BINDING_POWER_TERNARY),

    // .. ...
    [PM_TOKEN_DOT_DOT] = NON_ASSOCIATIVE(PM_BINDING_POWER_RANGE),
    [PM_TOKEN_DOT_DOT_DOT] = NON_ASSOCIATIVE(PM_BINDING_POWER_RANGE),
    [PM_TOKEN_UDOT_DOT] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_LOGICAL_OR),
    [PM_TOKEN_UDOT_DOT_DOT] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_LOGICAL_OR),

    // ||
    [PM_TOKEN_PIPE_PIPE] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_LOGICAL_OR),

    // &&
    [PM_TOKEN_AMPERSAND_AMPERSAND] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_LOGICAL_AND),

    // != !~ == === =~ <=>
    [PM_TOKEN_BANG_EQUAL] = NON_ASSOCIATIVE(PM_BINDING_POWER_EQUALITY),
    [PM_TOKEN_BANG_TILDE] = NON_ASSOCIATIVE(PM_BINDING_POWER_EQUALITY),
    [PM_TOKEN_EQUAL_EQUAL] = NON_ASSOCIATIVE(PM_BINDING_POWER_EQUALITY),
    [PM_TOKEN_EQUAL_EQUAL_EQUAL] = NON_ASSOCIATIVE(PM_BINDING_POWER_EQUALITY),
    [PM_TOKEN_EQUAL_TILDE] = NON_ASSOCIATIVE(PM_BINDING_POWER_EQUALITY),
    [PM_TOKEN_LESS_EQUAL_GREATER] = NON_ASSOCIATIVE(PM_BINDING_POWER_EQUALITY),

    // > >= < <=
    [PM_TOKEN_GREATER] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_COMPARISON),
    [PM_TOKEN_GREATER_EQUAL] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_COMPARISON),
    [PM_TOKEN_LESS] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_COMPARISON),
    [PM_TOKEN_LESS_EQUAL] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_COMPARISON),

    // ^ |
    [PM_TOKEN_CARET] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_BITWISE_OR),
    [PM_TOKEN_PIPE] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_BITWISE_OR),

    // &
    [PM_TOKEN_AMPERSAND] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_BITWISE_AND),

    // >> <<
    [PM_TOKEN_GREATER_GREATER] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_SHIFT),
    [PM_TOKEN_LESS_LESS] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_SHIFT),

    // - +
    [PM_TOKEN_MINUS] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_TERM),
    [PM_TOKEN_PLUS] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_TERM),

    // % / *
    [PM_TOKEN_PERCENT] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_FACTOR),
    [PM_TOKEN_SLASH] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_FACTOR),
    [PM_TOKEN_STAR] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_FACTOR),
    [PM_TOKEN_USTAR] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_FACTOR),

    // -@
    [PM_TOKEN_UMINUS] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_UMINUS),
    [PM_TOKEN_UMINUS_NUM] = { PM_BINDING_POWER_UMINUS, PM_BINDING_POWER_MAX, false, false },

    // **
    [PM_TOKEN_STAR_STAR] = RIGHT_ASSOCIATIVE(PM_BINDING_POWER_EXPONENT),
    [PM_TOKEN_USTAR_STAR] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_UNARY),

    // ! ~ +@
    [PM_TOKEN_BANG] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_UNARY),
    [PM_TOKEN_TILDE] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_UNARY),
    [PM_TOKEN_UPLUS] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_UNARY),

    // [
    [PM_TOKEN_BRACKET_LEFT] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_INDEX),

    // :: . &.
    [PM_TOKEN_COLON_COLON] = RIGHT_ASSOCIATIVE(PM_BINDING_POWER_CALL),
    [PM_TOKEN_DOT] = RIGHT_ASSOCIATIVE(PM_BINDING_POWER_CALL),
    [PM_TOKEN_AMPERSAND_DOT] = RIGHT_ASSOCIATIVE(PM_BINDING_POWER_CALL)
};

#undef BINDING_POWER_ASSIGNMENT
#undef LEFT_ASSOCIATIVE
#undef RIGHT_ASSOCIATIVE
#undef RIGHT_ASSOCIATIVE_UNARY

/**
 * Returns true if the current token is of the given type.
 */
static inline bool
match1(const pm_parser_t *parser, pm_token_type_t type) {
    return parser->current.type == type;
}

/**
 * Returns true if the current token is of either of the given types.
 */
static inline bool
match2(const pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2) {
    return match1(parser, type1) || match1(parser, type2);
}

/**
 * Returns true if the current token is any of the three given types.
 */
static inline bool
match3(const pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2, pm_token_type_t type3) {
    return match1(parser, type1) || match1(parser, type2) || match1(parser, type3);
}

/**
 * Returns true if the current token is any of the four given types.
 */
static inline bool
match4(const pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2, pm_token_type_t type3, pm_token_type_t type4) {
    return match1(parser, type1) || match1(parser, type2) || match1(parser, type3) || match1(parser, type4);
}

/**
 * Returns true if the current token is any of the seven given types.
 */
static inline bool
match7(const pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2, pm_token_type_t type3, pm_token_type_t type4, pm_token_type_t type5, pm_token_type_t type6, pm_token_type_t type7) {
    return match1(parser, type1) || match1(parser, type2) || match1(parser, type3) || match1(parser, type4) || match1(parser, type5) || match1(parser, type6) || match1(parser, type7);
}

/**
 * Returns true if the current token is any of the eight given types.
 */
static inline bool
match8(const pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2, pm_token_type_t type3, pm_token_type_t type4, pm_token_type_t type5, pm_token_type_t type6, pm_token_type_t type7, pm_token_type_t type8) {
    return match1(parser, type1) || match1(parser, type2) || match1(parser, type3) || match1(parser, type4) || match1(parser, type5) || match1(parser, type6) || match1(parser, type7) || match1(parser, type8);
}

/**
 * If the current token is of the specified type, lex forward by one token and
 * return true. Otherwise, return false. For example:
 *
 *     if (accept1(parser, PM_TOKEN_COLON)) { ... }
 */
static bool
accept1(pm_parser_t *parser, pm_token_type_t type) {
    if (match1(parser, type)) {
        parser_lex(parser);
        return true;
    }
    return false;
}

/**
 * If the current token is either of the two given types, lex forward by one
 * token and return true. Otherwise return false.
 */
static inline bool
accept2(pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2) {
    if (match2(parser, type1, type2)) {
        parser_lex(parser);
        return true;
    }
    return false;
}

/**
 * This function indicates that the parser expects a token in a specific
 * position. For example, if you're parsing a BEGIN block, you know that a { is
 * expected immediately after the keyword. In that case you would call this
 * function to indicate that that token should be found.
 *
 * If we didn't find the token that we were expecting, then we're going to add
 * an error to the parser's list of errors (to indicate that the tree is not
 * valid) and create an artificial token instead. This allows us to recover from
 * the fact that the token isn't present and continue parsing.
 */
static void
expect1(pm_parser_t *parser, pm_token_type_t type, pm_diagnostic_id_t diag_id) {
    if (accept1(parser, type)) return;

    const uint8_t *location = parser->previous.end;
    pm_parser_err(parser, location, location, diag_id);

    parser->previous.start = location;
    parser->previous.type = PM_TOKEN_MISSING;
}

/**
 * This function is the same as expect1, but it expects either of two token
 * types.
 */
static void
expect2(pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2, pm_diagnostic_id_t diag_id) {
    if (accept2(parser, type1, type2)) return;

    const uint8_t *location = parser->previous.end;
    pm_parser_err(parser, location, location, diag_id);

    parser->previous.start = location;
    parser->previous.type = PM_TOKEN_MISSING;
}

/**
 * A special expect1 that expects a heredoc terminator and handles popping the
 * lex mode accordingly.
 */
static void
expect1_heredoc_term(pm_parser_t *parser, const uint8_t *ident_start, size_t ident_length) {
    if (match1(parser, PM_TOKEN_HEREDOC_END)) {
        parser_lex(parser);
    } else {
        pm_parser_err_heredoc_term(parser, ident_start, ident_length);
        parser->previous.start = parser->previous.end;
        parser->previous.type = PM_TOKEN_MISSING;
    }
}

static pm_node_t *
parse_expression(pm_parser_t *parser, pm_binding_power_t binding_power, bool accepts_command_call, bool accepts_label, pm_diagnostic_id_t diag_id, uint16_t depth);

/**
 * This is a wrapper of parse_expression, which also checks whether the
 * resulting node is a value expression.
 */
static pm_node_t *
parse_value_expression(pm_parser_t *parser, pm_binding_power_t binding_power, bool accepts_command_call, bool accepts_label, pm_diagnostic_id_t diag_id, uint16_t depth) {
    pm_node_t *node = parse_expression(parser, binding_power, accepts_command_call, accepts_label, diag_id, depth);
    pm_assert_value_expression(parser, node);
    return node;
}

/**
 * This function controls whether or not we will attempt to parse an expression
 * beginning at the subsequent token. It is used when we are in a context where
 * an expression is optional.
 *
 * For example, looking at a range object when we've already lexed the operator,
 * we need to know if we should attempt to parse an expression on the right.
 *
 * For another example, if we've parsed an identifier or a method call and we do
 * not have parentheses, then the next token may be the start of an argument or
 * it may not.
 *
 * CRuby parsers that are generated would resolve this by using a lookahead and
 * potentially backtracking. We attempt to do this by just looking at the next
 * token and making a decision based on that. I am not sure if this is going to
 * work in all cases, it may need to be refactored later. But it appears to work
 * for now.
 */
static inline bool
token_begins_expression_p(pm_token_type_t type) {
    switch (type) {
        case PM_TOKEN_EQUAL_GREATER:
        case PM_TOKEN_KEYWORD_IN:
            // We need to special case this because it is a binary operator that
            // should not be marked as beginning an expression.
            return false;
        case PM_TOKEN_BRACE_RIGHT:
        case PM_TOKEN_BRACKET_RIGHT:
        case PM_TOKEN_COLON:
        case PM_TOKEN_COMMA:
        case PM_TOKEN_EMBEXPR_END:
        case PM_TOKEN_EOF:
        case PM_TOKEN_LAMBDA_BEGIN:
        case PM_TOKEN_KEYWORD_DO:
        case PM_TOKEN_KEYWORD_DO_LOOP:
        case PM_TOKEN_KEYWORD_END:
        case PM_TOKEN_KEYWORD_ELSE:
        case PM_TOKEN_KEYWORD_ELSIF:
        case PM_TOKEN_KEYWORD_ENSURE:
        case PM_TOKEN_KEYWORD_THEN:
        case PM_TOKEN_KEYWORD_RESCUE:
        case PM_TOKEN_KEYWORD_WHEN:
        case PM_TOKEN_NEWLINE:
        case PM_TOKEN_PARENTHESIS_RIGHT:
        case PM_TOKEN_SEMICOLON:
            // The reason we need this short-circuit is because we're using the
            // binding powers table to tell us if the subsequent token could
            // potentially be the start of an expression. If there _is_ a binding
            // power for one of these tokens, then we should remove it from this list
            // and let it be handled by the default case below.
            assert(pm_binding_powers[type].left == PM_BINDING_POWER_UNSET);
            return false;
        case PM_TOKEN_UAMPERSAND:
            // This is a special case because this unary operator cannot appear
            // as a general operator, it only appears in certain circumstances.
            return false;
        case PM_TOKEN_UCOLON_COLON:
        case PM_TOKEN_UMINUS:
        case PM_TOKEN_UMINUS_NUM:
        case PM_TOKEN_UPLUS:
        case PM_TOKEN_BANG:
        case PM_TOKEN_TILDE:
        case PM_TOKEN_UDOT_DOT:
        case PM_TOKEN_UDOT_DOT_DOT:
            // These unary tokens actually do have binding power associated with them
            // so that we can correctly place them into the precedence order. But we
            // want them to be marked as beginning an expression, so we need to
            // special case them here.
            return true;
        default:
            return pm_binding_powers[type].left == PM_BINDING_POWER_UNSET;
    }
}

/**
 * Parse an expression with the given binding power that may be optionally
 * prefixed by the * operator.
 */
static pm_node_t *
parse_starred_expression(pm_parser_t *parser, pm_binding_power_t binding_power, bool accepts_command_call, pm_diagnostic_id_t diag_id, uint16_t depth) {
    if (accept1(parser, PM_TOKEN_USTAR)) {
        pm_token_t operator = parser->previous;
        pm_node_t *expression = parse_value_expression(parser, binding_power, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_STAR, (uint16_t) (depth + 1));
        return (pm_node_t *) pm_splat_node_create(parser, &operator, expression);
    }

    return parse_value_expression(parser, binding_power, accepts_command_call, false, diag_id, depth);
}

/**
 * Convert the name of a method into the corresponding write method name. For
 * example, foo would be turned into foo=.
 */
static void
parse_write_name(pm_parser_t *parser, pm_constant_id_t *name_field) {
    // The method name needs to change. If we previously had
    // foo, we now need foo=. In this case we'll allocate a new
    // owned string, copy the previous method name in, and
    // append an =.
    pm_constant_t *constant = pm_constant_pool_id_to_constant(&parser->constant_pool, *name_field);
    size_t length = constant->length;
    uint8_t *name = xcalloc(length + 1, sizeof(uint8_t));
    if (name == NULL) return;

    memcpy(name, constant->start, length);
    name[length] = '=';

    // Now switch the name to the new string.
    // This silences clang analyzer warning about leak of memory pointed by `name`.
    // NOLINTNEXTLINE(clang-analyzer-*)
    *name_field = pm_constant_pool_insert_owned(&parser->constant_pool, name, length + 1);
}

/**
 * Certain expressions are not targetable, but in order to provide a better
 * experience we give a specific error message. In order to maintain as much
 * information in the tree as possible, we replace them with local variable
 * writes.
 */
static pm_node_t *
parse_unwriteable_target(pm_parser_t *parser, pm_node_t *target) {
    switch (PM_NODE_TYPE(target)) {
        case PM_SOURCE_ENCODING_NODE: pm_parser_err_node(parser, target, PM_ERR_EXPRESSION_NOT_WRITABLE_ENCODING); break;
        case PM_FALSE_NODE: pm_parser_err_node(parser, target, PM_ERR_EXPRESSION_NOT_WRITABLE_FALSE); break;
        case PM_SOURCE_FILE_NODE: pm_parser_err_node(parser, target, PM_ERR_EXPRESSION_NOT_WRITABLE_FILE); break;
        case PM_SOURCE_LINE_NODE: pm_parser_err_node(parser, target, PM_ERR_EXPRESSION_NOT_WRITABLE_LINE); break;
        case PM_NIL_NODE: pm_parser_err_node(parser, target, PM_ERR_EXPRESSION_NOT_WRITABLE_NIL); break;
        case PM_SELF_NODE: pm_parser_err_node(parser, target, PM_ERR_EXPRESSION_NOT_WRITABLE_SELF); break;
        case PM_TRUE_NODE: pm_parser_err_node(parser, target, PM_ERR_EXPRESSION_NOT_WRITABLE_TRUE); break;
        default: break;
    }

    pm_constant_id_t name = pm_parser_constant_id_location(parser, target->location.start, target->location.end);
    pm_local_variable_target_node_t *result = pm_local_variable_target_node_create(parser, &target->location, name, 0);

    pm_node_destroy(parser, target);
    return (pm_node_t *) result;
}

/**
 * When an implicit local variable is written to or targeted, it becomes a
 * regular, named local variable. This function removes it from the list of
 * implicit parameters when that happens.
 */
static void
parse_target_implicit_parameter(pm_parser_t *parser, pm_node_t *node) {
    pm_node_list_t *implicit_parameters = &parser->current_scope->implicit_parameters;

    for (size_t index = 0; index < implicit_parameters->size; index++) {
        if (implicit_parameters->nodes[index] == node) {
            // If the node is not the last one in the list, we need to shift the
            // remaining nodes down to fill the gap. This is extremely unlikely
            // to happen.
            if (index != implicit_parameters->size - 1) {
                memcpy(&implicit_parameters->nodes[index], &implicit_parameters->nodes[index + 1], (implicit_parameters->size - index - 1) * sizeof(pm_node_t *));
            }

            implicit_parameters->size--;
            break;
        }
    }
}

/**
 * Convert the given node into a valid target node.
 *
 * @param multiple Whether or not this target is part of a larger set of
 *   targets. If it is, then the &. operator is not allowed.
 * @param splat Whether or not this target is a child of a splat target. If it
 *   is, then fewer patterns are allowed.
 */
static pm_node_t *
parse_target(pm_parser_t *parser, pm_node_t *target, bool multiple, bool splat_parent) {
    switch (PM_NODE_TYPE(target)) {
        case PM_MISSING_NODE:
            return target;
        case PM_SOURCE_ENCODING_NODE:
        case PM_FALSE_NODE:
        case PM_SOURCE_FILE_NODE:
        case PM_SOURCE_LINE_NODE:
        case PM_NIL_NODE:
        case PM_SELF_NODE:
        case PM_TRUE_NODE: {
            // In these special cases, we have specific error messages and we
            // will replace them with local variable writes.
            return parse_unwriteable_target(parser, target);
        }
        case PM_CLASS_VARIABLE_READ_NODE:
            assert(sizeof(pm_class_variable_target_node_t) == sizeof(pm_class_variable_read_node_t));
            target->type = PM_CLASS_VARIABLE_TARGET_NODE;
            return target;
        case PM_CONSTANT_PATH_NODE:
            if (context_def_p(parser)) {
                pm_parser_err_node(parser, target, PM_ERR_WRITE_TARGET_IN_METHOD);
            }

            assert(sizeof(pm_constant_path_target_node_t) == sizeof(pm_constant_path_node_t));
            target->type = PM_CONSTANT_PATH_TARGET_NODE;

            return target;
        case PM_CONSTANT_READ_NODE:
            if (context_def_p(parser)) {
                pm_parser_err_node(parser, target, PM_ERR_WRITE_TARGET_IN_METHOD);
            }

            assert(sizeof(pm_constant_target_node_t) == sizeof(pm_constant_read_node_t));
            target->type = PM_CONSTANT_TARGET_NODE;

            return target;
        case PM_BACK_REFERENCE_READ_NODE:
        case PM_NUMBERED_REFERENCE_READ_NODE:
            PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, target, PM_ERR_WRITE_TARGET_READONLY);
            return target;
        case PM_GLOBAL_VARIABLE_READ_NODE:
            assert(sizeof(pm_global_variable_target_node_t) == sizeof(pm_global_variable_read_node_t));
            target->type = PM_GLOBAL_VARIABLE_TARGET_NODE;
            return target;
        case PM_LOCAL_VARIABLE_READ_NODE: {
            if (pm_token_is_numbered_parameter(target->location.start, target->location.end)) {
                PM_PARSER_ERR_FORMAT(parser, target->location.start, target->location.end, PM_ERR_PARAMETER_NUMBERED_RESERVED, target->location.start);
                parse_target_implicit_parameter(parser, target);
            }

            const pm_local_variable_read_node_t *cast = (const pm_local_variable_read_node_t *) target;
            uint32_t name = cast->name;
            uint32_t depth = cast->depth;
            pm_locals_unread(&pm_parser_scope_find(parser, depth)->locals, name);

            assert(sizeof(pm_local_variable_target_node_t) == sizeof(pm_local_variable_read_node_t));
            target->type = PM_LOCAL_VARIABLE_TARGET_NODE;

            return target;
        }
        case PM_IT_LOCAL_VARIABLE_READ_NODE: {
            pm_constant_id_t name = pm_parser_local_add_constant(parser, "it", 2);
            pm_node_t *node = (pm_node_t *) pm_local_variable_target_node_create(parser, &target->location, name, 0);

            parse_target_implicit_parameter(parser, target);
            pm_node_destroy(parser, target);

            return node;
        }
        case PM_INSTANCE_VARIABLE_READ_NODE:
            assert(sizeof(pm_instance_variable_target_node_t) == sizeof(pm_instance_variable_read_node_t));
            target->type = PM_INSTANCE_VARIABLE_TARGET_NODE;
            return target;
        case PM_MULTI_TARGET_NODE:
            if (splat_parent) {
                // Multi target is not accepted in all positions. If this is one
                // of them, then we need to add an error.
                pm_parser_err_node(parser, target, PM_ERR_WRITE_TARGET_UNEXPECTED);
            }

            return target;
        case PM_SPLAT_NODE: {
            pm_splat_node_t *splat = (pm_splat_node_t *) target;

            if (splat->expression != NULL) {
                splat->expression = parse_target(parser, splat->expression, multiple, true);
            }

            return (pm_node_t *) splat;
        }
        case PM_CALL_NODE: {
            pm_call_node_t *call = (pm_call_node_t *) target;

            // If we have no arguments to the call node and we need this to be a
            // target then this is either a method call or a local variable
            // write.
            if (
                (call->message_loc.start != NULL) &&
                (call->message_loc.end[-1] != '!') &&
                (call->message_loc.end[-1] != '?') &&
                (call->opening_loc.start == NULL) &&
                (call->arguments == NULL) &&
                (call->block == NULL)
            ) {
                if (call->receiver == NULL) {
                    // When we get here, we have a local variable write, because it
                    // was previously marked as a method call but now we have an =.
                    // This looks like:
                    //
                    //     foo = 1
                    //
                    // When it was parsed in the prefix position, foo was seen as a
                    // method call with no receiver and no arguments. Now we have an
                    // =, so we know it's a local variable write.
                    const pm_location_t message_loc = call->message_loc;

                    pm_constant_id_t name = pm_parser_local_add_location(parser, message_loc.start, message_loc.end, 0);
                    pm_node_destroy(parser, target);

                    return (pm_node_t *) pm_local_variable_target_node_create(parser, &message_loc, name, 0);
                }

                if (*call->message_loc.start == '_' || parser->encoding->alnum_char(call->message_loc.start, call->message_loc.end - call->message_loc.start)) {
                    if (multiple && PM_NODE_FLAG_P(call, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
                        pm_parser_err_node(parser, (const pm_node_t *) call, PM_ERR_UNEXPECTED_SAFE_NAVIGATION);
                    }

                    parse_write_name(parser, &call->name);
                    return (pm_node_t *) pm_call_target_node_create(parser, call);
                }
            }

            // If there is no call operator and the message is "[]" then this is
            // an aref expression, and we can transform it into an aset
            // expression.
            if (PM_NODE_FLAG_P(call, PM_CALL_NODE_FLAGS_INDEX)) {
                return (pm_node_t *) pm_index_target_node_create(parser, call);
            }
        }
        PRISM_FALLTHROUGH
        default:
            // In this case we have a node that we don't know how to convert
            // into a target. We need to treat it as an error. For now, we'll
            // mark it as an error and just skip right past it.
            pm_parser_err_node(parser, target, PM_ERR_WRITE_TARGET_UNEXPECTED);
            return target;
    }
}

/**
 * Parse a write target and validate that it is in a valid position for
 * assignment.
 */
static pm_node_t *
parse_target_validate(pm_parser_t *parser, pm_node_t *target, bool multiple) {
    pm_node_t *result = parse_target(parser, target, multiple, false);

    // Ensure that we have one of an =, an 'in' in for indexes, and a ')' in
    // parens after the targets.
    if (
        !match1(parser, PM_TOKEN_EQUAL) &&
        !(context_p(parser, PM_CONTEXT_FOR_INDEX) && match1(parser, PM_TOKEN_KEYWORD_IN)) &&
        !(context_p(parser, PM_CONTEXT_PARENS) && match1(parser, PM_TOKEN_PARENTHESIS_RIGHT))
    ) {
        pm_parser_err_node(parser, result, PM_ERR_WRITE_TARGET_UNEXPECTED);
    }

    return result;
}

/**
 * Potentially wrap a constant write node in a shareable constant node depending
 * on the current state.
 */
static pm_node_t *
parse_shareable_constant_write(pm_parser_t *parser, pm_node_t *write) {
    pm_shareable_constant_value_t shareable_constant = pm_parser_scope_shareable_constant_get(parser);

    if (shareable_constant != PM_SCOPE_SHAREABLE_CONSTANT_NONE) {
        return (pm_node_t *) pm_shareable_constant_node_create(parser, write, shareable_constant);
    }

    return write;
}

/**
 * Convert the given node into a valid write node.
 */
static pm_node_t *
parse_write(pm_parser_t *parser, pm_node_t *target, pm_token_t *operator, pm_node_t *value) {
    switch (PM_NODE_TYPE(target)) {
        case PM_MISSING_NODE:
            pm_node_destroy(parser, value);
            return target;
        case PM_CLASS_VARIABLE_READ_NODE: {
            pm_class_variable_write_node_t *node = pm_class_variable_write_node_create(parser, (pm_class_variable_read_node_t *) target, operator, value);
            pm_node_destroy(parser, target);
            return (pm_node_t *) node;
        }
        case PM_CONSTANT_PATH_NODE: {
            pm_node_t *node = (pm_node_t *) pm_constant_path_write_node_create(parser, (pm_constant_path_node_t *) target, operator, value);

            if (context_def_p(parser)) {
                pm_parser_err_node(parser, node, PM_ERR_WRITE_TARGET_IN_METHOD);
            }

            return parse_shareable_constant_write(parser, node);
        }
        case PM_CONSTANT_READ_NODE: {
            pm_node_t *node = (pm_node_t *) pm_constant_write_node_create(parser, (pm_constant_read_node_t *) target, operator, value);

            if (context_def_p(parser)) {
                pm_parser_err_node(parser, node, PM_ERR_WRITE_TARGET_IN_METHOD);
            }

            pm_node_destroy(parser, target);
            return parse_shareable_constant_write(parser, node);
        }
        case PM_BACK_REFERENCE_READ_NODE:
        case PM_NUMBERED_REFERENCE_READ_NODE:
            PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, target, PM_ERR_WRITE_TARGET_READONLY);
            PRISM_FALLTHROUGH
        case PM_GLOBAL_VARIABLE_READ_NODE: {
            pm_global_variable_write_node_t *node = pm_global_variable_write_node_create(parser, target, operator, value);
            pm_node_destroy(parser, target);
            return (pm_node_t *) node;
        }
        case PM_LOCAL_VARIABLE_READ_NODE: {
            pm_local_variable_read_node_t *local_read = (pm_local_variable_read_node_t *) target;

            pm_constant_id_t name = local_read->name;
            pm_location_t name_loc = target->location;

            uint32_t depth = local_read->depth;
            pm_scope_t *scope = pm_parser_scope_find(parser, depth);

            if (pm_token_is_numbered_parameter(target->location.start, target->location.end)) {
                pm_diagnostic_id_t diag_id = (scope->parameters & PM_SCOPE_PARAMETERS_NUMBERED_FOUND) ? PM_ERR_EXPRESSION_NOT_WRITABLE_NUMBERED : PM_ERR_PARAMETER_NUMBERED_RESERVED;
                PM_PARSER_ERR_FORMAT(parser, target->location.start, target->location.end, diag_id, target->location.start);
                parse_target_implicit_parameter(parser, target);
            }

            pm_locals_unread(&scope->locals, name);
            pm_node_destroy(parser, target);

            return (pm_node_t *) pm_local_variable_write_node_create(parser, name, depth, value, &name_loc, operator);
        }
        case PM_IT_LOCAL_VARIABLE_READ_NODE: {
            pm_constant_id_t name = pm_parser_local_add_constant(parser, "it", 2);
            pm_node_t *node = (pm_node_t *) pm_local_variable_write_node_create(parser, name, 0, value, &target->location, operator);

            parse_target_implicit_parameter(parser, target);
            pm_node_destroy(parser, target);

            return node;
        }
        case PM_INSTANCE_VARIABLE_READ_NODE: {
            pm_node_t *write_node = (pm_node_t *) pm_instance_variable_write_node_create(parser, (pm_instance_variable_read_node_t *) target, operator, value);
            pm_node_destroy(parser, target);
            return write_node;
        }
        case PM_MULTI_TARGET_NODE:
            return (pm_node_t *) pm_multi_write_node_create(parser, (pm_multi_target_node_t *) target, operator, value);
        case PM_SPLAT_NODE: {
            pm_splat_node_t *splat = (pm_splat_node_t *) target;

            if (splat->expression != NULL) {
                splat->expression = parse_write(parser, splat->expression, operator, value);
            }

            pm_multi_target_node_t *multi_target = pm_multi_target_node_create(parser);
            pm_multi_target_node_targets_append(parser, multi_target, (pm_node_t *) splat);

            return (pm_node_t *) pm_multi_write_node_create(parser, multi_target, operator, value);
        }
        case PM_CALL_NODE: {
            pm_call_node_t *call = (pm_call_node_t *) target;

            // If we have no arguments to the call node and we need this to be a
            // target then this is either a method call or a local variable
            // write.
            if (
                (call->message_loc.start != NULL) &&
                (call->message_loc.end[-1] != '!') &&
                (call->message_loc.end[-1] != '?') &&
                (call->opening_loc.start == NULL) &&
                (call->arguments == NULL) &&
                (call->block == NULL)
            ) {
                if (call->receiver == NULL) {
                    // When we get here, we have a local variable write, because it
                    // was previously marked as a method call but now we have an =.
                    // This looks like:
                    //
                    //     foo = 1
                    //
                    // When it was parsed in the prefix position, foo was seen as a
                    // method call with no receiver and no arguments. Now we have an
                    // =, so we know it's a local variable write.
                    const pm_location_t message = call->message_loc;

                    pm_parser_local_add_location(parser, message.start, message.end, 0);
                    pm_node_destroy(parser, target);

                    pm_constant_id_t constant_id = pm_parser_constant_id_location(parser, message.start, message.end);
                    target = (pm_node_t *) pm_local_variable_write_node_create(parser, constant_id, 0, value, &message, operator);

                    pm_refute_numbered_parameter(parser, message.start, message.end);
                    return target;
                }

                if (char_is_identifier_start(parser, call->message_loc.start, parser->end - call->message_loc.start)) {
                    // When we get here, we have a method call, because it was
                    // previously marked as a method call but now we have an =. This
                    // looks like:
                    //
                    //     foo.bar = 1
                    //
                    // When it was parsed in the prefix position, foo.bar was seen as a
                    // method call with no arguments. Now we have an =, so we know it's
                    // a method call with an argument. In this case we will create the
                    // arguments node, parse the argument, and add it to the list.
                    pm_arguments_node_t *arguments = pm_arguments_node_create(parser);
                    call->arguments = arguments;

                    pm_arguments_node_arguments_append(arguments, value);
                    call->base.location.end = arguments->base.location.end;

                    parse_write_name(parser, &call->name);
                    pm_node_flag_set((pm_node_t *) call, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE | pm_implicit_array_write_flags(value, PM_CALL_NODE_FLAGS_IMPLICIT_ARRAY));

                    return (pm_node_t *) call;
                }
            }

            // If there is no call operator and the message is "[]" then this is
            // an aref expression, and we can transform it into an aset
            // expression.
            if (PM_NODE_FLAG_P(call, PM_CALL_NODE_FLAGS_INDEX)) {
                if (call->arguments == NULL) {
                    call->arguments = pm_arguments_node_create(parser);
                }

                pm_arguments_node_arguments_append(call->arguments, value);
                target->location.end = value->location.end;

                // Replace the name with "[]=".
                call->name = pm_parser_constant_id_constant(parser, "[]=", 3);

                // Ensure that the arguments for []= don't contain keywords
                pm_index_arguments_check(parser, call->arguments, call->block);
                pm_node_flag_set((pm_node_t *) call, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE | pm_implicit_array_write_flags(value, PM_CALL_NODE_FLAGS_IMPLICIT_ARRAY));

                return target;
            }

            // If there are arguments on the call node, then it can't be a method
            // call ending with = or a local variable write, so it must be a
            // syntax error. In this case we'll fall through to our default
            // handling. We need to free the value that we parsed because there
            // is no way for us to attach it to the tree at this point.
            pm_node_destroy(parser, value);
        }
        PRISM_FALLTHROUGH
        default:
            // In this case we have a node that we don't know how to convert into a
            // target. We need to treat it as an error. For now, we'll mark it as an
            // error and just skip right past it.
            pm_parser_err_token(parser, operator, PM_ERR_WRITE_TARGET_UNEXPECTED);
            return target;
    }
}

/**
 * Certain expressions are not writable, but in order to provide a better
 * experience we give a specific error message. In order to maintain as much
 * information in the tree as possible, we replace them with local variable
 * writes.
 */
static pm_node_t *
parse_unwriteable_write(pm_parser_t *parser, pm_node_t *target, const pm_token_t *equals, pm_node_t *value) {
    switch (PM_NODE_TYPE(target)) {
        case PM_SOURCE_ENCODING_NODE: pm_parser_err_token(parser, equals, PM_ERR_EXPRESSION_NOT_WRITABLE_ENCODING); break;
        case PM_FALSE_NODE: pm_parser_err_token(parser, equals, PM_ERR_EXPRESSION_NOT_WRITABLE_FALSE); break;
        case PM_SOURCE_FILE_NODE: pm_parser_err_token(parser, equals, PM_ERR_EXPRESSION_NOT_WRITABLE_FILE); break;
        case PM_SOURCE_LINE_NODE: pm_parser_err_token(parser, equals, PM_ERR_EXPRESSION_NOT_WRITABLE_LINE); break;
        case PM_NIL_NODE: pm_parser_err_token(parser, equals, PM_ERR_EXPRESSION_NOT_WRITABLE_NIL); break;
        case PM_SELF_NODE: pm_parser_err_token(parser, equals, PM_ERR_EXPRESSION_NOT_WRITABLE_SELF); break;
        case PM_TRUE_NODE: pm_parser_err_token(parser, equals, PM_ERR_EXPRESSION_NOT_WRITABLE_TRUE); break;
        default: break;
    }

    pm_constant_id_t name = pm_parser_local_add_location(parser, target->location.start, target->location.end, 1);
    pm_local_variable_write_node_t *result = pm_local_variable_write_node_create(parser, name, 0, value, &target->location, equals);

    pm_node_destroy(parser, target);
    return (pm_node_t *) result;
}

/**
 * Parse a list of targets for assignment. This is used in the case of a for
 * loop or a multi-assignment. For example, in the following code:
 *
 *     for foo, bar in baz
 *         ^^^^^^^^
 *
 * The targets are `foo` and `bar`. This function will either return a single
 * target node or a multi-target node.
 */
static pm_node_t *
parse_targets(pm_parser_t *parser, pm_node_t *first_target, pm_binding_power_t binding_power, uint16_t depth) {
    bool has_rest = PM_NODE_TYPE_P(first_target, PM_SPLAT_NODE);

    pm_multi_target_node_t *result = pm_multi_target_node_create(parser);
    pm_multi_target_node_targets_append(parser, result, parse_target(parser, first_target, true, false));

    while (accept1(parser, PM_TOKEN_COMMA)) {
        if (accept1(parser, PM_TOKEN_USTAR)) {
            // Here we have a splat operator. It can have a name or be
            // anonymous. It can be the final target or be in the middle if
            // there haven't been any others yet.
            if (has_rest) {
                pm_parser_err_previous(parser, PM_ERR_MULTI_ASSIGN_MULTI_SPLATS);
            }

            pm_token_t star_operator = parser->previous;
            pm_node_t *name = NULL;

            if (token_begins_expression_p(parser->current.type)) {
                name = parse_expression(parser, binding_power, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_STAR, (uint16_t) (depth + 1));
                name = parse_target(parser, name, true, true);
            }

            pm_node_t *splat = (pm_node_t *) pm_splat_node_create(parser, &star_operator, name);
            pm_multi_target_node_targets_append(parser, result, splat);
            has_rest = true;
        } else if (match1(parser, PM_TOKEN_PARENTHESIS_LEFT)) {
            context_push(parser, PM_CONTEXT_MULTI_TARGET);
            pm_node_t *target = parse_expression(parser, binding_power, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_COMMA, (uint16_t) (depth + 1));
            target = parse_target(parser, target, true, false);

            pm_multi_target_node_targets_append(parser, result, target);
            context_pop(parser);
        } else if (token_begins_expression_p(parser->current.type)) {
            pm_node_t *target = parse_expression(parser, binding_power, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_COMMA, (uint16_t) (depth + 1));
            target = parse_target(parser, target, true, false);

            pm_multi_target_node_targets_append(parser, result, target);
        } else if (!match1(parser, PM_TOKEN_EOF)) {
            // If we get here, then we have a trailing , in a multi target node.
            // We'll add an implicit rest node to represent this.
            pm_node_t *rest = (pm_node_t *) pm_implicit_rest_node_create(parser, &parser->previous);
            pm_multi_target_node_targets_append(parser, result, rest);
            break;
        }
    }

    return (pm_node_t *) result;
}

/**
 * Parse a list of targets and validate that it is in a valid position for
 * assignment.
 */
static pm_node_t *
parse_targets_validate(pm_parser_t *parser, pm_node_t *first_target, pm_binding_power_t binding_power, uint16_t depth) {
    pm_node_t *result = parse_targets(parser, first_target, binding_power, depth);
    accept1(parser, PM_TOKEN_NEWLINE);

    // Ensure that we have either an = or a ) after the targets.
    if (!match2(parser, PM_TOKEN_EQUAL, PM_TOKEN_PARENTHESIS_RIGHT)) {
        pm_parser_err_node(parser, result, PM_ERR_WRITE_TARGET_UNEXPECTED);
    }

    return result;
}

/**
 * Parse a list of statements separated by newlines or semicolons.
 */
static pm_statements_node_t *
parse_statements(pm_parser_t *parser, pm_context_t context, uint16_t depth) {
    // First, skip past any optional terminators that might be at the beginning
    // of the statements.
    while (accept2(parser, PM_TOKEN_SEMICOLON, PM_TOKEN_NEWLINE));

    // If we have a terminator, then we can just return NULL.
    if (context_terminator(context, &parser->current)) return NULL;

    pm_statements_node_t *statements = pm_statements_node_create(parser);

    // At this point we know we have at least one statement, and that it
    // immediately follows the current token.
    context_push(parser, context);

    while (true) {
        pm_node_t *node = parse_expression(parser, PM_BINDING_POWER_STATEMENT, true, false, PM_ERR_CANNOT_PARSE_EXPRESSION, (uint16_t) (depth + 1));
        pm_statements_node_body_append(parser, statements, node, true);

        // If we're recovering from a syntax error, then we need to stop parsing
        // the statements now.
        if (parser->recovering) {
            // If this is the level of context where the recovery has happened,
            // then we can mark the parser as done recovering.
            if (context_terminator(context, &parser->current)) parser->recovering = false;
            break;
        }

        // If we have a terminator, then we will parse all consecutive
        // terminators and then continue parsing the statements list.
        if (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
            // If we have a terminator, then we will continue parsing the
            // statements list.
            while (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON));
            if (context_terminator(context, &parser->current)) break;

            // Now we can continue parsing the list of statements.
            continue;
        }

        // At this point we have a list of statements that are not terminated by
        // a newline or semicolon. At this point we need to check if we're at
        // the end of the statements list. If we are, then we should break out
        // of the loop.
        if (context_terminator(context, &parser->current)) break;

        // At this point, we have a syntax error, because the statement was not
        // terminated by a newline or semicolon, and we're not at the end of the
        // statements list. Ideally we should scan forward to determine if we
        // should insert a missing terminator or break out of parsing the
        // statements list at this point.
        //
        // We don't have that yet, so instead we'll do a more naive approach. If
        // we were unable to parse an expression, then we will skip past this
        // token and continue parsing the statements list. Otherwise we'll add
        // an error and continue parsing the statements list.
        if (PM_NODE_TYPE_P(node, PM_MISSING_NODE)) {
            parser_lex(parser);

            // If we are at the end of the file, then we need to stop parsing
            // the statements entirely at this point. Mark the parser as
            // recovering, as we know that EOF closes the top-level context, and
            // then break out of the loop.
            if (match1(parser, PM_TOKEN_EOF)) {
                parser->recovering = true;
                break;
            }

            while (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON));
            if (context_terminator(context, &parser->current)) break;
        } else if (!accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_EOF)) {
            // This is an inlined version of accept1 because the error that we
            // want to add has varargs. If this happens again, we should
            // probably extract a helper function.
            PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_type_human(parser->current.type));
            parser->previous.start = parser->previous.end;
            parser->previous.type = PM_TOKEN_MISSING;
        }
    }

    context_pop(parser);
    bool last_value = true;
    switch (context) {
        case PM_CONTEXT_BEGIN_ENSURE:
        case PM_CONTEXT_DEF_ENSURE:
            last_value = false;
            break;
        default:
            break;
    }
    pm_void_statements_check(parser, statements, last_value);

    return statements;
}

/**
 * Add a node to a set of static literals that holds a set of hash keys. If the
 * node is a duplicate, then add an appropriate warning.
 */
static void
pm_hash_key_static_literals_add(pm_parser_t *parser, pm_static_literals_t *literals, pm_node_t *node) {
    const pm_node_t *duplicated = pm_static_literals_add(&parser->newline_list, parser->start_line, literals, node, true);

    if (duplicated != NULL) {
        pm_buffer_t buffer = { 0 };
        pm_static_literal_inspect(&buffer, &parser->newline_list, parser->start_line, parser->encoding->name, duplicated);

        pm_diagnostic_list_append_format(
            &parser->warning_list,
            duplicated->location.start,
            duplicated->location.end,
            PM_WARN_DUPLICATED_HASH_KEY,
            (int) pm_buffer_length(&buffer),
            pm_buffer_value(&buffer),
            pm_newline_list_line_column(&parser->newline_list, node->location.start, parser->start_line).line
        );

        pm_buffer_free(&buffer);
    }
}

/**
 * Add a node to a set of static literals that holds a set of hash keys. If the
 * node is a duplicate, then add an appropriate warning.
 */
static void
pm_when_clause_static_literals_add(pm_parser_t *parser, pm_static_literals_t *literals, pm_node_t *node) {
    pm_node_t *previous;

    if ((previous = pm_static_literals_add(&parser->newline_list, parser->start_line, literals, node, false)) != NULL) {
        pm_diagnostic_list_append_format(
            &parser->warning_list,
            node->location.start,
            node->location.end,
            PM_WARN_DUPLICATED_WHEN_CLAUSE,
            pm_newline_list_line_column(&parser->newline_list, node->location.start, parser->start_line).line,
            pm_newline_list_line_column(&parser->newline_list, previous->location.start, parser->start_line).line
        );
    }
}

/**
 * Parse all of the elements of a hash. Return true if a double splat was found.
 */
static bool
parse_assocs(pm_parser_t *parser, pm_static_literals_t *literals, pm_node_t *node, uint16_t depth) {
    assert(PM_NODE_TYPE_P(node, PM_HASH_NODE) || PM_NODE_TYPE_P(node, PM_KEYWORD_HASH_NODE));
    bool contains_keyword_splat = false;

    while (true) {
        pm_node_t *element;

        switch (parser->current.type) {
            case PM_TOKEN_USTAR_STAR: {
                parser_lex(parser);
                pm_token_t operator = parser->previous;
                pm_node_t *value = NULL;

                if (match1(parser, PM_TOKEN_BRACE_LEFT)) {
                    // If we're about to parse a nested hash that is being
                    // pushed into this hash directly with **, then we want the
                    // inner hash to share the static literals with the outer
                    // hash.
                    parser->current_hash_keys = literals;
                    value = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_SPLAT_HASH, (uint16_t) (depth + 1));
                } else if (token_begins_expression_p(parser->current.type)) {
                    value = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_SPLAT_HASH, (uint16_t) (depth + 1));
                } else {
                    pm_parser_scope_forwarding_keywords_check(parser, &operator);
                }

                element = (pm_node_t *) pm_assoc_splat_node_create(parser, value, &operator);
                contains_keyword_splat = true;
                break;
            }
            case PM_TOKEN_LABEL: {
                pm_token_t label = parser->current;
                parser_lex(parser);

                pm_node_t *key = (pm_node_t *) pm_symbol_node_label_create(parser, &label);
                pm_hash_key_static_literals_add(parser, literals, key);

                pm_token_t operator = not_provided(parser);
                pm_node_t *value = NULL;

                if (token_begins_expression_p(parser->current.type)) {
                    value = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_HASH_EXPRESSION_AFTER_LABEL, (uint16_t) (depth + 1));
                } else {
                    if (parser->encoding->isupper_char(label.start, (label.end - 1) - label.start)) {
                        pm_token_t constant = { .type = PM_TOKEN_CONSTANT, .start = label.start, .end = label.end - 1 };
                        value = (pm_node_t *) pm_constant_read_node_create(parser, &constant);
                    } else {
                        int depth = -1;
                        pm_token_t identifier = { .type = PM_TOKEN_IDENTIFIER, .start = label.start, .end = label.end - 1 };

                        if (identifier.end[-1] == '!' || identifier.end[-1] == '?') {
                            PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, identifier, PM_ERR_INVALID_LOCAL_VARIABLE_READ);
                        } else {
                            depth = pm_parser_local_depth(parser, &identifier);
                        }

                        if (depth == -1) {
                            value = (pm_node_t *) pm_call_node_variable_call_create(parser, &identifier);
                        } else {
                            value = (pm_node_t *) pm_local_variable_read_node_create(parser, &identifier, (uint32_t) depth);
                        }
                    }

                    value->location.end++;
                    value = (pm_node_t *) pm_implicit_node_create(parser, value);
                }

                element = (pm_node_t *) pm_assoc_node_create(parser, key, &operator, value);
                break;
            }
            default: {
                pm_node_t *key = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, false, true, PM_ERR_HASH_KEY, (uint16_t) (depth + 1));

                // Hash keys that are strings are automatically frozen. We will
                // mark that here.
                if (PM_NODE_TYPE_P(key, PM_STRING_NODE)) {
                    pm_node_flag_set(key, PM_STRING_FLAGS_FROZEN | PM_NODE_FLAG_STATIC_LITERAL);
                }

                pm_hash_key_static_literals_add(parser, literals, key);

                pm_token_t operator;
                if (pm_symbol_node_label_p(key)) {
                    operator = not_provided(parser);
                } else {
                    expect1(parser, PM_TOKEN_EQUAL_GREATER, PM_ERR_HASH_ROCKET);
                    operator = parser->previous;
                }

                pm_node_t *value = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_HASH_VALUE, (uint16_t) (depth + 1));
                element = (pm_node_t *) pm_assoc_node_create(parser, key, &operator, value);
                break;
            }
        }

        if (PM_NODE_TYPE_P(node, PM_HASH_NODE)) {
            pm_hash_node_elements_append((pm_hash_node_t *) node, element);
        } else {
            pm_keyword_hash_node_elements_append((pm_keyword_hash_node_t *) node, element);
        }

        // If there's no comma after the element, then we're done.
        if (!accept1(parser, PM_TOKEN_COMMA)) break;

        // If the next element starts with a label or a **, then we know we have
        // another element in the hash, so we'll continue parsing.
        if (match2(parser, PM_TOKEN_USTAR_STAR, PM_TOKEN_LABEL)) continue;

        // Otherwise we need to check if the subsequent token begins an expression.
        // If it does, then we'll continue parsing.
        if (token_begins_expression_p(parser->current.type)) continue;

        // Otherwise by default we will exit out of this loop.
        break;
    }

    return contains_keyword_splat;
}

/**
 * Append an argument to a list of arguments.
 */
static inline void
parse_arguments_append(pm_parser_t *parser, pm_arguments_t *arguments, pm_node_t *argument) {
    if (arguments->arguments == NULL) {
        arguments->arguments = pm_arguments_node_create(parser);
    }

    pm_arguments_node_arguments_append(arguments->arguments, argument);
}

/**
 * Parse a list of arguments.
 */
static void
parse_arguments(pm_parser_t *parser, pm_arguments_t *arguments, bool accepts_forwarding, pm_token_type_t terminator, uint16_t depth) {
    pm_binding_power_t binding_power = pm_binding_powers[parser->current.type].left;

    // First we need to check if the next token is one that could be the start
    // of an argument. If it's not, then we can just return.
    if (
        match2(parser, terminator, PM_TOKEN_EOF) ||
        (binding_power != PM_BINDING_POWER_UNSET && binding_power < PM_BINDING_POWER_RANGE) ||
        context_terminator(parser->current_context->context, &parser->current)
    ) {
        return;
    }

    bool parsed_first_argument = false;
    bool parsed_bare_hash = false;
    bool parsed_block_argument = false;
    bool parsed_forwarding_arguments = false;

    while (!match1(parser, PM_TOKEN_EOF)) {
        if (parsed_forwarding_arguments) {
            pm_parser_err_current(parser, PM_ERR_ARGUMENT_AFTER_FORWARDING_ELLIPSES);
        }

        pm_node_t *argument = NULL;

        switch (parser->current.type) {
            case PM_TOKEN_USTAR_STAR:
            case PM_TOKEN_LABEL: {
                if (parsed_bare_hash) {
                    pm_parser_err_current(parser, PM_ERR_ARGUMENT_BARE_HASH);
                }

                pm_keyword_hash_node_t *hash = pm_keyword_hash_node_create(parser);
                argument = (pm_node_t *) hash;

                pm_static_literals_t hash_keys = { 0 };
                bool contains_keyword_splat = parse_assocs(parser, &hash_keys, (pm_node_t *) hash, (uint16_t) (depth + 1));

                parse_arguments_append(parser, arguments, argument);

                pm_node_flags_t flags = PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS;
                if (contains_keyword_splat) flags |= PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT;
                pm_node_flag_set((pm_node_t *) arguments->arguments, flags);

                pm_static_literals_free(&hash_keys);
                parsed_bare_hash = true;

                break;
            }
            case PM_TOKEN_UAMPERSAND: {
                parser_lex(parser);
                pm_token_t operator = parser->previous;
                pm_node_t *expression = NULL;

                if (token_begins_expression_p(parser->current.type)) {
                    expression = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_EXPECT_ARGUMENT, (uint16_t) (depth + 1));
                } else {
                    pm_parser_scope_forwarding_block_check(parser, &operator);
                }

                argument = (pm_node_t *) pm_block_argument_node_create(parser, &operator, expression);
                if (parsed_block_argument) {
                    parse_arguments_append(parser, arguments, argument);
                } else {
                    arguments->block = argument;
                }

                if (match1(parser, PM_TOKEN_COMMA)) {
                    pm_parser_err_current(parser, PM_ERR_ARGUMENT_AFTER_BLOCK);
                }

                parsed_block_argument = true;
                break;
            }
            case PM_TOKEN_USTAR: {
                parser_lex(parser);
                pm_token_t operator = parser->previous;

                if (match4(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_TOKEN_COMMA, PM_TOKEN_SEMICOLON, PM_TOKEN_BRACKET_RIGHT)) {
                    pm_parser_scope_forwarding_positionals_check(parser, &operator);
                    argument = (pm_node_t *) pm_splat_node_create(parser, &operator, NULL);
                    if (parsed_bare_hash) {
                        pm_parser_err_previous(parser, PM_ERR_ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT);
                    }
                } else {
                    pm_node_t *expression = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_SPLAT, (uint16_t) (depth + 1));

                    if (parsed_bare_hash) {
                        pm_parser_err(parser, operator.start, expression->location.end, PM_ERR_ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT);
                    }

                    argument = (pm_node_t *) pm_splat_node_create(parser, &operator, expression);
                }

                parse_arguments_append(parser, arguments, argument);
                break;
            }
            case PM_TOKEN_UDOT_DOT_DOT: {
                if (accepts_forwarding) {
                    parser_lex(parser);

                    if (token_begins_expression_p(parser->current.type)) {
                        // If the token begins an expression then this ... was
                        // not actually argument forwarding but was instead a
                        // range.
                        pm_token_t operator = parser->previous;
                        pm_node_t *right = parse_expression(parser, PM_BINDING_POWER_RANGE, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));

                        // If we parse a range, we need to validate that we
                        // didn't accidentally violate the nonassoc rules of the
                        // ... operator.
                        if (PM_NODE_TYPE_P(right, PM_RANGE_NODE)) {
                            pm_range_node_t *range = (pm_range_node_t *) right;
                            pm_parser_err(parser, range->operator_loc.start, range->operator_loc.end, PM_ERR_UNEXPECTED_RANGE_OPERATOR);
                        }

                        argument = (pm_node_t *) pm_range_node_create(parser, NULL, &operator, right);
                    } else {
                        pm_parser_scope_forwarding_all_check(parser, &parser->previous);
                        if (parsed_first_argument && terminator == PM_TOKEN_EOF) {
                            pm_parser_err_previous(parser, PM_ERR_ARGUMENT_FORWARDING_UNBOUND);
                        }

                        argument = (pm_node_t *) pm_forwarding_arguments_node_create(parser, &parser->previous);
                        parse_arguments_append(parser, arguments, argument);
                        pm_node_flag_set((pm_node_t *) arguments->arguments, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING);
                        arguments->has_forwarding = true;
                        parsed_forwarding_arguments = true;
                        break;
                    }
                }
            }
            PRISM_FALLTHROUGH
            default: {
                if (argument == NULL) {
                    argument = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, !parsed_first_argument, true, PM_ERR_EXPECT_ARGUMENT, (uint16_t) (depth + 1));
                }

                bool contains_keywords = false;
                bool contains_keyword_splat = false;

                if (pm_symbol_node_label_p(argument) || accept1(parser, PM_TOKEN_EQUAL_GREATER)) {
                    if (parsed_bare_hash) {
                        pm_parser_err_previous(parser, PM_ERR_ARGUMENT_BARE_HASH);
                    }

                    pm_token_t operator;
                    if (parser->previous.type == PM_TOKEN_EQUAL_GREATER) {
                        operator = parser->previous;
                    } else {
                        operator = not_provided(parser);
                    }

                    pm_keyword_hash_node_t *bare_hash = pm_keyword_hash_node_create(parser);
                    contains_keywords = true;

                    // Create the set of static literals for this hash.
                    pm_static_literals_t hash_keys = { 0 };
                    pm_hash_key_static_literals_add(parser, &hash_keys, argument);

                    // Finish parsing the one we are part way through.
                    pm_node_t *value = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_HASH_VALUE, (uint16_t) (depth + 1));
                    argument = (pm_node_t *) pm_assoc_node_create(parser, argument, &operator, value);

                    pm_keyword_hash_node_elements_append(bare_hash, argument);
                    argument = (pm_node_t *) bare_hash;

                    // Then parse more if we have a comma
                    if (accept1(parser, PM_TOKEN_COMMA) && (
                        token_begins_expression_p(parser->current.type) ||
                        match2(parser, PM_TOKEN_USTAR_STAR, PM_TOKEN_LABEL)
                    )) {
                        contains_keyword_splat = parse_assocs(parser, &hash_keys, (pm_node_t *) bare_hash, (uint16_t) (depth + 1));
                    }

                    pm_static_literals_free(&hash_keys);
                    parsed_bare_hash = true;
                }

                parse_arguments_append(parser, arguments, argument);

                pm_node_flags_t flags = 0;
                if (contains_keywords) flags |= PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS;
                if (contains_keyword_splat) flags |= PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT;
                pm_node_flag_set((pm_node_t *) arguments->arguments, flags);

                break;
            }
        }

        parsed_first_argument = true;

        // If parsing the argument failed, we need to stop parsing arguments.
        if (PM_NODE_TYPE_P(argument, PM_MISSING_NODE) || parser->recovering) break;

        // If the terminator of these arguments is not EOF, then we have a
        // specific token we're looking for. In that case we can accept a
        // newline here because it is not functioning as a statement terminator.
        bool accepted_newline = false;
        if (terminator != PM_TOKEN_EOF) {
            accepted_newline = accept1(parser, PM_TOKEN_NEWLINE);
        }

        if (parser->previous.type == PM_TOKEN_COMMA && parsed_bare_hash) {
            // If we previously were on a comma and we just parsed a bare hash,
            // then we want to continue parsing arguments. This is because the
            // comma was grabbed up by the hash parser.
        } else if (accept1(parser, PM_TOKEN_COMMA)) {
            // If there was a comma, then we need to check if we also accepted a
            // newline. If we did, then this is a syntax error.
            if (accepted_newline) {
                pm_parser_err_previous(parser, PM_ERR_INVALID_COMMA);
            }
        } else {
            // If there is no comma at the end of the argument list then we're
            // done parsing arguments and can break out of this loop.
            break;
        }

        // If we hit the terminator, then that means we have a trailing comma so
        // we can accept that output as well.
        if (match1(parser, terminator)) break;
    }
}

/**
 * Required parameters on method, block, and lambda declarations can be
 * destructured using parentheses. This looks like:
 *
 *     def foo((bar, baz))
 *     end
 *
 *
 * It can recurse infinitely down, and splats are allowed to group arguments.
 */
static pm_multi_target_node_t *
parse_required_destructured_parameter(pm_parser_t *parser) {
    expect1(parser, PM_TOKEN_PARENTHESIS_LEFT, PM_ERR_EXPECT_LPAREN_REQ_PARAMETER);

    pm_multi_target_node_t *node = pm_multi_target_node_create(parser);
    pm_multi_target_node_opening_set(node, &parser->previous);

    do {
        pm_node_t *param;

        // If we get here then we have a trailing comma, which isn't allowed in
        // the grammar. In other places, multi targets _do_ allow trailing
        // commas, so here we'll assume this is a mistake of the user not
        // knowing it's not allowed here.
        if (node->lefts.size > 0 && match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
            param = (pm_node_t *) pm_implicit_rest_node_create(parser, &parser->previous);
            pm_multi_target_node_targets_append(parser, node, param);
            pm_parser_err_current(parser, PM_ERR_PARAMETER_WILD_LOOSE_COMMA);
            break;
        }

        if (match1(parser, PM_TOKEN_PARENTHESIS_LEFT)) {
            param = (pm_node_t *) parse_required_destructured_parameter(parser);
        } else if (accept1(parser, PM_TOKEN_USTAR)) {
            pm_token_t star = parser->previous;
            pm_node_t *value = NULL;

            if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
                pm_token_t name = parser->previous;
                value = (pm_node_t *) pm_required_parameter_node_create(parser, &name);
                if (pm_parser_parameter_name_check(parser, &name)) {
                    pm_node_flag_set_repeated_parameter(value);
                }
                pm_parser_local_add_token(parser, &name, 1);
            }

            param = (pm_node_t *) pm_splat_node_create(parser, &star, value);
        } else {
            expect1(parser, PM_TOKEN_IDENTIFIER, PM_ERR_EXPECT_IDENT_REQ_PARAMETER);
            pm_token_t name = parser->previous;

            param = (pm_node_t *) pm_required_parameter_node_create(parser, &name);
            if (pm_parser_parameter_name_check(parser, &name)) {
                pm_node_flag_set_repeated_parameter(param);
            }
            pm_parser_local_add_token(parser, &name, 1);
        }

        pm_multi_target_node_targets_append(parser, node, param);
    } while (accept1(parser, PM_TOKEN_COMMA));

    accept1(parser, PM_TOKEN_NEWLINE);
    expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_EXPECT_RPAREN_REQ_PARAMETER);
    pm_multi_target_node_closing_set(node, &parser->previous);

    return node;
}

/**
 * This represents the different order states we can be in when parsing
 * method parameters.
 */
typedef enum {
    PM_PARAMETERS_NO_CHANGE = 0, // Extra state for tokens that should not change the state
    PM_PARAMETERS_ORDER_NOTHING_AFTER = 1,
    PM_PARAMETERS_ORDER_KEYWORDS_REST,
    PM_PARAMETERS_ORDER_KEYWORDS,
    PM_PARAMETERS_ORDER_REST,
    PM_PARAMETERS_ORDER_AFTER_OPTIONAL,
    PM_PARAMETERS_ORDER_OPTIONAL,
    PM_PARAMETERS_ORDER_NAMED,
    PM_PARAMETERS_ORDER_NONE,
} pm_parameters_order_t;

/**
 * This matches parameters tokens with parameters state.
 */
static pm_parameters_order_t parameters_ordering[PM_TOKEN_MAXIMUM] = {
    [0] = PM_PARAMETERS_NO_CHANGE,
    [PM_TOKEN_UAMPERSAND] = PM_PARAMETERS_ORDER_NOTHING_AFTER,
    [PM_TOKEN_AMPERSAND] = PM_PARAMETERS_ORDER_NOTHING_AFTER,
    [PM_TOKEN_UDOT_DOT_DOT] = PM_PARAMETERS_ORDER_NOTHING_AFTER,
    [PM_TOKEN_IDENTIFIER] = PM_PARAMETERS_ORDER_NAMED,
    [PM_TOKEN_PARENTHESIS_LEFT] = PM_PARAMETERS_ORDER_NAMED,
    [PM_TOKEN_EQUAL] = PM_PARAMETERS_ORDER_OPTIONAL,
    [PM_TOKEN_LABEL] = PM_PARAMETERS_ORDER_KEYWORDS,
    [PM_TOKEN_USTAR] = PM_PARAMETERS_ORDER_AFTER_OPTIONAL,
    [PM_TOKEN_STAR] = PM_PARAMETERS_ORDER_AFTER_OPTIONAL,
    [PM_TOKEN_USTAR_STAR] = PM_PARAMETERS_ORDER_KEYWORDS_REST,
    [PM_TOKEN_STAR_STAR] = PM_PARAMETERS_ORDER_KEYWORDS_REST
};

/**
 * Check if current parameter follows valid parameters ordering. If not it adds
 * an error to the list without stopping the parsing, otherwise sets the
 * parameters state to the one corresponding to the current parameter.
 *
 * It returns true if it was successful, and false otherwise.
 */
static bool
update_parameter_state(pm_parser_t *parser, pm_token_t *token, pm_parameters_order_t *current) {
    pm_parameters_order_t state = parameters_ordering[token->type];
    if (state == PM_PARAMETERS_NO_CHANGE) return true;

    // If we see another ordered argument after a optional argument
    // we only continue parsing ordered arguments until we stop seeing ordered arguments.
    if (*current == PM_PARAMETERS_ORDER_OPTIONAL && state == PM_PARAMETERS_ORDER_NAMED) {
        *current = PM_PARAMETERS_ORDER_AFTER_OPTIONAL;
        return true;
    } else if (*current == PM_PARAMETERS_ORDER_AFTER_OPTIONAL && state == PM_PARAMETERS_ORDER_NAMED) {
        return true;
    }

    if (token->type == PM_TOKEN_USTAR && *current == PM_PARAMETERS_ORDER_AFTER_OPTIONAL) {
        pm_parser_err_token(parser, token, PM_ERR_PARAMETER_STAR);
        return false;
    } else if (token->type == PM_TOKEN_UDOT_DOT_DOT && (*current >= PM_PARAMETERS_ORDER_KEYWORDS_REST && *current <= PM_PARAMETERS_ORDER_AFTER_OPTIONAL)) {
        pm_parser_err_token(parser, token, *current == PM_PARAMETERS_ORDER_AFTER_OPTIONAL ? PM_ERR_PARAMETER_FORWARDING_AFTER_REST : PM_ERR_PARAMETER_ORDER);
        return false;
    } else if (*current == PM_PARAMETERS_ORDER_NOTHING_AFTER || state > *current) {
        // We know what transition we failed on, so we can provide a better error here.
        pm_parser_err_token(parser, token, PM_ERR_PARAMETER_ORDER);
        return false;
    }

    if (state < *current) *current = state;
    return true;
}

/**
 * Parse a list of parameters on a method definition.
 */
static pm_parameters_node_t *
parse_parameters(
    pm_parser_t *parser,
    pm_binding_power_t binding_power,
    bool uses_parentheses,
    bool allows_trailing_comma,
    bool allows_forwarding_parameters,
    bool accepts_blocks_in_defaults,
    bool in_block,
    uint16_t depth
) {
    pm_do_loop_stack_push(parser, false);

    pm_parameters_node_t *params = pm_parameters_node_create(parser);
    pm_parameters_order_t order = PM_PARAMETERS_ORDER_NONE;

    while (true) {
        bool parsing = true;

        switch (parser->current.type) {
            case PM_TOKEN_PARENTHESIS_LEFT: {
                update_parameter_state(parser, &parser->current, &order);
                pm_node_t *param = (pm_node_t *) parse_required_destructured_parameter(parser);

                if (order > PM_PARAMETERS_ORDER_AFTER_OPTIONAL) {
                    pm_parameters_node_requireds_append(params, param);
                } else {
                    pm_parameters_node_posts_append(params, param);
                }
                break;
            }
            case PM_TOKEN_UAMPERSAND:
            case PM_TOKEN_AMPERSAND: {
                update_parameter_state(parser, &parser->current, &order);
                parser_lex(parser);

                pm_token_t operator = parser->previous;
                pm_token_t name;

                bool repeated = false;
                if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
                    name = parser->previous;
                    repeated = pm_parser_parameter_name_check(parser, &name);
                    pm_parser_local_add_token(parser, &name, 1);
                } else {
                    name = not_provided(parser);
                    parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_FORWARDING_BLOCK;
                }

                pm_block_parameter_node_t *param = pm_block_parameter_node_create(parser, &name, &operator);
                if (repeated) {
                    pm_node_flag_set_repeated_parameter((pm_node_t *)param);
                }
                if (params->block == NULL) {
                    pm_parameters_node_block_set(params, param);
                } else {
                    pm_parser_err_node(parser, (pm_node_t *) param, PM_ERR_PARAMETER_BLOCK_MULTI);
                    pm_parameters_node_posts_append(params, (pm_node_t *) param);
                }

                break;
            }
            case PM_TOKEN_UDOT_DOT_DOT: {
                if (!allows_forwarding_parameters) {
                    pm_parser_err_current(parser, PM_ERR_ARGUMENT_NO_FORWARDING_ELLIPSES);
                }

                bool succeeded = update_parameter_state(parser, &parser->current, &order);
                parser_lex(parser);

                parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_FORWARDING_ALL;
                pm_forwarding_parameter_node_t *param = pm_forwarding_parameter_node_create(parser, &parser->previous);

                if (params->keyword_rest != NULL) {
                    // If we already have a keyword rest parameter, then we replace it with the
                    // forwarding parameter and move the keyword rest parameter to the posts list.
                    pm_node_t *keyword_rest = params->keyword_rest;
                    pm_parameters_node_posts_append(params, keyword_rest);
                    if (succeeded) pm_parser_err_previous(parser, PM_ERR_PARAMETER_UNEXPECTED_FWD);
                    params->keyword_rest = NULL;
                }

                pm_parameters_node_keyword_rest_set(params, (pm_node_t *) param);
                break;
            }
            case PM_TOKEN_CLASS_VARIABLE:
            case PM_TOKEN_IDENTIFIER:
            case PM_TOKEN_CONSTANT:
            case PM_TOKEN_INSTANCE_VARIABLE:
            case PM_TOKEN_GLOBAL_VARIABLE:
            case PM_TOKEN_METHOD_NAME: {
                parser_lex(parser);
                switch (parser->previous.type) {
                    case PM_TOKEN_CONSTANT:
                        pm_parser_err_previous(parser, PM_ERR_ARGUMENT_FORMAL_CONSTANT);
                        break;
                    case PM_TOKEN_INSTANCE_VARIABLE:
                        pm_parser_err_previous(parser, PM_ERR_ARGUMENT_FORMAL_IVAR);
                        break;
                    case PM_TOKEN_GLOBAL_VARIABLE:
                        pm_parser_err_previous(parser, PM_ERR_ARGUMENT_FORMAL_GLOBAL);
                        break;
                    case PM_TOKEN_CLASS_VARIABLE:
                        pm_parser_err_previous(parser, PM_ERR_ARGUMENT_FORMAL_CLASS);
                        break;
                    case PM_TOKEN_METHOD_NAME:
                        pm_parser_err_previous(parser, PM_ERR_PARAMETER_METHOD_NAME);
                        break;
                    default: break;
                }

                if (parser->current.type == PM_TOKEN_EQUAL) {
                    update_parameter_state(parser, &parser->current, &order);
                } else {
                    update_parameter_state(parser, &parser->previous, &order);
                }

                pm_token_t name = parser->previous;
                bool repeated = pm_parser_parameter_name_check(parser, &name);
                pm_parser_local_add_token(parser, &name, 1);

                if (match1(parser, PM_TOKEN_EQUAL)) {
                    pm_token_t operator = parser->current;
                    context_push(parser, PM_CONTEXT_DEFAULT_PARAMS);
                    parser_lex(parser);

                    pm_constant_id_t name_id = pm_parser_constant_id_token(parser, &name);
                    uint32_t reads = parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3 ? pm_locals_reads(&parser->current_scope->locals, name_id) : 0;

                    if (accepts_blocks_in_defaults) pm_accepts_block_stack_push(parser, true);
                    pm_node_t *value = parse_value_expression(parser, binding_power, false, false, PM_ERR_PARAMETER_NO_DEFAULT, (uint16_t) (depth + 1));
                    if (accepts_blocks_in_defaults) pm_accepts_block_stack_pop(parser);

                    pm_optional_parameter_node_t *param = pm_optional_parameter_node_create(parser, &name, &operator, value);

                    if (repeated) {
                        pm_node_flag_set_repeated_parameter((pm_node_t *) param);
                    }
                    pm_parameters_node_optionals_append(params, param);

                    // If the value of the parameter increased the number of
                    // reads of that parameter, then we need to warn that we
                    // have a circular definition.
                    if ((parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3) && (pm_locals_reads(&parser->current_scope->locals, name_id) != reads)) {
                        PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, name, PM_ERR_PARAMETER_CIRCULAR);
                    }

                    context_pop(parser);

                    // If parsing the value of the parameter resulted in error recovery,
                    // then we can put a missing node in its place and stop parsing the
                    // parameters entirely now.
                    if (parser->recovering) {
                        parsing = false;
                        break;
                    }
                } else if (order > PM_PARAMETERS_ORDER_AFTER_OPTIONAL) {
                    pm_required_parameter_node_t *param = pm_required_parameter_node_create(parser, &name);
                    if (repeated) {
                        pm_node_flag_set_repeated_parameter((pm_node_t *)param);
                    }
                    pm_parameters_node_requireds_append(params, (pm_node_t *) param);
                } else {
                    pm_required_parameter_node_t *param = pm_required_parameter_node_create(parser, &name);
                    if (repeated) {
                        pm_node_flag_set_repeated_parameter((pm_node_t *)param);
                    }
                    pm_parameters_node_posts_append(params, (pm_node_t *) param);
                }

                break;
            }
            case PM_TOKEN_LABEL: {
                if (!uses_parentheses && !in_block) parser->in_keyword_arg = true;
                update_parameter_state(parser, &parser->current, &order);

                context_push(parser, PM_CONTEXT_DEFAULT_PARAMS);
                parser_lex(parser);

                pm_token_t name = parser->previous;
                pm_token_t local = name;
                local.end -= 1;

                if (parser->encoding_changed ? parser->encoding->isupper_char(local.start, local.end - local.start) : pm_encoding_utf_8_isupper_char(local.start, local.end - local.start)) {
                    pm_parser_err(parser, local.start, local.end, PM_ERR_ARGUMENT_FORMAL_CONSTANT);
                } else if (local.end[-1] == '!' || local.end[-1] == '?') {
                    PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, local, PM_ERR_INVALID_LOCAL_VARIABLE_WRITE);
                }

                bool repeated = pm_parser_parameter_name_check(parser, &local);
                pm_parser_local_add_token(parser, &local, 1);

                switch (parser->current.type) {
                    case PM_TOKEN_COMMA:
                    case PM_TOKEN_PARENTHESIS_RIGHT:
                    case PM_TOKEN_PIPE: {
                        context_pop(parser);

                        pm_node_t *param = (pm_node_t *) pm_required_keyword_parameter_node_create(parser, &name);
                        if (repeated) {
                            pm_node_flag_set_repeated_parameter(param);
                        }

                        pm_parameters_node_keywords_append(params, param);
                        break;
                    }
                    case PM_TOKEN_SEMICOLON:
                    case PM_TOKEN_NEWLINE: {
                        context_pop(parser);

                        if (uses_parentheses) {
                            parsing = false;
                            break;
                        }

                        pm_node_t *param = (pm_node_t *) pm_required_keyword_parameter_node_create(parser, &name);
                        if (repeated) {
                            pm_node_flag_set_repeated_parameter(param);
                        }

                        pm_parameters_node_keywords_append(params, param);
                        break;
                    }
                    default: {
                        pm_node_t *param;

                        if (token_begins_expression_p(parser->current.type)) {
                            pm_constant_id_t name_id = pm_parser_constant_id_token(parser, &local);
                            uint32_t reads = parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3 ? pm_locals_reads(&parser->current_scope->locals, name_id) : 0;

                            if (accepts_blocks_in_defaults) pm_accepts_block_stack_push(parser, true);
                            pm_node_t *value = parse_value_expression(parser, binding_power, false, false, PM_ERR_PARAMETER_NO_DEFAULT_KW, (uint16_t) (depth + 1));
                            if (accepts_blocks_in_defaults) pm_accepts_block_stack_pop(parser);

                            if (parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3 && (pm_locals_reads(&parser->current_scope->locals, name_id) != reads)) {
                                PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, local, PM_ERR_PARAMETER_CIRCULAR);
                            }

                            param = (pm_node_t *) pm_optional_keyword_parameter_node_create(parser, &name, value);
                        }
                        else {
                            param = (pm_node_t *) pm_required_keyword_parameter_node_create(parser, &name);
                        }

                        if (repeated) {
                            pm_node_flag_set_repeated_parameter(param);
                        }

                        context_pop(parser);
                        pm_parameters_node_keywords_append(params, param);

                        // If parsing the value of the parameter resulted in error recovery,
                        // then we can put a missing node in its place and stop parsing the
                        // parameters entirely now.
                        if (parser->recovering) {
                            parsing = false;
                            break;
                        }
                    }
                }

                parser->in_keyword_arg = false;
                break;
            }
            case PM_TOKEN_USTAR:
            case PM_TOKEN_STAR: {
                update_parameter_state(parser, &parser->current, &order);
                parser_lex(parser);

                pm_token_t operator = parser->previous;
                pm_token_t name;
                bool repeated = false;

                if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
                    name = parser->previous;
                    repeated = pm_parser_parameter_name_check(parser, &name);
                    pm_parser_local_add_token(parser, &name, 1);
                } else {
                    name = not_provided(parser);
                    parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_FORWARDING_POSITIONALS;
                }

                pm_node_t *param = (pm_node_t *) pm_rest_parameter_node_create(parser, &operator, &name);
                if (repeated) {
                    pm_node_flag_set_repeated_parameter(param);
                }

                if (params->rest == NULL) {
                    pm_parameters_node_rest_set(params, param);
                } else {
                    pm_parser_err_node(parser, param, PM_ERR_PARAMETER_SPLAT_MULTI);
                    pm_parameters_node_posts_append(params, param);
                }

                break;
            }
            case PM_TOKEN_STAR_STAR:
            case PM_TOKEN_USTAR_STAR: {
                pm_parameters_order_t previous_order = order;
                update_parameter_state(parser, &parser->current, &order);
                parser_lex(parser);

                pm_token_t operator = parser->previous;
                pm_node_t *param;

                if (accept1(parser, PM_TOKEN_KEYWORD_NIL)) {
                    if (previous_order <= PM_PARAMETERS_ORDER_KEYWORDS) {
                        pm_parser_err_previous(parser, PM_ERR_PARAMETER_UNEXPECTED_NO_KW);
                    }

                    param = (pm_node_t *) pm_no_keywords_parameter_node_create(parser, &operator, &parser->previous);
                } else {
                    pm_token_t name;

                    bool repeated = false;
                    if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
                        name = parser->previous;
                        repeated = pm_parser_parameter_name_check(parser, &name);
                        pm_parser_local_add_token(parser, &name, 1);
                    } else {
                        name = not_provided(parser);
                        parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_FORWARDING_KEYWORDS;
                    }

                    param = (pm_node_t *) pm_keyword_rest_parameter_node_create(parser, &operator, &name);
                    if (repeated) {
                        pm_node_flag_set_repeated_parameter(param);
                    }
                }

                if (params->keyword_rest == NULL) {
                    pm_parameters_node_keyword_rest_set(params, param);
                } else {
                    pm_parser_err_node(parser, param, PM_ERR_PARAMETER_ASSOC_SPLAT_MULTI);
                    pm_parameters_node_posts_append(params, param);
                }

                break;
            }
            default:
                if (parser->previous.type == PM_TOKEN_COMMA) {
                    if (allows_trailing_comma && order >= PM_PARAMETERS_ORDER_NAMED) {
                        // If we get here, then we have a trailing comma in a
                        // block parameter list.
                        pm_node_t *param = (pm_node_t *) pm_implicit_rest_node_create(parser, &parser->previous);

                        if (params->rest == NULL) {
                            pm_parameters_node_rest_set(params, param);
                        } else {
                            pm_parser_err_node(parser, (pm_node_t *) param, PM_ERR_PARAMETER_SPLAT_MULTI);
                            pm_parameters_node_posts_append(params, (pm_node_t *) param);
                        }
                    } else {
                        pm_parser_err_previous(parser, PM_ERR_PARAMETER_WILD_LOOSE_COMMA);
                    }
                }

                parsing = false;
                break;
        }

        // If we hit some kind of issue while parsing the parameter, this would
        // have been set to false. In that case, we need to break out of the
        // loop.
        if (!parsing) break;

        bool accepted_newline = false;
        if (uses_parentheses) {
            accepted_newline = accept1(parser, PM_TOKEN_NEWLINE);
        }

        if (accept1(parser, PM_TOKEN_COMMA)) {
            // If there was a comma, but we also accepted a newline, then this
            // is a syntax error.
            if (accepted_newline) {
                pm_parser_err_previous(parser, PM_ERR_INVALID_COMMA);
            }
        } else {
            // If there was no comma, then we're done parsing parameters.
            break;
        }
    }

    pm_do_loop_stack_pop(parser);

    // If we don't have any parameters, return `NULL` instead of an empty `ParametersNode`.
    if (params->base.location.start == params->base.location.end) {
        pm_node_destroy(parser, (pm_node_t *) params);
        return NULL;
    }

    return params;
}

/**
 * Accepts a parser returns the index of the last newline in the file that was
 * ecorded before the current token within the newline list.
 */
static size_t
token_newline_index(const pm_parser_t *parser) {
    if (parser->heredoc_end == NULL) {
        // This is the common case. In this case we can look at the previously
        // recorded newline in the newline list and subtract from the current
        // offset.
        return parser->newline_list.size - 1;
    } else {
        // This is unlikely. This is the case that we have already parsed the
        // start of a heredoc, so we cannot rely on looking at the previous
        // offset of the newline list, and instead must go through the whole
        // process of a binary search for the line number.
        return (size_t) pm_newline_list_line(&parser->newline_list, parser->current.start, 0);
    }
}

/**
 * Accepts a parser, a newline index, and a token and returns the column. The
 * important piece of this is that it expands tabs out to the next tab stop.
 */
static int64_t
token_column(const pm_parser_t *parser, size_t newline_index, const pm_token_t *token, bool break_on_non_space) {
    const uint8_t *cursor = parser->start + parser->newline_list.offsets[newline_index];
    const uint8_t *end = token->start;

    // Skip over the BOM if it is present.
    if (
        newline_index == 0 &&
        parser->start[0] == 0xef &&
        parser->start[1] == 0xbb &&
        parser->start[2] == 0xbf
    ) cursor += 3;

    int64_t column = 0;
    for (; cursor < end; cursor++) {
        switch (*cursor) {
            case '\t':
                column = ((column / PM_TAB_WHITESPACE_SIZE) + 1) * PM_TAB_WHITESPACE_SIZE;
                break;
            case ' ':
                column++;
                break;
            default:
                column++;
                if (break_on_non_space) return -1;
                break;
        }
    }

    return column;
}

/**
 * Accepts a parser, two newline indices, and pointers to two tokens. This
 * function warns if the indentation of the two tokens does not match.
 */
static void
parser_warn_indentation_mismatch(pm_parser_t *parser, size_t opening_newline_index, const pm_token_t *opening_token, bool if_after_else, bool allow_indent) {
    // If these warnings are disabled (unlikely), then we can just return.
    if (!parser->warn_mismatched_indentation) return;

    // If the tokens are on the same line, we do not warn.
    size_t closing_newline_index = token_newline_index(parser);
    if (opening_newline_index == closing_newline_index) return;

    // If the opening token has anything other than spaces or tabs before it,
    // then we do not warn. This is unless we are matching up an `if`/`end` pair
    // and the `if` immediately follows an `else` keyword.
    int64_t opening_column = token_column(parser, opening_newline_index, opening_token, !if_after_else);
    if (!if_after_else && (opening_column == -1)) return;

    // Get a reference to the closing token off the current parser. This assumes
    // that the caller has placed this in the correct position.
    pm_token_t *closing_token = &parser->current;

    // If the tokens are at the same indentation, we do not warn.
    int64_t closing_column = token_column(parser, closing_newline_index, closing_token, true);
    if ((closing_column == -1) || (opening_column == closing_column)) return;

    // If the closing column is greater than the opening column and we are
    // allowing indentation, then we do not warn.
    if (allow_indent && (closing_column > opening_column)) return;

    // Otherwise, add a warning.
    PM_PARSER_WARN_FORMAT(
        parser,
        closing_token->start,
        closing_token->end,
        PM_WARN_INDENTATION_MISMATCH,
        (int) (closing_token->end - closing_token->start),
        (const char *) closing_token->start,
        (int) (opening_token->end - opening_token->start),
        (const char *) opening_token->start,
        ((int32_t) opening_newline_index) + parser->start_line
    );
}

typedef enum {
    PM_RESCUES_BEGIN = 1,
    PM_RESCUES_BLOCK,
    PM_RESCUES_CLASS,
    PM_RESCUES_DEF,
    PM_RESCUES_LAMBDA,
    PM_RESCUES_MODULE,
    PM_RESCUES_SCLASS
} pm_rescues_type_t;

/**
 * Parse any number of rescue clauses. This will form a linked list of if
 * nodes pointing to each other from the top.
 */
static inline void
parse_rescues(pm_parser_t *parser, size_t opening_newline_index, const pm_token_t *opening, pm_begin_node_t *parent_node, pm_rescues_type_t type, uint16_t depth) {
    pm_rescue_node_t *current = NULL;

    while (match1(parser, PM_TOKEN_KEYWORD_RESCUE)) {
        if (opening != NULL) parser_warn_indentation_mismatch(parser, opening_newline_index, opening, false, false);
        parser_lex(parser);

        pm_rescue_node_t *rescue = pm_rescue_node_create(parser, &parser->previous);

        switch (parser->current.type) {
            case PM_TOKEN_EQUAL_GREATER: {
                // Here we have an immediate => after the rescue keyword, in which case
                // we're going to have an empty list of exceptions to rescue (which
                // implies StandardError).
                parser_lex(parser);
                pm_rescue_node_operator_set(rescue, &parser->previous);

                pm_node_t *reference = parse_expression(parser, PM_BINDING_POWER_INDEX, false, false, PM_ERR_RESCUE_VARIABLE, (uint16_t) (depth + 1));
                reference = parse_target(parser, reference, false, false);

                pm_rescue_node_reference_set(rescue, reference);
                break;
            }
            case PM_TOKEN_NEWLINE:
            case PM_TOKEN_SEMICOLON:
            case PM_TOKEN_KEYWORD_THEN:
                // Here we have a terminator for the rescue keyword, in which
                // case we're going to just continue on.
                break;
            default: {
                if (token_begins_expression_p(parser->current.type) || match1(parser, PM_TOKEN_USTAR)) {
                    // Here we have something that could be an exception expression, so
                    // we'll attempt to parse it here and any others delimited by commas.

                    do {
                        pm_node_t *expression = parse_starred_expression(parser, PM_BINDING_POWER_DEFINED, false, PM_ERR_RESCUE_EXPRESSION, (uint16_t) (depth + 1));
                        pm_rescue_node_exceptions_append(rescue, expression);

                        // If we hit a newline, then this is the end of the rescue expression. We
                        // can continue on to parse the statements.
                        if (match3(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON, PM_TOKEN_KEYWORD_THEN)) break;

                        // If we hit a `=>` then we're going to parse the exception variable. Once
                        // we've done that, we'll break out of the loop and parse the statements.
                        if (accept1(parser, PM_TOKEN_EQUAL_GREATER)) {
                            pm_rescue_node_operator_set(rescue, &parser->previous);

                            pm_node_t *reference = parse_expression(parser, PM_BINDING_POWER_INDEX, false, false, PM_ERR_RESCUE_VARIABLE, (uint16_t) (depth + 1));
                            reference = parse_target(parser, reference, false, false);

                            pm_rescue_node_reference_set(rescue, reference);
                            break;
                        }
                    } while (accept1(parser, PM_TOKEN_COMMA));
                }
            }
        }

        if (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
            if (accept1(parser, PM_TOKEN_KEYWORD_THEN)) {
                rescue->then_keyword_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(&parser->previous);
            }
        } else {
            expect1(parser, PM_TOKEN_KEYWORD_THEN, PM_ERR_RESCUE_TERM);
            rescue->then_keyword_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(&parser->previous);
        }

        if (!match3(parser, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_END)) {
            pm_accepts_block_stack_push(parser, true);
            pm_context_t context;

            switch (type) {
                case PM_RESCUES_BEGIN: context = PM_CONTEXT_BEGIN_RESCUE; break;
                case PM_RESCUES_BLOCK: context = PM_CONTEXT_BLOCK_RESCUE; break;
                case PM_RESCUES_CLASS: context = PM_CONTEXT_CLASS_RESCUE; break;
                case PM_RESCUES_DEF: context = PM_CONTEXT_DEF_RESCUE; break;
                case PM_RESCUES_LAMBDA: context = PM_CONTEXT_LAMBDA_RESCUE; break;
                case PM_RESCUES_MODULE: context = PM_CONTEXT_MODULE_RESCUE; break;
                case PM_RESCUES_SCLASS: context = PM_CONTEXT_SCLASS_RESCUE; break;
                default: assert(false && "unreachable"); context = PM_CONTEXT_BEGIN_RESCUE; break;
            }

            pm_statements_node_t *statements = parse_statements(parser, context, (uint16_t) (depth + 1));
            if (statements != NULL) pm_rescue_node_statements_set(rescue, statements);

            pm_accepts_block_stack_pop(parser);
            accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
        }

        if (current == NULL) {
            pm_begin_node_rescue_clause_set(parent_node, rescue);
        } else {
            pm_rescue_node_subsequent_set(current, rescue);
        }

        current = rescue;
    }

    // The end node locations on rescue nodes will not be set correctly
    // since we won't know the end until we've found all subsequent
    // clauses. This sets the end location on all rescues once we know it.
    if (current != NULL) {
        const uint8_t *end_to_set = current->base.location.end;
        pm_rescue_node_t *clause = parent_node->rescue_clause;

        while (clause != NULL) {
            clause->base.location.end = end_to_set;
            clause = clause->subsequent;
        }
    }

    pm_token_t else_keyword;
    if (match1(parser, PM_TOKEN_KEYWORD_ELSE)) {
        if (opening != NULL) parser_warn_indentation_mismatch(parser, opening_newline_index, opening, false, false);
        opening_newline_index = token_newline_index(parser);

        else_keyword = parser->current;
        opening = &else_keyword;

        parser_lex(parser);
        accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);

        pm_statements_node_t *else_statements = NULL;
        if (!match2(parser, PM_TOKEN_KEYWORD_END, PM_TOKEN_KEYWORD_ENSURE)) {
            pm_accepts_block_stack_push(parser, true);
            pm_context_t context;

            switch (type) {
                case PM_RESCUES_BEGIN: context = PM_CONTEXT_BEGIN_ELSE; break;
                case PM_RESCUES_BLOCK: context = PM_CONTEXT_BLOCK_ELSE; break;
                case PM_RESCUES_CLASS: context = PM_CONTEXT_CLASS_ELSE; break;
                case PM_RESCUES_DEF: context = PM_CONTEXT_DEF_ELSE; break;
                case PM_RESCUES_LAMBDA: context = PM_CONTEXT_LAMBDA_ELSE; break;
                case PM_RESCUES_MODULE: context = PM_CONTEXT_MODULE_ELSE; break;
                case PM_RESCUES_SCLASS: context = PM_CONTEXT_SCLASS_ELSE; break;
                default: assert(false && "unreachable"); context = PM_CONTEXT_BEGIN_ELSE; break;
            }

            else_statements = parse_statements(parser, context, (uint16_t) (depth + 1));
            pm_accepts_block_stack_pop(parser);

            accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
        }

        pm_else_node_t *else_clause = pm_else_node_create(parser, &else_keyword, else_statements, &parser->current);
        pm_begin_node_else_clause_set(parent_node, else_clause);

        // If we don't have a `current` rescue node, then this is a dangling
        // else, and it's an error.
        if (current == NULL) pm_parser_err_node(parser, (pm_node_t *) else_clause, PM_ERR_BEGIN_LONELY_ELSE);
    }

    if (match1(parser, PM_TOKEN_KEYWORD_ENSURE)) {
        if (opening != NULL) parser_warn_indentation_mismatch(parser, opening_newline_index, opening, false, false);
        pm_token_t ensure_keyword = parser->current;

        parser_lex(parser);
        accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);

        pm_statements_node_t *ensure_statements = NULL;
        if (!match1(parser, PM_TOKEN_KEYWORD_END)) {
            pm_accepts_block_stack_push(parser, true);
            pm_context_t context;

            switch (type) {
                case PM_RESCUES_BEGIN: context = PM_CONTEXT_BEGIN_ENSURE; break;
                case PM_RESCUES_BLOCK: context = PM_CONTEXT_BLOCK_ENSURE; break;
                case PM_RESCUES_CLASS: context = PM_CONTEXT_CLASS_ENSURE; break;
                case PM_RESCUES_DEF: context = PM_CONTEXT_DEF_ENSURE; break;
                case PM_RESCUES_LAMBDA: context = PM_CONTEXT_LAMBDA_ENSURE; break;
                case PM_RESCUES_MODULE: context = PM_CONTEXT_MODULE_ENSURE; break;
                case PM_RESCUES_SCLASS: context = PM_CONTEXT_SCLASS_ENSURE; break;
                default: assert(false && "unreachable"); context = PM_CONTEXT_BEGIN_RESCUE; break;
            }

            ensure_statements = parse_statements(parser, context, (uint16_t) (depth + 1));
            pm_accepts_block_stack_pop(parser);

            accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
        }

        pm_ensure_node_t *ensure_clause = pm_ensure_node_create(parser, &ensure_keyword, ensure_statements, &parser->current);
        pm_begin_node_ensure_clause_set(parent_node, ensure_clause);
    }

    if (match1(parser, PM_TOKEN_KEYWORD_END)) {
        if (opening != NULL) parser_warn_indentation_mismatch(parser, opening_newline_index, opening, false, false);
        pm_begin_node_end_keyword_set(parent_node, &parser->current);
    } else {
        pm_token_t end_keyword = (pm_token_t) { .type = PM_TOKEN_MISSING, .start = parser->previous.end, .end = parser->previous.end };
        pm_begin_node_end_keyword_set(parent_node, &end_keyword);
    }
}

/**
 * Parse a set of rescue clauses with an implicit begin (for example when on a
 * class, module, def, etc.).
 */
static pm_begin_node_t *
parse_rescues_implicit_begin(pm_parser_t *parser, size_t opening_newline_index, const pm_token_t *opening, const uint8_t *start, pm_statements_node_t *statements, pm_rescues_type_t type, uint16_t depth) {
    pm_token_t begin_keyword = not_provided(parser);
    pm_begin_node_t *node = pm_begin_node_create(parser, &begin_keyword, statements);

    parse_rescues(parser, opening_newline_index, opening, node, type, (uint16_t) (depth + 1));
    node->base.location.start = start;

    return node;
}

/**
 * Parse a list of parameters and local on a block definition.
 */
static pm_block_parameters_node_t *
parse_block_parameters(
    pm_parser_t *parser,
    bool allows_trailing_comma,
    const pm_token_t *opening,
    bool is_lambda_literal,
    bool accepts_blocks_in_defaults,
    uint16_t depth
) {
    pm_parameters_node_t *parameters = NULL;
    if (!match1(parser, PM_TOKEN_SEMICOLON)) {
        parameters = parse_parameters(
            parser,
            is_lambda_literal ? PM_BINDING_POWER_DEFINED : PM_BINDING_POWER_INDEX,
            false,
            allows_trailing_comma,
            false,
            accepts_blocks_in_defaults,
            true,
            (uint16_t) (depth + 1)
        );
    }

    pm_block_parameters_node_t *block_parameters = pm_block_parameters_node_create(parser, parameters, opening);
    if ((opening->type != PM_TOKEN_NOT_PROVIDED)) {
        accept1(parser, PM_TOKEN_NEWLINE);

        if (accept1(parser, PM_TOKEN_SEMICOLON)) {
            do {
                switch (parser->current.type) {
                    case PM_TOKEN_CONSTANT:
                        pm_parser_err_current(parser, PM_ERR_ARGUMENT_FORMAL_CONSTANT);
                        parser_lex(parser);
                        break;
                    case PM_TOKEN_INSTANCE_VARIABLE:
                        pm_parser_err_current(parser, PM_ERR_ARGUMENT_FORMAL_IVAR);
                        parser_lex(parser);
                        break;
                    case PM_TOKEN_GLOBAL_VARIABLE:
                        pm_parser_err_current(parser, PM_ERR_ARGUMENT_FORMAL_GLOBAL);
                        parser_lex(parser);
                        break;
                    case PM_TOKEN_CLASS_VARIABLE:
                        pm_parser_err_current(parser, PM_ERR_ARGUMENT_FORMAL_CLASS);
                        parser_lex(parser);
                        break;
                    default:
                        expect1(parser, PM_TOKEN_IDENTIFIER, PM_ERR_BLOCK_PARAM_LOCAL_VARIABLE);
                        break;
                }

                bool repeated = pm_parser_parameter_name_check(parser, &parser->previous);
                pm_parser_local_add_token(parser, &parser->previous, 1);

                pm_block_local_variable_node_t *local = pm_block_local_variable_node_create(parser, &parser->previous);
                if (repeated) pm_node_flag_set_repeated_parameter((pm_node_t *) local);

                pm_block_parameters_node_append_local(block_parameters, local);
            } while (accept1(parser, PM_TOKEN_COMMA));
        }
    }

    return block_parameters;
}

/**
 * Return true if any of the visible scopes to the current context are using
 * numbered parameters.
 */
static bool
outer_scope_using_numbered_parameters_p(pm_parser_t *parser) {
    for (pm_scope_t *scope = parser->current_scope->previous; scope != NULL && !scope->closed; scope = scope->previous) {
        if (scope->parameters & PM_SCOPE_PARAMETERS_NUMBERED_FOUND) return true;
    }

    return false;
}

/**
 * These are the names of the various numbered parameters. We have them here so
 * that when we insert them into the constant pool we can use a constant string
 * and not have to allocate.
 */
static const char * const pm_numbered_parameter_names[] = {
    "_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9"
};

/**
 * Return the node that should be used in the parameters field of a block-like
 * (block or lambda) node, depending on the kind of parameters that were
 * declared in the current scope.
 */
static pm_node_t *
parse_blocklike_parameters(pm_parser_t *parser, pm_node_t *parameters, const pm_token_t *opening, const pm_token_t *closing) {
    pm_node_list_t *implicit_parameters = &parser->current_scope->implicit_parameters;

    // If we have ordinary parameters, then we will return them as the set of
    // parameters.
    if (parameters != NULL) {
        // If we also have implicit parameters, then this is an error.
        if (implicit_parameters->size > 0) {
            pm_node_t *node = implicit_parameters->nodes[0];

            if (PM_NODE_TYPE_P(node, PM_LOCAL_VARIABLE_READ_NODE)) {
                pm_parser_err_node(parser, node, PM_ERR_NUMBERED_PARAMETER_ORDINARY);
            } else if (PM_NODE_TYPE_P(node, PM_IT_LOCAL_VARIABLE_READ_NODE)) {
                pm_parser_err_node(parser, node, PM_ERR_IT_NOT_ALLOWED_ORDINARY);
            } else {
                assert(false && "unreachable");
            }
        }

        return parameters;
    }

    // If we don't have any implicit parameters, then the set of parameters is
    // NULL.
    if (implicit_parameters->size == 0) {
        return NULL;
    }

    // If we don't have ordinary parameters, then we now must validate our set
    // of implicit parameters. We can only have numbered parameters or it, but
    // they cannot be mixed.
    uint8_t numbered_parameter = 0;
    bool it_parameter = false;

    for (size_t index = 0; index < implicit_parameters->size; index++) {
        pm_node_t *node = implicit_parameters->nodes[index];

        if (PM_NODE_TYPE_P(node, PM_LOCAL_VARIABLE_READ_NODE)) {
            if (it_parameter) {
                pm_parser_err_node(parser, node, PM_ERR_NUMBERED_PARAMETER_IT);
            } else if (outer_scope_using_numbered_parameters_p(parser)) {
                pm_parser_err_node(parser, node, PM_ERR_NUMBERED_PARAMETER_OUTER_BLOCK);
            } else if (parser->current_scope->parameters & PM_SCOPE_PARAMETERS_NUMBERED_INNER) {
                pm_parser_err_node(parser, node, PM_ERR_NUMBERED_PARAMETER_INNER_BLOCK);
            } else if (pm_token_is_numbered_parameter(node->location.start, node->location.end)) {
                numbered_parameter = MAX(numbered_parameter, (uint8_t) (node->location.start[1] - '0'));
            } else {
                assert(false && "unreachable");
            }
        } else if (PM_NODE_TYPE_P(node, PM_IT_LOCAL_VARIABLE_READ_NODE)) {
            if (numbered_parameter > 0) {
                pm_parser_err_node(parser, node, PM_ERR_IT_NOT_ALLOWED_NUMBERED);
            } else {
                it_parameter = true;
            }
        }
    }

    if (numbered_parameter > 0) {
        // Go through the parent scopes and mark them as being disallowed from
        // using numbered parameters because this inner scope is using them.
        for (pm_scope_t *scope = parser->current_scope->previous; scope != NULL && !scope->closed; scope = scope->previous) {
            scope->parameters |= PM_SCOPE_PARAMETERS_NUMBERED_INNER;
        }

        const pm_location_t location = { .start = opening->start, .end = closing->end };
        return (pm_node_t *) pm_numbered_parameters_node_create(parser, &location, numbered_parameter);
    }

    if (it_parameter) {
        return (pm_node_t *) pm_it_parameters_node_create(parser, opening, closing);
    }

    return NULL;
}

/**
 * Parse a block.
 */
static pm_block_node_t *
parse_block(pm_parser_t *parser, uint16_t depth) {
    pm_token_t opening = parser->previous;
    accept1(parser, PM_TOKEN_NEWLINE);

    pm_accepts_block_stack_push(parser, true);
    pm_parser_scope_push(parser, false);

    pm_block_parameters_node_t *block_parameters = NULL;

    if (accept1(parser, PM_TOKEN_PIPE)) {
        pm_token_t block_parameters_opening = parser->previous;
        if (match1(parser, PM_TOKEN_PIPE)) {
            block_parameters = pm_block_parameters_node_create(parser, NULL, &block_parameters_opening);
            parser->command_start = true;
            parser_lex(parser);
        } else {
            block_parameters = parse_block_parameters(parser, true, &block_parameters_opening, false, true, (uint16_t) (depth + 1));
            accept1(parser, PM_TOKEN_NEWLINE);
            parser->command_start = true;
            expect1(parser, PM_TOKEN_PIPE, PM_ERR_BLOCK_PARAM_PIPE_TERM);
        }

        pm_block_parameters_node_closing_set(block_parameters, &parser->previous);
    }

    accept1(parser, PM_TOKEN_NEWLINE);
    pm_node_t *statements = NULL;

    if (opening.type == PM_TOKEN_BRACE_LEFT) {
        if (!match1(parser, PM_TOKEN_BRACE_RIGHT)) {
            statements = (pm_node_t *) parse_statements(parser, PM_CONTEXT_BLOCK_BRACES, (uint16_t) (depth + 1));
        }

        expect1(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_BLOCK_TERM_BRACE);
    } else {
        if (!match1(parser, PM_TOKEN_KEYWORD_END)) {
            if (!match3(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_ENSURE)) {
                pm_accepts_block_stack_push(parser, true);
                statements = (pm_node_t *) parse_statements(parser, PM_CONTEXT_BLOCK_KEYWORDS, (uint16_t) (depth + 1));
                pm_accepts_block_stack_pop(parser);
            }

            if (match2(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE)) {
                assert(statements == NULL || PM_NODE_TYPE_P(statements, PM_STATEMENTS_NODE));
                statements = (pm_node_t *) parse_rescues_implicit_begin(parser, 0, NULL, opening.start, (pm_statements_node_t *) statements, PM_RESCUES_BLOCK, (uint16_t) (depth + 1));
            }
        }

        expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_BLOCK_TERM_END);
    }

    pm_constant_id_list_t locals;
    pm_locals_order(parser, &parser->current_scope->locals, &locals, pm_parser_scope_toplevel_p(parser));
    pm_node_t *parameters = parse_blocklike_parameters(parser, (pm_node_t *) block_parameters, &opening, &parser->previous);

    pm_parser_scope_pop(parser);
    pm_accepts_block_stack_pop(parser);

    return pm_block_node_create(parser, &locals, &opening, parameters, statements, &parser->previous);
}

/**
 * Parse a list of arguments and their surrounding parentheses if they are
 * present. It returns true if it found any pieces of arguments (parentheses,
 * arguments, or blocks).
 */
static bool
parse_arguments_list(pm_parser_t *parser, pm_arguments_t *arguments, bool accepts_block, bool accepts_command_call, uint16_t depth) {
    bool found = false;

    if (accept1(parser, PM_TOKEN_PARENTHESIS_LEFT)) {
        found |= true;
        arguments->opening_loc = PM_LOCATION_TOKEN_VALUE(&parser->previous);

        if (accept1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
            arguments->closing_loc = PM_LOCATION_TOKEN_VALUE(&parser->previous);
        } else {
            pm_accepts_block_stack_push(parser, true);
            parse_arguments(parser, arguments, accepts_block, PM_TOKEN_PARENTHESIS_RIGHT, (uint16_t) (depth + 1));

            if (!accept1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
                PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_ARGUMENT_TERM_PAREN, pm_token_type_human(parser->current.type));
                parser->previous.start = parser->previous.end;
                parser->previous.type = PM_TOKEN_MISSING;
            }

            pm_accepts_block_stack_pop(parser);
            arguments->closing_loc = PM_LOCATION_TOKEN_VALUE(&parser->previous);
        }
    } else if (accepts_command_call && (token_begins_expression_p(parser->current.type) || match3(parser, PM_TOKEN_USTAR, PM_TOKEN_USTAR_STAR, PM_TOKEN_UAMPERSAND)) && !match1(parser, PM_TOKEN_BRACE_LEFT)) {
        found |= true;
        pm_accepts_block_stack_push(parser, false);

        // If we get here, then the subsequent token cannot be used as an infix
        // operator. In this case we assume the subsequent token is part of an
        // argument to this method call.
        parse_arguments(parser, arguments, accepts_block, PM_TOKEN_EOF, (uint16_t) (depth + 1));

        // If we have done with the arguments and still not consumed the comma,
        // then we have a trailing comma where we need to check whether it is
        // allowed or not.
        if (parser->previous.type == PM_TOKEN_COMMA && !match1(parser, PM_TOKEN_SEMICOLON)) {
            PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->previous, PM_ERR_EXPECT_ARGUMENT, pm_token_type_human(parser->current.type));
        }

        pm_accepts_block_stack_pop(parser);
    }

    // If we're at the end of the arguments, we can now check if there is a block
    // node that starts with a {. If there is, then we can parse it and add it to
    // the arguments.
    if (accepts_block) {
        pm_block_node_t *block = NULL;

        if (accept1(parser, PM_TOKEN_BRACE_LEFT)) {
            found |= true;
            block = parse_block(parser, (uint16_t) (depth + 1));
            pm_arguments_validate_block(parser, arguments, block);
        } else if (pm_accepts_block_stack_p(parser) && accept1(parser, PM_TOKEN_KEYWORD_DO)) {
            found |= true;
            block = parse_block(parser, (uint16_t) (depth + 1));
        }

        if (block != NULL) {
            if (arguments->block == NULL && !arguments->has_forwarding) {
                arguments->block = (pm_node_t *) block;
            } else {
                pm_parser_err_node(parser, (pm_node_t *) block, PM_ERR_ARGUMENT_BLOCK_MULTI);

                if (arguments->block != NULL) {
                    if (arguments->arguments == NULL) {
                        arguments->arguments = pm_arguments_node_create(parser);
                    }
                    pm_arguments_node_arguments_append(arguments->arguments, arguments->block);
                }
                arguments->block = (pm_node_t *) block;
            }
        }
    }

    return found;
}

/**
 * Check that the return is allowed in the current context. If it isn't, add an
 * error to the parser.
 */
static void
parse_return(pm_parser_t *parser, pm_node_t *node) {
    bool in_sclass = false;
    for (pm_context_node_t *context_node = parser->current_context; context_node != NULL; context_node = context_node->prev) {
        switch (context_node->context) {
            case PM_CONTEXT_BEGIN_ELSE:
            case PM_CONTEXT_BEGIN_ENSURE:
            case PM_CONTEXT_BEGIN_RESCUE:
            case PM_CONTEXT_BEGIN:
            case PM_CONTEXT_CASE_IN:
            case PM_CONTEXT_CASE_WHEN:
            case PM_CONTEXT_DEFAULT_PARAMS:
            case PM_CONTEXT_DEFINED:
            case PM_CONTEXT_ELSE:
            case PM_CONTEXT_ELSIF:
            case PM_CONTEXT_EMBEXPR:
            case PM_CONTEXT_FOR_INDEX:
            case PM_CONTEXT_FOR:
            case PM_CONTEXT_IF:
            case PM_CONTEXT_LOOP_PREDICATE:
            case PM_CONTEXT_MAIN:
            case PM_CONTEXT_MULTI_TARGET:
            case PM_CONTEXT_PARENS:
            case PM_CONTEXT_POSTEXE:
            case PM_CONTEXT_PREDICATE:
            case PM_CONTEXT_PREEXE:
            case PM_CONTEXT_RESCUE_MODIFIER:
            case PM_CONTEXT_TERNARY:
            case PM_CONTEXT_UNLESS:
            case PM_CONTEXT_UNTIL:
            case PM_CONTEXT_WHILE:
                // Keep iterating up the lists of contexts, because returns can
                // see through these.
                continue;
            case PM_CONTEXT_SCLASS_ELSE:
            case PM_CONTEXT_SCLASS_ENSURE:
            case PM_CONTEXT_SCLASS_RESCUE:
            case PM_CONTEXT_SCLASS:
                in_sclass = true;
                continue;
            case PM_CONTEXT_CLASS_ELSE:
            case PM_CONTEXT_CLASS_ENSURE:
            case PM_CONTEXT_CLASS_RESCUE:
            case PM_CONTEXT_CLASS:
            case PM_CONTEXT_MODULE_ELSE:
            case PM_CONTEXT_MODULE_ENSURE:
            case PM_CONTEXT_MODULE_RESCUE:
            case PM_CONTEXT_MODULE:
                // These contexts are invalid for a return.
                pm_parser_err_node(parser, node, PM_ERR_RETURN_INVALID);
                return;
            case PM_CONTEXT_BLOCK_BRACES:
            case PM_CONTEXT_BLOCK_ELSE:
            case PM_CONTEXT_BLOCK_ENSURE:
            case PM_CONTEXT_BLOCK_KEYWORDS:
            case PM_CONTEXT_BLOCK_RESCUE:
            case PM_CONTEXT_DEF_ELSE:
            case PM_CONTEXT_DEF_ENSURE:
            case PM_CONTEXT_DEF_PARAMS:
            case PM_CONTEXT_DEF_RESCUE:
            case PM_CONTEXT_DEF:
            case PM_CONTEXT_LAMBDA_BRACES:
            case PM_CONTEXT_LAMBDA_DO_END:
            case PM_CONTEXT_LAMBDA_ELSE:
            case PM_CONTEXT_LAMBDA_ENSURE:
            case PM_CONTEXT_LAMBDA_RESCUE:
                // These contexts are valid for a return, and we should not
                // continue to loop.
                return;
            case PM_CONTEXT_NONE:
                // This case should never happen.
                assert(false && "unreachable");
                break;
        }
    }
    if (in_sclass) {
        pm_parser_err_node(parser, node, PM_ERR_RETURN_INVALID);
    }
}

/**
 * Check that the block exit (next, break, redo) is allowed in the current
 * context. If it isn't, add an error to the parser.
 */
static void
parse_block_exit(pm_parser_t *parser, pm_node_t *node) {
    for (pm_context_node_t *context_node = parser->current_context; context_node != NULL; context_node = context_node->prev) {
        switch (context_node->context) {
            case PM_CONTEXT_BLOCK_BRACES:
            case PM_CONTEXT_BLOCK_KEYWORDS:
            case PM_CONTEXT_BLOCK_ELSE:
            case PM_CONTEXT_BLOCK_ENSURE:
            case PM_CONTEXT_BLOCK_RESCUE:
            case PM_CONTEXT_DEFINED:
            case PM_CONTEXT_FOR:
            case PM_CONTEXT_LAMBDA_BRACES:
            case PM_CONTEXT_LAMBDA_DO_END:
            case PM_CONTEXT_LAMBDA_ELSE:
            case PM_CONTEXT_LAMBDA_ENSURE:
            case PM_CONTEXT_LAMBDA_RESCUE:
            case PM_CONTEXT_LOOP_PREDICATE:
            case PM_CONTEXT_POSTEXE:
            case PM_CONTEXT_UNTIL:
            case PM_CONTEXT_WHILE:
                // These are the good cases. We're allowed to have a block exit
                // in these contexts.
                return;
            case PM_CONTEXT_DEF:
            case PM_CONTEXT_DEF_PARAMS:
            case PM_CONTEXT_DEF_ELSE:
            case PM_CONTEXT_DEF_ENSURE:
            case PM_CONTEXT_DEF_RESCUE:
            case PM_CONTEXT_MAIN:
            case PM_CONTEXT_PREEXE:
            case PM_CONTEXT_SCLASS:
            case PM_CONTEXT_SCLASS_ELSE:
            case PM_CONTEXT_SCLASS_ENSURE:
            case PM_CONTEXT_SCLASS_RESCUE:
                // These are the bad cases. We're not allowed to have a block
                // exit in these contexts.
                //
                // If we get here, then we're about to mark this block exit
                // as invalid. However, it could later _become_ valid if we
                // find a trailing while/until on the expression. In this
                // case instead of adding the error here, we'll add the
                // block exit to the list of exits for the expression, and
                // the node parsing will handle validating it instead.
                assert(parser->current_block_exits != NULL);
                pm_node_list_append(parser->current_block_exits, node);
                return;
            case PM_CONTEXT_BEGIN_ELSE:
            case PM_CONTEXT_BEGIN_ENSURE:
            case PM_CONTEXT_BEGIN_RESCUE:
            case PM_CONTEXT_BEGIN:
            case PM_CONTEXT_CASE_IN:
            case PM_CONTEXT_CASE_WHEN:
            case PM_CONTEXT_CLASS_ELSE:
            case PM_CONTEXT_CLASS_ENSURE:
            case PM_CONTEXT_CLASS_RESCUE:
            case PM_CONTEXT_CLASS:
            case PM_CONTEXT_DEFAULT_PARAMS:
            case PM_CONTEXT_ELSE:
            case PM_CONTEXT_ELSIF:
            case PM_CONTEXT_EMBEXPR:
            case PM_CONTEXT_FOR_INDEX:
            case PM_CONTEXT_IF:
            case PM_CONTEXT_MODULE_ELSE:
            case PM_CONTEXT_MODULE_ENSURE:
            case PM_CONTEXT_MODULE_RESCUE:
            case PM_CONTEXT_MODULE:
            case PM_CONTEXT_MULTI_TARGET:
            case PM_CONTEXT_PARENS:
            case PM_CONTEXT_PREDICATE:
            case PM_CONTEXT_RESCUE_MODIFIER:
            case PM_CONTEXT_TERNARY:
            case PM_CONTEXT_UNLESS:
                // In these contexts we should continue walking up the list of
                // contexts.
                break;
            case PM_CONTEXT_NONE:
                // This case should never happen.
                assert(false && "unreachable");
                break;
        }
    }
}

/**
 * When we hit an expression that could contain block exits, we need to stash
 * the previous set and create a new one.
 */
static pm_node_list_t *
push_block_exits(pm_parser_t *parser, pm_node_list_t *current_block_exits) {
    pm_node_list_t *previous_block_exits = parser->current_block_exits;
    parser->current_block_exits = current_block_exits;
    return previous_block_exits;
}

/**
 * If we did not match a trailing while/until and this was the last chance to do
 * so, then all of the block exits in the list are invalid and we need to add an
 * error for each of them.
 */
static void
flush_block_exits(pm_parser_t *parser, pm_node_list_t *previous_block_exits) {
    pm_node_t *block_exit;
    PM_NODE_LIST_FOREACH(parser->current_block_exits, index, block_exit) {
        const char *type;

        switch (PM_NODE_TYPE(block_exit)) {
            case PM_BREAK_NODE: type = "break"; break;
            case PM_NEXT_NODE: type = "next"; break;
            case PM_REDO_NODE: type = "redo"; break;
            default: assert(false && "unreachable"); type = ""; break;
        }

        PM_PARSER_ERR_NODE_FORMAT(parser, block_exit, PM_ERR_INVALID_BLOCK_EXIT, type);
    }

    parser->current_block_exits = previous_block_exits;
}

/**
 * Pop the current level of block exits from the parser, and add errors to the
 * parser if any of them are deemed to be invalid.
 */
static void
pop_block_exits(pm_parser_t *parser, pm_node_list_t *previous_block_exits) {
    if (match2(parser, PM_TOKEN_KEYWORD_WHILE_MODIFIER, PM_TOKEN_KEYWORD_UNTIL_MODIFIER)) {
        // If we matched a trailing while/until, then all of the block exits in
        // the contained list are valid. In this case we do not need to do
        // anything.
        parser->current_block_exits = previous_block_exits;
    } else if (previous_block_exits != NULL) {
        // If we did not matching a trailing while/until, then all of the block
        // exits contained in the list are invalid for this specific context.
        // However, they could still become valid in a higher level context if
        // there is another list above this one. In this case we'll push all of
        // the block exits up to the previous list.
        pm_node_list_concat(previous_block_exits, parser->current_block_exits);
        parser->current_block_exits = previous_block_exits;
    } else {
        // If we did not match a trailing while/until and this was the last
        // chance to do so, then all of the block exits in the list are invalid
        // and we need to add an error for each of them.
        flush_block_exits(parser, previous_block_exits);
    }
}

static inline pm_node_t *
parse_predicate(pm_parser_t *parser, pm_binding_power_t binding_power, pm_context_t context, pm_token_t *then_keyword, uint16_t depth) {
    context_push(parser, PM_CONTEXT_PREDICATE);
    pm_diagnostic_id_t error_id = context == PM_CONTEXT_IF ? PM_ERR_CONDITIONAL_IF_PREDICATE : PM_ERR_CONDITIONAL_UNLESS_PREDICATE;
    pm_node_t *predicate = parse_value_expression(parser, binding_power, true, false, error_id, (uint16_t) (depth + 1));

    // Predicates are closed by a term, a "then", or a term and then a "then".
    bool predicate_closed = accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);

    if (accept1(parser, PM_TOKEN_KEYWORD_THEN)) {
        predicate_closed = true;
        *then_keyword = parser->previous;
    }

    if (!predicate_closed) {
        pm_parser_err_current(parser, PM_ERR_CONDITIONAL_PREDICATE_TERM);
    }

    context_pop(parser);
    return predicate;
}

static inline pm_node_t *
parse_conditional(pm_parser_t *parser, pm_context_t context, size_t opening_newline_index, bool if_after_else, uint16_t depth) {
    pm_node_list_t current_block_exits = { 0 };
    pm_node_list_t *previous_block_exits = push_block_exits(parser, ¤t_block_exits);

    pm_token_t keyword = parser->previous;
    pm_token_t then_keyword = not_provided(parser);

    pm_node_t *predicate = parse_predicate(parser, PM_BINDING_POWER_MODIFIER, context, &then_keyword, (uint16_t) (depth + 1));
    pm_statements_node_t *statements = NULL;

    if (!match3(parser, PM_TOKEN_KEYWORD_ELSIF, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
        pm_accepts_block_stack_push(parser, true);
        statements = parse_statements(parser, context, (uint16_t) (depth + 1));
        pm_accepts_block_stack_pop(parser);
        accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
    }

    pm_token_t end_keyword = not_provided(parser);
    pm_node_t *parent = NULL;

    switch (context) {
        case PM_CONTEXT_IF:
            parent = (pm_node_t *) pm_if_node_create(parser, &keyword, predicate, &then_keyword, statements, NULL, &end_keyword);
            break;
        case PM_CONTEXT_UNLESS:
            parent = (pm_node_t *) pm_unless_node_create(parser, &keyword, predicate, &then_keyword, statements);
            break;
        default:
            assert(false && "unreachable");
            break;
    }

    pm_node_t *current = parent;

    // Parse any number of elsif clauses. This will form a linked list of if
    // nodes pointing to each other from the top.
    if (context == PM_CONTEXT_IF) {
        while (match1(parser, PM_TOKEN_KEYWORD_ELSIF)) {
            if (parser_end_of_line_p(parser)) {
                PM_PARSER_WARN_TOKEN_FORMAT_CONTENT(parser, parser->current, PM_WARN_KEYWORD_EOL);
            }

            parser_warn_indentation_mismatch(parser, opening_newline_index, &keyword, false, false);
            pm_token_t elsif_keyword = parser->current;
            parser_lex(parser);

            pm_node_t *predicate = parse_predicate(parser, PM_BINDING_POWER_MODIFIER, PM_CONTEXT_ELSIF, &then_keyword, (uint16_t) (depth + 1));
            pm_accepts_block_stack_push(parser, true);

            pm_statements_node_t *statements = parse_statements(parser, PM_CONTEXT_ELSIF, (uint16_t) (depth + 1));
            pm_accepts_block_stack_pop(parser);
            accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);

            pm_node_t *elsif = (pm_node_t *) pm_if_node_create(parser, &elsif_keyword, predicate, &then_keyword, statements, NULL, &end_keyword);
            ((pm_if_node_t *) current)->subsequent = elsif;
            current = elsif;
        }
    }

    if (match1(parser, PM_TOKEN_KEYWORD_ELSE)) {
        parser_warn_indentation_mismatch(parser, opening_newline_index, &keyword, false, false);
        opening_newline_index = token_newline_index(parser);

        parser_lex(parser);
        pm_token_t else_keyword = parser->previous;

        pm_accepts_block_stack_push(parser, true);
        pm_statements_node_t *else_statements = parse_statements(parser, PM_CONTEXT_ELSE, (uint16_t) (depth + 1));
        pm_accepts_block_stack_pop(parser);

        accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
        parser_warn_indentation_mismatch(parser, opening_newline_index, &else_keyword, false, false);
        expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CONDITIONAL_TERM_ELSE);

        pm_else_node_t *else_node = pm_else_node_create(parser, &else_keyword, else_statements, &parser->previous);

        switch (context) {
            case PM_CONTEXT_IF:
                ((pm_if_node_t *) current)->subsequent = (pm_node_t *) else_node;
                break;
            case PM_CONTEXT_UNLESS:
                ((pm_unless_node_t *) parent)->else_clause = else_node;
                break;
            default:
                assert(false && "unreachable");
                break;
        }
    } else {
        parser_warn_indentation_mismatch(parser, opening_newline_index, &keyword, if_after_else, false);
        expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CONDITIONAL_TERM);
    }

    // Set the appropriate end location for all of the nodes in the subtree.
    switch (context) {
        case PM_CONTEXT_IF: {
            pm_node_t *current = parent;
            bool recursing = true;

            while (recursing) {
                switch (PM_NODE_TYPE(current)) {
                    case PM_IF_NODE:
                        pm_if_node_end_keyword_loc_set((pm_if_node_t *) current, &parser->previous);
                        current = ((pm_if_node_t *) current)->subsequent;
                        recursing = current != NULL;
                        break;
                    case PM_ELSE_NODE:
                        pm_else_node_end_keyword_loc_set((pm_else_node_t *) current, &parser->previous);
                        recursing = false;
                        break;
                    default: {
                        recursing = false;
                        break;
                    }
                }
            }
            break;
        }
        case PM_CONTEXT_UNLESS:
            pm_unless_node_end_keyword_loc_set((pm_unless_node_t *) parent, &parser->previous);
            break;
        default:
            assert(false && "unreachable");
            break;
    }

    pop_block_exits(parser, previous_block_exits);
    pm_node_list_free(¤t_block_exits);

    return parent;
}

/**
 * This macro allows you to define a case statement for all of the keywords.
 * It's meant to be used in a switch statement.
 */
#define PM_CASE_KEYWORD PM_TOKEN_KEYWORD___ENCODING__: case PM_TOKEN_KEYWORD___FILE__: case PM_TOKEN_KEYWORD___LINE__: \
    case PM_TOKEN_KEYWORD_ALIAS: case PM_TOKEN_KEYWORD_AND: case PM_TOKEN_KEYWORD_BEGIN: case PM_TOKEN_KEYWORD_BEGIN_UPCASE: \
    case PM_TOKEN_KEYWORD_BREAK: case PM_TOKEN_KEYWORD_CASE: case PM_TOKEN_KEYWORD_CLASS: case PM_TOKEN_KEYWORD_DEF: \
    case PM_TOKEN_KEYWORD_DEFINED: case PM_TOKEN_KEYWORD_DO: case PM_TOKEN_KEYWORD_DO_LOOP: case PM_TOKEN_KEYWORD_ELSE: \
    case PM_TOKEN_KEYWORD_ELSIF: case PM_TOKEN_KEYWORD_END: case PM_TOKEN_KEYWORD_END_UPCASE: case PM_TOKEN_KEYWORD_ENSURE: \
    case PM_TOKEN_KEYWORD_FALSE: case PM_TOKEN_KEYWORD_FOR: case PM_TOKEN_KEYWORD_IF: case PM_TOKEN_KEYWORD_IN: \
    case PM_TOKEN_KEYWORD_MODULE: case PM_TOKEN_KEYWORD_NEXT: case PM_TOKEN_KEYWORD_NIL: case PM_TOKEN_KEYWORD_NOT: \
    case PM_TOKEN_KEYWORD_OR: case PM_TOKEN_KEYWORD_REDO: case PM_TOKEN_KEYWORD_RESCUE: case PM_TOKEN_KEYWORD_RETRY: \
    case PM_TOKEN_KEYWORD_RETURN: case PM_TOKEN_KEYWORD_SELF: case PM_TOKEN_KEYWORD_SUPER: case PM_TOKEN_KEYWORD_THEN: \
    case PM_TOKEN_KEYWORD_TRUE: case PM_TOKEN_KEYWORD_UNDEF: case PM_TOKEN_KEYWORD_UNLESS: case PM_TOKEN_KEYWORD_UNTIL: \
    case PM_TOKEN_KEYWORD_WHEN: case PM_TOKEN_KEYWORD_WHILE: case PM_TOKEN_KEYWORD_YIELD

/**
 * This macro allows you to define a case statement for all of the operators.
 * It's meant to be used in a switch statement.
 */
#define PM_CASE_OPERATOR PM_TOKEN_AMPERSAND: case PM_TOKEN_BACKTICK: case PM_TOKEN_BANG_EQUAL: \
    case PM_TOKEN_BANG_TILDE: case PM_TOKEN_BANG: case PM_TOKEN_BRACKET_LEFT_RIGHT_EQUAL: \
    case PM_TOKEN_BRACKET_LEFT_RIGHT: case PM_TOKEN_CARET: case PM_TOKEN_EQUAL_EQUAL_EQUAL: case PM_TOKEN_EQUAL_EQUAL: \
    case PM_TOKEN_EQUAL_TILDE: case PM_TOKEN_GREATER_EQUAL: case PM_TOKEN_GREATER_GREATER: case PM_TOKEN_GREATER: \
    case PM_TOKEN_LESS_EQUAL_GREATER: case PM_TOKEN_LESS_EQUAL: case PM_TOKEN_LESS_LESS: case PM_TOKEN_LESS: \
    case PM_TOKEN_MINUS: case PM_TOKEN_PERCENT: case PM_TOKEN_PIPE: case PM_TOKEN_PLUS: case PM_TOKEN_SLASH: \
    case PM_TOKEN_STAR_STAR: case PM_TOKEN_STAR: case PM_TOKEN_TILDE: case PM_TOKEN_UAMPERSAND: case PM_TOKEN_UMINUS: \
    case PM_TOKEN_UMINUS_NUM: case PM_TOKEN_UPLUS: case PM_TOKEN_USTAR: case PM_TOKEN_USTAR_STAR

/**
 * This macro allows you to define a case statement for all of the token types
 * that represent the beginning of nodes that are "primitives" in a pattern
 * matching expression.
 */
#define PM_CASE_PRIMITIVE PM_TOKEN_INTEGER: case PM_TOKEN_INTEGER_IMAGINARY: case PM_TOKEN_INTEGER_RATIONAL: \
    case PM_TOKEN_INTEGER_RATIONAL_IMAGINARY: case PM_TOKEN_FLOAT: case PM_TOKEN_FLOAT_IMAGINARY: \
    case PM_TOKEN_FLOAT_RATIONAL: case PM_TOKEN_FLOAT_RATIONAL_IMAGINARY: case PM_TOKEN_SYMBOL_BEGIN: \
    case PM_TOKEN_REGEXP_BEGIN: case PM_TOKEN_BACKTICK: case PM_TOKEN_PERCENT_LOWER_X: case PM_TOKEN_PERCENT_LOWER_I: \
    case PM_TOKEN_PERCENT_LOWER_W: case PM_TOKEN_PERCENT_UPPER_I: case PM_TOKEN_PERCENT_UPPER_W: \
    case PM_TOKEN_STRING_BEGIN: case PM_TOKEN_KEYWORD_NIL: case PM_TOKEN_KEYWORD_SELF: case PM_TOKEN_KEYWORD_TRUE: \
    case PM_TOKEN_KEYWORD_FALSE: case PM_TOKEN_KEYWORD___FILE__: case PM_TOKEN_KEYWORD___LINE__: \
    case PM_TOKEN_KEYWORD___ENCODING__: case PM_TOKEN_MINUS_GREATER: case PM_TOKEN_HEREDOC_START: \
    case PM_TOKEN_UMINUS_NUM: case PM_TOKEN_CHARACTER_LITERAL

/**
 * This macro allows you to define a case statement for all of the token types
 * that could begin a parameter.
 */
#define PM_CASE_PARAMETER PM_TOKEN_UAMPERSAND: case PM_TOKEN_AMPERSAND: case PM_TOKEN_UDOT_DOT_DOT: \
    case PM_TOKEN_IDENTIFIER: case PM_TOKEN_LABEL: case PM_TOKEN_USTAR: case PM_TOKEN_STAR: case PM_TOKEN_STAR_STAR: \
    case PM_TOKEN_USTAR_STAR: case PM_TOKEN_CONSTANT: case PM_TOKEN_INSTANCE_VARIABLE: case PM_TOKEN_GLOBAL_VARIABLE: \
    case PM_TOKEN_CLASS_VARIABLE

/**
 * This macro allows you to define a case statement for all of the nodes that
 * can be transformed into write targets.
 */
#define PM_CASE_WRITABLE PM_CLASS_VARIABLE_READ_NODE: case PM_CONSTANT_PATH_NODE: \
    case PM_CONSTANT_READ_NODE: case PM_GLOBAL_VARIABLE_READ_NODE: case PM_LOCAL_VARIABLE_READ_NODE: \
    case PM_INSTANCE_VARIABLE_READ_NODE: case PM_MULTI_TARGET_NODE: case PM_BACK_REFERENCE_READ_NODE: \
    case PM_NUMBERED_REFERENCE_READ_NODE: case PM_IT_LOCAL_VARIABLE_READ_NODE

// Assert here that the flags are the same so that we can safely switch the type
// of the node without having to move the flags.
PM_STATIC_ASSERT(__LINE__, ((int) PM_STRING_FLAGS_FORCED_UTF8_ENCODING) == ((int) PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING), "Expected the flags to match.");

/**
 * If the encoding was explicitly set through the lexing process, then we need
 * to potentially mark the string's flags to indicate how to encode it.
 */
static inline pm_node_flags_t
parse_unescaped_encoding(const pm_parser_t *parser) {
    if (parser->explicit_encoding != NULL) {
        if (parser->explicit_encoding == PM_ENCODING_UTF_8_ENTRY) {
            // If the there's an explicit encoding and it's using a UTF-8 escape
            // sequence, then mark the string as UTF-8.
            return PM_STRING_FLAGS_FORCED_UTF8_ENCODING;
        } else if (parser->encoding == PM_ENCODING_US_ASCII_ENTRY) {
            // If there's a non-UTF-8 escape sequence being used, then the
            // string uses the source encoding, unless the source is marked as
            // US-ASCII. In that case the string is forced as ASCII-8BIT in
            // order to keep the string valid.
            return PM_STRING_FLAGS_FORCED_BINARY_ENCODING;
        }
    }
    return 0;
}

/**
 * Parse a node that is part of a string. If the subsequent tokens cannot be
 * parsed as a string part, then NULL is returned.
 */
static pm_node_t *
parse_string_part(pm_parser_t *parser, uint16_t depth) {
    switch (parser->current.type) {
        // Here the lexer has returned to us plain string content. In this case
        // we'll create a string node that has no opening or closing and return that
        // as the part. These kinds of parts look like:
        //
        //     "aaa #{bbb} #@ccc ddd"
        //      ^^^^      ^     ^^^^
        case PM_TOKEN_STRING_CONTENT: {
            pm_token_t opening = not_provided(parser);
            pm_token_t closing = not_provided(parser);

            pm_node_t *node = (pm_node_t *) pm_string_node_create_current_string(parser, &opening, &parser->current, &closing);
            pm_node_flag_set(node, parse_unescaped_encoding(parser));

            parser_lex(parser);
            return node;
        }
        // Here the lexer has returned the beginning of an embedded expression. In
        // that case we'll parse the inner statements and return that as the part.
        // These kinds of parts look like:
        //
        //     "aaa #{bbb} #@ccc ddd"
        //          ^^^^^^
        case PM_TOKEN_EMBEXPR_BEGIN: {
            // Ruby disallows seeing encoding around interpolation in strings,
            // even though it is known at parse time.
            parser->explicit_encoding = NULL;

            pm_lex_state_t state = parser->lex_state;
            int brace_nesting = parser->brace_nesting;

            parser->brace_nesting = 0;
            lex_state_set(parser, PM_LEX_STATE_BEG);
            parser_lex(parser);

            pm_token_t opening = parser->previous;
            pm_statements_node_t *statements = NULL;

            if (!match1(parser, PM_TOKEN_EMBEXPR_END)) {
                pm_accepts_block_stack_push(parser, true);
                statements = parse_statements(parser, PM_CONTEXT_EMBEXPR, (uint16_t) (depth + 1));
                pm_accepts_block_stack_pop(parser);
            }

            parser->brace_nesting = brace_nesting;
            lex_state_set(parser, state);

            expect1(parser, PM_TOKEN_EMBEXPR_END, PM_ERR_EMBEXPR_END);
            pm_token_t closing = parser->previous;

            // If this set of embedded statements only contains a single
            // statement, then Ruby does not consider it as a possible statement
            // that could emit a line event.
            if (statements != NULL && statements->body.size == 1) {
                pm_node_flag_unset(statements->body.nodes[0], PM_NODE_FLAG_NEWLINE);
            }

            return (pm_node_t *) pm_embedded_statements_node_create(parser, &opening, statements, &closing);
        }

        // Here the lexer has returned the beginning of an embedded variable.
        // In that case we'll parse the variable and create an appropriate node
        // for it and then return that node. These kinds of parts look like:
        //
        //     "aaa #{bbb} #@ccc ddd"
        //                 ^^^^^
        case PM_TOKEN_EMBVAR: {
            // Ruby disallows seeing encoding around interpolation in strings,
            // even though it is known at parse time.
            parser->explicit_encoding = NULL;

            lex_state_set(parser, PM_LEX_STATE_BEG);
            parser_lex(parser);

            pm_token_t operator = parser->previous;
            pm_node_t *variable;

            switch (parser->current.type) {
                // In this case a back reference is being interpolated. We'll
                // create a global variable read node.
                case PM_TOKEN_BACK_REFERENCE:
                    parser_lex(parser);
                    variable = (pm_node_t *) pm_back_reference_read_node_create(parser, &parser->previous);
                    break;
                // In this case an nth reference is being interpolated. We'll
                // create a global variable read node.
                case PM_TOKEN_NUMBERED_REFERENCE:
                    parser_lex(parser);
                    variable = (pm_node_t *) pm_numbered_reference_read_node_create(parser, &parser->previous);
                    break;
                // In this case a global variable is being interpolated. We'll
                // create a global variable read node.
                case PM_TOKEN_GLOBAL_VARIABLE:
                    parser_lex(parser);
                    variable = (pm_node_t *) pm_global_variable_read_node_create(parser, &parser->previous);
                    break;
                // In this case an instance variable is being interpolated.
                // We'll create an instance variable read node.
                case PM_TOKEN_INSTANCE_VARIABLE:
                    parser_lex(parser);
                    variable = (pm_node_t *) pm_instance_variable_read_node_create(parser, &parser->previous);
                    break;
                // In this case a class variable is being interpolated. We'll
                // create a class variable read node.
                case PM_TOKEN_CLASS_VARIABLE:
                    parser_lex(parser);
                    variable = (pm_node_t *) pm_class_variable_read_node_create(parser, &parser->previous);
                    break;
                // We can hit here if we got an invalid token. In that case
                // we'll not attempt to lex this token and instead just return a
                // missing node.
                default:
                    expect1(parser, PM_TOKEN_IDENTIFIER, PM_ERR_EMBVAR_INVALID);
                    variable = (pm_node_t *) pm_missing_node_create(parser, parser->current.start, parser->current.end);
                    break;
            }

            return (pm_node_t *) pm_embedded_variable_node_create(parser, &operator, variable);
        }
        default:
            parser_lex(parser);
            pm_parser_err_previous(parser, PM_ERR_CANNOT_PARSE_STRING_PART);
            return NULL;
    }
}

/**
 * When creating a symbol, unary operators that cannot be binary operators
 * automatically drop trailing `@` characters. This happens at the parser level,
 * such that `~@` is parsed as `~` and `!@` is parsed as `!`. We do that here.
 */
static const uint8_t *
parse_operator_symbol_name(const pm_token_t *name) {
    switch (name->type) {
        case PM_TOKEN_TILDE:
        case PM_TOKEN_BANG:
            if (name->end[-1] == '@') return name->end - 1;
        PRISM_FALLTHROUGH
        default:
            return name->end;
    }
}

static pm_node_t *
parse_operator_symbol(pm_parser_t *parser, const pm_token_t *opening, pm_lex_state_t next_state) {
    pm_token_t closing = not_provided(parser);
    pm_symbol_node_t *symbol = pm_symbol_node_create(parser, opening, &parser->current, &closing);

    const uint8_t *end = parse_operator_symbol_name(&parser->current);

    if (next_state != PM_LEX_STATE_NONE) lex_state_set(parser, next_state);
    parser_lex(parser);

    pm_string_shared_init(&symbol->unescaped, parser->previous.start, end);
    pm_node_flag_set((pm_node_t *) symbol, PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING);

    return (pm_node_t *) symbol;
}

/**
 * Parse a symbol node. This function will get called immediately after finding
 * a symbol opening token. This handles parsing bare symbols and interpolated
 * symbols.
 */
static pm_node_t *
parse_symbol(pm_parser_t *parser, pm_lex_mode_t *lex_mode, pm_lex_state_t next_state, uint16_t depth) {
    const pm_token_t opening = parser->previous;

    if (lex_mode->mode != PM_LEX_STRING) {
        if (next_state != PM_LEX_STATE_NONE) lex_state_set(parser, next_state);

        switch (parser->current.type) {
            case PM_CASE_OPERATOR:
                return parse_operator_symbol(parser, &opening, next_state == PM_LEX_STATE_NONE ? PM_LEX_STATE_ENDFN : next_state);
            case PM_TOKEN_IDENTIFIER:
            case PM_TOKEN_CONSTANT:
            case PM_TOKEN_INSTANCE_VARIABLE:
            case PM_TOKEN_METHOD_NAME:
            case PM_TOKEN_CLASS_VARIABLE:
            case PM_TOKEN_GLOBAL_VARIABLE:
            case PM_TOKEN_NUMBERED_REFERENCE:
            case PM_TOKEN_BACK_REFERENCE:
            case PM_CASE_KEYWORD:
                parser_lex(parser);
                break;
            default:
                expect2(parser, PM_TOKEN_IDENTIFIER, PM_TOKEN_METHOD_NAME, PM_ERR_SYMBOL_INVALID);
                break;
        }

        pm_token_t closing = not_provided(parser);
        pm_symbol_node_t *symbol = pm_symbol_node_create(parser, &opening, &parser->previous, &closing);

        pm_string_shared_init(&symbol->unescaped, parser->previous.start, parser->previous.end);
        pm_node_flag_set((pm_node_t *) symbol, parse_symbol_encoding(parser, &parser->previous, &symbol->unescaped, false));

        return (pm_node_t *) symbol;
    }

    if (lex_mode->as.string.interpolation) {
        // If we have the end of the symbol, then we can return an empty symbol.
        if (match1(parser, PM_TOKEN_STRING_END)) {
            if (next_state != PM_LEX_STATE_NONE) lex_state_set(parser, next_state);
            parser_lex(parser);

            pm_token_t content = not_provided(parser);
            pm_token_t closing = parser->previous;
            return (pm_node_t *) pm_symbol_node_create(parser, &opening, &content, &closing);
        }

        // Now we can parse the first part of the symbol.
        pm_node_t *part = parse_string_part(parser, (uint16_t) (depth + 1));

        // If we got a string part, then it's possible that we could transform
        // what looks like an interpolated symbol into a regular symbol.
        if (part && PM_NODE_TYPE_P(part, PM_STRING_NODE) && match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
            if (next_state != PM_LEX_STATE_NONE) lex_state_set(parser, next_state);
            expect1(parser, PM_TOKEN_STRING_END, PM_ERR_SYMBOL_TERM_INTERPOLATED);

            return (pm_node_t *) pm_string_node_to_symbol_node(parser, (pm_string_node_t *) part, &opening, &parser->previous);
        }

        pm_interpolated_symbol_node_t *symbol = pm_interpolated_symbol_node_create(parser, &opening, NULL, &opening);
        if (part) pm_interpolated_symbol_node_append(symbol, part);

        while (!match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
            if ((part = parse_string_part(parser, (uint16_t) (depth + 1))) != NULL) {
                pm_interpolated_symbol_node_append(symbol, part);
            }
        }

        if (next_state != PM_LEX_STATE_NONE) lex_state_set(parser, next_state);
        if (match1(parser, PM_TOKEN_EOF)) {
            pm_parser_err_token(parser, &opening, PM_ERR_SYMBOL_TERM_INTERPOLATED);
        } else {
            expect1(parser, PM_TOKEN_STRING_END, PM_ERR_SYMBOL_TERM_INTERPOLATED);
        }

        pm_interpolated_symbol_node_closing_loc_set(symbol, &parser->previous);
        return (pm_node_t *) symbol;
    }

    pm_token_t content;
    pm_string_t unescaped;

    if (match1(parser, PM_TOKEN_STRING_CONTENT)) {
        content = parser->current;
        unescaped = parser->current_string;
        parser_lex(parser);

        // If we have two string contents in a row, then the content of this
        // symbol is split because of heredoc contents. This looks like:
        //
        // <current, &bounds, &parser->current_string);
            pm_interpolated_symbol_node_append(symbol, part);

            if (next_state != PM_LEX_STATE_NONE) {
                lex_state_set(parser, next_state);
            }

            parser_lex(parser);
            expect1(parser, PM_TOKEN_STRING_END, PM_ERR_SYMBOL_TERM_DYNAMIC);

            pm_interpolated_symbol_node_closing_loc_set(symbol, &parser->previous);
            return (pm_node_t *) symbol;
        }
    } else {
        content = (pm_token_t) { .type = PM_TOKEN_STRING_CONTENT, .start = parser->previous.end, .end = parser->previous.end };
        pm_string_shared_init(&unescaped, content.start, content.end);
    }

    if (next_state != PM_LEX_STATE_NONE) {
        lex_state_set(parser, next_state);
    }

    if (match1(parser, PM_TOKEN_EOF)) {
        pm_parser_err_token(parser, &opening, PM_ERR_SYMBOL_TERM_DYNAMIC);
    } else {
        expect1(parser, PM_TOKEN_STRING_END, PM_ERR_SYMBOL_TERM_DYNAMIC);
    }

    return (pm_node_t *) pm_symbol_node_create_unescaped(parser, &opening, &content, &parser->previous, &unescaped, parse_symbol_encoding(parser, &content, &unescaped, false));
}

/**
 * Parse an argument to undef which can either be a bare word, a symbol, a
 * constant, or an interpolated symbol.
 */
static inline pm_node_t *
parse_undef_argument(pm_parser_t *parser, uint16_t depth) {
    switch (parser->current.type) {
        case PM_CASE_OPERATOR: {
            const pm_token_t opening = not_provided(parser);
            return parse_operator_symbol(parser, &opening, PM_LEX_STATE_NONE);
        }
        case PM_CASE_KEYWORD:
        case PM_TOKEN_CONSTANT:
        case PM_TOKEN_IDENTIFIER:
        case PM_TOKEN_METHOD_NAME: {
            parser_lex(parser);

            pm_token_t opening = not_provided(parser);
            pm_token_t closing = not_provided(parser);
            pm_symbol_node_t *symbol = pm_symbol_node_create(parser, &opening, &parser->previous, &closing);

            pm_string_shared_init(&symbol->unescaped, parser->previous.start, parser->previous.end);
            pm_node_flag_set((pm_node_t *) symbol, parse_symbol_encoding(parser, &parser->previous, &symbol->unescaped, false));

            return (pm_node_t *) symbol;
        }
        case PM_TOKEN_SYMBOL_BEGIN: {
            pm_lex_mode_t lex_mode = *parser->lex_modes.current;
            parser_lex(parser);

            return parse_symbol(parser, &lex_mode, PM_LEX_STATE_NONE, (uint16_t) (depth + 1));
        }
        default:
            pm_parser_err_current(parser, PM_ERR_UNDEF_ARGUMENT);
            return (pm_node_t *) pm_missing_node_create(parser, parser->current.start, parser->current.end);
    }
}

/**
 * Parse an argument to alias which can either be a bare word, a symbol, an
 * interpolated symbol or a global variable. If this is the first argument, then
 * we need to set the lex state to PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM
 * between the first and second arguments.
 */
static inline pm_node_t *
parse_alias_argument(pm_parser_t *parser, bool first, uint16_t depth) {
    switch (parser->current.type) {
        case PM_CASE_OPERATOR: {
            const pm_token_t opening = not_provided(parser);
            return parse_operator_symbol(parser, &opening, first ? PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM : PM_LEX_STATE_NONE);
        }
        case PM_CASE_KEYWORD:
        case PM_TOKEN_CONSTANT:
        case PM_TOKEN_IDENTIFIER:
        case PM_TOKEN_METHOD_NAME: {
            if (first) lex_state_set(parser, PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM);
            parser_lex(parser);

            pm_token_t opening = not_provided(parser);
            pm_token_t closing = not_provided(parser);
            pm_symbol_node_t *symbol = pm_symbol_node_create(parser, &opening, &parser->previous, &closing);

            pm_string_shared_init(&symbol->unescaped, parser->previous.start, parser->previous.end);
            pm_node_flag_set((pm_node_t *) symbol, parse_symbol_encoding(parser, &parser->previous, &symbol->unescaped, false));

            return (pm_node_t *) symbol;
        }
        case PM_TOKEN_SYMBOL_BEGIN: {
            pm_lex_mode_t lex_mode = *parser->lex_modes.current;
            parser_lex(parser);

            return parse_symbol(parser, &lex_mode, first ? PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM : PM_LEX_STATE_NONE, (uint16_t) (depth + 1));
        }
        case PM_TOKEN_BACK_REFERENCE:
            parser_lex(parser);
            return (pm_node_t *) pm_back_reference_read_node_create(parser, &parser->previous);
        case PM_TOKEN_NUMBERED_REFERENCE:
            parser_lex(parser);
            return (pm_node_t *) pm_numbered_reference_read_node_create(parser, &parser->previous);
        case PM_TOKEN_GLOBAL_VARIABLE:
            parser_lex(parser);
            return (pm_node_t *) pm_global_variable_read_node_create(parser, &parser->previous);
        default:
            pm_parser_err_current(parser, PM_ERR_ALIAS_ARGUMENT);
            return (pm_node_t *) pm_missing_node_create(parser, parser->current.start, parser->current.end);
    }
}

/**
 * Parse an identifier into either a local variable read. If the local variable
 * is not found, it returns NULL instead.
 */
static pm_node_t *
parse_variable(pm_parser_t *parser) {
    pm_constant_id_t name_id = pm_parser_constant_id_token(parser, &parser->previous);
    int depth;
    bool is_numbered_param = pm_token_is_numbered_parameter(parser->previous.start, parser->previous.end);

    if (!is_numbered_param && ((depth = pm_parser_local_depth_constant_id(parser, name_id)) != -1)) {
        return (pm_node_t *) pm_local_variable_read_node_create_constant_id(parser, &parser->previous, name_id, (uint32_t) depth, false);
    }

    pm_scope_t *current_scope = parser->current_scope;
    if (!current_scope->closed && !(current_scope->parameters & PM_SCOPE_PARAMETERS_IMPLICIT_DISALLOWED)) {
        if (is_numbered_param) {
            // When you use a numbered parameter, it implies the existence of
            // all of the locals that exist before it. For example, referencing
            // _2 means that _1 must exist. Therefore here we loop through all
            // of the possibilities and add them into the constant pool.
            uint8_t maximum = (uint8_t) (parser->previous.start[1] - '0');
            for (uint8_t number = 1; number <= maximum; number++) {
                pm_parser_local_add_constant(parser, pm_numbered_parameter_names[number - 1], 2);
            }

            if (!match1(parser, PM_TOKEN_EQUAL)) {
                parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_NUMBERED_FOUND;
            }

            pm_node_t *node = (pm_node_t *) pm_local_variable_read_node_create_constant_id(parser, &parser->previous, name_id, 0, false);
            pm_node_list_append(¤t_scope->implicit_parameters, node);

            return node;
        } else if ((parser->version >= PM_OPTIONS_VERSION_CRUBY_3_4) && pm_token_is_it(parser->previous.start, parser->previous.end)) {
            pm_node_t *node = (pm_node_t *) pm_it_local_variable_read_node_create(parser, &parser->previous);
            pm_node_list_append(¤t_scope->implicit_parameters, node);

            return node;
        }
    }

    return NULL;
}

/**
 * Parse an identifier into either a local variable read or a call.
 */
static pm_node_t *
parse_variable_call(pm_parser_t *parser) {
    pm_node_flags_t flags = 0;

    if (!match1(parser, PM_TOKEN_PARENTHESIS_LEFT) && (parser->previous.end[-1] != '!') && (parser->previous.end[-1] != '?')) {
        pm_node_t *node = parse_variable(parser);
        if (node != NULL) return node;
        flags |= PM_CALL_NODE_FLAGS_VARIABLE_CALL;
    }

    pm_call_node_t *node = pm_call_node_variable_call_create(parser, &parser->previous);
    pm_node_flag_set((pm_node_t *)node, flags);

    return (pm_node_t *) node;
}

/**
 * Parse the method definition name based on the current token available on the
 * parser. If it does not match a valid method definition name, then a missing
 * token is returned.
 */
static inline pm_token_t
parse_method_definition_name(pm_parser_t *parser) {
    switch (parser->current.type) {
        case PM_CASE_KEYWORD:
        case PM_TOKEN_CONSTANT:
        case PM_TOKEN_METHOD_NAME:
            parser_lex(parser);
            return parser->previous;
        case PM_TOKEN_IDENTIFIER:
            pm_refute_numbered_parameter(parser, parser->current.start, parser->current.end);
            parser_lex(parser);
            return parser->previous;
        case PM_CASE_OPERATOR:
            lex_state_set(parser, PM_LEX_STATE_ENDFN);
            parser_lex(parser);
            return parser->previous;
        default:
            PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_DEF_NAME, pm_token_type_human(parser->current.type));
            return (pm_token_t) { .type = PM_TOKEN_MISSING, .start = parser->current.start, .end = parser->current.end };
    }
}

static void
parse_heredoc_dedent_string(pm_string_t *string, size_t common_whitespace) {
    // Get a reference to the string struct that is being held by the string
    // node. This is the value we're going to actually manipulate.
    pm_string_ensure_owned(string);

    // Now get the bounds of the existing string. We'll use this as a
    // destination to move bytes into. We'll also use it for bounds checking
    // since we don't require that these strings be null terminated.
    size_t dest_length = pm_string_length(string);
    const uint8_t *source_cursor = (uint8_t *) string->source;
    const uint8_t *source_end = source_cursor + dest_length;

    // We're going to move bytes backward in the string when we get leading
    // whitespace, so we'll maintain a pointer to the current position in the
    // string that we're writing to.
    size_t trimmed_whitespace = 0;

    // While we haven't reached the amount of common whitespace that we need to
    // trim and we haven't reached the end of the string, we'll keep trimming
    // whitespace. Trimming in this context means skipping over these bytes such
    // that they aren't copied into the new string.
    while ((source_cursor < source_end) && pm_char_is_inline_whitespace(*source_cursor) && trimmed_whitespace < common_whitespace) {
        if (*source_cursor == '\t') {
            trimmed_whitespace = (trimmed_whitespace / PM_TAB_WHITESPACE_SIZE + 1) * PM_TAB_WHITESPACE_SIZE;
            if (trimmed_whitespace > common_whitespace) break;
        } else {
            trimmed_whitespace++;
        }

        source_cursor++;
        dest_length--;
    }

    memmove((uint8_t *) string->source, source_cursor, (size_t) (source_end - source_cursor));
    string->length = dest_length;
}

/**
 * Take a heredoc node that is indented by a ~ and trim the leading whitespace.
 */
static void
parse_heredoc_dedent(pm_parser_t *parser, pm_node_list_t *nodes, size_t common_whitespace) {
    // The next node should be dedented if it's the first node in the list or if
    // it follows a string node.
    bool dedent_next = true;

    // Iterate over all nodes, and trim whitespace accordingly. We're going to
    // keep around two indices: a read and a write. If we end up trimming all of
    // the whitespace from a node, then we'll drop it from the list entirely.
    size_t write_index = 0;

    pm_node_t *node;
    PM_NODE_LIST_FOREACH(nodes, read_index, node) {
        // We're not manipulating child nodes that aren't strings. In this case
        // we'll skip past it and indicate that the subsequent node should not
        // be dedented.
        if (!PM_NODE_TYPE_P(node, PM_STRING_NODE)) {
            nodes->nodes[write_index++] = node;
            dedent_next = false;
            continue;
        }

        pm_string_node_t *string_node = ((pm_string_node_t *) node);
        if (dedent_next) {
            parse_heredoc_dedent_string(&string_node->unescaped, common_whitespace);
        }

        if (string_node->unescaped.length == 0) {
            pm_node_destroy(parser, node);
        } else {
            nodes->nodes[write_index++] = node;
        }

        // We always dedent the next node if it follows a string node.
        dedent_next = true;
    }

    nodes->size = write_index;
}

/**
 * Return a string content token at a particular location that is empty.
 */
static pm_token_t
parse_strings_empty_content(const uint8_t *location) {
    return (pm_token_t) { .type = PM_TOKEN_STRING_CONTENT, .start = location, .end = location };
}

/**
 * Parse a set of strings that could be concatenated together.
 */
static inline pm_node_t *
parse_strings(pm_parser_t *parser, pm_node_t *current, bool accepts_label, uint16_t depth) {
    assert(parser->current.type == PM_TOKEN_STRING_BEGIN);
    bool concating = false;

    while (match1(parser, PM_TOKEN_STRING_BEGIN)) {
        pm_node_t *node = NULL;

        // Here we have found a string literal. We'll parse it and add it to
        // the list of strings.
        const pm_lex_mode_t *lex_mode = parser->lex_modes.current;
        assert(lex_mode->mode == PM_LEX_STRING);
        bool lex_interpolation = lex_mode->as.string.interpolation;
        bool label_allowed = lex_mode->as.string.label_allowed && accepts_label;

        pm_token_t opening = parser->current;
        parser_lex(parser);

        if (match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
            expect1(parser, PM_TOKEN_STRING_END, PM_ERR_STRING_LITERAL_EOF);
            // If we get here, then we have an end immediately after a
            // start. In that case we'll create an empty content token and
            // return an uninterpolated string.
            pm_token_t content = parse_strings_empty_content(parser->previous.start);
            pm_string_node_t *string = pm_string_node_create(parser, &opening, &content, &parser->previous);

            pm_string_shared_init(&string->unescaped, content.start, content.end);
            node = (pm_node_t *) string;
        } else if (accept1(parser, PM_TOKEN_LABEL_END)) {
            // If we get here, then we have an end of a label immediately
            // after a start. In that case we'll create an empty symbol
            // node.
            pm_token_t content = parse_strings_empty_content(parser->previous.start);
            pm_symbol_node_t *symbol = pm_symbol_node_create(parser, &opening, &content, &parser->previous);

            pm_string_shared_init(&symbol->unescaped, content.start, content.end);
            node = (pm_node_t *) symbol;

            if (!label_allowed) pm_parser_err_node(parser, node, PM_ERR_UNEXPECTED_LABEL);
        } else if (!lex_interpolation) {
            // If we don't accept interpolation then we expect the string to
            // start with a single string content node.
            pm_string_t unescaped;
            pm_token_t content;

            if (match1(parser, PM_TOKEN_EOF)) {
                unescaped = PM_STRING_EMPTY;
                content = not_provided(parser);
            } else {
                unescaped = parser->current_string;
                expect1(parser, PM_TOKEN_STRING_CONTENT, PM_ERR_EXPECT_STRING_CONTENT);
                content = parser->previous;
            }

            // It is unfortunately possible to have multiple string content
            // nodes in a row in the case that there's heredoc content in
            // the middle of the string, like this cursed example:
            //
            // <<-END+'b
            //  a
            // END
            //  c'+'d'
            //
            // In that case we need to switch to an interpolated string to
            // be able to contain all of the parts.
            if (match1(parser, PM_TOKEN_STRING_CONTENT)) {
                pm_node_list_t parts = { 0 };

                pm_token_t delimiters = not_provided(parser);
                pm_node_t *part = (pm_node_t *) pm_string_node_create_unescaped(parser, &delimiters, &content, &delimiters, &unescaped);
                pm_node_list_append(&parts, part);

                do {
                    part = (pm_node_t *) pm_string_node_create_current_string(parser, &delimiters, &parser->current, &delimiters);
                    pm_node_list_append(&parts, part);
                    parser_lex(parser);
                } while (match1(parser, PM_TOKEN_STRING_CONTENT));

                expect1(parser, PM_TOKEN_STRING_END, PM_ERR_STRING_LITERAL_EOF);
                node = (pm_node_t *) pm_interpolated_string_node_create(parser, &opening, &parts, &parser->previous);

                pm_node_list_free(&parts);
            } else if (accept1(parser, PM_TOKEN_LABEL_END)) {
                node = (pm_node_t *) pm_symbol_node_create_unescaped(parser, &opening, &content, &parser->previous, &unescaped, parse_symbol_encoding(parser, &content, &unescaped, true));
                if (!label_allowed) pm_parser_err_node(parser, node, PM_ERR_UNEXPECTED_LABEL);
            } else if (match1(parser, PM_TOKEN_EOF)) {
                pm_parser_err_token(parser, &opening, PM_ERR_STRING_LITERAL_EOF);
                node = (pm_node_t *) pm_string_node_create_unescaped(parser, &opening, &content, &parser->current, &unescaped);
            } else if (accept1(parser, PM_TOKEN_STRING_END)) {
                node = (pm_node_t *) pm_string_node_create_unescaped(parser, &opening, &content, &parser->previous, &unescaped);
            } else {
                PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->previous, PM_ERR_STRING_LITERAL_TERM, pm_token_type_human(parser->previous.type));
                parser->previous.start = parser->previous.end;
                parser->previous.type = PM_TOKEN_MISSING;
                node = (pm_node_t *) pm_string_node_create_unescaped(parser, &opening, &content, &parser->previous, &unescaped);
            }
        } else if (match1(parser, PM_TOKEN_STRING_CONTENT)) {
            // In this case we've hit string content so we know the string
            // at least has something in it. We'll need to check if the
            // following token is the end (in which case we can return a
            // plain string) or if it's not then it has interpolation.
            pm_token_t content = parser->current;
            pm_string_t unescaped = parser->current_string;
            parser_lex(parser);

            if (match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
                node = (pm_node_t *) pm_string_node_create_unescaped(parser, &opening, &content, &parser->current, &unescaped);
                pm_node_flag_set(node, parse_unescaped_encoding(parser));

                // Kind of odd behavior, but basically if we have an
                // unterminated string and it ends in a newline, we back up one
                // character so that the error message is on the last line of
                // content in the string.
                if (!accept1(parser, PM_TOKEN_STRING_END)) {
                    const uint8_t *location = parser->previous.end;
                    if (location > parser->start && location[-1] == '\n') location--;
                    pm_parser_err(parser, location, location, PM_ERR_STRING_LITERAL_EOF);

                    parser->previous.start = parser->previous.end;
                    parser->previous.type = PM_TOKEN_MISSING;
                }
            } else if (accept1(parser, PM_TOKEN_LABEL_END)) {
                node = (pm_node_t *) pm_symbol_node_create_unescaped(parser, &opening, &content, &parser->previous, &unescaped, parse_symbol_encoding(parser, &content, &unescaped, true));
                if (!label_allowed) pm_parser_err_node(parser, node, PM_ERR_UNEXPECTED_LABEL);
            } else {
                // If we get here, then we have interpolation so we'll need
                // to create a string or symbol node with interpolation.
                pm_node_list_t parts = { 0 };
                pm_token_t string_opening = not_provided(parser);
                pm_token_t string_closing = not_provided(parser);

                pm_node_t *part = (pm_node_t *) pm_string_node_create_unescaped(parser, &string_opening, &parser->previous, &string_closing, &unescaped);
                pm_node_flag_set(part, parse_unescaped_encoding(parser));
                pm_node_list_append(&parts, part);

                while (!match3(parser, PM_TOKEN_STRING_END, PM_TOKEN_LABEL_END, PM_TOKEN_EOF)) {
                    if ((part = parse_string_part(parser, (uint16_t) (depth + 1))) != NULL) {
                        pm_node_list_append(&parts, part);
                    }
                }

                if (accept1(parser, PM_TOKEN_LABEL_END)) {
                    node = (pm_node_t *) pm_interpolated_symbol_node_create(parser, &opening, &parts, &parser->previous);
                    if (!label_allowed) pm_parser_err_node(parser, node, PM_ERR_UNEXPECTED_LABEL);
                } else if (match1(parser, PM_TOKEN_EOF)) {
                    pm_parser_err_token(parser, &opening, PM_ERR_STRING_INTERPOLATED_TERM);
                    node = (pm_node_t *) pm_interpolated_string_node_create(parser, &opening, &parts, &parser->current);
                } else {
                    expect1(parser, PM_TOKEN_STRING_END, PM_ERR_STRING_INTERPOLATED_TERM);
                    node = (pm_node_t *) pm_interpolated_string_node_create(parser, &opening, &parts, &parser->previous);
                }

                pm_node_list_free(&parts);
            }
        } else {
            // If we get here, then the first part of the string is not plain
            // string content, in which case we need to parse the string as an
            // interpolated string.
            pm_node_list_t parts = { 0 };
            pm_node_t *part;

            while (!match3(parser, PM_TOKEN_STRING_END, PM_TOKEN_LABEL_END, PM_TOKEN_EOF)) {
                if ((part = parse_string_part(parser, (uint16_t) (depth + 1))) != NULL) {
                    pm_node_list_append(&parts, part);
                }
            }

            if (accept1(parser, PM_TOKEN_LABEL_END)) {
                node = (pm_node_t *) pm_interpolated_symbol_node_create(parser, &opening, &parts, &parser->previous);
                if (!label_allowed) pm_parser_err_node(parser, node, PM_ERR_UNEXPECTED_LABEL);
            } else if (match1(parser, PM_TOKEN_EOF)) {
                pm_parser_err_token(parser, &opening, PM_ERR_STRING_INTERPOLATED_TERM);
                node = (pm_node_t *) pm_interpolated_string_node_create(parser, &opening, &parts, &parser->current);
            } else {
                expect1(parser, PM_TOKEN_STRING_END, PM_ERR_STRING_INTERPOLATED_TERM);
                node = (pm_node_t *) pm_interpolated_string_node_create(parser, &opening, &parts, &parser->previous);
            }

            pm_node_list_free(&parts);
        }

        if (current == NULL) {
            // If the node we just parsed is a symbol node, then we can't
            // concatenate it with anything else, so we can now return that
            // node.
            if (PM_NODE_TYPE_P(node, PM_SYMBOL_NODE) || PM_NODE_TYPE_P(node, PM_INTERPOLATED_SYMBOL_NODE)) {
                return node;
            }

            // If we don't already have a node, then it's fine and we can just
            // set the result to be the node we just parsed.
            current = node;
        } else {
            // Otherwise we need to check the type of the node we just parsed.
            // If it cannot be concatenated with the previous node, then we'll
            // need to add a syntax error.
            if (!PM_NODE_TYPE_P(node, PM_STRING_NODE) && !PM_NODE_TYPE_P(node, PM_INTERPOLATED_STRING_NODE)) {
                pm_parser_err_node(parser, node, PM_ERR_STRING_CONCATENATION);
            }

            // If we haven't already created our container for concatenation,
            // we'll do that now.
            if (!concating) {
                if (!PM_NODE_TYPE_P(current, PM_STRING_NODE) && !PM_NODE_TYPE_P(current, PM_INTERPOLATED_STRING_NODE)) {
                    pm_parser_err_node(parser, current, PM_ERR_STRING_CONCATENATION);
                }

                concating = true;
                pm_token_t bounds = not_provided(parser);

                pm_interpolated_string_node_t *container = pm_interpolated_string_node_create(parser, &bounds, NULL, &bounds);
                pm_interpolated_string_node_append(container, current);
                current = (pm_node_t *) container;
            }

            pm_interpolated_string_node_append((pm_interpolated_string_node_t *) current, node);
        }
    }

    return current;
}

#define PM_PARSE_PATTERN_SINGLE 0
#define PM_PARSE_PATTERN_TOP 1
#define PM_PARSE_PATTERN_MULTI 2

static pm_node_t *
parse_pattern(pm_parser_t *parser, pm_constant_id_list_t *captures, uint8_t flags, pm_diagnostic_id_t diag_id, uint16_t depth);

/**
 * Add the newly created local to the list of captures for this pattern matching
 * expression. If it is duplicated from a previous local, then we'll need to add
 * an error to the parser.
 */
static void
parse_pattern_capture(pm_parser_t *parser, pm_constant_id_list_t *captures, pm_constant_id_t capture, const pm_location_t *location) {
    // Skip this capture if it starts with an underscore.
    if (*location->start == '_') return;

    if (pm_constant_id_list_includes(captures, capture)) {
        pm_parser_err(parser, location->start, location->end, PM_ERR_PATTERN_CAPTURE_DUPLICATE);
    } else {
        pm_constant_id_list_append(captures, capture);
    }
}

/**
 * Accept any number of constants joined by :: delimiters.
 */
static pm_node_t *
parse_pattern_constant_path(pm_parser_t *parser, pm_constant_id_list_t *captures, pm_node_t *node, uint16_t depth) {
    // Now, if there are any :: operators that follow, parse them as constant
    // path nodes.
    while (accept1(parser, PM_TOKEN_COLON_COLON)) {
        pm_token_t delimiter = parser->previous;
        expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
        node = (pm_node_t *) pm_constant_path_node_create(parser, node, &delimiter, &parser->previous);
    }

    // If there is a [ or ( that follows, then this is part of a larger pattern
    // expression. We'll parse the inner pattern here, then modify the returned
    // inner pattern with our constant path attached.
    if (!match2(parser, PM_TOKEN_BRACKET_LEFT, PM_TOKEN_PARENTHESIS_LEFT)) {
        return node;
    }

    pm_token_t opening;
    pm_token_t closing;
    pm_node_t *inner = NULL;

    if (accept1(parser, PM_TOKEN_BRACKET_LEFT)) {
        opening = parser->previous;
        accept1(parser, PM_TOKEN_NEWLINE);

        if (!accept1(parser, PM_TOKEN_BRACKET_RIGHT)) {
            inner = parse_pattern(parser, captures, PM_PARSE_PATTERN_TOP | PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET, (uint16_t) (depth + 1));
            accept1(parser, PM_TOKEN_NEWLINE);
            expect1(parser, PM_TOKEN_BRACKET_RIGHT, PM_ERR_PATTERN_TERM_BRACKET);
        }

        closing = parser->previous;
    } else {
        parser_lex(parser);
        opening = parser->previous;
        accept1(parser, PM_TOKEN_NEWLINE);

        if (!accept1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
            inner = parse_pattern(parser, captures, PM_PARSE_PATTERN_TOP | PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_PAREN, (uint16_t) (depth + 1));
            accept1(parser, PM_TOKEN_NEWLINE);
            expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_PATTERN_TERM_PAREN);
        }

        closing = parser->previous;
    }

    if (!inner) {
        // If there was no inner pattern, then we have something like Foo() or
        // Foo[]. In that case we'll create an array pattern with no requireds.
        return (pm_node_t *) pm_array_pattern_node_constant_create(parser, node, &opening, &closing);
    }

    // Now that we have the inner pattern, check to see if it's an array, find,
    // or hash pattern. If it is, then we'll attach our constant path to it if
    // it doesn't already have a constant. If it's not one of those node types
    // or it does have a constant, then we'll create an array pattern.
    switch (PM_NODE_TYPE(inner)) {
        case PM_ARRAY_PATTERN_NODE: {
            pm_array_pattern_node_t *pattern_node = (pm_array_pattern_node_t *) inner;

            if (pattern_node->constant == NULL && pattern_node->opening_loc.start == NULL) {
                pattern_node->base.location.start = node->location.start;
                pattern_node->base.location.end = closing.end;

                pattern_node->constant = node;
                pattern_node->opening_loc = PM_LOCATION_TOKEN_VALUE(&opening);
                pattern_node->closing_loc = PM_LOCATION_TOKEN_VALUE(&closing);

                return (pm_node_t *) pattern_node;
            }

            break;
        }
        case PM_FIND_PATTERN_NODE: {
            pm_find_pattern_node_t *pattern_node = (pm_find_pattern_node_t *) inner;

            if (pattern_node->constant == NULL && pattern_node->opening_loc.start == NULL) {
                pattern_node->base.location.start = node->location.start;
                pattern_node->base.location.end = closing.end;

                pattern_node->constant = node;
                pattern_node->opening_loc = PM_LOCATION_TOKEN_VALUE(&opening);
                pattern_node->closing_loc = PM_LOCATION_TOKEN_VALUE(&closing);

                return (pm_node_t *) pattern_node;
            }

            break;
        }
        case PM_HASH_PATTERN_NODE: {
            pm_hash_pattern_node_t *pattern_node = (pm_hash_pattern_node_t *) inner;

            if (pattern_node->constant == NULL && pattern_node->opening_loc.start == NULL) {
                pattern_node->base.location.start = node->location.start;
                pattern_node->base.location.end = closing.end;

                pattern_node->constant = node;
                pattern_node->opening_loc = PM_LOCATION_TOKEN_VALUE(&opening);
                pattern_node->closing_loc = PM_LOCATION_TOKEN_VALUE(&closing);

                return (pm_node_t *) pattern_node;
            }

            break;
        }
        default:
            break;
    }

    // If we got here, then we didn't return one of the inner patterns by
    // attaching its constant. In this case we'll create an array pattern and
    // attach our constant to it.
    pm_array_pattern_node_t *pattern_node = pm_array_pattern_node_constant_create(parser, node, &opening, &closing);
    pm_array_pattern_node_requireds_append(pattern_node, inner);
    return (pm_node_t *) pattern_node;
}

/**
 * Parse a rest pattern.
 */
static pm_splat_node_t *
parse_pattern_rest(pm_parser_t *parser, pm_constant_id_list_t *captures) {
    assert(parser->previous.type == PM_TOKEN_USTAR);
    pm_token_t operator = parser->previous;
    pm_node_t *name = NULL;

    // Rest patterns don't necessarily have a name associated with them. So we
    // will check for that here. If they do, then we'll add it to the local
    // table since this pattern will cause it to become a local variable.
    if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
        pm_token_t identifier = parser->previous;
        pm_constant_id_t constant_id = pm_parser_constant_id_token(parser, &identifier);

        int depth;
        if ((depth = pm_parser_local_depth_constant_id(parser, constant_id)) == -1) {
            pm_parser_local_add(parser, constant_id, identifier.start, identifier.end, 0);
        }

        parse_pattern_capture(parser, captures, constant_id, &PM_LOCATION_TOKEN_VALUE(&identifier));
        name = (pm_node_t *) pm_local_variable_target_node_create(
            parser,
            &PM_LOCATION_TOKEN_VALUE(&identifier),
            constant_id,
            (uint32_t) (depth == -1 ? 0 : depth)
        );
    }

    // Finally we can return the created node.
    return pm_splat_node_create(parser, &operator, name);
}

/**
 * Parse a keyword rest node.
 */
static pm_node_t *
parse_pattern_keyword_rest(pm_parser_t *parser, pm_constant_id_list_t *captures) {
    assert(parser->current.type == PM_TOKEN_USTAR_STAR);
    parser_lex(parser);

    pm_token_t operator = parser->previous;
    pm_node_t *value = NULL;

    if (accept1(parser, PM_TOKEN_KEYWORD_NIL)) {
        return (pm_node_t *) pm_no_keywords_parameter_node_create(parser, &operator, &parser->previous);
    }

    if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
        pm_constant_id_t constant_id = pm_parser_constant_id_token(parser, &parser->previous);

        int depth;
        if ((depth = pm_parser_local_depth_constant_id(parser, constant_id)) == -1) {
            pm_parser_local_add(parser, constant_id, parser->previous.start, parser->previous.end, 0);
        }

        parse_pattern_capture(parser, captures, constant_id, &PM_LOCATION_TOKEN_VALUE(&parser->previous));
        value = (pm_node_t *) pm_local_variable_target_node_create(
            parser,
            &PM_LOCATION_TOKEN_VALUE(&parser->previous),
            constant_id,
            (uint32_t) (depth == -1 ? 0 : depth)
        );
    }

    return (pm_node_t *) pm_assoc_splat_node_create(parser, value, &operator);
}

/**
 * Check that the slice of the source given by the bounds parameters constitutes
 * a valid local variable name.
 */
static bool
pm_slice_is_valid_local(const pm_parser_t *parser, const uint8_t *start, const uint8_t *end) {
    ptrdiff_t length = end - start;
    if (length == 0) return false;

    // First ensure that it starts with a valid identifier starting character.
    size_t width = char_is_identifier_start(parser, start, end - start);
    if (width == 0) return false;

    // Next, ensure that it's not an uppercase character.
    if (parser->encoding_changed) {
        if (parser->encoding->isupper_char(start, length)) return false;
    } else {
        if (pm_encoding_utf_8_isupper_char(start, length)) return false;
    }

    // Next, iterate through all of the bytes of the string to ensure that they
    // are all valid identifier characters.
    const uint8_t *cursor = start + width;
    while ((width = char_is_identifier(parser, cursor, end - cursor))) cursor += width;
    return cursor == end;
}

/**
 * Create an implicit node for the value of a hash pattern that has omitted the
 * value. This will use an implicit local variable target.
 */
static pm_node_t *
parse_pattern_hash_implicit_value(pm_parser_t *parser, pm_constant_id_list_t *captures, pm_symbol_node_t *key) {
    const pm_location_t *value_loc = &((pm_symbol_node_t *) key)->value_loc;

    pm_constant_id_t constant_id = pm_parser_constant_id_location(parser, value_loc->start, value_loc->end);
    int depth = -1;

    if (pm_slice_is_valid_local(parser, value_loc->start, value_loc->end)) {
        depth = pm_parser_local_depth_constant_id(parser, constant_id);
    } else {
        pm_parser_err(parser, key->base.location.start, key->base.location.end, PM_ERR_PATTERN_HASH_KEY_LOCALS);

        if ((value_loc->end > value_loc->start) && ((value_loc->end[-1] == '!') || (value_loc->end[-1] == '?'))) {
            PM_PARSER_ERR_LOCATION_FORMAT(parser, value_loc, PM_ERR_INVALID_LOCAL_VARIABLE_WRITE, (int) (value_loc->end - value_loc->start), (const char *) value_loc->start);
        }
    }

    if (depth == -1) {
        pm_parser_local_add(parser, constant_id, value_loc->start, value_loc->end, 0);
    }

    parse_pattern_capture(parser, captures, constant_id, value_loc);
    pm_local_variable_target_node_t *target = pm_local_variable_target_node_create(
        parser,
        value_loc,
        constant_id,
        (uint32_t) (depth == -1 ? 0 : depth)
    );

    return (pm_node_t *) pm_implicit_node_create(parser, (pm_node_t *) target);
}

/**
 * Add a node to the list of keys for a hash pattern, and if it is a duplicate
 * then add an error to the parser.
 */
static void
parse_pattern_hash_key(pm_parser_t *parser, pm_static_literals_t *keys, pm_node_t *node) {
    if (pm_static_literals_add(&parser->newline_list, parser->start_line, keys, node, true) != NULL) {
        pm_parser_err_node(parser, node, PM_ERR_PATTERN_HASH_KEY_DUPLICATE);
    }
}

/**
 * Parse a hash pattern.
 */
static pm_hash_pattern_node_t *
parse_pattern_hash(pm_parser_t *parser, pm_constant_id_list_t *captures, pm_node_t *first_node, uint16_t depth) {
    pm_node_list_t assocs = { 0 };
    pm_static_literals_t keys = { 0 };
    pm_node_t *rest = NULL;

    switch (PM_NODE_TYPE(first_node)) {
        case PM_ASSOC_SPLAT_NODE:
        case PM_NO_KEYWORDS_PARAMETER_NODE:
            rest = first_node;
            break;
        case PM_SYMBOL_NODE: {
            if (pm_symbol_node_label_p(first_node)) {
                parse_pattern_hash_key(parser, &keys, first_node);
                pm_node_t *value;

                if (match8(parser, PM_TOKEN_COMMA, PM_TOKEN_KEYWORD_THEN, PM_TOKEN_BRACE_RIGHT, PM_TOKEN_BRACKET_RIGHT, PM_TOKEN_PARENTHESIS_RIGHT, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON, PM_TOKEN_EOF)) {
                    // Otherwise, we will create an implicit local variable
                    // target for the value.
                    value = parse_pattern_hash_implicit_value(parser, captures, (pm_symbol_node_t *) first_node);
                } else {
                    // Here we have a value for the first assoc in the list, so
                    // we will parse it now.
                    value = parse_pattern(parser, captures, PM_PARSE_PATTERN_SINGLE, PM_ERR_PATTERN_EXPRESSION_AFTER_KEY, (uint16_t) (depth + 1));
                }

                pm_token_t operator = not_provided(parser);
                pm_node_t *assoc = (pm_node_t *) pm_assoc_node_create(parser, first_node, &operator, value);

                pm_node_list_append(&assocs, assoc);
                break;
            }
        }
        PRISM_FALLTHROUGH
        default: {
            // If we get anything else, then this is an error. For this we'll
            // create a missing node for the value and create an assoc node for
            // the first node in the list.
            pm_diagnostic_id_t diag_id = PM_NODE_TYPE_P(first_node, PM_INTERPOLATED_SYMBOL_NODE) ? PM_ERR_PATTERN_HASH_KEY_INTERPOLATED : PM_ERR_PATTERN_HASH_KEY_LABEL;
            pm_parser_err_node(parser, first_node, diag_id);

            pm_token_t operator = not_provided(parser);
            pm_node_t *value = (pm_node_t *) pm_missing_node_create(parser, first_node->location.start, first_node->location.end);
            pm_node_t *assoc = (pm_node_t *) pm_assoc_node_create(parser, first_node, &operator, value);

            pm_node_list_append(&assocs, assoc);
            break;
        }
    }

    // If there are any other assocs, then we'll parse them now.
    while (accept1(parser, PM_TOKEN_COMMA)) {
        // Here we need to break to support trailing commas.
        if (match7(parser, PM_TOKEN_KEYWORD_THEN, PM_TOKEN_BRACE_RIGHT, PM_TOKEN_BRACKET_RIGHT, PM_TOKEN_PARENTHESIS_RIGHT, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON, PM_TOKEN_EOF)) {
            // Trailing commas are not allowed to follow a rest pattern.
            if (rest != NULL) {
                pm_parser_err_token(parser, &parser->current, PM_ERR_PATTERN_EXPRESSION_AFTER_REST);
            }

            break;
        }

        if (match1(parser, PM_TOKEN_USTAR_STAR)) {
            pm_node_t *assoc = parse_pattern_keyword_rest(parser, captures);

            if (rest == NULL) {
                rest = assoc;
            } else {
                pm_parser_err_node(parser, assoc, PM_ERR_PATTERN_EXPRESSION_AFTER_REST);
                pm_node_list_append(&assocs, assoc);
            }
        } else {
            pm_node_t *key;

            if (match1(parser, PM_TOKEN_STRING_BEGIN)) {
                key = parse_strings(parser, NULL, true, (uint16_t) (depth + 1));

                if (PM_NODE_TYPE_P(key, PM_INTERPOLATED_SYMBOL_NODE)) {
                    pm_parser_err_node(parser, key, PM_ERR_PATTERN_HASH_KEY_INTERPOLATED);
                } else if (!pm_symbol_node_label_p(key)) {
                    pm_parser_err_node(parser, key, PM_ERR_PATTERN_LABEL_AFTER_COMMA);
                }
            } else {
                expect1(parser, PM_TOKEN_LABEL, PM_ERR_PATTERN_LABEL_AFTER_COMMA);
                key = (pm_node_t *) pm_symbol_node_label_create(parser, &parser->previous);
            }

            parse_pattern_hash_key(parser, &keys, key);
            pm_node_t *value = NULL;

            if (match7(parser, PM_TOKEN_COMMA, PM_TOKEN_KEYWORD_THEN, PM_TOKEN_BRACE_RIGHT, PM_TOKEN_BRACKET_RIGHT, PM_TOKEN_PARENTHESIS_RIGHT, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
                value = parse_pattern_hash_implicit_value(parser, captures, (pm_symbol_node_t *) key);
            } else {
                value = parse_pattern(parser, captures, PM_PARSE_PATTERN_SINGLE, PM_ERR_PATTERN_EXPRESSION_AFTER_KEY, (uint16_t) (depth + 1));
            }

            pm_token_t operator = not_provided(parser);
            pm_node_t *assoc = (pm_node_t *) pm_assoc_node_create(parser, key, &operator, value);

            if (rest != NULL) {
                pm_parser_err_node(parser, assoc, PM_ERR_PATTERN_EXPRESSION_AFTER_REST);
            }

            pm_node_list_append(&assocs, assoc);
        }
    }

    pm_hash_pattern_node_t *node = pm_hash_pattern_node_node_list_create(parser, &assocs, rest);
    xfree(assocs.nodes);

    pm_static_literals_free(&keys);
    return node;
}

/**
 * Parse a pattern expression primitive.
 */
static pm_node_t *
parse_pattern_primitive(pm_parser_t *parser, pm_constant_id_list_t *captures, pm_diagnostic_id_t diag_id, uint16_t depth) {
    switch (parser->current.type) {
        case PM_TOKEN_IDENTIFIER:
        case PM_TOKEN_METHOD_NAME: {
            parser_lex(parser);
            pm_constant_id_t constant_id = pm_parser_constant_id_token(parser, &parser->previous);

            int depth;
            if ((depth = pm_parser_local_depth_constant_id(parser, constant_id)) == -1) {
                pm_parser_local_add(parser, constant_id, parser->previous.start, parser->previous.end, 0);
            }

            parse_pattern_capture(parser, captures, constant_id, &PM_LOCATION_TOKEN_VALUE(&parser->previous));
            return (pm_node_t *) pm_local_variable_target_node_create(
                parser,
                &PM_LOCATION_TOKEN_VALUE(&parser->previous),
                constant_id,
                (uint32_t) (depth == -1 ? 0 : depth)
            );
        }
        case PM_TOKEN_BRACKET_LEFT_ARRAY: {
            pm_token_t opening = parser->current;
            parser_lex(parser);

            if (accept1(parser, PM_TOKEN_BRACKET_RIGHT)) {
                // If we have an empty array pattern, then we'll just return a new
                // array pattern node.
                return (pm_node_t *) pm_array_pattern_node_empty_create(parser, &opening, &parser->previous);
            }

            // Otherwise, we'll parse the inner pattern, then deal with it depending
            // on the type it returns.
            pm_node_t *inner = parse_pattern(parser, captures, PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET, (uint16_t) (depth + 1));

            accept1(parser, PM_TOKEN_NEWLINE);
            expect1(parser, PM_TOKEN_BRACKET_RIGHT, PM_ERR_PATTERN_TERM_BRACKET);
            pm_token_t closing = parser->previous;

            switch (PM_NODE_TYPE(inner)) {
                case PM_ARRAY_PATTERN_NODE: {
                    pm_array_pattern_node_t *pattern_node = (pm_array_pattern_node_t *) inner;
                    if (pattern_node->opening_loc.start == NULL) {
                        pattern_node->base.location.start = opening.start;
                        pattern_node->base.location.end = closing.end;

                        pattern_node->opening_loc = PM_LOCATION_TOKEN_VALUE(&opening);
                        pattern_node->closing_loc = PM_LOCATION_TOKEN_VALUE(&closing);

                        return (pm_node_t *) pattern_node;
                    }

                    break;
                }
                case PM_FIND_PATTERN_NODE: {
                    pm_find_pattern_node_t *pattern_node = (pm_find_pattern_node_t *) inner;
                    if (pattern_node->opening_loc.start == NULL) {
                        pattern_node->base.location.start = opening.start;
                        pattern_node->base.location.end = closing.end;

                        pattern_node->opening_loc = PM_LOCATION_TOKEN_VALUE(&opening);
                        pattern_node->closing_loc = PM_LOCATION_TOKEN_VALUE(&closing);

                        return (pm_node_t *) pattern_node;
                    }

                    break;
                }
                default:
                    break;
            }

            pm_array_pattern_node_t *node = pm_array_pattern_node_empty_create(parser, &opening, &closing);
            pm_array_pattern_node_requireds_append(node, inner);
            return (pm_node_t *) node;
        }
        case PM_TOKEN_BRACE_LEFT: {
            bool previous_pattern_matching_newlines = parser->pattern_matching_newlines;
            parser->pattern_matching_newlines = false;

            pm_hash_pattern_node_t *node;
            pm_token_t opening = parser->current;
            parser_lex(parser);

            if (accept1(parser, PM_TOKEN_BRACE_RIGHT)) {
                // If we have an empty hash pattern, then we'll just return a new hash
                // pattern node.
                node = pm_hash_pattern_node_empty_create(parser, &opening, &parser->previous);
            } else {
                pm_node_t *first_node;

                switch (parser->current.type) {
                    case PM_TOKEN_LABEL:
                        parser_lex(parser);
                        first_node = (pm_node_t *) pm_symbol_node_label_create(parser, &parser->previous);
                        break;
                    case PM_TOKEN_USTAR_STAR:
                        first_node = parse_pattern_keyword_rest(parser, captures);
                        break;
                    case PM_TOKEN_STRING_BEGIN:
                        first_node = parse_expression(parser, PM_BINDING_POWER_MAX, false, true, PM_ERR_PATTERN_HASH_KEY_LABEL, (uint16_t) (depth + 1));
                        break;
                    default: {
                        PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_PATTERN_HASH_KEY, pm_token_type_human(parser->current.type));
                        parser_lex(parser);

                        first_node = (pm_node_t *) pm_missing_node_create(parser, parser->previous.start, parser->previous.end);
                        break;
                    }
                }

                node = parse_pattern_hash(parser, captures, first_node, (uint16_t) (depth + 1));

                accept1(parser, PM_TOKEN_NEWLINE);
                expect1(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_PATTERN_TERM_BRACE);
                pm_token_t closing = parser->previous;

                node->base.location.start = opening.start;
                node->base.location.end = closing.end;

                node->opening_loc = PM_LOCATION_TOKEN_VALUE(&opening);
                node->closing_loc = PM_LOCATION_TOKEN_VALUE(&closing);
            }

            parser->pattern_matching_newlines = previous_pattern_matching_newlines;
            return (pm_node_t *) node;
        }
        case PM_TOKEN_UDOT_DOT:
        case PM_TOKEN_UDOT_DOT_DOT: {
            pm_token_t operator = parser->current;
            parser_lex(parser);

            // Since we have a unary range operator, we need to parse the subsequent
            // expression as the right side of the range.
            switch (parser->current.type) {
                case PM_CASE_PRIMITIVE: {
                    pm_node_t *right = parse_expression(parser, PM_BINDING_POWER_MAX, false, false, PM_ERR_PATTERN_EXPRESSION_AFTER_RANGE, (uint16_t) (depth + 1));
                    return (pm_node_t *) pm_range_node_create(parser, NULL, &operator, right);
                }
                default: {
                    pm_parser_err_token(parser, &operator, PM_ERR_PATTERN_EXPRESSION_AFTER_RANGE);
                    pm_node_t *right = (pm_node_t *) pm_missing_node_create(parser, operator.start, operator.end);
                    return (pm_node_t *) pm_range_node_create(parser, NULL, &operator, right);
                }
            }
        }
        case PM_CASE_PRIMITIVE: {
            pm_node_t *node = parse_expression(parser, PM_BINDING_POWER_MAX, false, true, diag_id, (uint16_t) (depth + 1));

            // If we found a label, we need to immediately return to the caller.
            if (pm_symbol_node_label_p(node)) return node;

            // Call nodes (arithmetic operations) are not allowed in patterns
            if (PM_NODE_TYPE(node) == PM_CALL_NODE) {
                pm_parser_err_node(parser, node, diag_id);
                pm_missing_node_t *missing_node = pm_missing_node_create(parser, node->location.start, node->location.end);
                pm_node_destroy(parser, node);
                return (pm_node_t *) missing_node;
            }

            // Now that we have a primitive, we need to check if it's part of a range.
            if (accept2(parser, PM_TOKEN_DOT_DOT, PM_TOKEN_DOT_DOT_DOT)) {
                pm_token_t operator = parser->previous;

                // Now that we have the operator, we need to check if this is followed
                // by another expression. If it is, then we will create a full range
                // node. Otherwise, we'll create an endless range.
                switch (parser->current.type) {
                    case PM_CASE_PRIMITIVE: {
                        pm_node_t *right = parse_expression(parser, PM_BINDING_POWER_MAX, false, false, PM_ERR_PATTERN_EXPRESSION_AFTER_RANGE, (uint16_t) (depth + 1));
                        return (pm_node_t *) pm_range_node_create(parser, node, &operator, right);
                    }
                    default:
                        return (pm_node_t *) pm_range_node_create(parser, node, &operator, NULL);
                }
            }

            return node;
        }
        case PM_TOKEN_CARET: {
            parser_lex(parser);
            pm_token_t operator = parser->previous;

            // At this point we have a pin operator. We need to check the subsequent
            // expression to determine if it's a variable or an expression.
            switch (parser->current.type) {
                case PM_TOKEN_IDENTIFIER: {
                    parser_lex(parser);
                    pm_node_t *variable = (pm_node_t *) parse_variable(parser);

                    if (variable == NULL) {
                        PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, parser->previous, PM_ERR_NO_LOCAL_VARIABLE);
                        variable = (pm_node_t *) pm_local_variable_read_node_missing_create(parser, &parser->previous, 0);
                    }

                    return (pm_node_t *) pm_pinned_variable_node_create(parser, &operator, variable);
                }
                case PM_TOKEN_INSTANCE_VARIABLE: {
                    parser_lex(parser);
                    pm_node_t *variable = (pm_node_t *) pm_instance_variable_read_node_create(parser, &parser->previous);

                    return (pm_node_t *) pm_pinned_variable_node_create(parser, &operator, variable);
                }
                case PM_TOKEN_CLASS_VARIABLE: {
                    parser_lex(parser);
                    pm_node_t *variable = (pm_node_t *) pm_class_variable_read_node_create(parser, &parser->previous);

                    return (pm_node_t *) pm_pinned_variable_node_create(parser, &operator, variable);
                }
                case PM_TOKEN_GLOBAL_VARIABLE: {
                    parser_lex(parser);
                    pm_node_t *variable = (pm_node_t *) pm_global_variable_read_node_create(parser, &parser->previous);

                    return (pm_node_t *) pm_pinned_variable_node_create(parser, &operator, variable);
                }
                case PM_TOKEN_NUMBERED_REFERENCE: {
                    parser_lex(parser);
                    pm_node_t *variable = (pm_node_t *) pm_numbered_reference_read_node_create(parser, &parser->previous);

                    return (pm_node_t *) pm_pinned_variable_node_create(parser, &operator, variable);
                }
                case PM_TOKEN_BACK_REFERENCE: {
                    parser_lex(parser);
                    pm_node_t *variable = (pm_node_t *) pm_back_reference_read_node_create(parser, &parser->previous);

                    return (pm_node_t *) pm_pinned_variable_node_create(parser, &operator, variable);
                }
                case PM_TOKEN_PARENTHESIS_LEFT: {
                    bool previous_pattern_matching_newlines = parser->pattern_matching_newlines;
                    parser->pattern_matching_newlines = false;

                    pm_token_t lparen = parser->current;
                    parser_lex(parser);

                    pm_node_t *expression = parse_value_expression(parser, PM_BINDING_POWER_STATEMENT, true, false, PM_ERR_PATTERN_EXPRESSION_AFTER_PIN, (uint16_t) (depth + 1));
                    parser->pattern_matching_newlines = previous_pattern_matching_newlines;

                    accept1(parser, PM_TOKEN_NEWLINE);
                    expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_PATTERN_TERM_PAREN);
                    return (pm_node_t *) pm_pinned_expression_node_create(parser, expression, &operator, &lparen, &parser->previous);
                }
                default: {
                    // If we get here, then we have a pin operator followed by something
                    // not understood. We'll create a missing node and return that.
                    pm_parser_err_token(parser, &operator, PM_ERR_PATTERN_EXPRESSION_AFTER_PIN);
                    pm_node_t *variable = (pm_node_t *) pm_missing_node_create(parser, operator.start, operator.end);
                    return (pm_node_t *) pm_pinned_variable_node_create(parser, &operator, variable);
                }
            }
        }
        case PM_TOKEN_UCOLON_COLON: {
            pm_token_t delimiter = parser->current;
            parser_lex(parser);

            expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
            pm_constant_path_node_t *node = pm_constant_path_node_create(parser, NULL, &delimiter, &parser->previous);

            return parse_pattern_constant_path(parser, captures, (pm_node_t *) node, (uint16_t) (depth + 1));
        }
        case PM_TOKEN_CONSTANT: {
            pm_token_t constant = parser->current;
            parser_lex(parser);

            pm_node_t *node = (pm_node_t *) pm_constant_read_node_create(parser, &constant);
            return parse_pattern_constant_path(parser, captures, node, (uint16_t) (depth + 1));
        }
        default:
            pm_parser_err_current(parser, diag_id);
            return (pm_node_t *) pm_missing_node_create(parser, parser->current.start, parser->current.end);
    }
}

/**
 * Parse any number of primitives joined by alternation and ended optionally by
 * assignment.
 */
static pm_node_t *
parse_pattern_primitives(pm_parser_t *parser, pm_constant_id_list_t *captures, pm_node_t *first_node, pm_diagnostic_id_t diag_id, uint16_t depth) {
    pm_node_t *node = first_node;

    while ((node == NULL) || accept1(parser, PM_TOKEN_PIPE)) {
        pm_token_t operator = parser->previous;

        switch (parser->current.type) {
            case PM_TOKEN_IDENTIFIER:
            case PM_TOKEN_BRACKET_LEFT_ARRAY:
            case PM_TOKEN_BRACE_LEFT:
            case PM_TOKEN_CARET:
            case PM_TOKEN_CONSTANT:
            case PM_TOKEN_UCOLON_COLON:
            case PM_TOKEN_UDOT_DOT:
            case PM_TOKEN_UDOT_DOT_DOT:
            case PM_CASE_PRIMITIVE: {
                if (node == NULL) {
                    node = parse_pattern_primitive(parser, captures, diag_id, (uint16_t) (depth + 1));
                } else {
                    pm_node_t *right = parse_pattern_primitive(parser, captures, PM_ERR_PATTERN_EXPRESSION_AFTER_PIPE, (uint16_t) (depth + 1));
                    node = (pm_node_t *) pm_alternation_pattern_node_create(parser, node, right, &operator);
                }

                break;
            }
            case PM_TOKEN_PARENTHESIS_LEFT:
            case PM_TOKEN_PARENTHESIS_LEFT_PARENTHESES: {
                pm_token_t opening = parser->current;
                parser_lex(parser);

                pm_node_t *body = parse_pattern(parser, captures, PM_PARSE_PATTERN_SINGLE, PM_ERR_PATTERN_EXPRESSION_AFTER_PAREN, (uint16_t) (depth + 1));
                accept1(parser, PM_TOKEN_NEWLINE);
                expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_PATTERN_TERM_PAREN);
                pm_node_t *right = (pm_node_t *) pm_parentheses_node_create(parser, &opening, body, &parser->previous, 0);

                if (node == NULL) {
                    node = right;
                } else {
                    node = (pm_node_t *) pm_alternation_pattern_node_create(parser, node, right, &operator);
                }

                break;
            }
            default: {
                pm_parser_err_current(parser, diag_id);
                pm_node_t *right = (pm_node_t *) pm_missing_node_create(parser, parser->current.start, parser->current.end);

                if (node == NULL) {
                    node = right;
                } else {
                    node = (pm_node_t *) pm_alternation_pattern_node_create(parser, node, right, &operator);
                }

                break;
            }
        }
    }

    // If we have an =>, then we are assigning this pattern to a variable.
    // In this case we should create an assignment node.
    while (accept1(parser, PM_TOKEN_EQUAL_GREATER)) {
        pm_token_t operator = parser->previous;
        expect1(parser, PM_TOKEN_IDENTIFIER, PM_ERR_PATTERN_IDENT_AFTER_HROCKET);

        pm_constant_id_t constant_id = pm_parser_constant_id_token(parser, &parser->previous);
        int depth;

        if ((depth = pm_parser_local_depth_constant_id(parser, constant_id)) == -1) {
            pm_parser_local_add(parser, constant_id, parser->previous.start, parser->previous.end, 0);
        }

        parse_pattern_capture(parser, captures, constant_id, &PM_LOCATION_TOKEN_VALUE(&parser->previous));
        pm_local_variable_target_node_t *target = pm_local_variable_target_node_create(
            parser,
            &PM_LOCATION_TOKEN_VALUE(&parser->previous),
            constant_id,
            (uint32_t) (depth == -1 ? 0 : depth)
        );

        node = (pm_node_t *) pm_capture_pattern_node_create(parser, node, target, &operator);
    }

    return node;
}

/**
 * Parse a pattern matching expression.
 */
static pm_node_t *
parse_pattern(pm_parser_t *parser, pm_constant_id_list_t *captures, uint8_t flags, pm_diagnostic_id_t diag_id, uint16_t depth) {
    pm_node_t *node = NULL;

    bool leading_rest = false;
    bool trailing_rest = false;

    switch (parser->current.type) {
        case PM_TOKEN_LABEL: {
            parser_lex(parser);
            pm_node_t *key = (pm_node_t *) pm_symbol_node_label_create(parser, &parser->previous);
            node = (pm_node_t *) parse_pattern_hash(parser, captures, key, (uint16_t) (depth + 1));

            if (!(flags & PM_PARSE_PATTERN_TOP)) {
                pm_parser_err_node(parser, node, PM_ERR_PATTERN_HASH_IMPLICIT);
            }

            return node;
        }
        case PM_TOKEN_USTAR_STAR: {
            node = parse_pattern_keyword_rest(parser, captures);
            node = (pm_node_t *) parse_pattern_hash(parser, captures, node, (uint16_t) (depth + 1));

            if (!(flags & PM_PARSE_PATTERN_TOP)) {
                pm_parser_err_node(parser, node, PM_ERR_PATTERN_HASH_IMPLICIT);
            }

            return node;
        }
        case PM_TOKEN_STRING_BEGIN: {
            // We need special handling for string beginnings because they could
            // be dynamic symbols leading to hash patterns.
            node = parse_pattern_primitive(parser, captures, diag_id, (uint16_t) (depth + 1));

            if (pm_symbol_node_label_p(node)) {
                node = (pm_node_t *) parse_pattern_hash(parser, captures, node, (uint16_t) (depth + 1));

                if (!(flags & PM_PARSE_PATTERN_TOP)) {
                    pm_parser_err_node(parser, node, PM_ERR_PATTERN_HASH_IMPLICIT);
                }

                return node;
            }

            node = parse_pattern_primitives(parser, captures, node, diag_id, (uint16_t) (depth + 1));
            break;
        }
        case PM_TOKEN_USTAR: {
            if (flags & (PM_PARSE_PATTERN_TOP | PM_PARSE_PATTERN_MULTI)) {
                parser_lex(parser);
                node = (pm_node_t *) parse_pattern_rest(parser, captures);
                leading_rest = true;
                break;
            }
        }
        PRISM_FALLTHROUGH
        default:
            node = parse_pattern_primitives(parser, captures, NULL, diag_id, (uint16_t) (depth + 1));
            break;
    }

    // If we got a dynamic label symbol, then we need to treat it like the
    // beginning of a hash pattern.
    if (pm_symbol_node_label_p(node)) {
        return (pm_node_t *) parse_pattern_hash(parser, captures, node, (uint16_t) (depth + 1));
    }

    if ((flags & PM_PARSE_PATTERN_MULTI) && match1(parser, PM_TOKEN_COMMA)) {
        // If we have a comma, then we are now parsing either an array pattern
        // or a find pattern. We need to parse all of the patterns, put them
        // into a big list, and then determine which type of node we have.
        pm_node_list_t nodes = { 0 };
        pm_node_list_append(&nodes, node);

        // Gather up all of the patterns into the list.
        while (accept1(parser, PM_TOKEN_COMMA)) {
            // Break early here in case we have a trailing comma.
            if (match7(parser, PM_TOKEN_KEYWORD_THEN, PM_TOKEN_BRACE_RIGHT, PM_TOKEN_BRACKET_RIGHT, PM_TOKEN_PARENTHESIS_RIGHT, PM_TOKEN_SEMICOLON, PM_TOKEN_KEYWORD_AND, PM_TOKEN_KEYWORD_OR)) {
                node = (pm_node_t *) pm_implicit_rest_node_create(parser, &parser->previous);
                pm_node_list_append(&nodes, node);
                trailing_rest = true;
                break;
            }

            if (accept1(parser, PM_TOKEN_USTAR)) {
                node = (pm_node_t *) parse_pattern_rest(parser, captures);

                // If we have already parsed a splat pattern, then this is an
                // error. We will continue to parse the rest of the patterns,
                // but we will indicate it as an error.
                if (trailing_rest) {
                    pm_parser_err_previous(parser, PM_ERR_PATTERN_REST);
                }

                trailing_rest = true;
            } else {
                node = parse_pattern_primitives(parser, captures, NULL, PM_ERR_PATTERN_EXPRESSION_AFTER_COMMA, (uint16_t) (depth + 1));
            }

            pm_node_list_append(&nodes, node);
        }

        // If the first pattern and the last pattern are rest patterns, then we
        // will call this a find pattern, regardless of how many rest patterns
        // are in between because we know we already added the appropriate
        // errors. Otherwise we will create an array pattern.
        if (leading_rest && PM_NODE_TYPE_P(nodes.nodes[nodes.size - 1], PM_SPLAT_NODE)) {
            node = (pm_node_t *) pm_find_pattern_node_create(parser, &nodes);

            if (nodes.size == 2) {
                pm_parser_err_node(parser, node, PM_ERR_PATTERN_FIND_MISSING_INNER);
            }
        } else {
            node = (pm_node_t *) pm_array_pattern_node_node_list_create(parser, &nodes);

            if (leading_rest && trailing_rest) {
                pm_parser_err_node(parser, node, PM_ERR_PATTERN_ARRAY_MULTIPLE_RESTS);
            }
        }

        xfree(nodes.nodes);
    } else if (leading_rest) {
        // Otherwise, if we parsed a single splat pattern, then we know we have
        // an array pattern, so we can go ahead and create that node.
        node = (pm_node_t *) pm_array_pattern_node_rest_create(parser, node);
    }

    return node;
}

/**
 * Incorporate a negative sign into a numeric node by subtracting 1 character
 * from its start bounds. If it's a compound node, then we will recursively
 * apply this function to its value.
 */
static inline void
parse_negative_numeric(pm_node_t *node) {
    switch (PM_NODE_TYPE(node)) {
        case PM_INTEGER_NODE: {
            pm_integer_node_t *cast = (pm_integer_node_t *) node;
            cast->base.location.start--;
            cast->value.negative = true;
            break;
        }
        case PM_FLOAT_NODE: {
            pm_float_node_t *cast = (pm_float_node_t *) node;
            cast->base.location.start--;
            cast->value = -cast->value;
            break;
        }
        case PM_RATIONAL_NODE: {
            pm_rational_node_t *cast = (pm_rational_node_t *) node;
            cast->base.location.start--;
            cast->numerator.negative = true;
            break;
        }
        case PM_IMAGINARY_NODE:
            node->location.start--;
            parse_negative_numeric(((pm_imaginary_node_t *) node)->numeric);
            break;
        default:
            assert(false && "unreachable");
            break;
    }
}

/**
 * Append an error to the error list on the parser using the given diagnostic
 * ID. This function is a specialization that handles formatting the specific
 * kind of error that is being appended.
 */
static void
pm_parser_err_prefix(pm_parser_t *parser, pm_diagnostic_id_t diag_id) {
    switch (diag_id) {
        case PM_ERR_HASH_KEY: {
            PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->previous, diag_id, pm_token_type_human(parser->previous.type));
            break;
        }
        case PM_ERR_HASH_VALUE:
        case PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR: {
            PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, diag_id, pm_token_type_human(parser->current.type));
            break;
        }
        case PM_ERR_UNARY_RECEIVER: {
            const char *human = (parser->current.type == PM_TOKEN_EOF ? "end-of-input" : pm_token_type_human(parser->current.type));
            PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->previous, diag_id, human, parser->previous.start[0]);
            break;
        }
        case PM_ERR_UNARY_DISALLOWED:
        case PM_ERR_EXPECT_ARGUMENT: {
            PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, diag_id, pm_token_type_human(parser->current.type));
            break;
        }
        default:
            pm_parser_err_previous(parser, diag_id);
            break;
    }
}

/**
 * Ensures that the current retry token is valid in the current context.
 */
static void
parse_retry(pm_parser_t *parser, const pm_node_t *node) {
#define CONTEXT_NONE 0
#define CONTEXT_THROUGH_ENSURE 1
#define CONTEXT_THROUGH_ELSE 2

    pm_context_node_t *context_node = parser->current_context;
    int context = CONTEXT_NONE;

    while (context_node != NULL) {
        switch (context_node->context) {
            case PM_CONTEXT_BEGIN_RESCUE:
            case PM_CONTEXT_BLOCK_RESCUE:
            case PM_CONTEXT_CLASS_RESCUE:
            case PM_CONTEXT_DEF_RESCUE:
            case PM_CONTEXT_LAMBDA_RESCUE:
            case PM_CONTEXT_MODULE_RESCUE:
            case PM_CONTEXT_SCLASS_RESCUE:
            case PM_CONTEXT_DEFINED:
            case PM_CONTEXT_RESCUE_MODIFIER:
                // These are the good cases. We're allowed to have a retry here.
                return;
            case PM_CONTEXT_CLASS:
            case PM_CONTEXT_DEF:
            case PM_CONTEXT_DEF_PARAMS:
            case PM_CONTEXT_MAIN:
            case PM_CONTEXT_MODULE:
            case PM_CONTEXT_PREEXE:
            case PM_CONTEXT_SCLASS:
                // These are the bad cases. We're not allowed to have a retry in
                // these contexts.
                if (context == CONTEXT_NONE) {
                    pm_parser_err_node(parser, node, PM_ERR_INVALID_RETRY_WITHOUT_RESCUE);
                } else if (context == CONTEXT_THROUGH_ENSURE) {
                    pm_parser_err_node(parser, node, PM_ERR_INVALID_RETRY_AFTER_ENSURE);
                } else if (context == CONTEXT_THROUGH_ELSE) {
                    pm_parser_err_node(parser, node, PM_ERR_INVALID_RETRY_AFTER_ELSE);
                }
                return;
            case PM_CONTEXT_BEGIN_ELSE:
            case PM_CONTEXT_BLOCK_ELSE:
            case PM_CONTEXT_CLASS_ELSE:
            case PM_CONTEXT_DEF_ELSE:
            case PM_CONTEXT_LAMBDA_ELSE:
            case PM_CONTEXT_MODULE_ELSE:
            case PM_CONTEXT_SCLASS_ELSE:
                // These are also bad cases, but with a more specific error
                // message indicating the else.
                context = CONTEXT_THROUGH_ELSE;
                break;
            case PM_CONTEXT_BEGIN_ENSURE:
            case PM_CONTEXT_BLOCK_ENSURE:
            case PM_CONTEXT_CLASS_ENSURE:
            case PM_CONTEXT_DEF_ENSURE:
            case PM_CONTEXT_LAMBDA_ENSURE:
            case PM_CONTEXT_MODULE_ENSURE:
            case PM_CONTEXT_SCLASS_ENSURE:
                // These are also bad cases, but with a more specific error
                // message indicating the ensure.
                context = CONTEXT_THROUGH_ENSURE;
                break;
            case PM_CONTEXT_NONE:
                // This case should never happen.
                assert(false && "unreachable");
                break;
            case PM_CONTEXT_BEGIN:
            case PM_CONTEXT_BLOCK_BRACES:
            case PM_CONTEXT_BLOCK_KEYWORDS:
            case PM_CONTEXT_CASE_IN:
            case PM_CONTEXT_CASE_WHEN:
            case PM_CONTEXT_DEFAULT_PARAMS:
            case PM_CONTEXT_ELSE:
            case PM_CONTEXT_ELSIF:
            case PM_CONTEXT_EMBEXPR:
            case PM_CONTEXT_FOR_INDEX:
            case PM_CONTEXT_FOR:
            case PM_CONTEXT_IF:
            case PM_CONTEXT_LAMBDA_BRACES:
            case PM_CONTEXT_LAMBDA_DO_END:
            case PM_CONTEXT_LOOP_PREDICATE:
            case PM_CONTEXT_MULTI_TARGET:
            case PM_CONTEXT_PARENS:
            case PM_CONTEXT_POSTEXE:
            case PM_CONTEXT_PREDICATE:
            case PM_CONTEXT_TERNARY:
            case PM_CONTEXT_UNLESS:
            case PM_CONTEXT_UNTIL:
            case PM_CONTEXT_WHILE:
                // In these contexts we should continue walking up the list of
                // contexts.
                break;
        }

        context_node = context_node->prev;
    }

#undef CONTEXT_NONE
#undef CONTEXT_ENSURE
#undef CONTEXT_ELSE
}

/**
 * Ensures that the current yield token is valid in the current context.
 */
static void
parse_yield(pm_parser_t *parser, const pm_node_t *node) {
    pm_context_node_t *context_node = parser->current_context;

    while (context_node != NULL) {
        switch (context_node->context) {
            case PM_CONTEXT_DEF:
            case PM_CONTEXT_DEF_PARAMS:
            case PM_CONTEXT_DEFINED:
            case PM_CONTEXT_DEF_ENSURE:
            case PM_CONTEXT_DEF_RESCUE:
            case PM_CONTEXT_DEF_ELSE:
                // These are the good cases. We're allowed to have a block exit
                // in these contexts.
                return;
            case PM_CONTEXT_CLASS:
            case PM_CONTEXT_CLASS_ENSURE:
            case PM_CONTEXT_CLASS_RESCUE:
            case PM_CONTEXT_CLASS_ELSE:
            case PM_CONTEXT_MAIN:
            case PM_CONTEXT_MODULE:
            case PM_CONTEXT_MODULE_ENSURE:
            case PM_CONTEXT_MODULE_RESCUE:
            case PM_CONTEXT_MODULE_ELSE:
            case PM_CONTEXT_SCLASS:
            case PM_CONTEXT_SCLASS_RESCUE:
            case PM_CONTEXT_SCLASS_ENSURE:
            case PM_CONTEXT_SCLASS_ELSE:
                // These are the bad cases. We're not allowed to have a retry in
                // these contexts.
                pm_parser_err_node(parser, node, PM_ERR_INVALID_YIELD);
                return;
            case PM_CONTEXT_NONE:
                // This case should never happen.
                assert(false && "unreachable");
                break;
            case PM_CONTEXT_BEGIN:
            case PM_CONTEXT_BEGIN_ELSE:
            case PM_CONTEXT_BEGIN_ENSURE:
            case PM_CONTEXT_BEGIN_RESCUE:
            case PM_CONTEXT_BLOCK_BRACES:
            case PM_CONTEXT_BLOCK_KEYWORDS:
            case PM_CONTEXT_BLOCK_ELSE:
            case PM_CONTEXT_BLOCK_ENSURE:
            case PM_CONTEXT_BLOCK_RESCUE:
            case PM_CONTEXT_CASE_IN:
            case PM_CONTEXT_CASE_WHEN:
            case PM_CONTEXT_DEFAULT_PARAMS:
            case PM_CONTEXT_ELSE:
            case PM_CONTEXT_ELSIF:
            case PM_CONTEXT_EMBEXPR:
            case PM_CONTEXT_FOR_INDEX:
            case PM_CONTEXT_FOR:
            case PM_CONTEXT_IF:
            case PM_CONTEXT_LAMBDA_BRACES:
            case PM_CONTEXT_LAMBDA_DO_END:
            case PM_CONTEXT_LAMBDA_ELSE:
            case PM_CONTEXT_LAMBDA_ENSURE:
            case PM_CONTEXT_LAMBDA_RESCUE:
            case PM_CONTEXT_LOOP_PREDICATE:
            case PM_CONTEXT_MULTI_TARGET:
            case PM_CONTEXT_PARENS:
            case PM_CONTEXT_POSTEXE:
            case PM_CONTEXT_PREDICATE:
            case PM_CONTEXT_PREEXE:
            case PM_CONTEXT_RESCUE_MODIFIER:
            case PM_CONTEXT_TERNARY:
            case PM_CONTEXT_UNLESS:
            case PM_CONTEXT_UNTIL:
            case PM_CONTEXT_WHILE:
                // In these contexts we should continue walking up the list of
                // contexts.
                break;
        }

        context_node = context_node->prev;
    }
}

/**
 * This struct is used to pass information between the regular expression parser
 * and the error callback.
 */
typedef struct {
    /** The parser that we are parsing the regular expression for. */
    pm_parser_t *parser;

    /** The start of the regular expression. */
    const uint8_t *start;

    /** The end of the regular expression. */
    const uint8_t *end;

    /**
     * Whether or not the source of the regular expression is shared. This
     * impacts the location of error messages, because if it is shared then we
     * can use the location directly and if it is not, then we use the bounds of
     * the regular expression itself.
     */
    bool shared;
} parse_regular_expression_error_data_t;

/**
 * This callback is called when the regular expression parser encounters a
 * syntax error.
 */
static void
parse_regular_expression_error(const uint8_t *start, const uint8_t *end, const char *message, void *data) {
    parse_regular_expression_error_data_t *callback_data = (parse_regular_expression_error_data_t *) data;
    pm_location_t location;

    if (callback_data->shared) {
        location = (pm_location_t) { .start = start, .end = end };
    } else {
        location = (pm_location_t) { .start = callback_data->start, .end = callback_data->end };
    }

    PM_PARSER_ERR_FORMAT(callback_data->parser, location.start, location.end, PM_ERR_REGEXP_PARSE_ERROR, message);
}

/**
 * Parse the errors for the regular expression and add them to the parser.
 */
static void
parse_regular_expression_errors(pm_parser_t *parser, pm_regular_expression_node_t *node) {
    const pm_string_t *unescaped = &node->unescaped;
    parse_regular_expression_error_data_t error_data = {
        .parser = parser,
        .start = node->base.location.start,
        .end = node->base.location.end,
        .shared = unescaped->type == PM_STRING_SHARED
    };

    pm_regexp_parse(parser, pm_string_source(unescaped), pm_string_length(unescaped), PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED), NULL, NULL, parse_regular_expression_error, &error_data);
}

/**
 * Parse an expression that begins with the previous node that we just lexed.
 */
static inline pm_node_t *
parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, bool accepts_command_call, bool accepts_label, pm_diagnostic_id_t diag_id, uint16_t depth) {
    switch (parser->current.type) {
        case PM_TOKEN_BRACKET_LEFT_ARRAY: {
            parser_lex(parser);

            pm_array_node_t *array = pm_array_node_create(parser, &parser->previous);
            pm_accepts_block_stack_push(parser, true);
            bool parsed_bare_hash = false;

            while (!match2(parser, PM_TOKEN_BRACKET_RIGHT, PM_TOKEN_EOF)) {
                bool accepted_newline = accept1(parser, PM_TOKEN_NEWLINE);

                // Handle the case where we don't have a comma and we have a
                // newline followed by a right bracket.
                if (accepted_newline && match1(parser, PM_TOKEN_BRACKET_RIGHT)) {
                    break;
                }

                // Ensure that we have a comma between elements in the array.
                if (array->elements.size > 0) {
                    if (accept1(parser, PM_TOKEN_COMMA)) {
                        // If there was a comma but we also accepts a newline,
                        // then this is a syntax error.
                        if (accepted_newline) {
                            pm_parser_err_previous(parser, PM_ERR_INVALID_COMMA);
                        }
                    } else {
                        // If there was no comma, then we need to add a syntax
                        // error.
                        const uint8_t *location = parser->previous.end;
                        PM_PARSER_ERR_FORMAT(parser, location, location, PM_ERR_ARRAY_SEPARATOR, pm_token_type_human(parser->current.type));

                        parser->previous.start = location;
                        parser->previous.type = PM_TOKEN_MISSING;
                    }
                }

                // If we have a right bracket immediately following a comma,
                // this is allowed since it's a trailing comma. In this case we
                // can break out of the loop.
                if (match1(parser, PM_TOKEN_BRACKET_RIGHT)) break;

                pm_node_t *element;

                if (accept1(parser, PM_TOKEN_USTAR)) {
                    pm_token_t operator = parser->previous;
                    pm_node_t *expression = NULL;

                    if (match3(parser, PM_TOKEN_BRACKET_RIGHT, PM_TOKEN_COMMA, PM_TOKEN_EOF)) {
                        pm_parser_scope_forwarding_positionals_check(parser, &operator);
                    } else {
                        expression = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_ARRAY_EXPRESSION_AFTER_STAR, (uint16_t) (depth + 1));
                    }

                    element = (pm_node_t *) pm_splat_node_create(parser, &operator, expression);
                } else if (match2(parser, PM_TOKEN_LABEL, PM_TOKEN_USTAR_STAR)) {
                    if (parsed_bare_hash) {
                        pm_parser_err_current(parser, PM_ERR_EXPRESSION_BARE_HASH);
                    }

                    element = (pm_node_t *) pm_keyword_hash_node_create(parser);
                    pm_static_literals_t hash_keys = { 0 };

                    if (!match8(parser, PM_TOKEN_EOF, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON, PM_TOKEN_EOF, PM_TOKEN_BRACE_RIGHT, PM_TOKEN_BRACKET_RIGHT, PM_TOKEN_KEYWORD_DO, PM_TOKEN_PARENTHESIS_RIGHT)) {
                        parse_assocs(parser, &hash_keys, element, (uint16_t) (depth + 1));
                    }

                    pm_static_literals_free(&hash_keys);
                    parsed_bare_hash = true;
                } else {
                    element = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, false, true, PM_ERR_ARRAY_EXPRESSION, (uint16_t) (depth + 1));

                    if (pm_symbol_node_label_p(element) || accept1(parser, PM_TOKEN_EQUAL_GREATER)) {
                        if (parsed_bare_hash) {
                            pm_parser_err_previous(parser, PM_ERR_EXPRESSION_BARE_HASH);
                        }

                        pm_keyword_hash_node_t *hash = pm_keyword_hash_node_create(parser);
                        pm_static_literals_t hash_keys = { 0 };
                        pm_hash_key_static_literals_add(parser, &hash_keys, element);

                        pm_token_t operator;
                        if (parser->previous.type == PM_TOKEN_EQUAL_GREATER) {
                            operator = parser->previous;
                        } else {
                            operator = not_provided(parser);
                        }

                        pm_node_t *value = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_HASH_VALUE, (uint16_t) (depth + 1));
                        pm_node_t *assoc = (pm_node_t *) pm_assoc_node_create(parser, element, &operator, value);
                        pm_keyword_hash_node_elements_append(hash, assoc);

                        element = (pm_node_t *) hash;
                        if (accept1(parser, PM_TOKEN_COMMA) && !match1(parser, PM_TOKEN_BRACKET_RIGHT)) {
                            parse_assocs(parser, &hash_keys, element, (uint16_t) (depth + 1));
                        }

                        pm_static_literals_free(&hash_keys);
                        parsed_bare_hash = true;
                    }
                }

                pm_array_node_elements_append(array, element);
                if (PM_NODE_TYPE_P(element, PM_MISSING_NODE)) break;
            }

            accept1(parser, PM_TOKEN_NEWLINE);

            if (!accept1(parser, PM_TOKEN_BRACKET_RIGHT)) {
                PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_ARRAY_TERM, pm_token_type_human(parser->current.type));
                parser->previous.start = parser->previous.end;
                parser->previous.type = PM_TOKEN_MISSING;
            }

            pm_array_node_close_set(array, &parser->previous);
            pm_accepts_block_stack_pop(parser);

            return (pm_node_t *) array;
        }
        case PM_TOKEN_PARENTHESIS_LEFT:
        case PM_TOKEN_PARENTHESIS_LEFT_PARENTHESES: {
            pm_token_t opening = parser->current;
            pm_node_flags_t flags = 0;

            pm_node_list_t current_block_exits = { 0 };
            pm_node_list_t *previous_block_exits = push_block_exits(parser, ¤t_block_exits);

            parser_lex(parser);
            while (true) {
                if (accept1(parser, PM_TOKEN_SEMICOLON)) {
                    flags |= PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS;
                } else if (!accept1(parser, PM_TOKEN_NEWLINE)) {
                    break;
                }
            }

            // If this is the end of the file or we match a right parenthesis, then
            // we have an empty parentheses node, and we can immediately return.
            if (match2(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_TOKEN_EOF)) {
                expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_EXPECT_RPAREN);

                pop_block_exits(parser, previous_block_exits);
                pm_node_list_free(¤t_block_exits);

                return (pm_node_t *) pm_parentheses_node_create(parser, &opening, NULL, &parser->previous, flags);
            }

            // Otherwise, we're going to parse the first statement in the list
            // of statements within the parentheses.
            pm_accepts_block_stack_push(parser, true);
            context_push(parser, PM_CONTEXT_PARENS);
            pm_node_t *statement = parse_expression(parser, PM_BINDING_POWER_STATEMENT, true, false, PM_ERR_CANNOT_PARSE_EXPRESSION, (uint16_t) (depth + 1));
            context_pop(parser);

            // Determine if this statement is followed by a terminator. In the
            // case of a single statement, this is fine. But in the case of
            // multiple statements it's required.
            bool terminator_found = false;

            if (accept1(parser, PM_TOKEN_SEMICOLON)) {
                terminator_found = true;
                flags |= PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS;
            } else if (accept1(parser, PM_TOKEN_NEWLINE)) {
                terminator_found = true;
            }

            if (terminator_found) {
                while (true) {
                    if (accept1(parser, PM_TOKEN_SEMICOLON)) {
                        flags |= PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS;
                    } else if (!accept1(parser, PM_TOKEN_NEWLINE)) {
                        break;
                    }
                }
            }

            // If we hit a right parenthesis, then we're done parsing the
            // parentheses node, and we can check which kind of node we should
            // return.
            if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
                if (opening.type == PM_TOKEN_PARENTHESIS_LEFT_PARENTHESES) {
                    lex_state_set(parser, PM_LEX_STATE_ENDARG);
                }

                parser_lex(parser);
                pm_accepts_block_stack_pop(parser);

                pop_block_exits(parser, previous_block_exits);
                pm_node_list_free(¤t_block_exits);

                if (PM_NODE_TYPE_P(statement, PM_MULTI_TARGET_NODE) || PM_NODE_TYPE_P(statement, PM_SPLAT_NODE)) {
                    // If we have a single statement and are ending on a right
                    // parenthesis, then we need to check if this is possibly a
                    // multiple target node.
                    pm_multi_target_node_t *multi_target;

                    if (PM_NODE_TYPE_P(statement, PM_MULTI_TARGET_NODE) && ((pm_multi_target_node_t *) statement)->lparen_loc.start == NULL) {
                        multi_target = (pm_multi_target_node_t *) statement;
                    } else {
                        multi_target = pm_multi_target_node_create(parser);
                        pm_multi_target_node_targets_append(parser, multi_target, statement);
                    }

                    pm_location_t lparen_loc = PM_LOCATION_TOKEN_VALUE(&opening);
                    pm_location_t rparen_loc = PM_LOCATION_TOKEN_VALUE(&parser->previous);

                    multi_target->lparen_loc = lparen_loc;
                    multi_target->rparen_loc = rparen_loc;
                    multi_target->base.location.start = lparen_loc.start;
                    multi_target->base.location.end = rparen_loc.end;

                    pm_node_t *result;
                    if (match1(parser, PM_TOKEN_COMMA) && (binding_power == PM_BINDING_POWER_STATEMENT)) {
                        result = parse_targets(parser, (pm_node_t *) multi_target, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
                        accept1(parser, PM_TOKEN_NEWLINE);
                    } else {
                        result = (pm_node_t *) multi_target;
                    }

                    if (context_p(parser, PM_CONTEXT_MULTI_TARGET)) {
                        // All set, this is explicitly allowed by the parent
                        // context.
                    } else if (context_p(parser, PM_CONTEXT_FOR_INDEX) && match1(parser, PM_TOKEN_KEYWORD_IN)) {
                        // All set, we're inside a for loop and we're parsing
                        // multiple targets.
                    } else if (binding_power != PM_BINDING_POWER_STATEMENT) {
                        // Multi targets are not allowed when it's not a
                        // statement level.
                        pm_parser_err_node(parser, result, PM_ERR_WRITE_TARGET_UNEXPECTED);
                    } else if (!match2(parser, PM_TOKEN_EQUAL, PM_TOKEN_PARENTHESIS_RIGHT)) {
                        // Multi targets must be followed by an equal sign in
                        // order to be valid (or a right parenthesis if they are
                        // nested).
                        pm_parser_err_node(parser, result, PM_ERR_WRITE_TARGET_UNEXPECTED);
                    }

                    return result;
                }

                // If we have a single statement and are ending on a right parenthesis
                // and we didn't return a multiple assignment node, then we can return a
                // regular parentheses node now.
                pm_statements_node_t *statements = pm_statements_node_create(parser);
                pm_statements_node_body_append(parser, statements, statement, true);

                return (pm_node_t *) pm_parentheses_node_create(parser, &opening, (pm_node_t *) statements, &parser->previous, flags);
            }

            // If we have more than one statement in the set of parentheses,
            // then we are going to parse all of them as a list of statements.
            // We'll do that here.
            context_push(parser, PM_CONTEXT_PARENS);
            flags |= PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS;

            pm_statements_node_t *statements = pm_statements_node_create(parser);
            pm_statements_node_body_append(parser, statements, statement, true);

            // If we didn't find a terminator and we didn't find a right
            // parenthesis, then this is a syntax error.
            if (!terminator_found && !match1(parser, PM_TOKEN_EOF)) {
                PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_type_human(parser->current.type));
            }

            // Parse each statement within the parentheses.
            while (true) {
                pm_node_t *node = parse_expression(parser, PM_BINDING_POWER_STATEMENT, true, false, PM_ERR_CANNOT_PARSE_EXPRESSION, (uint16_t) (depth + 1));
                pm_statements_node_body_append(parser, statements, node, true);

                // If we're recovering from a syntax error, then we need to stop
                // parsing the statements now.
                if (parser->recovering) {
                    // If this is the level of context where the recovery has
                    // happened, then we can mark the parser as done recovering.
                    if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) parser->recovering = false;
                    break;
                }

                // If we couldn't parse an expression at all, then we need to
                // bail out of the loop.
                if (PM_NODE_TYPE_P(node, PM_MISSING_NODE)) break;

                // If we successfully parsed a statement, then we are going to
                // need terminator to delimit them.
                if (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
                    while (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON));
                    if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) break;
                } else if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
                    break;
                } else if (!match1(parser, PM_TOKEN_EOF)) {
                    // If we're at the end of the file, then we're going to add
                    // an error after this for the ) anyway.
                    PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_type_human(parser->current.type));
                }
            }

            context_pop(parser);
            pm_accepts_block_stack_pop(parser);
            expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_EXPECT_RPAREN);

            // When we're parsing multi targets, we allow them to be followed by
            // a right parenthesis if they are at the statement level. This is
            // only possible if they are the final statement in a parentheses.
            // We need to explicitly reject that here.
            {
                pm_node_t *statement = statements->body.nodes[statements->body.size - 1];

                if (PM_NODE_TYPE_P(statement, PM_SPLAT_NODE)) {
                    pm_multi_target_node_t *multi_target = pm_multi_target_node_create(parser);
                    pm_multi_target_node_targets_append(parser, multi_target, statement);

                    statement = (pm_node_t *) multi_target;
                    statements->body.nodes[statements->body.size - 1] = statement;
                }

                if (PM_NODE_TYPE_P(statement, PM_MULTI_TARGET_NODE)) {
                    const uint8_t *offset = statement->location.end;
                    pm_token_t operator = { .type = PM_TOKEN_EQUAL, .start = offset, .end = offset };
                    pm_node_t *value = (pm_node_t *) pm_missing_node_create(parser, offset, offset);

                    statement = (pm_node_t *) pm_multi_write_node_create(parser, (pm_multi_target_node_t *) statement, &operator, value);
                    statements->body.nodes[statements->body.size - 1] = statement;

                    pm_parser_err_node(parser, statement, PM_ERR_WRITE_TARGET_UNEXPECTED);
                }
            }

            pop_block_exits(parser, previous_block_exits);
            pm_node_list_free(¤t_block_exits);

            pm_void_statements_check(parser, statements, true);
            return (pm_node_t *) pm_parentheses_node_create(parser, &opening, (pm_node_t *) statements, &parser->previous, flags);
        }
        case PM_TOKEN_BRACE_LEFT: {
            // If we were passed a current_hash_keys via the parser, then that
            // means we're already parsing a hash and we want to share the set
            // of hash keys with this inner hash we're about to parse for the
            // sake of warnings. We'll set it to NULL after we grab it to make
            // sure subsequent expressions don't use it. Effectively this is a
            // way of getting around passing it to every call to
            // parse_expression.
            pm_static_literals_t *current_hash_keys = parser->current_hash_keys;
            parser->current_hash_keys = NULL;

            pm_accepts_block_stack_push(parser, true);
            parser_lex(parser);

            pm_hash_node_t *node = pm_hash_node_create(parser, &parser->previous);

            if (!match2(parser, PM_TOKEN_BRACE_RIGHT, PM_TOKEN_EOF)) {
                if (current_hash_keys != NULL) {
                    parse_assocs(parser, current_hash_keys, (pm_node_t *) node, (uint16_t) (depth + 1));
                } else {
                    pm_static_literals_t hash_keys = { 0 };
                    parse_assocs(parser, &hash_keys, (pm_node_t *) node, (uint16_t) (depth + 1));
                    pm_static_literals_free(&hash_keys);
                }

                accept1(parser, PM_TOKEN_NEWLINE);
            }

            pm_accepts_block_stack_pop(parser);
            expect1(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_HASH_TERM);
            pm_hash_node_closing_loc_set(node, &parser->previous);

            return (pm_node_t *) node;
        }
        case PM_TOKEN_CHARACTER_LITERAL: {
            parser_lex(parser);

            pm_token_t opening = parser->previous;
            opening.type = PM_TOKEN_STRING_BEGIN;
            opening.end = opening.start + 1;

            pm_token_t content = parser->previous;
            content.type = PM_TOKEN_STRING_CONTENT;
            content.start = content.start + 1;

            pm_token_t closing = not_provided(parser);
            pm_node_t *node = (pm_node_t *) pm_string_node_create_current_string(parser, &opening, &content, &closing);
            pm_node_flag_set(node, parse_unescaped_encoding(parser));

            // Characters can be followed by strings in which case they are
            // automatically concatenated.
            if (match1(parser, PM_TOKEN_STRING_BEGIN)) {
                return parse_strings(parser, node, false, (uint16_t) (depth + 1));
            }

            return node;
        }
        case PM_TOKEN_CLASS_VARIABLE: {
            parser_lex(parser);
            pm_node_t *node = (pm_node_t *) pm_class_variable_read_node_create(parser, &parser->previous);

            if (binding_power == PM_BINDING_POWER_STATEMENT && match1(parser, PM_TOKEN_COMMA)) {
                node = parse_targets_validate(parser, node, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
            }

            return node;
        }
        case PM_TOKEN_CONSTANT: {
            parser_lex(parser);
            pm_token_t constant = parser->previous;

            // If a constant is immediately followed by parentheses, then this is in
            // fact a method call, not a constant read.
            if (
                match1(parser, PM_TOKEN_PARENTHESIS_LEFT) ||
                (accepts_command_call && (token_begins_expression_p(parser->current.type) || match3(parser, PM_TOKEN_UAMPERSAND, PM_TOKEN_USTAR, PM_TOKEN_USTAR_STAR))) ||
                (pm_accepts_block_stack_p(parser) && match1(parser, PM_TOKEN_KEYWORD_DO)) ||
                match1(parser, PM_TOKEN_BRACE_LEFT)
            ) {
                pm_arguments_t arguments = { 0 };
                parse_arguments_list(parser, &arguments, true, accepts_command_call, (uint16_t) (depth + 1));
                return (pm_node_t *) pm_call_node_fcall_create(parser, &constant, &arguments);
            }

            pm_node_t *node = (pm_node_t *) pm_constant_read_node_create(parser, &parser->previous);

            if ((binding_power == PM_BINDING_POWER_STATEMENT) && match1(parser, PM_TOKEN_COMMA)) {
                // If we get here, then we have a comma immediately following a
                // constant, so we're going to parse this as a multiple assignment.
                node = parse_targets_validate(parser, node, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
            }

            return node;
        }
        case PM_TOKEN_UCOLON_COLON: {
            parser_lex(parser);
            pm_token_t delimiter = parser->previous;

            expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
            pm_node_t *node = (pm_node_t *) pm_constant_path_node_create(parser, NULL, &delimiter, &parser->previous);

            if ((binding_power == PM_BINDING_POWER_STATEMENT) && match1(parser, PM_TOKEN_COMMA)) {
                node = parse_targets_validate(parser, node, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
            }

            return node;
        }
        case PM_TOKEN_UDOT_DOT:
        case PM_TOKEN_UDOT_DOT_DOT: {
            pm_token_t operator = parser->current;
            parser_lex(parser);

            pm_node_t *right = parse_expression(parser, pm_binding_powers[operator.type].left, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));

            // Unary .. and ... are special because these are non-associative
            // operators that can also be unary operators. In this case we need
            // to explicitly reject code that has a .. or ... that follows this
            // expression.
            if (match2(parser, PM_TOKEN_DOT_DOT, PM_TOKEN_DOT_DOT_DOT)) {
                pm_parser_err_current(parser, PM_ERR_UNEXPECTED_RANGE_OPERATOR);
            }

            return (pm_node_t *) pm_range_node_create(parser, NULL, &operator, right);
        }
        case PM_TOKEN_FLOAT:
            parser_lex(parser);
            return (pm_node_t *) pm_float_node_create(parser, &parser->previous);
        case PM_TOKEN_FLOAT_IMAGINARY:
            parser_lex(parser);
            return (pm_node_t *) pm_float_node_imaginary_create(parser, &parser->previous);
        case PM_TOKEN_FLOAT_RATIONAL:
            parser_lex(parser);
            return (pm_node_t *) pm_float_node_rational_create(parser, &parser->previous);
        case PM_TOKEN_FLOAT_RATIONAL_IMAGINARY:
            parser_lex(parser);
            return (pm_node_t *) pm_float_node_rational_imaginary_create(parser, &parser->previous);
        case PM_TOKEN_NUMBERED_REFERENCE: {
            parser_lex(parser);
            pm_node_t *node = (pm_node_t *) pm_numbered_reference_read_node_create(parser, &parser->previous);

            if (binding_power == PM_BINDING_POWER_STATEMENT && match1(parser, PM_TOKEN_COMMA)) {
                node = parse_targets_validate(parser, node, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
            }

            return node;
        }
        case PM_TOKEN_GLOBAL_VARIABLE: {
            parser_lex(parser);
            pm_node_t *node = (pm_node_t *) pm_global_variable_read_node_create(parser, &parser->previous);

            if (binding_power == PM_BINDING_POWER_STATEMENT && match1(parser, PM_TOKEN_COMMA)) {
                node = parse_targets_validate(parser, node, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
            }

            return node;
        }
        case PM_TOKEN_BACK_REFERENCE: {
            parser_lex(parser);
            pm_node_t *node = (pm_node_t *) pm_back_reference_read_node_create(parser, &parser->previous);

            if (binding_power == PM_BINDING_POWER_STATEMENT && match1(parser, PM_TOKEN_COMMA)) {
                node = parse_targets_validate(parser, node, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
            }

            return node;
        }
        case PM_TOKEN_IDENTIFIER:
        case PM_TOKEN_METHOD_NAME: {
            parser_lex(parser);
            pm_token_t identifier = parser->previous;
            pm_node_t *node = parse_variable_call(parser);

            if (PM_NODE_TYPE_P(node, PM_CALL_NODE)) {
                // If parse_variable_call returned with a call node, then we
                // know the identifier is not in the local table. In that case
                // we need to check if there are arguments following the
                // identifier.
                pm_call_node_t *call = (pm_call_node_t *) node;
                pm_arguments_t arguments = { 0 };

                if (parse_arguments_list(parser, &arguments, true, accepts_command_call, (uint16_t) (depth + 1))) {
                    // Since we found arguments, we need to turn off the
                    // variable call bit in the flags.
                    pm_node_flag_unset((pm_node_t *)call, PM_CALL_NODE_FLAGS_VARIABLE_CALL);

                    call->opening_loc = arguments.opening_loc;
                    call->arguments = arguments.arguments;
                    call->closing_loc = arguments.closing_loc;
                    call->block = arguments.block;

                    const uint8_t *end = pm_arguments_end(&arguments);
                    if (!end) {
                        end = call->message_loc.end;
                    }
                    call->base.location.end = end;
                }
            } else {
                // Otherwise, we know the identifier is in the local table. This
                // can still be a method call if it is followed by arguments or
                // a block, so we need to check for that here.
                if (
                    (accepts_command_call && (token_begins_expression_p(parser->current.type) || match3(parser, PM_TOKEN_UAMPERSAND, PM_TOKEN_USTAR, PM_TOKEN_USTAR_STAR))) ||
                    (pm_accepts_block_stack_p(parser) && match1(parser, PM_TOKEN_KEYWORD_DO)) ||
                    match1(parser, PM_TOKEN_BRACE_LEFT)
                ) {
                    pm_arguments_t arguments = { 0 };
                    parse_arguments_list(parser, &arguments, true, accepts_command_call, (uint16_t) (depth + 1));
                    pm_call_node_t *fcall = pm_call_node_fcall_create(parser, &identifier, &arguments);

                    if (PM_NODE_TYPE_P(node, PM_IT_LOCAL_VARIABLE_READ_NODE)) {
                        // If we're about to convert an 'it' implicit local
                        // variable read into a method call, we need to remove
                        // it from the list of implicit local variables.
                        parse_target_implicit_parameter(parser, node);
                    } else {
                        // Otherwise, we're about to convert a regular local
                        // variable read into a method call, in which case we
                        // need to indicate that this was not a read for the
                        // purposes of warnings.
                        assert(PM_NODE_TYPE_P(node, PM_LOCAL_VARIABLE_READ_NODE));

                        if (pm_token_is_numbered_parameter(identifier.start, identifier.end)) {
                            parse_target_implicit_parameter(parser, node);
                        } else {
                            pm_local_variable_read_node_t *cast = (pm_local_variable_read_node_t *) node;
                            pm_locals_unread(&pm_parser_scope_find(parser, cast->depth)->locals, cast->name);
                        }
                    }

                    pm_node_destroy(parser, node);
                    return (pm_node_t *) fcall;
                }
            }

            if ((binding_power == PM_BINDING_POWER_STATEMENT) && match1(parser, PM_TOKEN_COMMA)) {
                node = parse_targets_validate(parser, node, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
            }

            return node;
        }
        case PM_TOKEN_HEREDOC_START: {
            // Here we have found a heredoc. We'll parse it and add it to the
            // list of strings.
            assert(parser->lex_modes.current->mode == PM_LEX_HEREDOC);
            pm_heredoc_lex_mode_t lex_mode = parser->lex_modes.current->as.heredoc.base;

            size_t common_whitespace = (size_t) -1;
            parser->lex_modes.current->as.heredoc.common_whitespace = &common_whitespace;

            parser_lex(parser);
            pm_token_t opening = parser->previous;

            pm_node_t *node;
            pm_node_t *part;

            if (match2(parser, PM_TOKEN_HEREDOC_END, PM_TOKEN_EOF)) {
                // If we get here, then we have an empty heredoc. We'll create
                // an empty content token and return an empty string node.
                expect1_heredoc_term(parser, lex_mode.ident_start, lex_mode.ident_length);
                pm_token_t content = parse_strings_empty_content(parser->previous.start);

                if (lex_mode.quote == PM_HEREDOC_QUOTE_BACKTICK) {
                    node = (pm_node_t *) pm_xstring_node_create_unescaped(parser, &opening, &content, &parser->previous, &PM_STRING_EMPTY);
                } else {
                    node = (pm_node_t *) pm_string_node_create_unescaped(parser, &opening, &content, &parser->previous, &PM_STRING_EMPTY);
                }

                node->location.end = opening.end;
            } else if ((part = parse_string_part(parser, (uint16_t) (depth + 1))) == NULL) {
                // If we get here, then we tried to find something in the
                // heredoc but couldn't actually parse anything, so we'll just
                // return a missing node.
                //
                // parse_string_part handles its own errors, so there is no need
                // for us to add one here.
                node = (pm_node_t *) pm_missing_node_create(parser, parser->previous.start, parser->previous.end);
            } else if (PM_NODE_TYPE_P(part, PM_STRING_NODE) && match2(parser, PM_TOKEN_HEREDOC_END, PM_TOKEN_EOF)) {
                // If we get here, then the part that we parsed was plain string
                // content and we're at the end of the heredoc, so we can return
                // just a string node with the heredoc opening and closing as
                // its opening and closing.
                pm_node_flag_set(part, parse_unescaped_encoding(parser));
                pm_string_node_t *cast = (pm_string_node_t *) part;

                cast->opening_loc = PM_LOCATION_TOKEN_VALUE(&opening);
                cast->closing_loc = PM_LOCATION_TOKEN_VALUE(&parser->current);
                cast->base.location = cast->opening_loc;

                if (lex_mode.quote == PM_HEREDOC_QUOTE_BACKTICK) {
                    assert(sizeof(pm_string_node_t) == sizeof(pm_x_string_node_t));
                    cast->base.type = PM_X_STRING_NODE;
                }

                if (lex_mode.indent == PM_HEREDOC_INDENT_TILDE && (common_whitespace != (size_t) -1) && (common_whitespace != 0)) {
                    parse_heredoc_dedent_string(&cast->unescaped, common_whitespace);
                }

                node = (pm_node_t *) cast;
                expect1_heredoc_term(parser, lex_mode.ident_start, lex_mode.ident_length);
            } else {
                // If we get here, then we have multiple parts in the heredoc,
                // so we'll need to create an interpolated string node to hold
                // them all.
                pm_node_list_t parts = { 0 };
                pm_node_list_append(&parts, part);

                while (!match2(parser, PM_TOKEN_HEREDOC_END, PM_TOKEN_EOF)) {
                    if ((part = parse_string_part(parser, (uint16_t) (depth + 1))) != NULL) {
                        pm_node_list_append(&parts, part);
                    }
                }

                // Now that we have all of the parts, create the correct type of
                // interpolated node.
                if (lex_mode.quote == PM_HEREDOC_QUOTE_BACKTICK) {
                    pm_interpolated_x_string_node_t *cast = pm_interpolated_xstring_node_create(parser, &opening, &opening);
                    cast->parts = parts;

                    expect1_heredoc_term(parser, lex_mode.ident_start, lex_mode.ident_length);
                    pm_interpolated_xstring_node_closing_set(cast, &parser->previous);

                    cast->base.location = cast->opening_loc;
                    node = (pm_node_t *) cast;
                } else {
                    pm_interpolated_string_node_t *cast = pm_interpolated_string_node_create(parser, &opening, &parts, &opening);
                    pm_node_list_free(&parts);

                    expect1_heredoc_term(parser, lex_mode.ident_start, lex_mode.ident_length);
                    pm_interpolated_string_node_closing_set(cast, &parser->previous);

                    cast->base.location = cast->opening_loc;
                    node = (pm_node_t *) cast;
                }

                // If this is a heredoc that is indented with a ~, then we need
                // to dedent each line by the common leading whitespace.
                if (lex_mode.indent == PM_HEREDOC_INDENT_TILDE && (common_whitespace != (size_t) -1) && (common_whitespace != 0)) {
                    pm_node_list_t *nodes;
                    if (lex_mode.quote == PM_HEREDOC_QUOTE_BACKTICK) {
                        nodes = &((pm_interpolated_x_string_node_t *) node)->parts;
                    } else {
                        nodes = &((pm_interpolated_string_node_t *) node)->parts;
                    }

                    parse_heredoc_dedent(parser, nodes, common_whitespace);
                }
            }

            if (match1(parser, PM_TOKEN_STRING_BEGIN)) {
                return parse_strings(parser, node, false, (uint16_t) (depth + 1));
            }

            return node;
        }
        case PM_TOKEN_INSTANCE_VARIABLE: {
            parser_lex(parser);
            pm_node_t *node = (pm_node_t *) pm_instance_variable_read_node_create(parser, &parser->previous);

            if (binding_power == PM_BINDING_POWER_STATEMENT && match1(parser, PM_TOKEN_COMMA)) {
                node = parse_targets_validate(parser, node, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
            }

            return node;
        }
        case PM_TOKEN_INTEGER: {
            pm_node_flags_t base = parser->integer_base;
            parser_lex(parser);
            return (pm_node_t *) pm_integer_node_create(parser, base, &parser->previous);
        }
        case PM_TOKEN_INTEGER_IMAGINARY: {
            pm_node_flags_t base = parser->integer_base;
            parser_lex(parser);
            return (pm_node_t *) pm_integer_node_imaginary_create(parser, base, &parser->previous);
        }
        case PM_TOKEN_INTEGER_RATIONAL: {
            pm_node_flags_t base = parser->integer_base;
            parser_lex(parser);
            return (pm_node_t *) pm_integer_node_rational_create(parser, base, &parser->previous);
        }
        case PM_TOKEN_INTEGER_RATIONAL_IMAGINARY: {
            pm_node_flags_t base = parser->integer_base;
            parser_lex(parser);
            return (pm_node_t *) pm_integer_node_rational_imaginary_create(parser, base, &parser->previous);
        }
        case PM_TOKEN_KEYWORD___ENCODING__:
            parser_lex(parser);
            return (pm_node_t *) pm_source_encoding_node_create(parser, &parser->previous);
        case PM_TOKEN_KEYWORD___FILE__:
            parser_lex(parser);
            return (pm_node_t *) pm_source_file_node_create(parser, &parser->previous);
        case PM_TOKEN_KEYWORD___LINE__:
            parser_lex(parser);
            return (pm_node_t *) pm_source_line_node_create(parser, &parser->previous);
        case PM_TOKEN_KEYWORD_ALIAS: {
            if (binding_power != PM_BINDING_POWER_STATEMENT) {
                pm_parser_err_current(parser, PM_ERR_STATEMENT_ALIAS);
            }

            parser_lex(parser);
            pm_token_t keyword = parser->previous;

            pm_node_t *new_name = parse_alias_argument(parser, true, (uint16_t) (depth + 1));
            pm_node_t *old_name = parse_alias_argument(parser, false, (uint16_t) (depth + 1));

            switch (PM_NODE_TYPE(new_name)) {
                case PM_BACK_REFERENCE_READ_NODE:
                case PM_NUMBERED_REFERENCE_READ_NODE:
                case PM_GLOBAL_VARIABLE_READ_NODE: {
                    if (PM_NODE_TYPE_P(old_name, PM_BACK_REFERENCE_READ_NODE) || PM_NODE_TYPE_P(old_name, PM_NUMBERED_REFERENCE_READ_NODE) || PM_NODE_TYPE_P(old_name, PM_GLOBAL_VARIABLE_READ_NODE)) {
                        if (PM_NODE_TYPE_P(old_name, PM_NUMBERED_REFERENCE_READ_NODE)) {
                            pm_parser_err_node(parser, old_name, PM_ERR_ALIAS_ARGUMENT_NUMBERED_REFERENCE);
                        }
                    } else {
                        pm_parser_err_node(parser, old_name, PM_ERR_ALIAS_ARGUMENT);
                    }

                    return (pm_node_t *) pm_alias_global_variable_node_create(parser, &keyword, new_name, old_name);
                }
                case PM_SYMBOL_NODE:
                case PM_INTERPOLATED_SYMBOL_NODE: {
                    if (!PM_NODE_TYPE_P(old_name, PM_SYMBOL_NODE) && !PM_NODE_TYPE_P(old_name, PM_INTERPOLATED_SYMBOL_NODE)) {
                        pm_parser_err_node(parser, old_name, PM_ERR_ALIAS_ARGUMENT);
                    }
                }
                PRISM_FALLTHROUGH
                default:
                    return (pm_node_t *) pm_alias_method_node_create(parser, &keyword, new_name, old_name);
            }
        }
        case PM_TOKEN_KEYWORD_CASE: {
            size_t opening_newline_index = token_newline_index(parser);
            parser_lex(parser);

            pm_token_t case_keyword = parser->previous;
            pm_node_t *predicate = NULL;

            pm_node_list_t current_block_exits = { 0 };
            pm_node_list_t *previous_block_exits = push_block_exits(parser, ¤t_block_exits);

            if (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
                while (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON));
                predicate = NULL;
            } else if (match3(parser, PM_TOKEN_KEYWORD_WHEN, PM_TOKEN_KEYWORD_IN, PM_TOKEN_KEYWORD_END)) {
                predicate = NULL;
             } else if (!token_begins_expression_p(parser->current.type)) {
                predicate = NULL;
            } else {
                predicate = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, true, false, PM_ERR_CASE_EXPRESSION_AFTER_CASE, (uint16_t) (depth + 1));
                while (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON));
            }

            if (match1(parser, PM_TOKEN_KEYWORD_END)) {
                parser_warn_indentation_mismatch(parser, opening_newline_index, &case_keyword, false, false);
                parser_lex(parser);

                pop_block_exits(parser, previous_block_exits);
                pm_node_list_free(¤t_block_exits);

                pm_parser_err_token(parser, &case_keyword, PM_ERR_CASE_MISSING_CONDITIONS);
                return (pm_node_t *) pm_case_node_create(parser, &case_keyword, predicate, &parser->previous);
            }

            // At this point we can create a case node, though we don't yet know
            // if it is a case-in or case-when node.
            pm_token_t end_keyword = not_provided(parser);
            pm_node_t *node;

            if (match1(parser, PM_TOKEN_KEYWORD_WHEN)) {
                pm_case_node_t *case_node = pm_case_node_create(parser, &case_keyword, predicate, &end_keyword);
                pm_static_literals_t literals = { 0 };

                // At this point we've seen a when keyword, so we know this is a
                // case-when node. We will continue to parse the when nodes
                // until we hit the end of the list.
                while (match1(parser, PM_TOKEN_KEYWORD_WHEN)) {
                    parser_warn_indentation_mismatch(parser, opening_newline_index, &case_keyword, false, true);
                    parser_lex(parser);

                    pm_token_t when_keyword = parser->previous;
                    pm_when_node_t *when_node = pm_when_node_create(parser, &when_keyword);

                    do {
                        if (accept1(parser, PM_TOKEN_USTAR)) {
                            pm_token_t operator = parser->previous;
                            pm_node_t *expression = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_STAR, (uint16_t) (depth + 1));

                            pm_splat_node_t *splat_node = pm_splat_node_create(parser, &operator, expression);
                            pm_when_node_conditions_append(when_node, (pm_node_t *) splat_node);

                            if (PM_NODE_TYPE_P(expression, PM_MISSING_NODE)) break;
                        } else {
                            pm_node_t *condition = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_CASE_EXPRESSION_AFTER_WHEN, (uint16_t) (depth + 1));
                            pm_when_node_conditions_append(when_node, condition);

                            // If we found a missing node, then this is a syntax
                            // error and we should stop looping.
                            if (PM_NODE_TYPE_P(condition, PM_MISSING_NODE)) break;

                            // If this is a string node, then we need to mark it
                            // as frozen because when clause strings are frozen.
                            if (PM_NODE_TYPE_P(condition, PM_STRING_NODE)) {
                                pm_node_flag_set(condition, PM_STRING_FLAGS_FROZEN | PM_NODE_FLAG_STATIC_LITERAL);
                            } else if (PM_NODE_TYPE_P(condition, PM_SOURCE_FILE_NODE)) {
                                pm_node_flag_set(condition, PM_NODE_FLAG_STATIC_LITERAL);
                            }

                            pm_when_clause_static_literals_add(parser, &literals, condition);
                        }
                    } while (accept1(parser, PM_TOKEN_COMMA));

                    if (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
                        if (accept1(parser, PM_TOKEN_KEYWORD_THEN)) {
                            pm_when_node_then_keyword_loc_set(when_node, &parser->previous);
                        }
                    } else {
                        expect1(parser, PM_TOKEN_KEYWORD_THEN, PM_ERR_EXPECT_WHEN_DELIMITER);
                        pm_when_node_then_keyword_loc_set(when_node, &parser->previous);
                    }

                    if (!match3(parser, PM_TOKEN_KEYWORD_WHEN, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
                        pm_statements_node_t *statements = parse_statements(parser, PM_CONTEXT_CASE_WHEN, (uint16_t) (depth + 1));
                        if (statements != NULL) {
                            pm_when_node_statements_set(when_node, statements);
                        }
                    }

                    pm_case_node_condition_append(case_node, (pm_node_t *) when_node);
                }

                // If we didn't parse any conditions (in or when) then we need
                // to indicate that we have an error.
                if (case_node->conditions.size == 0) {
                    pm_parser_err_token(parser, &case_keyword, PM_ERR_CASE_MISSING_CONDITIONS);
                }

                pm_static_literals_free(&literals);
                node = (pm_node_t *) case_node;
            } else {
                pm_case_match_node_t *case_node = pm_case_match_node_create(parser, &case_keyword, predicate, &end_keyword);

                // If this is a case-match node (i.e., it is a pattern matching
                // case statement) then we must have a predicate.
                if (predicate == NULL) {
                    pm_parser_err_token(parser, &case_keyword, PM_ERR_CASE_MATCH_MISSING_PREDICATE);
                }

                // At this point we expect that we're parsing a case-in node. We
                // will continue to parse the in nodes until we hit the end of
                // the list.
                while (match1(parser, PM_TOKEN_KEYWORD_IN)) {
                    parser_warn_indentation_mismatch(parser, opening_newline_index, &case_keyword, false, true);

                    bool previous_pattern_matching_newlines = parser->pattern_matching_newlines;
                    parser->pattern_matching_newlines = true;

                    lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
                    parser->command_start = false;
                    parser_lex(parser);

                    pm_token_t in_keyword = parser->previous;

                    pm_constant_id_list_t captures = { 0 };
                    pm_node_t *pattern = parse_pattern(parser, &captures, PM_PARSE_PATTERN_TOP | PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_IN, (uint16_t) (depth + 1));

                    parser->pattern_matching_newlines = previous_pattern_matching_newlines;
                    pm_constant_id_list_free(&captures);

                    // Since we're in the top-level of the case-in node we need
                    // to check for guard clauses in the form of `if` or
                    // `unless` statements.
                    if (accept1(parser, PM_TOKEN_KEYWORD_IF_MODIFIER)) {
                        pm_token_t keyword = parser->previous;
                        pm_node_t *predicate = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, true, false, PM_ERR_CONDITIONAL_IF_PREDICATE, (uint16_t) (depth + 1));
                        pattern = (pm_node_t *) pm_if_node_modifier_create(parser, pattern, &keyword, predicate);
                    } else if (accept1(parser, PM_TOKEN_KEYWORD_UNLESS_MODIFIER)) {
                        pm_token_t keyword = parser->previous;
                        pm_node_t *predicate = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, true, false, PM_ERR_CONDITIONAL_UNLESS_PREDICATE, (uint16_t) (depth + 1));
                        pattern = (pm_node_t *) pm_unless_node_modifier_create(parser, pattern, &keyword, predicate);
                    }

                    // Now we need to check for the terminator of the in node's
                    // pattern. It can be a newline or semicolon optionally
                    // followed by a `then` keyword.
                    pm_token_t then_keyword;
                    if (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
                        if (accept1(parser, PM_TOKEN_KEYWORD_THEN)) {
                            then_keyword = parser->previous;
                        } else {
                            then_keyword = not_provided(parser);
                        }
                    } else {
                        expect1(parser, PM_TOKEN_KEYWORD_THEN, PM_ERR_EXPECT_IN_DELIMITER);
                        then_keyword = parser->previous;
                    }

                    // Now we can actually parse the statements associated with
                    // the in node.
                    pm_statements_node_t *statements;
                    if (match3(parser, PM_TOKEN_KEYWORD_IN, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
                        statements = NULL;
                    } else {
                        statements = parse_statements(parser, PM_CONTEXT_CASE_IN, (uint16_t) (depth + 1));
                    }

                    // Now that we have the full pattern and statements, we can
                    // create the node and attach it to the case node.
                    pm_node_t *condition = (pm_node_t *) pm_in_node_create(parser, pattern, statements, &in_keyword, &then_keyword);
                    pm_case_match_node_condition_append(case_node, condition);
                }

                // If we didn't parse any conditions (in or when) then we need
                // to indicate that we have an error.
                if (case_node->conditions.size == 0) {
                    pm_parser_err_token(parser, &case_keyword, PM_ERR_CASE_MISSING_CONDITIONS);
                }

                node = (pm_node_t *) case_node;
            }

            accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
            if (accept1(parser, PM_TOKEN_KEYWORD_ELSE)) {
                pm_token_t else_keyword = parser->previous;
                pm_else_node_t *else_node;

                if (!match1(parser, PM_TOKEN_KEYWORD_END)) {
                    else_node = pm_else_node_create(parser, &else_keyword, parse_statements(parser, PM_CONTEXT_ELSE, (uint16_t) (depth + 1)), &parser->current);
                } else {
                    else_node = pm_else_node_create(parser, &else_keyword, NULL, &parser->current);
                }

                if (PM_NODE_TYPE_P(node, PM_CASE_NODE)) {
                    pm_case_node_else_clause_set((pm_case_node_t *) node, else_node);
                } else {
                    pm_case_match_node_else_clause_set((pm_case_match_node_t *) node, else_node);
                }
            }

            parser_warn_indentation_mismatch(parser, opening_newline_index, &case_keyword, false, false);
            expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CASE_TERM);

            if (PM_NODE_TYPE_P(node, PM_CASE_NODE)) {
                pm_case_node_end_keyword_loc_set((pm_case_node_t *) node, &parser->previous);
            } else {
                pm_case_match_node_end_keyword_loc_set((pm_case_match_node_t *) node, &parser->previous);
            }

            pop_block_exits(parser, previous_block_exits);
            pm_node_list_free(¤t_block_exits);

            return node;
        }
        case PM_TOKEN_KEYWORD_BEGIN: {
            size_t opening_newline_index = token_newline_index(parser);
            parser_lex(parser);

            pm_token_t begin_keyword = parser->previous;
            accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);

            pm_node_list_t current_block_exits = { 0 };
            pm_node_list_t *previous_block_exits = push_block_exits(parser, ¤t_block_exits);
            pm_statements_node_t *begin_statements = NULL;

            if (!match4(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
                pm_accepts_block_stack_push(parser, true);
                begin_statements = parse_statements(parser, PM_CONTEXT_BEGIN, (uint16_t) (depth + 1));
                pm_accepts_block_stack_pop(parser);
                accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
            }

            pm_begin_node_t *begin_node = pm_begin_node_create(parser, &begin_keyword, begin_statements);
            parse_rescues(parser, opening_newline_index, &begin_keyword, begin_node, PM_RESCUES_BEGIN, (uint16_t) (depth + 1));
            expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_BEGIN_TERM);

            begin_node->base.location.end = parser->previous.end;
            pm_begin_node_end_keyword_set(begin_node, &parser->previous);

            pop_block_exits(parser, previous_block_exits);
            pm_node_list_free(¤t_block_exits);

            return (pm_node_t *) begin_node;
        }
        case PM_TOKEN_KEYWORD_BEGIN_UPCASE: {
            pm_node_list_t current_block_exits = { 0 };
            pm_node_list_t *previous_block_exits = push_block_exits(parser, ¤t_block_exits);

            if (binding_power != PM_BINDING_POWER_STATEMENT) {
                pm_parser_err_current(parser, PM_ERR_STATEMENT_PREEXE_BEGIN);
            }

            parser_lex(parser);
            pm_token_t keyword = parser->previous;

            expect1(parser, PM_TOKEN_BRACE_LEFT, PM_ERR_BEGIN_UPCASE_BRACE);
            pm_token_t opening = parser->previous;
            pm_statements_node_t *statements = parse_statements(parser, PM_CONTEXT_PREEXE, (uint16_t) (depth + 1));

            expect1(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_BEGIN_UPCASE_TERM);
            pm_context_t context = parser->current_context->context;
            if ((context != PM_CONTEXT_MAIN) && (context != PM_CONTEXT_PREEXE)) {
                pm_parser_err_token(parser, &keyword, PM_ERR_BEGIN_UPCASE_TOPLEVEL);
            }

            flush_block_exits(parser, previous_block_exits);
            pm_node_list_free(¤t_block_exits);

            return (pm_node_t *) pm_pre_execution_node_create(parser, &keyword, &opening, statements, &parser->previous);
        }
        case PM_TOKEN_KEYWORD_BREAK:
        case PM_TOKEN_KEYWORD_NEXT:
        case PM_TOKEN_KEYWORD_RETURN: {
            parser_lex(parser);

            pm_token_t keyword = parser->previous;
            pm_arguments_t arguments = { 0 };

            if (
                token_begins_expression_p(parser->current.type) ||
                match2(parser, PM_TOKEN_USTAR, PM_TOKEN_USTAR_STAR)
            ) {
                pm_binding_power_t binding_power = pm_binding_powers[parser->current.type].left;

                if (binding_power == PM_BINDING_POWER_UNSET || binding_power >= PM_BINDING_POWER_RANGE) {
                    pm_token_t next = parser->current;
                    parse_arguments(parser, &arguments, false, PM_TOKEN_EOF, (uint16_t) (depth + 1));

                    // Reject `foo && return bar`.
                    if (!accepts_command_call && arguments.arguments != NULL) {
                        PM_PARSER_ERR_TOKEN_FORMAT(parser, next, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_type_human(next.type));
                    }
                }
            }

            switch (keyword.type) {
                case PM_TOKEN_KEYWORD_BREAK: {
                    pm_node_t *node = (pm_node_t *) pm_break_node_create(parser, &keyword, arguments.arguments);
                    if (!parser->partial_script) parse_block_exit(parser, node);
                    return node;
                }
                case PM_TOKEN_KEYWORD_NEXT: {
                    pm_node_t *node = (pm_node_t *) pm_next_node_create(parser, &keyword, arguments.arguments);
                    if (!parser->partial_script) parse_block_exit(parser, node);
                    return node;
                }
                case PM_TOKEN_KEYWORD_RETURN: {
                    pm_node_t *node = (pm_node_t *) pm_return_node_create(parser, &keyword, arguments.arguments);
                    parse_return(parser, node);
                    return node;
                }
                default:
                    assert(false && "unreachable");
                    return (pm_node_t *) pm_missing_node_create(parser, parser->previous.start, parser->previous.end);
            }
        }
        case PM_TOKEN_KEYWORD_SUPER: {
            parser_lex(parser);

            pm_token_t keyword = parser->previous;
            pm_arguments_t arguments = { 0 };
            parse_arguments_list(parser, &arguments, true, accepts_command_call, (uint16_t) (depth + 1));

            if (
                arguments.opening_loc.start == NULL &&
                arguments.arguments == NULL &&
                ((arguments.block == NULL) || PM_NODE_TYPE_P(arguments.block, PM_BLOCK_NODE))
            ) {
                return (pm_node_t *) pm_forwarding_super_node_create(parser, &keyword, &arguments);
            }

            return (pm_node_t *) pm_super_node_create(parser, &keyword, &arguments);
        }
        case PM_TOKEN_KEYWORD_YIELD: {
            parser_lex(parser);

            pm_token_t keyword = parser->previous;
            pm_arguments_t arguments = { 0 };
            parse_arguments_list(parser, &arguments, false, accepts_command_call, (uint16_t) (depth + 1));

            // It's possible that we've parsed a block argument through our
            // call to parse_arguments_list. If we found one, we should mark it
            // as invalid and destroy it, as we don't have a place for it on the
            // yield node.
            if (arguments.block != NULL) {
                pm_parser_err_node(parser, arguments.block, PM_ERR_UNEXPECTED_BLOCK_ARGUMENT);
                pm_node_destroy(parser, arguments.block);
                arguments.block = NULL;
            }

            pm_node_t *node = (pm_node_t *) pm_yield_node_create(parser, &keyword, &arguments.opening_loc, arguments.arguments, &arguments.closing_loc);
            if (!parser->parsing_eval && !parser->partial_script) parse_yield(parser, node);

            return node;
        }
        case PM_TOKEN_KEYWORD_CLASS: {
            size_t opening_newline_index = token_newline_index(parser);
            parser_lex(parser);

            pm_token_t class_keyword = parser->previous;
            pm_do_loop_stack_push(parser, false);

            pm_node_list_t current_block_exits = { 0 };
            pm_node_list_t *previous_block_exits = push_block_exits(parser, ¤t_block_exits);

            if (accept1(parser, PM_TOKEN_LESS_LESS)) {
                pm_token_t operator = parser->previous;
                pm_node_t *expression = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, true, false, PM_ERR_EXPECT_EXPRESSION_AFTER_LESS_LESS, (uint16_t) (depth + 1));

                pm_parser_scope_push(parser, true);
                if (!match2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
                    PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_EXPECT_SINGLETON_CLASS_DELIMITER, pm_token_type_human(parser->current.type));
                }

                pm_node_t *statements = NULL;
                if (!match4(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
                    pm_accepts_block_stack_push(parser, true);
                    statements = (pm_node_t *) parse_statements(parser, PM_CONTEXT_SCLASS, (uint16_t) (depth + 1));
                    pm_accepts_block_stack_pop(parser);
                }

                if (match2(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE)) {
                    assert(statements == NULL || PM_NODE_TYPE_P(statements, PM_STATEMENTS_NODE));
                    statements = (pm_node_t *) parse_rescues_implicit_begin(parser, opening_newline_index, &class_keyword, class_keyword.start, (pm_statements_node_t *) statements, PM_RESCUES_SCLASS, (uint16_t) (depth + 1));
                } else {
                    parser_warn_indentation_mismatch(parser, opening_newline_index, &class_keyword, false, false);
                }

                expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CLASS_TERM);

                pm_constant_id_list_t locals;
                pm_locals_order(parser, &parser->current_scope->locals, &locals, false);

                pm_parser_scope_pop(parser);
                pm_do_loop_stack_pop(parser);

                flush_block_exits(parser, previous_block_exits);
                pm_node_list_free(¤t_block_exits);

                return (pm_node_t *) pm_singleton_class_node_create(parser, &locals, &class_keyword, &operator, expression, statements, &parser->previous);
            }

            pm_node_t *constant_path = parse_expression(parser, PM_BINDING_POWER_INDEX, false, false, PM_ERR_CLASS_NAME, (uint16_t) (depth + 1));
            pm_token_t name = parser->previous;
            if (name.type != PM_TOKEN_CONSTANT) {
                pm_parser_err_token(parser, &name, PM_ERR_CLASS_NAME);
            }

            pm_token_t inheritance_operator;
            pm_node_t *superclass;

            if (match1(parser, PM_TOKEN_LESS)) {
                inheritance_operator = parser->current;
                lex_state_set(parser, PM_LEX_STATE_BEG);

                parser->command_start = true;
                parser_lex(parser);

                superclass = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, true, false, PM_ERR_CLASS_SUPERCLASS, (uint16_t) (depth + 1));
            } else {
                inheritance_operator = not_provided(parser);
                superclass = NULL;
            }

            pm_parser_scope_push(parser, true);

            if (inheritance_operator.type != PM_TOKEN_NOT_PROVIDED) {
                expect2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON, PM_ERR_CLASS_UNEXPECTED_END);
            } else {
                accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
            }
            pm_node_t *statements = NULL;

            if (!match4(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
                pm_accepts_block_stack_push(parser, true);
                statements = (pm_node_t *) parse_statements(parser, PM_CONTEXT_CLASS, (uint16_t) (depth + 1));
                pm_accepts_block_stack_pop(parser);
            }

            if (match2(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE)) {
                assert(statements == NULL || PM_NODE_TYPE_P(statements, PM_STATEMENTS_NODE));
                statements = (pm_node_t *) parse_rescues_implicit_begin(parser, opening_newline_index, &class_keyword, class_keyword.start, (pm_statements_node_t *) statements, PM_RESCUES_CLASS, (uint16_t) (depth + 1));
            } else {
                parser_warn_indentation_mismatch(parser, opening_newline_index, &class_keyword, false, false);
            }

            expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CLASS_TERM);

            if (context_def_p(parser)) {
                pm_parser_err_token(parser, &class_keyword, PM_ERR_CLASS_IN_METHOD);
            }

            pm_constant_id_list_t locals;
            pm_locals_order(parser, &parser->current_scope->locals, &locals, false);

            pm_parser_scope_pop(parser);
            pm_do_loop_stack_pop(parser);

            if (!PM_NODE_TYPE_P(constant_path, PM_CONSTANT_PATH_NODE) && !(PM_NODE_TYPE_P(constant_path, PM_CONSTANT_READ_NODE))) {
                pm_parser_err_node(parser, constant_path, PM_ERR_CLASS_NAME);
            }

            pop_block_exits(parser, previous_block_exits);
            pm_node_list_free(¤t_block_exits);

            return (pm_node_t *) pm_class_node_create(parser, &locals, &class_keyword, constant_path, &name, &inheritance_operator, superclass, statements, &parser->previous);
        }
        case PM_TOKEN_KEYWORD_DEF: {
            pm_node_list_t current_block_exits = { 0 };
            pm_node_list_t *previous_block_exits = push_block_exits(parser, ¤t_block_exits);

            pm_token_t def_keyword = parser->current;
            size_t opening_newline_index = token_newline_index(parser);

            pm_node_t *receiver = NULL;
            pm_token_t operator = not_provided(parser);
            pm_token_t name;

            // This context is necessary for lexing `...` in a bare params
            // correctly. It must be pushed before lexing the first param, so it
            // is here.
            context_push(parser, PM_CONTEXT_DEF_PARAMS);
            parser_lex(parser);

            // This will be false if the method name is not a valid identifier
            // but could be followed by an operator.
            bool valid_name = true;

            switch (parser->current.type) {
                case PM_CASE_OPERATOR:
                    pm_parser_scope_push(parser, true);
                    lex_state_set(parser, PM_LEX_STATE_ENDFN);
                    parser_lex(parser);

                    name = parser->previous;
                    break;
                case PM_TOKEN_IDENTIFIER: {
                    parser_lex(parser);

                    if (match2(parser, PM_TOKEN_DOT, PM_TOKEN_COLON_COLON)) {
                        receiver = parse_variable_call(parser);

                        pm_parser_scope_push(parser, true);
                        lex_state_set(parser, PM_LEX_STATE_FNAME);
                        parser_lex(parser);

                        operator = parser->previous;
                        name = parse_method_definition_name(parser);
                    } else {
                        pm_refute_numbered_parameter(parser, parser->previous.start, parser->previous.end);
                        pm_parser_scope_push(parser, true);

                        name = parser->previous;
                    }

                    break;
                }
                case PM_TOKEN_INSTANCE_VARIABLE:
                case PM_TOKEN_CLASS_VARIABLE:
                case PM_TOKEN_GLOBAL_VARIABLE:
                    valid_name = false;
                    PRISM_FALLTHROUGH
                case PM_TOKEN_CONSTANT:
                case PM_TOKEN_KEYWORD_NIL:
                case PM_TOKEN_KEYWORD_SELF:
                case PM_TOKEN_KEYWORD_TRUE:
                case PM_TOKEN_KEYWORD_FALSE:
                case PM_TOKEN_KEYWORD___FILE__:
                case PM_TOKEN_KEYWORD___LINE__:
                case PM_TOKEN_KEYWORD___ENCODING__: {
                    pm_parser_scope_push(parser, true);
                    parser_lex(parser);

                    pm_token_t identifier = parser->previous;

                    if (match2(parser, PM_TOKEN_DOT, PM_TOKEN_COLON_COLON)) {
                        lex_state_set(parser, PM_LEX_STATE_FNAME);
                        parser_lex(parser);
                        operator = parser->previous;

                        switch (identifier.type) {
                            case PM_TOKEN_CONSTANT:
                                receiver = (pm_node_t *) pm_constant_read_node_create(parser, &identifier);
                                break;
                            case PM_TOKEN_INSTANCE_VARIABLE:
                                receiver = (pm_node_t *) pm_instance_variable_read_node_create(parser, &identifier);
                                break;
                            case PM_TOKEN_CLASS_VARIABLE:
                                receiver = (pm_node_t *) pm_class_variable_read_node_create(parser, &identifier);
                                break;
                            case PM_TOKEN_GLOBAL_VARIABLE:
                                receiver = (pm_node_t *) pm_global_variable_read_node_create(parser, &identifier);
                                break;
                            case PM_TOKEN_KEYWORD_NIL:
                                receiver = (pm_node_t *) pm_nil_node_create(parser, &identifier);
                                break;
                            case PM_TOKEN_KEYWORD_SELF:
                                receiver = (pm_node_t *) pm_self_node_create(parser, &identifier);
                                break;
                            case PM_TOKEN_KEYWORD_TRUE:
                                receiver = (pm_node_t *) pm_true_node_create(parser, &identifier);
                                break;
                            case PM_TOKEN_KEYWORD_FALSE:
                                receiver = (pm_node_t *) pm_false_node_create(parser, &identifier);
                                break;
                            case PM_TOKEN_KEYWORD___FILE__:
                                receiver = (pm_node_t *) pm_source_file_node_create(parser, &identifier);
                                break;
                            case PM_TOKEN_KEYWORD___LINE__:
                                receiver = (pm_node_t *) pm_source_line_node_create(parser, &identifier);
                                break;
                            case PM_TOKEN_KEYWORD___ENCODING__:
                                receiver = (pm_node_t *) pm_source_encoding_node_create(parser, &identifier);
                                break;
                            default:
                                break;
                        }

                        name = parse_method_definition_name(parser);
                    } else {
                        if (!valid_name) {
                            PM_PARSER_ERR_TOKEN_FORMAT(parser, identifier, PM_ERR_DEF_NAME, pm_token_type_human(identifier.type));
                        }

                        name = identifier;
                    }
                    break;
                }
                case PM_TOKEN_PARENTHESIS_LEFT: {
                    // The current context is `PM_CONTEXT_DEF_PARAMS`, however
                    // the inner expression of this parenthesis should not be
                    // processed under this context. Thus, the context is popped
                    // here.
                    context_pop(parser);
                    parser_lex(parser);

                    pm_token_t lparen = parser->previous;
                    pm_node_t *expression = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, true, false, PM_ERR_DEF_RECEIVER, (uint16_t) (depth + 1));

                    accept1(parser, PM_TOKEN_NEWLINE);
                    expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_EXPECT_RPAREN);
                    pm_token_t rparen = parser->previous;

                    lex_state_set(parser, PM_LEX_STATE_FNAME);
                    expect2(parser, PM_TOKEN_DOT, PM_TOKEN_COLON_COLON, PM_ERR_DEF_RECEIVER_TERM);

                    operator = parser->previous;
                    receiver = (pm_node_t *) pm_parentheses_node_create(parser, &lparen, expression, &rparen, 0);

                    // To push `PM_CONTEXT_DEF_PARAMS` again is for the same
                    // reason as described the above.
                    pm_parser_scope_push(parser, true);
                    context_push(parser, PM_CONTEXT_DEF_PARAMS);
                    name = parse_method_definition_name(parser);
                    break;
                }
                default:
                    pm_parser_scope_push(parser, true);
                    name = parse_method_definition_name(parser);
                    break;
            }

            pm_token_t lparen;
            pm_token_t rparen;
            pm_parameters_node_t *params;

            switch (parser->current.type) {
                case PM_TOKEN_PARENTHESIS_LEFT: {
                    parser_lex(parser);
                    lparen = parser->previous;

                    if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
                        params = NULL;
                    } else {
                        params = parse_parameters(parser, PM_BINDING_POWER_DEFINED, true, false, true, true, false, (uint16_t) (depth + 1));
                    }

                    lex_state_set(parser, PM_LEX_STATE_BEG);
                    parser->command_start = true;

                    context_pop(parser);
                    if (!accept1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
                        PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_DEF_PARAMS_TERM_PAREN, pm_token_type_human(parser->current.type));
                        parser->previous.start = parser->previous.end;
                        parser->previous.type = PM_TOKEN_MISSING;
                    }

                    rparen = parser->previous;
                    break;
                }
                case PM_CASE_PARAMETER: {
                    // If we're about to lex a label, we need to add the label
                    // state to make sure the next newline is ignored.
                    if (parser->current.type == PM_TOKEN_LABEL) {
                        lex_state_set(parser, parser->lex_state | PM_LEX_STATE_LABEL);
                    }

                    lparen = not_provided(parser);
                    rparen = not_provided(parser);
                    params = parse_parameters(parser, PM_BINDING_POWER_DEFINED, false, false, true, true, false, (uint16_t) (depth + 1));

                    context_pop(parser);
                    break;
                }
                default: {
                    lparen = not_provided(parser);
                    rparen = not_provided(parser);
                    params = NULL;

                    context_pop(parser);
                    break;
                }
            }

            pm_node_t *statements = NULL;
            pm_token_t equal;
            pm_token_t end_keyword;

            if (accept1(parser, PM_TOKEN_EQUAL)) {
                if (token_is_setter_name(&name)) {
                    pm_parser_err_token(parser, &name, PM_ERR_DEF_ENDLESS_SETTER);
                }
                equal = parser->previous;

                context_push(parser, PM_CONTEXT_DEF);
                pm_do_loop_stack_push(parser, false);
                statements = (pm_node_t *) pm_statements_node_create(parser);

                bool allow_command_call;
                if (parser->version >= PM_OPTIONS_VERSION_CRUBY_3_5) {
                    allow_command_call = accepts_command_call;
                } else {
                    // Allow `def foo = puts "Hello"` but not `private def foo = puts "Hello"`
                    allow_command_call = binding_power == PM_BINDING_POWER_ASSIGNMENT || binding_power < PM_BINDING_POWER_COMPOSITION;
                }

                pm_node_t *statement = parse_expression(parser, PM_BINDING_POWER_DEFINED + 1, allow_command_call, false, PM_ERR_DEF_ENDLESS, (uint16_t) (depth + 1));

                if (accept1(parser, PM_TOKEN_KEYWORD_RESCUE_MODIFIER)) {
                    context_push(parser, PM_CONTEXT_RESCUE_MODIFIER);

                    pm_token_t rescue_keyword = parser->previous;
                    pm_node_t *value = parse_expression(parser, pm_binding_powers[PM_TOKEN_KEYWORD_RESCUE_MODIFIER].right, false, false, PM_ERR_RESCUE_MODIFIER_VALUE, (uint16_t) (depth + 1));
                    context_pop(parser);

                    statement = (pm_node_t *) pm_rescue_modifier_node_create(parser, statement, &rescue_keyword, value);
                }

                pm_statements_node_body_append(parser, (pm_statements_node_t *) statements, statement, false);
                pm_do_loop_stack_pop(parser);
                context_pop(parser);
                end_keyword = not_provided(parser);
            } else {
                equal = not_provided(parser);

                if (lparen.type == PM_TOKEN_NOT_PROVIDED) {
                    lex_state_set(parser, PM_LEX_STATE_BEG);
                    parser->command_start = true;
                    expect2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON, PM_ERR_DEF_PARAMS_TERM);
                } else {
                    accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
                }

                pm_accepts_block_stack_push(parser, true);
                pm_do_loop_stack_push(parser, false);

                if (!match4(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
                    pm_accepts_block_stack_push(parser, true);
                    statements = (pm_node_t *) parse_statements(parser, PM_CONTEXT_DEF, (uint16_t) (depth + 1));
                    pm_accepts_block_stack_pop(parser);
                }

                if (match3(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_ELSE)) {
                    assert(statements == NULL || PM_NODE_TYPE_P(statements, PM_STATEMENTS_NODE));
                    statements = (pm_node_t *) parse_rescues_implicit_begin(parser, opening_newline_index, &def_keyword, def_keyword.start, (pm_statements_node_t *) statements, PM_RESCUES_DEF, (uint16_t) (depth + 1));
                } else {
                    parser_warn_indentation_mismatch(parser, opening_newline_index, &def_keyword, false, false);
                }

                pm_accepts_block_stack_pop(parser);
                pm_do_loop_stack_pop(parser);

                expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_DEF_TERM);
                end_keyword = parser->previous;
            }

            pm_constant_id_list_t locals;
            pm_locals_order(parser, &parser->current_scope->locals, &locals, false);
            pm_parser_scope_pop(parser);

            /**
             * If the final character is @. As is the case when defining
             * methods to override the unary operators, we should ignore
             * the @ in the same way we do for symbols.
             */
            pm_constant_id_t name_id = pm_parser_constant_id_location(parser, name.start, parse_operator_symbol_name(&name));

            flush_block_exits(parser, previous_block_exits);
            pm_node_list_free(¤t_block_exits);

            return (pm_node_t *) pm_def_node_create(
                parser,
                name_id,
                &name,
                receiver,
                params,
                statements,
                &locals,
                &def_keyword,
                &operator,
                &lparen,
                &rparen,
                &equal,
                &end_keyword
            );
        }
        case PM_TOKEN_KEYWORD_DEFINED: {
            parser_lex(parser);
            pm_token_t keyword = parser->previous;

            pm_token_t lparen;
            pm_token_t rparen;
            pm_node_t *expression;

            context_push(parser, PM_CONTEXT_DEFINED);
            bool newline = accept1(parser, PM_TOKEN_NEWLINE);

            if (accept1(parser, PM_TOKEN_PARENTHESIS_LEFT)) {
                lparen = parser->previous;

                if (newline && accept1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
                    expression = (pm_node_t *) pm_parentheses_node_create(parser, &lparen, NULL, &parser->previous, 0);
                    lparen = not_provided(parser);
                    rparen = not_provided(parser);
                } else {
                    expression = parse_expression(parser, PM_BINDING_POWER_COMPOSITION, true, false, PM_ERR_DEFINED_EXPRESSION, (uint16_t) (depth + 1));

                    if (parser->recovering) {
                        rparen = not_provided(parser);
                    } else {
                        accept1(parser, PM_TOKEN_NEWLINE);
                        expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_EXPECT_RPAREN);
                        rparen = parser->previous;
                    }
                }
            } else {
                lparen = not_provided(parser);
                rparen = not_provided(parser);
                expression = parse_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_DEFINED_EXPRESSION, (uint16_t) (depth + 1));
            }

            context_pop(parser);
            return (pm_node_t *) pm_defined_node_create(
                parser,
                &lparen,
                expression,
                &rparen,
                &PM_LOCATION_TOKEN_VALUE(&keyword)
            );
        }
        case PM_TOKEN_KEYWORD_END_UPCASE: {
            if (binding_power != PM_BINDING_POWER_STATEMENT) {
                pm_parser_err_current(parser, PM_ERR_STATEMENT_POSTEXE_END);
            }

            parser_lex(parser);
            pm_token_t keyword = parser->previous;

            if (context_def_p(parser)) {
                pm_parser_warn_token(parser, &keyword, PM_WARN_END_IN_METHOD);
            }

            expect1(parser, PM_TOKEN_BRACE_LEFT, PM_ERR_END_UPCASE_BRACE);
            pm_token_t opening = parser->previous;
            pm_statements_node_t *statements = parse_statements(parser, PM_CONTEXT_POSTEXE, (uint16_t) (depth + 1));

            expect1(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_END_UPCASE_TERM);
            return (pm_node_t *) pm_post_execution_node_create(parser, &keyword, &opening, statements, &parser->previous);
        }
        case PM_TOKEN_KEYWORD_FALSE:
            parser_lex(parser);
            return (pm_node_t *) pm_false_node_create(parser, &parser->previous);
        case PM_TOKEN_KEYWORD_FOR: {
            size_t opening_newline_index = token_newline_index(parser);
            parser_lex(parser);

            pm_token_t for_keyword = parser->previous;
            pm_node_t *index;

            context_push(parser, PM_CONTEXT_FOR_INDEX);

            // First, parse out the first index expression.
            if (accept1(parser, PM_TOKEN_USTAR)) {
                pm_token_t star_operator = parser->previous;
                pm_node_t *name = NULL;

                if (token_begins_expression_p(parser->current.type)) {
                    name = parse_expression(parser, PM_BINDING_POWER_INDEX, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_STAR, (uint16_t) (depth + 1));
                }

                index = (pm_node_t *) pm_splat_node_create(parser, &star_operator, name);
            } else if (token_begins_expression_p(parser->current.type)) {
                index = parse_expression(parser, PM_BINDING_POWER_INDEX, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_COMMA, (uint16_t) (depth + 1));
            } else {
                pm_parser_err_token(parser, &for_keyword, PM_ERR_FOR_INDEX);
                index = (pm_node_t *) pm_missing_node_create(parser, for_keyword.start, for_keyword.end);
            }

            // Now, if there are multiple index expressions, parse them out.
            if (match1(parser, PM_TOKEN_COMMA)) {
                index = parse_targets(parser, index, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
            } else {
                index = parse_target(parser, index, false, false);
            }

            context_pop(parser);
            pm_do_loop_stack_push(parser, true);

            expect1(parser, PM_TOKEN_KEYWORD_IN, PM_ERR_FOR_IN);
            pm_token_t in_keyword = parser->previous;

            pm_node_t *collection = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, true, false, PM_ERR_FOR_COLLECTION, (uint16_t) (depth + 1));
            pm_do_loop_stack_pop(parser);

            pm_token_t do_keyword;
            if (accept1(parser, PM_TOKEN_KEYWORD_DO_LOOP)) {
                do_keyword = parser->previous;
            } else {
                do_keyword = not_provided(parser);
                if (!match2(parser, PM_TOKEN_SEMICOLON, PM_TOKEN_NEWLINE)) {
                    PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_EXPECT_FOR_DELIMITER, pm_token_type_human(parser->current.type));
                }
            }

            pm_statements_node_t *statements = NULL;
            if (!match1(parser, PM_TOKEN_KEYWORD_END)) {
                statements = parse_statements(parser, PM_CONTEXT_FOR, (uint16_t) (depth + 1));
            }

            parser_warn_indentation_mismatch(parser, opening_newline_index, &for_keyword, false, false);
            expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_FOR_TERM);

            return (pm_node_t *) pm_for_node_create(parser, index, collection, statements, &for_keyword, &in_keyword, &do_keyword, &parser->previous);
        }
        case PM_TOKEN_KEYWORD_IF:
            if (parser_end_of_line_p(parser)) {
                PM_PARSER_WARN_TOKEN_FORMAT_CONTENT(parser, parser->current, PM_WARN_KEYWORD_EOL);
            }

            size_t opening_newline_index = token_newline_index(parser);
            bool if_after_else = parser->previous.type == PM_TOKEN_KEYWORD_ELSE;
            parser_lex(parser);

            return parse_conditional(parser, PM_CONTEXT_IF, opening_newline_index, if_after_else, (uint16_t) (depth + 1));
        case PM_TOKEN_KEYWORD_UNDEF: {
            if (binding_power != PM_BINDING_POWER_STATEMENT) {
                pm_parser_err_current(parser, PM_ERR_STATEMENT_UNDEF);
            }

            parser_lex(parser);
            pm_undef_node_t *undef = pm_undef_node_create(parser, &parser->previous);
            pm_node_t *name = parse_undef_argument(parser, (uint16_t) (depth + 1));

            if (PM_NODE_TYPE_P(name, PM_MISSING_NODE)) {
                pm_node_destroy(parser, name);
            } else {
                pm_undef_node_append(undef, name);

                while (match1(parser, PM_TOKEN_COMMA)) {
                    lex_state_set(parser, PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM);
                    parser_lex(parser);
                    name = parse_undef_argument(parser, (uint16_t) (depth + 1));

                    if (PM_NODE_TYPE_P(name, PM_MISSING_NODE)) {
                        pm_node_destroy(parser, name);
                        break;
                    }

                    pm_undef_node_append(undef, name);
                }
            }

            return (pm_node_t *) undef;
        }
        case PM_TOKEN_KEYWORD_NOT: {
            parser_lex(parser);

            pm_token_t message = parser->previous;
            pm_arguments_t arguments = { 0 };
            pm_node_t *receiver = NULL;

            // If we do not accept a command call, then we also do not accept a
            // not without parentheses. In this case we need to reject this
            // syntax.
            if (!accepts_command_call && !match1(parser, PM_TOKEN_PARENTHESIS_LEFT)) {
                if (match1(parser, PM_TOKEN_PARENTHESIS_LEFT_PARENTHESES)) {
                    pm_parser_err(parser, parser->previous.end, parser->previous.end + 1, PM_ERR_EXPECT_LPAREN_AFTER_NOT_LPAREN);
                } else {
                    accept1(parser, PM_TOKEN_NEWLINE);
                    pm_parser_err_current(parser, PM_ERR_EXPECT_LPAREN_AFTER_NOT_OTHER);
                }

                return (pm_node_t *) pm_missing_node_create(parser, parser->current.start, parser->current.end);
            }

            accept1(parser, PM_TOKEN_NEWLINE);

            if (accept1(parser, PM_TOKEN_PARENTHESIS_LEFT)) {
                pm_token_t lparen = parser->previous;

                if (accept1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
                    receiver = (pm_node_t *) pm_parentheses_node_create(parser, &lparen, NULL, &parser->previous, 0);
                } else {
                    arguments.opening_loc = PM_LOCATION_TOKEN_VALUE(&lparen);
                    receiver = parse_expression(parser, PM_BINDING_POWER_COMPOSITION, true, false, PM_ERR_NOT_EXPRESSION, (uint16_t) (depth + 1));

                    if (!parser->recovering) {
                        accept1(parser, PM_TOKEN_NEWLINE);
                        expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_EXPECT_RPAREN);
                        arguments.closing_loc = PM_LOCATION_TOKEN_VALUE(&parser->previous);
                    }
                }
            } else {
                receiver = parse_expression(parser, PM_BINDING_POWER_NOT, true, false, PM_ERR_NOT_EXPRESSION, (uint16_t) (depth + 1));
            }

            return (pm_node_t *) pm_call_node_not_create(parser, receiver, &message, &arguments);
        }
        case PM_TOKEN_KEYWORD_UNLESS: {
            size_t opening_newline_index = token_newline_index(parser);
            parser_lex(parser);

            return parse_conditional(parser, PM_CONTEXT_UNLESS, opening_newline_index, false, (uint16_t) (depth + 1));
        }
        case PM_TOKEN_KEYWORD_MODULE: {
            pm_node_list_t current_block_exits = { 0 };
            pm_node_list_t *previous_block_exits = push_block_exits(parser, ¤t_block_exits);

            size_t opening_newline_index = token_newline_index(parser);
            parser_lex(parser);
            pm_token_t module_keyword = parser->previous;

            pm_node_t *constant_path = parse_expression(parser, PM_BINDING_POWER_INDEX, false, false, PM_ERR_MODULE_NAME, (uint16_t) (depth + 1));
            pm_token_t name;

            // If we can recover from a syntax error that occurred while parsing
            // the name of the module, then we'll handle that here.
            if (PM_NODE_TYPE_P(constant_path, PM_MISSING_NODE)) {
                pop_block_exits(parser, previous_block_exits);
                pm_node_list_free(¤t_block_exits);

                pm_token_t missing = (pm_token_t) { .type = PM_TOKEN_MISSING, .start = parser->previous.end, .end = parser->previous.end };
                return (pm_node_t *) pm_module_node_create(parser, NULL, &module_keyword, constant_path, &missing, NULL, &missing);
            }

            while (accept1(parser, PM_TOKEN_COLON_COLON)) {
                pm_token_t double_colon = parser->previous;

                expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
                constant_path = (pm_node_t *) pm_constant_path_node_create(parser, constant_path, &double_colon, &parser->previous);
            }

            // Here we retrieve the name of the module. If it wasn't a constant,
            // then it's possible that `module foo` was passed, which is a
            // syntax error. We handle that here as well.
            name = parser->previous;
            if (name.type != PM_TOKEN_CONSTANT) {
                pm_parser_err_token(parser, &name, PM_ERR_MODULE_NAME);
            }

            pm_parser_scope_push(parser, true);
            accept2(parser, PM_TOKEN_SEMICOLON, PM_TOKEN_NEWLINE);
            pm_node_t *statements = NULL;

            if (!match4(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
                pm_accepts_block_stack_push(parser, true);
                statements = (pm_node_t *) parse_statements(parser, PM_CONTEXT_MODULE, (uint16_t) (depth + 1));
                pm_accepts_block_stack_pop(parser);
            }

            if (match3(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_ELSE)) {
                assert(statements == NULL || PM_NODE_TYPE_P(statements, PM_STATEMENTS_NODE));
                statements = (pm_node_t *) parse_rescues_implicit_begin(parser, opening_newline_index, &module_keyword, module_keyword.start, (pm_statements_node_t *) statements, PM_RESCUES_MODULE, (uint16_t) (depth + 1));
            } else {
                parser_warn_indentation_mismatch(parser, opening_newline_index, &module_keyword, false, false);
            }

            pm_constant_id_list_t locals;
            pm_locals_order(parser, &parser->current_scope->locals, &locals, false);

            pm_parser_scope_pop(parser);
            expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_MODULE_TERM);

            if (context_def_p(parser)) {
                pm_parser_err_token(parser, &module_keyword, PM_ERR_MODULE_IN_METHOD);
            }

            pop_block_exits(parser, previous_block_exits);
            pm_node_list_free(¤t_block_exits);

            return (pm_node_t *) pm_module_node_create(parser, &locals, &module_keyword, constant_path, &name, statements, &parser->previous);
        }
        case PM_TOKEN_KEYWORD_NIL:
            parser_lex(parser);
            return (pm_node_t *) pm_nil_node_create(parser, &parser->previous);
        case PM_TOKEN_KEYWORD_REDO: {
            parser_lex(parser);

            pm_node_t *node = (pm_node_t *) pm_redo_node_create(parser, &parser->previous);
            if (!parser->partial_script) parse_block_exit(parser, node);

            return node;
        }
        case PM_TOKEN_KEYWORD_RETRY: {
            parser_lex(parser);

            pm_node_t *node = (pm_node_t *) pm_retry_node_create(parser, &parser->previous);
            parse_retry(parser, node);

            return node;
        }
        case PM_TOKEN_KEYWORD_SELF:
            parser_lex(parser);
            return (pm_node_t *) pm_self_node_create(parser, &parser->previous);
        case PM_TOKEN_KEYWORD_TRUE:
            parser_lex(parser);
            return (pm_node_t *) pm_true_node_create(parser, &parser->previous);
        case PM_TOKEN_KEYWORD_UNTIL: {
            size_t opening_newline_index = token_newline_index(parser);

            context_push(parser, PM_CONTEXT_LOOP_PREDICATE);
            pm_do_loop_stack_push(parser, true);

            parser_lex(parser);
            pm_token_t keyword = parser->previous;
            pm_node_t *predicate = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, true, false, PM_ERR_CONDITIONAL_UNTIL_PREDICATE, (uint16_t) (depth + 1));

            pm_do_loop_stack_pop(parser);
            context_pop(parser);

            pm_token_t do_keyword;
            if (accept1(parser, PM_TOKEN_KEYWORD_DO_LOOP)) {
                do_keyword = parser->previous;
            } else {
                do_keyword = not_provided(parser);
                expect2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON, PM_ERR_CONDITIONAL_UNTIL_PREDICATE);
            }

            pm_statements_node_t *statements = NULL;
            if (!match1(parser, PM_TOKEN_KEYWORD_END)) {
                pm_accepts_block_stack_push(parser, true);
                statements = parse_statements(parser, PM_CONTEXT_UNTIL, (uint16_t) (depth + 1));
                pm_accepts_block_stack_pop(parser);
                accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
            }

            parser_warn_indentation_mismatch(parser, opening_newline_index, &keyword, false, false);
            expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_UNTIL_TERM);

            return (pm_node_t *) pm_until_node_create(parser, &keyword, &do_keyword, &parser->previous, predicate, statements, 0);
        }
        case PM_TOKEN_KEYWORD_WHILE: {
            size_t opening_newline_index = token_newline_index(parser);

            context_push(parser, PM_CONTEXT_LOOP_PREDICATE);
            pm_do_loop_stack_push(parser, true);

            parser_lex(parser);
            pm_token_t keyword = parser->previous;
            pm_node_t *predicate = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, true, false, PM_ERR_CONDITIONAL_WHILE_PREDICATE, (uint16_t) (depth + 1));

            pm_do_loop_stack_pop(parser);
            context_pop(parser);

            pm_token_t do_keyword;
            if (accept1(parser, PM_TOKEN_KEYWORD_DO_LOOP)) {
                do_keyword = parser->previous;
            } else {
                do_keyword = not_provided(parser);
                expect2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON, PM_ERR_CONDITIONAL_WHILE_PREDICATE);
            }

            pm_statements_node_t *statements = NULL;
            if (!match1(parser, PM_TOKEN_KEYWORD_END)) {
                pm_accepts_block_stack_push(parser, true);
                statements = parse_statements(parser, PM_CONTEXT_WHILE, (uint16_t) (depth + 1));
                pm_accepts_block_stack_pop(parser);
                accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
            }

            parser_warn_indentation_mismatch(parser, opening_newline_index, &keyword, false, false);
            expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_WHILE_TERM);

            return (pm_node_t *) pm_while_node_create(parser, &keyword, &do_keyword, &parser->previous, predicate, statements, 0);
        }
        case PM_TOKEN_PERCENT_LOWER_I: {
            parser_lex(parser);
            pm_token_t opening = parser->previous;
            pm_array_node_t *array = pm_array_node_create(parser, &opening);

            while (!match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
                accept1(parser, PM_TOKEN_WORDS_SEP);
                if (match1(parser, PM_TOKEN_STRING_END)) break;

                if (match1(parser, PM_TOKEN_STRING_CONTENT)) {
                    pm_token_t opening = not_provided(parser);
                    pm_token_t closing = not_provided(parser);
                    pm_array_node_elements_append(array, (pm_node_t *) pm_symbol_node_create_current_string(parser, &opening, &parser->current, &closing));
                }

                expect1(parser, PM_TOKEN_STRING_CONTENT, PM_ERR_LIST_I_LOWER_ELEMENT);
            }

            pm_token_t closing = parser->current;
            if (match1(parser, PM_TOKEN_EOF)) {
                pm_parser_err_token(parser, &opening, PM_ERR_LIST_I_LOWER_TERM);
                closing = (pm_token_t) { .type = PM_TOKEN_MISSING, .start = parser->previous.end, .end = parser->previous.end };
            } else {
                expect1(parser, PM_TOKEN_STRING_END, PM_ERR_LIST_I_LOWER_TERM);
            }
            pm_array_node_close_set(array, &closing);

            return (pm_node_t *) array;
        }
        case PM_TOKEN_PERCENT_UPPER_I: {
            parser_lex(parser);
            pm_token_t opening = parser->previous;
            pm_array_node_t *array = pm_array_node_create(parser, &opening);

            // This is the current node that we are parsing that will be added to the
            // list of elements.
            pm_node_t *current = NULL;

            while (!match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
                switch (parser->current.type) {
                    case PM_TOKEN_WORDS_SEP: {
                        if (current == NULL) {
                            // If we hit a separator before we have any content, then we don't
                            // need to do anything.
                        } else {
                            // If we hit a separator after we've hit content, then we need to
                            // append that content to the list and reset the current node.
                            pm_array_node_elements_append(array, current);
                            current = NULL;
                        }

                        parser_lex(parser);
                        break;
                    }
                    case PM_TOKEN_STRING_CONTENT: {
                        pm_token_t opening = not_provided(parser);
                        pm_token_t closing = not_provided(parser);

                        if (current == NULL) {
                            // If we hit content and the current node is NULL, then this is
                            // the first string content we've seen. In that case we're going
                            // to create a new string node and set that to the current.
                            current = (pm_node_t *) pm_symbol_node_create_current_string(parser, &opening, &parser->current, &closing);
                            parser_lex(parser);
                        } else if (PM_NODE_TYPE_P(current, PM_INTERPOLATED_SYMBOL_NODE)) {
                            // If we hit string content and the current node is an
                            // interpolated string, then we need to append the string content
                            // to the list of child nodes.
                            pm_node_t *string = (pm_node_t *) pm_string_node_create_current_string(parser, &opening, &parser->current, &closing);
                            parser_lex(parser);

                            pm_interpolated_symbol_node_append((pm_interpolated_symbol_node_t *) current, string);
                        } else if (PM_NODE_TYPE_P(current, PM_SYMBOL_NODE)) {
                            // If we hit string content and the current node is a symbol node,
                            // then we need to convert the current node into an interpolated
                            // string and add the string content to the list of child nodes.
                            pm_symbol_node_t *cast = (pm_symbol_node_t *) current;
                            pm_token_t bounds = not_provided(parser);

                            pm_token_t content = { .type = PM_TOKEN_STRING_CONTENT, .start = cast->value_loc.start, .end = cast->value_loc.end };
                            pm_node_t *first_string = (pm_node_t *) pm_string_node_create_unescaped(parser, &bounds, &content, &bounds, &cast->unescaped);
                            pm_node_t *second_string = (pm_node_t *) pm_string_node_create_current_string(parser, &opening, &parser->previous, &closing);
                            parser_lex(parser);

                            pm_interpolated_symbol_node_t *interpolated = pm_interpolated_symbol_node_create(parser, &opening, NULL, &closing);
                            pm_interpolated_symbol_node_append(interpolated, first_string);
                            pm_interpolated_symbol_node_append(interpolated, second_string);

                            xfree(current);
                            current = (pm_node_t *) interpolated;
                        } else {
                            assert(false && "unreachable");
                        }

                        break;
                    }
                    case PM_TOKEN_EMBVAR: {
                        bool start_location_set = false;
                        if (current == NULL) {
                            // If we hit an embedded variable and the current node is NULL,
                            // then this is the start of a new string. We'll set the current
                            // node to a new interpolated string.
                            pm_token_t opening = not_provided(parser);
                            pm_token_t closing = not_provided(parser);
                            current = (pm_node_t *) pm_interpolated_symbol_node_create(parser, &opening, NULL, &closing);
                        } else if (PM_NODE_TYPE_P(current, PM_SYMBOL_NODE)) {
                            // If we hit an embedded variable and the current node is a string
                            // node, then we'll convert the current into an interpolated
                            // string and add the string node to the list of parts.
                            pm_token_t opening = not_provided(parser);
                            pm_token_t closing = not_provided(parser);
                            pm_interpolated_symbol_node_t *interpolated = pm_interpolated_symbol_node_create(parser, &opening, NULL, &closing);

                            current = (pm_node_t *) pm_symbol_node_to_string_node(parser, (pm_symbol_node_t *) current);
                            pm_interpolated_symbol_node_append(interpolated, current);
                            interpolated->base.location.start = current->location.start;
                            start_location_set = true;
                            current = (pm_node_t *) interpolated;
                        } else {
                            // If we hit an embedded variable and the current node is an
                            // interpolated string, then we'll just add the embedded variable.
                        }

                        pm_node_t *part = parse_string_part(parser, (uint16_t) (depth + 1));
                        pm_interpolated_symbol_node_append((pm_interpolated_symbol_node_t *) current, part);
                        if (!start_location_set) {
                            current->location.start = part->location.start;
                        }
                        break;
                    }
                    case PM_TOKEN_EMBEXPR_BEGIN: {
                        bool start_location_set = false;
                        if (current == NULL) {
                            // If we hit an embedded expression and the current node is NULL,
                            // then this is the start of a new string. We'll set the current
                            // node to a new interpolated string.
                            pm_token_t opening = not_provided(parser);
                            pm_token_t closing = not_provided(parser);
                            current = (pm_node_t *) pm_interpolated_symbol_node_create(parser, &opening, NULL, &closing);
                        } else if (PM_NODE_TYPE_P(current, PM_SYMBOL_NODE)) {
                            // If we hit an embedded expression and the current node is a
                            // string node, then we'll convert the current into an
                            // interpolated string and add the string node to the list of
                            // parts.
                            pm_token_t opening = not_provided(parser);
                            pm_token_t closing = not_provided(parser);
                            pm_interpolated_symbol_node_t *interpolated = pm_interpolated_symbol_node_create(parser, &opening, NULL, &closing);

                            current = (pm_node_t *) pm_symbol_node_to_string_node(parser, (pm_symbol_node_t *) current);
                            pm_interpolated_symbol_node_append(interpolated, current);
                            interpolated->base.location.start = current->location.start;
                            start_location_set = true;
                            current = (pm_node_t *) interpolated;
                        } else if (PM_NODE_TYPE_P(current, PM_INTERPOLATED_SYMBOL_NODE)) {
                            // If we hit an embedded expression and the current node is an
                            // interpolated string, then we'll just continue on.
                        } else {
                            assert(false && "unreachable");
                        }

                        pm_node_t *part = parse_string_part(parser, (uint16_t) (depth + 1));
                        pm_interpolated_symbol_node_append((pm_interpolated_symbol_node_t *) current, part);
                        if (!start_location_set) {
                            current->location.start = part->location.start;
                        }
                        break;
                    }
                    default:
                        expect1(parser, PM_TOKEN_STRING_CONTENT, PM_ERR_LIST_I_UPPER_ELEMENT);
                        parser_lex(parser);
                        break;
                }
            }

            // If we have a current node, then we need to append it to the list.
            if (current) {
                pm_array_node_elements_append(array, current);
            }

            pm_token_t closing = parser->current;
            if (match1(parser, PM_TOKEN_EOF)) {
                pm_parser_err_token(parser, &opening, PM_ERR_LIST_I_UPPER_TERM);
                closing = (pm_token_t) { .type = PM_TOKEN_MISSING, .start = parser->previous.end, .end = parser->previous.end };
            } else {
                expect1(parser, PM_TOKEN_STRING_END, PM_ERR_LIST_I_UPPER_TERM);
            }
            pm_array_node_close_set(array, &closing);

            return (pm_node_t *) array;
        }
        case PM_TOKEN_PERCENT_LOWER_W: {
            parser_lex(parser);
            pm_token_t opening = parser->previous;
            pm_array_node_t *array = pm_array_node_create(parser, &opening);

            // skip all leading whitespaces
            accept1(parser, PM_TOKEN_WORDS_SEP);

            while (!match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
                accept1(parser, PM_TOKEN_WORDS_SEP);
                if (match1(parser, PM_TOKEN_STRING_END)) break;

                if (match1(parser, PM_TOKEN_STRING_CONTENT)) {
                    pm_token_t opening = not_provided(parser);
                    pm_token_t closing = not_provided(parser);

                    pm_node_t *string = (pm_node_t *) pm_string_node_create_current_string(parser, &opening, &parser->current, &closing);
                    pm_array_node_elements_append(array, string);
                }

                expect1(parser, PM_TOKEN_STRING_CONTENT, PM_ERR_LIST_W_LOWER_ELEMENT);
            }

            pm_token_t closing = parser->current;
            if (match1(parser, PM_TOKEN_EOF)) {
                pm_parser_err_token(parser, &opening, PM_ERR_LIST_W_LOWER_TERM);
                closing = (pm_token_t) { .type = PM_TOKEN_MISSING, .start = parser->previous.end, .end = parser->previous.end };
            } else {
                expect1(parser, PM_TOKEN_STRING_END, PM_ERR_LIST_W_LOWER_TERM);
            }

            pm_array_node_close_set(array, &closing);
            return (pm_node_t *) array;
        }
        case PM_TOKEN_PERCENT_UPPER_W: {
            parser_lex(parser);
            pm_token_t opening = parser->previous;
            pm_array_node_t *array = pm_array_node_create(parser, &opening);

            // This is the current node that we are parsing that will be added
            // to the list of elements.
            pm_node_t *current = NULL;

            while (!match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
                switch (parser->current.type) {
                    case PM_TOKEN_WORDS_SEP: {
                        // Reset the explicit encoding if we hit a separator
                        // since each element can have its own encoding.
                        parser->explicit_encoding = NULL;

                        if (current == NULL) {
                            // If we hit a separator before we have any content,
                            // then we don't need to do anything.
                        } else {
                            // If we hit a separator after we've hit content,
                            // then we need to append that content to the list
                            // and reset the current node.
                            pm_array_node_elements_append(array, current);
                            current = NULL;
                        }

                        parser_lex(parser);
                        break;
                    }
                    case PM_TOKEN_STRING_CONTENT: {
                        pm_token_t opening = not_provided(parser);
                        pm_token_t closing = not_provided(parser);

                        pm_node_t *string = (pm_node_t *) pm_string_node_create_current_string(parser, &opening, &parser->current, &closing);
                        pm_node_flag_set(string, parse_unescaped_encoding(parser));
                        parser_lex(parser);

                        if (current == NULL) {
                            // If we hit content and the current node is NULL,
                            // then this is the first string content we've seen.
                            // In that case we're going to create a new string
                            // node and set that to the current.
                            current = string;
                        } else if (PM_NODE_TYPE_P(current, PM_INTERPOLATED_STRING_NODE)) {
                            // If we hit string content and the current node is
                            // an interpolated string, then we need to append
                            // the string content to the list of child nodes.
                            pm_interpolated_string_node_append((pm_interpolated_string_node_t *) current, string);
                        } else if (PM_NODE_TYPE_P(current, PM_STRING_NODE)) {
                            // If we hit string content and the current node is
                            // a string node, then we need to convert the
                            // current node into an interpolated string and add
                            // the string content to the list of child nodes.
                            pm_interpolated_string_node_t *interpolated = pm_interpolated_string_node_create(parser, &opening, NULL, &closing);
                            pm_interpolated_string_node_append(interpolated, current);
                            pm_interpolated_string_node_append(interpolated, string);
                            current = (pm_node_t *) interpolated;
                        } else {
                            assert(false && "unreachable");
                        }

                        break;
                    }
                    case PM_TOKEN_EMBVAR: {
                        if (current == NULL) {
                            // If we hit an embedded variable and the current
                            // node is NULL, then this is the start of a new
                            // string. We'll set the current node to a new
                            // interpolated string.
                            pm_token_t opening = not_provided(parser);
                            pm_token_t closing = not_provided(parser);
                            current = (pm_node_t *) pm_interpolated_string_node_create(parser, &opening, NULL, &closing);
                        } else if (PM_NODE_TYPE_P(current, PM_STRING_NODE)) {
                            // If we hit an embedded variable and the current
                            // node is a string node, then we'll convert the
                            // current into an interpolated string and add the
                            // string node to the list of parts.
                            pm_token_t opening = not_provided(parser);
                            pm_token_t closing = not_provided(parser);
                            pm_interpolated_string_node_t *interpolated = pm_interpolated_string_node_create(parser, &opening, NULL, &closing);
                            pm_interpolated_string_node_append(interpolated, current);
                            current = (pm_node_t *) interpolated;
                        } else {
                            // If we hit an embedded variable and the current
                            // node is an interpolated string, then we'll just
                            // add the embedded variable.
                        }

                        pm_node_t *part = parse_string_part(parser, (uint16_t) (depth + 1));
                        pm_interpolated_string_node_append((pm_interpolated_string_node_t *) current, part);
                        break;
                    }
                    case PM_TOKEN_EMBEXPR_BEGIN: {
                        if (current == NULL) {
                            // If we hit an embedded expression and the current
                            // node is NULL, then this is the start of a new
                            // string. We'll set the current node to a new
                            // interpolated string.
                            pm_token_t opening = not_provided(parser);
                            pm_token_t closing = not_provided(parser);
                            current = (pm_node_t *) pm_interpolated_string_node_create(parser, &opening, NULL, &closing);
                        } else if (PM_NODE_TYPE_P(current, PM_STRING_NODE)) {
                            // If we hit an embedded expression and the current
                            // node is a string node, then we'll convert the
                            // current into an interpolated string and add the
                            // string node to the list of parts.
                            pm_token_t opening = not_provided(parser);
                            pm_token_t closing = not_provided(parser);
                            pm_interpolated_string_node_t *interpolated = pm_interpolated_string_node_create(parser, &opening, NULL, &closing);
                            pm_interpolated_string_node_append(interpolated, current);
                            current = (pm_node_t *) interpolated;
                        } else if (PM_NODE_TYPE_P(current, PM_INTERPOLATED_STRING_NODE)) {
                            // If we hit an embedded expression and the current
                            // node is an interpolated string, then we'll just
                            // continue on.
                        } else {
                            assert(false && "unreachable");
                        }

                        pm_node_t *part = parse_string_part(parser, (uint16_t) (depth + 1));
                        pm_interpolated_string_node_append((pm_interpolated_string_node_t *) current, part);
                        break;
                    }
                    default:
                        expect1(parser, PM_TOKEN_STRING_CONTENT, PM_ERR_LIST_W_UPPER_ELEMENT);
                        parser_lex(parser);
                        break;
                }
            }

            // If we have a current node, then we need to append it to the list.
            if (current) {
                pm_array_node_elements_append(array, current);
            }

            pm_token_t closing = parser->current;
            if (match1(parser, PM_TOKEN_EOF)) {
                pm_parser_err_token(parser, &opening, PM_ERR_LIST_W_UPPER_TERM);
                closing = (pm_token_t) { .type = PM_TOKEN_MISSING, .start = parser->previous.end, .end = parser->previous.end };
            } else {
                expect1(parser, PM_TOKEN_STRING_END, PM_ERR_LIST_W_UPPER_TERM);
            }

            pm_array_node_close_set(array, &closing);
            return (pm_node_t *) array;
        }
        case PM_TOKEN_REGEXP_BEGIN: {
            pm_token_t opening = parser->current;
            parser_lex(parser);

            if (match1(parser, PM_TOKEN_REGEXP_END)) {
                // If we get here, then we have an end immediately after a start. In
                // that case we'll create an empty content token and return an
                // uninterpolated regular expression.
                pm_token_t content = (pm_token_t) {
                    .type = PM_TOKEN_STRING_CONTENT,
                    .start = parser->previous.end,
                    .end = parser->previous.end
                };

                parser_lex(parser);

                pm_node_t *node = (pm_node_t *) pm_regular_expression_node_create(parser, &opening, &content, &parser->previous);
                pm_node_flag_set(node, PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING);

                return node;
            }

            pm_interpolated_regular_expression_node_t *interpolated;

            if (match1(parser, PM_TOKEN_STRING_CONTENT)) {
                // In this case we've hit string content so we know the regular
                // expression at least has something in it. We'll need to check if the
                // following token is the end (in which case we can return a plain
                // regular expression) or if it's not then it has interpolation.
                pm_string_t unescaped = parser->current_string;
                pm_token_t content = parser->current;
                bool ascii_only = parser->current_regular_expression_ascii_only;
                parser_lex(parser);

                // If we hit an end, then we can create a regular expression
                // node without interpolation, which can be represented more
                // succinctly and more easily compiled.
                if (accept1(parser, PM_TOKEN_REGEXP_END)) {
                    pm_regular_expression_node_t *node = (pm_regular_expression_node_t *) pm_regular_expression_node_create_unescaped(parser, &opening, &content, &parser->previous, &unescaped);

                    // If we're not immediately followed by a =~, then we want
                    // to parse all of the errors at this point. If it is
                    // followed by a =~, then it will get parsed higher up while
                    // parsing the named captures as well.
                    if (!match1(parser, PM_TOKEN_EQUAL_TILDE)) {
                        parse_regular_expression_errors(parser, node);
                    }

                    pm_node_flag_set((pm_node_t *) node, parse_and_validate_regular_expression_encoding(parser, &unescaped, ascii_only, node->base.flags));
                    return (pm_node_t *) node;
                }

                // If we get here, then we have interpolation so we'll need to create
                // a regular expression node with interpolation.
                interpolated = pm_interpolated_regular_expression_node_create(parser, &opening);

                pm_token_t opening = not_provided(parser);
                pm_token_t closing = not_provided(parser);
                pm_node_t *part = (pm_node_t *) pm_string_node_create_unescaped(parser, &opening, &parser->previous, &closing, &unescaped);

                if (parser->encoding == PM_ENCODING_US_ASCII_ENTRY) {
                    // This is extremely strange, but the first string part of a
                    // regular expression will always be tagged as binary if we
                    // are in a US-ASCII file, no matter its contents.
                    pm_node_flag_set(part, PM_STRING_FLAGS_FORCED_BINARY_ENCODING);
                }

                pm_interpolated_regular_expression_node_append(interpolated, part);
            } else {
                // If the first part of the body of the regular expression is not a
                // string content, then we have interpolation and we need to create an
                // interpolated regular expression node.
                interpolated = pm_interpolated_regular_expression_node_create(parser, &opening);
            }

            // Now that we're here and we have interpolation, we'll parse all of the
            // parts into the list.
            pm_node_t *part;
            while (!match2(parser, PM_TOKEN_REGEXP_END, PM_TOKEN_EOF)) {
                if ((part = parse_string_part(parser, (uint16_t) (depth + 1))) != NULL) {
                    pm_interpolated_regular_expression_node_append(interpolated, part);
                }
            }

            pm_token_t closing = parser->current;
            if (match1(parser, PM_TOKEN_EOF)) {
                pm_parser_err_token(parser, &opening, PM_ERR_REGEXP_TERM);
                closing = (pm_token_t) { .type = PM_TOKEN_MISSING, .start = parser->previous.end, .end = parser->previous.end };
            } else {
                expect1(parser, PM_TOKEN_REGEXP_END, PM_ERR_REGEXP_TERM);
            }

            pm_interpolated_regular_expression_node_closing_set(parser, interpolated, &closing);
            return (pm_node_t *) interpolated;
        }
        case PM_TOKEN_BACKTICK:
        case PM_TOKEN_PERCENT_LOWER_X: {
            parser_lex(parser);
            pm_token_t opening = parser->previous;

            // When we get here, we don't know if this string is going to have
            // interpolation or not, even though it is allowed. Still, we want to be
            // able to return a string node without interpolation if we can since
            // it'll be faster.
            if (match1(parser, PM_TOKEN_STRING_END)) {
                // If we get here, then we have an end immediately after a start. In
                // that case we'll create an empty content token and return an
                // uninterpolated string.
                pm_token_t content = (pm_token_t) {
                    .type = PM_TOKEN_STRING_CONTENT,
                    .start = parser->previous.end,
                    .end = parser->previous.end
                };

                parser_lex(parser);
                return (pm_node_t *) pm_xstring_node_create(parser, &opening, &content, &parser->previous);
            }

            pm_interpolated_x_string_node_t *node;

            if (match1(parser, PM_TOKEN_STRING_CONTENT)) {
                // In this case we've hit string content so we know the string
                // at least has something in it. We'll need to check if the
                // following token is the end (in which case we can return a
                // plain string) or if it's not then it has interpolation.
                pm_string_t unescaped = parser->current_string;
                pm_token_t content = parser->current;
                parser_lex(parser);

                if (match1(parser, PM_TOKEN_STRING_END)) {
                    pm_node_t *node = (pm_node_t *) pm_xstring_node_create_unescaped(parser, &opening, &content, &parser->current, &unescaped);
                    pm_node_flag_set(node, parse_unescaped_encoding(parser));
                    parser_lex(parser);
                    return node;
                }

                // If we get here, then we have interpolation so we'll need to
                // create a string node with interpolation.
                node = pm_interpolated_xstring_node_create(parser, &opening, &opening);

                pm_token_t opening = not_provided(parser);
                pm_token_t closing = not_provided(parser);

                pm_node_t *part = (pm_node_t *) pm_string_node_create_unescaped(parser, &opening, &parser->previous, &closing, &unescaped);
                pm_node_flag_set(part, parse_unescaped_encoding(parser));

                pm_interpolated_xstring_node_append(node, part);
            } else {
                // If the first part of the body of the string is not a string
                // content, then we have interpolation and we need to create an
                // interpolated string node.
                node = pm_interpolated_xstring_node_create(parser, &opening, &opening);
            }

            pm_node_t *part;
            while (!match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
                if ((part = parse_string_part(parser, (uint16_t) (depth + 1))) != NULL) {
                    pm_interpolated_xstring_node_append(node, part);
                }
            }

            pm_token_t closing = parser->current;
            if (match1(parser, PM_TOKEN_EOF)) {
                pm_parser_err_token(parser, &opening, PM_ERR_XSTRING_TERM);
                closing = (pm_token_t) { .type = PM_TOKEN_MISSING, .start = parser->previous.end, .end = parser->previous.end };
            } else {
                expect1(parser, PM_TOKEN_STRING_END, PM_ERR_XSTRING_TERM);
            }
            pm_interpolated_xstring_node_closing_set(node, &closing);

            return (pm_node_t *) node;
        }
        case PM_TOKEN_USTAR: {
            parser_lex(parser);

            // * operators at the beginning of expressions are only valid in the
            // context of a multiple assignment. We enforce that here. We'll
            // still lex past it though and create a missing node place.
            if (binding_power != PM_BINDING_POWER_STATEMENT) {
                pm_parser_err_prefix(parser, diag_id);
                return (pm_node_t *) pm_missing_node_create(parser, parser->previous.start, parser->previous.end);
            }

            pm_token_t operator = parser->previous;
            pm_node_t *name = NULL;

            if (token_begins_expression_p(parser->current.type)) {
                name = parse_expression(parser, PM_BINDING_POWER_INDEX, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_STAR, (uint16_t) (depth + 1));
            }

            pm_node_t *splat = (pm_node_t *) pm_splat_node_create(parser, &operator, name);

            if (match1(parser, PM_TOKEN_COMMA)) {
                return parse_targets_validate(parser, splat, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
            } else {
                return parse_target_validate(parser, splat, true);
            }
        }
        case PM_TOKEN_BANG: {
            if (binding_power > PM_BINDING_POWER_UNARY) {
                pm_parser_err_prefix(parser, PM_ERR_UNARY_DISALLOWED);
            }

            parser_lex(parser);

            pm_token_t operator = parser->previous;
            pm_node_t *receiver = parse_expression(parser, pm_binding_powers[parser->previous.type].right, binding_power < PM_BINDING_POWER_MATCH, false, PM_ERR_UNARY_RECEIVER, (uint16_t) (depth + 1));
            pm_call_node_t *node = pm_call_node_unary_create(parser, &operator, receiver, "!");

            pm_conditional_predicate(parser, receiver, PM_CONDITIONAL_PREDICATE_TYPE_NOT);
            return (pm_node_t *) node;
        }
        case PM_TOKEN_TILDE: {
            if (binding_power > PM_BINDING_POWER_UNARY) {
                pm_parser_err_prefix(parser, PM_ERR_UNARY_DISALLOWED);
            }
            parser_lex(parser);

            pm_token_t operator = parser->previous;
            pm_node_t *receiver = parse_expression(parser, pm_binding_powers[parser->previous.type].right, false, false, PM_ERR_UNARY_RECEIVER, (uint16_t) (depth + 1));
            pm_call_node_t *node = pm_call_node_unary_create(parser, &operator, receiver, "~");

            return (pm_node_t *) node;
        }
        case PM_TOKEN_UMINUS: {
            if (binding_power > PM_BINDING_POWER_UNARY) {
                pm_parser_err_prefix(parser, PM_ERR_UNARY_DISALLOWED);
            }
            parser_lex(parser);

            pm_token_t operator = parser->previous;
            pm_node_t *receiver = parse_expression(parser, pm_binding_powers[parser->previous.type].right, false, false, PM_ERR_UNARY_RECEIVER, (uint16_t) (depth + 1));
            pm_call_node_t *node = pm_call_node_unary_create(parser, &operator, receiver, "-@");

            return (pm_node_t *) node;
        }
        case PM_TOKEN_UMINUS_NUM: {
            parser_lex(parser);

            pm_token_t operator = parser->previous;
            pm_node_t *node = parse_expression(parser, pm_binding_powers[parser->previous.type].right, false, false, PM_ERR_UNARY_RECEIVER, (uint16_t) (depth + 1));

            if (accept1(parser, PM_TOKEN_STAR_STAR)) {
                pm_token_t exponent_operator = parser->previous;
                pm_node_t *exponent = parse_expression(parser, pm_binding_powers[exponent_operator.type].right, false, false, PM_ERR_EXPECT_ARGUMENT, (uint16_t) (depth + 1));
                node = (pm_node_t *) pm_call_node_binary_create(parser, node, &exponent_operator, exponent, 0);
                node = (pm_node_t *) pm_call_node_unary_create(parser, &operator, node, "-@");
            } else {
                switch (PM_NODE_TYPE(node)) {
                    case PM_INTEGER_NODE:
                    case PM_FLOAT_NODE:
                    case PM_RATIONAL_NODE:
                    case PM_IMAGINARY_NODE:
                        parse_negative_numeric(node);
                        break;
                    default:
                        node = (pm_node_t *) pm_call_node_unary_create(parser, &operator, node, "-@");
                        break;
                }
            }

            return node;
        }
        case PM_TOKEN_MINUS_GREATER: {
            int previous_lambda_enclosure_nesting = parser->lambda_enclosure_nesting;
            parser->lambda_enclosure_nesting = parser->enclosure_nesting;

            size_t opening_newline_index = token_newline_index(parser);
            pm_accepts_block_stack_push(parser, true);
            parser_lex(parser);

            pm_token_t operator = parser->previous;
            pm_parser_scope_push(parser, false);

            pm_block_parameters_node_t *block_parameters;

            switch (parser->current.type) {
                case PM_TOKEN_PARENTHESIS_LEFT: {
                    pm_token_t opening = parser->current;
                    parser_lex(parser);

                    if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
                        block_parameters = pm_block_parameters_node_create(parser, NULL, &opening);
                    } else {
                        block_parameters = parse_block_parameters(parser, false, &opening, true, true, (uint16_t) (depth + 1));
                    }

                    accept1(parser, PM_TOKEN_NEWLINE);
                    expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_EXPECT_RPAREN);

                    pm_block_parameters_node_closing_set(block_parameters, &parser->previous);
                    break;
                }
                case PM_CASE_PARAMETER: {
                    pm_accepts_block_stack_push(parser, false);
                    pm_token_t opening = not_provided(parser);
                    block_parameters = parse_block_parameters(parser, false, &opening, true, false, (uint16_t) (depth + 1));
                    pm_accepts_block_stack_pop(parser);
                    break;
                }
                default: {
                    block_parameters = NULL;
                    break;
                }
            }

            pm_token_t opening;
            pm_node_t *body = NULL;
            parser->lambda_enclosure_nesting = previous_lambda_enclosure_nesting;

            if (accept1(parser, PM_TOKEN_LAMBDA_BEGIN)) {
                opening = parser->previous;

                if (!match1(parser, PM_TOKEN_BRACE_RIGHT)) {
                    body = (pm_node_t *) parse_statements(parser, PM_CONTEXT_LAMBDA_BRACES, (uint16_t) (depth + 1));
                }

                parser_warn_indentation_mismatch(parser, opening_newline_index, &operator, false, false);
                expect1(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_LAMBDA_TERM_BRACE);
            } else {
                expect1(parser, PM_TOKEN_KEYWORD_DO, PM_ERR_LAMBDA_OPEN);
                opening = parser->previous;

                if (!match3(parser, PM_TOKEN_KEYWORD_END, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE)) {
                    pm_accepts_block_stack_push(parser, true);
                    body = (pm_node_t *) parse_statements(parser, PM_CONTEXT_LAMBDA_DO_END, (uint16_t) (depth + 1));
                    pm_accepts_block_stack_pop(parser);
                }

                if (match2(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE)) {
                    assert(body == NULL || PM_NODE_TYPE_P(body, PM_STATEMENTS_NODE));
                    body = (pm_node_t *) parse_rescues_implicit_begin(parser, opening_newline_index, &operator, opening.start, (pm_statements_node_t *) body, PM_RESCUES_LAMBDA, (uint16_t) (depth + 1));
                } else {
                    parser_warn_indentation_mismatch(parser, opening_newline_index, &operator, false, false);
                }

                expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_LAMBDA_TERM_END);
            }

            pm_constant_id_list_t locals;
            pm_locals_order(parser, &parser->current_scope->locals, &locals, pm_parser_scope_toplevel_p(parser));
            pm_node_t *parameters = parse_blocklike_parameters(parser, (pm_node_t *) block_parameters, &operator, &parser->previous);

            pm_parser_scope_pop(parser);
            pm_accepts_block_stack_pop(parser);

            return (pm_node_t *) pm_lambda_node_create(parser, &locals, &operator, &opening, &parser->previous, parameters, body);
        }
        case PM_TOKEN_UPLUS: {
            if (binding_power > PM_BINDING_POWER_UNARY) {
                pm_parser_err_prefix(parser, PM_ERR_UNARY_DISALLOWED);
            }
            parser_lex(parser);

            pm_token_t operator = parser->previous;
            pm_node_t *receiver = parse_expression(parser, pm_binding_powers[parser->previous.type].right, false, false, PM_ERR_UNARY_RECEIVER, (uint16_t) (depth + 1));
            pm_call_node_t *node = pm_call_node_unary_create(parser, &operator, receiver, "+@");

            return (pm_node_t *) node;
        }
        case PM_TOKEN_STRING_BEGIN:
            return parse_strings(parser, NULL, accepts_label, (uint16_t) (depth + 1));
        case PM_TOKEN_SYMBOL_BEGIN: {
            pm_lex_mode_t lex_mode = *parser->lex_modes.current;
            parser_lex(parser);

            return parse_symbol(parser, &lex_mode, PM_LEX_STATE_END, (uint16_t) (depth + 1));
        }
        default: {
            pm_context_t recoverable = context_recoverable(parser, &parser->current);

            if (recoverable != PM_CONTEXT_NONE) {
                parser->recovering = true;

                // If the given error is not the generic one, then we'll add it
                // here because it will provide more context in addition to the
                // recoverable error that we will also add.
                if (diag_id != PM_ERR_CANNOT_PARSE_EXPRESSION) {
                    pm_parser_err_prefix(parser, diag_id);
                }

                // If we get here, then we are assuming this token is closing a
                // parent context, so we'll indicate that to the user so that
                // they know how we behaved.
                PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT, pm_token_type_human(parser->current.type), context_human(recoverable));
            } else if (diag_id == PM_ERR_CANNOT_PARSE_EXPRESSION) {
                // We're going to make a special case here, because "cannot
                // parse expression" is pretty generic, and we know here that we
                // have an unexpected token.
                PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE, pm_token_type_human(parser->current.type));
            } else {
                pm_parser_err_prefix(parser, diag_id);
            }

            return (pm_node_t *) pm_missing_node_create(parser, parser->previous.start, parser->previous.end);
        }
    }
}

/**
 * Parse a value that is going to be written to some kind of variable or method
 * call. We need to handle this separately because the rescue modifier is
 * permitted on the end of the these expressions, which is a deviation from its
 * normal binding power.
 *
 * Note that this will only be called after an operator write, as in &&=, ||=,
 * or any of the binary operators that can be written to a variable.
 */
static pm_node_t *
parse_assignment_value(pm_parser_t *parser, pm_binding_power_t previous_binding_power, pm_binding_power_t binding_power, bool accepts_command_call, pm_diagnostic_id_t diag_id, uint16_t depth) {
    pm_node_t *value = parse_value_expression(parser, binding_power, previous_binding_power == PM_BINDING_POWER_ASSIGNMENT ? accepts_command_call : previous_binding_power < PM_BINDING_POWER_MATCH, false, diag_id, (uint16_t) (depth + 1));

    // Contradicting binding powers, the right-hand-side value of the assignment
    // allows the `rescue` modifier.
    if (match1(parser, PM_TOKEN_KEYWORD_RESCUE_MODIFIER)) {
        context_push(parser, PM_CONTEXT_RESCUE_MODIFIER);

        pm_token_t rescue = parser->current;
        parser_lex(parser);

        pm_node_t *right = parse_expression(parser, pm_binding_powers[PM_TOKEN_KEYWORD_RESCUE_MODIFIER].right, false, false, PM_ERR_RESCUE_MODIFIER_VALUE, (uint16_t) (depth + 1));
        context_pop(parser);

        return (pm_node_t *) pm_rescue_modifier_node_create(parser, value, &rescue, right);
    }

    return value;
}

/**
 * When a local variable write node is the value being written in a different
 * write, the local variable is considered "used".
 */
static void
parse_assignment_value_local(pm_parser_t *parser, const pm_node_t *node) {
    switch (PM_NODE_TYPE(node)) {
        case PM_BEGIN_NODE: {
            const pm_begin_node_t *cast = (const pm_begin_node_t *) node;
            if (cast->statements != NULL) parse_assignment_value_local(parser, (const pm_node_t *) cast->statements);
            break;
        }
        case PM_LOCAL_VARIABLE_WRITE_NODE: {
            const pm_local_variable_write_node_t *cast = (const pm_local_variable_write_node_t *) node;
            pm_locals_read(&pm_parser_scope_find(parser, cast->depth)->locals, cast->name);
            break;
        }
        case PM_PARENTHESES_NODE: {
            const pm_parentheses_node_t *cast = (const pm_parentheses_node_t *) node;
            if (cast->body != NULL) parse_assignment_value_local(parser, cast->body);
            break;
        }
        case PM_STATEMENTS_NODE: {
            const pm_statements_node_t *cast = (const pm_statements_node_t *) node;
            const pm_node_t *statement;

            PM_NODE_LIST_FOREACH(&cast->body, index, statement) {
                parse_assignment_value_local(parser, statement);
            }
            break;
        }
        default:
            break;
    }
}

/**
 * Parse the value (or values, through an implicit array) that is going to be
 * written to some kind of variable or method call. We need to handle this
 * separately because the rescue modifier is permitted on the end of the these
 * expressions, which is a deviation from its normal binding power.
 *
 * Additionally, if the value is a local variable write node (e.g., a = a = 1),
 * the "a" is marked as being used so the parser should not warn on it.
 *
 * Note that this will only be called after an = operator, as that is the only
 * operator that allows multiple values after it.
 */
static pm_node_t *
parse_assignment_values(pm_parser_t *parser, pm_binding_power_t previous_binding_power, pm_binding_power_t binding_power, bool accepts_command_call, pm_diagnostic_id_t diag_id, uint16_t depth) {
    bool permitted = true;
    if (previous_binding_power != PM_BINDING_POWER_STATEMENT && match1(parser, PM_TOKEN_USTAR)) permitted = false;

    pm_node_t *value = parse_starred_expression(parser, binding_power, previous_binding_power == PM_BINDING_POWER_ASSIGNMENT ? accepts_command_call : previous_binding_power < PM_BINDING_POWER_MATCH, diag_id, (uint16_t) (depth + 1));
    if (!permitted) pm_parser_err_node(parser, value, PM_ERR_UNEXPECTED_MULTI_WRITE);

    parse_assignment_value_local(parser, value);
    bool single_value = true;

    if (previous_binding_power == PM_BINDING_POWER_STATEMENT && (PM_NODE_TYPE_P(value, PM_SPLAT_NODE) || match1(parser, PM_TOKEN_COMMA))) {
        single_value = false;

        pm_token_t opening = not_provided(parser);
        pm_array_node_t *array = pm_array_node_create(parser, &opening);

        pm_array_node_elements_append(array, value);
        value = (pm_node_t *) array;

        while (accept1(parser, PM_TOKEN_COMMA)) {
            pm_node_t *element = parse_starred_expression(parser, binding_power, false, PM_ERR_ARRAY_ELEMENT, (uint16_t) (depth + 1));

            pm_array_node_elements_append(array, element);
            if (PM_NODE_TYPE_P(element, PM_MISSING_NODE)) break;

            parse_assignment_value_local(parser, element);
        }
    }

    // Contradicting binding powers, the right-hand-side value of the assignment
    // allows the `rescue` modifier.
    if ((single_value || (binding_power == (PM_BINDING_POWER_MULTI_ASSIGNMENT + 1))) && match1(parser, PM_TOKEN_KEYWORD_RESCUE_MODIFIER)) {
        context_push(parser, PM_CONTEXT_RESCUE_MODIFIER);

        pm_token_t rescue = parser->current;
        parser_lex(parser);

        bool accepts_command_call_inner = false;

        // RHS can accept command call iff the value is a call with arguments
        // but without parenthesis.
        if (PM_NODE_TYPE_P(value, PM_CALL_NODE)) {
            pm_call_node_t *call_node = (pm_call_node_t *) value;
            if ((call_node->arguments != NULL) && (call_node->opening_loc.start == NULL)) {
                accepts_command_call_inner = true;
            }
        }

        pm_node_t *right = parse_expression(parser, pm_binding_powers[PM_TOKEN_KEYWORD_RESCUE_MODIFIER].right, accepts_command_call_inner, false, PM_ERR_RESCUE_MODIFIER_VALUE, (uint16_t) (depth + 1));
        context_pop(parser);

        return (pm_node_t *) pm_rescue_modifier_node_create(parser, value, &rescue, right);
    }

    return value;
}

/**
 * Ensure a call node that is about to become a call operator node does not
 * have arguments or a block attached. If it does, then we'll need to add an
 * error message and destroy the arguments/block. Ideally we would keep the node
 * around so that consumers would still have access to it, but we don't have a
 * great structure for that at the moment.
 */
static void
parse_call_operator_write(pm_parser_t *parser, pm_call_node_t *call_node, const pm_token_t *operator) {
    if (call_node->arguments != NULL) {
        pm_parser_err_token(parser, operator, PM_ERR_OPERATOR_WRITE_ARGUMENTS);
        pm_node_destroy(parser, (pm_node_t *) call_node->arguments);
        call_node->arguments = NULL;
    }

    if (call_node->block != NULL) {
        pm_parser_err_token(parser, operator, PM_ERR_OPERATOR_WRITE_BLOCK);
        pm_node_destroy(parser, (pm_node_t *) call_node->block);
        call_node->block = NULL;
    }
}

/**
 * This struct is used to pass information between the regular expression parser
 * and the named capture callback.
 */
typedef struct {
    /** The parser that is parsing the regular expression. */
    pm_parser_t *parser;

    /** The call node wrapping the regular expression node. */
    pm_call_node_t *call;

    /** The match write node that is being created. */
    pm_match_write_node_t *match;

    /** The list of names that have been parsed. */
    pm_constant_id_list_t names;

    /**
     * Whether the content of the regular expression is shared. This impacts
     * whether or not we used owned constants or shared constants in the
     * constant pool for the names of the captures.
     */
    bool shared;
} parse_regular_expression_named_capture_data_t;

static inline const uint8_t *
pm_named_capture_escape_hex(pm_buffer_t *unescaped, const uint8_t *cursor, const uint8_t *end) {
    cursor++;

    if (cursor < end && pm_char_is_hexadecimal_digit(*cursor)) {
        uint8_t value = escape_hexadecimal_digit(*cursor);
        cursor++;

        if (cursor < end && pm_char_is_hexadecimal_digit(*cursor)) {
            value = (uint8_t) ((value << 4) | escape_hexadecimal_digit(*cursor));
            cursor++;
        }

        pm_buffer_append_byte(unescaped, value);
    } else {
        pm_buffer_append_string(unescaped, "\\x", 2);
    }

    return cursor;
}

static inline const uint8_t *
pm_named_capture_escape_octal(pm_buffer_t *unescaped, const uint8_t *cursor, const uint8_t *end) {
    uint8_t value = (uint8_t) (*cursor - '0');
    cursor++;

    if (cursor < end && pm_char_is_octal_digit(*cursor)) {
        value = ((uint8_t) (value << 3)) | ((uint8_t) (*cursor - '0'));
        cursor++;

        if (cursor < end && pm_char_is_octal_digit(*cursor)) {
            value = ((uint8_t) (value << 3)) | ((uint8_t) (*cursor - '0'));
            cursor++;
        }
    }

    pm_buffer_append_byte(unescaped, value);
    return cursor;
}

static inline const uint8_t *
pm_named_capture_escape_unicode(pm_parser_t *parser, pm_buffer_t *unescaped, const uint8_t *cursor, const uint8_t *end) {
    const uint8_t *start = cursor - 1;
    cursor++;

    if (cursor >= end) {
        pm_buffer_append_string(unescaped, "\\u", 2);
        return cursor;
    }

    if (*cursor != '{') {
        size_t length = pm_strspn_hexadecimal_digit(cursor, MIN(end - cursor, 4));
        uint32_t value = escape_unicode(parser, cursor, length);

        if (!pm_buffer_append_unicode_codepoint(unescaped, value)) {
            pm_buffer_append_string(unescaped, (const char *) start, (size_t) ((cursor + length) - start));
        }

        return cursor + length;
    }

    cursor++;
    for (;;) {
        while (cursor < end && *cursor == ' ') cursor++;

        if (cursor >= end) break;
        if (*cursor == '}') {
            cursor++;
            break;
        }

        size_t length = pm_strspn_hexadecimal_digit(cursor, end - cursor);
        uint32_t value = escape_unicode(parser, cursor, length);

        (void) pm_buffer_append_unicode_codepoint(unescaped, value);
        cursor += length;
    }

    return cursor;
}

static void
pm_named_capture_escape(pm_parser_t *parser, pm_buffer_t *unescaped, const uint8_t *source, const size_t length, const uint8_t *cursor) {
    const uint8_t *end = source + length;
    pm_buffer_append_string(unescaped, (const char *) source, (size_t) (cursor - source));

    for (;;) {
        if (++cursor >= end) {
            pm_buffer_append_byte(unescaped, '\\');
            return;
        }

        switch (*cursor) {
            case 'x':
                cursor = pm_named_capture_escape_hex(unescaped, cursor, end);
                break;
            case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7':
                cursor = pm_named_capture_escape_octal(unescaped, cursor, end);
                break;
            case 'u':
                cursor = pm_named_capture_escape_unicode(parser, unescaped, cursor, end);
                break;
            default:
                pm_buffer_append_byte(unescaped, '\\');
                break;
        }

        const uint8_t *next_cursor = pm_memchr(cursor, '\\', (size_t) (end - cursor), parser->encoding_changed, parser->encoding);
        if (next_cursor == NULL) break;

        pm_buffer_append_string(unescaped, (const char *) cursor, (size_t) (next_cursor - cursor));
        cursor = next_cursor;
    }

    pm_buffer_append_string(unescaped, (const char *) cursor, (size_t) (end - cursor));
}

/**
 * This callback is called when the regular expression parser encounters a named
 * capture group.
 */
static void
parse_regular_expression_named_capture(const pm_string_t *capture, void *data) {
    parse_regular_expression_named_capture_data_t *callback_data = (parse_regular_expression_named_capture_data_t *) data;

    pm_parser_t *parser = callback_data->parser;
    pm_call_node_t *call = callback_data->call;
    pm_constant_id_list_t *names = &callback_data->names;

    const uint8_t *source = pm_string_source(capture);
    size_t length = pm_string_length(capture);
    pm_buffer_t unescaped = { 0 };

    // First, we need to handle escapes within the name of the capture group.
    // This is because regular expressions have three different representations
    // in prism. The first is the plain source code. The second is the
    // representation that will be sent to the regular expression engine, which
    // is the value of the "unescaped" field. This is poorly named, because it
    // actually still contains escapes, just a subset of them that the regular
    // expression engine knows how to handle. The third representation is fully
    // unescaped, which is what we need.
    const uint8_t *cursor = pm_memchr(source, '\\', length, parser->encoding_changed, parser->encoding);
    if (PRISM_UNLIKELY(cursor != NULL)) {
        pm_named_capture_escape(parser, &unescaped, source, length, cursor);
        source = (const uint8_t *) pm_buffer_value(&unescaped);
        length = pm_buffer_length(&unescaped);
    }

    pm_location_t location;
    pm_constant_id_t name;

    // If the name of the capture group isn't a valid identifier, we do
    // not add it to the local table.
    if (!pm_slice_is_valid_local(parser, source, source + length)) {
        pm_buffer_free(&unescaped);
        return;
    }

    if (callback_data->shared) {
        // If the unescaped string is a slice of the source, then we can
        // copy the names directly. The pointers will line up.
        location = (pm_location_t) { .start = source, .end = source + length };
        name = pm_parser_constant_id_location(parser, location.start, location.end);
    } else {
        // Otherwise, the name is a slice of the malloc-ed owned string,
        // in which case we need to copy it out into a new string.
        location = (pm_location_t) { .start = call->receiver->location.start, .end = call->receiver->location.end };

        void *memory = xmalloc(length);
        if (memory == NULL) abort();

        memcpy(memory, source, length);
        name = pm_parser_constant_id_owned(parser, (uint8_t *) memory, length);
    }

    // Add this name to the list of constants if it is valid, not duplicated,
    // and not a keyword.
    if (name != 0 && !pm_constant_id_list_includes(names, name)) {
        pm_constant_id_list_append(names, name);

        int depth;
        if ((depth = pm_parser_local_depth_constant_id(parser, name)) == -1) {
            // If the local is not already a local but it is a keyword, then we
            // do not want to add a capture for this.
            if (pm_local_is_keyword((const char *) source, length)) {
                pm_buffer_free(&unescaped);
                return;
            }

            // If the identifier is not already a local, then we will add it to
            // the local table.
            pm_parser_local_add(parser, name, location.start, location.end, 0);
        }

        // Here we lazily create the MatchWriteNode since we know we're
        // about to add a target.
        if (callback_data->match == NULL) {
            callback_data->match = pm_match_write_node_create(parser, call);
        }

        // Next, create the local variable target and add it to the list of
        // targets for the match.
        pm_node_t *target = (pm_node_t *) pm_local_variable_target_node_create(parser, &location, name, depth == -1 ? 0 : (uint32_t) depth);
        pm_node_list_append(&callback_data->match->targets, target);
    }

    pm_buffer_free(&unescaped);
}

/**
 * Potentially change a =~ with a regular expression with named captures into a
 * match write node.
 */
static pm_node_t *
parse_regular_expression_named_captures(pm_parser_t *parser, const pm_string_t *content, pm_call_node_t *call, bool extended_mode) {
    parse_regular_expression_named_capture_data_t callback_data = {
        .parser = parser,
        .call = call,
        .names = { 0 },
        .shared = content->type == PM_STRING_SHARED
    };

    parse_regular_expression_error_data_t error_data = {
        .parser = parser,
        .start = call->receiver->location.start,
        .end = call->receiver->location.end,
        .shared = content->type == PM_STRING_SHARED
    };

    pm_regexp_parse(parser, pm_string_source(content), pm_string_length(content), extended_mode, parse_regular_expression_named_capture, &callback_data, parse_regular_expression_error, &error_data);
    pm_constant_id_list_free(&callback_data.names);

    if (callback_data.match != NULL) {
        return (pm_node_t *) callback_data.match;
    } else {
        return (pm_node_t *) call;
    }
}

static inline pm_node_t *
parse_expression_infix(pm_parser_t *parser, pm_node_t *node, pm_binding_power_t previous_binding_power, pm_binding_power_t binding_power, bool accepts_command_call, uint16_t depth) {
    pm_token_t token = parser->current;

    switch (token.type) {
        case PM_TOKEN_EQUAL: {
            switch (PM_NODE_TYPE(node)) {
                case PM_CALL_NODE: {
                    // If we have no arguments to the call node and we need this
                    // to be a target then this is either a method call or a
                    // local variable write. This _must_ happen before the value
                    // is parsed because it could be referenced in the value.
                    pm_call_node_t *call_node = (pm_call_node_t *) node;
                    if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
                        pm_parser_local_add_location(parser, call_node->message_loc.start, call_node->message_loc.end, 0);
                    }
                }
                PRISM_FALLTHROUGH
                case PM_CASE_WRITABLE: {
                    // When we have `it = value`, we need to add `it` as a local
                    // variable before parsing the value, in case the value
                    // references the variable.
                    if (PM_NODE_TYPE_P(node, PM_IT_LOCAL_VARIABLE_READ_NODE)) {
                        pm_parser_local_add_location(parser, node->location.start, node->location.end, 0);
                    }

                    parser_lex(parser);
                    pm_node_t *value = parse_assignment_values(parser, previous_binding_power, PM_NODE_TYPE_P(node, PM_MULTI_TARGET_NODE) ? PM_BINDING_POWER_MULTI_ASSIGNMENT + 1 : binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_EQUAL, (uint16_t) (depth + 1));

                    if (PM_NODE_TYPE_P(node, PM_MULTI_TARGET_NODE) && previous_binding_power != PM_BINDING_POWER_STATEMENT) {
                        pm_parser_err_node(parser, node, PM_ERR_UNEXPECTED_MULTI_WRITE);
                    }

                    return parse_write(parser, node, &token, value);
                }
                case PM_SPLAT_NODE: {
                    pm_multi_target_node_t *multi_target = pm_multi_target_node_create(parser);
                    pm_multi_target_node_targets_append(parser, multi_target, node);

                    parser_lex(parser);
                    pm_node_t *value = parse_assignment_values(parser, previous_binding_power, PM_BINDING_POWER_MULTI_ASSIGNMENT + 1, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_EQUAL, (uint16_t) (depth + 1));
                    return parse_write(parser, (pm_node_t *) multi_target, &token, value);
                }
                case PM_SOURCE_ENCODING_NODE:
                case PM_FALSE_NODE:
                case PM_SOURCE_FILE_NODE:
                case PM_SOURCE_LINE_NODE:
                case PM_NIL_NODE:
                case PM_SELF_NODE:
                case PM_TRUE_NODE: {
                    // In these special cases, we have specific error messages
                    // and we will replace them with local variable writes.
                    parser_lex(parser);
                    pm_node_t *value = parse_assignment_values(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_EQUAL, (uint16_t) (depth + 1));
                    return parse_unwriteable_write(parser, node, &token, value);
                }
                default:
                    // In this case we have an = sign, but we don't know what
                    // it's for. We need to treat it as an error. We'll mark it
                    // as an error and skip past it.
                    parser_lex(parser);
                    pm_parser_err_token(parser, &token, PM_ERR_EXPRESSION_NOT_WRITABLE);
                    return node;
            }
        }
        case PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL: {
            switch (PM_NODE_TYPE(node)) {
                case PM_BACK_REFERENCE_READ_NODE:
                case PM_NUMBERED_REFERENCE_READ_NODE:
                    PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, node, PM_ERR_WRITE_TARGET_READONLY);
                PRISM_FALLTHROUGH
                case PM_GLOBAL_VARIABLE_READ_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_global_variable_and_write_node_create(parser, node, &token, value);

                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_CLASS_VARIABLE_READ_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_class_variable_and_write_node_create(parser, (pm_class_variable_read_node_t *) node, &token, value);

                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_CONSTANT_PATH_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
                    pm_node_t *write = (pm_node_t *) pm_constant_path_and_write_node_create(parser, (pm_constant_path_node_t *) node, &token, value);

                    return parse_shareable_constant_write(parser, write);
                }
                case PM_CONSTANT_READ_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
                    pm_node_t *write = (pm_node_t *) pm_constant_and_write_node_create(parser, (pm_constant_read_node_t *) node, &token, value);

                    pm_node_destroy(parser, node);
                    return parse_shareable_constant_write(parser, write);
                }
                case PM_INSTANCE_VARIABLE_READ_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_instance_variable_and_write_node_create(parser, (pm_instance_variable_read_node_t *) node, &token, value);

                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_IT_LOCAL_VARIABLE_READ_NODE: {
                    pm_constant_id_t name = pm_parser_local_add_constant(parser, "it", 2);
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_local_variable_and_write_node_create(parser, node, &token, value, name, 0);

                    parse_target_implicit_parameter(parser, node);
                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_LOCAL_VARIABLE_READ_NODE: {
                    if (pm_token_is_numbered_parameter(node->location.start, node->location.end)) {
                        PM_PARSER_ERR_FORMAT(parser, node->location.start, node->location.end, PM_ERR_PARAMETER_NUMBERED_RESERVED, node->location.start);
                        parse_target_implicit_parameter(parser, node);
                    }

                    pm_local_variable_read_node_t *cast = (pm_local_variable_read_node_t *) node;
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_local_variable_and_write_node_create(parser, node, &token, value, cast->name, cast->depth);

                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_CALL_NODE: {
                    pm_call_node_t *cast = (pm_call_node_t *) node;

                    // If we have a vcall (a method with no arguments and no
                    // receiver that could have been a local variable) then we
                    // will transform it into a local variable write.
                    if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
                        pm_location_t *message_loc = &cast->message_loc;
                        pm_refute_numbered_parameter(parser, message_loc->start, message_loc->end);

                        pm_constant_id_t constant_id = pm_parser_local_add_location(parser, message_loc->start, message_loc->end, 1);
                        parser_lex(parser);

                        pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
                        pm_node_t *result = (pm_node_t *) pm_local_variable_and_write_node_create(parser, (pm_node_t *) cast, &token, value, constant_id, 0);

                        pm_node_destroy(parser, (pm_node_t *) cast);
                        return result;
                    }

                    // Move past the token here so that we have already added
                    // the local variable by this point.
                    parser_lex(parser);

                    // If there is no call operator and the message is "[]" then
                    // this is an aref expression, and we can transform it into
                    // an aset expression.
                    if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_INDEX)) {
                        pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
                        return (pm_node_t *) pm_index_and_write_node_create(parser, cast, &token, value);
                    }

                    // If this node cannot be writable, then we have an error.
                    if (pm_call_node_writable_p(parser, cast)) {
                        parse_write_name(parser, &cast->name);
                    } else {
                        pm_parser_err_node(parser, node, PM_ERR_WRITE_TARGET_UNEXPECTED);
                    }

                    parse_call_operator_write(parser, cast, &token);
                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
                    return (pm_node_t *) pm_call_and_write_node_create(parser, cast, &token, value);
                }
                case PM_MULTI_WRITE_NODE: {
                    parser_lex(parser);
                    pm_parser_err_token(parser, &token, PM_ERR_AMPAMPEQ_MULTI_ASSIGN);
                    return node;
                }
                default:
                    parser_lex(parser);

                    // In this case we have an &&= sign, but we don't know what it's for.
                    // We need to treat it as an error. For now, we'll mark it as an error
                    // and just skip right past it.
                    pm_parser_err_token(parser, &token, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ);
                    return node;
            }
        }
        case PM_TOKEN_PIPE_PIPE_EQUAL: {
            switch (PM_NODE_TYPE(node)) {
                case PM_BACK_REFERENCE_READ_NODE:
                case PM_NUMBERED_REFERENCE_READ_NODE:
                    PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, node, PM_ERR_WRITE_TARGET_READONLY);
                PRISM_FALLTHROUGH
                case PM_GLOBAL_VARIABLE_READ_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_global_variable_or_write_node_create(parser, node, &token, value);

                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_CLASS_VARIABLE_READ_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_class_variable_or_write_node_create(parser, (pm_class_variable_read_node_t *) node, &token, value);

                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_CONSTANT_PATH_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
                    pm_node_t *write = (pm_node_t *) pm_constant_path_or_write_node_create(parser, (pm_constant_path_node_t *) node, &token, value);

                    return parse_shareable_constant_write(parser, write);
                }
                case PM_CONSTANT_READ_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
                    pm_node_t *write = (pm_node_t *) pm_constant_or_write_node_create(parser, (pm_constant_read_node_t *) node, &token, value);

                    pm_node_destroy(parser, node);
                    return parse_shareable_constant_write(parser, write);
                }
                case PM_INSTANCE_VARIABLE_READ_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_instance_variable_or_write_node_create(parser, (pm_instance_variable_read_node_t *) node, &token, value);

                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_IT_LOCAL_VARIABLE_READ_NODE: {
                    pm_constant_id_t name = pm_parser_local_add_constant(parser, "it", 2);
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_local_variable_or_write_node_create(parser, node, &token, value, name, 0);

                    parse_target_implicit_parameter(parser, node);
                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_LOCAL_VARIABLE_READ_NODE: {
                    if (pm_token_is_numbered_parameter(node->location.start, node->location.end)) {
                        PM_PARSER_ERR_FORMAT(parser, node->location.start, node->location.end, PM_ERR_PARAMETER_NUMBERED_RESERVED, node->location.start);
                        parse_target_implicit_parameter(parser, node);
                    }

                    pm_local_variable_read_node_t *cast = (pm_local_variable_read_node_t *) node;
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_local_variable_or_write_node_create(parser, node, &token, value, cast->name, cast->depth);

                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_CALL_NODE: {
                    pm_call_node_t *cast = (pm_call_node_t *) node;

                    // If we have a vcall (a method with no arguments and no
                    // receiver that could have been a local variable) then we
                    // will transform it into a local variable write.
                    if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
                        pm_location_t *message_loc = &cast->message_loc;
                        pm_refute_numbered_parameter(parser, message_loc->start, message_loc->end);

                        pm_constant_id_t constant_id = pm_parser_local_add_location(parser, message_loc->start, message_loc->end, 1);
                        parser_lex(parser);

                        pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
                        pm_node_t *result = (pm_node_t *) pm_local_variable_or_write_node_create(parser, (pm_node_t *) cast, &token, value, constant_id, 0);

                        pm_node_destroy(parser, (pm_node_t *) cast);
                        return result;
                    }

                    // Move past the token here so that we have already added
                    // the local variable by this point.
                    parser_lex(parser);

                    // If there is no call operator and the message is "[]" then
                    // this is an aref expression, and we can transform it into
                    // an aset expression.
                    if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_INDEX)) {
                        pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
                        return (pm_node_t *) pm_index_or_write_node_create(parser, cast, &token, value);
                    }

                    // If this node cannot be writable, then we have an error.
                    if (pm_call_node_writable_p(parser, cast)) {
                        parse_write_name(parser, &cast->name);
                    } else {
                        pm_parser_err_node(parser, node, PM_ERR_WRITE_TARGET_UNEXPECTED);
                    }

                    parse_call_operator_write(parser, cast, &token);
                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
                    return (pm_node_t *) pm_call_or_write_node_create(parser, cast, &token, value);
                }
                case PM_MULTI_WRITE_NODE: {
                    parser_lex(parser);
                    pm_parser_err_token(parser, &token, PM_ERR_PIPEPIPEEQ_MULTI_ASSIGN);
                    return node;
                }
                default:
                    parser_lex(parser);

                    // In this case we have an ||= sign, but we don't know what it's for.
                    // We need to treat it as an error. For now, we'll mark it as an error
                    // and just skip right past it.
                    pm_parser_err_token(parser, &token, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ);
                    return node;
            }
        }
        case PM_TOKEN_AMPERSAND_EQUAL:
        case PM_TOKEN_CARET_EQUAL:
        case PM_TOKEN_GREATER_GREATER_EQUAL:
        case PM_TOKEN_LESS_LESS_EQUAL:
        case PM_TOKEN_MINUS_EQUAL:
        case PM_TOKEN_PERCENT_EQUAL:
        case PM_TOKEN_PIPE_EQUAL:
        case PM_TOKEN_PLUS_EQUAL:
        case PM_TOKEN_SLASH_EQUAL:
        case PM_TOKEN_STAR_EQUAL:
        case PM_TOKEN_STAR_STAR_EQUAL: {
            switch (PM_NODE_TYPE(node)) {
                case PM_BACK_REFERENCE_READ_NODE:
                case PM_NUMBERED_REFERENCE_READ_NODE:
                    PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, node, PM_ERR_WRITE_TARGET_READONLY);
                PRISM_FALLTHROUGH
                case PM_GLOBAL_VARIABLE_READ_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_global_variable_operator_write_node_create(parser, node, &token, value);

                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_CLASS_VARIABLE_READ_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_class_variable_operator_write_node_create(parser, (pm_class_variable_read_node_t *) node, &token, value);

                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_CONSTANT_PATH_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
                    pm_node_t *write = (pm_node_t *) pm_constant_path_operator_write_node_create(parser, (pm_constant_path_node_t *) node, &token, value);

                    return parse_shareable_constant_write(parser, write);
                }
                case PM_CONSTANT_READ_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
                    pm_node_t *write = (pm_node_t *) pm_constant_operator_write_node_create(parser, (pm_constant_read_node_t *) node, &token, value);

                    pm_node_destroy(parser, node);
                    return parse_shareable_constant_write(parser, write);
                }
                case PM_INSTANCE_VARIABLE_READ_NODE: {
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_instance_variable_operator_write_node_create(parser, (pm_instance_variable_read_node_t *) node, &token, value);

                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_IT_LOCAL_VARIABLE_READ_NODE: {
                    pm_constant_id_t name = pm_parser_local_add_constant(parser, "it", 2);
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_local_variable_operator_write_node_create(parser, node, &token, value, name, 0);

                    parse_target_implicit_parameter(parser, node);
                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_LOCAL_VARIABLE_READ_NODE: {
                    if (pm_token_is_numbered_parameter(node->location.start, node->location.end)) {
                        PM_PARSER_ERR_FORMAT(parser, node->location.start, node->location.end, PM_ERR_PARAMETER_NUMBERED_RESERVED, node->location.start);
                        parse_target_implicit_parameter(parser, node);
                    }

                    pm_local_variable_read_node_t *cast = (pm_local_variable_read_node_t *) node;
                    parser_lex(parser);

                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
                    pm_node_t *result = (pm_node_t *) pm_local_variable_operator_write_node_create(parser, node, &token, value, cast->name, cast->depth);

                    pm_node_destroy(parser, node);
                    return result;
                }
                case PM_CALL_NODE: {
                    parser_lex(parser);
                    pm_call_node_t *cast = (pm_call_node_t *) node;

                    // If we have a vcall (a method with no arguments and no
                    // receiver that could have been a local variable) then we
                    // will transform it into a local variable write.
                    if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
                        pm_location_t *message_loc = &cast->message_loc;
                        pm_refute_numbered_parameter(parser, message_loc->start, message_loc->end);

                        pm_constant_id_t constant_id = pm_parser_local_add_location(parser, message_loc->start, message_loc->end, 1);
                        pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
                        pm_node_t *result = (pm_node_t *) pm_local_variable_operator_write_node_create(parser, (pm_node_t *) cast, &token, value, constant_id, 0);

                        pm_node_destroy(parser, (pm_node_t *) cast);
                        return result;
                    }

                    // If there is no call operator and the message is "[]" then
                    // this is an aref expression, and we can transform it into
                    // an aset expression.
                    if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_INDEX)) {
                        pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
                        return (pm_node_t *) pm_index_operator_write_node_create(parser, cast, &token, value);
                    }

                    // If this node cannot be writable, then we have an error.
                    if (pm_call_node_writable_p(parser, cast)) {
                        parse_write_name(parser, &cast->name);
                    } else {
                        pm_parser_err_node(parser, node, PM_ERR_WRITE_TARGET_UNEXPECTED);
                    }

                    parse_call_operator_write(parser, cast, &token);
                    pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
                    return (pm_node_t *) pm_call_operator_write_node_create(parser, cast, &token, value);
                }
                case PM_MULTI_WRITE_NODE: {
                    parser_lex(parser);
                    pm_parser_err_token(parser, &token, PM_ERR_OPERATOR_MULTI_ASSIGN);
                    return node;
                }
                default:
                    parser_lex(parser);

                    // In this case we have an operator but we don't know what it's for.
                    // We need to treat it as an error. For now, we'll mark it as an error
                    // and just skip right past it.
                    PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->previous, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, pm_token_type_human(parser->current.type));
                    return node;
            }
        }
        case PM_TOKEN_AMPERSAND_AMPERSAND:
        case PM_TOKEN_KEYWORD_AND: {
            parser_lex(parser);

            pm_node_t *right = parse_expression(parser, binding_power, parser->previous.type == PM_TOKEN_KEYWORD_AND, false, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
            return (pm_node_t *) pm_and_node_create(parser, node, &token, right);
        }
        case PM_TOKEN_KEYWORD_OR:
        case PM_TOKEN_PIPE_PIPE: {
            parser_lex(parser);

            pm_node_t *right = parse_expression(parser, binding_power, parser->previous.type == PM_TOKEN_KEYWORD_OR, false, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
            return (pm_node_t *) pm_or_node_create(parser, node, &token, right);
        }
        case PM_TOKEN_EQUAL_TILDE: {
            // Note that we _must_ parse the value before adding the local
            // variables in order to properly mirror the behavior of Ruby. For
            // example,
            //
            //     /(?bar)/ =~ foo
            //
            // In this case, `foo` should be a method call and not a local yet.
            parser_lex(parser);
            pm_node_t *argument = parse_expression(parser, binding_power, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));

            // By default, we're going to create a call node and then return it.
            pm_call_node_t *call = pm_call_node_binary_create(parser, node, &token, argument, 0);
            pm_node_t *result = (pm_node_t *) call;

            // If the receiver of this =~ is a regular expression node, then we
            // need to introduce local variables for it based on its named
            // capture groups.
            if (PM_NODE_TYPE_P(node, PM_INTERPOLATED_REGULAR_EXPRESSION_NODE)) {
                // It's possible to have an interpolated regular expression node
                // that only contains strings. This is because it can be split
                // up by a heredoc. In this case we need to concat the unescaped
                // strings together and then parse them as a regular expression.
                pm_node_list_t *parts = &((pm_interpolated_regular_expression_node_t *) node)->parts;

                bool interpolated = false;
                size_t total_length = 0;

                pm_node_t *part;
                PM_NODE_LIST_FOREACH(parts, index, part) {
                    if (PM_NODE_TYPE_P(part, PM_STRING_NODE)) {
                        total_length += pm_string_length(&((pm_string_node_t *) part)->unescaped);
                    } else {
                        interpolated = true;
                        break;
                    }
                }

                if (!interpolated && total_length > 0) {
                    void *memory = xmalloc(total_length);
                    if (!memory) abort();

                    uint8_t *cursor = memory;
                    PM_NODE_LIST_FOREACH(parts, index, part) {
                        pm_string_t *unescaped = &((pm_string_node_t *) part)->unescaped;
                        size_t length = pm_string_length(unescaped);

                        memcpy(cursor, pm_string_source(unescaped), length);
                        cursor += length;
                    }

                    pm_string_t owned;
                    pm_string_owned_init(&owned, (uint8_t *) memory, total_length);

                    result = parse_regular_expression_named_captures(parser, &owned, call, PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED));
                    pm_string_free(&owned);
                }
            } else if (PM_NODE_TYPE_P(node, PM_REGULAR_EXPRESSION_NODE)) {
                // If we have a regular expression node, then we can just parse
                // the named captures directly off the unescaped string.
                const pm_string_t *content = &((pm_regular_expression_node_t *) node)->unescaped;
                result = parse_regular_expression_named_captures(parser, content, call, PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED));
            }

            return result;
        }
        case PM_TOKEN_UAMPERSAND:
        case PM_TOKEN_USTAR:
        case PM_TOKEN_USTAR_STAR:
            // The only times this will occur are when we are in an error state,
            // but we'll put them in here so that errors can propagate.
        case PM_TOKEN_BANG_EQUAL:
        case PM_TOKEN_BANG_TILDE:
        case PM_TOKEN_EQUAL_EQUAL:
        case PM_TOKEN_EQUAL_EQUAL_EQUAL:
        case PM_TOKEN_LESS_EQUAL_GREATER:
        case PM_TOKEN_CARET:
        case PM_TOKEN_PIPE:
        case PM_TOKEN_AMPERSAND:
        case PM_TOKEN_GREATER_GREATER:
        case PM_TOKEN_LESS_LESS:
        case PM_TOKEN_MINUS:
        case PM_TOKEN_PLUS:
        case PM_TOKEN_PERCENT:
        case PM_TOKEN_SLASH:
        case PM_TOKEN_STAR:
        case PM_TOKEN_STAR_STAR: {
            parser_lex(parser);
            pm_token_t operator = parser->previous;
            switch (PM_NODE_TYPE(node)) {
                case PM_RESCUE_MODIFIER_NODE: {
                    pm_rescue_modifier_node_t *cast = (pm_rescue_modifier_node_t *) node;
                    if (PM_NODE_TYPE_P(cast->rescue_expression, PM_MATCH_PREDICATE_NODE) || PM_NODE_TYPE_P(cast->rescue_expression, PM_MATCH_REQUIRED_NODE)) {
                        PM_PARSER_ERR_TOKEN_FORMAT(parser, operator, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_type_human(operator.type));
                    }
                    break;
                }
                case PM_AND_NODE: {
                    pm_and_node_t *cast = (pm_and_node_t *) node;
                    if (PM_NODE_TYPE_P(cast->right, PM_MATCH_PREDICATE_NODE) || PM_NODE_TYPE_P(cast->right, PM_MATCH_REQUIRED_NODE)) {
                        PM_PARSER_ERR_TOKEN_FORMAT(parser, operator, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_type_human(operator.type));
                    }
                    break;
                }
                case PM_OR_NODE: {
                    pm_or_node_t *cast = (pm_or_node_t *) node;
                    if (PM_NODE_TYPE_P(cast->right, PM_MATCH_PREDICATE_NODE) || PM_NODE_TYPE_P(cast->right, PM_MATCH_REQUIRED_NODE)) {
                        PM_PARSER_ERR_TOKEN_FORMAT(parser, operator, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_type_human(operator.type));
                    }
                    break;
                }
                default:
                    break;
            }

            pm_node_t *argument = parse_expression(parser, binding_power, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
            return (pm_node_t *) pm_call_node_binary_create(parser, node, &token, argument, 0);
        }
        case PM_TOKEN_GREATER:
        case PM_TOKEN_GREATER_EQUAL:
        case PM_TOKEN_LESS:
        case PM_TOKEN_LESS_EQUAL: {
            if (PM_NODE_TYPE_P(node, PM_CALL_NODE) && PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_COMPARISON)) {
                PM_PARSER_WARN_TOKEN_FORMAT_CONTENT(parser, parser->current, PM_WARN_COMPARISON_AFTER_COMPARISON);
            }

            parser_lex(parser);
            pm_node_t *argument = parse_expression(parser, binding_power, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
            return (pm_node_t *) pm_call_node_binary_create(parser, node, &token, argument, PM_CALL_NODE_FLAGS_COMPARISON);
        }
        case PM_TOKEN_AMPERSAND_DOT:
        case PM_TOKEN_DOT: {
            parser_lex(parser);
            pm_token_t operator = parser->previous;
            pm_arguments_t arguments = { 0 };

            // This if statement handles the foo.() syntax.
            if (match1(parser, PM_TOKEN_PARENTHESIS_LEFT)) {
                parse_arguments_list(parser, &arguments, true, false, (uint16_t) (depth + 1));
                return (pm_node_t *) pm_call_node_shorthand_create(parser, node, &operator, &arguments);
            }

            switch (PM_NODE_TYPE(node)) {
                case PM_RESCUE_MODIFIER_NODE: {
                    pm_rescue_modifier_node_t *cast = (pm_rescue_modifier_node_t *) node;
                    if (PM_NODE_TYPE_P(cast->rescue_expression, PM_MATCH_PREDICATE_NODE) || PM_NODE_TYPE_P(cast->rescue_expression, PM_MATCH_REQUIRED_NODE)) {
                        PM_PARSER_ERR_TOKEN_FORMAT(parser, operator, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_type_human(operator.type));
                    }
                    break;
                }
                case PM_AND_NODE: {
                    pm_and_node_t *cast = (pm_and_node_t *) node;
                    if (PM_NODE_TYPE_P(cast->right, PM_MATCH_PREDICATE_NODE) || PM_NODE_TYPE_P(cast->right, PM_MATCH_REQUIRED_NODE)) {
                        PM_PARSER_ERR_TOKEN_FORMAT(parser, operator, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_type_human(operator.type));
                    }
                    break;
                }
                case PM_OR_NODE: {
                    pm_or_node_t *cast = (pm_or_node_t *) node;
                    if (PM_NODE_TYPE_P(cast->right, PM_MATCH_PREDICATE_NODE) || PM_NODE_TYPE_P(cast->right, PM_MATCH_REQUIRED_NODE)) {
                        PM_PARSER_ERR_TOKEN_FORMAT(parser, operator, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_type_human(operator.type));
                    }
                    break;
                }
                default:
                    break;
            }

            pm_token_t message;

            switch (parser->current.type) {
                case PM_CASE_OPERATOR:
                case PM_CASE_KEYWORD:
                case PM_TOKEN_CONSTANT:
                case PM_TOKEN_IDENTIFIER:
                case PM_TOKEN_METHOD_NAME: {
                    parser_lex(parser);
                    message = parser->previous;
                    break;
                }
                default: {
                    PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_EXPECT_MESSAGE, pm_token_type_human(parser->current.type));
                    message = (pm_token_t) { .type = PM_TOKEN_MISSING, .start = parser->previous.end, .end = parser->previous.end };
                }
            }

            parse_arguments_list(parser, &arguments, true, accepts_command_call, (uint16_t) (depth + 1));
            pm_call_node_t *call = pm_call_node_call_create(parser, node, &operator, &message, &arguments);

            if (
                (previous_binding_power == PM_BINDING_POWER_STATEMENT) &&
                arguments.arguments == NULL &&
                arguments.opening_loc.start == NULL &&
                match1(parser, PM_TOKEN_COMMA)
            ) {
                return parse_targets_validate(parser, (pm_node_t *) call, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
            } else {
                return (pm_node_t *) call;
            }
        }
        case PM_TOKEN_DOT_DOT:
        case PM_TOKEN_DOT_DOT_DOT: {
            parser_lex(parser);

            pm_node_t *right = NULL;
            if (token_begins_expression_p(parser->current.type)) {
                right = parse_expression(parser, binding_power, false, false, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
            }

            return (pm_node_t *) pm_range_node_create(parser, node, &token, right);
        }
        case PM_TOKEN_KEYWORD_IF_MODIFIER: {
            pm_token_t keyword = parser->current;
            parser_lex(parser);

            pm_node_t *predicate = parse_value_expression(parser, binding_power, true, false, PM_ERR_CONDITIONAL_IF_PREDICATE, (uint16_t) (depth + 1));
            return (pm_node_t *) pm_if_node_modifier_create(parser, node, &keyword, predicate);
        }
        case PM_TOKEN_KEYWORD_UNLESS_MODIFIER: {
            pm_token_t keyword = parser->current;
            parser_lex(parser);

            pm_node_t *predicate = parse_value_expression(parser, binding_power, true, false, PM_ERR_CONDITIONAL_UNLESS_PREDICATE, (uint16_t) (depth + 1));
            return (pm_node_t *) pm_unless_node_modifier_create(parser, node, &keyword, predicate);
        }
        case PM_TOKEN_KEYWORD_UNTIL_MODIFIER: {
            parser_lex(parser);
            pm_statements_node_t *statements = pm_statements_node_create(parser);
            pm_statements_node_body_append(parser, statements, node, true);

            pm_node_t *predicate = parse_value_expression(parser, binding_power, true, false, PM_ERR_CONDITIONAL_UNTIL_PREDICATE, (uint16_t) (depth + 1));
            return (pm_node_t *) pm_until_node_modifier_create(parser, &token, predicate, statements, PM_NODE_TYPE_P(node, PM_BEGIN_NODE) ? PM_LOOP_FLAGS_BEGIN_MODIFIER : 0);
        }
        case PM_TOKEN_KEYWORD_WHILE_MODIFIER: {
            parser_lex(parser);
            pm_statements_node_t *statements = pm_statements_node_create(parser);
            pm_statements_node_body_append(parser, statements, node, true);

            pm_node_t *predicate = parse_value_expression(parser, binding_power, true, false, PM_ERR_CONDITIONAL_WHILE_PREDICATE, (uint16_t) (depth + 1));
            return (pm_node_t *) pm_while_node_modifier_create(parser, &token, predicate, statements, PM_NODE_TYPE_P(node, PM_BEGIN_NODE) ? PM_LOOP_FLAGS_BEGIN_MODIFIER : 0);
        }
        case PM_TOKEN_QUESTION_MARK: {
            context_push(parser, PM_CONTEXT_TERNARY);
            pm_node_list_t current_block_exits = { 0 };
            pm_node_list_t *previous_block_exits = push_block_exits(parser, ¤t_block_exits);

            pm_token_t qmark = parser->current;
            parser_lex(parser);

            pm_node_t *true_expression = parse_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_TERNARY_EXPRESSION_TRUE, (uint16_t) (depth + 1));

            if (parser->recovering) {
                // If parsing the true expression of this ternary resulted in a syntax
                // error that we can recover from, then we're going to put missing nodes
                // and tokens into the remaining places. We want to be sure to do this
                // before the `expect` function call to make sure it doesn't
                // accidentally move past a ':' token that occurs after the syntax
                // error.
                pm_token_t colon = (pm_token_t) { .type = PM_TOKEN_MISSING, .start = parser->previous.end, .end = parser->previous.end };
                pm_node_t *false_expression = (pm_node_t *) pm_missing_node_create(parser, colon.start, colon.end);

                context_pop(parser);
                pop_block_exits(parser, previous_block_exits);
                pm_node_list_free(¤t_block_exits);

                return (pm_node_t *) pm_if_node_ternary_create(parser, node, &qmark, true_expression, &colon, false_expression);
            }

            accept1(parser, PM_TOKEN_NEWLINE);
            expect1(parser, PM_TOKEN_COLON, PM_ERR_TERNARY_COLON);

            pm_token_t colon = parser->previous;
            pm_node_t *false_expression = parse_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_TERNARY_EXPRESSION_FALSE, (uint16_t) (depth + 1));

            context_pop(parser);
            pop_block_exits(parser, previous_block_exits);
            pm_node_list_free(¤t_block_exits);

            return (pm_node_t *) pm_if_node_ternary_create(parser, node, &qmark, true_expression, &colon, false_expression);
        }
        case PM_TOKEN_COLON_COLON: {
            parser_lex(parser);
            pm_token_t delimiter = parser->previous;

            switch (parser->current.type) {
                case PM_TOKEN_CONSTANT: {
                    parser_lex(parser);
                    pm_node_t *path;

                    if (
                        (parser->current.type == PM_TOKEN_PARENTHESIS_LEFT) ||
                        (accepts_command_call && (token_begins_expression_p(parser->current.type) || match3(parser, PM_TOKEN_UAMPERSAND, PM_TOKEN_USTAR, PM_TOKEN_USTAR_STAR)))
                    ) {
                        // If we have a constant immediately following a '::' operator, then
                        // this can either be a constant path or a method call, depending on
                        // what follows the constant.
                        //
                        // If we have parentheses, then this is a method call. That would
                        // look like Foo::Bar().
                        pm_token_t message = parser->previous;
                        pm_arguments_t arguments = { 0 };

                        parse_arguments_list(parser, &arguments, true, accepts_command_call, (uint16_t) (depth + 1));
                        path = (pm_node_t *) pm_call_node_call_create(parser, node, &delimiter, &message, &arguments);
                    } else {
                        // Otherwise, this is a constant path. That would look like Foo::Bar.
                        path = (pm_node_t *) pm_constant_path_node_create(parser, node, &delimiter, &parser->previous);
                    }

                    // If this is followed by a comma then it is a multiple assignment.
                    if (previous_binding_power == PM_BINDING_POWER_STATEMENT && match1(parser, PM_TOKEN_COMMA)) {
                        return parse_targets_validate(parser, path, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
                    }

                    return path;
                }
                case PM_CASE_OPERATOR:
                case PM_CASE_KEYWORD:
                case PM_TOKEN_IDENTIFIER:
                case PM_TOKEN_METHOD_NAME: {
                    parser_lex(parser);
                    pm_token_t message = parser->previous;

                    // If we have an identifier following a '::' operator, then it is for
                    // sure a method call.
                    pm_arguments_t arguments = { 0 };
                    parse_arguments_list(parser, &arguments, true, accepts_command_call, (uint16_t) (depth + 1));
                    pm_call_node_t *call = pm_call_node_call_create(parser, node, &delimiter, &message, &arguments);

                    // If this is followed by a comma then it is a multiple assignment.
                    if (previous_binding_power == PM_BINDING_POWER_STATEMENT && match1(parser, PM_TOKEN_COMMA)) {
                        return parse_targets_validate(parser, (pm_node_t *) call, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
                    }

                    return (pm_node_t *) call;
                }
                case PM_TOKEN_PARENTHESIS_LEFT: {
                    // If we have a parenthesis following a '::' operator, then it is the
                    // method call shorthand. That would look like Foo::(bar).
                    pm_arguments_t arguments = { 0 };
                    parse_arguments_list(parser, &arguments, true, false, (uint16_t) (depth + 1));

                    return (pm_node_t *) pm_call_node_shorthand_create(parser, node, &delimiter, &arguments);
                }
                default: {
                    expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
                    return (pm_node_t *) pm_constant_path_node_create(parser, node, &delimiter, &parser->previous);
                }
            }
        }
        case PM_TOKEN_KEYWORD_RESCUE_MODIFIER: {
            context_push(parser, PM_CONTEXT_RESCUE_MODIFIER);
            parser_lex(parser);
            accept1(parser, PM_TOKEN_NEWLINE);

            pm_node_t *value = parse_expression(parser, binding_power, true, false, PM_ERR_RESCUE_MODIFIER_VALUE, (uint16_t) (depth + 1));
            context_pop(parser);

            return (pm_node_t *) pm_rescue_modifier_node_create(parser, node, &token, value);
        }
        case PM_TOKEN_BRACKET_LEFT: {
            parser_lex(parser);

            pm_arguments_t arguments = { 0 };
            arguments.opening_loc = PM_LOCATION_TOKEN_VALUE(&parser->previous);

            if (!accept1(parser, PM_TOKEN_BRACKET_RIGHT)) {
                pm_accepts_block_stack_push(parser, true);
                parse_arguments(parser, &arguments, false, PM_TOKEN_BRACKET_RIGHT, (uint16_t) (depth + 1));
                pm_accepts_block_stack_pop(parser);
                expect1(parser, PM_TOKEN_BRACKET_RIGHT, PM_ERR_EXPECT_RBRACKET);
            }

            arguments.closing_loc = PM_LOCATION_TOKEN_VALUE(&parser->previous);

            // If we have a comma after the closing bracket then this is a multiple
            // assignment and we should parse the targets.
            if (previous_binding_power == PM_BINDING_POWER_STATEMENT && match1(parser, PM_TOKEN_COMMA)) {
                pm_call_node_t *aref = pm_call_node_aref_create(parser, node, &arguments);
                return parse_targets_validate(parser, (pm_node_t *) aref, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
            }

            // If we're at the end of the arguments, we can now check if there is a
            // block node that starts with a {. If there is, then we can parse it and
            // add it to the arguments.
            pm_block_node_t *block = NULL;
            if (accept1(parser, PM_TOKEN_BRACE_LEFT)) {
                block = parse_block(parser, (uint16_t) (depth + 1));
                pm_arguments_validate_block(parser, &arguments, block);
            } else if (pm_accepts_block_stack_p(parser) && accept1(parser, PM_TOKEN_KEYWORD_DO)) {
                block = parse_block(parser, (uint16_t) (depth + 1));
            }

            if (block != NULL) {
                if (arguments.block != NULL) {
                    pm_parser_err_node(parser, (pm_node_t *) block, PM_ERR_ARGUMENT_AFTER_BLOCK);
                    if (arguments.arguments == NULL) {
                        arguments.arguments = pm_arguments_node_create(parser);
                    }
                    pm_arguments_node_arguments_append(arguments.arguments, arguments.block);
                }

                arguments.block = (pm_node_t *) block;
            }

            return (pm_node_t *) pm_call_node_aref_create(parser, node, &arguments);
        }
        case PM_TOKEN_KEYWORD_IN: {
            bool previous_pattern_matching_newlines = parser->pattern_matching_newlines;
            parser->pattern_matching_newlines = true;

            pm_token_t operator = parser->current;
            parser->command_start = false;
            lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
            parser_lex(parser);

            pm_constant_id_list_t captures = { 0 };
            pm_node_t *pattern = parse_pattern(parser, &captures, PM_PARSE_PATTERN_TOP | PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_IN, (uint16_t) (depth + 1));

            parser->pattern_matching_newlines = previous_pattern_matching_newlines;
            pm_constant_id_list_free(&captures);

            return (pm_node_t *) pm_match_predicate_node_create(parser, node, pattern, &operator);
        }
        case PM_TOKEN_EQUAL_GREATER: {
            bool previous_pattern_matching_newlines = parser->pattern_matching_newlines;
            parser->pattern_matching_newlines = true;

            pm_token_t operator = parser->current;
            parser->command_start = false;
            lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
            parser_lex(parser);

            pm_constant_id_list_t captures = { 0 };
            pm_node_t *pattern = parse_pattern(parser, &captures, PM_PARSE_PATTERN_TOP | PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_HROCKET, (uint16_t) (depth + 1));

            parser->pattern_matching_newlines = previous_pattern_matching_newlines;
            pm_constant_id_list_free(&captures);

            return (pm_node_t *) pm_match_required_node_create(parser, node, pattern, &operator);
        }
        default:
            assert(false && "unreachable");
            return NULL;
    }
}

#undef PM_PARSE_PATTERN_SINGLE
#undef PM_PARSE_PATTERN_TOP
#undef PM_PARSE_PATTERN_MULTI

/**
 * Determine if a given call node looks like a "command", which means it has
 * arguments but does not have parentheses.
 */
static inline bool
pm_call_node_command_p(const pm_call_node_t *node) {
    return (
        (node->opening_loc.start == NULL) &&
        (node->block == NULL || PM_NODE_TYPE_P(node->block, PM_BLOCK_ARGUMENT_NODE)) &&
        (node->arguments != NULL || node->block != NULL)
    );
}

/**
 * Parse an expression at the given point of the parser using the given binding
 * power to parse subsequent chains. If this function finds a syntax error, it
 * will append the error message to the parser's error list.
 *
 * Consumers of this function should always check parser->recovering to
 * determine if they need to perform additional cleanup.
 */
static pm_node_t *
parse_expression(pm_parser_t *parser, pm_binding_power_t binding_power, bool accepts_command_call, bool accepts_label, pm_diagnostic_id_t diag_id, uint16_t depth) {
    if (PRISM_UNLIKELY(depth >= PRISM_DEPTH_MAXIMUM)) {
        pm_parser_err_current(parser, PM_ERR_NESTING_TOO_DEEP);
        return (pm_node_t *) pm_missing_node_create(parser, parser->current.start, parser->current.end);
    }

    pm_node_t *node = parse_expression_prefix(parser, binding_power, accepts_command_call, accepts_label, diag_id, depth);

    switch (PM_NODE_TYPE(node)) {
        case PM_MISSING_NODE:
            // If we found a syntax error, then the type of node returned by
            // parse_expression_prefix is going to be a missing node.
            return node;
        case PM_PRE_EXECUTION_NODE:
        case PM_POST_EXECUTION_NODE:
        case PM_ALIAS_GLOBAL_VARIABLE_NODE:
        case PM_ALIAS_METHOD_NODE:
        case PM_MULTI_WRITE_NODE:
        case PM_UNDEF_NODE:
            // These expressions are statements, and cannot be followed by
            // operators (except modifiers).
            if (pm_binding_powers[parser->current.type].left > PM_BINDING_POWER_MODIFIER) {
                return node;
            }
            break;
        case PM_CALL_NODE:
            // If we have a call node, then we need to check if it looks like a
            // method call without parentheses that contains arguments. If it
            // does, then it has different rules for parsing infix operators,
            // namely that it only accepts composition (and/or) and modifiers
            // (if/unless/etc.).
            if ((pm_binding_powers[parser->current.type].left > PM_BINDING_POWER_COMPOSITION) && pm_call_node_command_p((pm_call_node_t *) node)) {
                return node;
            }
            break;
        case PM_SYMBOL_NODE:
            // If we have a symbol node that is being parsed as a label, then we
            // need to immediately return, because there should never be an
            // infix operator following this node.
            if (pm_symbol_node_label_p(node)) {
                return node;
            }
            break;
        default:
            break;
    }

    // Otherwise we'll look and see if the next token can be parsed as an infix
    // operator. If it can, then we'll parse it using parse_expression_infix.
    pm_binding_powers_t current_binding_powers;
    pm_token_type_t current_token_type;

    while (
        current_token_type = parser->current.type,
        current_binding_powers = pm_binding_powers[current_token_type],
        binding_power <= current_binding_powers.left &&
        current_binding_powers.binary
     ) {
        node = parse_expression_infix(parser, node, binding_power, current_binding_powers.right, accepts_command_call, (uint16_t) (depth + 1));

        if (context_terminator(parser->current_context->context, &parser->current)) {
            // If this token terminates the current context, then we need to
            // stop parsing the expression, as it has become a statement.
            return node;
        }

        switch (PM_NODE_TYPE(node)) {
            case PM_MULTI_WRITE_NODE:
                // Multi-write nodes are statements, and cannot be followed by
                // operators except modifiers.
                if (pm_binding_powers[parser->current.type].left > PM_BINDING_POWER_MODIFIER) {
                    return node;
                }
                break;
            case PM_CLASS_VARIABLE_WRITE_NODE:
            case PM_CONSTANT_PATH_WRITE_NODE:
            case PM_CONSTANT_WRITE_NODE:
            case PM_GLOBAL_VARIABLE_WRITE_NODE:
            case PM_INSTANCE_VARIABLE_WRITE_NODE:
            case PM_LOCAL_VARIABLE_WRITE_NODE:
                // These expressions are statements, by virtue of the right-hand
                // side of their write being an implicit array.
                if (PM_NODE_FLAG_P(node, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY) && pm_binding_powers[parser->current.type].left > PM_BINDING_POWER_MODIFIER) {
                    return node;
                }
                break;
            case PM_CALL_NODE:
                // These expressions are also statements, by virtue of the
                // right-hand side of the expression (i.e., the last argument to
                // the call node) being an implicit array.
                if (PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_IMPLICIT_ARRAY) && pm_binding_powers[parser->current.type].left > PM_BINDING_POWER_MODIFIER) {
                    return node;
                }
                break;
            default:
                break;
        }

        // If the operator is nonassoc and we should not be able to parse the
        // upcoming infix operator, break.
        if (current_binding_powers.nonassoc) {
            // If this is a non-assoc operator and we are about to parse the
            // exact same operator, then we need to add an error.
            if (match1(parser, current_token_type)) {
                PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_NON_ASSOCIATIVE_OPERATOR, pm_token_type_human(parser->current.type), pm_token_type_human(current_token_type));
                break;
            }

            // If this is an endless range, then we need to reject a couple of
            // additional operators because it violates the normal operator
            // precedence rules. Those patterns are:
            //
            //     1.. & 2
            //     1.. * 2
            //
            if (PM_NODE_TYPE_P(node, PM_RANGE_NODE) && ((pm_range_node_t *) node)->right == NULL) {
                if (match4(parser, PM_TOKEN_UAMPERSAND, PM_TOKEN_USTAR, PM_TOKEN_DOT, PM_TOKEN_AMPERSAND_DOT)) {
                    PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_NON_ASSOCIATIVE_OPERATOR, pm_token_type_human(parser->current.type), pm_token_type_human(current_token_type));
                    break;
                }

                if (PM_BINDING_POWER_TERM <= pm_binding_powers[parser->current.type].left) {
                    break;
                }
            } else if (current_binding_powers.left <= pm_binding_powers[parser->current.type].left) {
                break;
            }
        }

        if (accepts_command_call) {
            // A command-style method call is only accepted on method chains.
            // Thus, we check whether the parsed node can continue method chains.
            // The method chain can continue if the parsed node is one of the following five kinds:
            // (1) index access: foo[1]
            // (2) attribute access: foo.bar
            // (3) method call with parenthesis: foo.bar(1)
            // (4) method call with a block: foo.bar do end
            // (5) constant path: foo::Bar
            switch (node->type) {
                case PM_CALL_NODE: {
                    pm_call_node_t *cast = (pm_call_node_t *)node;
                    if (
                        // (1) foo[1]
                        !(
                            cast->call_operator_loc.start == NULL &&
                            cast->message_loc.start != NULL &&
                            cast->message_loc.start[0] == '[' &&
                            cast->message_loc.end[-1] == ']'
                        ) &&
                        // (2) foo.bar
                        !(
                            cast->call_operator_loc.start != NULL &&
                            cast->arguments == NULL &&
                            cast->block == NULL &&
                            cast->opening_loc.start == NULL
                        ) &&
                        // (3) foo.bar(1)
                        !(
                            cast->call_operator_loc.start != NULL &&
                            cast->opening_loc.start != NULL
                        ) &&
                        // (4) foo.bar do end
                        !(
                            cast->block != NULL && PM_NODE_TYPE_P(cast->block, PM_BLOCK_NODE)
                        )
                     ) {
                        accepts_command_call = false;
                    }
                    break;
                }
                // (5) foo::Bar
                case PM_CONSTANT_PATH_NODE:
                    break;
                default:
                    accepts_command_call = false;
                    break;
            }
        }
    }

    return node;
}

/**
 * ruby -p, ruby -n, ruby -a, and ruby -l options will mutate the AST. We
 * perform that mutation here.
 */
static pm_statements_node_t *
wrap_statements(pm_parser_t *parser, pm_statements_node_t *statements) {
    if (PM_PARSER_COMMAND_LINE_OPTION_P(parser)) {
        if (statements == NULL) {
            statements = pm_statements_node_create(parser);
        }

        pm_arguments_node_t *arguments = pm_arguments_node_create(parser);
        pm_arguments_node_arguments_append(
            arguments,
            (pm_node_t *) pm_global_variable_read_node_synthesized_create(parser, pm_parser_constant_id_constant(parser, "$_", 2))
        );

        pm_statements_node_body_append(parser, statements, (pm_node_t *) pm_call_node_fcall_synthesized_create(
            parser,
            arguments,
            pm_parser_constant_id_constant(parser, "print", 5)
        ), true);
    }

    if (PM_PARSER_COMMAND_LINE_OPTION_N(parser)) {
        if (PM_PARSER_COMMAND_LINE_OPTION_A(parser)) {
            if (statements == NULL) {
                statements = pm_statements_node_create(parser);
            }

            pm_arguments_node_t *arguments = pm_arguments_node_create(parser);
            pm_arguments_node_arguments_append(
                arguments,
                (pm_node_t *) pm_global_variable_read_node_synthesized_create(parser, pm_parser_constant_id_constant(parser, "$;", 2))
            );

            pm_global_variable_read_node_t *receiver = pm_global_variable_read_node_synthesized_create(parser, pm_parser_constant_id_constant(parser, "$_", 2));
            pm_call_node_t *call = pm_call_node_call_synthesized_create(parser, (pm_node_t *) receiver, "split", arguments);

            pm_global_variable_write_node_t *write = pm_global_variable_write_node_synthesized_create(
                parser,
                pm_parser_constant_id_constant(parser, "$F", 2),
                (pm_node_t *) call
            );

            pm_statements_node_body_prepend(statements, (pm_node_t *) write);
        }

        pm_arguments_node_t *arguments = pm_arguments_node_create(parser);
        pm_arguments_node_arguments_append(
            arguments,
            (pm_node_t *) pm_global_variable_read_node_synthesized_create(parser, pm_parser_constant_id_constant(parser, "$/", 2))
        );

        if (PM_PARSER_COMMAND_LINE_OPTION_L(parser)) {
            pm_keyword_hash_node_t *keywords = pm_keyword_hash_node_create(parser);
            pm_keyword_hash_node_elements_append(keywords, (pm_node_t *) pm_assoc_node_create(
                parser,
                (pm_node_t *) pm_symbol_node_synthesized_create(parser, "chomp"),
                &(pm_token_t) { .type = PM_TOKEN_NOT_PROVIDED, .start = parser->start, .end = parser->start },
                (pm_node_t *) pm_true_node_synthesized_create(parser)
            ));

            pm_arguments_node_arguments_append(arguments, (pm_node_t *) keywords);
            pm_node_flag_set((pm_node_t *) arguments, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS);
        }

        pm_statements_node_t *wrapped_statements = pm_statements_node_create(parser);
        pm_statements_node_body_append(parser, wrapped_statements, (pm_node_t *) pm_while_node_synthesized_create(
            parser,
            (pm_node_t *) pm_call_node_fcall_synthesized_create(parser, arguments, pm_parser_constant_id_constant(parser, "gets", 4)),
            statements
        ), true);

        statements = wrapped_statements;
    }

    return statements;
}

/**
 * Parse the top-level program node.
 */
static pm_node_t *
parse_program(pm_parser_t *parser) {
    // If the current scope is NULL, then we want to push a new top level scope.
    // The current scope could exist in the event that we are parsing an eval
    // and the user has passed into scopes that already exist.
    if (parser->current_scope == NULL) {
        pm_parser_scope_push(parser, true);
    }

    pm_node_list_t current_block_exits = { 0 };
    pm_node_list_t *previous_block_exits = push_block_exits(parser, ¤t_block_exits);

    parser_lex(parser);
    pm_statements_node_t *statements = parse_statements(parser, PM_CONTEXT_MAIN, 0);

    if (statements != NULL && !parser->parsing_eval) {
        // If we have statements, then the top-level statement should be
        // explicitly checked as well. We have to do this here because
        // everywhere else we check all but the last statement.
        assert(statements->body.size > 0);
        pm_void_statement_check(parser, statements->body.nodes[statements->body.size - 1]);
    }

    pm_constant_id_list_t locals;
    pm_locals_order(parser, &parser->current_scope->locals, &locals, true);
    pm_parser_scope_pop(parser);

    // At the top level, see if we need to wrap the statements in a program
    // node with a while loop based on the options.
    if (parser->command_line & (PM_OPTIONS_COMMAND_LINE_P | PM_OPTIONS_COMMAND_LINE_N)) {
        statements = wrap_statements(parser, statements);
    } else {
        flush_block_exits(parser, previous_block_exits);
        pm_node_list_free(¤t_block_exits);
    }

    // If this is an empty file, then we're still going to parse all of the
    // statements in order to gather up all of the comments and such. Here we'll
    // correct the location information.
    if (statements == NULL) {
        statements = pm_statements_node_create(parser);
        pm_statements_node_location_set(statements, parser->start, parser->start);
    }

    return (pm_node_t *) pm_program_node_create(parser, &locals, statements);
}

/******************************************************************************/
/* External functions                                                         */
/******************************************************************************/

/**
 * A vendored version of strnstr that is used to find a substring within a
 * string with a given length. This function is used to search for the Ruby
 * engine name within a shebang when the -x option is passed to Ruby.
 *
 * The only modification that we made here is that we don't do NULL byte checks
 * because we know the little parameter will not have a NULL byte and we allow
 * the big parameter to have them.
 */
static const char *
pm_strnstr(const char *big, const char *little, size_t big_length) {
    size_t little_length = strlen(little);

    for (const char *big_end = big + big_length; big < big_end; big++) {
        if (*big == *little && memcmp(big, little, little_length) == 0) return big;
    }

    return NULL;
}

#ifdef _WIN32
#define pm_parser_warn_shebang_carriage_return(parser, start, length) ((void) 0)
#else
/**
 * Potentially warn the user if the shebang that has been found to include
 * "ruby" has a carriage return at the end, as that can cause problems on some
 * platforms.
 */
static void
pm_parser_warn_shebang_carriage_return(pm_parser_t *parser, const uint8_t *start, size_t length) {
    if (length > 2 && start[length - 2] == '\r' && start[length - 1] == '\n') {
        pm_parser_warn(parser, start, start + length, PM_WARN_SHEBANG_CARRIAGE_RETURN);
    }
}
#endif

/**
 * Process the shebang when initializing the parser. This function assumes that
 * the shebang_callback option has already been checked for nullability.
 */
static void
pm_parser_init_shebang(pm_parser_t *parser, const pm_options_t *options, const char *engine, size_t length) {
    const char *switches = pm_strnstr(engine, " -", length);
    if (switches == NULL) return;

    pm_options_t next_options = *options;
    options->shebang_callback(
        &next_options,
        (const uint8_t *) (switches + 1),
        length - ((size_t) (switches - engine)) - 1,
        options->shebang_callback_data
    );

    size_t encoding_length;
    if ((encoding_length = pm_string_length(&next_options.encoding)) > 0) {
        const uint8_t *encoding_source = pm_string_source(&next_options.encoding);
        parser_lex_magic_comment_encoding_value(parser, encoding_source, encoding_source + encoding_length);
    }

    parser->command_line = next_options.command_line;
    parser->frozen_string_literal = next_options.frozen_string_literal;
}

/**
 * Initialize a parser with the given start and end pointers.
 */
PRISM_EXPORTED_FUNCTION void
pm_parser_init(pm_parser_t *parser, const uint8_t *source, size_t size, const pm_options_t *options) {
    assert(source != NULL);

    *parser = (pm_parser_t) {
        .node_id = 0,
        .lex_state = PM_LEX_STATE_BEG,
        .enclosure_nesting = 0,
        .lambda_enclosure_nesting = -1,
        .brace_nesting = 0,
        .do_loop_stack = 0,
        .accepts_block_stack = 0,
        .lex_modes = {
            .index = 0,
            .stack = {{ .mode = PM_LEX_DEFAULT }},
            .current = &parser->lex_modes.stack[0],
        },
        .start = source,
        .end = source + size,
        .previous = { .type = PM_TOKEN_EOF, .start = source, .end = source },
        .current = { .type = PM_TOKEN_EOF, .start = source, .end = source },
        .next_start = NULL,
        .heredoc_end = NULL,
        .data_loc = { .start = NULL, .end = NULL },
        .comment_list = { 0 },
        .magic_comment_list = { 0 },
        .warning_list = { 0 },
        .error_list = { 0 },
        .current_scope = NULL,
        .current_context = NULL,
        .encoding = PM_ENCODING_UTF_8_ENTRY,
        .encoding_changed_callback = NULL,
        .encoding_comment_start = source,
        .lex_callback = NULL,
        .filepath = { 0 },
        .constant_pool = { 0 },
        .newline_list = { 0 },
        .integer_base = 0,
        .current_string = PM_STRING_EMPTY,
        .start_line = 1,
        .explicit_encoding = NULL,
        .command_line = 0,
        .parsing_eval = false,
        .partial_script = false,
        .command_start = true,
        .recovering = false,
        .encoding_locked = false,
        .encoding_changed = false,
        .pattern_matching_newlines = false,
        .in_keyword_arg = false,
        .current_block_exits = NULL,
        .semantic_token_seen = false,
        .frozen_string_literal = PM_OPTIONS_FROZEN_STRING_LITERAL_UNSET,
        .current_regular_expression_ascii_only = false,
        .warn_mismatched_indentation = true
    };

    // Initialize the constant pool. We're going to completely guess as to the
    // number of constants that we'll need based on the size of the input. The
    // ratio we chose here is actually less arbitrary than you might think.
    //
    // We took ~50K Ruby files and measured the size of the file versus the
    // number of constants that were found in those files. Then we found the
    // average and standard deviation of the ratios of constants/bytesize. Then
    // we added 1.34 standard deviations to the average to get a ratio that
    // would fit 75% of the files (for a two-tailed distribution). This works
    // because there was about a 0.77 correlation and the distribution was
    // roughly normal.
    //
    // This ratio will need to change if we add more constants to the constant
    // pool for another node type.
    uint32_t constant_size = ((uint32_t) size) / 95;
    pm_constant_pool_init(&parser->constant_pool, constant_size < 4 ? 4 : constant_size);

    // Initialize the newline list. Similar to the constant pool, we're going to
    // guess at the number of newlines that we'll need based on the size of the
    // input.
    size_t newline_size = size / 22;
    pm_newline_list_init(&parser->newline_list, source, newline_size < 4 ? 4 : newline_size);

    // If options were provided to this parse, establish them here.
    if (options != NULL) {
        // filepath option
        parser->filepath = options->filepath;

        // line option
        parser->start_line = options->line;

        // encoding option
        size_t encoding_length = pm_string_length(&options->encoding);
        if (encoding_length > 0) {
            const uint8_t *encoding_source = pm_string_source(&options->encoding);
            parser_lex_magic_comment_encoding_value(parser, encoding_source, encoding_source + encoding_length);
        }

        // encoding_locked option
        parser->encoding_locked = options->encoding_locked;

        // frozen_string_literal option
        parser->frozen_string_literal = options->frozen_string_literal;

        // command_line option
        parser->command_line = options->command_line;

        // version option
        parser->version = options->version;

        // partial_script
        parser->partial_script = options->partial_script;

        // scopes option
        parser->parsing_eval = options->scopes_count > 0;
        if (parser->parsing_eval) parser->warn_mismatched_indentation = false;

        for (size_t scope_index = 0; scope_index < options->scopes_count; scope_index++) {
            const pm_options_scope_t *scope = pm_options_scope_get(options, scope_index);
            pm_parser_scope_push(parser, scope_index == 0);

            // Scopes given from the outside are not allowed to have numbered
            // parameters.
            parser->current_scope->parameters = ((pm_scope_parameters_t) scope->forwarding) | PM_SCOPE_PARAMETERS_IMPLICIT_DISALLOWED;

            for (size_t local_index = 0; local_index < scope->locals_count; local_index++) {
                const pm_string_t *local = pm_options_scope_local_get(scope, local_index);

                const uint8_t *source = pm_string_source(local);
                size_t length = pm_string_length(local);

                void *allocated = xmalloc(length);
                if (allocated == NULL) continue;

                memcpy(allocated, source, length);
                pm_parser_local_add_owned(parser, (uint8_t *) allocated, length);
            }
        }
    }

    // Now that we have established the user-provided options, check if
    // a version was given and parse as the latest version otherwise.
    if (parser->version == PM_OPTIONS_VERSION_UNSET) {
        parser->version = PM_OPTIONS_VERSION_LATEST;
    }

    pm_accepts_block_stack_push(parser, true);

    // Skip past the UTF-8 BOM if it exists.
    if (size >= 3 && source[0] == 0xef && source[1] == 0xbb && source[2] == 0xbf) {
        parser->current.end += 3;
        parser->encoding_comment_start += 3;

        if (parser->encoding != PM_ENCODING_UTF_8_ENTRY) {
            parser->encoding = PM_ENCODING_UTF_8_ENTRY;
            if (parser->encoding_changed_callback != NULL) parser->encoding_changed_callback(parser);
        }
    }

    // If the -x command line flag is set, or the first shebang of the file does
    // not include "ruby", then we'll search for a shebang that does include
    // "ruby" and start parsing from there.
    bool search_shebang = PM_PARSER_COMMAND_LINE_OPTION_X(parser);

    // If the first two bytes of the source are a shebang, then we will do a bit
    // of extra processing.
    //
    // First, we'll indicate that the encoding comment is at the end of the
    // shebang. This means that when a shebang is present the encoding comment
    // can begin on the second line.
    //
    // Second, we will check if the shebang includes "ruby". If it does, then we
    // we will start parsing from there. We will also potentially warning the
    // user if there is a carriage return at the end of the shebang. We will
    // also potentially call the shebang callback if this is the main script to
    // allow the caller to parse the shebang and find any command-line options.
    // If the shebang does not include "ruby" and this is the main script being
    // parsed, then we will start searching the file for a shebang that does
    // contain "ruby" as if -x were passed on the command line.
    const uint8_t *newline = next_newline(parser->start, parser->end - parser->start);
    size_t length = (size_t) ((newline != NULL ? newline : parser->end) - parser->start);

    if (length > 2 && parser->current.end[0] == '#' && parser->current.end[1] == '!') {
        const char *engine;

        if ((engine = pm_strnstr((const char *) parser->start, "ruby", length)) != NULL) {
            if (newline != NULL) {
                parser->encoding_comment_start = newline + 1;

                if (options == NULL || options->main_script) {
                    pm_parser_warn_shebang_carriage_return(parser, parser->start, length + 1);
                }
            }

            if (options != NULL && options->main_script && options->shebang_callback != NULL) {
                pm_parser_init_shebang(parser, options, engine, length - ((size_t) (engine - (const char *) parser->start)));
            }

            search_shebang = false;
        } else if (options != NULL && options->main_script && !parser->parsing_eval) {
            search_shebang = true;
        }
    }

    // Here we're going to find the first shebang that includes "ruby" and start
    // parsing from there.
    if (search_shebang) {
        // If a shebang that includes "ruby" is not found, then we're going to a
        // a load error to the list of errors on the parser.
        bool found_shebang = false;

        // This is going to point to the start of each line as we check it.
        // We'll maintain a moving window looking at each line at they come.
        const uint8_t *cursor = parser->start;

        // The newline pointer points to the end of the current line that we're
        // considering. If it is NULL, then we're at the end of the file.
        const uint8_t *newline = next_newline(cursor, parser->end - cursor);

        while (newline != NULL) {
            pm_newline_list_append(&parser->newline_list, newline);

            cursor = newline + 1;
            newline = next_newline(cursor, parser->end - cursor);

            size_t length = (size_t) ((newline != NULL ? newline : parser->end) - cursor);
            if (length > 2 && cursor[0] == '#' && cursor[1] == '!') {
                const char *engine;
                if ((engine = pm_strnstr((const char *) cursor, "ruby", length)) != NULL) {
                    found_shebang = true;

                    if (newline != NULL) {
                        pm_parser_warn_shebang_carriage_return(parser, cursor, length + 1);
                        parser->encoding_comment_start = newline + 1;
                    }

                    if (options != NULL && options->shebang_callback != NULL) {
                        pm_parser_init_shebang(parser, options, engine, length - ((size_t) (engine - (const char *) cursor)));
                    }

                    break;
                }
            }
        }

        if (found_shebang) {
            parser->previous = (pm_token_t) { .type = PM_TOKEN_EOF, .start = cursor, .end = cursor };
            parser->current = (pm_token_t) { .type = PM_TOKEN_EOF, .start = cursor, .end = cursor };
        } else {
            pm_parser_err(parser, parser->start, parser->start, PM_ERR_SCRIPT_NOT_FOUND);
            pm_newline_list_clear(&parser->newline_list);
        }
    }

    // The encoding comment can start after any amount of inline whitespace, so
    // here we'll advance it to the first non-inline-whitespace character so
    // that it is ready for future comparisons.
    parser->encoding_comment_start += pm_strspn_inline_whitespace(parser->encoding_comment_start, parser->end - parser->encoding_comment_start);
}

/**
 * Register a callback that will be called whenever prism changes the encoding
 * it is using to parse based on the magic comment.
 */
PRISM_EXPORTED_FUNCTION void
pm_parser_register_encoding_changed_callback(pm_parser_t *parser, pm_encoding_changed_callback_t callback) {
    parser->encoding_changed_callback = callback;
}

/**
 * Free all of the memory associated with the comment list.
 */
static inline void
pm_comment_list_free(pm_list_t *list) {
    pm_list_node_t *node, *next;

    for (node = list->head; node != NULL; node = next) {
        next = node->next;

        pm_comment_t *comment = (pm_comment_t *) node;
        xfree(comment);
    }
}

/**
 * Free all of the memory associated with the magic comment list.
 */
static inline void
pm_magic_comment_list_free(pm_list_t *list) {
    pm_list_node_t *node, *next;

    for (node = list->head; node != NULL; node = next) {
        next = node->next;

        pm_magic_comment_t *magic_comment = (pm_magic_comment_t *) node;
        xfree(magic_comment);
    }
}

/**
 * Free any memory associated with the given parser.
 */
PRISM_EXPORTED_FUNCTION void
pm_parser_free(pm_parser_t *parser) {
    pm_string_free(&parser->filepath);
    pm_diagnostic_list_free(&parser->error_list);
    pm_diagnostic_list_free(&parser->warning_list);
    pm_comment_list_free(&parser->comment_list);
    pm_magic_comment_list_free(&parser->magic_comment_list);
    pm_constant_pool_free(&parser->constant_pool);
    pm_newline_list_free(&parser->newline_list);

    while (parser->current_scope != NULL) {
        // Normally, popping the scope doesn't free the locals since it is
        // assumed that ownership has transferred to the AST. However if we have
        // scopes while we're freeing the parser, it's likely they came from
        // eval scopes and we need to free them explicitly here.
        pm_parser_scope_pop(parser);
    }

    while (parser->lex_modes.index >= PM_LEX_STACK_SIZE) {
        lex_mode_pop(parser);
    }
}

/**
 * Parse the Ruby source associated with the given parser and return the tree.
 */
PRISM_EXPORTED_FUNCTION pm_node_t *
pm_parse(pm_parser_t *parser) {
    return parse_program(parser);
}

/**
 * Read into the stream until the gets callback returns false. If the last read
 * line from the stream matches an __END__ marker, then halt and return false,
 * otherwise return true.
 */
static bool
pm_parse_stream_read(pm_buffer_t *buffer, void *stream, pm_parse_stream_fgets_t *stream_fgets, pm_parse_stream_feof_t *stream_feof) {
#define LINE_SIZE 4096
    char line[LINE_SIZE];

    while (memset(line, '\n', LINE_SIZE), stream_fgets(line, LINE_SIZE, stream) != NULL) {
        size_t length = LINE_SIZE;
        while (length > 0 && line[length - 1] == '\n') length--;

        if (length == LINE_SIZE) {
            // If we read a line that is the maximum size and it doesn't end
            // with a newline, then we'll just append it to the buffer and
            // continue reading.
            length--;
            pm_buffer_append_string(buffer, line, length);
            continue;
        }

        // Append the line to the buffer.
        length--;
        pm_buffer_append_string(buffer, line, length);

        // Check if the line matches the __END__ marker. If it does, then stop
        // reading and return false. In most circumstances, this means we should
        // stop reading from the stream so that the DATA constant can pick it
        // up.
        switch (length) {
            case 7:
                if (strncmp(line, "__END__", 7) == 0) return false;
                break;
            case 8:
                if (strncmp(line, "__END__\n", 8) == 0) return false;
                break;
            case 9:
                if (strncmp(line, "__END__\r\n", 9) == 0) return false;
                break;
        }

        // All data should be read via gets.  If the string returned by gets
        // _doesn't_ end with a newline, then we assume we hit EOF condition.
        if (stream_feof(stream)) {
            break;
        }
    }

    return true;
#undef LINE_SIZE
}

/**
 * Determine if there was an unterminated heredoc at the end of the input, which
 * would mean the stream isn't finished and we should keep reading.
 *
 * For the other lex modes we can check if the lex mode has been closed, but for
 * heredocs when we hit EOF we close the lex mode and then go back to parse the
 * rest of the line after the heredoc declaration so that we get more of the
 * syntax tree.
 */
static bool
pm_parse_stream_unterminated_heredoc_p(pm_parser_t *parser) {
    pm_diagnostic_t *diagnostic = (pm_diagnostic_t *) parser->error_list.head;

    for (; diagnostic != NULL; diagnostic = (pm_diagnostic_t *) diagnostic->node.next) {
        if (diagnostic->diag_id == PM_ERR_HEREDOC_TERM) {
            return true;
        }
    }

    return false;
}

/**
 * Parse a stream of Ruby source and return the tree.
 *
 * Prism is designed around having the entire source in memory at once, but you
 * can stream stdin in to Ruby so we need to support a streaming API.
 */
PRISM_EXPORTED_FUNCTION pm_node_t *
pm_parse_stream(pm_parser_t *parser, pm_buffer_t *buffer, void *stream, pm_parse_stream_fgets_t *stream_fgets, pm_parse_stream_feof_t *stream_feof, const pm_options_t *options) {
    pm_buffer_init(buffer);

    bool eof = pm_parse_stream_read(buffer, stream, stream_fgets, stream_feof);

    pm_parser_init(parser, (const uint8_t *) pm_buffer_value(buffer), pm_buffer_length(buffer), options);
    pm_node_t *node = pm_parse(parser);

    while (!eof && parser->error_list.size > 0 && (parser->lex_modes.index > 0 || pm_parse_stream_unterminated_heredoc_p(parser))) {
        pm_node_destroy(parser, node);
        eof = pm_parse_stream_read(buffer, stream, stream_fgets, stream_feof);

        pm_parser_free(parser);
        pm_parser_init(parser, (const uint8_t *) pm_buffer_value(buffer), pm_buffer_length(buffer), options);
        node = pm_parse(parser);
    }

    return node;
}

/**
 * Parse the source and return true if it parses without errors or warnings.
 */
PRISM_EXPORTED_FUNCTION bool
pm_parse_success_p(const uint8_t *source, size_t size, const char *data) {
    pm_options_t options = { 0 };
    pm_options_read(&options, data);

    pm_parser_t parser;
    pm_parser_init(&parser, source, size, &options);

    pm_node_t *node = pm_parse(&parser);
    pm_node_destroy(&parser, node);

    bool result = parser.error_list.size == 0;
    pm_parser_free(&parser);
    pm_options_free(&options);

    return result;
}

#undef PM_CASE_KEYWORD
#undef PM_CASE_OPERATOR
#undef PM_CASE_WRITABLE
#undef PM_STRING_EMPTY
#undef PM_LOCATION_NODE_BASE_VALUE
#undef PM_LOCATION_NODE_VALUE
#undef PM_LOCATION_NULL_VALUE
#undef PM_LOCATION_TOKEN_VALUE

// We optionally support serializing to a binary string. For systems that don't
// want or need this functionality, it can be turned off with the
// PRISM_EXCLUDE_SERIALIZATION define.
#ifndef PRISM_EXCLUDE_SERIALIZATION

static inline void
pm_serialize_header(pm_buffer_t *buffer) {
    pm_buffer_append_string(buffer, "PRISM", 5);
    pm_buffer_append_byte(buffer, PRISM_VERSION_MAJOR);
    pm_buffer_append_byte(buffer, PRISM_VERSION_MINOR);
    pm_buffer_append_byte(buffer, PRISM_VERSION_PATCH);
    pm_buffer_append_byte(buffer, PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS ? 1 : 0);
}

/**
 * Serialize the AST represented by the given node to the given buffer.
 */
PRISM_EXPORTED_FUNCTION void
pm_serialize(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
    pm_serialize_header(buffer);
    pm_serialize_content(parser, node, buffer);
    pm_buffer_append_byte(buffer, '\0');
}

/**
 * Parse and serialize the AST represented by the given source to the given
 * buffer.
 */
PRISM_EXPORTED_FUNCTION void
pm_serialize_parse(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data) {
    pm_options_t options = { 0 };
    pm_options_read(&options, data);

    pm_parser_t parser;
    pm_parser_init(&parser, source, size, &options);

    pm_node_t *node = pm_parse(&parser);

    pm_serialize_header(buffer);
    pm_serialize_content(&parser, node, buffer);
    pm_buffer_append_byte(buffer, '\0');

    pm_node_destroy(&parser, node);
    pm_parser_free(&parser);
    pm_options_free(&options);
}

/**
 * Parse and serialize the AST represented by the source that is read out of the
 * given stream into to the given buffer.
 */
PRISM_EXPORTED_FUNCTION void
pm_serialize_parse_stream(pm_buffer_t *buffer, void *stream, pm_parse_stream_fgets_t *stream_fgets, pm_parse_stream_feof_t *stream_feof, const char *data) {
    pm_parser_t parser;
    pm_options_t options = { 0 };
    pm_options_read(&options, data);

    pm_buffer_t parser_buffer;
    pm_node_t *node = pm_parse_stream(&parser, &parser_buffer, stream, stream_fgets, stream_feof, &options);
    pm_serialize_header(buffer);
    pm_serialize_content(&parser, node, buffer);
    pm_buffer_append_byte(buffer, '\0');

    pm_node_destroy(&parser, node);
    pm_buffer_free(&parser_buffer);
    pm_parser_free(&parser);
    pm_options_free(&options);
}

/**
 * Parse and serialize the comments in the given source to the given buffer.
 */
PRISM_EXPORTED_FUNCTION void
pm_serialize_parse_comments(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data) {
    pm_options_t options = { 0 };
    pm_options_read(&options, data);

    pm_parser_t parser;
    pm_parser_init(&parser, source, size, &options);

    pm_node_t *node = pm_parse(&parser);
    pm_serialize_header(buffer);
    pm_serialize_encoding(parser.encoding, buffer);
    pm_buffer_append_varsint(buffer, parser.start_line);
    pm_serialize_comment_list(&parser, &parser.comment_list, buffer);

    pm_node_destroy(&parser, node);
    pm_parser_free(&parser);
    pm_options_free(&options);
}

#endif

/******************************************************************************/
/* Slice queries for the Ruby API                                             */
/******************************************************************************/

/** The category of slice returned from pm_slice_type. */
typedef enum {
    /** Returned when the given encoding name is invalid. */
    PM_SLICE_TYPE_ERROR = -1,

    /** Returned when no other types apply to the slice. */
    PM_SLICE_TYPE_NONE,

    /** Returned when the slice is a valid local variable name. */
    PM_SLICE_TYPE_LOCAL,

    /** Returned when the slice is a valid constant name. */
    PM_SLICE_TYPE_CONSTANT,

    /** Returned when the slice is a valid method name. */
    PM_SLICE_TYPE_METHOD_NAME
} pm_slice_type_t;

/**
 * Check that the slice is a valid local variable name or constant.
 */
pm_slice_type_t
pm_slice_type(const uint8_t *source, size_t length, const char *encoding_name) {
    // first, get the right encoding object
    const pm_encoding_t *encoding = pm_encoding_find((const uint8_t *) encoding_name, (const uint8_t *) (encoding_name + strlen(encoding_name)));
    if (encoding == NULL) return PM_SLICE_TYPE_ERROR;

    // check that there is at least one character
    if (length == 0) return PM_SLICE_TYPE_NONE;

    size_t width;
    if ((width = encoding->alpha_char(source, (ptrdiff_t) length)) != 0) {
        // valid because alphabetical
    } else if (*source == '_') {
        // valid because underscore
        width = 1;
    } else if ((*source >= 0x80) && ((width = encoding->char_width(source, (ptrdiff_t) length)) > 0)) {
        // valid because multibyte
    } else {
        // invalid because no match
        return PM_SLICE_TYPE_NONE;
    }

    // determine the type of the slice based on the first character
    const uint8_t *end = source + length;
    pm_slice_type_t result = encoding->isupper_char(source, end - source) ? PM_SLICE_TYPE_CONSTANT : PM_SLICE_TYPE_LOCAL;

    // next, iterate through all of the bytes of the string to ensure that they
    // are all valid identifier characters
    source += width;

    while (source < end) {
        if ((width = encoding->alnum_char(source, end - source)) != 0) {
            // valid because alphanumeric
            source += width;
        } else if (*source == '_') {
            // valid because underscore
            source++;
        } else if ((*source >= 0x80) && ((width = encoding->char_width(source, end - source)) > 0)) {
            // valid because multibyte
            source += width;
        } else {
            // invalid because no match
            break;
        }
    }

    // accept a ! or ? at the end of the slice as a method name
    if (*source == '!' || *source == '?' || *source == '=') {
        source++;
        result = PM_SLICE_TYPE_METHOD_NAME;
    }

    // valid if we are at the end of the slice
    return source == end ? result : PM_SLICE_TYPE_NONE;
}

/**
 * Check that the slice is a valid local variable name.
 */
PRISM_EXPORTED_FUNCTION pm_string_query_t
pm_string_query_local(const uint8_t *source, size_t length, const char *encoding_name) {
    switch (pm_slice_type(source, length, encoding_name)) {
        case PM_SLICE_TYPE_ERROR:
            return PM_STRING_QUERY_ERROR;
        case PM_SLICE_TYPE_NONE:
        case PM_SLICE_TYPE_CONSTANT:
        case PM_SLICE_TYPE_METHOD_NAME:
            return PM_STRING_QUERY_FALSE;
        case PM_SLICE_TYPE_LOCAL:
            return PM_STRING_QUERY_TRUE;
    }

    assert(false && "unreachable");
    return PM_STRING_QUERY_FALSE;
}

/**
 * Check that the slice is a valid constant name.
 */
PRISM_EXPORTED_FUNCTION pm_string_query_t
pm_string_query_constant(const uint8_t *source, size_t length, const char *encoding_name) {
    switch (pm_slice_type(source, length, encoding_name)) {
        case PM_SLICE_TYPE_ERROR:
            return PM_STRING_QUERY_ERROR;
        case PM_SLICE_TYPE_NONE:
        case PM_SLICE_TYPE_LOCAL:
        case PM_SLICE_TYPE_METHOD_NAME:
            return PM_STRING_QUERY_FALSE;
        case PM_SLICE_TYPE_CONSTANT:
            return PM_STRING_QUERY_TRUE;
    }

    assert(false && "unreachable");
    return PM_STRING_QUERY_FALSE;
}

/**
 * Check that the slice is a valid method name.
 */
PRISM_EXPORTED_FUNCTION pm_string_query_t
pm_string_query_method_name(const uint8_t *source, size_t length, const char *encoding_name) {
#define B(p) ((p) ? PM_STRING_QUERY_TRUE : PM_STRING_QUERY_FALSE)
#define C1(c) (*source == c)
#define C2(s) (memcmp(source, s, 2) == 0)
#define C3(s) (memcmp(source, s, 3) == 0)

    switch (pm_slice_type(source, length, encoding_name)) {
        case PM_SLICE_TYPE_ERROR:
            return PM_STRING_QUERY_ERROR;
        case PM_SLICE_TYPE_NONE:
            break;
        case PM_SLICE_TYPE_LOCAL:
            // numbered parameters are not valid method names
            return B((length != 2) || (source[0] != '_') || (source[1] == '0') || !pm_char_is_decimal_digit(source[1]));
        case PM_SLICE_TYPE_CONSTANT:
            // all constants are valid method names
        case PM_SLICE_TYPE_METHOD_NAME:
            // all method names are valid method names
            return PM_STRING_QUERY_TRUE;
    }

    switch (length) {
        case 1:
            return B(C1('&') || C1('`') || C1('!') || C1('^') || C1('>') || C1('<') || C1('-') || C1('%') || C1('|') || C1('+') || C1('/') || C1('*') || C1('~'));
        case 2:
            return B(C2("!=") || C2("!~") || C2("[]") || C2("==") || C2("=~") || C2(">=") || C2(">>") || C2("<=") || C2("<<") || C2("**"));
        case 3:
            return B(C3("===") || C3("<=>") || C3("[]="));
        default:
            return PM_STRING_QUERY_FALSE;
    }

#undef B
#undef C1
#undef C2
#undef C3
}
prism-1.5.1/src/regexp.c000066400000000000000000000663341506127434000151130ustar00rootroot00000000000000#include "prism/regexp.h"

#define PM_REGEXP_PARSE_DEPTH_MAX 4096

/**
 * This is the parser that is going to handle parsing regular expressions.
 */
typedef struct {
    /** The parser that is currently being used. */
    pm_parser_t *parser;

    /** A pointer to the start of the source that we are parsing. */
    const uint8_t *start;

    /** A pointer to the current position in the source. */
    const uint8_t *cursor;

    /** A pointer to the end of the source that we are parsing. */
    const uint8_t *end;

    /**
     * Whether or not the regular expression currently being parsed is in
     * extended mode, wherein whitespace is ignored and comments are allowed.
     */
    bool extended_mode;

    /** Whether the encoding has changed from the default. */
    bool encoding_changed;

    /** The encoding of the source. */
    const pm_encoding_t *encoding;

    /** The callback to call when a named capture group is found. */
    pm_regexp_name_callback_t name_callback;

    /** The data to pass to the name callback. */
    void *name_data;

    /** The callback to call when a parse error is found. */
    pm_regexp_error_callback_t error_callback;

    /** The data to pass to the error callback. */
    void *error_data;
} pm_regexp_parser_t;

/**
 * Append an error to the parser.
 */
static inline void
pm_regexp_parse_error(pm_regexp_parser_t *parser, const uint8_t *start, const uint8_t *end, const char *message) {
    parser->error_callback(start, end, message, parser->error_data);
}

/**
 * This appends a new string to the list of named captures. This function
 * assumes the caller has already checked the validity of the name callback.
 */
static void
pm_regexp_parser_named_capture(pm_regexp_parser_t *parser, const uint8_t *start, const uint8_t *end) {
    pm_string_t string;
    pm_string_shared_init(&string, start, end);
    parser->name_callback(&string, parser->name_data);
    pm_string_free(&string);
}

/**
 * Returns true if the next character is the end of the source.
 */
static inline bool
pm_regexp_char_is_eof(pm_regexp_parser_t *parser) {
    return parser->cursor >= parser->end;
}

/**
 * Optionally accept a char and consume it if it exists.
 */
static inline bool
pm_regexp_char_accept(pm_regexp_parser_t *parser, uint8_t value) {
    if (!pm_regexp_char_is_eof(parser) && *parser->cursor == value) {
        parser->cursor++;
        return true;
    }
    return false;
}

/**
 * Expect a character to be present and consume it.
 */
static inline bool
pm_regexp_char_expect(pm_regexp_parser_t *parser, uint8_t value) {
    if (!pm_regexp_char_is_eof(parser) && *parser->cursor == value) {
        parser->cursor++;
        return true;
    }
    return false;
}

/**
 * This advances the current token to the next instance of the given character.
 */
static bool
pm_regexp_char_find(pm_regexp_parser_t *parser, uint8_t value) {
    if (pm_regexp_char_is_eof(parser)) {
        return false;
    }

    const uint8_t *end = (const uint8_t *) pm_memchr(parser->cursor, value, (size_t) (parser->end - parser->cursor), parser->encoding_changed, parser->encoding);
    if (end == NULL) {
        return false;
    }

    parser->cursor = end + 1;
    return true;
}

/**
 * Range quantifiers are a special class of quantifiers that look like
 *
 * * {digit}
 * * {digit,}
 * * {digit,digit}
 * * {,digit}
 *
 * Unfortunately, if there are any spaces in between, then this just becomes a
 * regular character match expression and we have to backtrack. So when this
 * function first starts running, we'll create a "save" point and then attempt
 * to parse the quantifier. If it fails, we'll restore the save point and
 * return.
 *
 * The properly track everything, we're going to build a little state machine.
 * It looks something like the following:
 *
 *                  +-------+                 +---------+ ------------+
 * ---- lbrace ---> | start | ---- digit ---> | minimum |             |
 *                  +-------+                 +---------+ <--- digit -+
 *                      |                       |    |
 *   +-------+          |                       |  rbrace
 *   | comma | <----- comma  +---- comma -------+    |
 *   +-------+               V                       V
 *      |             +---------+               +---------+
 *      +-- digit --> | maximum | -- rbrace --> || final ||
 *                    +---------+               +---------+
 *                    |         ^
 *                    +- digit -+
 *
 * Note that by the time we've hit this function, the lbrace has already been
 * consumed so we're in the start state.
 */
static bool
pm_regexp_parse_range_quantifier(pm_regexp_parser_t *parser) {
    const uint8_t *savepoint = parser->cursor;

    enum {
        PM_REGEXP_RANGE_QUANTIFIER_STATE_START,
        PM_REGEXP_RANGE_QUANTIFIER_STATE_MINIMUM,
        PM_REGEXP_RANGE_QUANTIFIER_STATE_MAXIMUM,
        PM_REGEXP_RANGE_QUANTIFIER_STATE_COMMA
    } state = PM_REGEXP_RANGE_QUANTIFIER_STATE_START;

    while (1) {
        if (parser->cursor >= parser->end) {
            parser->cursor = savepoint;
            return true;
        }

        switch (state) {
            case PM_REGEXP_RANGE_QUANTIFIER_STATE_START:
                switch (*parser->cursor) {
                    case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
                        parser->cursor++;
                        state = PM_REGEXP_RANGE_QUANTIFIER_STATE_MINIMUM;
                        break;
                    case ',':
                        parser->cursor++;
                        state = PM_REGEXP_RANGE_QUANTIFIER_STATE_COMMA;
                        break;
                    default:
                        parser->cursor = savepoint;
                        return true;
                }
                break;
            case PM_REGEXP_RANGE_QUANTIFIER_STATE_MINIMUM:
                switch (*parser->cursor) {
                    case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
                        parser->cursor++;
                        break;
                    case ',':
                        parser->cursor++;
                        state = PM_REGEXP_RANGE_QUANTIFIER_STATE_MAXIMUM;
                        break;
                    case '}':
                        parser->cursor++;
                        return true;
                    default:
                        parser->cursor = savepoint;
                        return true;
                }
                break;
            case PM_REGEXP_RANGE_QUANTIFIER_STATE_COMMA:
                switch (*parser->cursor) {
                    case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
                        parser->cursor++;
                        state = PM_REGEXP_RANGE_QUANTIFIER_STATE_MAXIMUM;
                        break;
                    default:
                        parser->cursor = savepoint;
                        return true;
                }
                break;
            case PM_REGEXP_RANGE_QUANTIFIER_STATE_MAXIMUM:
                switch (*parser->cursor) {
                    case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
                        parser->cursor++;
                        break;
                    case '}':
                        parser->cursor++;
                        return true;
                    default:
                        parser->cursor = savepoint;
                        return true;
                }
                break;
        }
    }

    return true;
}

/**
 * quantifier : star-quantifier
 *            | plus-quantifier
 *            | optional-quantifier
 *            | range-quantifier
 *            | 
 *            ;
 */
static bool
pm_regexp_parse_quantifier(pm_regexp_parser_t *parser) {
    while (!pm_regexp_char_is_eof(parser)) {
        switch (*parser->cursor) {
            case '*':
            case '+':
            case '?':
                parser->cursor++;
                break;
            case '{':
                parser->cursor++;
                if (!pm_regexp_parse_range_quantifier(parser)) return false;
                break;
            default:
                // In this case there is no quantifier.
                return true;
        }
    }

    return true;
}

/**
 * match-posix-class : '[' '[' ':' '^'? CHAR+ ':' ']' ']'
 *                   ;
 */
static bool
pm_regexp_parse_posix_class(pm_regexp_parser_t *parser) {
    if (!pm_regexp_char_expect(parser, ':')) {
        return false;
    }

    pm_regexp_char_accept(parser, '^');

    return (
        pm_regexp_char_find(parser, ':') &&
        pm_regexp_char_expect(parser, ']') &&
        pm_regexp_char_expect(parser, ']')
    );
}

// Forward declaration because character sets can be nested.
static bool
pm_regexp_parse_lbracket(pm_regexp_parser_t *parser, uint16_t depth);

/**
 * match-char-set : '[' '^'? (match-range | match-char)* ']'
 *                ;
 */
static bool
pm_regexp_parse_character_set(pm_regexp_parser_t *parser, uint16_t depth) {
    pm_regexp_char_accept(parser, '^');

    while (!pm_regexp_char_is_eof(parser) && *parser->cursor != ']') {
        switch (*parser->cursor++) {
            case '[':
                pm_regexp_parse_lbracket(parser, (uint16_t) (depth + 1));
                break;
            case '\\':
                if (!pm_regexp_char_is_eof(parser)) {
                    parser->cursor++;
                }
                break;
            default:
                // do nothing, we've already advanced the cursor
                break;
        }
    }

    return pm_regexp_char_expect(parser, ']');
}

/**
 * A left bracket can either mean a POSIX class or a character set.
 */
static bool
pm_regexp_parse_lbracket(pm_regexp_parser_t *parser, uint16_t depth) {
    if (depth >= PM_REGEXP_PARSE_DEPTH_MAX) {
        pm_regexp_parse_error(parser, parser->start, parser->end, "parse depth limit over");
        return false;
    }

    if ((parser->cursor < parser->end) && parser->cursor[0] == ']') {
        parser->cursor++;
        pm_regexp_parse_error(parser, parser->cursor - 1, parser->cursor, "empty char-class");
        return true;
    }

    const uint8_t *reset = parser->cursor;

    if ((parser->cursor + 2 < parser->end) && parser->cursor[0] == '[' && parser->cursor[1] == ':') {
        parser->cursor++;
        if (pm_regexp_parse_posix_class(parser)) return true;

        parser->cursor = reset;
    }

    return pm_regexp_parse_character_set(parser, depth);
}

// Forward declaration here since parsing groups needs to go back up the grammar
// to parse expressions within them.
static bool
pm_regexp_parse_expression(pm_regexp_parser_t *parser, uint16_t depth);

/**
 * These are the states of the options that are configurable on the regular
 * expression (or from within a group).
 */
typedef enum {
    PM_REGEXP_OPTION_STATE_INVALID,
    PM_REGEXP_OPTION_STATE_TOGGLEABLE,
    PM_REGEXP_OPTION_STATE_ADDABLE,
    PM_REGEXP_OPTION_STATE_ADDED,
    PM_REGEXP_OPTION_STATE_REMOVED
} pm_regexp_option_state_t;

// These are the options that are configurable on the regular expression (or
// from within a group).

#define PRISM_REGEXP_OPTION_STATE_SLOT_MINIMUM 'a'
#define PRISM_REGEXP_OPTION_STATE_SLOT_MAXIMUM 'x'
#define PRISM_REGEXP_OPTION_STATE_SLOTS (PRISM_REGEXP_OPTION_STATE_SLOT_MAXIMUM - PRISM_REGEXP_OPTION_STATE_SLOT_MINIMUM + 1)

/**
 * This is the set of options that are configurable on the regular expression.
 */
typedef struct {
    /** The current state of each option. */
    uint8_t values[PRISM_REGEXP_OPTION_STATE_SLOTS];
} pm_regexp_options_t;

/**
 * Initialize a new set of options to their default values.
 */
static void
pm_regexp_options_init(pm_regexp_options_t *options) {
    memset(options, PM_REGEXP_OPTION_STATE_INVALID, sizeof(uint8_t) * PRISM_REGEXP_OPTION_STATE_SLOTS);
    options->values['i' - PRISM_REGEXP_OPTION_STATE_SLOT_MINIMUM] = PM_REGEXP_OPTION_STATE_TOGGLEABLE;
    options->values['m' - PRISM_REGEXP_OPTION_STATE_SLOT_MINIMUM] = PM_REGEXP_OPTION_STATE_TOGGLEABLE;
    options->values['x' - PRISM_REGEXP_OPTION_STATE_SLOT_MINIMUM] = PM_REGEXP_OPTION_STATE_TOGGLEABLE;
    options->values['d' - PRISM_REGEXP_OPTION_STATE_SLOT_MINIMUM] = PM_REGEXP_OPTION_STATE_ADDABLE;
    options->values['a' - PRISM_REGEXP_OPTION_STATE_SLOT_MINIMUM] = PM_REGEXP_OPTION_STATE_ADDABLE;
    options->values['u' - PRISM_REGEXP_OPTION_STATE_SLOT_MINIMUM] = PM_REGEXP_OPTION_STATE_ADDABLE;
}

/**
 * Attempt to add the given option to the set of options. Returns true if it was
 * added, false if it was already present.
 */
static bool
pm_regexp_options_add(pm_regexp_options_t *options, uint8_t key) {
    if (key >= PRISM_REGEXP_OPTION_STATE_SLOT_MINIMUM && key <= PRISM_REGEXP_OPTION_STATE_SLOT_MAXIMUM) {
        key = (uint8_t) (key - PRISM_REGEXP_OPTION_STATE_SLOT_MINIMUM);

        switch (options->values[key]) {
            case PM_REGEXP_OPTION_STATE_INVALID:
            case PM_REGEXP_OPTION_STATE_REMOVED:
                return false;
            case PM_REGEXP_OPTION_STATE_TOGGLEABLE:
            case PM_REGEXP_OPTION_STATE_ADDABLE:
                options->values[key] = PM_REGEXP_OPTION_STATE_ADDED;
                return true;
            case PM_REGEXP_OPTION_STATE_ADDED:
                return true;
        }
    }

    return false;
}

/**
 * Attempt to remove the given option from the set of options. Returns true if
 * it was removed, false if it was already absent.
 */
static bool
pm_regexp_options_remove(pm_regexp_options_t *options, uint8_t key) {
    if (key >= PRISM_REGEXP_OPTION_STATE_SLOT_MINIMUM && key <= PRISM_REGEXP_OPTION_STATE_SLOT_MAXIMUM) {
        key = (uint8_t) (key - PRISM_REGEXP_OPTION_STATE_SLOT_MINIMUM);

        switch (options->values[key]) {
            case PM_REGEXP_OPTION_STATE_INVALID:
            case PM_REGEXP_OPTION_STATE_ADDABLE:
                return false;
            case PM_REGEXP_OPTION_STATE_TOGGLEABLE:
            case PM_REGEXP_OPTION_STATE_ADDED:
            case PM_REGEXP_OPTION_STATE_REMOVED:
                options->values[key] = PM_REGEXP_OPTION_STATE_REMOVED;
                return true;
        }
    }

    return false;
}

/**
 * True if the given key is set in the options.
 */
static uint8_t
pm_regexp_options_state(pm_regexp_options_t *options, uint8_t key) {
    if (key >= PRISM_REGEXP_OPTION_STATE_SLOT_MINIMUM && key <= PRISM_REGEXP_OPTION_STATE_SLOT_MAXIMUM) {
        key = (uint8_t) (key - PRISM_REGEXP_OPTION_STATE_SLOT_MINIMUM);
        return options->values[key];
    }

    return false;
}

/**
 * Groups can have quite a few different patterns for syntax. They basically
 * just wrap a set of expressions, but they can potentially have options after a
 * question mark. If there _isn't_ a question mark, then it's just a set of
 * expressions. If there _is_, then here are the options:
 *
 * * (?#...)                       - inline comments
 * * (?:subexp)                    - non-capturing group
 * * (?=subexp)                    - positive lookahead
 * * (?!subexp)                    - negative lookahead
 * * (?>subexp)                    - atomic group
 * * (?~subexp)                    - absence operator
 * * (?<=subexp)                   - positive lookbehind
 * * (?subexp)               - named capturing group
 * * (?'name'subexp)               - named capturing group
 * * (?(cond)yes-subexp)           - conditional expression
 * * (?(cond)yes-subexp|no-subexp) - conditional expression
 * * (?imxdau-imx)                 - turn on and off configuration
 * * (?imxdau-imx:subexp)          - turn on and off configuration for an expression
 */
static bool
pm_regexp_parse_group(pm_regexp_parser_t *parser, uint16_t depth) {
    const uint8_t *group_start = parser->cursor;

    pm_regexp_options_t options;
    pm_regexp_options_init(&options);

    // First, parse any options for the group.
    if (pm_regexp_char_accept(parser, '?')) {
        if (pm_regexp_char_is_eof(parser)) {
            pm_regexp_parse_error(parser, group_start, parser->cursor, "end pattern in group");
            return false;
        }

        switch (*parser->cursor) {
            case '#': { // inline comments
                parser->cursor++;
                if (pm_regexp_char_is_eof(parser)) {
                    pm_regexp_parse_error(parser, group_start, parser->cursor, "end pattern in group");
                    return false;
                }

                if (parser->encoding_changed && parser->encoding->multibyte) {
                    bool escaped = false;

                    // Here we're going to take a slow path and iterate through
                    // each multibyte character to find the close paren. We do
                    // this because \ can be a trailing byte in some encodings.
                    while (parser->cursor < parser->end) {
                        if (!escaped && *parser->cursor == ')') {
                            parser->cursor++;
                            return true;
                        }

                        size_t width = parser->encoding->char_width(parser->cursor, (ptrdiff_t) (parser->end - parser->cursor));
                        if (width == 0) return false;

                        escaped = (width == 1) && (*parser->cursor == '\\');
                        parser->cursor += width;
                    }

                    return false;
                } else {
                    // Here we can take the fast path and use memchr to find the
                    // next ) because we are safe checking backward for \ since
                    // it cannot be a trailing character.
                    bool found = pm_regexp_char_find(parser, ')');

                    while (found && (parser->start <= parser->cursor - 2) && (*(parser->cursor - 2) == '\\')) {
                        found = pm_regexp_char_find(parser, ')');
                    }

                    return found;
                }
            }
            case ':': // non-capturing group
            case '=': // positive lookahead
            case '!': // negative lookahead
            case '>': // atomic group
            case '~': // absence operator
                parser->cursor++;
                break;
            case '<':
                parser->cursor++;
                if (pm_regexp_char_is_eof(parser)) {
                    pm_regexp_parse_error(parser, group_start, parser->cursor, "end pattern with unmatched parenthesis");
                    return false;
                }

                switch (*parser->cursor) {
                    case '=': // positive lookbehind
                    case '!': // negative lookbehind
                        parser->cursor++;
                        break;
                    default: { // named capture group
                        const uint8_t *start = parser->cursor;
                        if (!pm_regexp_char_find(parser, '>')) {
                            return false;
                        }

                        if (parser->cursor - start == 1) {
                            pm_regexp_parse_error(parser, start, parser->cursor, "group name is empty");
                        }

                        if (parser->name_callback != NULL) {
                            pm_regexp_parser_named_capture(parser, start, parser->cursor - 1);
                        }

                        break;
                    }
                }
                break;
            case '\'': { // named capture group
                const uint8_t *start = ++parser->cursor;
                if (!pm_regexp_char_find(parser, '\'')) {
                    return false;
                }

                if (parser->name_callback != NULL) {
                    pm_regexp_parser_named_capture(parser, start, parser->cursor - 1);
                }

                break;
            }
            case '(': // conditional expression
                if (!pm_regexp_char_find(parser, ')')) {
                    return false;
                }
                break;
            case 'i': case 'm': case 'x': case 'd': case 'a': case 'u': // options
                while (!pm_regexp_char_is_eof(parser) && *parser->cursor != '-' && *parser->cursor != ':' && *parser->cursor != ')') {
                    if (!pm_regexp_options_add(&options, *parser->cursor)) {
                        return false;
                    }
                    parser->cursor++;
                }

                if (pm_regexp_char_is_eof(parser)) {
                    return false;
                }

                // If we are at the end of the group of options and there is no
                // subexpression, then we are going to be setting the options
                // for the parent group. In this case we are safe to return now.
                if (*parser->cursor == ')') {
                    if (pm_regexp_options_state(&options, 'x') == PM_REGEXP_OPTION_STATE_ADDED) {
                        parser->extended_mode = true;
                    }

                    parser->cursor++;
                    return true;
                }

                // If we hit a -, then we're done parsing options.
                if (*parser->cursor != '-') break;

                PRISM_FALLTHROUGH
            case '-':
                parser->cursor++;
                while (!pm_regexp_char_is_eof(parser) && *parser->cursor != ':' && *parser->cursor != ')') {
                    if (!pm_regexp_options_remove(&options, *parser->cursor)) {
                        return false;
                    }
                    parser->cursor++;
                }

                if (pm_regexp_char_is_eof(parser)) {
                    return false;
                }

                // If we are at the end of the group of options and there is no
                // subexpression, then we are going to be setting the options
                // for the parent group. In this case we are safe to return now.
                if (*parser->cursor == ')') {
                    switch (pm_regexp_options_state(&options, 'x')) {
                        case PM_REGEXP_OPTION_STATE_ADDED:
                            parser->extended_mode = true;
                            break;
                        case PM_REGEXP_OPTION_STATE_REMOVED:
                            parser->extended_mode = false;
                            break;
                    }

                    parser->cursor++;
                    return true;
                }

                break;
            default:
                parser->cursor++;
                pm_regexp_parse_error(parser, parser->cursor - 1, parser->cursor, "undefined group option");
                break;
        }
    }

    bool extended_mode = parser->extended_mode;
    switch (pm_regexp_options_state(&options, 'x')) {
        case PM_REGEXP_OPTION_STATE_ADDED:
            parser->extended_mode = true;
            break;
        case PM_REGEXP_OPTION_STATE_REMOVED:
            parser->extended_mode = false;
            break;
    }

    // Now, parse the expressions within this group.
    while (!pm_regexp_char_is_eof(parser) && *parser->cursor != ')') {
        if (!pm_regexp_parse_expression(parser, (uint16_t) (depth + 1))) {
            parser->extended_mode = extended_mode;
            return false;
        }
        pm_regexp_char_accept(parser, '|');
    }

    // Finally, make sure we have a closing parenthesis.
    parser->extended_mode = extended_mode;
    if (pm_regexp_char_expect(parser, ')')) return true;

    pm_regexp_parse_error(parser, group_start, parser->cursor, "end pattern with unmatched parenthesis");
    return false;
}

/**
 * item : anchor
 *      | match-posix-class
 *      | match-char-set
 *      | match-char-class
 *      | match-char-prop
 *      | match-char
 *      | match-any
 *      | group
 *      | quantified
 *      ;
 */
static bool
pm_regexp_parse_item(pm_regexp_parser_t *parser, uint16_t depth) {
    switch (*parser->cursor) {
        case '^':
        case '$':
            parser->cursor++;
            return pm_regexp_parse_quantifier(parser);
        case '\\':
            parser->cursor++;
            if (!pm_regexp_char_is_eof(parser)) {
                parser->cursor++;
            }
            return pm_regexp_parse_quantifier(parser);
        case '(':
            parser->cursor++;
            return pm_regexp_parse_group(parser, depth) && pm_regexp_parse_quantifier(parser);
        case '[':
            parser->cursor++;
            return pm_regexp_parse_lbracket(parser, depth) && pm_regexp_parse_quantifier(parser);
        case '*':
        case '?':
        case '+':
            parser->cursor++;
            pm_regexp_parse_error(parser, parser->cursor - 1, parser->cursor, "target of repeat operator is not specified");
            return true;
        case ')':
            parser->cursor++;
            pm_regexp_parse_error(parser, parser->cursor - 1, parser->cursor, "unmatched close parenthesis");
            return true;
        case '#':
            if (parser->extended_mode) {
                if (!pm_regexp_char_find(parser, '\n')) parser->cursor = parser->end;
                return true;
            }
        PRISM_FALLTHROUGH
        default: {
            size_t width;
            if (!parser->encoding_changed) {
                width = pm_encoding_utf_8_char_width(parser->cursor, (ptrdiff_t) (parser->end - parser->cursor));
            } else {
                width = parser->encoding->char_width(parser->cursor, (ptrdiff_t) (parser->end - parser->cursor));
            }

            if (width == 0) return false; // TODO: add appropriate error
            parser->cursor += width;

            return pm_regexp_parse_quantifier(parser);
        }
    }
}

/**
 * expression : item+
 *            ;
 */
static bool
pm_regexp_parse_expression(pm_regexp_parser_t *parser, uint16_t depth) {
    if (depth >= PM_REGEXP_PARSE_DEPTH_MAX) {
        pm_regexp_parse_error(parser, parser->start, parser->end, "parse depth limit over");
        return false;
    }

    if (!pm_regexp_parse_item(parser, depth)) {
        return false;
    }

    while (!pm_regexp_char_is_eof(parser) && *parser->cursor != ')' && *parser->cursor != '|') {
        if (!pm_regexp_parse_item(parser, depth)) {
            return false;
        }
    }

    return true;
}

/**
 * pattern : EOF
 *         | expression EOF
 *         | expression '|' pattern
 *         ;
 */
static bool
pm_regexp_parse_pattern(pm_regexp_parser_t *parser) {
    do {
        if (pm_regexp_char_is_eof(parser)) return true;
        if (!pm_regexp_parse_expression(parser, 0)) return false;
    } while (pm_regexp_char_accept(parser, '|'));

    return pm_regexp_char_is_eof(parser);
}

/**
 * Parse a regular expression and extract the names of all of the named capture
 * groups.
 */
PRISM_EXPORTED_FUNCTION void
pm_regexp_parse(pm_parser_t *parser, const uint8_t *source, size_t size, bool extended_mode, pm_regexp_name_callback_t name_callback, void *name_data, pm_regexp_error_callback_t error_callback, void *error_data) {
    pm_regexp_parse_pattern(&(pm_regexp_parser_t) {
        .parser = parser,
        .start = source,
        .cursor = source,
        .end = source + size,
        .extended_mode = extended_mode,
        .encoding_changed = parser->encoding_changed,
        .encoding = parser->encoding,
        .name_callback = name_callback,
        .name_data = name_data,
        .error_callback = error_callback,
        .error_data = error_data
    });
}
prism-1.5.1/src/static_literals.c000066400000000000000000000602061506127434000167770ustar00rootroot00000000000000#include "prism/static_literals.h"

/**
 * A small struct used for passing around a subset of the information that is
 * stored on the parser. We use this to avoid having static literals explicitly
 * depend on the parser struct.
 */
typedef struct {
    /** The list of newline offsets to use to calculate line numbers. */
    const pm_newline_list_t *newline_list;

    /** The line number that the parser starts on. */
    int32_t start_line;

    /** The name of the encoding that the parser is using. */
    const char *encoding_name;
} pm_static_literals_metadata_t;

static inline uint32_t
murmur_scramble(uint32_t value) {
    value *= 0xcc9e2d51;
    value = (value << 15) | (value >> 17);
    value *= 0x1b873593;
    return value;
}

/**
 * Murmur hash (https://en.wikipedia.org/wiki/MurmurHash) is a non-cryptographic
 * general-purpose hash function. It is fast, which is what we care about in
 * this case.
 */
static uint32_t
murmur_hash(const uint8_t *key, size_t length) {
    uint32_t hash = 0x9747b28c;
    uint32_t segment;

    for (size_t index = length >> 2; index; index--) {
        memcpy(&segment, key, sizeof(uint32_t));
        key += sizeof(uint32_t);
        hash ^= murmur_scramble(segment);
        hash = (hash << 13) | (hash >> 19);
        hash = hash * 5 + 0xe6546b64;
    }

    segment = 0;
    for (size_t index = length & 3; index; index--) {
        segment <<= 8;
        segment |= key[index - 1];
    }

    hash ^= murmur_scramble(segment);
    hash ^= (uint32_t) length;
    hash ^= hash >> 16;
    hash *= 0x85ebca6b;
    hash ^= hash >> 13;
    hash *= 0xc2b2ae35;
    hash ^= hash >> 16;
    return hash;
}

/**
 * Hash the value of an integer and return it.
 */
static uint32_t
integer_hash(const pm_integer_t *integer) {
    uint32_t hash;
    if (integer->values) {
        hash = murmur_hash((const uint8_t *) integer->values, sizeof(uint32_t) * integer->length);
    } else {
        hash = murmur_hash((const uint8_t *) &integer->value, sizeof(uint32_t));
    }

    if (integer->negative) {
        hash ^= murmur_scramble((uint32_t) 1);
    }

    return hash;
}

/**
 * Return the hash of the given node. It is important that nodes that have
 * equivalent static literal values have the same hash. This is because we use
 * these hashes to look for duplicates.
 */
static uint32_t
node_hash(const pm_static_literals_metadata_t *metadata, const pm_node_t *node) {
    switch (PM_NODE_TYPE(node)) {
        case PM_INTEGER_NODE: {
            // Integers hash their value.
            const pm_integer_node_t *cast = (const pm_integer_node_t *) node;
            return integer_hash(&cast->value);
        }
        case PM_SOURCE_LINE_NODE: {
            // Source lines hash their line number.
            const pm_line_column_t line_column = pm_newline_list_line_column(metadata->newline_list, node->location.start, metadata->start_line);
            const int32_t *value = &line_column.line;
            return murmur_hash((const uint8_t *) value, sizeof(int32_t));
        }
        case PM_FLOAT_NODE: {
            // Floats hash their value.
            const double *value = &((const pm_float_node_t *) node)->value;
            return murmur_hash((const uint8_t *) value, sizeof(double));
        }
        case PM_RATIONAL_NODE: {
            // Rationals hash their numerator and denominator.
            const pm_rational_node_t *cast = (const pm_rational_node_t *) node;
            return integer_hash(&cast->numerator) ^ integer_hash(&cast->denominator) ^ murmur_scramble((uint32_t) cast->base.type);
        }
        case PM_IMAGINARY_NODE: {
            // Imaginaries hash their numeric value. Because their numeric value
            // is stored as a subnode, we hash that node and then mix in the
            // fact that this is an imaginary node.
            const pm_node_t *numeric = ((const pm_imaginary_node_t *) node)->numeric;
            return node_hash(metadata, numeric) ^ murmur_scramble((uint32_t) node->type);
        }
        case PM_STRING_NODE: {
            // Strings hash their value and mix in their flags so that different
            // encodings are not considered equal.
            const pm_string_t *value = &((const pm_string_node_t *) node)->unescaped;

            pm_node_flags_t flags = node->flags;
            flags &= (PM_STRING_FLAGS_FORCED_BINARY_ENCODING | PM_STRING_FLAGS_FORCED_UTF8_ENCODING);

            return murmur_hash(pm_string_source(value), pm_string_length(value) * sizeof(uint8_t)) ^ murmur_scramble((uint32_t) flags);
        }
        case PM_SOURCE_FILE_NODE: {
            // Source files hash their value and mix in their flags so that
            // different encodings are not considered equal.
            const pm_string_t *value = &((const pm_source_file_node_t *) node)->filepath;
            return murmur_hash(pm_string_source(value), pm_string_length(value) * sizeof(uint8_t));
        }
        case PM_REGULAR_EXPRESSION_NODE: {
            // Regular expressions hash their value and mix in their flags so
            // that different encodings are not considered equal.
            const pm_string_t *value = &((const pm_regular_expression_node_t *) node)->unescaped;
            return murmur_hash(pm_string_source(value), pm_string_length(value) * sizeof(uint8_t)) ^ murmur_scramble((uint32_t) node->flags);
        }
        case PM_SYMBOL_NODE: {
            // Symbols hash their value and mix in their flags so that different
            // encodings are not considered equal.
            const pm_string_t *value = &((const pm_symbol_node_t *) node)->unescaped;
            return murmur_hash(pm_string_source(value), pm_string_length(value) * sizeof(uint8_t)) ^ murmur_scramble((uint32_t) node->flags);
        }
        default:
            assert(false && "unreachable");
            return 0;
    }
}

/**
 * Insert a node into the node hash. It accepts the hash that should hold the
 * new node, the parser that generated the node, the node to insert, and a
 * comparison function. The comparison function is used for collision detection,
 * and must be able to compare all node types that will be stored in this hash.
 */
static pm_node_t *
pm_node_hash_insert(pm_node_hash_t *hash, const pm_static_literals_metadata_t *metadata, pm_node_t *node, bool replace, int (*compare)(const pm_static_literals_metadata_t *metadata, const pm_node_t *left, const pm_node_t *right)) {
    // If we are out of space, we need to resize the hash. This will cause all
    // of the nodes to be rehashed and reinserted into the new hash.
    if (hash->size * 2 >= hash->capacity) {
        // First, allocate space for the new node list.
        uint32_t new_capacity = hash->capacity == 0 ? 4 : hash->capacity * 2;
        pm_node_t **new_nodes = xcalloc(new_capacity, sizeof(pm_node_t *));
        if (new_nodes == NULL) return NULL;

        // It turns out to be more efficient to mask the hash value than to use
        // the modulo operator. Because our capacities are always powers of two,
        // we can use a bitwise AND to get the same result as the modulo
        // operator.
        uint32_t mask = new_capacity - 1;

        // Now, rehash all of the nodes into the new list.
        for (uint32_t index = 0; index < hash->capacity; index++) {
            pm_node_t *node = hash->nodes[index];

            if (node != NULL) {
                uint32_t index = node_hash(metadata, node) & mask;
                new_nodes[index] = node;
            }
        }

        // Finally, free the old node list and update the hash.
        xfree(hash->nodes);
        hash->nodes = new_nodes;
        hash->capacity = new_capacity;
    }

    // Now, insert the node into the hash.
    uint32_t mask = hash->capacity - 1;
    uint32_t index = node_hash(metadata, node) & mask;

    // We use linear probing to resolve collisions. This means that if the
    // current index is occupied, we will move to the next index and try again.
    // We are guaranteed that this will eventually find an empty slot because we
    // resize the hash when it gets too full.
    while (hash->nodes[index] != NULL) {
        if (compare(metadata, hash->nodes[index], node) == 0) break;
        index = (index + 1) & mask;
    }

    // If the current index is occupied, we need to return the node that was
    // already in the hash. Otherwise, we can just increment the size and insert
    // the new node.
    pm_node_t *result = hash->nodes[index];

    if (result == NULL) {
        hash->size++;
        hash->nodes[index] = node;
    } else if (replace) {
        hash->nodes[index] = node;
    }

    return result;
}

/**
 * Free the internal memory associated with the given node hash.
 */
static void
pm_node_hash_free(pm_node_hash_t *hash) {
    if (hash->capacity > 0) xfree(hash->nodes);
}

/**
 * Compare two values that can be compared with a simple numeric comparison.
 */
#define PM_NUMERIC_COMPARISON(left, right) ((left < right) ? -1 : (left > right) ? 1 : 0)

/**
 * Return the integer value of the given node as an int64_t.
 */
static int64_t
pm_int64_value(const pm_static_literals_metadata_t *metadata, const pm_node_t *node) {
    switch (PM_NODE_TYPE(node)) {
        case PM_INTEGER_NODE: {
            const pm_integer_t *integer = &((const pm_integer_node_t *) node)->value;
            if (integer->values) return integer->negative ? INT64_MIN : INT64_MAX;

            int64_t value = (int64_t) integer->value;
            return integer->negative ? -value : value;
        }
        case PM_SOURCE_LINE_NODE:
            return (int64_t) pm_newline_list_line_column(metadata->newline_list, node->location.start, metadata->start_line).line;
        default:
            assert(false && "unreachable");
            return 0;
    }
}

/**
 * A comparison function for comparing two IntegerNode or SourceLineNode
 * instances.
 */
static int
pm_compare_integer_nodes(const pm_static_literals_metadata_t *metadata, const pm_node_t *left, const pm_node_t *right) {
    if (PM_NODE_TYPE_P(left, PM_SOURCE_LINE_NODE) || PM_NODE_TYPE_P(right, PM_SOURCE_LINE_NODE)) {
        int64_t left_value = pm_int64_value(metadata, left);
        int64_t right_value = pm_int64_value(metadata, right);
        return PM_NUMERIC_COMPARISON(left_value, right_value);
    }

    const pm_integer_t *left_integer = &((const pm_integer_node_t *) left)->value;
    const pm_integer_t *right_integer = &((const pm_integer_node_t *) right)->value;
    return pm_integer_compare(left_integer, right_integer);
}

/**
 * A comparison function for comparing two FloatNode instances.
 */
static int
pm_compare_float_nodes(PRISM_ATTRIBUTE_UNUSED const pm_static_literals_metadata_t *metadata, const pm_node_t *left, const pm_node_t *right) {
    const double left_value = ((const pm_float_node_t *) left)->value;
    const double right_value = ((const pm_float_node_t *) right)->value;
    return PM_NUMERIC_COMPARISON(left_value, right_value);
}

/**
 * A comparison function for comparing two nodes that have attached numbers.
 */
static int
pm_compare_number_nodes(const pm_static_literals_metadata_t *metadata, const pm_node_t *left, const pm_node_t *right) {
    if (PM_NODE_TYPE(left) != PM_NODE_TYPE(right)) {
        return PM_NUMERIC_COMPARISON(PM_NODE_TYPE(left), PM_NODE_TYPE(right));
    }

    switch (PM_NODE_TYPE(left)) {
        case PM_IMAGINARY_NODE:
            return pm_compare_number_nodes(metadata, ((const pm_imaginary_node_t *) left)->numeric, ((const pm_imaginary_node_t *) right)->numeric);
        case PM_RATIONAL_NODE: {
            const pm_rational_node_t *left_rational = (const pm_rational_node_t *) left;
            const pm_rational_node_t *right_rational = (const pm_rational_node_t *) right;

            int result = pm_integer_compare(&left_rational->denominator, &right_rational->denominator);
            if (result != 0) return result;

            return pm_integer_compare(&left_rational->numerator, &right_rational->numerator);
        }
        case PM_INTEGER_NODE:
            return pm_compare_integer_nodes(metadata, left, right);
        case PM_FLOAT_NODE:
            return pm_compare_float_nodes(metadata, left, right);
        default:
            assert(false && "unreachable");
            return 0;
    }
}

/**
 * Return a pointer to the string value of the given node.
 */
static const pm_string_t *
pm_string_value(const pm_node_t *node) {
    switch (PM_NODE_TYPE(node)) {
        case PM_STRING_NODE:
            return &((const pm_string_node_t *) node)->unescaped;
        case PM_SOURCE_FILE_NODE:
            return &((const pm_source_file_node_t *) node)->filepath;
        case PM_SYMBOL_NODE:
            return &((const pm_symbol_node_t *) node)->unescaped;
        default:
            assert(false && "unreachable");
            return NULL;
    }
}

/**
 * A comparison function for comparing two nodes that have attached strings.
 */
static int
pm_compare_string_nodes(PRISM_ATTRIBUTE_UNUSED const pm_static_literals_metadata_t *metadata, const pm_node_t *left, const pm_node_t *right) {
    const pm_string_t *left_string = pm_string_value(left);
    const pm_string_t *right_string = pm_string_value(right);
    return pm_string_compare(left_string, right_string);
}

/**
 * A comparison function for comparing two RegularExpressionNode instances.
 */
static int
pm_compare_regular_expression_nodes(PRISM_ATTRIBUTE_UNUSED const pm_static_literals_metadata_t *metadata, const pm_node_t *left, const pm_node_t *right) {
    const pm_regular_expression_node_t *left_regexp = (const pm_regular_expression_node_t *) left;
    const pm_regular_expression_node_t *right_regexp = (const pm_regular_expression_node_t *) right;

    int result = pm_string_compare(&left_regexp->unescaped, &right_regexp->unescaped);
    if (result != 0) return result;

    return PM_NUMERIC_COMPARISON(left_regexp->base.flags, right_regexp->base.flags);
}

#undef PM_NUMERIC_COMPARISON

/**
 * Add a node to the set of static literals.
 */
pm_node_t *
pm_static_literals_add(const pm_newline_list_t *newline_list, int32_t start_line, pm_static_literals_t *literals, pm_node_t *node, bool replace) {
    switch (PM_NODE_TYPE(node)) {
        case PM_INTEGER_NODE:
        case PM_SOURCE_LINE_NODE:
            return pm_node_hash_insert(
                &literals->integer_nodes,
                &(pm_static_literals_metadata_t) {
                    .newline_list = newline_list,
                    .start_line = start_line,
                    .encoding_name = NULL
                },
                node,
                replace,
                pm_compare_integer_nodes
            );
        case PM_FLOAT_NODE:
            return pm_node_hash_insert(
                &literals->float_nodes,
                &(pm_static_literals_metadata_t) {
                    .newline_list = newline_list,
                    .start_line = start_line,
                    .encoding_name = NULL
                },
                node,
                replace,
                pm_compare_float_nodes
            );
        case PM_RATIONAL_NODE:
        case PM_IMAGINARY_NODE:
            return pm_node_hash_insert(
                &literals->number_nodes,
                &(pm_static_literals_metadata_t) {
                    .newline_list = newline_list,
                    .start_line = start_line,
                    .encoding_name = NULL
                },
                node,
                replace,
                pm_compare_number_nodes
            );
        case PM_STRING_NODE:
        case PM_SOURCE_FILE_NODE:
            return pm_node_hash_insert(
                &literals->string_nodes,
                &(pm_static_literals_metadata_t) {
                    .newline_list = newline_list,
                    .start_line = start_line,
                    .encoding_name = NULL
                },
                node,
                replace,
                pm_compare_string_nodes
            );
        case PM_REGULAR_EXPRESSION_NODE:
            return pm_node_hash_insert(
                &literals->regexp_nodes,
                &(pm_static_literals_metadata_t) {
                    .newline_list = newline_list,
                    .start_line = start_line,
                    .encoding_name = NULL
                },
                node,
                replace,
                pm_compare_regular_expression_nodes
            );
        case PM_SYMBOL_NODE:
            return pm_node_hash_insert(
                &literals->symbol_nodes,
                &(pm_static_literals_metadata_t) {
                    .newline_list = newline_list,
                    .start_line = start_line,
                    .encoding_name = NULL
                },
                node,
                replace,
                pm_compare_string_nodes
            );
        case PM_TRUE_NODE: {
            pm_node_t *duplicated = literals->true_node;
            if ((duplicated == NULL) || replace) literals->true_node = node;
            return duplicated;
        }
        case PM_FALSE_NODE: {
            pm_node_t *duplicated = literals->false_node;
            if ((duplicated == NULL) || replace) literals->false_node = node;
            return duplicated;
        }
        case PM_NIL_NODE: {
            pm_node_t *duplicated = literals->nil_node;
            if ((duplicated == NULL) || replace) literals->nil_node = node;
            return duplicated;
        }
        case PM_SOURCE_ENCODING_NODE: {
            pm_node_t *duplicated = literals->source_encoding_node;
            if ((duplicated == NULL) || replace) literals->source_encoding_node = node;
            return duplicated;
        }
        default:
            return NULL;
    }
}

/**
 * Free the internal memory associated with the given static literals set.
 */
void
pm_static_literals_free(pm_static_literals_t *literals) {
    pm_node_hash_free(&literals->integer_nodes);
    pm_node_hash_free(&literals->float_nodes);
    pm_node_hash_free(&literals->number_nodes);
    pm_node_hash_free(&literals->string_nodes);
    pm_node_hash_free(&literals->regexp_nodes);
    pm_node_hash_free(&literals->symbol_nodes);
}

/**
 * A helper to determine if the given node is a static literal that is positive.
 * This is used for formatting imaginary nodes.
 */
static bool
pm_static_literal_positive_p(const pm_node_t *node) {
    switch (PM_NODE_TYPE(node)) {
        case PM_FLOAT_NODE:
            return ((const pm_float_node_t *) node)->value > 0;
        case PM_INTEGER_NODE:
            return !((const pm_integer_node_t *) node)->value.negative;
        case PM_RATIONAL_NODE:
            return !((const pm_rational_node_t *) node)->numerator.negative;
        case PM_IMAGINARY_NODE:
            return pm_static_literal_positive_p(((const pm_imaginary_node_t *) node)->numeric);
        default:
            assert(false && "unreachable");
            return false;
    }
}

/**
 * Create a string-based representation of the given static literal.
 */
static inline void
pm_static_literal_inspect_node(pm_buffer_t *buffer, const pm_static_literals_metadata_t *metadata, const pm_node_t *node) {
    switch (PM_NODE_TYPE(node)) {
        case PM_FALSE_NODE:
            pm_buffer_append_string(buffer, "false", 5);
            break;
        case PM_FLOAT_NODE: {
            const double value = ((const pm_float_node_t *) node)->value;

            if (PRISM_ISINF(value)) {
                if (*node->location.start == '-') {
                    pm_buffer_append_byte(buffer, '-');
                }
                pm_buffer_append_string(buffer, "Infinity", 8);
            } else if (value == 0.0) {
                if (*node->location.start == '-') {
                    pm_buffer_append_byte(buffer, '-');
                }
                pm_buffer_append_string(buffer, "0.0", 3);
            } else {
                pm_buffer_append_format(buffer, "%g", value);

                // %g will not insert a .0 for 1e100 (we'll get back 1e+100). So
                // we check for the decimal point and add it in here if it's not
                // present.
                if (pm_buffer_index(buffer, '.') == SIZE_MAX) {
                    size_t exponent_index = pm_buffer_index(buffer, 'e');
                    size_t index = exponent_index == SIZE_MAX ? pm_buffer_length(buffer) : exponent_index;
                    pm_buffer_insert(buffer, index, ".0", 2);
                }
            }

            break;
        }
        case PM_IMAGINARY_NODE: {
            const pm_node_t *numeric = ((const pm_imaginary_node_t *) node)->numeric;
            pm_buffer_append_string(buffer, "(0", 2);
            if (pm_static_literal_positive_p(numeric)) pm_buffer_append_byte(buffer, '+');
            pm_static_literal_inspect_node(buffer, metadata, numeric);
            if (PM_NODE_TYPE_P(numeric, PM_RATIONAL_NODE)) {
                pm_buffer_append_byte(buffer, '*');
            }
            pm_buffer_append_string(buffer, "i)", 2);
            break;
        }
        case PM_INTEGER_NODE:
            pm_integer_string(buffer, &((const pm_integer_node_t *) node)->value);
            break;
        case PM_NIL_NODE:
            pm_buffer_append_string(buffer, "nil", 3);
            break;
        case PM_RATIONAL_NODE: {
            const pm_rational_node_t *rational = (const pm_rational_node_t *) node;
            pm_buffer_append_byte(buffer, '(');
            pm_integer_string(buffer, &rational->numerator);
            pm_buffer_append_byte(buffer, '/');
            pm_integer_string(buffer, &rational->denominator);
            pm_buffer_append_byte(buffer, ')');
            break;
        }
        case PM_REGULAR_EXPRESSION_NODE: {
            const pm_string_t *unescaped = &((const pm_regular_expression_node_t *) node)->unescaped;
            pm_buffer_append_byte(buffer, '/');
            pm_buffer_append_source(buffer, pm_string_source(unescaped), pm_string_length(unescaped), PM_BUFFER_ESCAPING_RUBY);
            pm_buffer_append_byte(buffer, '/');

            if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) pm_buffer_append_string(buffer, "m", 1);
            if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) pm_buffer_append_string(buffer, "i", 1);
            if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) pm_buffer_append_string(buffer, "x", 1);
            if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) pm_buffer_append_string(buffer, "n", 1);

            break;
        }
        case PM_SOURCE_ENCODING_NODE:
            pm_buffer_append_format(buffer, "#", metadata->encoding_name);
            break;
        case PM_SOURCE_FILE_NODE: {
            const pm_string_t *filepath = &((const pm_source_file_node_t *) node)->filepath;
            pm_buffer_append_byte(buffer, '"');
            pm_buffer_append_source(buffer, pm_string_source(filepath), pm_string_length(filepath), PM_BUFFER_ESCAPING_RUBY);
            pm_buffer_append_byte(buffer, '"');
            break;
        }
        case PM_SOURCE_LINE_NODE:
            pm_buffer_append_format(buffer, "%d", pm_newline_list_line_column(metadata->newline_list, node->location.start, metadata->start_line).line);
            break;
        case PM_STRING_NODE: {
            const pm_string_t *unescaped = &((const pm_string_node_t *) node)->unescaped;
            pm_buffer_append_byte(buffer, '"');
            pm_buffer_append_source(buffer, pm_string_source(unescaped), pm_string_length(unescaped), PM_BUFFER_ESCAPING_RUBY);
            pm_buffer_append_byte(buffer, '"');
            break;
        }
        case PM_SYMBOL_NODE: {
            const pm_string_t *unescaped = &((const pm_symbol_node_t *) node)->unescaped;
            pm_buffer_append_byte(buffer, ':');
            pm_buffer_append_source(buffer, pm_string_source(unescaped), pm_string_length(unescaped), PM_BUFFER_ESCAPING_RUBY);
            break;
        }
        case PM_TRUE_NODE:
            pm_buffer_append_string(buffer, "true", 4);
            break;
        default:
            assert(false && "unreachable");
            break;
    }
}

/**
 * Create a string-based representation of the given static literal.
 */
void
pm_static_literal_inspect(pm_buffer_t *buffer, const pm_newline_list_t *newline_list, int32_t start_line, const char *encoding_name, const pm_node_t *node) {
    pm_static_literal_inspect_node(
        buffer,
        &(pm_static_literals_metadata_t) {
            .newline_list = newline_list,
            .start_line = start_line,
            .encoding_name = encoding_name
        },
        node
    );
}
prism-1.5.1/src/util/000077500000000000000000000000001506127434000144165ustar00rootroot00000000000000prism-1.5.1/src/util/pm_buffer.c000066400000000000000000000235701506127434000165360ustar00rootroot00000000000000#include "prism/util/pm_buffer.h"

/**
 * Return the size of the pm_buffer_t struct.
 */
size_t
pm_buffer_sizeof(void) {
    return sizeof(pm_buffer_t);
}

/**
 * Initialize a pm_buffer_t with the given capacity.
 */
bool
pm_buffer_init_capacity(pm_buffer_t *buffer, size_t capacity) {
    buffer->length = 0;
    buffer->capacity = capacity;

    buffer->value = (char *) xmalloc(capacity);
    return buffer->value != NULL;
}

/**
 * Initialize a pm_buffer_t with its default values.
 */
bool
pm_buffer_init(pm_buffer_t *buffer) {
    return pm_buffer_init_capacity(buffer, 1024);
}

/**
 * Return the value of the buffer.
 */
char *
pm_buffer_value(const pm_buffer_t *buffer) {
    return buffer->value;
}

/**
 * Return the length of the buffer.
 */
size_t
pm_buffer_length(const pm_buffer_t *buffer) {
    return buffer->length;
}

/**
 * Append the given amount of space to the buffer.
 */
static inline bool
pm_buffer_append_length(pm_buffer_t *buffer, size_t length) {
    size_t next_length = buffer->length + length;

    if (next_length > buffer->capacity) {
        if (buffer->capacity == 0) {
            buffer->capacity = 1;
        }

        while (next_length > buffer->capacity) {
            buffer->capacity *= 2;
        }

        buffer->value = xrealloc(buffer->value, buffer->capacity);
        if (buffer->value == NULL) return false;
    }

    buffer->length = next_length;
    return true;
}

/**
 * Append a generic pointer to memory to the buffer.
 */
static inline void
pm_buffer_append(pm_buffer_t *buffer, const void *source, size_t length) {
    size_t cursor = buffer->length;
    if (pm_buffer_append_length(buffer, length)) {
        memcpy(buffer->value + cursor, source, length);
    }
}

/**
 * Append the given amount of space as zeroes to the buffer.
 */
void
pm_buffer_append_zeroes(pm_buffer_t *buffer, size_t length) {
    size_t cursor = buffer->length;
    if (pm_buffer_append_length(buffer, length)) {
        memset(buffer->value + cursor, 0, length);
    }
}

/**
 * Append a formatted string to the buffer.
 */
void
pm_buffer_append_format(pm_buffer_t *buffer, const char *format, ...) {
    va_list arguments;
    va_start(arguments, format);
    int result = vsnprintf(NULL, 0, format, arguments);
    va_end(arguments);

    if (result < 0) return;
    size_t length = (size_t) (result + 1);

    size_t cursor = buffer->length;
    if (pm_buffer_append_length(buffer, length)) {
        va_start(arguments, format);
        vsnprintf(buffer->value + cursor, length, format, arguments);
        va_end(arguments);
        buffer->length--;
    }
}

/**
 * Append a string to the buffer.
 */
void
pm_buffer_append_string(pm_buffer_t *buffer, const char *value, size_t length) {
    pm_buffer_append(buffer, value, length);
}

/**
 * Append a list of bytes to the buffer.
 */
void
pm_buffer_append_bytes(pm_buffer_t *buffer, const uint8_t *value, size_t length) {
    pm_buffer_append(buffer, (const char *) value, length);
}

/**
 * Append a single byte to the buffer.
 */
void
pm_buffer_append_byte(pm_buffer_t *buffer, uint8_t value) {
    const void *source = &value;
    pm_buffer_append(buffer, source, sizeof(uint8_t));
}

/**
 * Append a 32-bit unsigned integer to the buffer as a variable-length integer.
 */
void
pm_buffer_append_varuint(pm_buffer_t *buffer, uint32_t value) {
    if (value < 128) {
        pm_buffer_append_byte(buffer, (uint8_t) value);
    } else {
        uint32_t n = value;
        while (n >= 128) {
            pm_buffer_append_byte(buffer, (uint8_t) (n | 128));
            n >>= 7;
        }
        pm_buffer_append_byte(buffer, (uint8_t) n);
    }
}

/**
 * Append a 32-bit signed integer to the buffer as a variable-length integer.
 */
void
pm_buffer_append_varsint(pm_buffer_t *buffer, int32_t value) {
    uint32_t unsigned_int = ((uint32_t)(value) << 1) ^ ((uint32_t)(value >> 31));
    pm_buffer_append_varuint(buffer, unsigned_int);
}

/**
 * Append a double to the buffer.
 */
void
pm_buffer_append_double(pm_buffer_t *buffer, double value) {
    const void *source = &value;
    pm_buffer_append(buffer, source, sizeof(double));
}

/**
 * Append a unicode codepoint to the buffer.
 */
bool
pm_buffer_append_unicode_codepoint(pm_buffer_t *buffer, uint32_t value) {
    if (value <= 0x7F) {
        pm_buffer_append_byte(buffer, (uint8_t) value); // 0xxxxxxx
        return true;
    } else if (value <= 0x7FF) {
        uint8_t bytes[] = {
            (uint8_t) (0xC0 | ((value >> 6) & 0x3F)), // 110xxxxx
            (uint8_t) (0x80 | (value & 0x3F))         // 10xxxxxx
        };

        pm_buffer_append_bytes(buffer, bytes, 2);
        return true;
    } else if (value <= 0xFFFF) {
        uint8_t bytes[] = {
            (uint8_t) (0xE0 | ((value >> 12) & 0x3F)), // 1110xxxx
            (uint8_t) (0x80 | ((value >> 6) & 0x3F)),  // 10xxxxxx
            (uint8_t) (0x80 | (value & 0x3F))          // 10xxxxxx
        };

        pm_buffer_append_bytes(buffer, bytes, 3);
        return true;
    } else if (value <= 0x10FFFF) {
        uint8_t bytes[] = {
            (uint8_t) (0xF0 | ((value >> 18) & 0x3F)), // 11110xxx
            (uint8_t) (0x80 | ((value >> 12) & 0x3F)), // 10xxxxxx
            (uint8_t) (0x80 | ((value >> 6) & 0x3F)),  // 10xxxxxx
            (uint8_t) (0x80 | (value & 0x3F))          // 10xxxxxx
        };

        pm_buffer_append_bytes(buffer, bytes, 4);
        return true;
    } else {
        return false;
    }
}

/**
 * Append a slice of source code to the buffer.
 */
void
pm_buffer_append_source(pm_buffer_t *buffer, const uint8_t *source, size_t length, pm_buffer_escaping_t escaping) {
    for (size_t index = 0; index < length; index++) {
        const uint8_t byte = source[index];

        if ((byte <= 0x06) || (byte >= 0x0E && byte <= 0x1F) || (byte >= 0x7F)) {
            if (escaping == PM_BUFFER_ESCAPING_RUBY) {
                pm_buffer_append_format(buffer, "\\x%02X", byte);
            } else {
                pm_buffer_append_format(buffer, "\\u%04X", byte);
            }
        } else {
            switch (byte) {
                case '\a':
                    if (escaping == PM_BUFFER_ESCAPING_RUBY) {
                        pm_buffer_append_string(buffer, "\\a", 2);
                    } else {
                        pm_buffer_append_format(buffer, "\\u%04X", byte);
                    }
                    break;
                case '\b':
                    pm_buffer_append_string(buffer, "\\b", 2);
                    break;
                case '\t':
                    pm_buffer_append_string(buffer, "\\t", 2);
                    break;
                case '\n':
                    pm_buffer_append_string(buffer, "\\n", 2);
                    break;
                case '\v':
                    if (escaping == PM_BUFFER_ESCAPING_RUBY) {
                        pm_buffer_append_string(buffer, "\\v", 2);
                    } else {
                        pm_buffer_append_format(buffer, "\\u%04X", byte);
                    }
                    break;
                case '\f':
                    pm_buffer_append_string(buffer, "\\f", 2);
                    break;
                case '\r':
                    pm_buffer_append_string(buffer, "\\r", 2);
                    break;
                case '"':
                    pm_buffer_append_string(buffer, "\\\"", 2);
                    break;
                case '#': {
                    if (escaping == PM_BUFFER_ESCAPING_RUBY && index + 1 < length) {
                        const uint8_t next_byte = source[index + 1];
                        if (next_byte == '{' || next_byte == '@' || next_byte == '$') {
                            pm_buffer_append_byte(buffer, '\\');
                        }
                    }

                    pm_buffer_append_byte(buffer, '#');
                    break;
                }
                case '\\':
                    pm_buffer_append_string(buffer, "\\\\", 2);
                    break;
                default:
                    pm_buffer_append_byte(buffer, byte);
                    break;
            }
        }
    }
}

/**
 * Prepend the given string to the buffer.
 */
void
pm_buffer_prepend_string(pm_buffer_t *buffer, const char *value, size_t length) {
    size_t cursor = buffer->length;
    if (pm_buffer_append_length(buffer, length)) {
        memmove(buffer->value + length, buffer->value, cursor);
        memcpy(buffer->value, value, length);
    }
}

/**
 * Concatenate one buffer onto another.
 */
void
pm_buffer_concat(pm_buffer_t *destination, const pm_buffer_t *source) {
    if (source->length > 0) {
        pm_buffer_append(destination, source->value, source->length);
    }
}

/**
 * Clear the buffer by reducing its size to 0. This does not free the allocated
 * memory, but it does allow the buffer to be reused.
 */
void
pm_buffer_clear(pm_buffer_t *buffer) {
    buffer->length = 0;
}

/**
 * Strip the whitespace from the end of the buffer.
 */
void
pm_buffer_rstrip(pm_buffer_t *buffer) {
    while (buffer->length > 0 && pm_char_is_whitespace((uint8_t) buffer->value[buffer->length - 1])) {
        buffer->length--;
    }
}

/**
 * Checks if the buffer includes the given value.
 */
size_t
pm_buffer_index(const pm_buffer_t *buffer, char value) {
    const char *first = memchr(buffer->value, value, buffer->length);
    return (first == NULL) ? SIZE_MAX : (size_t) (first - buffer->value);
}

/**
 * Insert the given string into the buffer at the given index.
 */
void
pm_buffer_insert(pm_buffer_t *buffer, size_t index, const char *value, size_t length) {
    assert(index <= buffer->length);

    if (index == buffer->length) {
        pm_buffer_append_string(buffer, value, length);
    } else {
        pm_buffer_append_zeroes(buffer, length);
        memmove(buffer->value + index + length, buffer->value + index, buffer->length - length - index);
        memcpy(buffer->value + index, value, length);
    }
}

/**
 * Free the memory associated with the buffer.
 */
void
pm_buffer_free(pm_buffer_t *buffer) {
    xfree(buffer->value);
}
prism-1.5.1/src/util/pm_char.c000066400000000000000000000271531506127434000162030ustar00rootroot00000000000000#include "prism/util/pm_char.h"

#define PRISM_CHAR_BIT_WHITESPACE (1 << 0)
#define PRISM_CHAR_BIT_INLINE_WHITESPACE (1 << 1)
#define PRISM_CHAR_BIT_REGEXP_OPTION (1 << 2)

#define PRISM_NUMBER_BIT_BINARY_DIGIT (1 << 0)
#define PRISM_NUMBER_BIT_BINARY_NUMBER (1 << 1)
#define PRISM_NUMBER_BIT_OCTAL_DIGIT (1 << 2)
#define PRISM_NUMBER_BIT_OCTAL_NUMBER (1 << 3)
#define PRISM_NUMBER_BIT_DECIMAL_DIGIT (1 << 4)
#define PRISM_NUMBER_BIT_DECIMAL_NUMBER (1 << 5)
#define PRISM_NUMBER_BIT_HEXADECIMAL_DIGIT (1 << 6)
#define PRISM_NUMBER_BIT_HEXADECIMAL_NUMBER (1 << 7)

static const uint8_t pm_byte_table[256] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 3, 3, 3, 0, 0, // 0x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
    3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 3x
    0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, // 4x
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, // 5x
    0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, // 6x
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, // 7x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
};

static const uint8_t pm_number_table[256] = {
    // 0     1     2     3     4     5     6     7     8     9     A     B     C     D     E     F
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 1x
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2x
    0xff, 0xff, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 3x
    0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 4x
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa, // 5x
    0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 6x
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 7x
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 8x
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 9x
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Ax
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Bx
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Cx
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Dx
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Ex
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Fx
};

/**
 * Returns the number of characters at the start of the string that match the
 * given kind. Disallows searching past the given maximum number of characters.
 */
static inline size_t
pm_strspn_char_kind(const uint8_t *string, ptrdiff_t length, uint8_t kind) {
    if (length <= 0) return 0;

    size_t size = 0;
    size_t maximum = (size_t) length;

    while (size < maximum && (pm_byte_table[string[size]] & kind)) size++;
    return size;
}

/**
 * Returns the number of characters at the start of the string that are
 * whitespace. Disallows searching past the given maximum number of characters.
 */
size_t
pm_strspn_whitespace(const uint8_t *string, ptrdiff_t length) {
    return pm_strspn_char_kind(string, length, PRISM_CHAR_BIT_WHITESPACE);
}

/**
 * Returns the number of characters at the start of the string that are
 * whitespace while also tracking the location of each newline. Disallows
 * searching past the given maximum number of characters.
 */
size_t
pm_strspn_whitespace_newlines(const uint8_t *string, ptrdiff_t length, pm_newline_list_t *newline_list) {
    if (length <= 0) return 0;

    size_t size = 0;
    size_t maximum = (size_t) length;

    while (size < maximum && (pm_byte_table[string[size]] & PRISM_CHAR_BIT_WHITESPACE)) {
        if (string[size] == '\n') {
            pm_newline_list_append(newline_list, string + size);
        }

        size++;
    }

    return size;
}

/**
 * Returns the number of characters at the start of the string that are inline
 * whitespace. Disallows searching past the given maximum number of characters.
 */
size_t
pm_strspn_inline_whitespace(const uint8_t *string, ptrdiff_t length) {
    return pm_strspn_char_kind(string, length, PRISM_CHAR_BIT_INLINE_WHITESPACE);
}

/**
 * Returns the number of characters at the start of the string that are regexp
 * options. Disallows searching past the given maximum number of characters.
 */
size_t
pm_strspn_regexp_option(const uint8_t *string, ptrdiff_t length) {
    return pm_strspn_char_kind(string, length, PRISM_CHAR_BIT_REGEXP_OPTION);
}

/**
 * Returns true if the given character matches the given kind.
 */
static inline bool
pm_char_is_char_kind(const uint8_t b, uint8_t kind) {
    return (pm_byte_table[b] & kind) != 0;
}

/**
 * Returns true if the given character is a whitespace character.
 */
bool
pm_char_is_whitespace(const uint8_t b) {
    return pm_char_is_char_kind(b, PRISM_CHAR_BIT_WHITESPACE);
}

/**
 * Returns true if the given character is an inline whitespace character.
 */
bool
pm_char_is_inline_whitespace(const uint8_t b) {
    return pm_char_is_char_kind(b, PRISM_CHAR_BIT_INLINE_WHITESPACE);
}

/**
 * Scan through the string and return the number of characters at the start of
 * the string that match the given kind. Disallows searching past the given
 * maximum number of characters.
 */
static inline size_t
pm_strspn_number_kind(const uint8_t *string, ptrdiff_t length, uint8_t kind) {
    if (length <= 0) return 0;

    size_t size = 0;
    size_t maximum = (size_t) length;

    while (size < maximum && (pm_number_table[string[size]] & kind)) size++;
    return size;
}

/**
 * Scan through the string and return the number of characters at the start of
 * the string that match the given kind. Disallows searching past the given
 * maximum number of characters.
 *
 * Additionally, report the location of the last invalid underscore character
 * found in the string through the out invalid parameter.
 */
static inline size_t
pm_strspn_number_kind_underscores(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid, uint8_t kind) {
    if (length <= 0) return 0;

    size_t size = 0;
    size_t maximum = (size_t) length;

    bool underscore = false;
    while (size < maximum && (pm_number_table[string[size]] & kind)) {
        if (string[size] == '_') {
            if (underscore) *invalid = string + size;
            underscore = true;
        } else {
            underscore = false;
        }

        size++;
    }

    if (size > 0 && string[size - 1] == '_') *invalid = string + size - 1;
    return size;
}

/**
 * Returns the number of characters at the start of the string that are binary
 * digits or underscores. Disallows searching past the given maximum number of
 * characters.
 *
 * If multiple underscores are found in a row or if an underscore is
 * found at the end of the number, then the invalid pointer is set to the index
 * of the first invalid underscore.
 */
size_t
pm_strspn_binary_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
    return pm_strspn_number_kind_underscores(string, length, invalid, PRISM_NUMBER_BIT_BINARY_NUMBER);
}

/**
 * Returns the number of characters at the start of the string that are octal
 * digits or underscores. Disallows searching past the given maximum number of
 * characters.
 *
 * If multiple underscores are found in a row or if an underscore is
 * found at the end of the number, then the invalid pointer is set to the index
 * of the first invalid underscore.
 */
size_t
pm_strspn_octal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
    return pm_strspn_number_kind_underscores(string, length, invalid, PRISM_NUMBER_BIT_OCTAL_NUMBER);
}

/**
 * Returns the number of characters at the start of the string that are decimal
 * digits. Disallows searching past the given maximum number of characters.
 */
size_t
pm_strspn_decimal_digit(const uint8_t *string, ptrdiff_t length) {
    return pm_strspn_number_kind(string, length, PRISM_NUMBER_BIT_DECIMAL_DIGIT);
}

/**
 * Returns the number of characters at the start of the string that are decimal
 * digits or underscores. Disallows searching past the given maximum number of
 * characters.
 *
 * If multiple underscores are found in a row or if an underscore is
 * found at the end of the number, then the invalid pointer is set to the index
 * of the first invalid underscore
 */
size_t
pm_strspn_decimal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
    return pm_strspn_number_kind_underscores(string, length, invalid, PRISM_NUMBER_BIT_DECIMAL_NUMBER);
}

/**
 * Returns the number of characters at the start of the string that are
 * hexadecimal digits. Disallows searching past the given maximum number of
 * characters.
 */
size_t
pm_strspn_hexadecimal_digit(const uint8_t *string, ptrdiff_t length) {
    return pm_strspn_number_kind(string, length, PRISM_NUMBER_BIT_HEXADECIMAL_DIGIT);
}

/**
 * Returns the number of characters at the start of the string that are
 * hexadecimal digits or underscores. Disallows searching past the given maximum
 * number of characters.
 *
 * If multiple underscores are found in a row or if an underscore is
 * found at the end of the number, then the invalid pointer is set to the index
 * of the first invalid underscore.
 */
size_t
pm_strspn_hexadecimal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
    return pm_strspn_number_kind_underscores(string, length, invalid, PRISM_NUMBER_BIT_HEXADECIMAL_NUMBER);
}

/**
 * Returns true if the given character matches the given kind.
 */
static inline bool
pm_char_is_number_kind(const uint8_t b, uint8_t kind) {
    return (pm_number_table[b] & kind) != 0;
}

/**
 * Returns true if the given character is a binary digit.
 */
bool
pm_char_is_binary_digit(const uint8_t b) {
    return pm_char_is_number_kind(b, PRISM_NUMBER_BIT_BINARY_DIGIT);
}

/**
 * Returns true if the given character is an octal digit.
 */
bool
pm_char_is_octal_digit(const uint8_t b) {
    return pm_char_is_number_kind(b, PRISM_NUMBER_BIT_OCTAL_DIGIT);
}

/**
 * Returns true if the given character is a decimal digit.
 */
bool
pm_char_is_decimal_digit(const uint8_t b) {
    return pm_char_is_number_kind(b, PRISM_NUMBER_BIT_DECIMAL_DIGIT);
}

/**
 * Returns true if the given character is a hexadecimal digit.
 */
bool
pm_char_is_hexadecimal_digit(const uint8_t b) {
    return pm_char_is_number_kind(b, PRISM_NUMBER_BIT_HEXADECIMAL_DIGIT);
}

#undef PRISM_CHAR_BIT_WHITESPACE
#undef PRISM_CHAR_BIT_INLINE_WHITESPACE
#undef PRISM_CHAR_BIT_REGEXP_OPTION

#undef PRISM_NUMBER_BIT_BINARY_DIGIT
#undef PRISM_NUMBER_BIT_BINARY_NUMBER
#undef PRISM_NUMBER_BIT_OCTAL_DIGIT
#undef PRISM_NUMBER_BIT_OCTAL_NUMBER
#undef PRISM_NUMBER_BIT_DECIMAL_DIGIT
#undef PRISM_NUMBER_BIT_DECIMAL_NUMBER
#undef PRISM_NUMBER_BIT_HEXADECIMAL_NUMBER
#undef PRISM_NUMBER_BIT_HEXADECIMAL_DIGIT
prism-1.5.1/src/util/pm_constant_pool.c000066400000000000000000000262471506127434000201530ustar00rootroot00000000000000#include "prism/util/pm_constant_pool.h"

/**
 * Initialize a list of constant ids.
 */
void
pm_constant_id_list_init(pm_constant_id_list_t *list) {
    list->ids = NULL;
    list->size = 0;
    list->capacity = 0;
}

/**
 * Initialize a list of constant ids with a given capacity.
 */
void
pm_constant_id_list_init_capacity(pm_constant_id_list_t *list, size_t capacity) {
    if (capacity) {
        list->ids = xcalloc(capacity, sizeof(pm_constant_id_t));
        if (list->ids == NULL) abort();
    } else {
        list->ids = NULL;
    }

    list->size = 0;
    list->capacity = capacity;
}

/**
 * Append a constant id to a list of constant ids. Returns false if any
 * potential reallocations fail.
 */
bool
pm_constant_id_list_append(pm_constant_id_list_t *list, pm_constant_id_t id) {
    if (list->size >= list->capacity) {
        list->capacity = list->capacity == 0 ? 8 : list->capacity * 2;
        list->ids = (pm_constant_id_t *) xrealloc(list->ids, sizeof(pm_constant_id_t) * list->capacity);
        if (list->ids == NULL) return false;
    }

    list->ids[list->size++] = id;
    return true;
}

/**
 * Insert a constant id into a list of constant ids at the specified index.
 */
void
pm_constant_id_list_insert(pm_constant_id_list_t *list, size_t index, pm_constant_id_t id) {
    assert(index < list->capacity);
    assert(list->ids[index] == PM_CONSTANT_ID_UNSET);

    list->ids[index] = id;
    list->size++;
}

/**
 * Checks if the current constant id list includes the given constant id.
 */
bool
pm_constant_id_list_includes(pm_constant_id_list_t *list, pm_constant_id_t id) {
    for (size_t index = 0; index < list->size; index++) {
        if (list->ids[index] == id) return true;
    }
    return false;
}

/**
 * Free the memory associated with a list of constant ids.
 */
void
pm_constant_id_list_free(pm_constant_id_list_t *list) {
    if (list->ids != NULL) {
        xfree(list->ids);
    }
}

/**
 * A relatively simple hash function (djb2) that is used to hash strings. We are
 * optimizing here for simplicity and speed.
 */
static inline uint32_t
pm_constant_pool_hash(const uint8_t *start, size_t length) {
    // This is a prime number used as the initial value for the hash function.
    uint32_t value = 5381;

    for (size_t index = 0; index < length; index++) {
        value = ((value << 5) + value) + start[index];
    }

    return value;
}

/**
 * https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
 */
static uint32_t
next_power_of_two(uint32_t v) {
    // Avoid underflow in subtraction on next line.
    if (v == 0) {
        // 1 is the nearest power of 2 to 0 (2^0)
        return 1;
    }
    v--;
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
    v++;
    return v;
}

#ifndef NDEBUG
static bool
is_power_of_two(uint32_t size) {
    return (size & (size - 1)) == 0;
}
#endif

/**
 * Resize a constant pool to a given capacity.
 */
static inline bool
pm_constant_pool_resize(pm_constant_pool_t *pool) {
    assert(is_power_of_two(pool->capacity));

    uint32_t next_capacity = pool->capacity * 2;
    if (next_capacity < pool->capacity) return false;

    const uint32_t mask = next_capacity - 1;
    const size_t element_size = sizeof(pm_constant_pool_bucket_t) + sizeof(pm_constant_t);

    void *next = xcalloc(next_capacity, element_size);
    if (next == NULL) return false;

    pm_constant_pool_bucket_t *next_buckets = next;
    pm_constant_t *next_constants = (void *)(((char *) next) + next_capacity * sizeof(pm_constant_pool_bucket_t));

    // For each bucket in the current constant pool, find the index in the
    // next constant pool, and insert it.
    for (uint32_t index = 0; index < pool->capacity; index++) {
        pm_constant_pool_bucket_t *bucket = &pool->buckets[index];

        // If an id is set on this constant, then we know we have content here.
        // In this case we need to insert it into the next constant pool.
        if (bucket->id != PM_CONSTANT_ID_UNSET) {
            uint32_t next_index = bucket->hash & mask;

            // This implements linear scanning to find the next available slot
            // in case this index is already taken. We don't need to bother
            // comparing the values since we know that the hash is unique.
            while (next_buckets[next_index].id != PM_CONSTANT_ID_UNSET) {
                next_index = (next_index + 1) & mask;
            }

            // Here we copy over the entire bucket, which includes the id so
            // that they are consistent between resizes.
            next_buckets[next_index] = *bucket;
        }
    }

    // The constants are stable with respect to hash table resizes.
    memcpy(next_constants, pool->constants, pool->size * sizeof(pm_constant_t));

    // pool->constants and pool->buckets are allocated out of the same chunk
    // of memory, with the buckets coming first.
    xfree(pool->buckets);
    pool->constants = next_constants;
    pool->buckets = next_buckets;
    pool->capacity = next_capacity;
    return true;
}

/**
 * Initialize a new constant pool with a given capacity.
 */
bool
pm_constant_pool_init(pm_constant_pool_t *pool, uint32_t capacity) {
    const uint32_t maximum = (~((uint32_t) 0));
    if (capacity >= ((maximum / 2) + 1)) return false;

    capacity = next_power_of_two(capacity);
    const size_t element_size = sizeof(pm_constant_pool_bucket_t) + sizeof(pm_constant_t);
    void *memory = xcalloc(capacity, element_size);
    if (memory == NULL) return false;

    pool->buckets = memory;
    pool->constants = (void *)(((char *)memory) + capacity * sizeof(pm_constant_pool_bucket_t));
    pool->size = 0;
    pool->capacity = capacity;
    return true;
}

/**
 * Return a pointer to the constant indicated by the given constant id.
 */
pm_constant_t *
pm_constant_pool_id_to_constant(const pm_constant_pool_t *pool, pm_constant_id_t constant_id) {
    assert(constant_id != PM_CONSTANT_ID_UNSET && constant_id <= pool->size);
    return &pool->constants[constant_id - 1];
}

/**
 * Find a constant in a constant pool. Returns the id of the constant, or 0 if
 * the constant is not found.
 */
pm_constant_id_t
pm_constant_pool_find(const pm_constant_pool_t *pool, const uint8_t *start, size_t length) {
    assert(is_power_of_two(pool->capacity));
    const uint32_t mask = pool->capacity - 1;

    uint32_t hash = pm_constant_pool_hash(start, length);
    uint32_t index = hash & mask;
    pm_constant_pool_bucket_t *bucket;

    while (bucket = &pool->buckets[index], bucket->id != PM_CONSTANT_ID_UNSET) {
        pm_constant_t *constant = &pool->constants[bucket->id - 1];
        if ((constant->length == length) && memcmp(constant->start, start, length) == 0) {
            return bucket->id;
        }

        index = (index + 1) & mask;
    }

    return PM_CONSTANT_ID_UNSET;
}

/**
 * Insert a constant into a constant pool and return its index in the pool.
 */
static inline pm_constant_id_t
pm_constant_pool_insert(pm_constant_pool_t *pool, const uint8_t *start, size_t length, pm_constant_pool_bucket_type_t type) {
    if (pool->size >= (pool->capacity / 4 * 3)) {
        if (!pm_constant_pool_resize(pool)) return PM_CONSTANT_ID_UNSET;
    }

    assert(is_power_of_two(pool->capacity));
    const uint32_t mask = pool->capacity - 1;

    uint32_t hash = pm_constant_pool_hash(start, length);
    uint32_t index = hash & mask;
    pm_constant_pool_bucket_t *bucket;

    while (bucket = &pool->buckets[index], bucket->id != PM_CONSTANT_ID_UNSET) {
        // If there is a collision, then we need to check if the content is the
        // same as the content we are trying to insert. If it is, then we can
        // return the id of the existing constant.
        pm_constant_t *constant = &pool->constants[bucket->id - 1];

        if ((constant->length == length) && memcmp(constant->start, start, length) == 0) {
            // Since we have found a match, we need to check if this is
            // attempting to insert a shared or an owned constant. We want to
            // prefer shared constants since they don't require allocations.
            if (type == PM_CONSTANT_POOL_BUCKET_OWNED) {
                // If we're attempting to insert an owned constant and we have
                // an existing constant, then either way we don't want the given
                // memory. Either it's duplicated with the existing constant or
                // it's not necessary because we have a shared version.
                xfree((void *) start);
            } else if (bucket->type == PM_CONSTANT_POOL_BUCKET_OWNED) {
                // If we're attempting to insert a shared constant and the
                // existing constant is owned, then we can free the owned
                // constant and replace it with the shared constant.
                xfree((void *) constant->start);
                constant->start = start;
                bucket->type = (unsigned int) (PM_CONSTANT_POOL_BUCKET_DEFAULT & 0x3);
            }

            return bucket->id;
        }

        index = (index + 1) & mask;
    }

    // IDs are allocated starting at 1, since the value 0 denotes a non-existent
    // constant.
    uint32_t id = ++pool->size;
    assert(pool->size < ((uint32_t) (1 << 30)));

    *bucket = (pm_constant_pool_bucket_t) {
        .id = (unsigned int) (id & 0x3fffffff),
        .type = (unsigned int) (type & 0x3),
        .hash = hash
    };

    pool->constants[id - 1] = (pm_constant_t) {
        .start = start,
        .length = length,
    };

    return id;
}

/**
 * Insert a constant into a constant pool. Returns the id of the constant, or
 * PM_CONSTANT_ID_UNSET if any potential calls to resize fail.
 */
pm_constant_id_t
pm_constant_pool_insert_shared(pm_constant_pool_t *pool, const uint8_t *start, size_t length) {
    return pm_constant_pool_insert(pool, start, length, PM_CONSTANT_POOL_BUCKET_DEFAULT);
}

/**
 * Insert a constant into a constant pool from memory that is now owned by the
 * constant pool. Returns the id of the constant, or PM_CONSTANT_ID_UNSET if any
 * potential calls to resize fail.
 */
pm_constant_id_t
pm_constant_pool_insert_owned(pm_constant_pool_t *pool, uint8_t *start, size_t length) {
    return pm_constant_pool_insert(pool, start, length, PM_CONSTANT_POOL_BUCKET_OWNED);
}

/**
 * Insert a constant into a constant pool from memory that is constant. Returns
 * the id of the constant, or PM_CONSTANT_ID_UNSET if any potential calls to
 * resize fail.
 */
pm_constant_id_t
pm_constant_pool_insert_constant(pm_constant_pool_t *pool, const uint8_t *start, size_t length) {
    return pm_constant_pool_insert(pool, start, length, PM_CONSTANT_POOL_BUCKET_CONSTANT);
}

/**
 * Free the memory associated with a constant pool.
 */
void
pm_constant_pool_free(pm_constant_pool_t *pool) {
    // For each constant in the current constant pool, free the contents if the
    // contents are owned.
    for (uint32_t index = 0; index < pool->capacity; index++) {
        pm_constant_pool_bucket_t *bucket = &pool->buckets[index];

        // If an id is set on this constant, then we know we have content here.
        if (bucket->id != PM_CONSTANT_ID_UNSET && bucket->type == PM_CONSTANT_POOL_BUCKET_OWNED) {
            pm_constant_t *constant = &pool->constants[bucket->id - 1];
            xfree((void *) constant->start);
        }
    }

    xfree(pool->buckets);
}
prism-1.5.1/src/util/pm_integer.c000066400000000000000000000563221506127434000167230ustar00rootroot00000000000000#include "prism/util/pm_integer.h"

/**
 * Pull out the length and values from the integer, regardless of the form in
 * which the length/values are stored.
 */
#define INTEGER_EXTRACT(integer, length_variable, values_variable) \
    if ((integer)->values == NULL) { \
        length_variable = 1; \
        values_variable = &(integer)->value; \
    } else { \
        length_variable = (integer)->length; \
        values_variable = (integer)->values; \
    }

/**
 * Adds two positive pm_integer_t with the given base.
 * Return pm_integer_t with values allocated. Not normalized.
 */
static void
big_add(pm_integer_t *destination, pm_integer_t *left, pm_integer_t *right, uint64_t base) {
    size_t left_length;
    uint32_t *left_values;
    INTEGER_EXTRACT(left, left_length, left_values)

    size_t right_length;
    uint32_t *right_values;
    INTEGER_EXTRACT(right, right_length, right_values)

    size_t length = left_length < right_length ? right_length : left_length;
    uint32_t *values = (uint32_t *) xmalloc(sizeof(uint32_t) * (length + 1));
    if (values == NULL) return;

    uint64_t carry = 0;
    for (size_t index = 0; index < length; index++) {
        uint64_t sum = carry + (index < left_length ? left_values[index] : 0) + (index < right_length ? right_values[index] : 0);
        values[index] = (uint32_t) (sum % base);
        carry = sum / base;
    }

    if (carry > 0) {
        values[length] = (uint32_t) carry;
        length++;
    }

    *destination = (pm_integer_t) { length, values, 0, false };
}

/**
 * Internal use for karatsuba_multiply. Calculates `a - b - c` with the given
 * base. Assume a, b, c, a - b - c all to be positive.
 * Return pm_integer_t with values allocated. Not normalized.
 */
static void
big_sub2(pm_integer_t *destination, pm_integer_t *a, pm_integer_t *b, pm_integer_t *c, uint64_t base) {
    size_t a_length;
    uint32_t *a_values;
    INTEGER_EXTRACT(a, a_length, a_values)

    size_t b_length;
    uint32_t *b_values;
    INTEGER_EXTRACT(b, b_length, b_values)

    size_t c_length;
    uint32_t *c_values;
    INTEGER_EXTRACT(c, c_length, c_values)

    uint32_t *values = (uint32_t*) xmalloc(sizeof(uint32_t) * a_length);
    int64_t carry = 0;

    for (size_t index = 0; index < a_length; index++) {
        int64_t sub = (
            carry +
            a_values[index] -
            (index < b_length ? b_values[index] : 0) -
            (index < c_length ? c_values[index] : 0)
        );

        if (sub >= 0) {
            values[index] = (uint32_t) sub;
            carry = 0;
        } else {
            sub += 2 * (int64_t) base;
            values[index] = (uint32_t) ((uint64_t) sub % base);
            carry = sub / (int64_t) base - 2;
        }
    }

    while (a_length > 1 && values[a_length - 1] == 0) a_length--;
    *destination = (pm_integer_t) { a_length, values, 0, false };
}

/**
 * Multiply two positive integers with the given base using karatsuba algorithm.
 * Return pm_integer_t with values allocated. Not normalized.
 */
static void
karatsuba_multiply(pm_integer_t *destination, pm_integer_t *left, pm_integer_t *right, uint64_t base) {
    size_t left_length;
    uint32_t *left_values;
    INTEGER_EXTRACT(left, left_length, left_values)

    size_t right_length;
    uint32_t *right_values;
    INTEGER_EXTRACT(right, right_length, right_values)

    if (left_length > right_length) {
        size_t temporary_length = left_length;
        left_length = right_length;
        right_length = temporary_length;

        uint32_t *temporary_values = left_values;
        left_values = right_values;
        right_values = temporary_values;
    }

    if (left_length <= 10) {
        size_t length = left_length + right_length;
        uint32_t *values = (uint32_t *) xcalloc(length, sizeof(uint32_t));
        if (values == NULL) return;

        for (size_t left_index = 0; left_index < left_length; left_index++) {
            uint32_t carry = 0;
            for (size_t right_index = 0; right_index < right_length; right_index++) {
                uint64_t product = (uint64_t) left_values[left_index] * right_values[right_index] + values[left_index + right_index] + carry;
                values[left_index + right_index] = (uint32_t) (product % base);
                carry = (uint32_t) (product / base);
            }
            values[left_index + right_length] = carry;
        }

        while (length > 1 && values[length - 1] == 0) length--;
        *destination = (pm_integer_t) { length, values, 0, false };
        return;
    }

    if (left_length * 2 <= right_length) {
        uint32_t *values = (uint32_t *) xcalloc(left_length + right_length, sizeof(uint32_t));

        for (size_t start_offset = 0; start_offset < right_length; start_offset += left_length) {
            size_t end_offset = start_offset + left_length;
            if (end_offset > right_length) end_offset = right_length;

            pm_integer_t sliced_left = {
                .length = left_length,
                .values = left_values,
                .value = 0,
                .negative = false
            };

            pm_integer_t sliced_right = {
                .length = end_offset - start_offset,
                .values = right_values + start_offset,
                .value = 0,
                .negative = false
            };

            pm_integer_t product;
            karatsuba_multiply(&product, &sliced_left, &sliced_right, base);

            uint32_t carry = 0;
            for (size_t index = 0; index < product.length; index++) {
                uint64_t sum = (uint64_t) values[start_offset + index] + product.values[index] + carry;
                values[start_offset + index] = (uint32_t) (sum % base);
                carry = (uint32_t) (sum / base);
            }

            if (carry > 0) values[start_offset + product.length] += carry;
            pm_integer_free(&product);
        }

        *destination = (pm_integer_t) { left_length + right_length, values, 0, false };
        return;
    }

    size_t half = left_length / 2;
    pm_integer_t x0 = { half, left_values, 0, false };
    pm_integer_t x1 = { left_length - half, left_values + half, 0, false };
    pm_integer_t y0 = { half, right_values, 0, false };
    pm_integer_t y1 = { right_length - half, right_values + half, 0, false };

    pm_integer_t z0 = { 0 };
    karatsuba_multiply(&z0, &x0, &y0, base);

    pm_integer_t z2 = { 0 };
    karatsuba_multiply(&z2, &x1, &y1, base);

    // For simplicity to avoid considering negative values,
    // use `z1 = (x0 + x1) * (y0 + y1) - z0 - z2` instead of original karatsuba algorithm.
    pm_integer_t x01 = { 0 };
    big_add(&x01, &x0, &x1, base);

    pm_integer_t y01 = { 0 };
    big_add(&y01, &y0, &y1, base);

    pm_integer_t xy = { 0 };
    karatsuba_multiply(&xy, &x01, &y01, base);

    pm_integer_t z1;
    big_sub2(&z1, &xy, &z0, &z2, base);

    size_t length = left_length + right_length;
    uint32_t *values = (uint32_t*) xcalloc(length, sizeof(uint32_t));

    assert(z0.values != NULL);
    memcpy(values, z0.values, sizeof(uint32_t) * z0.length);

    assert(z2.values != NULL);
    memcpy(values + 2 * half, z2.values, sizeof(uint32_t) * z2.length);

    uint32_t carry = 0;
    for(size_t index = 0; index < z1.length; index++) {
        uint64_t sum = (uint64_t) carry + values[index + half] + z1.values[index];
        values[index + half] = (uint32_t) (sum % base);
        carry = (uint32_t) (sum / base);
    }

    for(size_t index = half + z1.length; carry > 0; index++) {
        uint64_t sum = (uint64_t) carry + values[index];
        values[index] = (uint32_t) (sum % base);
        carry = (uint32_t) (sum / base);
    }

    while (length > 1 && values[length - 1] == 0) length--;
    pm_integer_free(&z0);
    pm_integer_free(&z1);
    pm_integer_free(&z2);
    pm_integer_free(&x01);
    pm_integer_free(&y01);
    pm_integer_free(&xy);

    *destination = (pm_integer_t) { length, values, 0, false };
}

/**
 * The values of a hexadecimal digit, where the index is the ASCII character.
 * Note that there's an odd exception here where _ is mapped to 0. This is
 * because it's possible for us to end up trying to parse a number that has
 * already had an error attached to it, and we want to provide _something_ to
 * the user.
 */
static const int8_t pm_integer_parse_digit_values[256] = {
//   0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 1x
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 2x
     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1, // 3x
    -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 4x
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  0, // 5x
    -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 6x
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 7x
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 8x
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 9x
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // Ax
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // Bx
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // Cx
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // Dx
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // Ex
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // Fx
};

/**
 * Return the value of a hexadecimal digit in a uint8_t.
 */
static uint8_t
pm_integer_parse_digit(const uint8_t character) {
    int8_t value = pm_integer_parse_digit_values[character];
    assert(value != -1 && "invalid digit");

    return (uint8_t) value;
}

/**
 * Create a pm_integer_t from uint64_t with the given base. It is assumed that
 * the memory for the pm_integer_t pointer has been zeroed.
 */
static void
pm_integer_from_uint64(pm_integer_t *integer, uint64_t value, uint64_t base) {
    if (value < base) {
        integer->value = (uint32_t) value;
        return;
    }

    size_t length = 0;
    uint64_t length_value = value;
    while (length_value > 0) {
        length++;
        length_value /= base;
    }

    uint32_t *values = (uint32_t *) xmalloc(sizeof(uint32_t) * length);
    if (values == NULL) return;

    for (size_t value_index = 0; value_index < length; value_index++) {
        values[value_index] = (uint32_t) (value % base);
        value /= base;
    }

    integer->length = length;
    integer->values = values;
}

/**
 * Normalize pm_integer_t.
 * Heading zero values will be removed. If the integer fits into uint32_t,
 * values is set to NULL, length is set to 0, and value field will be used.
 */
static void
pm_integer_normalize(pm_integer_t *integer) {
    if (integer->values == NULL) {
        return;
    }

    while (integer->length > 1 && integer->values[integer->length - 1] == 0) {
        integer->length--;
    }

    if (integer->length > 1) {
        return;
    }

    uint32_t value = integer->values[0];
    bool negative = integer->negative && value != 0;

    pm_integer_free(integer);
    *integer = (pm_integer_t) { .values = NULL, .value = value, .length = 0, .negative = negative };
}

/**
 * Convert base of the integer.
 * In practice, it converts 10**9 to 1<<32 or 1<<32 to 10**9.
 */
static void
pm_integer_convert_base(pm_integer_t *destination, const pm_integer_t *source, uint64_t base_from, uint64_t base_to) {
    size_t source_length;
    const uint32_t *source_values;
    INTEGER_EXTRACT(source, source_length, source_values)

    size_t bigints_length = (source_length + 1) / 2;
    assert(bigints_length > 0);

    pm_integer_t *bigints = (pm_integer_t *) xcalloc(bigints_length, sizeof(pm_integer_t));
    if (bigints == NULL) return;

    for (size_t index = 0; index < source_length; index += 2) {
        uint64_t value = source_values[index] + base_from * (index + 1 < source_length ? source_values[index + 1] : 0);
        pm_integer_from_uint64(&bigints[index / 2], value, base_to);
    }

    pm_integer_t base = { 0 };
    pm_integer_from_uint64(&base, base_from, base_to);

    while (bigints_length > 1) {
        pm_integer_t next_base;
        karatsuba_multiply(&next_base, &base, &base, base_to);

        pm_integer_free(&base);
        base = next_base;

        size_t next_length = (bigints_length + 1) / 2;
        pm_integer_t *next_bigints = (pm_integer_t *) xcalloc(next_length, sizeof(pm_integer_t));

        for (size_t bigints_index = 0; bigints_index < bigints_length; bigints_index += 2) {
            if (bigints_index + 1 == bigints_length) {
                next_bigints[bigints_index / 2] = bigints[bigints_index];
            } else {
                pm_integer_t multiplied = { 0 };
                karatsuba_multiply(&multiplied, &base, &bigints[bigints_index + 1], base_to);

                big_add(&next_bigints[bigints_index / 2], &bigints[bigints_index], &multiplied, base_to);
                pm_integer_free(&bigints[bigints_index]);
                pm_integer_free(&bigints[bigints_index + 1]);
                pm_integer_free(&multiplied);
            }
        }

        xfree(bigints);
        bigints = next_bigints;
        bigints_length = next_length;
    }

    *destination = bigints[0];
    destination->negative = source->negative;
    pm_integer_normalize(destination);

    xfree(bigints);
    pm_integer_free(&base);
}

#undef INTEGER_EXTRACT

/**
 * Convert digits to integer with the given power-of-two base.
 */
static void
pm_integer_parse_powof2(pm_integer_t *integer, uint32_t base, const uint8_t *digits, size_t digits_length) {
    size_t bit = 1;
    while (base > (uint32_t) (1 << bit)) bit++;

    size_t length = (digits_length * bit + 31) / 32;
    uint32_t *values = (uint32_t *) xcalloc(length, sizeof(uint32_t));

    for (size_t digit_index = 0; digit_index < digits_length; digit_index++) {
        size_t bit_position = bit * (digits_length - digit_index - 1);
        uint32_t value = digits[digit_index];

        size_t index = bit_position / 32;
        size_t shift = bit_position % 32;

        values[index] |= value << shift;
        if (32 - shift < bit) values[index + 1] |= value >> (32 - shift);
    }

    while (length > 1 && values[length - 1] == 0) length--;
    *integer = (pm_integer_t) { .length = length, .values = values, .value = 0, .negative = false };
    pm_integer_normalize(integer);
}

/**
 * Convert decimal digits to pm_integer_t.
 */
static void
pm_integer_parse_decimal(pm_integer_t *integer, const uint8_t *digits, size_t digits_length) {
    const size_t batch = 9;
    size_t length = (digits_length + batch - 1) / batch;

    uint32_t *values = (uint32_t *) xcalloc(length, sizeof(uint32_t));
    uint32_t value = 0;

    for (size_t digits_index = 0; digits_index < digits_length; digits_index++) {
        value = value * 10 + digits[digits_index];

        size_t reverse_index = digits_length - digits_index - 1;
        if (reverse_index % batch == 0) {
            values[reverse_index / batch] = value;
            value = 0;
        }
    }

    // Convert base from 10**9 to 1<<32.
    pm_integer_convert_base(integer, &((pm_integer_t) { .length = length, .values = values,  .value = 0, .negative = false }), 1000000000, ((uint64_t) 1 << 32));
    xfree(values);
}

/**
 * Parse a large integer from a string that does not fit into uint32_t.
 */
static void
pm_integer_parse_big(pm_integer_t *integer, uint32_t multiplier, const uint8_t *start, const uint8_t *end) {
    // Allocate an array to store digits.
    uint8_t *digits = xmalloc(sizeof(uint8_t) * (size_t) (end - start));
    size_t digits_length = 0;

    for (; start < end; start++) {
        if (*start == '_') continue;
        digits[digits_length++] = pm_integer_parse_digit(*start);
    }

    // Construct pm_integer_t from the digits.
    if (multiplier == 10) {
        pm_integer_parse_decimal(integer, digits, digits_length);
    } else {
        pm_integer_parse_powof2(integer, multiplier, digits, digits_length);
    }

    xfree(digits);
}

/**
 * Parse an integer from a string. This assumes that the format of the integer
 * has already been validated, as internal validation checks are not performed
 * here.
 */
void
pm_integer_parse(pm_integer_t *integer, pm_integer_base_t base, const uint8_t *start, const uint8_t *end) {
    // Ignore unary +. Unary - is parsed differently and will not end up here.
    // Instead, it will modify the parsed integer later.
    if (*start == '+') start++;

    // Determine the multiplier from the base, and skip past any prefixes.
    uint32_t multiplier = 10;
    switch (base) {
        case PM_INTEGER_BASE_DEFAULT:
            while (*start == '0') start++; // 01 -> 1
            break;
        case PM_INTEGER_BASE_BINARY:
            start += 2; // 0b
            multiplier = 2;
            break;
        case PM_INTEGER_BASE_OCTAL:
            start++; // 0
            if (*start == '_' || *start == 'o' || *start == 'O') start++; // o
            multiplier = 8;
            break;
        case PM_INTEGER_BASE_DECIMAL:
            if (*start == '0' && (end - start) > 1) start += 2; // 0d
            break;
        case PM_INTEGER_BASE_HEXADECIMAL:
            start += 2; // 0x
            multiplier = 16;
            break;
        case PM_INTEGER_BASE_UNKNOWN:
            if (*start == '0' && (end - start) > 1) {
                switch (start[1]) {
                    case '_': start += 2; multiplier = 8; break;
                    case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': start++; multiplier = 8; break;
                    case 'b': case 'B': start += 2; multiplier = 2; break;
                    case 'o': case 'O': start += 2; multiplier = 8; break;
                    case 'd': case 'D': start += 2; break;
                    case 'x': case 'X': start += 2; multiplier = 16; break;
                    default: assert(false && "unreachable"); break;
                }
            }
            break;
    }

    // It's possible that we've consumed everything at this point if there is an
    // invalid integer. If this is the case, we'll just return 0.
    if (start >= end) return;

    const uint8_t *cursor = start;
    uint64_t value = (uint64_t) pm_integer_parse_digit(*cursor++);

    for (; cursor < end; cursor++) {
        if (*cursor == '_') continue;
        value = value * multiplier + (uint64_t) pm_integer_parse_digit(*cursor);

        if (value > UINT32_MAX) {
            // If the integer is too large to fit into a single uint32_t, then
            // we'll parse it as a big integer.
            pm_integer_parse_big(integer, multiplier, start, end);
            return;
        }
    }

    integer->value = (uint32_t) value;
}

/**
 * Compare two integers. This function returns -1 if the left integer is less
 * than the right integer, 0 if they are equal, and 1 if the left integer is
 * greater than the right integer.
 */
int
pm_integer_compare(const pm_integer_t *left, const pm_integer_t *right) {
    if (left->negative != right->negative) return left->negative ? -1 : 1;
    int negative = left->negative ? -1 : 1;

    if (left->values == NULL && right->values == NULL) {
        if (left->value < right->value) return -1 * negative;
        if (left->value > right->value) return 1 * negative;
        return 0;
    }

    if (left->values == NULL || left->length < right->length) return -1 * negative;
    if (right->values == NULL || left->length > right->length) return 1 * negative;

    for (size_t index = 0; index < left->length; index++) {
        size_t value_index = left->length - index - 1;
        uint32_t left_value = left->values[value_index];
        uint32_t right_value = right->values[value_index];

        if (left_value < right_value) return -1 * negative;
        if (left_value > right_value) return 1 * negative;
    }

    return 0;
}

/**
 * Reduce a ratio of integers to its simplest form.
 */
void pm_integers_reduce(pm_integer_t *numerator, pm_integer_t *denominator) {
    // If either the numerator or denominator do not fit into a 32-bit integer,
    // then this function is a no-op. In the future, we may consider reducing
    // even the larger numbers, but for now we're going to keep it simple.
    if (
        // If the numerator doesn't fit into a 32-bit integer, return early.
        numerator->length != 0 ||
        // If the denominator doesn't fit into a 32-bit integer, return early.
        denominator->length != 0 ||
        // If the numerator is 0, then return early.
        numerator->value == 0 ||
        // If the denominator is 1, then return early.
        denominator->value == 1
    ) return;

    // Find the greatest common divisor of the numerator and denominator.
    uint32_t divisor = numerator->value;
    uint32_t remainder = denominator->value;

    while (remainder != 0) {
        uint32_t temporary = remainder;
        remainder = divisor % remainder;
        divisor = temporary;
    }

    // Divide the numerator and denominator by the greatest common divisor.
    numerator->value /= divisor;
    denominator->value /= divisor;
}

/**
 * Convert an integer to a decimal string.
 */
PRISM_EXPORTED_FUNCTION void
pm_integer_string(pm_buffer_t *buffer, const pm_integer_t *integer) {
    if (integer->negative) {
        pm_buffer_append_byte(buffer, '-');
    }

    // If the integer fits into a single uint32_t, then we can just append the
    // value directly to the buffer.
    if (integer->values == NULL) {
        pm_buffer_append_format(buffer, "%" PRIu32, integer->value);
        return;
    }

    // If the integer is two uint32_t values, then we can | them together and
    // append the result to the buffer.
    if (integer->length == 2) {
        const uint64_t value = ((uint64_t) integer->values[0]) | ((uint64_t) integer->values[1] << 32);
        pm_buffer_append_format(buffer, "%" PRIu64, value);
        return;
    }

    // Otherwise, first we'll convert the base from 1<<32 to 10**9.
    pm_integer_t converted = { 0 };
    pm_integer_convert_base(&converted, integer, (uint64_t) 1 << 32, 1000000000);

    if (converted.values == NULL) {
        pm_buffer_append_format(buffer, "%" PRIu32, converted.value);
        pm_integer_free(&converted);
        return;
    }

    // Allocate a buffer that we'll copy the decimal digits into.
    size_t digits_length = converted.length * 9;
    char *digits = xcalloc(digits_length, sizeof(char));
    if (digits == NULL) return;

    // Pack bigdecimal to digits.
    for (size_t value_index = 0; value_index < converted.length; value_index++) {
        uint32_t value = converted.values[value_index];

        for (size_t digit_index = 0; digit_index < 9; digit_index++) {
            digits[digits_length - 9 * value_index - digit_index - 1] = (char) ('0' + value % 10);
            value /= 10;
        }
    }

    size_t start_offset = 0;
    while (start_offset < digits_length - 1 && digits[start_offset] == '0') start_offset++;

    // Finally, append the string to the buffer and free the digits.
    pm_buffer_append_string(buffer, digits + start_offset, digits_length - start_offset);
    xfree(digits);
    pm_integer_free(&converted);
}

/**
 * Free the internal memory of an integer. This memory will only be allocated if
 * the integer exceeds the size of a single uint32_t.
 */
PRISM_EXPORTED_FUNCTION void
pm_integer_free(pm_integer_t *integer) {
    if (integer->values) {
        xfree(integer->values);
    }
}
prism-1.5.1/src/util/pm_list.c000066400000000000000000000015641506127434000162370ustar00rootroot00000000000000#include "prism/util/pm_list.h"

/**
 * Returns true if the given list is empty.
 */
PRISM_EXPORTED_FUNCTION bool
pm_list_empty_p(pm_list_t *list) {
    return list->head == NULL;
}

/**
 * Returns the size of the list.
 */
PRISM_EXPORTED_FUNCTION size_t
pm_list_size(pm_list_t *list) {
    return list->size;
}

/**
 * Append a node to the given list.
 */
void
pm_list_append(pm_list_t *list, pm_list_node_t *node) {
    if (list->head == NULL) {
        list->head = node;
    } else {
        list->tail->next = node;
    }

    list->tail = node;
    list->size++;
}

/**
 * Deallocate the internal state of the given list.
 */
PRISM_EXPORTED_FUNCTION void
pm_list_free(pm_list_t *list) {
    pm_list_node_t *node = list->head;
    pm_list_node_t *next;

    while (node != NULL) {
        next = node->next;
        xfree(node);
        node = next;
    }

    list->size = 0;
}
prism-1.5.1/src/util/pm_memchr.c000066400000000000000000000020701506127434000165300ustar00rootroot00000000000000#include "prism/util/pm_memchr.h"

#define PRISM_MEMCHR_TRAILING_BYTE_MINIMUM 0x40

/**
 * We need to roll our own memchr to handle cases where the encoding changes and
 * we need to search for a character in a buffer that could be the trailing byte
 * of a multibyte character.
 */
void *
pm_memchr(const void *memory, int character, size_t number, bool encoding_changed, const pm_encoding_t *encoding) {
    if (encoding_changed && encoding->multibyte && character >= PRISM_MEMCHR_TRAILING_BYTE_MINIMUM) {
        const uint8_t *source = (const uint8_t *) memory;
        size_t index = 0;

        while (index < number) {
            if (source[index] == character) {
                return (void *) (source + index);
            }

            size_t width = encoding->char_width(source + index, (ptrdiff_t) (number - index));
            if (width == 0) {
                return NULL;
            }

            index += width;
        }

        return NULL;
    } else {
        return memchr(memory, character, number);
    }
}

#undef PRISM_MEMCHR_TRAILING_BYTE_MINIMUM
prism-1.5.1/src/util/pm_newline_list.c000066400000000000000000000067521506127434000177640ustar00rootroot00000000000000#include "prism/util/pm_newline_list.h"

/**
 * Initialize a new newline list with the given capacity. Returns true if the
 * allocation of the offsets succeeds, otherwise returns false.
 */
bool
pm_newline_list_init(pm_newline_list_t *list, const uint8_t *start, size_t capacity) {
    list->offsets = (size_t *) xcalloc(capacity, sizeof(size_t));
    if (list->offsets == NULL) return false;

    list->start = start;

    // This is 1 instead of 0 because we want to include the first line of the
    // file as having offset 0, which is set because of calloc.
    list->size = 1;
    list->capacity = capacity;

    return true;
}

/**
 * Clear out the newlines that have been appended to the list.
 */
void
pm_newline_list_clear(pm_newline_list_t *list) {
    list->size = 1;
}

/**
 * Append a new offset to the newline list. Returns true if the reallocation of
 * the offsets succeeds (if one was necessary), otherwise returns false.
 */
bool
pm_newline_list_append(pm_newline_list_t *list, const uint8_t *cursor) {
    if (list->size == list->capacity) {
        size_t *original_offsets = list->offsets;

        list->capacity = (list->capacity * 3) / 2;
        list->offsets = (size_t *) xcalloc(list->capacity, sizeof(size_t));
        if (list->offsets == NULL) return false;

        memcpy(list->offsets, original_offsets, list->size * sizeof(size_t));
        xfree(original_offsets);
    }

    assert(*cursor == '\n');
    assert(cursor >= list->start);
    size_t newline_offset = (size_t) (cursor - list->start + 1);

    assert(list->size == 0 || newline_offset > list->offsets[list->size - 1]);
    list->offsets[list->size++] = newline_offset;

    return true;
}

/**
 * Returns the line of the given offset. If the offset is not in the list, the
 * line of the closest offset less than the given offset is returned.
 */
int32_t
pm_newline_list_line(const pm_newline_list_t *list, const uint8_t *cursor, int32_t start_line) {
    assert(cursor >= list->start);
    size_t offset = (size_t) (cursor - list->start);

    size_t left = 0;
    size_t right = list->size - 1;

    while (left <= right) {
        size_t mid = left + (right - left) / 2;

        if (list->offsets[mid] == offset) {
            return ((int32_t) mid) + start_line;
        }

        if (list->offsets[mid] < offset) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    return ((int32_t) left) + start_line - 1;
}

/**
 * Returns the line and column of the given offset. If the offset is not in the
 * list, the line and column of the closest offset less than the given offset
 * are returned.
 */
pm_line_column_t
pm_newline_list_line_column(const pm_newline_list_t *list, const uint8_t *cursor, int32_t start_line) {
    assert(cursor >= list->start);
    size_t offset = (size_t) (cursor - list->start);

    size_t left = 0;
    size_t right = list->size - 1;

    while (left <= right) {
        size_t mid = left + (right - left) / 2;

        if (list->offsets[mid] == offset) {
            return ((pm_line_column_t) { ((int32_t) mid) + start_line, 0 });
        }

        if (list->offsets[mid] < offset) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    return ((pm_line_column_t) {
        .line = ((int32_t) left) + start_line - 1,
        .column = (uint32_t) (offset - list->offsets[left - 1])
    });
}

/**
 * Free the internal memory allocated for the newline list.
 */
void
pm_newline_list_free(pm_newline_list_t *list) {
    xfree(list->offsets);
}
prism-1.5.1/src/util/pm_string.c000066400000000000000000000271541506127434000165750ustar00rootroot00000000000000#include "prism/util/pm_string.h"

/**
 * Returns the size of the pm_string_t struct. This is necessary to allocate the
 * correct amount of memory in the FFI backend.
 */
PRISM_EXPORTED_FUNCTION size_t
pm_string_sizeof(void) {
    return sizeof(pm_string_t);
}

/**
 * Initialize a shared string that is based on initial input.
 */
void
pm_string_shared_init(pm_string_t *string, const uint8_t *start, const uint8_t *end) {
    assert(start <= end);

    *string = (pm_string_t) {
        .type = PM_STRING_SHARED,
        .source = start,
        .length = (size_t) (end - start)
    };
}

/**
 * Initialize an owned string that is responsible for freeing allocated memory.
 */
void
pm_string_owned_init(pm_string_t *string, uint8_t *source, size_t length) {
    *string = (pm_string_t) {
        .type = PM_STRING_OWNED,
        .source = source,
        .length = length
    };
}

/**
 * Initialize a constant string that doesn't own its memory source.
 */
void
pm_string_constant_init(pm_string_t *string, const char *source, size_t length) {
    *string = (pm_string_t) {
        .type = PM_STRING_CONSTANT,
        .source = (const uint8_t *) source,
        .length = length
    };
}

#ifdef _WIN32
/**
 * Represents a file handle on Windows, where the path will need to be freed
 * when the file is closed.
 */
typedef struct {
    /** The path to the file, which will become allocated memory. */
    WCHAR *path;

    /** The handle to the file, which will start as uninitialized memory. */
    HANDLE file;
} pm_string_file_handle_t;

/**
 * Open the file indicated by the filepath parameter for reading on Windows.
 * Perform any kind of normalization that needs to happen on the filepath.
 */
static pm_string_init_result_t
pm_string_file_handle_open(pm_string_file_handle_t *handle, const char *filepath) {
    int length = MultiByteToWideChar(CP_UTF8, 0, filepath, -1, NULL, 0);
    if (length == 0) return PM_STRING_INIT_ERROR_GENERIC;

    handle->path = xmalloc(sizeof(WCHAR) * ((size_t) length));
    if ((handle->path == NULL) || (MultiByteToWideChar(CP_UTF8, 0, filepath, -1, handle->path, length) == 0)) {
        xfree(handle->path);
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    handle->file = CreateFileW(handle->path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
    if (handle->file == INVALID_HANDLE_VALUE) {
        pm_string_init_result_t result = PM_STRING_INIT_ERROR_GENERIC;

        if (GetLastError() == ERROR_ACCESS_DENIED) {
            DWORD attributes = GetFileAttributesW(handle->path);
            if ((attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
                result = PM_STRING_INIT_ERROR_DIRECTORY;
            }
        }

        xfree(handle->path);
        return result;
    }

    return PM_STRING_INIT_SUCCESS;
}

/**
 * Close the file handle and free the path.
 */
static void
pm_string_file_handle_close(pm_string_file_handle_t *handle) {
    xfree(handle->path);
    CloseHandle(handle->file);
}
#endif

/**
 * Read the file indicated by the filepath parameter into source and load its
 * contents and size into the given `pm_string_t`. The given `pm_string_t`
 * should be freed using `pm_string_free` when it is no longer used.
 *
 * We want to use demand paging as much as possible in order to avoid having to
 * read the entire file into memory (which could be detrimental to performance
 * for large files). This means that if we're on windows we'll use
 * `MapViewOfFile`, on POSIX systems that have access to `mmap` we'll use
 * `mmap`, and on other POSIX systems we'll use `read`.
 */
PRISM_EXPORTED_FUNCTION pm_string_init_result_t
pm_string_mapped_init(pm_string_t *string, const char *filepath) {
#ifdef _WIN32
    // Open the file for reading.
    pm_string_file_handle_t handle;
    pm_string_init_result_t result = pm_string_file_handle_open(&handle, filepath);
    if (result != PM_STRING_INIT_SUCCESS) return result;

    // Get the file size.
    DWORD file_size = GetFileSize(handle.file, NULL);
    if (file_size == INVALID_FILE_SIZE) {
        pm_string_file_handle_close(&handle);
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    // If the file is empty, then we don't need to do anything else, we'll set
    // the source to a constant empty string and return.
    if (file_size == 0) {
        pm_string_file_handle_close(&handle);
        const uint8_t source[] = "";
        *string = (pm_string_t) { .type = PM_STRING_CONSTANT, .source = source, .length = 0 };
        return PM_STRING_INIT_SUCCESS;
    }

    // Create a mapping of the file.
    HANDLE mapping = CreateFileMapping(handle.file, NULL, PAGE_READONLY, 0, 0, NULL);
    if (mapping == NULL) {
        pm_string_file_handle_close(&handle);
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    // Map the file into memory.
    uint8_t *source = (uint8_t *) MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
    CloseHandle(mapping);
    pm_string_file_handle_close(&handle);

    if (source == NULL) {
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    *string = (pm_string_t) { .type = PM_STRING_MAPPED, .source = source, .length = (size_t) file_size };
    return PM_STRING_INIT_SUCCESS;
#elif defined(_POSIX_MAPPED_FILES)
    // Open the file for reading
    int fd = open(filepath, O_RDONLY);
    if (fd == -1) {
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    // Stat the file to get the file size
    struct stat sb;
    if (fstat(fd, &sb) == -1) {
        close(fd);
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    // Ensure it is a file and not a directory
    if (S_ISDIR(sb.st_mode)) {
        close(fd);
        return PM_STRING_INIT_ERROR_DIRECTORY;
    }

    // mmap the file descriptor to virtually get the contents
    size_t size = (size_t) sb.st_size;
    uint8_t *source = NULL;

    if (size == 0) {
        close(fd);
        const uint8_t source[] = "";
        *string = (pm_string_t) { .type = PM_STRING_CONSTANT, .source = source, .length = 0 };
        return PM_STRING_INIT_SUCCESS;
    }

    source = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
    if (source == MAP_FAILED) {
        close(fd);
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    close(fd);
    *string = (pm_string_t) { .type = PM_STRING_MAPPED, .source = source, .length = size };
    return PM_STRING_INIT_SUCCESS;
#else
    return pm_string_file_init(string, filepath);
#endif
}

/**
 * Read the file indicated by the filepath parameter into source and load its
 * contents and size into the given `pm_string_t`. The given `pm_string_t`
 * should be freed using `pm_string_free` when it is no longer used.
 */
PRISM_EXPORTED_FUNCTION pm_string_init_result_t
pm_string_file_init(pm_string_t *string, const char *filepath) {
#ifdef _WIN32
    // Open the file for reading.
    pm_string_file_handle_t handle;
    pm_string_init_result_t result = pm_string_file_handle_open(&handle, filepath);
    if (result != PM_STRING_INIT_SUCCESS) return result;

    // Get the file size.
    DWORD file_size = GetFileSize(handle.file, NULL);
    if (file_size == INVALID_FILE_SIZE) {
        pm_string_file_handle_close(&handle);
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    // If the file is empty, then we don't need to do anything else, we'll set
    // the source to a constant empty string and return.
    if (file_size == 0) {
        pm_string_file_handle_close(&handle);
        const uint8_t source[] = "";
        *string = (pm_string_t) { .type = PM_STRING_CONSTANT, .source = source, .length = 0 };
        return PM_STRING_INIT_SUCCESS;
    }

    // Create a buffer to read the file into.
    uint8_t *source = xmalloc(file_size);
    if (source == NULL) {
        pm_string_file_handle_close(&handle);
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    // Read the contents of the file
    DWORD bytes_read;
    if (!ReadFile(handle.file, source, file_size, &bytes_read, NULL)) {
        pm_string_file_handle_close(&handle);
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    // Check the number of bytes read
    if (bytes_read != file_size) {
        xfree(source);
        pm_string_file_handle_close(&handle);
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    pm_string_file_handle_close(&handle);
    *string = (pm_string_t) { .type = PM_STRING_OWNED, .source = source, .length = (size_t) file_size };
    return PM_STRING_INIT_SUCCESS;
#elif defined(PRISM_HAS_FILESYSTEM)
    // Open the file for reading
    int fd = open(filepath, O_RDONLY);
    if (fd == -1) {
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    // Stat the file to get the file size
    struct stat sb;
    if (fstat(fd, &sb) == -1) {
        close(fd);
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    // Ensure it is a file and not a directory
    if (S_ISDIR(sb.st_mode)) {
        close(fd);
        return PM_STRING_INIT_ERROR_DIRECTORY;
    }

    // Check the size to see if it's empty
    size_t size = (size_t) sb.st_size;
    if (size == 0) {
        close(fd);
        const uint8_t source[] = "";
        *string = (pm_string_t) { .type = PM_STRING_CONSTANT, .source = source, .length = 0 };
        return PM_STRING_INIT_SUCCESS;
    }

    size_t length = (size_t) size;
    uint8_t *source = xmalloc(length);
    if (source == NULL) {
        close(fd);
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    long bytes_read = (long) read(fd, source, length);
    close(fd);

    if (bytes_read == -1) {
        xfree(source);
        return PM_STRING_INIT_ERROR_GENERIC;
    }

    *string = (pm_string_t) { .type = PM_STRING_OWNED, .source = source, .length = length };
    return PM_STRING_INIT_SUCCESS;
#else
    (void) string;
    (void) filepath;
    perror("pm_string_file_init is not implemented for this platform");
    return PM_STRING_INIT_ERROR_GENERIC;
#endif
}

/**
 * Ensure the string is owned. If it is not, then reinitialize it as owned and
 * copy over the previous source.
 */
void
pm_string_ensure_owned(pm_string_t *string) {
    if (string->type == PM_STRING_OWNED) return;

    size_t length = pm_string_length(string);
    const uint8_t *source = pm_string_source(string);

    uint8_t *memory = xmalloc(length);
    if (!memory) return;

    pm_string_owned_init(string, memory, length);
    memcpy((void *) string->source, source, length);
}

/**
 * Compare the underlying lengths and bytes of two strings. Returns 0 if the
 * strings are equal, a negative number if the left string is less than the
 * right string, and a positive number if the left string is greater than the
 * right string.
 */
int
pm_string_compare(const pm_string_t *left, const pm_string_t *right) {
    size_t left_length = pm_string_length(left);
    size_t right_length = pm_string_length(right);

    if (left_length < right_length) {
        return -1;
    } else if (left_length > right_length) {
        return 1;
    }

    return memcmp(pm_string_source(left), pm_string_source(right), left_length);
}

/**
 * Returns the length associated with the string.
 */
PRISM_EXPORTED_FUNCTION size_t
pm_string_length(const pm_string_t *string) {
    return string->length;
}

/**
 * Returns the start pointer associated with the string.
 */
PRISM_EXPORTED_FUNCTION const uint8_t *
pm_string_source(const pm_string_t *string) {
    return string->source;
}

/**
 * Free the associated memory of the given string.
 */
PRISM_EXPORTED_FUNCTION void
pm_string_free(pm_string_t *string) {
    void *memory = (void *) string->source;

    if (string->type == PM_STRING_OWNED) {
        xfree(memory);
#ifdef PRISM_HAS_MMAP
    } else if (string->type == PM_STRING_MAPPED && string->length) {
#if defined(_WIN32)
        UnmapViewOfFile(memory);
#elif defined(_POSIX_MAPPED_FILES)
        munmap(memory, string->length);
#endif
#endif /* PRISM_HAS_MMAP */
    }
}
prism-1.5.1/src/util/pm_strncasecmp.c000066400000000000000000000017721506127434000176070ustar00rootroot00000000000000#include "prism/util/pm_strncasecmp.h"

/**
 * A locale-insensitive version of `tolower(3)`
 */
static inline int
pm_tolower(int c)
{
    if ('A' <= c && c <= 'Z') {
        return c | 0x20;
    }
    return c;
}

/**
 * Compare two strings, ignoring case, up to the given length. Returns 0 if the
 * strings are equal, a negative number if string1 is less than string2, or a
 * positive number if string1 is greater than string2.
 *
 * Note that this is effectively our own implementation of strncasecmp, but it's
 * not available on all of the platforms we want to support so we're rolling it
 * here.
 */
int
pm_strncasecmp(const uint8_t *string1, const uint8_t *string2, size_t length) {
    size_t offset = 0;
    int difference = 0;

    while (offset < length && string1[offset] != '\0') {
        if (string2[offset] == '\0') return string1[offset];
        if ((difference = pm_tolower(string1[offset]) - pm_tolower(string2[offset])) != 0) return difference;
        offset++;
    }

    return difference;
}
prism-1.5.1/src/util/pm_strpbrk.c000066400000000000000000000171541506127434000167550ustar00rootroot00000000000000#include "prism/util/pm_strpbrk.h"

/**
 * Add an invalid multibyte character error to the parser.
 */
static inline void
pm_strpbrk_invalid_multibyte_character(pm_parser_t *parser, const uint8_t *start, const uint8_t *end) {
    pm_diagnostic_list_append_format(&parser->error_list, start, end, PM_ERR_INVALID_MULTIBYTE_CHARACTER, *start);
}

/**
 * Set the explicit encoding for the parser to the current encoding.
 */
static inline void
pm_strpbrk_explicit_encoding_set(pm_parser_t *parser, const uint8_t *source, size_t width) {
    if (parser->explicit_encoding != NULL) {
        if (parser->explicit_encoding == parser->encoding) {
            // Okay, we already locked to this encoding.
        } else if (parser->explicit_encoding == PM_ENCODING_UTF_8_ENTRY) {
            // Not okay, we already found a Unicode escape sequence and this
            // conflicts.
            pm_diagnostic_list_append_format(&parser->error_list, source, source + width, PM_ERR_MIXED_ENCODING, parser->encoding->name);
        } else {
            // Should not be anything else.
            assert(false && "unreachable");
        }
    }

    parser->explicit_encoding = parser->encoding;
}

/**
 * This is the default path.
 */
static inline const uint8_t *
pm_strpbrk_utf8(pm_parser_t *parser, const uint8_t *source, const uint8_t *charset, size_t maximum, bool validate) {
    size_t index = 0;

    while (index < maximum) {
        if (strchr((const char *) charset, source[index]) != NULL) {
            return source + index;
        }

        if (source[index] < 0x80) {
            index++;
        } else {
            size_t width = pm_encoding_utf_8_char_width(source + index, (ptrdiff_t) (maximum - index));

            if (width > 0) {
                index += width;
            } else if (!validate) {
                index++;
            } else {
                // At this point we know we have an invalid multibyte character.
                // We'll walk forward as far as we can until we find the next
                // valid character so that we don't spam the user with a ton of
                // the same kind of error.
                const size_t start = index;

                do {
                    index++;
                } while (index < maximum && pm_encoding_utf_8_char_width(source + index, (ptrdiff_t) (maximum - index)) == 0);

                pm_strpbrk_invalid_multibyte_character(parser, source + start, source + index);
            }
        }
    }

    return NULL;
}

/**
 * This is the path when the encoding is ASCII-8BIT.
 */
static inline const uint8_t *
pm_strpbrk_ascii_8bit(pm_parser_t *parser, const uint8_t *source, const uint8_t *charset, size_t maximum, bool validate) {
    size_t index = 0;

    while (index < maximum) {
        if (strchr((const char *) charset, source[index]) != NULL) {
            return source + index;
        }

        if (validate && source[index] >= 0x80) pm_strpbrk_explicit_encoding_set(parser, source, 1);
        index++;
    }

    return NULL;
}

/**
 * This is the slow path that does care about the encoding.
 */
static inline const uint8_t *
pm_strpbrk_multi_byte(pm_parser_t *parser, const uint8_t *source, const uint8_t *charset, size_t maximum, bool validate) {
    size_t index = 0;
    const pm_encoding_t *encoding = parser->encoding;

    while (index < maximum) {
        if (strchr((const char *) charset, source[index]) != NULL) {
            return source + index;
        }

        if (source[index] < 0x80) {
            index++;
        } else {
            size_t width = encoding->char_width(source + index, (ptrdiff_t) (maximum - index));
            if (validate) pm_strpbrk_explicit_encoding_set(parser, source, width);

            if (width > 0) {
                index += width;
            } else if (!validate) {
                index++;
            } else {
                // At this point we know we have an invalid multibyte character.
                // We'll walk forward as far as we can until we find the next
                // valid character so that we don't spam the user with a ton of
                // the same kind of error.
                const size_t start = index;

                do {
                    index++;
                } while (index < maximum && encoding->char_width(source + index, (ptrdiff_t) (maximum - index)) == 0);

                pm_strpbrk_invalid_multibyte_character(parser, source + start, source + index);
            }
        }
    }

    return NULL;
}

/**
 * This is the fast path that does not care about the encoding because we know
 * the encoding only supports single-byte characters.
 */
static inline const uint8_t *
pm_strpbrk_single_byte(pm_parser_t *parser, const uint8_t *source, const uint8_t *charset, size_t maximum, bool validate) {
    size_t index = 0;
    const pm_encoding_t *encoding = parser->encoding;

    while (index < maximum) {
        if (strchr((const char *) charset, source[index]) != NULL) {
            return source + index;
        }

        if (source[index] < 0x80 || !validate) {
            index++;
        } else {
            size_t width = encoding->char_width(source + index, (ptrdiff_t) (maximum - index));
            pm_strpbrk_explicit_encoding_set(parser, source, width);

            if (width > 0) {
                index += width;
            } else {
                // At this point we know we have an invalid multibyte character.
                // We'll walk forward as far as we can until we find the next
                // valid character so that we don't spam the user with a ton of
                // the same kind of error.
                const size_t start = index;

                do {
                    index++;
                } while (index < maximum && encoding->char_width(source + index, (ptrdiff_t) (maximum - index)) == 0);

                pm_strpbrk_invalid_multibyte_character(parser, source + start, source + index);
            }
        }
    }

    return NULL;
}

/**
 * Here we have rolled our own version of strpbrk. The standard library strpbrk
 * has undefined behavior when the source string is not null-terminated. We want
 * to support strings that are not null-terminated because pm_parse does not
 * have the contract that the string is null-terminated. (This is desirable
 * because it means the extension can call pm_parse with the result of a call to
 * mmap).
 *
 * The standard library strpbrk also does not support passing a maximum length
 * to search. We want to support this for the reason mentioned above, but we
 * also don't want it to stop on null bytes. Ruby actually allows null bytes
 * within strings, comments, regular expressions, etc. So we need to be able to
 * skip past them.
 *
 * Finally, we want to support encodings wherein the charset could contain
 * characters that are trailing bytes of multi-byte characters. For example, in
 * Shift_JIS, the backslash character can be a trailing byte. In that case we
 * need to take a slower path and iterate one multi-byte character at a time.
 */
const uint8_t *
pm_strpbrk(pm_parser_t *parser, const uint8_t *source, const uint8_t *charset, ptrdiff_t length, bool validate) {
    if (length <= 0) {
        return NULL;
    } else if (!parser->encoding_changed) {
        return pm_strpbrk_utf8(parser, source, charset, (size_t) length, validate);
    } else if (parser->encoding == PM_ENCODING_ASCII_8BIT_ENTRY) {
        return pm_strpbrk_ascii_8bit(parser, source, charset, (size_t) length, validate);
    } else if (parser->encoding->multibyte) {
        return pm_strpbrk_multi_byte(parser, source, charset, (size_t) length, validate);
    } else {
        return pm_strpbrk_single_byte(parser, source, charset, (size_t) length, validate);
    }
}
prism-1.5.1/suppressions/000077500000000000000000000000001506127434000154275ustar00rootroot00000000000000prism-1.5.1/suppressions/ruby-3.supp000066400000000000000000000002631506127434000174620ustar00rootroot00000000000000{
  Ripper not freeing strterm in all cases (https://bugs.ruby-lang.org/issues/20521)
  Memcheck:Leak
  ...
  fun:new_strterm
  fun:parse_percent
  ...
  fun:ripper_parse
  ...
}
prism-1.5.1/templates/000077500000000000000000000000001506127434000146505ustar00rootroot00000000000000prism-1.5.1/templates/ext/000077500000000000000000000000001506127434000154505ustar00rootroot00000000000000prism-1.5.1/templates/ext/prism/000077500000000000000000000000001506127434000166025ustar00rootroot00000000000000prism-1.5.1/templates/ext/prism/api_node.c.erb000066400000000000000000000275451506127434000213100ustar00rootroot00000000000000#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
#include "prism/extension.h"

extern VALUE rb_cPrism;
extern VALUE rb_cPrismNode;
extern VALUE rb_cPrismSource;
extern VALUE rb_cPrismToken;
extern VALUE rb_cPrismLocation;

<%- nodes.each do |node| -%>
static VALUE rb_cPrism<%= node.name %>;
<%- end -%>

static VALUE
pm_location_new(const pm_parser_t *parser, const uint8_t *start, const uint8_t *end, VALUE source, bool freeze) {
    if (freeze) {
        VALUE location_argv[] = {
            source,
            LONG2FIX(start - parser->start),
            LONG2FIX(end - start)
        };

        return rb_obj_freeze(rb_class_new_instance(3, location_argv, rb_cPrismLocation));
    } else {
        uint64_t value = ((((uint64_t) (start - parser->start)) << 32) | ((uint32_t) (end - start)));
        return ULL2NUM(value);
    }
}

VALUE
pm_token_new(const pm_parser_t *parser, const pm_token_t *token, rb_encoding *encoding, VALUE source, bool freeze) {
    ID type = rb_intern(pm_token_type_name(token->type));
    VALUE location = pm_location_new(parser, token->start, token->end, source, freeze);

    VALUE slice = rb_enc_str_new((const char *) token->start, token->end - token->start, encoding);
    if (freeze) rb_obj_freeze(slice);

    VALUE argv[] = { source, ID2SYM(type), slice, location };
    VALUE value = rb_class_new_instance(4, argv, rb_cPrismToken);
    if (freeze) rb_obj_freeze(value);

    return value;
}

static VALUE
pm_string_new(const pm_string_t *string, rb_encoding *encoding) {
    return rb_obj_freeze(rb_enc_str_new((const char *) pm_string_source(string), pm_string_length(string), encoding));
}

VALUE
pm_integer_new(const pm_integer_t *integer) {
    VALUE result;
    if (integer->values == NULL) {
        result = UINT2NUM(integer->value);
    } else {
        VALUE string = rb_str_new(NULL, integer->length * 8);
        unsigned char *bytes = (unsigned char *) RSTRING_PTR(string);

        size_t offset = integer->length * 8;
        for (size_t value_index = 0; value_index < integer->length; value_index++) {
            uint32_t value = integer->values[value_index];

            for (int index = 0; index < 8; index++) {
                int byte = (value >> (4 * index)) & 0xf;
                bytes[--offset] = byte < 10 ? byte + '0' : byte - 10 + 'a';
            }
        }

        result = rb_funcall(string, rb_intern("to_i"), 1, UINT2NUM(16));
    }

    if (integer->negative) {
        result = rb_funcall(result, rb_intern("-@"), 0);
    }

    return result;
}

// Create a Prism::Source object from the given parser, after pm_parse() was called.
VALUE
pm_source_new(const pm_parser_t *parser, rb_encoding *encoding, bool freeze) {
    VALUE source_string = rb_enc_str_new((const char *) parser->start, parser->end - parser->start, encoding);

    VALUE offsets = rb_ary_new_capa(parser->newline_list.size);
    for (size_t index = 0; index < parser->newline_list.size; index++) {
        rb_ary_push(offsets, ULONG2NUM(parser->newline_list.offsets[index]));
    }

    if (freeze) {
        rb_obj_freeze(source_string);
        rb_obj_freeze(offsets);
    }

    VALUE source = rb_funcall(rb_cPrismSource, rb_intern("for"), 3, source_string, LONG2NUM(parser->start_line), offsets);
    if (freeze) rb_obj_freeze(source);

    return source;
}

typedef struct pm_node_stack_node {
    struct pm_node_stack_node *prev;
    const pm_node_t *visit;
    bool visited;
} pm_node_stack_node_t;

static void
pm_node_stack_push(pm_node_stack_node_t **stack, const pm_node_t *visit) {
    pm_node_stack_node_t *node = xmalloc(sizeof(pm_node_stack_node_t));
    node->prev = *stack;
    node->visit = visit;
    node->visited = false;
    *stack = node;
}

static const pm_node_t *
pm_node_stack_pop(pm_node_stack_node_t **stack) {
    pm_node_stack_node_t *current = *stack;
    const pm_node_t *visit = current->visit;

    *stack = current->prev;
    xfree(current);

    return visit;
}

VALUE
pm_ast_new(const pm_parser_t *parser, const pm_node_t *node, rb_encoding *encoding, VALUE source, bool freeze) {
    VALUE constants = rb_ary_new_capa(parser->constant_pool.size);

    for (uint32_t index = 0; index < parser->constant_pool.size; index++) {
        pm_constant_t *constant = &parser->constant_pool.constants[index];
        int state = 0;

        VALUE string = rb_enc_str_new((const char *) constant->start, constant->length, encoding);
        VALUE value = rb_protect(rb_str_intern, string, &state);

        if (state != 0) {
            value = ID2SYM(rb_intern_const("?"));
            rb_set_errinfo(Qnil);
        }

        rb_ary_push(constants, value);
    }

    pm_node_stack_node_t *node_stack = NULL;
    pm_node_stack_push(&node_stack, node);
    VALUE value_stack = rb_ary_new();

    while (node_stack != NULL) {
        if (!node_stack->visited) {
            if (node_stack->visit == NULL) {
                pm_node_stack_pop(&node_stack);
                rb_ary_push(value_stack, Qnil);
                continue;
            }

            const pm_node_t *node = node_stack->visit;
            node_stack->visited = true;

            switch (PM_NODE_TYPE(node)) {
                <%- nodes.each do |node| -%>
                <%- if node.fields.any? { |field| [Prism::Template::NodeField, Prism::Template::OptionalNodeField, Prism::Template::NodeListField].include?(field.class) } -%>
#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
                case <%= node.type %>: {
                    pm_<%= node.human %>_t *cast = (pm_<%= node.human %>_t *) node;
                    <%- node.fields.each do |field| -%>
                    <%- case field -%>
                    <%- when Prism::Template::NodeField, Prism::Template::OptionalNodeField -%>
                    pm_node_stack_push(&node_stack, (pm_node_t *) cast-><%= field.name %>);
                    <%- when Prism::Template::NodeListField -%>
                    for (size_t index = 0; index < cast-><%= field.name %>.size; index++) {
                        pm_node_stack_push(&node_stack, (pm_node_t *) cast-><%= field.name %>.nodes[index]);
                    }
                    <%- end -%>
                    <%- end -%>
                    break;
                }
                <%- end -%>
                <%- end -%>
                default:
                    break;
            }
#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
        } else {
            const pm_node_t *node = pm_node_stack_pop(&node_stack);

            switch (PM_NODE_TYPE(node)) {
                <%- nodes.each do |node| -%>
#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
                case <%= node.type %>: {
                    <%- if node.fields.any? { |field| ![Prism::Template::NodeField, Prism::Template::OptionalNodeField].include?(field.class) } -%>
                    pm_<%= node.human %>_t *cast = (pm_<%= node.human %>_t *) node;
                    <%- end -%>
                    VALUE argv[<%= node.fields.length + 4 %>];

                    // source
                    argv[0] = source;

                    // node_id
                    argv[1] = ULONG2NUM(node->node_id);

                    // location
                    argv[2] = pm_location_new(parser, node->location.start, node->location.end, source, freeze);

                    // flags
                    argv[3] = ULONG2NUM(node->flags);
                    <%- node.fields.each.with_index(4) do |field, index| -%>

                    // <%= field.name %>
                    <%- case field -%>
                    <%- when Prism::Template::NodeField, Prism::Template::OptionalNodeField -%>
#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
                    argv[<%= index %>] = rb_ary_pop(value_stack);
                    <%- when Prism::Template::NodeListField -%>
#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
                    argv[<%= index %>] = rb_ary_new_capa(cast-><%= field.name %>.size);
                    for (size_t index = 0; index < cast-><%= field.name %>.size; index++) {
                        rb_ary_push(argv[<%= index %>], rb_ary_pop(value_stack));
                    }
                    if (freeze) rb_obj_freeze(argv[<%= index %>]);
                    <%- when Prism::Template::StringField -%>
#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
                    argv[<%= index %>] = pm_string_new(&cast-><%= field.name %>, encoding);
                    <%- when Prism::Template::ConstantField -%>
#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
                    assert(cast-><%= field.name %> != 0);
                    argv[<%= index %>] = RARRAY_AREF(constants, cast-><%= field.name %> - 1);
                    <%- when Prism::Template::OptionalConstantField -%>
                    argv[<%= index %>] = cast-><%= field.name %> == 0 ? Qnil : RARRAY_AREF(constants, cast-><%= field.name %> - 1);
                    <%- when Prism::Template::ConstantListField -%>
#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
                    argv[<%= index %>] = rb_ary_new_capa(cast-><%= field.name %>.size);
                    for (size_t index = 0; index < cast-><%= field.name %>.size; index++) {
                        assert(cast-><%= field.name %>.ids[index] != 0);
                        rb_ary_push(argv[<%= index %>], RARRAY_AREF(constants, cast-><%= field.name %>.ids[index] - 1));
                    }
                    if (freeze) rb_obj_freeze(argv[<%= index %>]);
                    <%- when Prism::Template::LocationField -%>
#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
                    argv[<%= index %>] = pm_location_new(parser, cast-><%= field.name %>.start, cast-><%= field.name %>.end, source, freeze);
                    <%- when Prism::Template::OptionalLocationField -%>
#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
                    argv[<%= index %>] = cast-><%= field.name %>.start == NULL ? Qnil : pm_location_new(parser, cast-><%= field.name %>.start, cast-><%= field.name %>.end, source, freeze);
                    <%- when Prism::Template::UInt8Field -%>
#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
                    argv[<%= index %>] = UINT2NUM(cast-><%= field.name %>);
                    <%- when Prism::Template::UInt32Field -%>
#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
                    argv[<%= index %>] = ULONG2NUM(cast-><%= field.name %>);
                    <%- when Prism::Template::IntegerField -%>
#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
                    argv[<%= index %>] = pm_integer_new(&cast-><%= field.name %>);
                    <%- when Prism::Template::DoubleField -%>
#line <%= __LINE__ + 1 %> "prism/templates/ext/prism/<%= File.basename(__FILE__) %>"
                    argv[<%= index %>] = DBL2NUM(cast-><%= field.name %>);
                    <%- else -%>
                    <%- raise -%>
                    <%- end -%>
                    <%- end -%>

                    VALUE value = rb_class_new_instance(<%= node.fields.length + 4 %>, argv, rb_cPrism<%= node.name %>);
                    if (freeze) rb_obj_freeze(value);

                    rb_ary_push(value_stack, value);
                    break;
                }
                <%- end -%>
                default:
                    rb_raise(rb_eRuntimeError, "unknown node type: %d", PM_NODE_TYPE(node));
            }
        }
    }

    return rb_ary_pop(value_stack);
}

void
Init_prism_api_node(void) {
    <%- nodes.each do |node| -%>
    rb_cPrism<%= node.name %> = rb_define_class_under(rb_cPrism, "<%= node.name %>", rb_cPrismNode);
    <%- end -%>
}
prism-1.5.1/templates/include/000077500000000000000000000000001506127434000162735ustar00rootroot00000000000000prism-1.5.1/templates/include/prism/000077500000000000000000000000001506127434000174255ustar00rootroot00000000000000prism-1.5.1/templates/include/prism/ast.h.erb000066400000000000000000000144721506127434000211440ustar00rootroot00000000000000/**
 * @file ast.h
 *
 * The abstract syntax tree.
 *
 * --
 */
#ifndef PRISM_AST_H
#define PRISM_AST_H

#include "prism/defines.h"
#include "prism/util/pm_constant_pool.h"
#include "prism/util/pm_integer.h"
#include "prism/util/pm_string.h"

#include 
#include 
#include 

/**
 * This enum represents every type of token in the Ruby source.
 */
typedef enum pm_token_type {
<%- tokens.each do |token| -%>
    /** <%= token.comment %> */
    PM_TOKEN_<%= token.name %><%= " = #{token.value}" if token.value %>,

<%- end -%>
    /** The maximum token value. */
    PM_TOKEN_MAXIMUM,
} pm_token_type_t;

/**
 * This struct represents a token in the Ruby source. We use it to track both
 * type and location information.
 */
typedef struct {
    /** The type of the token. */
    pm_token_type_t type;

    /** A pointer to the start location of the token in the source. */
    const uint8_t *start;

    /** A pointer to the end location of the token in the source. */
    const uint8_t *end;
} pm_token_t;

/**
 * This represents a range of bytes in the source string to which a node or
 * token corresponds.
 */
typedef struct {
    /** A pointer to the start location of the range in the source. */
    const uint8_t *start;

    /** A pointer to the end location of the range in the source. */
    const uint8_t *end;
} pm_location_t;

struct pm_node;

/**
 * A list of nodes in the source, most often used for lists of children.
 */
typedef struct pm_node_list {
    /** The number of nodes in the list. */
    size_t size;

    /** The capacity of the list that has been allocated. */
    size_t capacity;

    /** The nodes in the list. */
    struct pm_node **nodes;
} pm_node_list_t;

/**
 * This enum represents every type of node in the Ruby syntax tree.
 */
enum pm_node_type {
<%- nodes.each_with_index do |node, index| -%>
    /** <%= node.name %> */
    <%= node.type %> = <%= index + 1 %>,

<%- end -%>
    /** A special kind of node used for compilation. */
    PM_SCOPE_NODE
};

/**
 * This is the type of node embedded in the node struct. We explicitly control
 * the size of it here to avoid having the variable-width enum.
 */
typedef uint16_t pm_node_type_t;

/**
 * These are the flags embedded in the node struct. We explicitly control the
 * size of it here to avoid having the variable-width enum.
 */
typedef uint16_t pm_node_flags_t;

/**
 * We store the flags enum in every node in the tree. Some flags are common to
 * all nodes (the ones listed below). Others are specific to certain node types.
 */
static const pm_node_flags_t PM_NODE_FLAG_NEWLINE = 0x1;
static const pm_node_flags_t PM_NODE_FLAG_STATIC_LITERAL = 0x2;

/**
 * Cast the type to an enum to allow the compiler to provide exhaustiveness
 * checking.
 */
#define PM_NODE_TYPE(node) ((enum pm_node_type) (node)->type)

/**
 * Return true if the type of the given node matches the given type.
 */
#define PM_NODE_TYPE_P(node, type) (PM_NODE_TYPE(node) == (type))

/**
 * Return true if the given flag is set on the given node.
 */
#define PM_NODE_FLAG_P(node, flag) ((((pm_node_t *)(node))->flags & (flag)) != 0)

/**
 * This is the base structure that represents a node in the syntax tree. It is
 * embedded into every node type.
 */
typedef struct pm_node {
    /**
     * This represents the type of the node. It somewhat maps to the nodes that
     * existed in the original grammar and ripper, but it's not a 1:1 mapping.
     */
    pm_node_type_t type;

    /**
     * This represents any flags on the node. Some are common to all nodes, and
     * some are specific to the type of node.
     */
    pm_node_flags_t flags;

    /**
     * The unique identifier for this node, which is deterministic based on the
     * source. It is used to identify unique nodes across parses.
     */
    uint32_t node_id;

    /**
     * This is the location of the node in the source. It's a range of bytes
     * containing a start and an end.
     */
    pm_location_t location;
} pm_node_t;
<%- nodes.each do |node| -%>

/**
 * <%= node.name %>
 *
<%- node.each_comment_line do |line| -%>
 *<%= line %>
<%- end -%>
 *
 * Type: ::<%= node.type %>
<% if (node_flags = node.flags) %>
 * Flags (#pm_<%= node_flags.human %>):
<%- node_flags.values.each do |value| -%>
 * * ::PM_<%= node_flags.human.upcase %>_<%= value.name %>
<%- end -%>
<%- end -%>
 *
 * @extends pm_node_t
 */
typedef struct pm_<%= node.human %> {
    /** The embedded base node. */
    pm_node_t base;

<%- node.fields.each do |field| -%>

    /**
     * <%= node.name %>#<%= field.name %>
    <%- if field.comment -%>
     *
    <%- field.each_comment_line do |line| -%>
     *<%= line %>
    <%- end -%>
    <%- end -%>
     */
    <%= case field
    when Prism::Template::NodeField, Prism::Template::OptionalNodeField then "struct #{field.c_type} *#{field.name}"
    when Prism::Template::NodeListField then "struct pm_node_list #{field.name}"
    when Prism::Template::ConstantField, Prism::Template::OptionalConstantField then "pm_constant_id_t #{field.name}"
    when Prism::Template::ConstantListField then "pm_constant_id_list_t #{field.name}"
    when Prism::Template::StringField then "pm_string_t #{field.name}"
    when Prism::Template::LocationField, Prism::Template::OptionalLocationField then "pm_location_t #{field.name}"
    when Prism::Template::UInt8Field then "uint8_t #{field.name}"
    when Prism::Template::UInt32Field then "uint32_t #{field.name}"
    when Prism::Template::IntegerField then "pm_integer_t #{field.name}"
    when Prism::Template::DoubleField then "double #{field.name}"
    else raise field.class.name
    end
    %>;
<%- end -%>
} pm_<%= node.human %>_t;
<%- end -%>
<%- flags.each do |flag| -%>

/**
 * <%= flag.comment %>
 */
typedef enum pm_<%= flag.human %> {
    <%- flag.values.each_with_index do |value, index| -%>
<%= "\n" if index > 0 -%>
    /** <%= value.comment %> */
    PM_<%= flag.human.upcase %>_<%= value.name %> = <%= 1 << (index + Prism::Template::COMMON_FLAGS_COUNT) %>,
    <%- end -%>
} pm_<%= flag.human %>_t;
<%- end -%>

/**
 * When we're serializing to Java, we want to skip serializing the location
 * fields as they won't be used by JRuby or TruffleRuby. This boolean allows us
 * to specify that through the environment. It will never be true except for in
 * those build systems.
 */
#define PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS <%= Prism::Template::SERIALIZE_ONLY_SEMANTICS_FIELDS ? 1 : 0 %>

#endif
prism-1.5.1/templates/include/prism/diagnostic.h.erb000066400000000000000000000067441506127434000225040ustar00rootroot00000000000000/**
 * @file diagnostic.h
 *
 * A list of diagnostics generated during parsing.
 */
#ifndef PRISM_DIAGNOSTIC_H
#define PRISM_DIAGNOSTIC_H

#include "prism/ast.h"
#include "prism/defines.h"
#include "prism/util/pm_list.h"

#include 
#include 
#include 

/**
 * The diagnostic IDs of all of the diagnostics, used to communicate the types
 * of errors between the parser and the user.
 */
typedef enum {
    // These are the error diagnostics.
    <%- errors.each do |error| -%>
    PM_ERR_<%= error.name %>,
    <%- end -%>

    // These are the warning diagnostics.
    <%- warnings.each do |warning| -%>
    PM_WARN_<%= warning.name %>,
    <%- end -%>
} pm_diagnostic_id_t;

/**
 * This struct represents a diagnostic generated during parsing.
 *
 * @extends pm_list_node_t
 */
typedef struct {
    /** The embedded base node. */
    pm_list_node_t node;

    /** The location of the diagnostic in the source. */
    pm_location_t location;

    /** The ID of the diagnostic. */
    pm_diagnostic_id_t diag_id;

    /** The message associated with the diagnostic. */
    const char *message;

    /**
     * Whether or not the memory related to the message of this diagnostic is
     * owned by this diagnostic. If it is, it needs to be freed when the
     * diagnostic is freed.
     */
    bool owned;

    /**
     * The level of the diagnostic, see `pm_error_level_t` and
     * `pm_warning_level_t` for possible values.
     */
    uint8_t level;
} pm_diagnostic_t;

/**
 * The levels of errors generated during parsing.
 */
typedef enum {
    /** For errors that should raise a syntax error. */
    PM_ERROR_LEVEL_SYNTAX = 0,

    /** For errors that should raise an argument error. */
    PM_ERROR_LEVEL_ARGUMENT = 1,

    /** For errors that should raise a load error. */
    PM_ERROR_LEVEL_LOAD = 2
} pm_error_level_t;

/**
 * The levels of warnings generated during parsing.
 */
typedef enum {
    /** For warnings which should be emitted if $VERBOSE != nil. */
    PM_WARNING_LEVEL_DEFAULT = 0,

    /** For warnings which should be emitted if $VERBOSE == true. */
    PM_WARNING_LEVEL_VERBOSE = 1
} pm_warning_level_t;

/**
 * Get the human-readable name of the given diagnostic ID.
 *
 * @param diag_id The diagnostic ID.
 * @return The human-readable name of the diagnostic ID.
 */
const char * pm_diagnostic_id_human(pm_diagnostic_id_t diag_id);

/**
 * Append a diagnostic to the given list of diagnostics that is using shared
 * memory for its message.
 *
 * @param list The list to append to.
 * @param start The start of the diagnostic.
 * @param end The end of the diagnostic.
 * @param diag_id The diagnostic ID.
 * @return Whether the diagnostic was successfully appended.
 */
bool pm_diagnostic_list_append(pm_list_t *list, const uint8_t *start, const uint8_t *end, pm_diagnostic_id_t diag_id);

/**
 * Append a diagnostic to the given list of diagnostics that is using a format
 * string for its message.
 *
 * @param list The list to append to.
 * @param start The start of the diagnostic.
 * @param end The end of the diagnostic.
 * @param diag_id The diagnostic ID.
 * @param ... The arguments to the format string for the message.
 * @return Whether the diagnostic was successfully appended.
 */
bool pm_diagnostic_list_append_format(pm_list_t *list, const uint8_t *start, const uint8_t *end, pm_diagnostic_id_t diag_id, ...);

/**
 * Deallocate the internal state of the given diagnostic list.
 *
 * @param list The list to deallocate.
 */
void pm_diagnostic_list_free(pm_list_t *list);

#endif
prism-1.5.1/templates/java/000077500000000000000000000000001506127434000155715ustar00rootroot00000000000000prism-1.5.1/templates/java/org/000077500000000000000000000000001506127434000163605ustar00rootroot00000000000000prism-1.5.1/templates/java/org/prism/000077500000000000000000000000001506127434000175125ustar00rootroot00000000000000prism-1.5.1/templates/java/org/prism/AbstractNodeVisitor.java.erb000066400000000000000000000010031506127434000250470ustar00rootroot00000000000000package org.prism;

// GENERATED BY <%= File.basename(__FILE__) %>
// @formatter:off
public abstract class AbstractNodeVisitor {

    protected abstract T defaultVisit(Nodes.Node node);

    <%- nodes.each do |node| -%>
    /**
     * Visit a <%= node.name %> node.
     *
     * @param node The node to visit.
     * @return The result of visiting the node.
     */
    public T visit<%= node.name -%>(Nodes.<%= node.name -%> node) {
        return defaultVisit(node);
    }

    <%- end -%>
}
// @formatter:on
prism-1.5.1/templates/java/org/prism/Loader.java.erb000066400000000000000000000367451506127434000223510ustar00rootroot00000000000000<%- string_type = Prism::Template::JAVA_STRING_TYPE -%>
package org.prism;

import org.prism.Nodes;

import java.lang.Short;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Locale;

// GENERATED BY <%= File.basename(__FILE__) %>
// @formatter:off
public class Loader {

    public static ParseResult load(byte[] serialized, byte[] sourceBytes) {
        return new Loader(serialized, sourceBytes).load();
    }

    // Overridable methods

    public Charset getEncodingCharset(String encodingName) {
        encodingName = encodingName.toLowerCase(Locale.ROOT);
        if (encodingName.equals("ascii-8bit")) {
            return StandardCharsets.US_ASCII;
        }
        return Charset.forName(encodingName);
    }

    public <%= string_type %> bytesToName(byte[] bytes) {
        <%- if string_type == "String" -%>
        return new String(bytes, encodingCharset).intern();
        <%- else -%>
        return null; // Must be implemented by subclassing Loader
        <%- end -%>
    }

    private static final class ConstantPool {

        private final Loader loader;
        private final byte[] source;
        private final int bufferOffset;
        private final <%= string_type %>[] cache;

        ConstantPool(Loader loader, byte[] source, int bufferOffset, int length) {
            this.loader = loader;
            this.source = source;
            this.bufferOffset = bufferOffset;
            cache = new <%= string_type %>[length];
        }

        <%= string_type %> get(ByteBuffer buffer, int oneBasedIndex) {
            int index = oneBasedIndex - 1;
            <%= string_type %> constant = cache[index];

            if (constant == null) {
                int offset = bufferOffset + index * 8;
                int start = buffer.getInt(offset);
                int length = buffer.getInt(offset + 4);

                byte[] bytes = new byte[length];

                if (Integer.compareUnsigned(start, 0x7FFFFFFF) <= 0) {
                    System.arraycopy(source, start, bytes, 0, length);
                } else {
                    int position = buffer.position();
                    buffer.position(start & 0x7FFFFFFF);
                    buffer.get(bytes, 0, length);
                    buffer.position(position);
                }

                constant = loader.bytesToName(bytes);
                cache[index] = constant;
            }

            return constant;
        }

    }

    private final ByteBuffer buffer;
    private final Nodes.Source source;
    protected String encodingName;
    <%- if string_type == "String" -%>
    private Charset encodingCharset;
    <%- end -%>
    private ConstantPool constantPool;

    protected Loader(byte[] serialized, byte[] sourceBytes) {
        this.buffer = ByteBuffer.wrap(serialized).order(ByteOrder.nativeOrder());
        this.source = new Nodes.Source(sourceBytes);
    }

    protected ParseResult load() {
        expect((byte) 'P', "incorrect prism header");
        expect((byte) 'R', "incorrect prism header");
        expect((byte) 'I', "incorrect prism header");
        expect((byte) 'S', "incorrect prism header");
        expect((byte) 'M', "incorrect prism header");

        expect((byte) 1, "prism major version does not match");
        expect((byte) 5, "prism minor version does not match");
        expect((byte) 1, "prism patch version does not match");

        expect((byte) 1, "Loader.java requires no location fields in the serialized output");

        // This loads the name of the encoding.
        int encodingLength = loadVarUInt();
        byte[] encodingNameBytes = new byte[encodingLength];
        buffer.get(encodingNameBytes);
        this.encodingName = new String(encodingNameBytes, StandardCharsets.US_ASCII);
        <%- if string_type == "String" -%>
        this.encodingCharset = getEncodingCharset(this.encodingName);
        <%- end -%>

        source.setStartLine(loadVarSInt());
        source.setLineOffsets(loadLineOffsets());

        ParseResult.MagicComment[] magicComments = loadMagicComments();
        Nodes.Location dataLocation = loadOptionalLocation();
        ParseResult.Error[] errors = loadErrors();
        ParseResult.Warning[] warnings = loadWarnings();

        int constantPoolBufferOffset = buffer.getInt();
        int constantPoolLength = loadVarUInt();
        this.constantPool = new ConstantPool(this, source.bytes, constantPoolBufferOffset, constantPoolLength);

        Nodes.Node node;
        if (errors.length == 0) {
            node = loadNode();

            int left = constantPoolBufferOffset - buffer.position();
            if (left != 0) {
                throw new Error("Expected to consume all bytes while deserializing but there were " + left + " bytes left");
            }

            boolean[] newlineMarked = new boolean[1 + source.getLineCount()];
            MarkNewlinesVisitor visitor = new MarkNewlinesVisitor(source, newlineMarked);
            node.accept(visitor);
        } else {
            node = null;
        }

        return new ParseResult(node, magicComments, dataLocation, errors, warnings, source);
    }

    private byte[] loadEmbeddedString() {
        int length = loadVarUInt();
        byte[] bytes = new byte[length];
        buffer.get(bytes);
        return bytes;
    }

    private byte[] loadString() {
        switch (buffer.get()) {
            case 1:
                int start = loadVarUInt();
                int length = loadVarUInt();
                byte[] bytes = new byte[length];
                System.arraycopy(source.bytes, start, bytes, 0, length);
                return bytes;
            case 2:
                return loadEmbeddedString();
            default:
                throw new Error("Expected 0 or 1 but was " + buffer.get());
        }
    }

    private int[] loadLineOffsets() {
        int count = loadVarUInt();
        int[] lineOffsets = new int[count];
        for (int i = 0; i < count; i++) {
            lineOffsets[i] = loadVarUInt();
        }
        return lineOffsets;
    }

    private ParseResult.MagicComment[] loadMagicComments() {
        int count = loadVarUInt();
        ParseResult.MagicComment[] magicComments = new ParseResult.MagicComment[count];

        for (int i = 0; i < count; i++) {
            Nodes.Location keyLocation = loadLocation();
            Nodes.Location valueLocation = loadLocation();

            ParseResult.MagicComment magicComment = new ParseResult.MagicComment(keyLocation, valueLocation);
            magicComments[i] = magicComment;
        }

        return magicComments;
    }

    private ParseResult.Error[] loadErrors() {
        int count = loadVarUInt();
        ParseResult.Error[] errors = new ParseResult.Error[count];

        // error messages only contain ASCII characters
        for (int i = 0; i < count; i++) {
            Nodes.ErrorType type = Nodes.ERROR_TYPES[loadVarUInt()];
            byte[] bytes = loadEmbeddedString();
            String message = new String(bytes, StandardCharsets.US_ASCII);
            Nodes.Location location = loadLocation();
            ParseResult.ErrorLevel level = ParseResult.ERROR_LEVELS[buffer.get()];

            ParseResult.Error error = new ParseResult.Error(type, message, location, level);
            errors[i] = error;
        }

        return errors;
    }

    private ParseResult.Warning[] loadWarnings() {
        int count = loadVarUInt();
        ParseResult.Warning[] warnings = new ParseResult.Warning[count];

        // warning messages only contain ASCII characters
        for (int i = 0; i < count; i++) {
            Nodes.WarningType type = Nodes.WARNING_TYPES[loadVarUInt() - <%= errors.length %>];
            byte[] bytes = loadEmbeddedString();
            String message = new String(bytes, StandardCharsets.US_ASCII);
            Nodes.Location location = loadLocation();
            ParseResult.WarningLevel level = ParseResult.WARNING_LEVELS[buffer.get()];

            ParseResult.Warning warning = new ParseResult.Warning(type, message, location, level);
            warnings[i] = warning;
        }

        return warnings;
    }

    private Nodes.Node loadOptionalNode() {
        if (buffer.get(buffer.position()) != 0) {
            return loadNode();
        } else {
            buffer.position(buffer.position() + 1); // continue after the 0 byte
            return null;
        }
    }

    private <%= string_type %> loadConstant() {
        return constantPool.get(buffer, loadVarUInt());
    }

    private <%= string_type %> loadOptionalConstant() {
        if (buffer.get(buffer.position()) != 0) {
            return loadConstant();
        } else {
            buffer.position(buffer.position() + 1); // continue after the 0 byte
            return null;
        }
    }

    private <%= string_type %>[] loadConstants() {
        int length = loadVarUInt();
        if (length == 0) {
            return Nodes.EMPTY_STRING_ARRAY;
        }
        <%= string_type %>[] constants = new <%= string_type %>[length];
        for (int i = 0; i < length; i++) {
            constants[i] = constantPool.get(buffer, loadVarUInt());
        }
        return constants;
    }

    private Nodes.Location loadLocation() {
        return new Nodes.Location(loadVarUInt(), loadVarUInt());
    }

    private Nodes.Location loadOptionalLocation() {
        if (buffer.get() != 0) {
            return loadLocation();
        } else {
            return null;
        }
    }

    // From https://github.com/protocolbuffers/protobuf/blob/v23.1/java/core/src/main/java/com/google/protobuf/BinaryReader.java#L1507
    private int loadVarUInt() {
        int x;
        if ((x = buffer.get()) >= 0) {
            return x;
        } else if ((x ^= (buffer.get() << 7)) < 0) {
            x ^= (~0 << 7);
        } else if ((x ^= (buffer.get() << 14)) >= 0) {
            x ^= (~0 << 7) ^ (~0 << 14);
        } else if ((x ^= (buffer.get() << 21)) < 0) {
            x ^= (~0 << 7) ^ (~0 << 14) ^ (~0 << 21);
        } else {
            x ^= buffer.get() << 28;
            x ^= (~0 << 7) ^ (~0 << 14) ^ (~0 << 21) ^ (~0 << 28);
        }
        return x;
    }

    // From https://github.com/protocolbuffers/protobuf/blob/v25.1/java/core/src/main/java/com/google/protobuf/CodedInputStream.java#L508-L510
    private int loadVarSInt() {
        int x = loadVarUInt();
        return (x >>> 1) ^ (-(x & 1));
    }

    private short loadFlags() {
        int flags = loadVarUInt();
        assert flags >= 0 && flags <= Short.MAX_VALUE;
        return (short) flags;
    }

    private static final BigInteger UNSIGNED_LONG_MASK = BigInteger.ONE.shiftLeft(Long.SIZE).subtract(BigInteger.ONE);

    private Object loadInteger() {
        boolean negative = buffer.get() != 0;

        int wordsLength = loadVarUInt();
        assert wordsLength > 0;

        // Load the first word. If it's the only word, then return an int if it
        // fits into one and a long otherwise.
        int firstWord = loadVarUInt();
        if (wordsLength == 1) {
            if (firstWord < 0) {
                if (negative && firstWord == Integer.MIN_VALUE) {
                    return Integer.MIN_VALUE;
                }

                long words = Integer.toUnsignedLong(firstWord);
                return negative ? -words : words;
            }
            return negative ? -firstWord : firstWord;
        }

        // Load the second word. If there are only two words, then return a long
        // if it fits into one and a BigInteger otherwise.
        int secondWord = loadVarUInt();
        if (wordsLength == 2) {
            long words = (((long) secondWord) << 32L) | Integer.toUnsignedLong(firstWord);
            if (words < 0L) {
                if (negative && words == Long.MIN_VALUE) {
                    return Long.MIN_VALUE;
                }

                BigInteger result = BigInteger.valueOf(words).and(UNSIGNED_LONG_MASK);
                return negative ? result.negate() : result;
            }
            return negative ? -words : words;
        }

        // Otherwise, load the remaining words and return a BigInt.
        BigInteger result = BigInteger.valueOf(Integer.toUnsignedLong(firstWord));
        result = result.or(BigInteger.valueOf(Integer.toUnsignedLong(secondWord)).shiftLeft(32));

        for (int wordsIndex = 2; wordsIndex < wordsLength; wordsIndex++) {
            result = result.or(BigInteger.valueOf(Integer.toUnsignedLong(loadVarUInt())).shiftLeft(wordsIndex * 32));
        }

        return negative ? result.negate() : result;
    }

    private Nodes.Node loadNode() {
        int type = buffer.get() & 0xFF;
        <%- if Prism::Template::INCLUDE_NODE_ID -%>
        int nodeId = loadVarUInt();
        <%- end -%>
        int startOffset = loadVarUInt();
        int length = loadVarUInt();

        switch (type) {
            <%- array_types = [] -%>
            <%- nodes.each_with_index do |node, index| -%>
            case <%= index + 1 %>:
            <%-
            params = []
            params << "nodeId" if Prism::Template::INCLUDE_NODE_ID
            params << "startOffset" << "length"
            params << "buffer.getInt()" if node.needs_serialized_length?
            params << "loadFlags()" if node.flags
            params.concat node.semantic_fields.map { |field|
              case field
              when Prism::Template::NodeField then "#{field.java_cast}loadNode()"
              when Prism::Template::OptionalNodeField then "#{field.java_cast}loadOptionalNode()"
              when Prism::Template::StringField then "loadString()"
              when Prism::Template::NodeListField then
                element_type = field.java_type.sub('[]', '')
                array_types << element_type
                "load#{element_type}s()"
              when Prism::Template::ConstantField then "loadConstant()"
              when Prism::Template::OptionalConstantField then "loadOptionalConstant()"
              when Prism::Template::ConstantListField then "loadConstants()"
              when Prism::Template::LocationField then "loadLocation()"
              when Prism::Template::OptionalLocationField then "loadOptionalLocation()"
              when Prism::Template::UInt8Field then "buffer.get()"
              when Prism::Template::UInt32Field then "loadVarUInt()"
              when Prism::Template::IntegerField then "loadInteger()"
              when Prism::Template::DoubleField then "buffer.getDouble()"
              else raise
              end
            }
            -%>
                return new Nodes.<%= node.name %>(<%= params.join(", ") -%>);
            <%- end -%>
            default:
                throw new Error("Unknown node type: " + type);
        }
    }
    <%- array_types.uniq.each do |type| -%>

    private static final Nodes.<%= type %>[] EMPTY_<%= type %>_ARRAY = {};

    private Nodes.<%= type %>[] load<%= type %>s() {
        int length = loadVarUInt();
        if (length == 0) {
            return EMPTY_<%= type %>_ARRAY;
        }
        Nodes.<%= type %>[] nodes = new Nodes.<%= type %>[length];
        for (int i = 0; i < length; i++) {
            <%- if type == 'Node' -%>
            nodes[i] = loadNode();
            <%- else -%>
            nodes[i] = (Nodes.<%= type %>) loadNode();
            <%- end -%>
        }
        return nodes;
    }
    <%- end -%>

    private void expect(byte value, String error) {
        byte b = buffer.get();
        if (b != value) {
            throw new Error("Deserialization error: " + error + " (expected " + value + " but was " + b + " at position " + buffer.position() + ")");
        }
    }

}
// @formatter:on
prism-1.5.1/templates/java/org/prism/Nodes.java.erb000066400000000000000000000333011506127434000221740ustar00rootroot00000000000000<%- string_type = Prism::Template::JAVA_STRING_TYPE -%>
package org.prism;

import java.lang.Override;
import java.lang.String;
import java.lang.StringBuilder;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;

// GENERATED BY <%= File.basename(__FILE__) %>
// @formatter:off
public abstract class Nodes {

    public static final <%= string_type %>[] EMPTY_STRING_ARRAY = {};

    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.SOURCE)
    public @interface Nullable {
    }

    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.SOURCE)
    public @interface UnionType {
        Class[] value();
    }

    public static final class Location {

        public static final Location[] EMPTY_ARRAY = {};

        public final int startOffset;
        public final int length;

        public Location(int startOffset, int length) {
            this.startOffset = startOffset;
            this.length = length;
        }

        public int endOffset() {
            return startOffset + length;
        }
    }

    public static final class Source {
        public final byte[] bytes;
        private int startLine = 1;
        private int[] lineOffsets = null;

        Source(byte[] bytes) {
          this.bytes = bytes;
        }

        void setStartLine(int startLine) {
            this.startLine = startLine;
        }

        void setLineOffsets(int[] lineOffsets) {
            this.lineOffsets = lineOffsets;
        }

        // 1-based
        public int line(int byteOffset) {
            return startLine + findLine(byteOffset);
        }

        // 0-based
        public int findLine(int byteOffset) {
            if (byteOffset >= bytes.length) byteOffset = bytes.length - 1;
            assert byteOffset >= 0 : byteOffset;
            int index = Arrays.binarySearch(lineOffsets, byteOffset);
            int line;
            if (index < 0) {
                line = -index - 2;
            } else {
                line = index;
            }
            assert line >= 0 && line <= getLineCount() : line;
            return line;
        }

        public int getLineCount() {
            return lineOffsets.length;
        }
    }

    public static abstract class Node {

        public static final Node[] EMPTY_ARRAY = {};

        <%- if Prism::Template::INCLUDE_NODE_ID -%>
        public final int nodeId;
        <%- end -%>
        public final int startOffset;
        public final int length;
        private boolean newLineFlag = false;

        <%- if Prism::Template::INCLUDE_NODE_ID -%>
        public Node(int nodeId, int startOffset, int length) {
            this.nodeId = nodeId;
        <%- else -%>
        public Node(int startOffset, int length) {
        <%- end -%>
            this.startOffset = startOffset;
            this.length = length;
        }

        public final int endOffset() {
            return startOffset + length;
        }

        public final boolean hasNewLineFlag() {
            return newLineFlag;
        }

        public void setNewLineFlag(Source source, boolean[] newlineMarked) {
            int line = source.findLine(this.startOffset);
            if (!newlineMarked[line]) {
                newlineMarked[line] = true;
                this.newLineFlag = true;
            }
        }

        public void setNewLineFlag(boolean newLineFlag) {
            this.newLineFlag = newLineFlag;
        }

        public abstract  T accept(AbstractNodeVisitor visitor);

        public abstract  void visitChildNodes(AbstractNodeVisitor visitor);

        public abstract Node[] childNodes();

        @Override
        public String toString() {
            return toString("");
        }

        protected abstract String toString(String indent);
    }
<%# FLAGS -%>
    <%- flags.each do |flag| -%>

    /**
     * <%= Prism::Template::JavaDoc.escape(flag.comment) %>
     */
    public static final class <%= flag.name %> implements Comparable<<%= flag.name %>> {
        <%- flag.values.each_with_index do |value, index| -%>

        // <%= value.comment %>
        public static final short <%= value.name %> = 1 << <%= index + Prism::Template::COMMON_FLAGS_COUNT %>;
        <%- end -%>

        <%- flag.values.each do |value| -%>
        public static boolean is<%= value.camelcase %>(short flags) {
            return (flags & <%= value.name %>) != 0;
        }

        <%- end -%>
        private final short flags;

        public <%= flag.name %>(short flags) {
            this.flags = flags;
        }

        @Override
        public int hashCode() {
            return flags;
        }

        @Override
        public boolean equals(Object other) {
            if (!(other instanceof <%= flag.name %>)) {
                return false;
            }

            return flags == ((<%= flag.name %>) other).flags;
        }

        @Override
        public int compareTo(<%= flag.name %> other) {
            return flags - other.flags;
        }

        <%- flag.values.each do |value| -%>
        public boolean is<%= value.camelcase %>() {
            return (flags & <%= value.name %>) != 0;
        }

        <%- end -%>
    }
<%- end -%>
<%# NODES -%>
    <%- nodes.each do |node| -%>

    /**
     * 
    <%- node.each_comment_java_line do |line| -%>
     *<%= line %>
    <%- end -%>
     * 

     */
    public static final class <%= node.name -%> extends Node {
        <%- if node.needs_serialized_length? -%>
        public final int serializedLength;
        <%- end -%>
        <%- if node.flags -%>
        public final short flags;
        <%- end -%>
        <%- node.semantic_fields.each do |field| -%>
        <%- if field.comment -%>
        /**
         * 
        <%- field.each_comment_java_line do |line| -%>
         *<%= line %>
        <%- end -%>
         * 

         */
        <%- end -%>
        <%- if field.class.name.include?("Optional") -%>
        @Nullable
        <%- end -%>
        <%- if field.respond_to?(:union_kind) && field.union_kind -%>
        @UnionType({ <%= field.union_kind.map { |t| "#{t}.class" }.join(", ") %> })
        <%- end -%>
        public final <%= field.java_type %> <%= field.name %>;
        <%- end -%>

        <%-
          params = []
          params << "int nodeId" if Prism::Template::INCLUDE_NODE_ID
          params << "int startOffset" << "int length"
          params << "int serializedLength" if node.needs_serialized_length?
          params << "short flags" if node.flags
          params.concat(node.semantic_fields.map { |field| "#{field.java_type} #{field.name}" })
        -%>
        public <%= node.name -%>(<%= params.join(", ") %>) {
        <%- if Prism::Template::INCLUDE_NODE_ID -%>
            super(nodeId, startOffset, length);
        <%- else -%>
            super(startOffset, length);
        <%- end -%>
        <%- if node.needs_serialized_length? -%>
            this.serializedLength = serializedLength;
        <%- end -%>
        <%- if node.flags -%>
            this.flags = flags;
        <%- end -%>
        <%- node.semantic_fields.each do |field| -%>
            this.<%= field.name %> = <%= field.name %>;
        <%- end -%>
        }
        <%# methods for flags -%>
        <%- if (node_flags = node.flags) -%>
        <%- node_flags.values.each do |value| -%>

        public boolean is<%= value.camelcase %>() {
            return <%= node_flags.name %>.is<%= value.camelcase %>(flags);
        }
        <%- end -%>
        <%- end -%>
        <%# potential override of setNewLineFlag() -%>
        <%- if node.newline == false -%>

        @Override
        public void setNewLineFlag(Source source, boolean[] newlineMarked) {
            // Never mark <%= node.name %> with a newline flag, mark children instead
        }
        <%- elsif node.newline.is_a?(String) -%>

        @Override
        public void setNewLineFlag(Source source, boolean[] newlineMarked) {
          <%- field = node.semantic_fields.find { |f| f.name == node.newline } or raise node.newline -%>
          <%- case field -%>
          <%- when Prism::Template::NodeField -%>
            this.<%= field.name %>.setNewLineFlag(source, newlineMarked);
          <%- when Prism::Template::NodeListField -%>
            Node first = this.<%= field.name %>.length > 0 ? this.<%= field.name %>[0] : null;
            if (first != null) {
                first.setNewLineFlag(source, newlineMarked);
            }
          <%- else raise field.class.name -%>
          <%- end -%>
        }
        <%- end -%>

        public  void visitChildNodes(AbstractNodeVisitor visitor) {
          <%- node.semantic_fields.each do |field| -%>
            <%- case field -%>
            <%- when Prism::Template::NodeListField -%>
            for (Nodes.Node child : this.<%= field.name %>) {
                child.accept(visitor);
            }
            <%- when Prism::Template::NodeField -%>
            this.<%= field.name %>.accept(visitor);
            <%- when Prism::Template::OptionalNodeField -%>
            if (this.<%= field.name %> != null) {
                this.<%= field.name %>.accept(visitor);
            }
            <%- end -%>
          <%- end -%>
        }

        public Node[] childNodes() {
          <%- if node.semantic_fields.none?(Prism::Template::NodeListField) and node.semantic_fields.none?(Prism::Template::NodeKindField) -%>
            return EMPTY_ARRAY;
          <%- elsif node.semantic_fields.one?(Prism::Template::NodeListField) and node.semantic_fields.none?(Prism::Template::NodeKindField) -%>
            return this.<%= node.semantic_fields.grep(Prism::Template::NodeListField).first.name %>;
          <%- elsif node.semantic_fields.none?(Prism::Template::NodeListField) -%>
            return new Node[] { <%= node.semantic_fields.grep(Prism::Template::NodeKindField).map { |field| "this.#{field.name}" }.join(', ') %> };
          <%- else -%>
            ArrayList childNodes = new ArrayList<>();
            <%- node.semantic_fields.each do |field| -%>
              <%- case field -%>
              <%- when Prism::Template::NodeField, Prism::Template::OptionalNodeField -%>
            childNodes.add(this.<%= field.name %>);
              <%- when Prism::Template::NodeListField -%>
            childNodes.addAll(Arrays.asList(this.<%= field.name %>));
              <%- end -%>
            <%- end -%>
            return childNodes.toArray(EMPTY_ARRAY);
          <%- end -%>
        }

        public  T accept(AbstractNodeVisitor visitor) {
            return visitor.visit<%= node.name -%>(this);
        }

        @Override
        protected String toString(String indent) {
            StringBuilder builder = new StringBuilder();
            builder.append(this.getClass().getSimpleName());
            if (hasNewLineFlag()) {
                builder.append("[Li]");
            }
            builder.append('\n');
            String nextIndent = indent + "  ";
            <%- if node.fields.any?(Prism::Template::NodeListField) or node.fields.any?(Prism::Template::ConstantListField) -%>
            String nextNextIndent = nextIndent + "  ";
            <%- end -%>
            <%- [*node.flags, *node.fields.grep_v(Prism::Template::LocationField).grep_v(Prism::Template::OptionalLocationField)].each do |field| -%>
            builder.append(nextIndent);
            builder.append("<%= field.name %>: ");
            <%- case field -%>
            <%- when Prism::Template::NodeField -%>
            builder.append(this.<%= field.name %>.toString(nextIndent));
            <%- when Prism::Template::OptionalNodeField -%>
            builder.append(this.<%= field.name %> == null ? "null\n" : this.<%= field.name %>.toString(nextIndent));
            <%- when Prism::Template::NodeListField -%>
            builder.append('\n');
            for (Node child : this.<%= field.name %>) {
                builder.append(nextNextIndent).append(child.toString(nextNextIndent));
            }
            <%- when Prism::Template::StringField -%>
            builder.append('"' + new String(this.<%= field.name %>, StandardCharsets.UTF_8) + '"');
            builder.append('\n');
            <%- when Prism::Template::ConstantField -%>
            builder.append('"').append(this.<%= field.name %>).append('"');
            builder.append('\n');
            <%- when Prism::Template::OptionalConstantField -%>
            builder.append(this.<%= field.name %> == null ? "null" : "\"" + this.<%= field.name %> + "\"");
            builder.append('\n');
            <%- when Prism::Template::ConstantListField -%>
            builder.append('\n');
            for (<%= string_type %> constant : this.<%= field.name %>) {
                builder.append(nextNextIndent).append('"').append(constant).append('"').append('\n');
            }
            <%- when Prism::Template::Flags -%>
            builder.append(flags);
            builder.append('\n');
            <%- when Prism::Template::UInt8Field, Prism::Template::UInt32Field, Prism::Template::IntegerField, Prism::Template::DoubleField -%>
            builder.append(this.<%= field.name %>);
            builder.append('\n');
            <%- else -%>
            <%- raise field.class.name -%>
            <%- end -%>
            <%- end -%>
            return builder.toString();
        }
    }
    <%- end -%>

    public enum ErrorType {
        <%- errors.each do |error| -%>
        <%= error.name %>,
        <%- end -%>
    }

    public static ErrorType[] ERROR_TYPES = ErrorType.values();

    public enum WarningType {
        <%- warnings.each do |warning| -%>
        <%= warning.name %>,
        <%- end -%>
    }

    public static WarningType[] WARNING_TYPES = WarningType.values();
}
// @formatter:on
prism-1.5.1/templates/javascript/000077500000000000000000000000001506127434000170165ustar00rootroot00000000000000prism-1.5.1/templates/javascript/src/000077500000000000000000000000001506127434000176055ustar00rootroot00000000000000prism-1.5.1/templates/javascript/src/deserialize.js.erb000066400000000000000000000275221506127434000232220ustar00rootroot00000000000000import * as nodes from "./nodes.js";

const MAJOR_VERSION = 1;
const MINOR_VERSION = 5;
const PATCH_VERSION = 1;

// The DataView getFloat64 function takes an optional second argument that
// specifies whether the number is little-endian or big-endian. It does not
// appear to have a native endian mode, so we need to determine the endianness
// of the system at runtime.
const LITTLE_ENDIAN = (() => {
  let uint32 = new Uint32Array([0x11223344]);
  let uint8 = new Uint8Array(uint32.buffer);

  if (uint8[0] === 0x44) {
    return true;
  } else if (uInt8[0] === 0x11) {
    return false;
  } else {
    throw new Error("Mixed endianness");
  }
})();

class SerializationBuffer {
  FORCED_UTF8_ENCODING_FLAG = 1 << 2;
  FORCED_BINARY_ENCODING_FLAG = 1 << 3;

  DECODER_MAP = new Map([
    ["ascii-8bit", "ascii"]
  ]);

  constructor(source, array) {
    this.source = source;
    this.array = array;
    this.index = 0;
    this.fileEncoding = "utf-8";
    this.decoders = new Map();
  }

  readByte() {
    const result = this.array[this.index];
    this.index += 1;
    return result;
  }

  readBytes(length) {
    const result = this.array.slice(this.index, this.index + length);
    this.index += length;
    return result;
  }

  readString(length, flags) {
    return this.decodeString(this.readBytes(length), flags).value;
  }

  // Read a 32-bit unsigned integer in little-endian format.
  readUint32() {
    const result = this.scanUint32(this.index);
    this.index += 4;
    return result;
  }

  scanUint32(offset) {
    const bytes = this.array.slice(offset, offset + 4);
    return bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24);
  }

  readVarInt() {
    let result = 0;
    let shift = 0;

    while (true) {
      const byte = this.readByte();
      result += (byte & 0x7f) << shift;
      shift += 7;

      if ((byte & 0x80) === 0) {
        break;
      }
    }

    return result;
  }

  readLocation() {
    return { startOffset: this.readVarInt(), length: this.readVarInt() };
  }

  readOptionalLocation() {
    if (this.readByte() != 0) {
      return this.readLocation();
    } else {
      return null;
    }
  }

  readStringField(flags) {
    if (flags === undefined) flags = 0;
    const type = this.readByte();

    switch (type) {
      case 1: {
        const startOffset = this.readVarInt();
        const length = this.readVarInt();
        return this.decodeString(this.source.slice(startOffset, startOffset + length), flags);
      }
      case 2:
        return this.decodeString(this.readBytes(this.readVarInt()), flags);
      default:
        throw new Error(`Unknown serialized string type: ${type}`);
    }
  }

  scanConstant(constantPoolOffset, constantIndex) {
    const offset = constantPoolOffset + constantIndex * 8;
    let startOffset = this.scanUint32(offset);
    const length = this.scanUint32(offset + 4);

    if (startOffset & (1 << 31)) {
      startOffset &= (1 << 31) - 1;
      return new TextDecoder().decode(this.array.slice(startOffset, startOffset + length));
    } else {
      return new TextDecoder().decode(this.source.slice(startOffset, startOffset + length));
    }
  }

  readDouble() {
    const view = new DataView(new ArrayBuffer(8));
    for (let index = 0; index < 8; index++) {
      view.setUint8(index, this.readByte());
    }

    return view.getFloat64(0, LITTLE_ENDIAN);
  }

  decodeString(bytes, flags) {
    const forcedBin = (flags & this.FORCED_BINARY_ENCODING_FLAG) !== 0;
    const forcedUtf8 = (flags & this.FORCED_UTF8_ENCODING_FLAG) !== 0;

    if (forcedBin) {
      // just use raw bytes
      return {
        encoding: "ascii",
        validEncoding: true,
        value: this.asciiDecoder.decode(bytes)
      };
    } else {
      const encoding = forcedUtf8 ? "utf-8" : this.fileEncoding.toLowerCase();
      const decoder = this.getDecoder(encoding);

      try {
        // decode with encoding
        return {
          encoding,
          validEncoding: true,
          value: decoder.decode(bytes)
        };
      } catch(e) {
        // just use raw bytes, capture what the encoding should be, set flag saying encoding is invalid
        if (e.code === "ERR_ENCODING_INVALID_ENCODED_DATA") {
          return {
            encoding,
            validEncoding: false,
            value: this.asciiDecoder.decode(bytes)
          };
        }

        throw e;
      }
    }
  }

  getDecoder(encoding) {
    encoding = this.DECODER_MAP.get(encoding) || encoding;

    if (!this.decoders.has(encoding)) {
      this.decoders.set(encoding, new TextDecoder(encoding, {fatal: true}));
    }

    return this.decoders.get(encoding);
  }

  get asciiDecoder() {
    if (!this._asciiDecoder) {
      this._asciiDecoder = new TextDecoder("ascii");
    }

    return this._asciiDecoder;
  }
}

/**
 * A location in the source code.
 *
 * @typedef {{ startOffset: number, length: number }} Location
 */

/**
 * A comment in the source code.
 *
 * @typedef {{ type: number, location: Location }} Comment
 */

/**
 * A magic comment in the source code.
 *
 * @typedef {{ startLocation: Location, endLocation: Location }} MagicComment
 */

/**
 * An error in the source code.
 *
 * @typedef {{ type: string, message: string, location: Location, level: string }} ParseError
 */

/**
 * A warning in the source code.
 *
 * @typedef {{ type: string, message: string, location: Location, level: string }} ParseWarning
 */

/**
 * The result of parsing the source code.
 *
 * @typedef {{ value: ProgramNode, comments: Comment[], magicComments: MagicComment[], errors: ParseError[], warnings: ParseWarning[] }} ParseResult
 */

/**
 * The result of calling parse.
 */
export class ParseResult {
  /**
   * @type {nodes.ProgramNode}
   */
  value;

  /**
   * @type {Comment[]}
   */
  comments;

  /**
   * @type {MagicComment[]}
   */
  magicComments;

  /**
   * @type {Location | null}
   */

  /**
   * @type {ParseError[]}
   */
  errors;

  /**
   * @type {ParseWarning[]}
   */
  warnings;

  /**
   * @param {nodes.ProgramNode} value
   * @param {Comment[]} comments
   * @param {MagicComment[]} magicComments
   * @param {ParseError[]} errors
   * @param {ParseWarning[]} warnings
   */
  constructor(value, comments, magicComments, dataLoc, errors, warnings) {
    this.value = value;
    this.comments = comments;
    this.magicComments = magicComments;
    this.dataLoc = dataLoc;
    this.errors = errors;
    this.warnings = warnings;
  }
}

const errorLevels = ["syntax", "argument", "load"];
const errorTypes = [
  <%- errors.each do |error| -%>
  "<%= error.name.downcase %>",
  <%- end -%>
];

const warningLevels = ["default", "verbose"];
const warningTypes = [
  <%- warnings.each do |warning| -%>
  "<%= warning.name.downcase %>",
  <%- end -%>
];

/**
 * Accept two Uint8Arrays, one for the source and one for the serialized format.
 * Return the AST corresponding to the serialized form.
 *
 * @param {Uint8Array} source
 * @param {Uint8Array} array
 * @returns {ParseResult}
 * @throws {Error}
 */
export function deserialize(source, array) {
  const buffer = new SerializationBuffer(source, array);

  if (buffer.readString(5) !== "PRISM") {
    throw new Error("Invalid serialization");
  }

  if ((buffer.readByte() != MAJOR_VERSION) || (buffer.readByte() != MINOR_VERSION) || (buffer.readByte() != PATCH_VERSION)) {
    throw new Error("Invalid serialization");
  }

  if (buffer.readByte() != 0) {
    throw new Error("Invalid serialization (location fields must be included but are not)");
  }

  // Read the file's encoding.
  buffer.fileEncoding = buffer.readString(buffer.readVarInt());

  // Skip past the start line, as we don't support that option yet in
  // JavaScript.
  buffer.readVarInt();

  // Skip past the line offsets, as there is no Source object yet in JavaScript.
  // const lineOffsets = Array.from({ length: buffer.readVarInt() }, () => buffer.readVarInt());
  const lineOffsetsCount = buffer.readVarInt();
  for (let i = 0; i < lineOffsetsCount; i ++) {
    buffer.readVarInt();
  }

  const comments = Array.from({ length: buffer.readVarInt() }, () => ({
    type: buffer.readVarInt(),
    location: buffer.readLocation()
  }));

  const magicComments = Array.from({ length: buffer.readVarInt() }, () => ({
    startLocation: buffer.readLocation(),
    endLocation: buffer.readLocation()
  }));

  const dataLoc = buffer.readOptionalLocation();

  const errors = Array.from({ length: buffer.readVarInt() }, () => ({
    type: errorTypes[buffer.readVarInt()],
    message: buffer.readString(buffer.readVarInt()),
    location: buffer.readLocation(),
    level: errorLevels[buffer.readByte()]
  }));

  const warnings = Array.from({ length: buffer.readVarInt() }, () => ({
    type: warningTypes[buffer.readVarInt()],
    message: buffer.readString(buffer.readVarInt()),
    location: buffer.readLocation(),
    level: warningLevels[buffer.readByte()]
  }));

  const constantPoolOffset = buffer.readUint32();
  const constants = Array.from({ length: buffer.readVarInt() }, () => null);

  return new ParseResult(readRequiredNode(), comments, magicComments, dataLoc, errors, warnings);

  function readRequiredNode() {
    const type = buffer.readByte();
    const nodeID = buffer.readVarInt();
    const location = buffer.readLocation();
    let flags;

    switch (type) {
      <%- nodes.each.with_index(1) do |node, index| -%>
      case <%= index %>:
        <%- if node.needs_serialized_length? -%>
        buffer.readUint32();
        <%- end -%>
        return new nodes.<%= node.name %>(<%= ["nodeID", "location", "flags = buffer.readVarInt()", *node.fields.map { |field|
          case field
          when Prism::Template::NodeField then "readRequiredNode()"
          when Prism::Template::OptionalNodeField then "readOptionalNode()"
          when Prism::Template::StringField then "buffer.readStringField(flags)"
          when Prism::Template::NodeListField then "Array.from({ length: buffer.readVarInt() }, readRequiredNode)"
          when Prism::Template::ConstantField then "readRequiredConstant()"
          when Prism::Template::OptionalConstantField then "readOptionalConstant()"
          when Prism::Template::ConstantListField then "Array.from({ length: buffer.readVarInt() }, readRequiredConstant)"
          when Prism::Template::LocationField then "buffer.readLocation()"
          when Prism::Template::OptionalLocationField then "buffer.readOptionalLocation()"
          when Prism::Template::UInt8Field then "buffer.readByte()"
          when Prism::Template::UInt32Field then "buffer.readVarInt()"
          when Prism::Template::IntegerField then "readInteger()"
          when Prism::Template::DoubleField then "buffer.readDouble()"
          end
        }].join(", ") -%>);
      <%- end -%>
      default:
        throw new Error(`Unknown node type: ${type}`);
    }
  }

  function readOptionalNode() {
    if (buffer.readByte() != 0) {
      buffer.index -= 1;
      return readRequiredNode();
    } else {
      return null;
    }
  }

  function scanConstant(constantIndex) {
    if (constants[constantIndex] === null) {
      constants[constantIndex] = buffer.scanConstant(constantPoolOffset, constantIndex);
    }

    return constants[constantIndex];
  }

  function readRequiredConstant() {
    return scanConstant(buffer.readVarInt() - 1);
  }

  function readOptionalConstant() {
    const index = buffer.readVarInt();
    if (index === 0) {
      return null;
    } else {
      return scanConstant(index - 1);
    }
  }

  function readInteger() {
    const negative = buffer.readByte() != 0;
    const length = buffer.readVarInt();

    const firstWord = buffer.readVarInt();
    if (length == 1) {
      if (negative && firstWord >= 0x80000000) {
        return -BigInt(firstWord);
      } else if (negative) {
        return -firstWord;
      } else {
        return firstWord;
      }
    }

    let result = BigInt(firstWord);
    for (let index = 1; index < length; index++) {
      result |= (BigInt(buffer.readVarInt()) << BigInt(index * 32));
    }

    return negative ? -result : result;
  }
}
prism-1.5.1/templates/javascript/src/nodes.js.erb000066400000000000000000000112461506127434000220260ustar00rootroot00000000000000<%-

def camelize(string)
  string.gsub(/_([a-z])/) { $1.upcase }
end

def prop(field)
  field.name == "arguments" ? "arguments_" : camelize(field.name)
end

def jstype(field)
  case field
  when Prism::Template::NodeField then field.ruby_type
  when Prism::Template::OptionalNodeField then "#{field.ruby_type} | null"
  when Prism::Template::NodeListField then "Node[]"
  when Prism::Template::StringField then "RubyString"
  when Prism::Template::ConstantField then "string"
  when Prism::Template::OptionalConstantField then "string | null"
  when Prism::Template::ConstantListField then "string[]"
  when Prism::Template::LocationField then "Location"
  when Prism::Template::OptionalLocationField then "Location | null"
  when Prism::Template::UInt8Field, Prism::Template::UInt32Field, Prism::Template::IntegerField, Prism::Template::DoubleField then "number"
  else raise
  end
end
-%>
import * as visitors from "./visitor.js"

<%- flags.each do |flag| -%>

/**
 * <%= flag.comment %>
 */
const <%= flag.name %> = {
<%- flag.values.each_with_index do |value, index| -%>
  <%= value.name %>: 1 << <%= index + Prism::Template::COMMON_FLAGS_COUNT %>,
<%- end -%>
};
<%- end -%>

/**
 * A location in the source code.
 *
 * @typedef {{ startOffset: number, length: number }} Location
 */

/**
 * An encoded Ruby string.
 *
 * @typedef {{ value: string, encoding: string, validEncoding: boolean }} RubyString
 */

/**
 * A generic node in the tree.
 *
 * @typedef {(<%= nodes.map(&:name).join("|") %>)} Node
 */
<%- nodes.each do |node| -%>

/**
<%- node.each_comment_line do |line| -%>
 *<%= line %>
<%- end -%>
 */
export class <%= node.name -%> {
  /**
   * @type number
   */
  nodeID;

  /**
   * @type {Location}
   */
  location;

  /**
   * @type number
   */
  #flags;

  <%- node.fields.each do |field| -%>
  /**
   * @type <%= jstype(field) %>
   */
  <%= prop(field) %>;

  <%- end -%>
  /**
   * Construct a new <%= node.name %>.
   *
   * @param {number} nodeID
   * @param {Location} location
   * @param {number} flags
   <%- node.fields.each do |field| -%>
   * @param {<%= jstype(field) %>} <%= prop(field) %>
   <%- end -%>
   */
  constructor(<%= ["nodeID", "location", "flags", *node.fields.map { |field| prop(field) }].join(", ") %>) {
    this.nodeID = nodeID;
    this.location = location;
    this.#flags = flags;
    <%- node.fields.each do |field| -%>
    this.<%= prop(field) %> = <%= prop(field) %>;
    <%- end -%>
  }
  <%- if (node_flags = node.flags) -%>
  <%- node_flags.values.each do |value| -%>

  /**
   * True if this node has the <%= value.name %> flag.
   *
   * @returns {boolean}
   */
  is<%= value.camelcase %>() {
    return (this.#flags & <%= node_flags.name %>.<%= value.name %>) !== 0;
  }
  <%- end -%>
  <%- end -%>

  /**
   * Accept a visitor for this node.
   *
   * @param {visitors.Visitor} visitor
   */
  accept(visitor) {
    visitor.visit<%= camelize(node.name) %>(this)
  }

  /**
   * Returns all child nodes of the current node.
   *
   * @returns {(Node | null)[]} An array of child nodes.
   */
  childNodes() {
    return [<%= node.fields.map { |field|
    case field
    when Prism::Template::NodeField, Prism::Template::OptionalNodeField then "this.#{prop(field)}"
    when Prism::Template::NodeListField then "...this.#{prop(field)}"
    end
    }.compact.join(", ") %>]
  }

  /**
   * Compact and return an array of child nodes.
   *
   * @returns {Node[]} An array of compacted child nodes.
   */
  compactChildNodes() {
    <%- if node.fields.any? { |field| field.is_a?(Prism::Template::OptionalNodeField) } -%>
    const compact = [];

    <%- node.fields.each do |field| -%>
    <%- case field -%>
    <%- when Prism::Template::NodeField -%>
    compact.push(this.<%= prop(field) %>);

    <%- when Prism::Template::OptionalNodeField -%>
    if (this.<%= prop(field) %>) {
      compact.push(this.<%= prop(field) %>);
    }
    <%- when Prism::Template::NodeListField -%>
    compact.concat(this.<%= prop(field) %>);
    <%- end -%>
    <%- end -%>

    return compact;
    <%- else -%>
    return [<%= node.fields.map { |field|
    case field
    when Prism::Template::NodeField then "this.#{prop(field)}"
    when Prism::Template::NodeListField then "...this.#{prop(field)}"
    end
    }.compact.join(", ") %>];
    <%- end -%>
  }

  /**
   * Transforms the Node to a JavaScript object.
   *
   * @returns {Object}
   */
  toJSON() {
    return {
      type: "<%= node.name %>",
      location: this.location,
      flags: this.#flags,
      <%- node.fields.each do |field| -%>
      <%- if field.name == "arguments" -%>
      arguments: this.<%= prop(field) %>,
      <%- else -%>
      <%= prop(field) %>: this.<%= prop(field) %>,
      <%- end -%>
      <%- end -%>
    };
  }
}
<%- end -%>
prism-1.5.1/templates/javascript/src/visitor.js.erb000066400000000000000000000040161506127434000224120ustar00rootroot00000000000000import * as nodes from "./nodes.js";

/**
 * A class that knows how to walk down the tree. None of the individual visit
 * methods are implemented on this visitor, so it forces the consumer to
 * implement each one that they need. For a default implementation that
 * continues walking the tree, see the `Visitor` class.
 *
 */
export class BasicVisitor {
  /**
   * Calls `accept` on the given node if it is not `null`, which in turn should
   * call back into this visitor by calling the appropriate `visit*` method.
   *
   * @param {nodes.Node} node
   */
  visit(node) {
    node?.accept(this);
  }

  /**
   * Visits each node in `nodes` by calling `accept` on each one.
   *
   * @param {nodes.Node[]} nodes
   */
  visitAll(nodes) {
    nodes.forEach((node) => {
      node?.accept(this);
    });
  }

  /**
   * Visits the child nodes of `node` by calling `accept` on each one.
   *
   * @param {nodes.Node} node
   */
  visitChildNodes(node) {
    node.compactChildNodes().forEach((childNode) => {
      childNode.accept(this);
    });
  }
}

/**
 * A visitor is a class that provides a default implementation for every accept
 * method defined on the nodes. This means it can walk a tree without the
 * caller needing to define any special handling. This allows you to handle a
 * subset of the tree, while still walking the whole tree.
 *
 * For example, to find all of the method calls that call the `foo` method, you
 * could write:
 *
 * @example
 * class FooCalls extends Visitor {
 *   visitCallNode(node) {
 *     if (node.name === "foo") {
 *       // Do something with the node
 *     }
 *
 *     // Call super so that the visitor continues walking the tree
 *     super.visitCallNode(node);
 *   }
 * }
 *
 */
export class Visitor extends BasicVisitor {
<%- nodes.each_with_index do |node, index| -%>
<%= "\n" if index != 0 -%>
  /**
   * Visit a <%= node.name %> node.
   *
   * @param {nodes.<%= node.name %>} node
   */
  <%= "visit#{node.name.gsub(/_([a-z])/) { $1.upcase }}" %>(node) {
    this.visitChildNodes(node);
  }
<%- end -%>
}
prism-1.5.1/templates/lib/000077500000000000000000000000001506127434000154165ustar00rootroot00000000000000prism-1.5.1/templates/lib/prism/000077500000000000000000000000001506127434000165505ustar00rootroot00000000000000prism-1.5.1/templates/lib/prism/compiler.rb.erb000066400000000000000000000025731506127434000214650ustar00rootroot00000000000000module Prism
  # A compiler is a visitor that returns the value of each node as it visits.
  # This is as opposed to a visitor which will only walk the tree. This can be
  # useful when you are trying to compile a tree into a different format.
  #
  # For example, to build a representation of the tree as s-expressions, you
  # could write:
  #
  #     class SExpressions < Prism::Compiler
  #       def visit_arguments_node(node) = [:arguments, super]
  #       def visit_call_node(node) = [:call, super]
  #       def visit_integer_node(node) = [:integer]
  #       def visit_program_node(node) = [:program, super]
  #     end
  #
  #     Prism.parse("1 + 2").value.accept(SExpressions.new)
  #     # => [:program, [[[:call, [[:integer], [:arguments, [[:integer]]]]]]]]
  #
  class Compiler < Visitor
    # Visit an individual node.
    def visit(node)
      node&.accept(self)
    end

    # Visit a list of nodes.
    def visit_all(nodes)
      nodes.map { |node| node&.accept(self) }
    end

    # Visit the child nodes of the given node.
    def visit_child_nodes(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

    <%- nodes.each_with_index do |node, index| -%>
<%= "\n" if index != 0 -%>
    # Compile a <%= node.name %> node
    def visit_<%= node.human %>(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end
    <%- end -%>
  end
end
prism-1.5.1/templates/lib/prism/dispatcher.rb.erb000066400000000000000000000070371506127434000220010ustar00rootroot00000000000000module Prism
  # The dispatcher class fires events for nodes that are found while walking an
  # AST to all registered listeners. It's useful for performing different types
  # of analysis on the AST while only having to walk the tree once.
  #
  # To use the dispatcher, you would first instantiate it and register listeners
  # for the events you're interested in:
  #
  #     class OctalListener
  #       def on_integer_node_enter(node)
  #         if node.octal? && !node.slice.start_with?("0o")
  #           warn("Octal integers should be written with the 0o prefix")
  #         end
  #       end
  #     end
  #
  #     listener = OctalListener.new
  #     dispatcher = Prism::Dispatcher.new
  #     dispatcher.register(listener, :on_integer_node_enter)
  #
  # Then, you can walk any number of trees and dispatch events to the listeners:
  #
  #     result = Prism.parse("001 + 002 + 003")
  #     dispatcher.dispatch(result.value)
  #
  # Optionally, you can also use `#dispatch_once` to dispatch enter and leave
  # events for a single node without recursing further down the tree. This can
  # be useful in circumstances where you want to reuse the listeners you already
  # have registers but want to stop walking the tree at a certain point.
  #
  #     integer = result.value.statements.body.first.receiver.receiver
  #     dispatcher.dispatch_once(integer)
  #
  class Dispatcher < Visitor
    # attr_reader listeners: Hash[Symbol, Array[Listener]]
    attr_reader :listeners

    # Initialize a new dispatcher.
    def initialize
      @listeners = {}
    end

    # Register a listener for one or more events.
    #
    # def register: (Listener, *Symbol) -> void
    def register(listener, *events)
      register_events(listener, events)
    end

    # Register all public methods of a listener that match the pattern
    # `on__(enter|leave)`.
    #
    # def register_public_methods: (Listener) -> void
    def register_public_methods(listener)
      register_events(listener, listener.public_methods(false).grep(/\Aon_.+_(?:enter|leave)\z/))
    end

    # Register a listener for the given events.
    private def register_events(listener, events)
      events.each { |event| (listeners[event] ||= []) << listener }
    end

    # Walks `root` dispatching events to all registered listeners.
    #
    # def dispatch: (Node) -> void
    alias dispatch visit

    # Dispatches a single event for `node` to all registered listeners.
    #
    # def dispatch_once: (Node) -> void
    def dispatch_once(node)
      node.accept(DispatchOnce.new(listeners))
    end
    <%- nodes.each do |node| -%>

    # Dispatch enter and leave events for <%= node.name %> nodes and continue
    # walking the tree.
    def visit_<%= node.human %>(node)
      listeners[:on_<%= node.human %>_enter]&.each { |listener| listener.on_<%= node.human %>_enter(node) }
      super
      listeners[:on_<%= node.human %>_leave]&.each { |listener| listener.on_<%= node.human %>_leave(node) }
    end
    <%- end -%>

    class DispatchOnce < Visitor # :nodoc:
      attr_reader :listeners

      def initialize(listeners)
        @listeners = listeners
      end
      <%- nodes.each do |node| -%>

      # Dispatch enter and leave events for <%= node.name %> nodes.
      def visit_<%= node.human %>(node)
        listeners[:on_<%= node.human %>_enter]&.each { |listener| listener.on_<%= node.human %>_enter(node) }
        listeners[:on_<%= node.human %>_leave]&.each { |listener| listener.on_<%= node.human %>_leave(node) }
      end
      <%- end -%>
    end

    private_constant :DispatchOnce
  end
end
prism-1.5.1/templates/lib/prism/dot_visitor.rb.erb000066400000000000000000000123741506127434000222200ustar00rootroot00000000000000require "cgi/escape"
require "cgi/util" unless defined?(CGI::EscapeExt)

module Prism
  # This visitor provides the ability to call Node#to_dot, which converts a
  # subtree into a graphviz dot graph.
  class DotVisitor < Visitor
    class Field # :nodoc:
      attr_reader :name, :value, :port

      def initialize(name, value, port)
        @name = name
        @value = value
        @port = port
      end

      def to_dot
        if port
          "#{name}"
        else
          "#{name}#{CGI.escapeHTML(value || raise)}"
        end
      end
    end

    class Table # :nodoc:
      attr_reader :name, :fields

      def initialize(name)
        @name = name
        @fields = []
      end

      def field(name, value = nil, port: false)
        fields << Field.new(name, value, port)
      end

      def to_dot
        dot = <<~DOT
          
        DOT

        if fields.any?
          "#{dot}  #{fields.map(&:to_dot).join("\n  ")}\n

            
#{name}
"
        else
          "#{dot}"
        end
      end
    end

    class Digraph # :nodoc:
      attr_reader :nodes, :waypoints, :edges

      def initialize
        @nodes = []
        @waypoints = []
        @edges = []
      end

      def node(value)
        nodes << value
      end

      def waypoint(value)
        waypoints << value
      end

      def edge(value)
        edges << value
      end

      def to_dot
        <<~DOT
          digraph "Prism" {
            node [
              fontname=\"Courier New\"
              shape=plain
              style=filled
              fillcolor=gray95
            ];

            #{nodes.map { |node| node.gsub(/\n/, "\n  ") }.join("\n  ")}
            node [shape=point];
            #{waypoints.join("\n  ")}

            #{edges.join("\n  ")}
          }
        DOT
      end
    end

    private_constant :Field, :Table, :Digraph

    # The digraph that is being built.
    attr_reader :digraph

    # Initialize a new dot visitor.
    def initialize
      @digraph = Digraph.new
    end

    # Convert this visitor into a graphviz dot graph string.
    def to_dot
      digraph.to_dot
    end
    <%- nodes.each do |node| -%>

    # Visit a <%= node.name %> node.
    def visit_<%= node.human %>(node)
      table = Table.new("<%= node.name %>")
      id = node_id(node)
      <%- if (node_flags = node.flags) -%>

      # flags
      table.field("flags", <%= node_flags.human %>_inspect(node))
      <%- end -%>
      <%- node.fields.each do |field| -%>

      # <%= field.name %>
      <%- case field -%>
      <%- when Prism::Template::NodeField -%>
      table.field("<%= field.name %>", port: true)
      digraph.edge("#{id}:<%= field.name %> -> #{node_id(node.<%= field.name %>)};")
      <%- when Prism::Template::OptionalNodeField -%>
      unless (<%= field.name %> = node.<%= field.name %>).nil?
        table.field("<%= field.name %>", port: true)
        digraph.edge("#{id}:<%= field.name %> -> #{node_id(<%= field.name %>)};")
      end
      <%- when Prism::Template::NodeListField -%>
      if node.<%= field.name %>.any?
        table.field("<%= field.name %>", port: true)

        waypoint = "#{id}_<%= field.name %>"
        digraph.waypoint("#{waypoint};")

        digraph.edge("#{id}:<%= field.name %> -> #{waypoint};")
        node.<%= field.name %>.each { |child| digraph.edge("#{waypoint} -> #{node_id(child)};") }
      else
        table.field("<%= field.name %>", "[]")
      end
      <%- when Prism::Template::StringField, Prism::Template::ConstantField, Prism::Template::OptionalConstantField, Prism::Template::UInt8Field, Prism::Template::UInt32Field, Prism::Template::ConstantListField, Prism::Template::IntegerField, Prism::Template::DoubleField -%>
      table.field("<%= field.name %>", node.<%= field.name %>.inspect)
      <%- when Prism::Template::LocationField -%>
      table.field("<%= field.name %>", location_inspect(node.<%= field.name %>))
      <%- when Prism::Template::OptionalLocationField -%>
      unless (<%= field.name %> = node.<%= field.name %>).nil?
        table.field("<%= field.name %>", location_inspect(<%= field.name %>))
      end
      <%- else -%>
      <%- raise -%>
      <%- end -%>
      <%- end -%>

      digraph.nodes << <<~DOT
        #{id} [
          label=<#{table.to_dot.gsub(/\n/, "\n  ")}>
        ];
      DOT

      super
    end
    <%- end -%>

    private

    # Generate a unique node ID for a node throughout the digraph.
    def node_id(node)
      "Node_#{node.object_id}"
    end

    # Inspect a location to display the start and end line and column numbers.
    def location_inspect(location)
      "(#{location.start_line},#{location.start_column})-(#{location.end_line},#{location.end_column})"
    end
    <%- flags.each do |flag| -%>

    # Inspect a node that has <%= flag.human %> flags to display the flags as a
    # comma-separated list.
    def <%= flag.human %>_inspect(node)
      flags = [] #: Array[String]
      <%- flag.values.each do |value| -%>
      flags << "<%= value.name.downcase %>" if node.<%= value.name.downcase %>?
      <%- end -%>
      flags.join(", ")
    end
    <%- end -%>
  end
end
prism-1.5.1/templates/lib/prism/dsl.rb.erb000066400000000000000000000102701506127434000204260ustar00rootroot00000000000000module Prism
  # The DSL module provides a set of methods that can be used to create prism
  # nodes in a more concise manner. For example, instead of writing:
  #
  #     source = Prism::Source.for("[1]")
  #
  #     Prism::ArrayNode.new(
  #       source,
  #       0,
  #       Prism::Location.new(source, 0, 3),
  #       0,
  #       [
  #         Prism::IntegerNode.new(
  #           source,
  #           0,
  #           Prism::Location.new(source, 1, 1),
  #           Prism::IntegerBaseFlags::DECIMAL,
  #           1
  #         )
  #       ],
  #       Prism::Location.new(source, 0, 1),
  #       Prism::Location.new(source, 2, 1)
  #     )
  #
  # you could instead write:
  #
  #     class Builder
  #       include Prism::DSL
  #
  #       attr_reader :default_source
  #
  #       def initialize
  #         @default_source = source("[1]")
  #       end
  #
  #       def build
  #         array_node(
  #           location: location(start_offset: 0, length: 3),
  #           elements: [
  #             integer_node(
  #               location: location(start_offset: 1, length: 1),
  #               flags: integer_base_flag(:decimal),
  #               value: 1
  #             )
  #           ],
  #           opening_loc: location(start_offset: 0, length: 1),
  #           closing_loc: location(start_offset: 2, length: 1)
  #         )
  #       end
  #     end
  #
  # This is mostly helpful in the context of generating trees programmatically.
  module DSL
    # Provide all of these methods as module methods as well, to allow for
    # building nodes like Prism::DSL.nil_node.
    extend self

    # Create a new Source object.
    def source(string)
      Source.for(string)
    end

    # Create a new Location object.
    def location(source: default_source, start_offset: 0, length: 0)
      Location.new(source, start_offset, length)
    end
    <%- nodes.each do |node| -%>

    # Create a new <%= node.name %> node.
    def <%= node.human %>(<%= ["source: default_source", "node_id: 0", "location: default_location", "flags: 0", *node.fields.map { |field|
      case field
      when Prism::Template::NodeField
        kind = field.specific_kind || field.union_kind&.first
        if kind.nil?
          "#{field.name}: default_node(source, location)"
        else
          "#{field.name}: #{kind.gsub(/(?<=.)[A-Z]/, "_\\0").downcase}(source: source)"
        end
      when Prism::Template::ConstantField
        "#{field.name}: :\"\""
      when Prism::Template::OptionalNodeField, Prism::Template::OptionalConstantField, Prism::Template::OptionalLocationField
        "#{field.name}: nil"
      when Prism::Template::NodeListField, Prism::Template::ConstantListField
        "#{field.name}: []"
      when Prism::Template::StringField
        "#{field.name}: \"\""
      when Prism::Template::LocationField
        "#{field.name}: location"
      when Prism::Template::UInt8Field, Prism::Template::UInt32Field, Prism::Template::IntegerField
        "#{field.name}: 0"
      when Prism::Template::DoubleField
        "#{field.name}: 0.0"
      else
        raise
      end
    }].join(", ") %>)
      <%= node.name %>.new(<%= ["source", "node_id", "location", "flags", *node.fields.map(&:name)].join(", ") %>)
    end
    <%- end -%>
    <%- flags.each do |flag| -%>

    # Retrieve the value of one of the <%= flag.name %> flags.
    def <%= flag.human.chomp("s") %>(name)
      case name
      <%- flag.values.each do |value| -%>
      when :<%= value.name.downcase %> then <%= flag.name %>::<%= value.name %>
      <%- end -%>
      else Kernel.raise ArgumentError, "invalid <%= flag.name %> flag: #{name.inspect}"
      end
    end
    <%- end -%>

    private

    # The default source object that gets attached to nodes and locations if no
    # source is specified.
    def default_source
      Source.for("")
    end

    # The default location object that gets attached to nodes if no location is
    # specified, which uses the given source.
    def default_location
      Location.new(default_source, 0, 0)
    end

    # The default node that gets attached to nodes if no node is specified for a
    # required node field.
    def default_node(source, location)
      MissingNode.new(source, -1, location, 0)
    end
  end
end
prism-1.5.1/templates/lib/prism/inspect_visitor.rb.erb000066400000000000000000000121311506127434000230660ustar00rootroot00000000000000module Prism
  # This visitor is responsible for composing the strings that get returned by
  # the various #inspect methods defined on each of the nodes.
  class InspectVisitor < Visitor
    # Most of the time, we can simply pass down the indent to the next node.
    # However, when we are inside a list we want some extra special formatting
    # when we hit an element in that list. In this case, we have a special
    # command that replaces the subsequent indent with the given value.
    class Replace # :nodoc:
      attr_reader :value

      def initialize(value)
        @value = value
      end
    end

    private_constant :Replace

    # The current prefix string.
    attr_reader :indent

    # The list of commands that we need to execute in order to compose the
    # final string.
    attr_reader :commands

    # Initializes a new instance of the InspectVisitor.
    def initialize(indent = +"")
      @indent = indent
      @commands = []
    end

    # Compose an inspect string for the given node.
    def self.compose(node)
      visitor = new
      node.accept(visitor)
      visitor.compose
    end

    # Compose the final string.
    def compose
      buffer = +""
      replace = nil

      until commands.empty?
        # @type var command: String | node | Replace
        # @type var indent: String
        command, indent = *commands.shift

        case command
        when String
          buffer << (replace || indent)
          buffer << command
          replace = nil
        when Node
          visitor = InspectVisitor.new(indent)
          command.accept(visitor)
          @commands = [*visitor.commands, *@commands]
        when Replace
          replace = command.value
        else
          raise "Unknown command: #{command.inspect}"
        end
      end

      buffer
    end
    <%- nodes.each do |node| -%>

    # Inspect a <%= node.name %> node.
    def visit_<%= node.human %>(node)
      commands << [inspect_node(<%= node.name.inspect %>, node), indent]
      <%- (fields = [node.flags || Prism::Template::Flags.empty, *node.fields]).each_with_index do |field, index| -%>
      <%- pointer = index == fields.length - 1 ? "└── " : "├── " -%>
      <%- preadd = index == fields.length - 1 ? "    " : "│   " -%>
      <%- case field -%>
      <%- when Prism::Template::Flags -%>
      flags = [("newline" if node.newline?), ("static_literal" if node.static_literal?), <%= field.values.map { |value| "(\"#{value.name.downcase}\" if node.#{value.name.downcase}?)" }.join(", ") %>].compact
      commands << ["<%= pointer %>flags: #{flags.empty? ? "∅" : flags.join(", ")}\n", indent]
      <%- when Prism::Template::NodeListField -%>
      commands << ["<%= pointer %><%= field.name %>: (length: #{(<%= field.name %> = node.<%= field.name %>).length})\n", indent]
      if <%= field.name %>.any?
        <%= field.name %>[0...-1].each do |child|
          commands << [Replace.new("#{indent}<%= preadd %>├── "), indent]
          commands << [child, "#{indent}<%= preadd %>│   "]
        end
        commands << [Replace.new("#{indent}<%= preadd %>└── "), indent]
        commands << [<%= field.name %>[-1], "#{indent}<%= preadd %>    "]
      end
      <%- when Prism::Template::NodeField -%>
      commands << ["<%= pointer %><%= field.name %>:\n", indent]
      commands << [node.<%= field.name %>, "#{indent}<%= preadd %>"]
      <%- when Prism::Template::OptionalNodeField -%>
      if (<%= field.name %> = node.<%= field.name %>).nil?
        commands << ["<%= pointer %><%= field.name %>: ∅\n", indent]
      else
        commands << ["<%= pointer %><%= field.name %>:\n", indent]
        commands << [<%= field.name %>, "#{indent}<%= preadd %>"]
      end
      <%- when Prism::Template::ConstantField, Prism::Template::ConstantListField, Prism::Template::StringField, Prism::Template::UInt8Field, Prism::Template::UInt32Field, Prism::Template::IntegerField, Prism::Template::DoubleField -%>
      commands << ["<%= pointer %><%= field.name %>: #{node.<%= field.name %>.inspect}\n", indent]
      <%- when Prism::Template::OptionalConstantField -%>
      if (<%= field.name %> = node.<%= field.name %>).nil?
        commands << ["<%= pointer %><%= field.name %>: ∅\n", indent]
      else
        commands << ["<%= pointer %><%= field.name %>: #{<%= field.name %>.inspect}\n", indent]
      end
      <%- when Prism::Template::LocationField, Prism::Template::OptionalLocationField -%>
      commands << ["<%= pointer %><%= field.name %>: #{inspect_location(node.<%= field.name %>)}\n", indent]
      <%- end -%>
      <%- end -%>
    end
    <%- end -%>

    private

    # Compose a header for the given node.
    def inspect_node(name, node)
      location = node.location
      "@ #{name} (location: (#{location.start_line},#{location.start_column})-(#{location.end_line},#{location.end_column}))\n"
    end

    # Compose a string representing the given inner location field.
    def inspect_location(location)
      if location
        "(#{location.start_line},#{location.start_column})-(#{location.end_line},#{location.end_column}) = #{location.slice.inspect}"
      else
        "∅"
      end
    end
  end
end
prism-1.5.1/templates/lib/prism/mutation_compiler.rb.erb000066400000000000000000000015631506127434000234030ustar00rootroot00000000000000module Prism
  # This visitor walks through the tree and copies each node as it is being
  # visited. This is useful for consumers that want to mutate the tree, as you
  # can change subtrees in place without effecting the rest of the tree.
  class MutationCompiler < Compiler
    <%- nodes.each_with_index do |node, index| -%>
<%= "\n" if index != 0 -%>
    # Copy a <%= node.name %> node
    def visit_<%= node.human %>(node)
      <%- fields = node.fields.select { |field| [Prism::Template::NodeField, Prism::Template::OptionalNodeField, Prism::Template::NodeListField].include?(field.class) } -%>
      <%- if fields.any? -%>
      node.copy(<%= fields.map { |field| "#{field.name}: #{field.is_a?(Prism::Template::NodeListField) ? "visit_all" : "visit"}(node.#{field.name})" }.join(", ") %>)
      <%- else -%>
      node.copy
      <%- end -%>
    end
    <%- end -%>
  end
end
prism-1.5.1/templates/lib/prism/node.rb.erb000066400000000000000000000442341506127434000206000ustar00rootroot00000000000000module Prism
  # This represents a node in the tree. It is the parent class of all of the
  # various node types.
  class Node
    # A pointer to the source that this node was created from.
    attr_reader :source
    private :source

    # A unique identifier for this node. This is used in a very specific
    # use case where you want to keep around a reference to a node without
    # having to keep around the syntax tree in memory. This unique identifier
    # will be consistent across multiple parses of the same source code.
    attr_reader :node_id

    # Save this node using a saved source so that it can be retrieved later.
    def save(repository)
      repository.enter(node_id, :itself)
    end

    # A Location instance that represents the location of this node in the
    # source.
    def location
      location = @location
      return location if location.is_a?(Location)
      @location = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

    # Save the location using a saved source so that it can be retrieved later.
    def save_location(repository)
      repository.enter(node_id, :location)
    end

    # Delegates to the start_line of the associated location object.
    def start_line
      location.start_line
    end

    # Delegates to the end_line of the associated location object.
    def end_line
      location.end_line
    end

    # The start offset of the node in the source. This method is effectively a
    # delegate method to the location object.
    def start_offset
      location = @location
      location.is_a?(Location) ? location.start_offset : location >> 32
    end

    # The end offset of the node in the source. This method is effectively a
    # delegate method to the location object.
    def end_offset
      location = @location
      location.is_a?(Location) ? location.end_offset : ((location >> 32) + (location & 0xFFFFFFFF))
    end

    # Delegates to the start_character_offset of the associated location object.
    def start_character_offset
      location.start_character_offset
    end

    # Delegates to the end_character_offset of the associated location object.
    def end_character_offset
      location.end_character_offset
    end

    # Delegates to the cached_start_code_units_offset of the associated location
    # object.
    def cached_start_code_units_offset(cache)
      location.cached_start_code_units_offset(cache)
    end

    # Delegates to the cached_end_code_units_offset of the associated location
    # object.
    def cached_end_code_units_offset(cache)
      location.cached_end_code_units_offset(cache)
    end

    # Delegates to the start_column of the associated location object.
    def start_column
      location.start_column
    end

    # Delegates to the end_column of the associated location object.
    def end_column
      location.end_column
    end

    # Delegates to the start_character_column of the associated location object.
    def start_character_column
      location.start_character_column
    end

    # Delegates to the end_character_column of the associated location object.
    def end_character_column
      location.end_character_column
    end

    # Delegates to the cached_start_code_units_column of the associated location
    # object.
    def cached_start_code_units_column(cache)
      location.cached_start_code_units_column(cache)
    end

    # Delegates to the cached_end_code_units_column of the associated location
    # object.
    def cached_end_code_units_column(cache)
      location.cached_end_code_units_column(cache)
    end

    # Delegates to the leading_comments of the associated location object.
    def leading_comments
      location.leading_comments
    end

    # Delegates to the trailing_comments of the associated location object.
    def trailing_comments
      location.trailing_comments
    end

    # Delegates to the comments of the associated location object.
    def comments
      location.comments
    end

    # Returns all of the lines of the source code associated with this node.
    def source_lines
      location.source_lines
    end

    # An alias for source_lines, used to mimic the API from
    # RubyVM::AbstractSyntaxTree to make it easier to migrate.
    alias script_lines source_lines

    # Slice the location of the node from the source.
    def slice
      location.slice
    end

    # Slice the location of the node from the source, starting at the beginning
    # of the line that the location starts on, ending at the end of the line
    # that the location ends on.
    def slice_lines
      location.slice_lines
    end

    # An bitset of flags for this node. There are certain flags that are common
    # for all nodes, and then some nodes have specific flags.
    attr_reader :flags
    protected :flags

    # Returns true if the node has the newline flag set.
    def newline?
      flags.anybits?(NodeFlags::NEWLINE)
    end

    # Returns true if the node has the static literal flag set.
    def static_literal?
      flags.anybits?(NodeFlags::STATIC_LITERAL)
    end

    # Similar to inspect, but respects the current level of indentation given by
    # the pretty print object.
    def pretty_print(q)
      q.seplist(inspect.chomp.each_line, -> { q.breakable }) do |line|
        q.text(line.chomp)
      end
      q.current_group.break
    end

    # Convert this node into a graphviz dot graph string.
    def to_dot
      # @type self: node
      DotVisitor.new.tap { |visitor| accept(visitor) }.to_dot
    end

    # Returns a list of nodes that are descendants of this node that contain the
    # given line and column. This is useful for locating a node that is selected
    # based on the line and column of the source code.
    #
    # Important to note is that the column given to this method should be in
    # bytes, as opposed to characters or code units.
    def tunnel(line, column)
      queue = [self] #: Array[Prism::node]
      result = [] #: Array[Prism::node]

      while (node = queue.shift)
        result << node

        node.compact_child_nodes.each do |child_node|
          child_location = child_node.location

          start_line = child_location.start_line
          end_line = child_location.end_line

          if start_line == end_line
            if line == start_line && column >= child_location.start_column && column < child_location.end_column
              queue << child_node
              break
            end
          elsif (line == start_line && column >= child_location.start_column) || (line == end_line && column < child_location.end_column)
            queue << child_node
            break
          elsif line > start_line && line < end_line
            queue << child_node
            break
          end
        end
      end

      result
    end

    # Returns the first node that matches the given block when visited in a
    # depth-first search. This is useful for finding a node that matches a
    # particular condition.
    #
    #     node.breadth_first_search { |node| node.node_id == node_id }
    #
    def breadth_first_search(&block)
      queue = [self] #: Array[Prism::node]

      while (node = queue.shift)
        return node if yield node
        queue.concat(node.compact_child_nodes)
      end

      nil
    end

    # Returns a list of the fields that exist for this node class. Fields
    # describe the structure of the node. This kind of reflection is useful for
    # things like recursively visiting each node _and_ field in the tree.
    def self.fields
      # This method should only be called on subclasses of Node, not Node
      # itself.
      raise NoMethodError, "undefined method `fields' for #{inspect}" if self == Node

      Reflection.fields_for(self)
    end

    # --------------------------------------------------------------------------
    # :section: Node interface
    # These methods are effectively abstract methods that must be implemented by
    # the various subclasses of Node. They are here to make it easier to work
    # with typecheckers.
    # --------------------------------------------------------------------------

    # Accepts a visitor and calls back into the specialized visit function.
    def accept(visitor)
      raise NoMethodError, "undefined method `accept' for #{inspect}"
    end

    # Returns an array of child nodes, including `nil`s in the place of optional
    # nodes that were not present.
    def child_nodes
      raise NoMethodError, "undefined method `child_nodes' for #{inspect}"
    end

    alias deconstruct child_nodes

    # Returns an array of child nodes, excluding any `nil`s in the place of
    # optional nodes that were not present.
    def compact_child_nodes
      raise NoMethodError, "undefined method `compact_child_nodes' for #{inspect}"
    end

    # Returns an array of child nodes and locations that could potentially have
    # comments attached to them.
    def comment_targets
      raise NoMethodError, "undefined method `comment_targets' for #{inspect}"
    end

    # Returns a string representation of the node.
    def inspect
      raise NoMethodError, "undefined method `inspect' for #{inspect}"
    end

    # Sometimes you want to check an instance of a node against a list of
    # classes to see what kind of behavior to perform. Usually this is done by
    # calling `[cls1, cls2].include?(node.class)` or putting the node into a
    # case statement and doing `case node; when cls1; when cls2; end`. Both of
    # these approaches are relatively slow because of the constant lookups,
    # method calls, and/or array allocations.
    #
    # Instead, you can call #type, which will return to you a symbol that you
    # can use for comparison. This is faster than the other approaches because
    # it uses a single integer comparison, but also because if you're on CRuby
    # you can take advantage of the fact that case statements with all symbol
    # keys will use a jump table.
    def type
      raise NoMethodError, "undefined method `type' for #{inspect}"
    end

    # Similar to #type, this method returns a symbol that you can use for
    # splitting on the type of the node without having to do a long === chain.
    # Note that like #type, it will still be slower than using == for a single
    # class, but should be faster in a case statement or an array comparison.
    def self.type
      raise NoMethodError, "undefined method `type' for #{inspect}"
    end
  end
  <%- nodes.each do |node| -%>

  <%- node.each_comment_line do |line| -%>
  #<%= line %>
  <%- end -%>
  class <%= node.name -%> < Node
    # Initialize a new <%= node.name %> node.
    def initialize(<%= ["source", "node_id", "location", "flags", *node.fields.map(&:name)].join(", ") %>)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      <%- node.fields.each do |field| -%>
      <%- if Prism::Template::CHECK_FIELD_KIND && field.respond_to?(:check_field_kind) -%>
      raise "<%= node.name %>#<%= field.name %> was of unexpected type:\n#{<%= field.name %>.inspect}" unless <%= field.check_field_kind %>
      <%- end -%>
      @<%= field.name %> = <%= field.name %>
      <%- end -%>
    end

    # def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_<%= node.human %>(self)
    end

    # def child_nodes: () -> Array[Node?]
    def child_nodes
      [<%= node.fields.map { |field|
        case field
        when Prism::Template::NodeField, Prism::Template::OptionalNodeField then field.name
        when Prism::Template::NodeListField then "*#{field.name}"
        end
      }.compact.join(", ") %>]
    end

    # def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      <%- if node.fields.any? { |field| field.is_a?(Prism::Template::OptionalNodeField) } -%>
      compact = [] #: Array[Prism::node]
      <%- node.fields.each do |field| -%>
      <%- case field -%>
      <%- when Prism::Template::NodeField -%>
      compact << <%= field.name %>
      <%- when Prism::Template::OptionalNodeField -%>
      compact << <%= field.name %> if <%= field.name %>
      <%- when Prism::Template::NodeListField -%>
      compact.concat(<%= field.name %>)
      <%- end -%>
      <%- end -%>
      compact
      <%- else -%>
      [<%= node.fields.map { |field|
        case field
        when Prism::Template::NodeField then field.name
        when Prism::Template::NodeListField then "*#{field.name}"
        end
      }.compact.join(", ") %>]
      <%- end -%>
    end

    # def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [<%= node.fields.map { |field|
        case field
        when Prism::Template::NodeField, Prism::Template::LocationField then field.name
        when Prism::Template::OptionalNodeField, Prism::Template::NodeListField, Prism::Template::OptionalLocationField then "*#{field.name}"
        end
      }.compact.join(", ") %>] #: Array[Prism::node | Location]
    end

    # def copy: (<%= (["?node_id: Integer", "?location: Location", "?flags: Integer"] + node.fields.map { |field| "?#{field.name}: #{field.rbs_class}" }).join(", ") %>) -> <%= node.name %>
    def copy(<%= (["node_id", "location", "flags"] + node.fields.map(&:name)).map { |field| "#{field}: self.#{field}" }.join(", ") %>)
      <%= node.name %>.new(<%= ["source", "node_id", "location", "flags", *node.fields.map(&:name)].join(", ") %>)
    end

    # def deconstruct: () -> Array[Node?]
    alias deconstruct child_nodes

    # def deconstruct_keys: (Array[Symbol] keys) -> { <%= (["node_id: Integer", "location: Location"] + node.fields.map { |field| "#{field.name}: #{field.rbs_class}" }).join(", ") %> }
    def deconstruct_keys(keys)
      { <%= (["node_id: node_id", "location: location"] + node.fields.map { |field| "#{field.name}: #{field.name}" }).join(", ") %> }
    end
    <%- if (node_flags = node.flags) -%>
    <%- node_flags.values.each do |value| -%>

    # def <%= value.name.downcase %>?: () -> bool
    def <%= value.name.downcase %>?
      flags.anybits?(<%= node_flags.name %>::<%= value.name %>)
    end
    <%- end -%>
    <%- end -%>
    <%- node.fields.each do |field| -%>

    <%- if field.comment.nil? -%>
    # attr_reader <%= field.name %>: <%= field.rbs_class %>
    <%- else -%>
    <%- field.each_comment_line do |line| -%>
    #<%= line %>
    <%- end -%>
    <%- end -%>
    <%- case field -%>
    <%- when Prism::Template::LocationField -%>
    def <%= field.name %>
      location = @<%= field.name %>
      return location if location.is_a?(Location)
      @<%= field.name %> = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

    # Save the <%= field.name %> location using the given saved source so that
    # it can be retrieved later.
    def save_<%= field.name %>(repository)
      repository.enter(node_id, :<%= field.name %>)
    end
    <%- when Prism::Template::OptionalLocationField -%>
    def <%= field.name %>
      location = @<%= field.name %>
      case location
      when nil
        nil
      when Location
        location
      else
        @<%= field.name %> = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

    # Save the <%= field.name %> location using the given saved source so that
    # it can be retrieved later.
    def save_<%= field.name %>(repository)
      repository.enter(node_id, :<%= field.name %>) unless @<%= field.name %>.nil?
    end
    <%- else -%>
    attr_reader :<%= field.name %>
    <%- end -%>
    <%- end -%>
    <%- node.fields.each do |field| -%>
    <%- case field -%>
    <%- when Prism::Template::LocationField -%>
    <%- raise unless field.name.end_with?("_loc") -%>
    <%- next if node.fields.any? { |other| other.name == field.name.delete_suffix("_loc") } -%>

    # def <%= field.name.delete_suffix("_loc") %>: () -> String
    def <%= field.name.delete_suffix("_loc") %>
      <%= field.name %>.slice
    end
    <%- when Prism::Template::OptionalLocationField -%>
    <%- raise unless field.name.end_with?("_loc") -%>
    <%- next if node.fields.any? { |other| other.name == field.name.delete_suffix("_loc") } -%>

    # def <%= field.name.delete_suffix("_loc") %>: () -> String?
    def <%= field.name.delete_suffix("_loc") %>
      <%= field.name %>&.slice
    end
    <%- end -%>
    <%- end -%>

    # def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

    # Return a symbol representation of this node type. See `Node#type`.
    def type
      :<%= node.human %>
    end

    # Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :<%= node.human %>
    end

    # Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(<%= node.name %>)<%= " &&" if (fields = [*node.flags, *node.fields]).any? %>
        <%- fields.each_with_index do |field, index| -%>
        <%- if field.is_a?(Prism::Template::LocationField) || field.is_a?(Prism::Template::OptionalLocationField) -%>
        (<%= field.name %>.nil? == other.<%= field.name %>.nil?)<%= " &&" if index != fields.length - 1 %>
        <%- elsif field.is_a?(Prism::Template::NodeListField) || field.is_a?(Prism::Template::ConstantListField) -%>
        (<%= field.name %>.length == other.<%= field.name %>.length) &&
        <%= field.name %>.zip(other.<%= field.name %>).all? { |left, right| left === right }<%= " &&" if index != fields.length - 1 %>
        <%- elsif field.is_a?(Prism::Template::Flags) -%>
        (flags === other.flags)<%= " &&" if index != fields.length - 1 %>
        <%- else -%>
        (<%= field.name %> === other.<%= field.name %>)<%= " &&" if index != fields.length - 1 %>
        <%- end -%>
        <%- end -%>
    end
  end
  <%- end -%>
  <%- flags.each do |flag| -%>

  # <%= flag.comment %>
  module <%= flag.name %>
    <%- flag.values.each_with_index do |value, index| -%>
    # <%= value.comment %>
    <%= value.name %> = 1 << <%= index + Prism::Template::COMMON_FLAGS_COUNT %>
<%= "\n" if value != flag.values.last -%>
    <%- end -%>
  end
  <%- end -%>

  # The flags that are common to all nodes.
  module NodeFlags
    # A flag to indicate that the node is a candidate to emit a :line event
    # through tracepoint when compiled.
    NEWLINE = 1

    # A flag to indicate that the value that the node represents is a value that
    # can be determined at parse-time.
    STATIC_LITERAL = 2
  end
end
prism-1.5.1/templates/lib/prism/reflection.rb.erb000066400000000000000000000120431506127434000217760ustar00rootroot00000000000000module Prism
  # The Reflection module provides the ability to reflect on the structure of
  # the syntax tree itself, as opposed to looking at a single syntax tree. This
  # is useful in metaprogramming contexts.
  module Reflection
    # A field represents a single piece of data on a node. It is the base class
    # for all other field types.
    class Field
      # The name of the field.
      attr_reader :name

      # Initializes the field with the given name.
      def initialize(name)
        @name = name
      end
    end

    # A node field represents a single child node in the syntax tree. It
    # resolves to a Prism::Node in Ruby.
    class NodeField < Field
    end

    # An optional node field represents a single child node in the syntax tree
    # that may or may not be present. It resolves to either a Prism::Node or nil
    # in Ruby.
    class OptionalNodeField < Field
    end

    # A node list field represents a list of child nodes in the syntax tree. It
    # resolves to an array of Prism::Node instances in Ruby.
    class NodeListField < Field
    end

    # A constant field represents a constant value on a node. Effectively, it
    # represents an identifier found within the source. It resolves to a symbol
    # in Ruby.
    class ConstantField < Field
    end

    # An optional constant field represents a constant value on a node that may
    # or may not be present. It resolves to either a symbol or nil in Ruby.
    class OptionalConstantField < Field
    end

    # A constant list field represents a list of constant values on a node. It
    # resolves to an array of symbols in Ruby.
    class ConstantListField < Field
    end

    # A string field represents a string value on a node. It almost always
    # represents the unescaped value of a string-like literal. It resolves to a
    # string in Ruby.
    class StringField < Field
    end

    # A location field represents the location of some part of the node in the
    # source code. For example, the location of a keyword or an operator. It
    # resolves to a Prism::Location in Ruby.
    class LocationField < Field
    end

    # An optional location field represents the location of some part of the
    # node in the source code that may or may not be present. It resolves to
    # either a Prism::Location or nil in Ruby.
    class OptionalLocationField < Field
    end

    # An integer field represents an integer value. It is used to represent the
    # value of an integer literal, the depth of local variables, and the number
    # of a numbered reference. It resolves to an Integer in Ruby.
    class IntegerField < Field
    end

    # A float field represents a double-precision floating point value. It is
    # used exclusively to represent the value of a floating point literal. It
    # resolves to a Float in Ruby.
    class FloatField < Field
    end

    # A flags field represents a bitset of flags on a node. It resolves to an
    # integer in Ruby. Note that the flags cannot be accessed directly on the
    # node because the integer is kept private. Instead, the various flags in
    # the bitset should be accessed through their query methods.
    class FlagsField < Field
      # The names of the flags in the bitset.
      attr_reader :flags

      # Initializes the flags field with the given name and flags.
      def initialize(name, flags)
        super(name)
        @flags = flags
      end
    end

    # Returns the fields for the given node.
    def self.fields_for(node)
      case node.type
      <%- nodes.each do |node| -%>
      when :<%= node.human %>
        [<%= [*node.flags, *node.fields].map { |field|
          case field
          when Prism::Template::NodeField
            "NodeField.new(:#{field.name})"
          when Prism::Template::OptionalNodeField
            "OptionalNodeField.new(:#{field.name})"
          when Prism::Template::NodeListField
            "NodeListField.new(:#{field.name})"
          when Prism::Template::ConstantField
            "ConstantField.new(:#{field.name})"
          when Prism::Template::OptionalConstantField
            "OptionalConstantField.new(:#{field.name})"
          when Prism::Template::ConstantListField
            "ConstantListField.new(:#{field.name})"
          when Prism::Template::StringField
            "StringField.new(:#{field.name})"
          when Prism::Template::LocationField
            "LocationField.new(:#{field.name})"
          when Prism::Template::OptionalLocationField
            "OptionalLocationField.new(:#{field.name})"
          when Prism::Template::UInt8Field, Prism::Template::UInt32Field, Prism::Template::IntegerField
            "IntegerField.new(:#{field.name})"
          when Prism::Template::DoubleField
            "FloatField.new(:#{field.name})"
          when Prism::Template::Flags
            "FlagsField.new(:flags, [#{field.values.map { |value| ":#{value.name.downcase}?" }.join(", ")}])"
          else
            raise field.class.name
          end
        }.join(", ") %>]
      <%- end -%>
      else
        raise "Unknown node type: #{node.type.inspect}"
      end
    end
  end
end
prism-1.5.1/templates/lib/prism/serialize.rb.erb000066400000000000000000000445751506127434000216520ustar00rootroot00000000000000require "stringio"
require_relative "polyfill/unpack1"

module Prism
  # A module responsible for deserializing parse results.
  module Serialize
    # The major version of prism that we are expecting to find in the serialized
    # strings.
    MAJOR_VERSION = 1

    # The minor version of prism that we are expecting to find in the serialized
    # strings.
    MINOR_VERSION = 5

    # The patch version of prism that we are expecting to find in the serialized
    # strings.
    PATCH_VERSION = 1

    # Deserialize the dumped output from a request to parse or parse_file.
    #
    # The formatting of the source of this method is purposeful to illustrate
    # the structure of the serialized data.
    def self.load_parse(input, serialized, freeze)
      input = input.dup
      source = Source.for(input)
      loader = Loader.new(source, serialized)

                       loader.load_header
      encoding =       loader.load_encoding
      start_line =     loader.load_varsint
      offsets =        loader.load_line_offsets(freeze)

      source.replace_start_line(start_line)
      source.replace_offsets(offsets)

      comments =       loader.load_comments(freeze)
      magic_comments = loader.load_magic_comments(freeze)
      data_loc =       loader.load_optional_location_object(freeze)
      errors =         loader.load_errors(encoding, freeze)
      warnings =       loader.load_warnings(encoding, freeze)
      cpool_base =     loader.load_uint32
      cpool_size =     loader.load_varuint

      constant_pool = ConstantPool.new(input, serialized, cpool_base, cpool_size)

      node =           loader.load_node(constant_pool, encoding, freeze)
                       loader.load_constant_pool(constant_pool)
      raise unless     loader.eof?

      result = ParseResult.new(node, comments, magic_comments, data_loc, errors, warnings, source)
      result.freeze if freeze

      input.force_encoding(encoding)

      # This is an extremely niche use-case where the file was marked as binary
      # but it contained UTF-8-encoded characters. In that case we will actually
      # put it back to UTF-8 to give the location APIs the best chance of being
      # correct.
      if !input.ascii_only? && input.encoding == Encoding::BINARY
        input.force_encoding(Encoding::UTF_8)
        input.force_encoding(Encoding::BINARY) unless input.valid_encoding?
      end

      if freeze
        input.freeze
        source.deep_freeze
      end

      result
    end

    # Deserialize the dumped output from a request to lex or lex_file.
    #
    # The formatting of the source of this method is purposeful to illustrate
    # the structure of the serialized data.
    def self.load_lex(input, serialized, freeze)
      source = Source.for(input)
      loader = Loader.new(source, serialized)

      tokens =         loader.load_tokens
      encoding =       loader.load_encoding
      start_line =     loader.load_varsint
      offsets =        loader.load_line_offsets(freeze)

      source.replace_start_line(start_line)
      source.replace_offsets(offsets)

      comments =       loader.load_comments(freeze)
      magic_comments = loader.load_magic_comments(freeze)
      data_loc =       loader.load_optional_location_object(freeze)
      errors =         loader.load_errors(encoding, freeze)
      warnings =       loader.load_warnings(encoding, freeze)
      raise unless     loader.eof?

      result = LexResult.new(tokens, comments, magic_comments, data_loc, errors, warnings, source)

      tokens.each do |token|
        token[0].value.force_encoding(encoding)

        if freeze
          token[0].deep_freeze
          token.freeze
        end
      end

      if freeze
        source.deep_freeze
        tokens.freeze
        result.freeze
      end

      result
    end

    # Deserialize the dumped output from a request to parse_comments or
    # parse_file_comments.
    #
    # The formatting of the source of this method is purposeful to illustrate
    # the structure of the serialized data.
    def self.load_parse_comments(input, serialized, freeze)
      source = Source.for(input)
      loader = Loader.new(source, serialized)

                   loader.load_header
                   loader.load_encoding
      start_line = loader.load_varsint

      source.replace_start_line(start_line)

      result =     loader.load_comments(freeze)
      raise unless loader.eof?

      source.deep_freeze if freeze
      result
    end

    # Deserialize the dumped output from a request to parse_lex or
    # parse_lex_file.
    #
    # The formatting of the source of this method is purposeful to illustrate
    # the structure of the serialized data.
    def self.load_parse_lex(input, serialized, freeze)
      source = Source.for(input)
      loader = Loader.new(source, serialized)

      tokens =         loader.load_tokens
                       loader.load_header
      encoding =       loader.load_encoding
      start_line =     loader.load_varsint
      offsets =        loader.load_line_offsets(freeze)

      source.replace_start_line(start_line)
      source.replace_offsets(offsets)

      comments =       loader.load_comments(freeze)
      magic_comments = loader.load_magic_comments(freeze)
      data_loc =       loader.load_optional_location_object(freeze)
      errors =         loader.load_errors(encoding, freeze)
      warnings =       loader.load_warnings(encoding, freeze)
      cpool_base =     loader.load_uint32
      cpool_size =     loader.load_varuint

      constant_pool = ConstantPool.new(input, serialized, cpool_base, cpool_size)

      node =           loader.load_node(constant_pool, encoding, freeze)
                       loader.load_constant_pool(constant_pool)
      raise unless     loader.eof?

      value = [node, tokens]
      result = ParseLexResult.new(value, comments, magic_comments, data_loc, errors, warnings, source)

      tokens.each do |token|
        token[0].value.force_encoding(encoding)

        if freeze
          token[0].deep_freeze
          token.freeze
        end
      end

      if freeze
        source.deep_freeze
        tokens.freeze
        value.freeze
        result.freeze
      end

      result
    end

    class ConstantPool # :nodoc:
      attr_reader :size

      def initialize(input, serialized, base, size)
        @input = input
        @serialized = serialized
        @base = base
        @size = size
        @pool = Array.new(size, nil)
      end

      def get(index, encoding)
        @pool[index] ||=
          begin
            offset = @base + index * 8
            start = @serialized.unpack1("L", offset: offset)
            length = @serialized.unpack1("L", offset: offset + 4)

            if start.nobits?(1 << 31)
              @input.byteslice(start, length).force_encoding(encoding).to_sym
            else
              @serialized.byteslice(start & ((1 << 31) - 1), length).force_encoding(encoding).to_sym
            end
          end
      end
    end

    if RUBY_ENGINE == "truffleruby"
      # StringIO is synchronized and that adds a high overhead on TruffleRuby.
      class FastStringIO # :nodoc:
        attr_accessor :pos

        def initialize(string)
          @string = string
          @pos = 0
        end

        def getbyte
          byte = @string.getbyte(@pos)
          @pos += 1
          byte
        end

        def read(n)
          slice = @string.byteslice(@pos, n)
          @pos += n
          slice
        end

        def eof?
          @pos >= @string.bytesize
        end
      end
    else
      FastStringIO = ::StringIO # :nodoc:
    end

    class Loader # :nodoc:
      attr_reader :input, :io, :source

      def initialize(source, serialized)
        @input = source.source.dup
        raise unless serialized.encoding == Encoding::BINARY
        @io = FastStringIO.new(serialized)
        @source = source
        define_load_node_lambdas if RUBY_ENGINE != "ruby"
      end

      def eof?
        io.getbyte
        io.eof?
      end

      def load_constant_pool(constant_pool)
        trailer = 0

        constant_pool.size.times do |index|
          start, length = io.read(8).unpack("L2")
          trailer += length if start.anybits?(1 << 31)
        end

        io.read(trailer)
      end

      def load_header
        raise "Invalid serialization" if io.read(5) != "PRISM"
        raise "Invalid serialization" if io.read(3).unpack("C3") != [MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION]
        raise "Invalid serialization (location fields must be included but are not)" if io.getbyte != 0
      end

      def load_encoding
        encoding = Encoding.find(io.read(load_varuint))
        @input = input.force_encoding(encoding).freeze
        encoding
      end

      def load_line_offsets(freeze)
        offsets = Array.new(load_varuint) { load_varuint }
        offsets.freeze if freeze
        offsets
      end

      def load_comments(freeze)
        comments =
          Array.new(load_varuint) do
            comment =
              case load_varuint
              when 0 then InlineComment.new(load_location_object(freeze))
              when 1 then EmbDocComment.new(load_location_object(freeze))
              end

            comment.freeze if freeze
            comment
          end

        comments.freeze if freeze
        comments
      end

      def load_magic_comments(freeze)
        magic_comments =
          Array.new(load_varuint) do
            magic_comment =
              MagicComment.new(
                load_location_object(freeze),
                load_location_object(freeze)
              )

            magic_comment.freeze if freeze
            magic_comment
          end

        magic_comments.freeze if freeze
        magic_comments
      end

      DIAGNOSTIC_TYPES = [
        <%- errors.each do |error| -%>
        <%= error.name.downcase.to_sym.inspect %>,
        <%- end -%>
        <%- warnings.each do |warning| -%>
        <%= warning.name.downcase.to_sym.inspect %>,
        <%- end -%>
      ].freeze

      private_constant :DIAGNOSTIC_TYPES

      def load_error_level
        level = io.getbyte

        case level
        when 0
          :syntax
        when 1
          :argument
        when 2
          :load
        else
          raise "Unknown level: #{level}"
        end
      end

      def load_errors(encoding, freeze)
        errors =
          Array.new(load_varuint) do
            error =
              ParseError.new(
                DIAGNOSTIC_TYPES.fetch(load_varuint),
                load_embedded_string(encoding),
                load_location_object(freeze),
                load_error_level
              )

            error.freeze if freeze
            error
          end

        errors.freeze if freeze
        errors
      end

      def load_warning_level
        level = io.getbyte

        case level
        when 0
          :default
        when 1
          :verbose
        else
          raise "Unknown level: #{level}"
        end
      end

      def load_warnings(encoding, freeze)
        warnings =
          Array.new(load_varuint) do
            warning =
              ParseWarning.new(
                DIAGNOSTIC_TYPES.fetch(load_varuint),
                load_embedded_string(encoding),
                load_location_object(freeze),
                load_warning_level
              )

            warning.freeze if freeze
            warning
          end

        warnings.freeze if freeze
        warnings
      end

      def load_tokens
        tokens = []

        while (type = TOKEN_TYPES.fetch(load_varuint))
          start = load_varuint
          length = load_varuint
          lex_state = load_varuint

          location = Location.new(@source, start, length)
          token = Token.new(@source, type, location.slice, location)

          tokens << [token, lex_state]
        end

        tokens
      end

      # variable-length integer using https://en.wikipedia.org/wiki/LEB128
      # This is also what protobuf uses: https://protobuf.dev/programming-guides/encoding/#varints
      def load_varuint
        n = io.getbyte
        if n < 128
          n
        else
          n -= 128
          shift = 0
          while (b = io.getbyte) >= 128
            n += (b - 128) << (shift += 7)
          end
          n + (b << (shift + 7))
        end
      end

      def load_varsint
        n = load_varuint
        (n >> 1) ^ (-(n & 1))
      end

      def load_integer
        negative = io.getbyte != 0
        length = load_varuint

        value = 0
        length.times { |index| value |= (load_varuint << (index * 32)) }

        value = -value if negative
        value
      end

      def load_double
        io.read(8).unpack1("D")
      end

      def load_uint32
        io.read(4).unpack1("L")
      end

      def load_optional_node(constant_pool, encoding, freeze)
        if io.getbyte != 0
          io.pos -= 1
          load_node(constant_pool, encoding, freeze)
        end
      end

      def load_embedded_string(encoding)
        io.read(load_varuint).force_encoding(encoding).freeze
      end

      def load_string(encoding)
        case (type = io.getbyte)
        when 1
          input.byteslice(load_varuint, load_varuint).force_encoding(encoding).freeze
        when 2
          load_embedded_string(encoding)
        else
          raise "Unknown serialized string type: #{type}"
        end
      end

      def load_location_object(freeze)
        location = Location.new(source, load_varuint, load_varuint)
        location.freeze if freeze
        location
      end

      def load_location(freeze)
        return load_location_object(freeze) if freeze
        (load_varuint << 32) | load_varuint
      end

      def load_optional_location(freeze)
        load_location(freeze) if io.getbyte != 0
      end

      def load_optional_location_object(freeze)
        load_location_object(freeze) if io.getbyte != 0
      end

      def load_constant(constant_pool, encoding)
        index = load_varuint
        constant_pool.get(index - 1, encoding)
      end

      def load_optional_constant(constant_pool, encoding)
        index = load_varuint
        constant_pool.get(index - 1, encoding) if index != 0
      end

      if RUBY_ENGINE == "ruby"
        def load_node(constant_pool, encoding, freeze)
          type = io.getbyte
          node_id = load_varuint
          location = load_location(freeze)
          value = case type
          <%- nodes.each_with_index do |node, index| -%>
          when <%= index + 1 %> then
            <%- if node.needs_serialized_length? -%>
            load_uint32
            <%- end -%>
            <%= node.name %>.new(<%= ["source", "node_id", "location", "load_varuint", *node.fields.map { |field|
              case field
              when Prism::Template::NodeField then "load_node(constant_pool, encoding, freeze)"
              when Prism::Template::OptionalNodeField then "load_optional_node(constant_pool, encoding, freeze)"
              when Prism::Template::StringField then "load_string(encoding)"
              when Prism::Template::NodeListField then "Array.new(load_varuint) { load_node(constant_pool, encoding, freeze) }.tap { |nodes| nodes.freeze if freeze }"
              when Prism::Template::ConstantField then "load_constant(constant_pool, encoding)"
              when Prism::Template::OptionalConstantField then "load_optional_constant(constant_pool, encoding)"
              when Prism::Template::ConstantListField then "Array.new(load_varuint) { load_constant(constant_pool, encoding) }.tap { |constants| constants.freeze if freeze }"
              when Prism::Template::LocationField then "load_location(freeze)"
              when Prism::Template::OptionalLocationField then "load_optional_location(freeze)"
              when Prism::Template::UInt8Field then "io.getbyte"
              when Prism::Template::UInt32Field then "load_varuint"
              when Prism::Template::IntegerField then "load_integer"
              when Prism::Template::DoubleField then "load_double"
              else raise
              end
            }].join(", ") -%>)
            <%- end -%>
          end

          value.freeze if freeze
          value
        end
      else
        def load_node(constant_pool, encoding, freeze)
          @load_node_lambdas[io.getbyte].call(constant_pool, encoding, freeze)
        end

        def define_load_node_lambdas
          @load_node_lambdas = [
            nil,
            <%- nodes.each do |node| -%>
            -> (constant_pool, encoding, freeze) {
              node_id = load_varuint
              location = load_location(freeze)
              <%- if node.needs_serialized_length? -%>
              load_uint32
              <%- end -%>
              value = <%= node.name %>.new(<%= ["source", "node_id", "location", "load_varuint", *node.fields.map { |field|
                case field
                when Prism::Template::NodeField then "load_node(constant_pool, encoding, freeze)"
                when Prism::Template::OptionalNodeField then "load_optional_node(constant_pool, encoding, freeze)"
                when Prism::Template::StringField then "load_string(encoding)"
                when Prism::Template::NodeListField then "Array.new(load_varuint) { load_node(constant_pool, encoding, freeze) }"
                when Prism::Template::ConstantField then "load_constant(constant_pool, encoding)"
                when Prism::Template::OptionalConstantField then "load_optional_constant(constant_pool, encoding)"
                when Prism::Template::ConstantListField then "Array.new(load_varuint) { load_constant(constant_pool, encoding) }"
                when Prism::Template::LocationField then "load_location(freeze)"
                when Prism::Template::OptionalLocationField then "load_optional_location(freeze)"
                when Prism::Template::UInt8Field then "io.getbyte"
                when Prism::Template::UInt32Field then "load_varuint"
                when Prism::Template::IntegerField then "load_integer"
                when Prism::Template::DoubleField then "load_double"
                else raise
                end
              }].join(", ") -%>)
              value.freeze if freeze
              value
            },
            <%- end -%>
          ]
        end
      end
    end

    # The token types that can be indexed by their enum values.
    TOKEN_TYPES = [
      nil,
      <%- tokens.each do |token| -%>
      <%= token.name.to_sym.inspect %>,
      <%- end -%>
    ].freeze

    private_constant :MAJOR_VERSION, :MINOR_VERSION, :PATCH_VERSION
    private_constant :ConstantPool, :FastStringIO, :Loader, :TOKEN_TYPES
  end

  private_constant :Serialize
end
prism-1.5.1/templates/lib/prism/visitor.rb.erb000066400000000000000000000036021506127434000213440ustar00rootroot00000000000000module Prism
  # A class that knows how to walk down the tree. None of the individual visit
  # methods are implemented on this visitor, so it forces the consumer to
  # implement each one that they need. For a default implementation that
  # continues walking the tree, see the Visitor class.
  class BasicVisitor
    # Calls `accept` on the given node if it is not `nil`, which in turn should
    # call back into this visitor by calling the appropriate `visit_*` method.
    def visit(node)
      # @type self: _Visitor
      node&.accept(self)
    end

    # Visits each node in `nodes` by calling `accept` on each one.
    def visit_all(nodes)
      # @type self: _Visitor
      nodes.each { |node| node&.accept(self) }
    end

    # Visits the child nodes of `node` by calling `accept` on each one.
    def visit_child_nodes(node)
      # @type self: _Visitor
      node.compact_child_nodes.each { |node| node.accept(self) }
    end
  end

  # A visitor is a class that provides a default implementation for every accept
  # method defined on the nodes. This means it can walk a tree without the
  # caller needing to define any special handling. This allows you to handle a
  # subset of the tree, while still walking the whole tree.
  #
  # For example, to find all of the method calls that call the `foo` method, you
  # could write:
  #
  #     class FooCalls < Prism::Visitor
  #       def visit_call_node(node)
  #         if node.name == :foo
  #           # Do something with the node
  #         end
  #
  #         # Call super so that the visitor continues walking the tree
  #         super
  #       end
  #     end
  #
  class Visitor < BasicVisitor
    <%- nodes.each_with_index do |node, index| -%>
<%= "\n" if index != 0 -%>
    # Visit a <%= node.name %> node
    def visit_<%= node.human %>(node)
      node.compact_child_nodes.each { |node| node.accept(self) }
    end
    <%- end -%>
  end
end
prism-1.5.1/templates/rbi/000077500000000000000000000000001506127434000154245ustar00rootroot00000000000000prism-1.5.1/templates/rbi/prism/000077500000000000000000000000001506127434000165565ustar00rootroot00000000000000prism-1.5.1/templates/rbi/prism/dsl.rbi.erb000066400000000000000000000046431506127434000206140ustar00rootroot00000000000000module Prism::DSL
  sig { params(string: String).returns(Prism::Source) }
  def source(string); end

  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).returns(Prism::Location) }
  def location(source: default_source, start_offset: 0, length: 0); end
  <%- nodes.each do |node| -%>
  <%-
  params = [
    ["source", "default_source", "Prism::Source"],
    ["node_id", "0", "Integer"],
    ["location", "default_location", "Prism::Location"],
    ["flags", "0", "Integer"]
  ].concat(node.fields.map { |field|
    case field
    when Prism::Template::NodeField
      kind = field.specific_kind || field.union_kind&.first
      if kind.nil?
        [field.name, "default_node(source, location)", field.rbi_class]
      else
        [field.name, %Q{#{kind.gsub(/(?<=.)[A-Z]/, "_\\0").downcase}(source: source)}, field.rbi_class]
      end
    when Prism::Template::OptionalNodeField
      [field.name, "nil", field.rbi_class]
    when Prism::Template::NodeListField
      [field.name, "[]", field.rbi_class]
    when Prism::Template::ConstantField
      [field.name, ":\"\"", field.rbi_class]
    when Prism::Template::OptionalConstantField
      [field.name, "nil", field.rbi_class]
    when Prism::Template::ConstantListField
      [field.name, "[]", field.rbi_class]
    when Prism::Template::StringField
      [field.name, "\"\"", field.rbi_class]
    when Prism::Template::LocationField
      [field.name, "location", field.rbi_class]
    when Prism::Template::OptionalLocationField
      [field.name, "nil", field.rbi_class]
    when Prism::Template::UInt8Field, Prism::Template::UInt32Field, Prism::Template::IntegerField
      [field.name, "0", field.rbi_class]
    when Prism::Template::DoubleField
      [field.name, "0.0", field.rbi_class]
    else
      raise
    end
  })
  -%>

  sig { params(<%= params.map { |(name, _, type)| "#{name}: #{type}" }.join(", ") %>).returns(Prism::<%= node.name %>) }
  def <%= node.human %>(<%= params.map { |(name, default, _)| "#{name}: #{default}" }.join(", ") %>); end
  <%- end -%>
  <%- flags.each do |flag| -%>

  sig { params(name: Symbol).returns(Integer) }
  def <%= flag.human.chomp("s") %>(name); end
  <%- end -%>

  private

  sig { returns(Prism::Source) }
  def default_source; end

  sig { returns(Prism::Location) }
  def default_location; end

  sig { params(source: Prism::Source, location: Prism::Location).returns(Prism::Node) }
  def default_node(source, location); end
end
prism-1.5.1/templates/rbi/prism/node.rbi.erb000066400000000000000000000113671506127434000207600ustar00rootroot00000000000000class Prism::Node
  abstract!

  sig { returns(Prism::Source) }
  def source; end

  sig { returns(Integer) }
  def node_id; end

  sig { returns(Prism::Location) }
  def location; end

  sig{ returns(Integer) }
  def flags; end

  sig { returns(T::Boolean) }
  def newline?; end

  sig { returns(T::Boolean) }
  def static_literal?; end

  sig { returns(Integer) }
  def start_offset; end

  sig { returns(Integer) }
  def end_offset; end

  sig { returns(T::Array[String]) }
  def source_lines; end

  sig { returns(T::Array[String]) }
  def script_lines; end

  sig { returns(String) }
  def slice; end

  sig { returns(String) }
  def slice_lines; end

  sig { params(q: T.untyped).void }
  def pretty_print(q); end

  sig { returns(String) }
  def to_dot; end

  sig { params(line: Integer, column: Integer).returns(T::Array[Prism::Node]) }
  def tunnel(line, column); end

  sig { params(block: T.proc.params(node: Prism::Node).returns(T::Boolean)).returns(T.nilable(Prism::Node)) }
  def breadth_first_search(&block); end

  sig { abstract.params(visitor: Prism::Visitor).returns(T.untyped) }
  def accept(visitor); end

  sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) }
  def child_nodes; end

  sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) }
  def deconstruct; end

  sig { abstract.returns(T::Array[Prism::Node]) }
  def compact_child_nodes; end

  sig { abstract.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
  def comment_targets; end

  sig { abstract.returns(T::Array[Prism::Reflection::Field]) }
  def fields; end

  sig { abstract.returns(Symbol) }
  def type; end

  sig { abstract.returns(String) }
  def inspect; end
end
<%- nodes.each do |node| -%>

<%- node.each_comment_line do |line| -%>
#<%= line %>
<%- end -%>
class Prism::<%= node.name -%> < Prism::Node
  <%- if (node_flags = node.flags) -%>
  <%- node_flags.values.each do |value| -%>
  sig { returns(T::Boolean) }
  def <%= value.name.downcase %>?; end

  <%- end -%>
  <%- end -%>
  <%- node.fields.each do |field| -%>
  sig { returns(<%= field.rbi_class %>) }
  def <%= field.name %>; end

  <%- end -%>
  sig { params(<%= ["source: Prism::Source", "node_id: Integer", "location: Prism::Location", "flags: Integer", *node.fields.map { |field| "#{field.name}: #{field.rbi_class}" }].join(", ") %>).void }
  def initialize(<%= ["source", "node_id", "location", "flags", *node.fields.map(&:name)].join(", ") %>); end

  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
  def accept(visitor); end

  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
  def child_nodes; end

  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
  def deconstruct; end

  sig { override.returns(T::Array[Prism::Node]) }
  def compact_child_nodes; end

  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
  def comment_targets; end

  sig { params(<%= (["node_id: Integer", "location: Prism::Location", "flags: Integer"] + node.fields.map { |field| "#{field.name}: #{field.rbi_class}" }).join(", ") %>).returns(Prism::<%= node.name %>) }
  def copy(<%= (["node_id", "location", "flags"] + node.fields.map(&:name)).map { |field| "#{field}: self.#{field}" }.join(", ") %>); end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end
  <%- node.fields.each do |field| -%>
  <%- case field -%>
  <%- when Prism::Template::LocationField -%>
  <%- raise unless field.name.end_with?("_loc") -%>
  <%- next if node.fields.any? { |other| other.name == field.name.delete_suffix("_loc") } -%>

  sig { returns(String) }
  def <%= field.name.delete_suffix("_loc") %>; end
  <%- when Prism::Template::OptionalLocationField -%>
  <%- raise unless field.name.end_with?("_loc") -%>
  <%- next if node.fields.any? { |other| other.name == field.name.delete_suffix("_loc") } -%>

  sig { returns(T.nilable(String)) }
  def <%= field.name.delete_suffix("_loc") %>; end
  <%- end -%>
  <%- end -%>

  sig { override.returns(T::Array[Prism::Reflection::Field]) }
  def fields; end

  sig { override.returns(String) }
  def inspect; end

  sig { override.returns(Symbol) }
  def type; end
end
<%- end -%>
<%- flags.each do |flag| -%>

# <%= flag.comment %>
module Prism::<%= flag.name %>
  <%- flag.values.each_with_index do |value, index| -%>
  # <%= value.comment %>
  <%= value.name %> = T.let(1 << <%= index + Prism::Template::COMMON_FLAGS_COUNT %>, Integer)
  <%- end -%>
end
<%- end -%>

# The flags that are common to all nodes.
module Prism::NodeFlags
  # A flag to indicate that the node is a candidate to emit a :line event
  # through tracepoint when compiled.
  NEWLINE = T.let(1, Integer)

  # A flag to indicate that the value that the node represents is a value that
  # can be determined at parse-time.
  STATIC_LITERAL = T.let(2, Integer)
end
prism-1.5.1/templates/rbi/prism/visitor.rbi.erb000066400000000000000000000007721506127434000215300ustar00rootroot00000000000000class Prism::BasicVisitor
  sig { params(node: T.nilable(Prism::Node)).void }
  def visit(node); end

  sig { params(nodes: T::Array[T.nilable(Prism::Node)]).void }
  def visit_all(nodes); end

  sig { params(node: Prism::Node).void }
  def visit_child_nodes(node); end
end

class Prism::Visitor < Prism::BasicVisitor
  <%- nodes.each_with_index do |node, index| -%>
<%= "\n" if index != 0 -%>
  sig { params(node: Prism::<%= node.name %>).void }
  def visit_<%= node.human %>(node); end
  <%- end -%>
end
prism-1.5.1/templates/sig/000077500000000000000000000000001506127434000154325ustar00rootroot00000000000000prism-1.5.1/templates/sig/prism.rbs.erb000066400000000000000000000040241506127434000200430ustar00rootroot00000000000000module Prism
  BACKEND: :CEXT | :FFI
  VERSION: String

  # Methods taking a Ruby source code string:
  <%-
    {
      parse: "ParseResult",
      profile: "nil",
      lex: "LexResult",
      lex_compat: "LexCompat::Result",
      parse_lex: "ParseLexResult",
      dump: "String",
      parse_comments: "Array[comment]",
      parse_success?: "bool",
      parse_failure?: "bool",
    }.each do |method, return_type|
  -%>

  def self.<%= method %>: (
    String source,
    ?encoding: Encoding | false,
    ?filepath: String,
    ?freeze: bool,
    ?frozen_string_literal: bool,
    ?line: Integer,
    ?main_script: bool,
    ?offset: Integer,
    ?scopes: Array[Array[Symbol]],
    ?verbose: bool
  ) -> <%= return_type %>
  <%- end -%>

  def self.load: (
    String source,
    String serialized,
    ?bool freeze
  ) -> ParseResult

  def self.lex_ripper: (
    String source
  ) -> Array[[[Integer, Integer], Symbol, String, untyped]]

  # Methods taking a path to a Ruby file:
  <%-
    {
      parse_file: "ParseResult",
      profile_file: "nil",
      lex_file: "LexResult",
      parse_lex_file: "ParseLexResult",
      dump_file: "String",
      parse_file_comments: "Array[comment]",
      parse_file_success?: "bool",
      parse_file_failure?: "bool",
    }.each do |method, return_type|
  -%>

  def self.<%= method %>: (
    String filepath,
    ?encoding: Encoding | false,
    ?freeze: bool,
    ?frozen_string_literal: bool,
    ?line: Integer,
    ?main_script: bool,
    ?offset: Integer,
    ?scopes: Array[Array[Symbol]],
    ?verbose: bool
  ) -> <%= return_type %>
  <%- end -%>

  interface _Stream
    def gets: (?Integer integer) -> (String | nil)
  end

  def self.parse_stream: (
    _Stream stream,
    ?encoding: Encoding | false,
    ?filepath: String,
    ?freeze: bool,
    ?frozen_string_literal: bool,
    ?line: Integer,
    ?main_script: bool,
    ?offset: Integer,
    ?scopes: Array[Array[Symbol]],
    ?verbose: bool
  ) -> ParseResult

  def self.scope: (?locals: Array[Symbol], ?forwarding: Array[Symbol]) -> Scope
end
prism-1.5.1/templates/sig/prism/000077500000000000000000000000001506127434000165645ustar00rootroot00000000000000prism-1.5.1/templates/sig/prism/_private/000077500000000000000000000000001506127434000203755ustar00rootroot00000000000000prism-1.5.1/templates/sig/prism/_private/dot_visitor.rbs.erb000066400000000000000000000022301506127434000242160ustar00rootroot00000000000000module Prism
  class DotVisitor < Visitor
    class Field
      attr_reader name: String
      attr_reader value: String?
      attr_reader port: bool

      def initialize: (String name, String? value, bool port) -> void
      def to_dot: () -> String
    end

    class Table
      attr_reader name: String
      attr_reader fields: Array[Field]

      def initialize: (String name) -> void
      def field: (String name, ?String? value, ?port: bool) -> void
      def to_dot: () -> String
    end

    class Digraph
      attr_reader nodes: Array[String]
      attr_reader waypoints: Array[String]
      attr_reader edges: Array[String]

      def initialize: () -> void
      def node: (String value) -> void
      def waypoint: (String value) -> void
      def edge: (String value) -> void

      def to_dot: () -> String
    end

    attr_reader digraph: Digraph

    private

    def node_id: (Prism::node node) -> String
    def location_inspect: (Location location) -> String

    <%- flags.each do |flag| -%>
    def <%= flag.human %>_inspect: (<%= nodes.filter_map { |node| node.name if node.flags == flag }.join(" | ") %> node) -> String
    <%- end -%>
  end
end
prism-1.5.1/templates/sig/prism/dsl.rbs.erb000066400000000000000000000014741506127434000206330ustar00rootroot00000000000000module Prism
  module DSL
    def source: (String string) -> Source

    def location: (?source: Source, ?start_offset: Integer, ?length: Integer) -> Location
    <%- nodes.each do |node| -%>
    <%-
    params = [
      ["source", "Source"],
      ["node_id", "Integer"],
      ["location", "Location"],
      ["flags", "Integer"]
    ].concat(node.fields.map { |field| [field.name, field.rbs_class] })
    -%>

    def <%= node.human %>: (<%= params.map { |(name, type)| "?#{name}: #{type}" }.join(", ") %>) -> <%= node.name %>
    <%- end -%>
    <%- flags.each do |flag| -%>

    def <%= flag.human.chomp("s") %>: (Symbol name) -> Integer
    <%- end -%>

    private

    def default_source: () -> Source

    def default_location: () -> Location

    def default_node: (Source source, Location location) -> node
  end
end
prism-1.5.1/templates/sig/prism/mutation_compiler.rbs.erb000066400000000000000000000002511506127434000235730ustar00rootroot00000000000000module Prism
  class MutationCompiler < Compiler
    <%- nodes.each do |node| -%>
    def visit_<%= node.human %>: (<%= node.name %>) -> node?
    <%- end -%>
  end
end
prism-1.5.1/templates/sig/prism/node.rbs.erb000066400000000000000000000112441506127434000207720ustar00rootroot00000000000000module Prism
  class Node
    attr_reader source: Source
    attr_reader node_id: Integer
    attr_reader location: Location
    attr_reader flags: Integer

    def newline?: () -> bool
    def static_literal?: () -> bool

    def accept: (_Visitor) -> void
    def child_nodes: () -> Array[Prism::node?]
    def comment_targets: () -> Array[Prism::node | Location]
    def compact_child_nodes: () -> Array[Prism::node]
    def self.fields: () -> Array[Prism::Reflection::Field]
    def type: () -> Symbol
    def self.type: () -> Symbol

    def source_lines: () -> Array[String]
    alias script_lines source_lines
    def slice: () -> String
    def slice_lines: () -> String
    def pretty_print: (untyped q) -> untyped
    def to_dot: () -> String
    def tunnel: (Integer line, Integer column) -> Array[Prism::node]
    def breadth_first_search: () { (Prism::node) -> bool } -> Prism::node?
    def newline!: (Array[untyped]) -> void

    def save: (_Repository repository) -> void
    def save_location: (_Repository repository) -> void

    def leading_comments: () -> Array[comment]
    def trailing_comments: () -> Array[comment]
    def comments: () -> Array[comment]

    def start_offset: () -> Integer
    def start_character_offset: () -> Integer
    def start_code_units_offset: (Encoding encoding) -> Integer
    def cached_start_code_units_offset: (_CodeUnitsCache cache) -> Integer

    def end_offset: () -> Integer
    def end_character_offset: () -> Integer
    def end_code_units_offset: (Encoding encoding) -> Integer
    def cached_end_code_units_offset: (_CodeUnitsCache cache) -> Integer

    def start_line: () -> Integer
    def end_line: () -> Integer

    def start_column: () -> Integer
    def start_character_column: () -> Integer
    def start_code_units_column: (Encoding encoding) -> Integer
    def cached_start_code_units_column: (_CodeUnitsCache cache) -> Integer

    def end_column: () -> Integer
    def end_character_column: () -> Integer
    def end_code_units_column: (Encoding encoding) -> Integer
    def cached_end_code_units_column: (_CodeUnitsCache cache) -> Integer
  end

  # Methods implemented by every subclass of Node
  interface _Node
    def deconstruct: () -> Array[Prism::node?]
    def inspect: () -> String
  end

  type node = Node & _Node

  interface _Repository
    def enter: (Integer node_id, Symbol field_name) -> void
  end

  <%- nodes.each do |node| -%>

  <%- node.each_comment_line do |line| -%>
  #<%= line %>
  <%- end -%>
  class <%= node.name -%> < Node
    include _Node
    <%- if (node_flags = node.flags) -%>

    <%- node_flags.values.each do |value| -%>
    def <%= value.name.downcase %>?: () -> bool
    <%- end -%>
    <%- end -%>

    <%- node.fields.each do |field| -%>
    attr_reader <%= field.name %>: <%= field.rbs_class %>
    <%- end -%>
    <%- if (locations = node.fields.select { |field| field.is_a?(Prism::Template::LocationField) || field.is_a?(Prism::Template::OptionalLocationField) }) -%>

    <%- locations.each do |field| -%>
    def save_<%= field.name %>: (_Repository repository) -> void
    <%- end -%>
    <%- end -%>

    def initialize: (<%= ["Source source", "Integer node_id", "Location location", "Integer flags", *node.fields.map { |field| "#{field.rbs_class} #{field.name}" }].join(", ") %>) -> void
    def copy: (<%= (["?node_id: Integer", "?location: Location", "?flags: Integer"] + node.fields.map { |field| "?#{field.name}: #{field.rbs_class}" }).join(", ") %>) -> <%= node.name %>
    def deconstruct_keys: (Array[Symbol] keys) -> { <%= (["node_id: Integer", "location: Location"] + node.fields.map { |field| "#{field.name}: #{field.rbs_class}" }).join(", ") %> }
    <%- node.fields.each do |field| -%>
    <%- case field -%>
    <%- when Prism::Template::LocationField -%>
    <%- raise unless field.name.end_with?("_loc") -%>
    <%- next if node.fields.any? { |other| other.name == field.name.delete_suffix("_loc") } -%>
    def <%= field.name.delete_suffix("_loc") %>: () -> String
    <%- when Prism::Template::OptionalLocationField -%>
    <%- raise unless field.name.end_with?("_loc") -%>
    <%- next if node.fields.any? { |other| other.name == field.name.delete_suffix("_loc") } -%>
    def <%= field.name.delete_suffix("_loc") %>: () -> String?
    <%- end -%>
    <%- end -%>
    def type: () -> :<%= node.human %>
            | ...
    def self.type: () -> :<%= node.human %>
  end
  <%- end -%>
  <%- flags.each do |flag| -%>

  # <%= flag.comment %>
  module <%= flag.name %>
    <%- flag.values.each do |value| -%>
    # <%= value.comment %>
    <%= value.name %>: Integer
    <%- end -%>
  end
  <%- end -%>

  # The flags that are common to all nodes.
  module NodeFlags
    NEWLINE: Integer
    STATIC_LITERAL: Integer
  end
end
prism-1.5.1/templates/sig/prism/visitor.rbs.erb000066400000000000000000000005701506127434000215440ustar00rootroot00000000000000module Prism
  class BasicVisitor
    def visit: (Prism::node?) -> void
    def visit_all: (Array[Prism::node?]) -> void
    def visit_child_nodes: (Prism::node) -> void
  end

  interface _Visitor
    <%- nodes.each do |node| -%>
    def visit_<%= node.human %>: (<%= node.name %>) -> void
    <%- end -%>
  end

  class Visitor < BasicVisitor
    include _Visitor
  end
end
prism-1.5.1/templates/src/000077500000000000000000000000001506127434000154375ustar00rootroot00000000000000prism-1.5.1/templates/src/diagnostic.c.erb000066400000000000000000001335161506127434000205070ustar00rootroot00000000000000#include "prism/diagnostic.h"

#define PM_DIAGNOSTIC_ID_MAX <%= errors.length + warnings.length %>

/** This struct holds the data for each diagnostic. */
typedef struct {
    /** The message associated with the diagnostic. */
    const char* message;

    /** The level associated with the diagnostic. */
    uint8_t level;
} pm_diagnostic_data_t;

/**
 * ## Message composition
 *
 * When composing an error message, use sentence fragments.
 *
 * Try describing the property of the code that caused the error, rather than
 * the rule that is being violated. It may help to use a fragment that completes
 * a sentence beginning, "the parser encountered (a) ...". If appropriate, add a
 * description of the rule violation (or other helpful context) after a
 * semicolon.
 *
 * For example:, instead of "control escape sequence cannot be doubled", prefer:
 *
 * > "invalid control escape sequence; control cannot be repeated"
 *
 * In some cases, where the failure is more general or syntax expectations are
 * violated, it may make more sense to use a fragment that completes a sentence
 * beginning, "the parser ...".
 *
 * For example:
 *
 * > "expected an expression after `(`"
 * > "cannot parse the expression"
 *
 * ## Message style guide
 *
 * - Use articles like "a", "an", and "the" when appropriate.
 *   - e.g., prefer "cannot parse the expression" to "cannot parse expression".
 * - Use the common name for tokens and nodes.
 *   - e.g., prefer "keyword splat" to "assoc splat"
 *   - e.g., prefer "embedded document" to "embdoc"
 * - Do not capitalize the initial word of the message.
 * - Use back ticks around token literals
 *   - e.g., "Expected a `=>` between the hash key and value"
 * - Do not use `.` or other punctuation at the end of the message.
 * - Do not use contractions like "can't". Prefer "cannot" to "can not".
 * - For tokens that can have multiple meanings, reference the token and its meaning.
 *   - e.g., "`*` splat argument" is clearer and more complete than "splat argument" or "`*` argument"
 *
 * ## Error names (PM_ERR_*)
 *
 * - When appropriate, prefer node name to token name.
 *   - e.g., prefer "SPLAT" to "STAR" in the context of argument parsing.
 * - Prefer token name to common name.
 *   - e.g., prefer "STAR" to "ASTERISK".
 * - Try to order the words in the name from more general to more specific,
 *   - e.g., "INVALID_NUMBER_DECIMAL" is better than "DECIMAL_INVALID_NUMBER".
 *   - When in doubt, look for similar patterns and name them so that they are grouped when lexically
 *     sorted. See PM_ERR_ARGUMENT_NO_FORWARDING_* for an example.
 *
 * ## Level
 *
 * For errors, they are:
 *
 * * `PM_ERROR_LEVEL_SYNTAX` - Errors that should raise SyntaxError.
 * * `PM_ERROR_LEVEL_ARGUMENT` - Errors that should raise ArgumentError.
 * * `PM_ERROR_LEVEL_LOAD` - Errors that should raise LoadError.
 *
 * For warnings, they are:
 *
 * * `PM_WARNING_LEVEL_DEFAULT` - Warnings that appear for `ruby -c -e 'code'`.
 * * `PM_WARNING_LEVEL_VERBOSE` - Warnings that appear with `-w`, as in `ruby -w -c -e 'code'`.
 */
static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
    // Special error that can be replaced
    [PM_ERR_CANNOT_PARSE_EXPRESSION]            = { "cannot parse the expression", PM_ERROR_LEVEL_SYNTAX },

    // Errors that should raise argument errors
    [PM_ERR_INVALID_ENCODING_MAGIC_COMMENT]     = { "unknown or invalid encoding in the magic comment", PM_ERROR_LEVEL_ARGUMENT },

    // Errors that should raise load errors
    [PM_ERR_SCRIPT_NOT_FOUND]                   = { "no Ruby script found in input", PM_ERROR_LEVEL_LOAD },

    // Errors that should raise syntax errors
    [PM_ERR_ALIAS_ARGUMENT]                     = { "invalid argument being passed to `alias`; expected a bare word, symbol, constant, or global variable", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ALIAS_ARGUMENT_NUMBERED_REFERENCE]  = { "invalid argument being passed to `alias`; can't make alias for the number variables", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_AMPAMPEQ_MULTI_ASSIGN]              = { "unexpected `&&=` in a multiple assignment", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_AFTER_BLOCK]               = { "unexpected argument after a block argument", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_AFTER_FORWARDING_ELLIPSES] = { "unexpected argument after `...`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_BARE_HASH]                 = { "unexpected bare hash argument", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_BLOCK_MULTI]               = { "both block arg and actual block given; only one block is allowed", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_CONFLICT_AMPERSAND]        = { "unexpected `&`; anonymous block parameter is also used within block", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_CONFLICT_STAR]             = { "unexpected `*`; anonymous rest parameter is also used within block", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_CONFLICT_STAR_STAR]        = { "unexpected `**`; anonymous keyword rest parameter is also used within block", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_FORMAL_CLASS]              = { "invalid formal argument; formal argument cannot be a class variable", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_FORMAL_CONSTANT]           = { "invalid formal argument; formal argument cannot be a constant", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_FORMAL_GLOBAL]             = { "invalid formal argument; formal argument cannot be a global variable", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_FORMAL_IVAR]               = { "invalid formal argument; formal argument cannot be an instance variable", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_FORWARDING_UNBOUND]        = { "unexpected `...` in an non-parenthesized call", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_NO_FORWARDING_AMPERSAND]   = { "unexpected `&`; no anonymous block parameter", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_NO_FORWARDING_ELLIPSES]    = { "unexpected ... when the parent method is not forwarding", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_NO_FORWARDING_STAR]        = { "unexpected `*`; no anonymous rest parameter", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_NO_FORWARDING_STAR_STAR]   = { "unexpected `**`; no anonymous keyword rest parameter", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT]   = { "unexpected `*` splat argument after a `**` keyword splat argument", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_SPLAT_AFTER_SPLAT]         = { "unexpected `*` splat argument after a `*` splat argument", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_TERM_PAREN]                = { "unexpected %s; expected a `)` to close the arguments", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARGUMENT_UNEXPECTED_BLOCK]          = { "unexpected '{' after a method call without parenthesis", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARRAY_ELEMENT]                      = { "expected an element for the array", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARRAY_EXPRESSION]                   = { "expected an expression for the array element", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARRAY_EXPRESSION_AFTER_STAR]        = { "expected an expression after `*` in the array", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARRAY_SEPARATOR]                    = { "unexpected %s; expected a `,` separator for the array elements", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ARRAY_TERM]                         = { "unexpected %s; expected a `]` to close the array", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_BEGIN_LONELY_ELSE]                  = { "unexpected `else` in `begin` block; else without rescue is useless", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_BEGIN_TERM]                         = { "expected an `end` to close the `begin` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_BEGIN_UPCASE_BRACE]                 = { "expected a `{` after `BEGIN`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_BEGIN_UPCASE_TERM]                  = { "expected a `}` to close the `BEGIN` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_BEGIN_UPCASE_TOPLEVEL]              = { "BEGIN is permitted only at toplevel", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_BLOCK_PARAM_LOCAL_VARIABLE]         = { "expected a local variable name in the block parameters", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_BLOCK_PARAM_PIPE_TERM]              = { "expected the block parameters to end with `|`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_BLOCK_TERM_BRACE]                   = { "expected a block beginning with `{` to end with `}`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_BLOCK_TERM_END]                     = { "expected a block beginning with `do` to end with `end`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CANNOT_PARSE_STRING_PART]           = { "cannot parse the string part", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CASE_EXPRESSION_AFTER_CASE]         = { "expected an expression after `case`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CASE_EXPRESSION_AFTER_WHEN]         = { "expected an expression after `when`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CASE_MATCH_MISSING_PREDICATE]       = { "expected a predicate for a case matching statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CASE_MISSING_CONDITIONS]            = { "expected a `when` or `in` clause after `case`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CASE_TERM]                          = { "expected an `end` to close the `case` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CLASS_IN_METHOD]                    = { "unexpected class definition in method body", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CLASS_NAME]                         = { "unexpected constant path after `class`; class/module name must be CONSTANT", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CLASS_SUPERCLASS]                   = { "expected a superclass after `<`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CLASS_TERM]                         = { "expected an `end` to close the `class` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CLASS_UNEXPECTED_END]               = { "unexpected `end`, expecting ';' or '\\n'", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CLASS_VARIABLE_BARE]                = { "'@@' without identifiers is not allowed as a class variable name", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CONDITIONAL_ELSIF_PREDICATE]        = { "expected a predicate expression for the `elsif` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CONDITIONAL_IF_PREDICATE]           = { "expected a predicate expression for the `if` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CONDITIONAL_PREDICATE_TERM]         = { "expected `then` or `;` or '\\n'", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CONDITIONAL_TERM]                   = { "expected an `end` to close the conditional clause", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CONDITIONAL_TERM_ELSE]              = { "expected an `end` to close the `else` clause", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CONDITIONAL_UNLESS_PREDICATE]       = { "expected a predicate expression for the `unless` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CONDITIONAL_UNTIL_PREDICATE]        = { "expected a predicate expression for the `until` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CONDITIONAL_WHILE_PREDICATE]        = { "expected a predicate expression for the `while` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT] = { "expected a constant after the `::` operator", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_DEF_ENDLESS]                        = { "could not parse the endless method body", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_DEF_ENDLESS_SETTER]                 = { "invalid method name; a setter method cannot be defined in an endless method definition", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_DEF_NAME]                           = { "unexpected %s; expected a method name", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_DEF_PARAMS_TERM]                    = { "expected a delimiter to close the parameters", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_DEF_PARAMS_TERM_PAREN]              = { "unexpected %s; expected a `)` to close the parameters", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_DEF_RECEIVER]                       = { "expected a receiver for the method definition", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_DEF_RECEIVER_TERM]                  = { "expected a `.` or `::` after the receiver in a method definition", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_DEF_TERM]                           = { "expected an `end` to close the `def` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_DEFINED_EXPRESSION]                 = { "expected an expression after `defined?`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EMBDOC_TERM]                        = { "embedded document meets end of file", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EMBEXPR_END]                        = { "expected a `}` to close the embedded expression", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EMBVAR_INVALID]                     = { "invalid embedded variable", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_END_UPCASE_BRACE]                   = { "expected a `{` after `END`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_END_UPCASE_TERM]                    = { "expected a `}` to close the `END` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ESCAPE_INVALID_CONTROL]             = { "Invalid escape character syntax", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ESCAPE_INVALID_CONTROL_REPEAT]      = { "invalid control escape sequence; control cannot be repeated", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ESCAPE_INVALID_HEXADECIMAL]         = { "invalid hex escape sequence", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ESCAPE_INVALID_META]                = { "Invalid escape character syntax", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ESCAPE_INVALID_META_REPEAT]         = { "invalid meta escape sequence; meta cannot be repeated", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ESCAPE_INVALID_UNICODE]             = { "invalid Unicode escape sequence", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ESCAPE_INVALID_UNICODE_CM_FLAGS]    = { "invalid Unicode escape sequence; Unicode cannot be combined with control or meta flags", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ESCAPE_INVALID_UNICODE_LIST]        = { "invalid Unicode list: %.*s", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ESCAPE_INVALID_UNICODE_LITERAL]     = { "invalid Unicode escape sequence; Multiple codepoints at single character literal are disallowed", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ESCAPE_INVALID_UNICODE_LONG]        = { "invalid Unicode escape sequence; maximum length is 6 digits", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ESCAPE_INVALID_UNICODE_SHORT]       = { "too short escape sequence: %.*s", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_ESCAPE_INVALID_UNICODE_TERM]        = { "unterminated Unicode escape", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_ARGUMENT]                    = { "unexpected %s; expected an argument", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_EOL_AFTER_STATEMENT]         = { "unexpected %s, expecting end-of-input", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ]   = { "expected an expression after `&&=`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ] = { "expected an expression after `||=`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_EXPRESSION_AFTER_COMMA]      = { "expected an expression after `,`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_EXPRESSION_AFTER_EQUAL]      = { "expected an expression after `=`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_EXPRESSION_AFTER_LESS_LESS]  = { "expected an expression after `<<`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_EXPRESSION_AFTER_LPAREN]     = { "expected an expression after `(`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR]   = { "unexpected %s; expected an expression after the operator", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_EXPRESSION_AFTER_SPLAT]      = { "expected an expression after `*` splat in an argument", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_EXPRESSION_AFTER_SPLAT_HASH] = { "expected an expression after `**` in a hash", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_EXPRESSION_AFTER_STAR]       = { "expected an expression after `*`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_FOR_DELIMITER]               = { "unexpected %s; expected a 'do', newline, or ';' after the 'for' loop collection", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_IDENT_REQ_PARAMETER]         = { "expected an identifier for the required parameter", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_IN_DELIMITER]                = { "expected a delimiter after the patterns of an `in` clause", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_LPAREN_AFTER_NOT_LPAREN]     = { "expected a `(` immediately after `not`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_LPAREN_AFTER_NOT_OTHER]      = { "expected a `(` after `not`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_LPAREN_REQ_PARAMETER]        = { "expected a `(` to start a required parameter", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_MESSAGE]                     = { "unexpected %s; expecting a message to send to the receiver", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_RBRACKET]                    = { "expected a matching `]`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_RPAREN]                      = { "expected a matching `)`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_RPAREN_AFTER_MULTI]          = { "expected a `)` after multiple assignment", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_RPAREN_REQ_PARAMETER]        = { "expected a `)` to end a required parameter", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_SINGLETON_CLASS_DELIMITER]   = { "unexpected %s; expected a newline or a ';' after the singleton class", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_STRING_CONTENT]              = { "expected string content after opening string delimiter", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPECT_WHEN_DELIMITER]              = { "expected a delimiter after the predicates of a `when` clause", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPRESSION_BARE_HASH]               = { "unexpected bare hash in expression", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPRESSION_NOT_WRITABLE]            = { "unexpected '='; target cannot be written", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPRESSION_NOT_WRITABLE_ENCODING]   = { "Can't assign to __ENCODING__", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPRESSION_NOT_WRITABLE_FALSE]      = { "Can't assign to false", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPRESSION_NOT_WRITABLE_FILE]       = { "Can't assign to __FILE__", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPRESSION_NOT_WRITABLE_LINE]       = { "Can't assign to __LINE__", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPRESSION_NOT_WRITABLE_NIL]        = { "Can't assign to nil", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPRESSION_NOT_WRITABLE_NUMBERED]   = { "Can't assign to numbered parameter %.2s", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPRESSION_NOT_WRITABLE_SELF]       = { "Can't change the value of self", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_EXPRESSION_NOT_WRITABLE_TRUE]       = { "Can't assign to true", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_FLOAT_PARSE]                        = { "could not parse the float '%.*s'", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_FOR_COLLECTION]                     = { "expected a collection after the `in` in a `for` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_FOR_INDEX]                          = { "expected an index after `for`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_FOR_IN]                             = { "expected an `in` after the index in a `for` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_FOR_TERM]                           = { "expected an `end` to close the `for` loop", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_GLOBAL_VARIABLE_BARE]               = { "'$' without identifiers is not allowed as a global variable name", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_HASH_EXPRESSION_AFTER_LABEL]        = { "expected an expression after the label in a hash", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_HASH_KEY]                           = { "unexpected %s, expecting '}' or a key in the hash literal", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_HASH_ROCKET]                        = { "expected a `=>` between the hash key and value", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_HASH_TERM]                          = { "expected a `}` to close the hash literal", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_HASH_VALUE]                         = { "unexpected %s; expected a value in the hash literal", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_HEREDOC_IDENTIFIER]                 = { "unterminated here document identifier", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_HEREDOC_TERM]                       = { "unterminated heredoc; can't find string \"%.*s\" anywhere before EOF", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INCOMPLETE_QUESTION_MARK]           = { "incomplete expression at `?`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INCOMPLETE_VARIABLE_CLASS_3_3]      = { "`%.*s' is not allowed as a class variable name", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INCOMPLETE_VARIABLE_CLASS]          = { "'%.*s' is not allowed as a class variable name", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INCOMPLETE_VARIABLE_INSTANCE_3_3]   = { "`%.*s' is not allowed as an instance variable name", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INCOMPLETE_VARIABLE_INSTANCE]       = { "'%.*s' is not allowed as an instance variable name", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INSTANCE_VARIABLE_BARE]             = { "'@' without identifiers is not allowed as an instance variable name", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_BLOCK_EXIT]                 = { "Invalid %s", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_COMMA]                      = { "invalid comma", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_ESCAPE_CHARACTER]           = { "Invalid escape character syntax", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_FLOAT_EXPONENT]             = { "invalid exponent", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_LOCAL_VARIABLE_READ]        = { "identifier %.*s is not valid to get", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_LOCAL_VARIABLE_WRITE]       = { "identifier %.*s is not valid to set", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_NUMBER_BINARY]              = { "invalid binary number; numeric literal without digits", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_NUMBER_DECIMAL]             = { "invalid decimal number; numeric literal without digits", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_NUMBER_FRACTION]            = { "unexpected fraction part after numeric literal", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_NUMBER_HEXADECIMAL]         = { "invalid hexadecimal number; numeric literal without digits", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_NUMBER_OCTAL]               = { "invalid octal number; numeric literal without digits", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_NUMBER_UNDERSCORE_INNER]    = { "invalid underscore placement in number", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_NUMBER_UNDERSCORE_TRAILING] = { "trailing '_' in number", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_CHARACTER]                  = { "Invalid char '\\x%02X' in expression", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_MULTIBYTE_CHAR]             = { "invalid multibyte char (%s)", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_MULTIBYTE_CHARACTER]        = { "invalid multibyte character 0x%X", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_MULTIBYTE_ESCAPE]           = { "invalid multibyte escape: /%.*s/", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_PRINTABLE_CHARACTER]        = { "invalid character `%c`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_PERCENT]                    = { "unknown type of %string", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_PERCENT_EOF]                = { "unterminated quoted string meets end of file", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_RETRY_AFTER_ELSE]           = { "Invalid retry after else", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_RETRY_AFTER_ENSURE]         = { "Invalid retry after ensure", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_RETRY_WITHOUT_RESCUE]       = { "Invalid retry without rescue", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_SYMBOL]                     = { "invalid symbol", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_VARIABLE_GLOBAL_3_3]        = { "`%.*s' is not allowed as a global variable name", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_VARIABLE_GLOBAL]            = { "'%.*s' is not allowed as a global variable name", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_INVALID_YIELD]                      = { "Invalid yield", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_IT_NOT_ALLOWED_NUMBERED]            = { "'it' is not allowed when a numbered parameter is already used", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_IT_NOT_ALLOWED_ORDINARY]            = { "'it' is not allowed when an ordinary parameter is defined", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_LAMBDA_OPEN]                        = { "expected a `do` keyword or a `{` to open the lambda block", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_LAMBDA_TERM_BRACE]                  = { "expected a lambda block beginning with `{` to end with `}`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_LAMBDA_TERM_END]                    = { "expected a lambda block beginning with `do` to end with `end`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_LIST_I_LOWER_ELEMENT]               = { "expected a symbol in a `%i` list", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_LIST_I_LOWER_TERM]                  = { "unterminated list; expected a closing delimiter for the `%i`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_LIST_I_UPPER_ELEMENT]               = { "expected a symbol in a `%I` list", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_LIST_I_UPPER_TERM]                  = { "unterminated list; expected a closing delimiter for the `%I`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_LIST_W_LOWER_ELEMENT]               = { "expected a string in a `%w` list", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_LIST_W_LOWER_TERM]                  = { "unterminated list; expected a closing delimiter for the `%w`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_LIST_W_UPPER_ELEMENT]               = { "expected a string in a `%W` list", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_LIST_W_UPPER_TERM]                  = { "unterminated list; expected a closing delimiter for the `%W`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_MALLOC_FAILED]                      = { "failed to allocate memory", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_MIXED_ENCODING]                     = { "UTF-8 mixed within %s source", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_MODULE_IN_METHOD]                   = { "unexpected module definition in method body", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_MODULE_NAME]                        = { "unexpected constant path after `module`; class/module name must be CONSTANT", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_MODULE_TERM]                        = { "expected an `end` to close the `module` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_MULTI_ASSIGN_MULTI_SPLATS]          = { "multiple splats in multiple assignment", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_MULTI_ASSIGN_UNEXPECTED_REST]       = { "unexpected '%.*s' resulting in multiple splats in multiple assignment", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_NESTING_TOO_DEEP]                   = { "nesting too deep", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_NO_LOCAL_VARIABLE]                  = { "%.*s: no such local variable", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_NON_ASSOCIATIVE_OPERATOR]           = { "unexpected %s; %s is a non-associative operator", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_NOT_EXPRESSION]                     = { "expected an expression after `not`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_NUMBER_LITERAL_UNDERSCORE]          = { "number literal ending with a `_`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_NUMBERED_PARAMETER_INNER_BLOCK]     = { "numbered parameter is already used in inner block", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_NUMBERED_PARAMETER_IT]              = { "numbered parameters are not allowed when 'it' is already used", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_NUMBERED_PARAMETER_ORDINARY]        = { "numbered parameters are not allowed when an ordinary parameter is defined", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_NUMBERED_PARAMETER_OUTER_BLOCK]     = { "numbered parameter is already used in outer block", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_OPERATOR_MULTI_ASSIGN]              = { "unexpected operator for a multiple assignment", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_OPERATOR_WRITE_ARGUMENTS]           = { "unexpected operator after a call with arguments", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_OPERATOR_WRITE_BLOCK]               = { "unexpected operator after a call with a block", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_ASSOC_SPLAT_MULTI]        = { "unexpected multiple `**` splat parameters", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_BLOCK_MULTI]              = { "multiple block parameters; only one block is allowed", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_CIRCULAR]                 = { "circular argument reference - %.*s", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_FORWARDING_AFTER_REST]    = { "... after rest argument", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_METHOD_NAME]              = { "unexpected name for a parameter", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_NAME_DUPLICATED]          = { "duplicated argument name", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_NO_DEFAULT]               = { "expected a default value for the parameter", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_NO_DEFAULT_KW]            = { "expected a default value for the keyword parameter", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_NUMBERED_RESERVED]        = { "%.2s is reserved for numbered parameters", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_ORDER]                    = { "unexpected parameter order", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_SPLAT_MULTI]              = { "unexpected multiple `*` splat parameters", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_STAR]                     = { "unexpected parameter `*`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_UNEXPECTED_FWD]           = { "unexpected `...` in parameters", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_WILD_LOOSE_COMMA]         = { "unexpected `,` in parameters", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PARAMETER_UNEXPECTED_NO_KW]         = { "unexpected **nil; no keywords marker disallowed after keywords", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_ARRAY_MULTIPLE_RESTS]       = { "unexpected multiple '*' rest patterns in an array pattern", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_CAPTURE_DUPLICATE]          = { "duplicated variable name", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET]   = { "expected a pattern expression after the `[` operator", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_EXPRESSION_AFTER_COMMA]     = { "expected a pattern expression after `,`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_EXPRESSION_AFTER_HROCKET]   = { "expected a pattern expression after `=>`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_EXPRESSION_AFTER_IN]        = { "expected a pattern expression after the `in` keyword", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_EXPRESSION_AFTER_KEY]       = { "expected a pattern expression after the key", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_EXPRESSION_AFTER_PAREN]     = { "expected a pattern expression after the `(` operator", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_EXPRESSION_AFTER_PIN]       = { "expected a pattern expression after the `^` pin operator", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_EXPRESSION_AFTER_PIPE]      = { "expected a pattern expression after the `|` operator", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_EXPRESSION_AFTER_RANGE]     = { "expected a pattern expression after the range operator", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_EXPRESSION_AFTER_REST]      = { "unexpected pattern expression after the `**` expression", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_FIND_MISSING_INNER]         = { "find patterns need at least one required inner pattern", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_HASH_IMPLICIT]              = { "unexpected implicit hash in pattern; use '{' to delineate", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_HASH_KEY]                   = { "unexpected %s; expected a key in the hash pattern", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_HASH_KEY_DUPLICATE]         = { "duplicated key name", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_HASH_KEY_INTERPOLATED]      = { "symbol literal with interpolation is not allowed", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_HASH_KEY_LABEL]             = { "expected a label as the key in the hash pattern", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_HASH_KEY_LOCALS]            = { "key must be valid as local variables", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_IDENT_AFTER_HROCKET]        = { "expected an identifier after the `=>` operator", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_LABEL_AFTER_COMMA]          = { "expected a label after the `,` in the hash pattern", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_REST]                       = { "unexpected rest pattern", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_TERM_BRACE]                 = { "expected a `}` to close the pattern expression", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_TERM_BRACKET]               = { "expected a `]` to close the pattern expression", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PATTERN_TERM_PAREN]                 = { "expected a `)` to close the pattern expression", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_PIPEPIPEEQ_MULTI_ASSIGN]            = { "unexpected `||=` in a multiple assignment", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_REGEXP_ENCODING_OPTION_MISMATCH]    = { "regexp encoding option '%c' differs from source encoding '%s'", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_REGEXP_INCOMPAT_CHAR_ENCODING]      = { "incompatible character encoding: /%.*s/", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_REGEXP_NON_ESCAPED_MBC]             = { "/.../n has a non escaped non ASCII character in non ASCII-8BIT script: /%.*s/", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_REGEXP_INVALID_UNICODE_RANGE]       = { "invalid Unicode range: /%.*s/", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_REGEXP_PARSE_ERROR]                 = { "%s", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_REGEXP_UNKNOWN_OPTIONS]             = { "unknown regexp %s - %.*s", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_REGEXP_TERM]                        = { "unterminated regexp meets end of file; expected a closing delimiter", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_REGEXP_UTF8_CHAR_NON_UTF8_REGEXP]   = { "UTF-8 character in non UTF-8 regexp: /%s/", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_RESCUE_EXPRESSION]                  = { "expected a rescued expression", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_RESCUE_MODIFIER_VALUE]              = { "expected a value after the `rescue` modifier", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_RESCUE_TERM]                        = { "expected a closing delimiter for the `rescue` clause", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_RESCUE_VARIABLE]                    = { "expected an exception variable after `=>` in a rescue statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_RETURN_INVALID]                     = { "Invalid return in class/module body", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_SINGLETON_FOR_LITERALS]             = { "cannot define singleton method for literals", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_STATEMENT_ALIAS]                    = { "unexpected an `alias` at a non-statement position", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_STATEMENT_POSTEXE_END]              = { "unexpected an `END` at a non-statement position", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_STATEMENT_PREEXE_BEGIN]             = { "unexpected a `BEGIN` at a non-statement position", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_STATEMENT_UNDEF]                    = { "unexpected an `undef` at a non-statement position", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_STRING_CONCATENATION]               = { "expected a string for concatenation", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_STRING_INTERPOLATED_TERM]           = { "unterminated string; expected a closing delimiter for the interpolated string", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_STRING_LITERAL_EOF]                 = { "unterminated string meets end of file", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_STRING_LITERAL_TERM]                = { "unexpected %s, expected a string literal terminator", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_SYMBOL_INVALID]                     = { "invalid symbol", PM_ERROR_LEVEL_SYNTAX }, // TODO expected symbol? prism.c ~9719
    [PM_ERR_SYMBOL_TERM_DYNAMIC]                = { "unterminated quoted string; expected a closing delimiter for the dynamic symbol", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_SYMBOL_TERM_INTERPOLATED]           = { "unterminated symbol; expected a closing delimiter for the interpolated symbol", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_TERNARY_COLON]                      = { "expected a `:` after the true expression of a ternary operator", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_TERNARY_EXPRESSION_FALSE]           = { "expected an expression after `:` in the ternary operator", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_TERNARY_EXPRESSION_TRUE]            = { "expected an expression after `?` in the ternary operator", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_UNARY_RECEIVER]                     = { "unexpected %s, expected a receiver for unary `%c`", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_UNARY_DISALLOWED]                   = { "unexpected %s; unary calls are not allowed in this context", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_UNDEF_ARGUMENT]                     = { "invalid argument being passed to `undef`; expected a bare word, constant, or symbol argument", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_UNEXPECTED_BLOCK_ARGUMENT]          = { "block argument should not be given", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_UNEXPECTED_INDEX_BLOCK]             = { "unexpected block arg given in index assignment; blocks are not allowed in index assignment expressions", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_UNEXPECTED_INDEX_KEYWORDS]          = { "unexpected keyword arg given in index assignment; keywords are not allowed in index assignment expressions", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_UNEXPECTED_LABEL]                   = { "unexpected label", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_UNEXPECTED_MULTI_WRITE]             = { "unexpected multiple assignment; multiple assignment is not allowed in this context", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_UNEXPECTED_RANGE_OPERATOR]          = { "unexpected range operator; .. and ... are non-associative and cannot be chained", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_UNEXPECTED_SAFE_NAVIGATION]         = { "&. inside multiple assignment destination", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT]     = { "unexpected %s, assuming it is closing the parent %s", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_UNEXPECTED_TOKEN_IGNORE]            = { "unexpected %s, ignoring it", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_UNTIL_TERM]                         = { "expected an `end` to close the `until` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_VOID_EXPRESSION]                    = { "unexpected void value expression", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_WHILE_TERM]                         = { "expected an `end` to close the `while` statement", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_WRITE_TARGET_IN_METHOD]             = { "dynamic constant assignment", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_WRITE_TARGET_READONLY]              = { "Can't set variable %.*s", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_WRITE_TARGET_UNEXPECTED]            = { "unexpected write target", PM_ERROR_LEVEL_SYNTAX },
    [PM_ERR_XSTRING_TERM]                       = { "expected a closing delimiter for the `%x` or backtick string", PM_ERROR_LEVEL_SYNTAX },

    // Warnings
    [PM_WARN_AMBIGUOUS_BINARY_OPERATOR]         = { "'%s' after local variable or literal is interpreted as binary operator even though it seems like %s", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_MINUS]    = { "ambiguous first argument; put parentheses or a space even after `-` operator", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_PLUS]     = { "ambiguous first argument; put parentheses or a space even after `+` operator", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_AMBIGUOUS_PREFIX_AMPERSAND]        = { "ambiguous `&` has been interpreted as an argument prefix", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_AMBIGUOUS_PREFIX_STAR]             = { "ambiguous `*` has been interpreted as an argument prefix", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_AMBIGUOUS_PREFIX_STAR_STAR]        = { "ambiguous `**` has been interpreted as an argument prefix", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_AMBIGUOUS_SLASH]                   = { "ambiguous `/`; wrap regexp in parentheses or add a space after `/` operator", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_COMPARISON_AFTER_COMPARISON]       = { "comparison '%.*s' after comparison", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_DOT_DOT_DOT_EOL]                   = { "... at EOL, should be parenthesized?", PM_WARNING_LEVEL_DEFAULT },
    [PM_WARN_DUPLICATED_HASH_KEY]               = { "key %.*s is duplicated and overwritten on line %" PRIi32, PM_WARNING_LEVEL_DEFAULT },
    [PM_WARN_DUPLICATED_WHEN_CLAUSE]            = { "'when' clause on line %" PRIi32 " duplicates 'when' clause on line %" PRIi32 " and is ignored", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_EQUAL_IN_CONDITIONAL_3_3]          = { "found `= literal' in conditional, should be ==", PM_WARNING_LEVEL_DEFAULT },
    [PM_WARN_EQUAL_IN_CONDITIONAL]              = { "found '= literal' in conditional, should be ==", PM_WARNING_LEVEL_DEFAULT },
    [PM_WARN_END_IN_METHOD]                     = { "END in method; use at_exit", PM_WARNING_LEVEL_DEFAULT },
    [PM_WARN_FLOAT_OUT_OF_RANGE]                = { "Float %.*s%s out of range", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_IGNORED_FROZEN_STRING_LITERAL]     = { "'frozen_string_literal' is ignored after any tokens", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_INDENTATION_MISMATCH]              = { "mismatched indentations at '%.*s' with '%.*s' at %" PRIi32, PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_INTEGER_IN_FLIP_FLOP]              = { "integer literal in flip-flop", PM_WARNING_LEVEL_DEFAULT },
    [PM_WARN_INVALID_CHARACTER]                 = { "invalid character syntax; use %s%s%s", PM_WARNING_LEVEL_DEFAULT },
    [PM_WARN_INVALID_MAGIC_COMMENT_VALUE]       = { "invalid value for %.*s: %.*s", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_INVALID_NUMBERED_REFERENCE]        = { "'%.*s' is too big for a number variable, always nil", PM_WARNING_LEVEL_DEFAULT },
    [PM_WARN_KEYWORD_EOL]                       = { "`%.*s` at the end of line without an expression", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_LITERAL_IN_CONDITION_DEFAULT]      = { "%sliteral in %s", PM_WARNING_LEVEL_DEFAULT },
    [PM_WARN_LITERAL_IN_CONDITION_VERBOSE]      = { "%sliteral in %s", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_SHAREABLE_CONSTANT_VALUE_LINE]     = { "'shareable_constant_value' is ignored unless in comment-only line", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_SHEBANG_CARRIAGE_RETURN]           = { "shebang line ending with \\r may cause problems", PM_WARNING_LEVEL_DEFAULT },
    [PM_WARN_UNEXPECTED_CARRIAGE_RETURN]        = { "encountered \\r in middle of line, treated as a mere space", PM_WARNING_LEVEL_DEFAULT },
    [PM_WARN_UNREACHABLE_STATEMENT]             = { "statement not reached", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_UNUSED_LOCAL_VARIABLE]             = { "assigned but unused variable - %.*s", PM_WARNING_LEVEL_VERBOSE },
    [PM_WARN_VOID_STATEMENT]                    = { "possibly useless use of %.*s in void context", PM_WARNING_LEVEL_VERBOSE }
};

/**
 * Get the human-readable name of the given diagnostic ID.
 */
const char *
pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
    switch (diag_id) {
        <%- errors.each do |error| -%>
        case PM_ERR_<%= error.name %>: return "<%= error.name.downcase %>";
        <%- end -%>
        <%- warnings.each do |warning| -%>
        case PM_WARN_<%= warning.name %>: return "<%= warning.name.downcase %>";
        <%- end -%>
    }

    assert(false && "unreachable");
    return "";
}

static inline const char *
pm_diagnostic_message(pm_diagnostic_id_t diag_id) {
    assert(diag_id < PM_DIAGNOSTIC_ID_MAX);

    const char *message = diagnostic_messages[diag_id].message;
    assert(message);

    return message;
}

static inline uint8_t
pm_diagnostic_level(pm_diagnostic_id_t diag_id) {
    assert(diag_id < PM_DIAGNOSTIC_ID_MAX);

    return (uint8_t) diagnostic_messages[diag_id].level;
}

/**
 * Append an error to the given list of diagnostic.
 */
bool
pm_diagnostic_list_append(pm_list_t *list, const uint8_t *start, const uint8_t *end, pm_diagnostic_id_t diag_id) {
    pm_diagnostic_t *diagnostic = (pm_diagnostic_t *) xcalloc(1, sizeof(pm_diagnostic_t));
    if (diagnostic == NULL) return false;

    *diagnostic = (pm_diagnostic_t) {
        .location = { start, end },
        .diag_id = diag_id,
        .message = pm_diagnostic_message(diag_id),
        .owned = false,
        .level = pm_diagnostic_level(diag_id)
    };

    pm_list_append(list, (pm_list_node_t *) diagnostic);
    return true;
}

/**
 * Append a diagnostic to the given list of diagnostics that is using a format
 * string for its message.
 */
bool
pm_diagnostic_list_append_format(pm_list_t *list, const uint8_t *start, const uint8_t *end, pm_diagnostic_id_t diag_id, ...) {
    va_list arguments;
    va_start(arguments, diag_id);

    const char *format = pm_diagnostic_message(diag_id);
    int result = vsnprintf(NULL, 0, format, arguments);
    va_end(arguments);

    if (result < 0) {
        return false;
    }

    pm_diagnostic_t *diagnostic = (pm_diagnostic_t *) xcalloc(1, sizeof(pm_diagnostic_t));
    if (diagnostic == NULL) {
        return false;
    }

    size_t length = (size_t) (result + 1);
    char *message = (char *) xmalloc(length);
    if (message == NULL) {
        xfree(diagnostic);
        return false;
    }

    va_start(arguments, diag_id);
    vsnprintf(message, length, format, arguments);
    va_end(arguments);

    *diagnostic = (pm_diagnostic_t) {
        .location = { start, end },
        .diag_id = diag_id,
        .message = message,
        .owned = true,
        .level = pm_diagnostic_level(diag_id)
    };

    pm_list_append(list, (pm_list_node_t *) diagnostic);
    return true;
}

/**
 * Deallocate the internal state of the given diagnostic list.
 */
void
pm_diagnostic_list_free(pm_list_t *list) {
    pm_diagnostic_t *node = (pm_diagnostic_t *) list->head;

    while (node != NULL) {
        pm_diagnostic_t *next = (pm_diagnostic_t *) node->node.next;

        if (node->owned) xfree((void *) node->message);
        xfree(node);

        node = next;
    }
}
prism-1.5.1/templates/src/node.c.erb000066400000000000000000000330741506127434000173060ustar00rootroot00000000000000#line <%= __LINE__ + 1 %> "prism/templates/src/<%= File.basename(__FILE__) %>"
#include "prism/node.h"

/**
 * Attempts to grow the node list to the next size. If there is already
 * capacity in the list, this function does nothing. Otherwise it reallocates
 * the list to be twice as large as it was before. If the reallocation fails,
 * this function returns false, otherwise it returns true.
 */
static bool
pm_node_list_grow(pm_node_list_t *list, size_t size) {
    size_t requested_size = list->size + size;

    // If the requested size caused overflow, return false.
    if (requested_size < list->size) return false;

    // If the requested size is within the existing capacity, return true.
    if (requested_size < list->capacity) return true;

    // Otherwise, reallocate the list to be twice as large as it was before.
    size_t next_capacity = list->capacity == 0 ? 4 : list->capacity * 2;

    // If multiplying by 2 caused overflow, return false.
    if (next_capacity < list->capacity) return false;

    // If we didn't get enough by doubling, keep doubling until we do.
    while (requested_size > next_capacity) {
        size_t double_capacity = next_capacity * 2;

        // Ensure we didn't overflow by multiplying by 2.
        if (double_capacity < next_capacity) return false;
        next_capacity = double_capacity;
    }

    pm_node_t **nodes = (pm_node_t **) xrealloc(list->nodes, sizeof(pm_node_t *) * next_capacity);
    if (nodes == NULL) return false;

    list->nodes = nodes;
    list->capacity = next_capacity;
    return true;
}

/**
 * Append a new node onto the end of the node list.
 */
void
pm_node_list_append(pm_node_list_t *list, pm_node_t *node) {
    if (pm_node_list_grow(list, 1)) {
        list->nodes[list->size++] = node;
    }
}

/**
 * Prepend a new node onto the beginning of the node list.
 */
void
pm_node_list_prepend(pm_node_list_t *list, pm_node_t *node) {
    if (pm_node_list_grow(list, 1)) {
        memmove(list->nodes + 1, list->nodes, list->size * sizeof(pm_node_t *));
        list->nodes[0] = node;
        list->size++;
    }
}

/**
 * Concatenate the given node list onto the end of the other node list.
 */
void
pm_node_list_concat(pm_node_list_t *list, pm_node_list_t *other) {
    if (other->size > 0 && pm_node_list_grow(list, other->size)) {
        memcpy(list->nodes + list->size, other->nodes, other->size * sizeof(pm_node_t *));
        list->size += other->size;
    }
}

/**
 * Free the internal memory associated with the given node list.
 */
void
pm_node_list_free(pm_node_list_t *list) {
    if (list->capacity > 0) {
        xfree(list->nodes);
        *list = (pm_node_list_t) { 0 };
    }
}

PRISM_EXPORTED_FUNCTION void
pm_node_destroy(pm_parser_t *parser, pm_node_t *node);

/**
 * Destroy the nodes that are contained within the given node list.
 */
static void
pm_node_list_destroy(pm_parser_t *parser, pm_node_list_t *list) {
    pm_node_t *node;
    PM_NODE_LIST_FOREACH(list, index, node) pm_node_destroy(parser, node);
    pm_node_list_free(list);
}

/**
 * Deallocate the space for a pm_node_t. Similarly to pm_node_alloc, we're not
 * using the parser argument, but it's there to allow for the future possibility
 * of pre-allocating larger memory pools.
 */
PRISM_EXPORTED_FUNCTION void
pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
    switch (PM_NODE_TYPE(node)) {
        <%- nodes.each do |node| -%>
#line <%= __LINE__ + 1 %> "prism/templates/src/<%= File.basename(__FILE__) %>"
        case <%= node.type %>: {
            <%- if node.fields.any? { |field| ![Prism::Template::LocationField, Prism::Template::OptionalLocationField, Prism::Template::UInt8Field, Prism::Template::UInt32Field, Prism::Template::ConstantField, Prism::Template::OptionalConstantField, Prism::Template::DoubleField].include?(field.class) } -%>
            pm_<%= node.human %>_t *cast = (pm_<%= node.human %>_t *) node;
            <%- end -%>
            <%- node.fields.each do |field| -%>
            <%- case field -%>
            <%- when Prism::Template::LocationField, Prism::Template::OptionalLocationField, Prism::Template::UInt8Field, Prism::Template::UInt32Field, Prism::Template::ConstantField, Prism::Template::OptionalConstantField, Prism::Template::DoubleField -%>
            <%- when Prism::Template::NodeField -%>
            pm_node_destroy(parser, (pm_node_t *)cast-><%= field.name %>);
            <%- when Prism::Template::OptionalNodeField -%>
            if (cast-><%= field.name %> != NULL) {
                pm_node_destroy(parser, (pm_node_t *)cast-><%= field.name %>);
            }
            <%- when Prism::Template::StringField -%>
            pm_string_free(&cast-><%= field.name %>);
            <%- when Prism::Template::NodeListField -%>
            pm_node_list_destroy(parser, &cast-><%= field.name %>);
            <%- when Prism::Template::ConstantListField -%>
            pm_constant_id_list_free(&cast-><%= field.name %>);
            <%- when Prism::Template::IntegerField -%>
            pm_integer_free(&cast-><%= field.name %>);
            <%- else -%>
            <%- raise -%>
            <%- end -%>
            <%- end -%>
            break;
        }
        <%- end -%>
#line <%= __LINE__ + 1 %> "prism/templates/src/<%= File.basename(__FILE__) %>"
        default:
            assert(false && "unreachable");
            break;
    }
    xfree(node);
}

/**
 * Returns a string representation of the given node type.
 */
PRISM_EXPORTED_FUNCTION const char *
pm_node_type_to_str(pm_node_type_t node_type)
{
    switch (node_type) {
<%- nodes.each do |node| -%>
        case <%= node.type %>:
            return "<%= node.type %>";
<%- end -%>
    }
    return "";
}

/**
 * Visit each of the nodes in this subtree using the given visitor callback. The
 * callback function will be called for each node in the subtree. If it returns
 * false, then that node's children will not be visited. If it returns true,
 * then the children will be visited. The data parameter is treated as an opaque
 * pointer and is passed to the visitor callback for consumers to use as they
 * see fit.
 */
PRISM_EXPORTED_FUNCTION void
pm_visit_node(const pm_node_t *node, bool (*visitor)(const pm_node_t *node, void *data), void *data) {
    if (visitor(node, data)) pm_visit_child_nodes(node, visitor, data);
}

/**
 * Visit the children of the given node with the given callback. This is the
 * default behavior for walking the tree that is called from pm_visit_node if
 * the callback returns true.
 */
PRISM_EXPORTED_FUNCTION void
pm_visit_child_nodes(const pm_node_t *node, bool (*visitor)(const pm_node_t *node, void *data), void *data) {
    switch (PM_NODE_TYPE(node)) {
        <%- nodes.each do |node| -%>
        <%- if (fields = node.fields.select { |field| field.is_a?(Prism::Template::NodeField) || field.is_a?(Prism::Template::OptionalNodeField) || field.is_a?(Prism::Template::NodeListField) }).any? -%>
        case <%= node.type %>: {
            const pm_<%= node.human %>_t *cast = (const pm_<%= node.human %>_t *) node;
            <%- fields.each do |field| -%>

            // Visit the <%= field.name %> field
            <%- case field -%>
            <%- when Prism::Template::NodeField -%>
            pm_visit_node((const pm_node_t *) cast-><%= field.name %>, visitor, data);
            <%- when Prism::Template::OptionalNodeField -%>
            if (cast-><%= field.name %> != NULL) {
                pm_visit_node((const pm_node_t *) cast-><%= field.name %>, visitor, data);
            }
            <%- when Prism::Template::NodeListField -%>
            const pm_node_list_t *<%= field.name %> = &cast-><%= field.name %>;
            for (size_t index = 0; index < <%= field.name %>->size; index++) {
                pm_visit_node(<%= field.name %>->nodes[index], visitor, data);
            }
            <%- end -%>
            <%- end -%>

            break;
        }
        <%- else -%>
        case <%= node.type %>:
            break;
        <%- end -%>
        <%- end -%>
        case PM_SCOPE_NODE:
            break;
    }
}

// We optionally support dumping to JSON. For systems that don't want or need
// this functionality, it can be turned off with the PRISM_EXCLUDE_JSON define.
#ifndef PRISM_EXCLUDE_JSON

static void
pm_dump_json_constant(pm_buffer_t *buffer, const pm_parser_t *parser, pm_constant_id_t constant_id) {
    const pm_constant_t *constant = pm_constant_pool_id_to_constant(&parser->constant_pool, constant_id);
    pm_buffer_append_byte(buffer, '"');
    pm_buffer_append_source(buffer, constant->start, constant->length, PM_BUFFER_ESCAPING_JSON);
    pm_buffer_append_byte(buffer, '"');
}

static void
pm_dump_json_location(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_location_t *location) {
    uint32_t start = (uint32_t) (location->start - parser->start);
    uint32_t end = (uint32_t) (location->end - parser->start);
    pm_buffer_append_format(buffer, "{\"start\":%" PRIu32 ",\"end\":%" PRIu32 "}", start, end);
}

/**
 * Dump JSON to the given buffer.
 */
PRISM_EXPORTED_FUNCTION void
pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *node) {
    switch (PM_NODE_TYPE(node)) {
        <%- nodes.each do |node| -%>
        case <%= node.type %>: {
            pm_buffer_append_string(buffer, "{\"type\":\"<%= node.name %>\",\"location\":", <%= node.name.bytesize + 22 %>);

            const pm_<%= node.human %>_t *cast = (const pm_<%= node.human %>_t *) node;
            pm_dump_json_location(buffer, parser, &cast->base.location);
            <%- [*node.flags, *node.fields].each_with_index do |field, index| -%>

            // Dump the <%= field.name %> field
            pm_buffer_append_byte(buffer, ',');
            pm_buffer_append_string(buffer, "\"<%= field.name %>\":", <%= field.name.bytesize + 3 %>);
            <%- case field -%>
            <%- when Prism::Template::NodeField -%>
            pm_dump_json(buffer, parser, (const pm_node_t *) cast-><%= field.name %>);
            <%- when Prism::Template::OptionalNodeField -%>
            if (cast-><%= field.name %> != NULL) {
                pm_dump_json(buffer, parser, (const pm_node_t *) cast-><%= field.name %>);
            } else {
                pm_buffer_append_string(buffer, "null", 4);
            }
            <%- when Prism::Template::NodeListField -%>
            const pm_node_list_t *<%= field.name %> = &cast-><%= field.name %>;
            pm_buffer_append_byte(buffer, '[');

            for (size_t index = 0; index < <%= field.name %>->size; index++) {
                if (index != 0) pm_buffer_append_byte(buffer, ',');
                pm_dump_json(buffer, parser, <%= field.name %>->nodes[index]);
            }
            pm_buffer_append_byte(buffer, ']');
            <%- when Prism::Template::StringField -%>
            const pm_string_t *<%= field.name %> = &cast-><%= field.name %>;
            pm_buffer_append_byte(buffer, '"');
            pm_buffer_append_source(buffer, pm_string_source(<%= field.name %>), pm_string_length(<%= field.name %>), PM_BUFFER_ESCAPING_JSON);
            pm_buffer_append_byte(buffer, '"');
            <%- when Prism::Template::ConstantField -%>
            pm_dump_json_constant(buffer, parser, cast-><%= field.name %>);
            <%- when Prism::Template::OptionalConstantField -%>
            if (cast-><%= field.name %> != PM_CONSTANT_ID_UNSET) {
                pm_dump_json_constant(buffer, parser, cast-><%= field.name %>);
            } else {
                pm_buffer_append_string(buffer, "null", 4);
            }
            <%- when Prism::Template::ConstantListField -%>
            const pm_constant_id_list_t *<%= field.name %> = &cast-><%= field.name %>;
            pm_buffer_append_byte(buffer, '[');

            for (size_t index = 0; index < <%= field.name %>->size; index++) {
                if (index != 0) pm_buffer_append_byte(buffer, ',');
                pm_dump_json_constant(buffer, parser, <%= field.name %>->ids[index]);
            }
            pm_buffer_append_byte(buffer, ']');
            <%- when Prism::Template::LocationField -%>
            pm_dump_json_location(buffer, parser, &cast-><%= field.name %>);
            <%- when Prism::Template::OptionalLocationField -%>
            if (cast-><%= field.name %>.start != NULL) {
                pm_dump_json_location(buffer, parser, &cast-><%= field.name %>);
            } else {
                pm_buffer_append_string(buffer, "null", 4);
            }
            <%- when Prism::Template::UInt8Field -%>
            pm_buffer_append_format(buffer, "%" PRIu8, cast-><%= field.name %>);
            <%- when Prism::Template::UInt32Field -%>
            pm_buffer_append_format(buffer, "%" PRIu32, cast-><%= field.name %>);
            <%- when Prism::Template::Flags -%>
            size_t flags = 0;
            pm_buffer_append_byte(buffer, '[');
            <%- node.flags.values.each_with_index do |value, index| -%>
            if (PM_NODE_FLAG_P(cast, PM_<%= node.flags.human.upcase %>_<%= value.name %>)) {
                if (flags != 0) pm_buffer_append_byte(buffer, ',');
                pm_buffer_append_string(buffer, "\"<%= value.name %>\"", <%= value.name.bytesize + 2 %>);
                flags++;
            }
            <%- end -%>
            pm_buffer_append_byte(buffer, ']');
            <%- when Prism::Template::IntegerField -%>
            pm_integer_string(buffer, &cast-><%= field.name %>);
            <%- when Prism::Template::DoubleField -%>
            pm_buffer_append_format(buffer, "%f", cast-><%= field.name %>);
            <%- else -%>
            <%- raise %>
            <%- end -%>
            <%- end -%>

            pm_buffer_append_byte(buffer, '}');
            break;
        }
        <%- end -%>
        case PM_SCOPE_NODE:
            break;
    }
}

#endif
prism-1.5.1/templates/src/prettyprint.c.erb000066400000000000000000000217111506127434000207600ustar00rootroot00000000000000<%# encoding: ASCII -%>
#include "prism/prettyprint.h"

// We optionally support pretty printing nodes. For systems that don't want or
// need this functionality, it can be turned off with the
// PRISM_EXCLUDE_PRETTYPRINT define.
#ifdef PRISM_EXCLUDE_PRETTYPRINT

void pm_prettyprint(void) {}

#else

static inline void
prettyprint_location(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm_location_t *location) {
    pm_line_column_t start = pm_newline_list_line_column(&parser->newline_list, location->start, parser->start_line);
    pm_line_column_t end = pm_newline_list_line_column(&parser->newline_list, location->end, parser->start_line);
    pm_buffer_append_format(output_buffer, "(%" PRIi32 ",%" PRIu32 ")-(%" PRIi32 ",%" PRIu32 ")", start.line, start.column, end.line, end.column);
}

static inline void
prettyprint_constant(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm_constant_id_t constant_id) {
    pm_constant_t *constant = pm_constant_pool_id_to_constant(&parser->constant_pool, constant_id);
    pm_buffer_append_format(output_buffer, ":%.*s", (int) constant->length, constant->start);
}

static void
prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm_node_t *node, pm_buffer_t *prefix_buffer) {
    switch (PM_NODE_TYPE(node)) {
        case PM_SCOPE_NODE:
            // We do not need to print a ScopeNode as it's not part of the AST.
            return;
        <%- nodes.each do |node| -%>
        case <%= node.type %>: {
            <%- if !node.flags.nil? || node.fields.any? -%>
            pm_<%= node.human %>_t *cast = (pm_<%= node.human %>_t *) node;
            <%- end -%>
            pm_buffer_append_string(output_buffer, "@ <%= node.name %> (location: ", <%= node.name.length + 14 %>);
            prettyprint_location(output_buffer, parser, &node->location);
            pm_buffer_append_string(output_buffer, ")\n", 2);
            <%- (fields = [*node.flags, *node.fields]).each_with_index do |field, index| -%>
            <%- preadd = index == fields.length - 1 ? "    " : "|   " -%>

            // <%= field.name %>
            {
                pm_buffer_concat(output_buffer, prefix_buffer);
                pm_buffer_append_string(output_buffer, "+-- <%= field.name %>:", <%= 4 + field.name.length + 1 %>);
            <%- case field -%>
            <%- when Prism::Template::NodeField -%>
                pm_buffer_append_byte(output_buffer, '\n');

                size_t prefix_length = prefix_buffer->length;
                pm_buffer_append_string(prefix_buffer, "<%= preadd %>", 4);
                pm_buffer_concat(output_buffer, prefix_buffer);
                prettyprint_node(output_buffer, parser, (pm_node_t *) cast-><%= field.name %>, prefix_buffer);
                prefix_buffer->length = prefix_length;
            <%- when Prism::Template::OptionalNodeField -%>
                if (cast-><%= field.name %> == NULL) {
                    pm_buffer_append_string(output_buffer, " nil\n", 5);
                } else {
                    pm_buffer_append_byte(output_buffer, '\n');

                    size_t prefix_length = prefix_buffer->length;
                    pm_buffer_append_string(prefix_buffer, "<%= preadd %>", 4);
                    pm_buffer_concat(output_buffer, prefix_buffer);
                    prettyprint_node(output_buffer, parser, (pm_node_t *) cast-><%= field.name %>, prefix_buffer);
                    prefix_buffer->length = prefix_length;
                }
            <%- when Prism::Template::StringField -%>
                pm_buffer_append_string(output_buffer, " \"", 2);
                pm_buffer_append_source(output_buffer, pm_string_source(&cast-><%= field.name %>), pm_string_length(&cast-><%= field.name %>), PM_BUFFER_ESCAPING_RUBY);
                pm_buffer_append_string(output_buffer, "\"\n", 2);
            <%- when Prism::Template::NodeListField -%>
                pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast-><%= field.name %>.size));

                size_t last_index = cast-><%= field.name %>.size;
                for (uint32_t index = 0; index < last_index; index++) {
                    size_t prefix_length = prefix_buffer->length;
                    pm_buffer_append_string(prefix_buffer, "<%= preadd %>", 4);
                    pm_buffer_concat(output_buffer, prefix_buffer);
                    pm_buffer_append_string(output_buffer, "+-- ", 4);
                    pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? "    " : "|   ", 4);
                    prettyprint_node(output_buffer, parser, (pm_node_t *) cast-><%= field.name %>.nodes[index], prefix_buffer);
                    prefix_buffer->length = prefix_length;
                }
            <%- when Prism::Template::ConstantField -%>
                pm_buffer_append_byte(output_buffer, ' ');
                prettyprint_constant(output_buffer, parser, cast-><%= field.name %>);
                pm_buffer_append_byte(output_buffer, '\n');
            <%- when Prism::Template::OptionalConstantField -%>
                if (cast-><%= field.name %> == 0) {
                    pm_buffer_append_string(output_buffer, " nil\n", 5);
                } else {
                    pm_buffer_append_byte(output_buffer, ' ');
                    prettyprint_constant(output_buffer, parser, cast-><%= field.name %>);
                    pm_buffer_append_byte(output_buffer, '\n');
                }
            <%- when Prism::Template::ConstantListField -%>
                pm_buffer_append_string(output_buffer, " [", 2);
                for (uint32_t index = 0; index < cast-><%= field.name %>.size; index++) {
                    if (index != 0) pm_buffer_append_string(output_buffer, ", ", 2);
                    prettyprint_constant(output_buffer, parser, cast-><%= field.name %>.ids[index]);
                }
                pm_buffer_append_string(output_buffer, "]\n", 2);
            <%- when Prism::Template::LocationField -%>
                pm_location_t *location = &cast-><%= field.name %>;
                pm_buffer_append_byte(output_buffer, ' ');
                prettyprint_location(output_buffer, parser, location);
                pm_buffer_append_string(output_buffer, " = \"", 4);
                pm_buffer_append_source(output_buffer, location->start, (size_t) (location->end - location->start), PM_BUFFER_ESCAPING_RUBY);
                pm_buffer_append_string(output_buffer, "\"\n", 2);
            <%- when Prism::Template::OptionalLocationField -%>
                pm_location_t *location = &cast-><%= field.name %>;
                if (location->start == NULL) {
                    pm_buffer_append_string(output_buffer, " nil\n", 5);
                } else {
                    pm_buffer_append_byte(output_buffer, ' ');
                    prettyprint_location(output_buffer, parser, location);
                    pm_buffer_append_string(output_buffer, " = \"", 4);
                    pm_buffer_append_source(output_buffer, location->start, (size_t) (location->end - location->start), PM_BUFFER_ESCAPING_RUBY);
                    pm_buffer_append_string(output_buffer, "\"\n", 2);
                }
            <%- when Prism::Template::UInt8Field -%>
                pm_buffer_append_format(output_buffer, " %" PRIu8 "\n", cast-><%= field.name %>);
            <%- when Prism::Template::UInt32Field -%>
                pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast-><%= field.name %>);
            <%- when Prism::Template::Flags -%>
                bool found = false;
                <%- field.values.each do |value| -%>
                if (cast->base.flags & PM_<%= field.human.upcase %>_<%= value.name %>) {
                    if (found) pm_buffer_append_byte(output_buffer, ',');
                    pm_buffer_append_string(output_buffer, " <%= value.name.downcase %>", <%= value.name.bytesize + 1 %>);
                    found = true;
                }
                <%- end -%>
                if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
                pm_buffer_append_byte(output_buffer, '\n');
            <%- when Prism::Template::IntegerField -%>
                const pm_integer_t *integer = &cast-><%= field.name %>;
                pm_buffer_append_byte(output_buffer, ' ');
                pm_integer_string(output_buffer, integer);
                pm_buffer_append_byte(output_buffer, '\n');
            <%- when Prism::Template::DoubleField -%>
                pm_buffer_append_format(output_buffer, " %f\n", cast-><%= field.name %>);
            <%- else -%>
            <%- raise -%>
            <%- end -%>
            }
            <%- end -%>

            break;
        }
        <%- end -%>
    }
}

/**
 * Pretty-prints the AST represented by the given node to the given buffer.
 */
PRISM_EXPORTED_FUNCTION void
pm_prettyprint(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm_node_t *node) {
    pm_buffer_t prefix_buffer = { 0 };
    prettyprint_node(output_buffer, parser, node, &prefix_buffer);
    pm_buffer_free(&prefix_buffer);
}

#endif
prism-1.5.1/templates/src/serialize.c.erb000066400000000000000000000402141506127434000203420ustar00rootroot00000000000000#include "prism.h"

// We optionally support serializing to a binary string. For systems that don't
// want or need this functionality, it can be turned off with the
// PRISM_EXCLUDE_SERIALIZATION define.
#ifndef PRISM_EXCLUDE_SERIALIZATION

#include 

static inline uint32_t
pm_ptrdifft_to_u32(ptrdiff_t value) {
    assert(value >= 0 && ((unsigned long) value) < UINT32_MAX);
    return (uint32_t) value;
}

static inline uint32_t
pm_sizet_to_u32(size_t value) {
    assert(value < UINT32_MAX);
    return (uint32_t) value;
}

static void
pm_serialize_location(const pm_parser_t *parser, const pm_location_t *location, pm_buffer_t *buffer) {
    assert(location->start);
    assert(location->end);
    assert(location->start <= location->end);

    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(location->start - parser->start));
    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(location->end - location->start));
}

static void
pm_serialize_string(const pm_parser_t *parser, const pm_string_t *string, pm_buffer_t *buffer) {
    switch (string->type) {
        case PM_STRING_SHARED: {
            pm_buffer_append_byte(buffer, 1);
            pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(pm_string_source(string) - parser->start));
            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_string_length(string)));
            break;
        }
        case PM_STRING_OWNED:
        case PM_STRING_CONSTANT: {
            uint32_t length = pm_sizet_to_u32(pm_string_length(string));
            pm_buffer_append_byte(buffer, 2);
            pm_buffer_append_varuint(buffer, length);
            pm_buffer_append_bytes(buffer, pm_string_source(string), length);
            break;
        }
#ifdef PRISM_HAS_MMAP
        case PM_STRING_MAPPED:
            assert(false && "Cannot serialize mapped strings.");
            break;
#endif
    }
}

static void
pm_serialize_integer(const pm_integer_t *integer, pm_buffer_t *buffer) {
    pm_buffer_append_byte(buffer, integer->negative ? 1 : 0);
    if (integer->values == NULL) {
        pm_buffer_append_varuint(buffer, pm_sizet_to_u32(1));
        pm_buffer_append_varuint(buffer, integer->value);
    } else {
        pm_buffer_append_varuint(buffer, pm_sizet_to_u32(integer->length));
        for (size_t i = 0; i < integer->length; i++) {
            pm_buffer_append_varuint(buffer, integer->values[i]);
        }
    }
}

static void
pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
    pm_buffer_append_byte(buffer, (uint8_t) PM_NODE_TYPE(node));

    size_t offset = buffer->length;

    <%- if Prism::Template::INCLUDE_NODE_ID -%>
    pm_buffer_append_varuint(buffer, node->node_id);
    <%- end -%>
    pm_serialize_location(parser, &node->location, buffer);

    switch (PM_NODE_TYPE(node)) {
        // We do not need to serialize a ScopeNode ever as
        // it is not part of the AST
        case PM_SCOPE_NODE:
            return;
        <%- nodes.each do |node| -%>
        case <%= node.type %>: {
            <%- if node.needs_serialized_length? -%>
            // serialize length
            // encoding of location u32s make us need to save this offset.
            size_t length_offset = buffer->length;
            pm_buffer_append_string(buffer, "\0\0\0\0", 4); /* consume 4 bytes, updated below */
            <%- end -%>
            <%- unless Prism::Template::SERIALIZE_ONLY_SEMANTICS_FIELDS && !node.flags -%>
            pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
            <%- end -%>
            <%- node.fields.each do |field| -%>
            <%- case field -%>
            <%- when Prism::Template::NodeField -%>
            pm_serialize_node(parser, (pm_node_t *)((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer);
            <%- when Prism::Template::OptionalNodeField -%>
            if (((pm_<%= node.human %>_t *)node)-><%= field.name %> == NULL) {
                pm_buffer_append_byte(buffer, 0);
            } else {
                pm_serialize_node(parser, (pm_node_t *)((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer);
            }
            <%- when Prism::Template::StringField -%>
            pm_serialize_string(parser, &((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer);
            <%- when Prism::Template::NodeListField -%>
            uint32_t <%= field.name %>_size = pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.size);
            pm_buffer_append_varuint(buffer, <%= field.name %>_size);
            for (uint32_t index = 0; index < <%= field.name %>_size; index++) {
                pm_serialize_node(parser, (pm_node_t *) ((pm_<%= node.human %>_t *)node)-><%= field.name %>.nodes[index], buffer);
            }
            <%- when Prism::Template::ConstantField, Prism::Template::OptionalConstantField -%>
            pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>));
            <%- when Prism::Template::ConstantListField -%>
            uint32_t <%= field.name %>_size = pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.size);
            pm_buffer_append_varuint(buffer, <%= field.name %>_size);
            for (uint32_t index = 0; index < <%= field.name %>_size; index++) {
                pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.ids[index]));
            }
            <%- when Prism::Template::LocationField -%>
            <%- if field.should_be_serialized? -%>
            pm_serialize_location(parser, &((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer);
            <%- end -%>
            <%- when Prism::Template::OptionalLocationField -%>
            <%- if field.should_be_serialized? -%>
            if (((pm_<%= node.human %>_t *)node)-><%= field.name %>.start == NULL) {
                pm_buffer_append_byte(buffer, 0);
            } else {
                pm_buffer_append_byte(buffer, 1);
                pm_serialize_location(parser, &((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer);
            }
            <%- end -%>
            <%- when Prism::Template::UInt8Field -%>
            pm_buffer_append_byte(buffer, ((pm_<%= node.human %>_t *)node)-><%= field.name %>);
            <%- when Prism::Template::UInt32Field -%>
            pm_buffer_append_varuint(buffer, ((pm_<%= node.human %>_t *)node)-><%= field.name %>);
            <%- when Prism::Template::IntegerField -%>
            pm_serialize_integer(&((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer);
            <%- when Prism::Template::DoubleField -%>
            pm_buffer_append_double(buffer, ((pm_<%= node.human %>_t *)node)-><%= field.name %>);
            <%- else -%>
            <%- raise -%>
            <%- end -%>
            <%- end -%>
            <%- if node.needs_serialized_length? -%>
            // serialize length
            uint32_t length = pm_sizet_to_u32(buffer->length - offset - sizeof(uint32_t));
            memcpy(buffer->value + length_offset, &length, sizeof(uint32_t));
            <%- end -%>
            break;
        }
        <%- end -%>
    }
}

static void
pm_serialize_newline_list(pm_newline_list_t *list, pm_buffer_t *buffer) {
    uint32_t size = pm_sizet_to_u32(list->size);
    pm_buffer_append_varuint(buffer, size);

    for (uint32_t i = 0; i < size; i++) {
        uint32_t offset = pm_sizet_to_u32(list->offsets[i]);
        pm_buffer_append_varuint(buffer, offset);
    }
}

static void
pm_serialize_comment(pm_parser_t *parser, pm_comment_t *comment, pm_buffer_t *buffer) {
    // serialize type
    pm_buffer_append_byte(buffer, (uint8_t) comment->type);

    // serialize location
    pm_serialize_location(parser, &comment->location, buffer);
}

/**
 * Serialize the given list of comments to the given buffer.
 */
void
pm_serialize_comment_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) {
    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));

    pm_comment_t *comment;
    for (comment = (pm_comment_t *) list->head; comment != NULL; comment = (pm_comment_t *) comment->node.next) {
        pm_serialize_comment(parser, comment, buffer);
    }
}

static void
pm_serialize_magic_comment(pm_parser_t *parser, pm_magic_comment_t *magic_comment, pm_buffer_t *buffer) {
    // serialize key location
    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(magic_comment->key_start - parser->start));
    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(magic_comment->key_length));

    // serialize value location
    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(magic_comment->value_start - parser->start));
    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(magic_comment->value_length));
}

static void
pm_serialize_magic_comment_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) {
    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));

    pm_magic_comment_t *magic_comment;
    for (magic_comment = (pm_magic_comment_t *) list->head; magic_comment != NULL; magic_comment = (pm_magic_comment_t *) magic_comment->node.next) {
        pm_serialize_magic_comment(parser, magic_comment, buffer);
    }
}

static void
pm_serialize_data_loc(const pm_parser_t *parser, pm_buffer_t *buffer) {
    if (parser->data_loc.end == NULL) {
        pm_buffer_append_byte(buffer, 0);
    } else {
        pm_buffer_append_byte(buffer, 1);
        pm_serialize_location(parser, &parser->data_loc, buffer);
    }
}

static void
pm_serialize_diagnostic(pm_parser_t *parser, pm_diagnostic_t *diagnostic, pm_buffer_t *buffer) {
    // serialize the type
    pm_buffer_append_varuint(buffer, (uint32_t) diagnostic->diag_id);

    // serialize message
    size_t message_length = strlen(diagnostic->message);
    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(message_length));
    pm_buffer_append_string(buffer, diagnostic->message, message_length);

    // serialize location
    pm_serialize_location(parser, &diagnostic->location, buffer);

    pm_buffer_append_byte(buffer, diagnostic->level);
}

static void
pm_serialize_diagnostic_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) {
    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));

    pm_diagnostic_t *diagnostic;
    for (diagnostic = (pm_diagnostic_t *) list->head; diagnostic != NULL; diagnostic = (pm_diagnostic_t *) diagnostic->node.next) {
        pm_serialize_diagnostic(parser, diagnostic, buffer);
    }
}

/**
 * Serialize the name of the encoding to the buffer.
 */
void
pm_serialize_encoding(const pm_encoding_t *encoding, pm_buffer_t *buffer) {
    size_t encoding_length = strlen(encoding->name);
    pm_buffer_append_varuint(buffer, pm_sizet_to_u32(encoding_length));
    pm_buffer_append_string(buffer, encoding->name, encoding_length);
}

static void
pm_serialize_metadata(pm_parser_t *parser, pm_buffer_t *buffer) {
    pm_serialize_encoding(parser->encoding, buffer);
    pm_buffer_append_varsint(buffer, parser->start_line);
    pm_serialize_newline_list(&parser->newline_list, buffer);
<%- unless Prism::Template::SERIALIZE_ONLY_SEMANTICS_FIELDS -%>
    pm_serialize_comment_list(parser, &parser->comment_list, buffer);
<%- end -%>
    pm_serialize_magic_comment_list(parser, &parser->magic_comment_list, buffer);
    pm_serialize_data_loc(parser, buffer);
    pm_serialize_diagnostic_list(parser, &parser->error_list, buffer);
    pm_serialize_diagnostic_list(parser, &parser->warning_list, buffer);
}

#line <%= __LINE__ + 1 %> "prism/templates/src/<%= File.basename(__FILE__) %>"
/**
 * Serialize the metadata, nodes, and constant pool.
 */
void
pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
    pm_serialize_metadata(parser, buffer);

    // Here we're going to leave space for the offset of the constant pool in
    // the buffer.
    size_t offset = buffer->length;
    pm_buffer_append_zeroes(buffer, 4);

    // Next, encode the length of the constant pool.
    pm_buffer_append_varuint(buffer, parser->constant_pool.size);

    // Now we're going to serialize the content of the node.
    pm_serialize_node(parser, node, buffer);

    // Now we're going to serialize the offset of the constant pool back where
    // we left space for it.
    uint32_t length = pm_sizet_to_u32(buffer->length);
    memcpy(buffer->value + offset, &length, sizeof(uint32_t));

    // Now we're going to serialize the constant pool.
    offset = buffer->length;
    pm_buffer_append_zeroes(buffer, parser->constant_pool.size * 8);

    for (uint32_t index = 0; index < parser->constant_pool.capacity; index++) {
        pm_constant_pool_bucket_t *bucket = &parser->constant_pool.buckets[index];

        // If we find a constant at this index, serialize it at the correct
        // index in the buffer.
        if (bucket->id != 0) {
            pm_constant_t *constant = &parser->constant_pool.constants[bucket->id - 1];
            size_t buffer_offset = offset + ((((size_t)bucket->id) - 1) * 8);

            if (bucket->type == PM_CONSTANT_POOL_BUCKET_OWNED || bucket->type == PM_CONSTANT_POOL_BUCKET_CONSTANT) {
                // Since this is an owned or constant constant, we are going to
                // write its contents into the buffer after the constant pool.
                // So effectively in place of the source offset, we have a
                // buffer offset. We will add a leading 1 to indicate that this
                // is a buffer offset.
                uint32_t content_offset = pm_sizet_to_u32(buffer->length);
                uint32_t owned_mask = (uint32_t) (1 << 31);

                assert(content_offset < owned_mask);
                content_offset |= owned_mask;

                memcpy(buffer->value + buffer_offset, &content_offset, 4);
                pm_buffer_append_bytes(buffer, constant->start, constant->length);
            } else {
                // Since this is a shared constant, we are going to write its
                // source offset directly into the buffer.
                uint32_t source_offset = pm_ptrdifft_to_u32(constant->start - parser->start);
                memcpy(buffer->value + buffer_offset, &source_offset, 4);
            }

            // Now we can write the length of the constant into the buffer.
            uint32_t constant_length = pm_sizet_to_u32(constant->length);
            memcpy(buffer->value + buffer_offset + 4, &constant_length, 4);
        }
    }
}

static void
serialize_token(void *data, pm_parser_t *parser, pm_token_t *token) {
    pm_buffer_t *buffer = (pm_buffer_t *) data;

    pm_buffer_append_varuint(buffer, token->type);
    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(token->start - parser->start));
    pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(token->end - token->start));
    pm_buffer_append_varuint(buffer, parser->lex_state);
}

/**
 * Lex the given source and serialize to the given buffer.
 */
PRISM_EXPORTED_FUNCTION void
pm_serialize_lex(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data) {
    pm_options_t options = { 0 };
    pm_options_read(&options, data);

    pm_parser_t parser;
    pm_parser_init(&parser, source, size, &options);

    pm_lex_callback_t lex_callback = (pm_lex_callback_t) {
        .data = (void *) buffer,
        .callback = serialize_token,
    };

    parser.lex_callback = &lex_callback;
    pm_node_t *node = pm_parse(&parser);

    // Append 0 to mark end of tokens.
    pm_buffer_append_byte(buffer, 0);

    pm_serialize_metadata(&parser, buffer);

    pm_node_destroy(&parser, node);
    pm_parser_free(&parser);
    pm_options_free(&options);
}

/**
 * Parse and serialize both the AST and the tokens represented by the given
 * source to the given buffer.
 */
PRISM_EXPORTED_FUNCTION void
pm_serialize_parse_lex(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data) {
    pm_options_t options = { 0 };
    pm_options_read(&options, data);

    pm_parser_t parser;
    pm_parser_init(&parser, source, size, &options);

    pm_lex_callback_t lex_callback = (pm_lex_callback_t) {
        .data = (void *) buffer,
        .callback = serialize_token,
    };

    parser.lex_callback = &lex_callback;
    pm_node_t *node = pm_parse(&parser);

    pm_buffer_append_byte(buffer, 0);
    pm_serialize(&parser, node, buffer);

    pm_node_destroy(&parser, node);
    pm_parser_free(&parser);
    pm_options_free(&options);
}

#endif
prism-1.5.1/templates/src/token_type.c.erb000066400000000000000000000270711506127434000205420ustar00rootroot00000000000000#include 

#include "prism/ast.h"

/**
 * Returns a string representation of the given token type.
 */
PRISM_EXPORTED_FUNCTION const char *
pm_token_type_name(pm_token_type_t token_type) {
    switch (token_type) {
<%- tokens.each do |token| -%>
        case PM_TOKEN_<%= token.name %>:
            return "<%= token.name %>";
<%- end -%>
        case PM_TOKEN_MAXIMUM:
            assert(false && "unreachable");
            return "";
    }

    // Provide a default, because some compilers can't determine that the above
    // switch is exhaustive.
    assert(false && "unreachable");
    return "";
}

/**
 * Returns the human name of the given token type.
 */
const char *
pm_token_type_human(pm_token_type_t token_type) {
    switch (token_type) {
        case PM_TOKEN_EOF:
            return "end-of-input";
        case PM_TOKEN_MISSING:
            return "missing token";
        case PM_TOKEN_NOT_PROVIDED:
            return "not provided token";
        case PM_TOKEN_AMPERSAND:
            return "'&'";
        case PM_TOKEN_AMPERSAND_AMPERSAND:
            return "'&&'";
        case PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL:
            return "'&&='";
        case PM_TOKEN_AMPERSAND_DOT:
            return "'&.'";
        case PM_TOKEN_AMPERSAND_EQUAL:
            return "'&='";
        case PM_TOKEN_BACKTICK:
            return "'`'";
        case PM_TOKEN_BACK_REFERENCE:
            return "back reference";
        case PM_TOKEN_BANG:
            return "'!'";
        case PM_TOKEN_BANG_EQUAL:
            return "'!='";
        case PM_TOKEN_BANG_TILDE:
            return "'!~'";
        case PM_TOKEN_BRACE_LEFT:
            return "'{'";
        case PM_TOKEN_BRACE_RIGHT:
            return "'}'";
        case PM_TOKEN_BRACKET_LEFT:
            return "'['";
        case PM_TOKEN_BRACKET_LEFT_ARRAY:
            return "'['";
        case PM_TOKEN_BRACKET_LEFT_RIGHT:
            return "'[]'";
        case PM_TOKEN_BRACKET_LEFT_RIGHT_EQUAL:
            return "'[]='";
        case PM_TOKEN_BRACKET_RIGHT:
            return "']'";
        case PM_TOKEN_CARET:
            return "'^'";
        case PM_TOKEN_CARET_EQUAL:
            return "'^='";
        case PM_TOKEN_CHARACTER_LITERAL:
            return "character literal";
        case PM_TOKEN_CLASS_VARIABLE:
            return "class variable";
        case PM_TOKEN_COLON:
            return "':'";
        case PM_TOKEN_COLON_COLON:
            return "'::'";
        case PM_TOKEN_COMMA:
            return "','";
        case PM_TOKEN_COMMENT:
            return "comment";
        case PM_TOKEN_CONSTANT:
            return "constant";
        case PM_TOKEN_DOT:
            return "'.'";
        case PM_TOKEN_DOT_DOT:
            return "..";
        case PM_TOKEN_DOT_DOT_DOT:
            return "...";
        case PM_TOKEN_EMBDOC_BEGIN:
            return "'=begin'";
        case PM_TOKEN_EMBDOC_END:
            return "'=end'";
        case PM_TOKEN_EMBDOC_LINE:
            return "embedded documentation line";
        case PM_TOKEN_EMBEXPR_BEGIN:
            return "'#{'";
        case PM_TOKEN_EMBEXPR_END:
            return "'}'";
        case PM_TOKEN_EMBVAR:
            return "'#'";
        case PM_TOKEN_EQUAL:
            return "'='";
        case PM_TOKEN_EQUAL_EQUAL:
            return "'=='";
        case PM_TOKEN_EQUAL_EQUAL_EQUAL:
            return "'==='";
        case PM_TOKEN_EQUAL_GREATER:
            return "'=>'";
        case PM_TOKEN_EQUAL_TILDE:
            return "'=~'";
        case PM_TOKEN_FLOAT:
            return "float";
        case PM_TOKEN_FLOAT_IMAGINARY:
            return "imaginary";
        case PM_TOKEN_FLOAT_RATIONAL:
            return "rational";
        case PM_TOKEN_FLOAT_RATIONAL_IMAGINARY:
            return "imaginary";
        case PM_TOKEN_GLOBAL_VARIABLE:
            return "global variable";
        case PM_TOKEN_GREATER:
            return "'>'";
        case PM_TOKEN_GREATER_EQUAL:
            return "'>='";
        case PM_TOKEN_GREATER_GREATER:
            return ">>";
        case PM_TOKEN_GREATER_GREATER_EQUAL:
            return ">>=";
        case PM_TOKEN_HEREDOC_END:
            return "heredoc ending";
        case PM_TOKEN_HEREDOC_START:
            return "heredoc beginning";
        case PM_TOKEN_IDENTIFIER:
            return "local variable or method";
        case PM_TOKEN_IGNORED_NEWLINE:
            return "ignored newline";
        case PM_TOKEN_INSTANCE_VARIABLE:
            return "instance variable";
        case PM_TOKEN_INTEGER:
            return "integer";
        case PM_TOKEN_INTEGER_IMAGINARY:
            return "imaginary";
        case PM_TOKEN_INTEGER_RATIONAL:
            return "rational";
        case PM_TOKEN_INTEGER_RATIONAL_IMAGINARY:
            return "imaginary";
        case PM_TOKEN_KEYWORD_ALIAS:
            return "'alias'";
        case PM_TOKEN_KEYWORD_AND:
            return "'and'";
        case PM_TOKEN_KEYWORD_BEGIN:
            return "'begin'";
        case PM_TOKEN_KEYWORD_BEGIN_UPCASE:
            return "'BEGIN'";
        case PM_TOKEN_KEYWORD_BREAK:
            return "'break'";
        case PM_TOKEN_KEYWORD_CASE:
            return "'case'";
        case PM_TOKEN_KEYWORD_CLASS:
            return "'class'";
        case PM_TOKEN_KEYWORD_DEF:
            return "'def'";
        case PM_TOKEN_KEYWORD_DEFINED:
            return "'defined?'";
        case PM_TOKEN_KEYWORD_DO:
            return "'do'";
        case PM_TOKEN_KEYWORD_DO_LOOP:
            return "'do'";
        case PM_TOKEN_KEYWORD_ELSE:
            return "'else'";
        case PM_TOKEN_KEYWORD_ELSIF:
            return "'elsif'";
        case PM_TOKEN_KEYWORD_END:
            return "'end'";
        case PM_TOKEN_KEYWORD_END_UPCASE:
            return "'END'";
        case PM_TOKEN_KEYWORD_ENSURE:
            return "'ensure'";
        case PM_TOKEN_KEYWORD_FALSE:
            return "'false'";
        case PM_TOKEN_KEYWORD_FOR:
            return "'for'";
        case PM_TOKEN_KEYWORD_IF:
            return "'if'";
        case PM_TOKEN_KEYWORD_IF_MODIFIER:
            return "'if'";
        case PM_TOKEN_KEYWORD_IN:
            return "'in'";
        case PM_TOKEN_KEYWORD_MODULE:
            return "'module'";
        case PM_TOKEN_KEYWORD_NEXT:
            return "'next'";
        case PM_TOKEN_KEYWORD_NIL:
            return "'nil'";
        case PM_TOKEN_KEYWORD_NOT:
            return "'not'";
        case PM_TOKEN_KEYWORD_OR:
            return "'or'";
        case PM_TOKEN_KEYWORD_REDO:
            return "'redo'";
        case PM_TOKEN_KEYWORD_RESCUE:
            return "'rescue'";
        case PM_TOKEN_KEYWORD_RESCUE_MODIFIER:
            return "'rescue' modifier";
        case PM_TOKEN_KEYWORD_RETRY:
            return "'retry'";
        case PM_TOKEN_KEYWORD_RETURN:
            return "'return'";
        case PM_TOKEN_KEYWORD_SELF:
            return "'self'";
        case PM_TOKEN_KEYWORD_SUPER:
            return "'super'";
        case PM_TOKEN_KEYWORD_THEN:
            return "'then'";
        case PM_TOKEN_KEYWORD_TRUE:
            return "'true'";
        case PM_TOKEN_KEYWORD_UNDEF:
            return "'undef'";
        case PM_TOKEN_KEYWORD_UNLESS:
            return "'unless'";
        case PM_TOKEN_KEYWORD_UNLESS_MODIFIER:
            return "'unless'";
        case PM_TOKEN_KEYWORD_UNTIL:
            return "'until'";
        case PM_TOKEN_KEYWORD_UNTIL_MODIFIER:
            return "'until'";
        case PM_TOKEN_KEYWORD_WHEN:
            return "'when'";
        case PM_TOKEN_KEYWORD_WHILE:
            return "'while'";
        case PM_TOKEN_KEYWORD_WHILE_MODIFIER:
            return "'while'";
        case PM_TOKEN_KEYWORD_YIELD:
            return "'yield'";
        case PM_TOKEN_KEYWORD___ENCODING__:
            return "'__ENCODING__'";
        case PM_TOKEN_KEYWORD___FILE__:
            return "'__FILE__'";
        case PM_TOKEN_KEYWORD___LINE__:
            return "'__LINE__'";
        case PM_TOKEN_LABEL:
            return "label";
        case PM_TOKEN_LABEL_END:
            return "label terminator";
        case PM_TOKEN_LAMBDA_BEGIN:
            return "'{'";
        case PM_TOKEN_LESS:
            return "'<'";
        case PM_TOKEN_LESS_EQUAL:
            return "'<='";
        case PM_TOKEN_LESS_EQUAL_GREATER:
            return "'<=>'";
        case PM_TOKEN_LESS_LESS:
            return "<<";
        case PM_TOKEN_LESS_LESS_EQUAL:
            return "<<=";
        case PM_TOKEN_METHOD_NAME:
            return "method name";
        case PM_TOKEN_MINUS:
            return "'-'";
        case PM_TOKEN_MINUS_EQUAL:
            return "'-='";
        case PM_TOKEN_MINUS_GREATER:
            return "'->'";
        case PM_TOKEN_NEWLINE:
            return "newline";
        case PM_TOKEN_NUMBERED_REFERENCE:
            return "numbered reference";
        case PM_TOKEN_PARENTHESIS_LEFT:
            return "'('";
        case PM_TOKEN_PARENTHESIS_LEFT_PARENTHESES:
            return "'('";
        case PM_TOKEN_PARENTHESIS_RIGHT:
            return "')'";
        case PM_TOKEN_PERCENT:
            return "'%'";
        case PM_TOKEN_PERCENT_EQUAL:
            return "'%='";
        case PM_TOKEN_PERCENT_LOWER_I:
            return "'%i'";
        case PM_TOKEN_PERCENT_LOWER_W:
            return "'%w'";
        case PM_TOKEN_PERCENT_LOWER_X:
            return "'%x'";
        case PM_TOKEN_PERCENT_UPPER_I:
            return "'%I'";
        case PM_TOKEN_PERCENT_UPPER_W:
            return "'%W'";
        case PM_TOKEN_PIPE:
            return "'|'";
        case PM_TOKEN_PIPE_EQUAL:
            return "'|='";
        case PM_TOKEN_PIPE_PIPE:
            return "'||'";
        case PM_TOKEN_PIPE_PIPE_EQUAL:
            return "'||='";
        case PM_TOKEN_PLUS:
            return "'+'";
        case PM_TOKEN_PLUS_EQUAL:
            return "'+='";
        case PM_TOKEN_QUESTION_MARK:
            return "'?'";
        case PM_TOKEN_REGEXP_BEGIN:
            return "regular expression beginning";
        case PM_TOKEN_REGEXP_END:
            return "regular expression ending";
        case PM_TOKEN_SEMICOLON:
            return "';'";
        case PM_TOKEN_SLASH:
            return "'/'";
        case PM_TOKEN_SLASH_EQUAL:
            return "'/='";
        case PM_TOKEN_STAR:
            return "'*'";
        case PM_TOKEN_STAR_EQUAL:
            return "'*='";
        case PM_TOKEN_STAR_STAR:
            return "'**'";
        case PM_TOKEN_STAR_STAR_EQUAL:
            return "'**='";
        case PM_TOKEN_STRING_BEGIN:
            return "string literal";
        case PM_TOKEN_STRING_CONTENT:
            return "string content";
        case PM_TOKEN_STRING_END:
            return "string ending";
        case PM_TOKEN_SYMBOL_BEGIN:
            return "symbol literal";
        case PM_TOKEN_TILDE:
            return "'~'";
        case PM_TOKEN_UAMPERSAND:
            return "'&'";
        case PM_TOKEN_UCOLON_COLON:
            return "'::'";
        case PM_TOKEN_UDOT_DOT:
            return "'..'";
        case PM_TOKEN_UDOT_DOT_DOT:
            return "'...'";
        case PM_TOKEN_UMINUS:
            return "'-'";
        case PM_TOKEN_UMINUS_NUM:
            return "'-'";
        case PM_TOKEN_UPLUS:
            return "'+'";
        case PM_TOKEN_USTAR:
            return "*";
        case PM_TOKEN_USTAR_STAR:
            return "**";
        case PM_TOKEN_WORDS_SEP:
            return "string separator";
        case PM_TOKEN___END__:
            return "'__END__'";
        case PM_TOKEN_MAXIMUM:
            assert(false && "unreachable");
            return "";
    }

    // Provide a default, because some compilers can't determine that the above
    // switch is exhaustive.
    assert(false && "unreachable");
    return "";
}
prism-1.5.1/templates/template.rb000077500000000000000000000434321506127434000170210ustar00rootroot00000000000000#!/usr/bin/env ruby
# typed: ignore

require "erb"
require "fileutils"
require "yaml"

module Prism
  module Template
    SERIALIZE_ONLY_SEMANTICS_FIELDS = ENV.fetch("PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS", false)
    REMOVE_ON_ERROR_TYPES = SERIALIZE_ONLY_SEMANTICS_FIELDS
    CHECK_FIELD_KIND = ENV.fetch("CHECK_FIELD_KIND", false)

    JAVA_BACKEND = ENV["PRISM_JAVA_BACKEND"] || "truffleruby"
    JAVA_STRING_TYPE = JAVA_BACKEND == "jruby" ? "org.jruby.RubySymbol" : "String"
    INCLUDE_NODE_ID = !SERIALIZE_ONLY_SEMANTICS_FIELDS || JAVA_BACKEND == "jruby"

    COMMON_FLAGS_COUNT = 2

    class Error
      attr_reader :name

      def initialize(name)
        @name = name
      end
    end

    class Warning
      attr_reader :name

      def initialize(name)
        @name = name
      end
    end

    # This module contains methods for escaping characters in JavaDoc comments.
    module JavaDoc
      ESCAPES = {
        "'" => "'",
        "\"" => """,
        "@" => "@",
        "&" => "&",
        "<" => "<",
        ">" => ">"
      }.freeze

      def self.escape(value)
        value.gsub(/['&"<>@]/, ESCAPES)
      end
    end

    # A comment attached to a field or node.
    class ConfigComment
      attr_reader :value

      def initialize(value)
        @value = value
      end

      def each_line(&block)
        value.each_line { |line| yield line.prepend(" ").rstrip }
      end

      def each_java_line(&block)
        ConfigComment.new(JavaDoc.escape(value)).each_line(&block)
      end
    end

    # This represents a field on a node. It contains all of the necessary
    # information to template out the code for that field.
    class Field
      attr_reader :name, :comment, :options

      def initialize(name:, comment: nil, **options)
        @name = name
        @comment = comment
        @options = options
      end

      def each_comment_line(&block)
        ConfigComment.new(comment).each_line(&block) if comment
      end

      def each_comment_java_line(&block)
        ConfigComment.new(comment).each_java_line(&block) if comment
      end

      def semantic_field?
        true
      end

      def should_be_serialized?
        SERIALIZE_ONLY_SEMANTICS_FIELDS ? semantic_field? : true
      end
    end

    # Some node fields can be specialized if they point to a specific kind of
    # node and not just a generic node.
    class NodeKindField < Field
      def initialize(kind:, **options)
        @kind = kind
        super(**options)
      end

      def c_type
        if specific_kind
          "pm_#{specific_kind.gsub(/(?<=.)[A-Z]/, "_\\0").downcase}"
        else
          "pm_node"
        end
      end

      def ruby_type
        specific_kind || "Node"
      end

      def java_type
        specific_kind || "Node"
      end

      def java_cast
        if specific_kind
          "(Nodes.#{@kind}) "
        else
          ""
        end
      end

      def specific_kind
        @kind unless @kind.is_a?(Array)
      end

      def union_kind
        @kind if @kind.is_a?(Array)
      end
    end

    # This represents a field on a node that is itself a node. We pass them as
    # references and store them as references.
    class NodeField < NodeKindField
      def rbs_class
        if specific_kind
          specific_kind
        elsif union_kind
          union_kind.join(" | ")
        else
          "Prism::node"
        end
      end

      def rbi_class
        if specific_kind
          "Prism::#{specific_kind}"
        elsif union_kind
          "T.any(#{union_kind.map { |kind| "Prism::#{kind}" }.join(", ")})"
        else
          "Prism::Node"
        end
      end

      def check_field_kind
        if union_kind
          "[#{union_kind.join(', ')}].include?(#{name}.class)"
        else
          "#{name}.is_a?(#{ruby_type})"
        end
      end
    end

    # This represents a field on a node that is itself a node and can be
    # optionally null. We pass them as references and store them as references.
    class OptionalNodeField < NodeKindField
      def rbs_class
        if specific_kind
          "#{specific_kind}?"
        elsif union_kind
          [*union_kind, "nil"].join(" | ")
        else
          "Prism::node?"
        end
      end

      def rbi_class
        if specific_kind
          "T.nilable(Prism::#{specific_kind})"
        elsif union_kind
          "T.nilable(T.any(#{union_kind.map { |kind| "Prism::#{kind}" }.join(", ")}))"
        else
          "T.nilable(Prism::Node)"
        end
      end

      def check_field_kind
        if union_kind
          "[#{union_kind.join(', ')}, NilClass].include?(#{name}.class)"
        else
          "#{name}.nil? || #{name}.is_a?(#{ruby_type})"
        end
      end
    end

    # This represents a field on a node that is a list of nodes. We pass them as
    # references and store them directly on the struct.
    class NodeListField < NodeKindField
      def rbs_class
        if specific_kind
          "Array[#{specific_kind}]"
        elsif union_kind
          "Array[#{union_kind.join(" | ")}]"
        else
          "Array[Prism::node]"
        end
      end

      def rbi_class
        if specific_kind
          "T::Array[Prism::#{specific_kind}]"
        elsif union_kind
          "T::Array[T.any(#{union_kind.map { |kind| "Prism::#{kind}" }.join(", ")})]"
        else
          "T::Array[Prism::Node]"
        end
      end

      def java_type
        "#{super}[]"
      end

      def check_field_kind
        if union_kind
          "#{name}.all? { |n| [#{union_kind.join(', ')}].include?(n.class) }"
        else
          "#{name}.all? { |n| n.is_a?(#{ruby_type}) }"
        end
      end
    end

    # This represents a field on a node that is the ID of a string interned
    # through the parser's constant pool.
    class ConstantField < Field
      def rbs_class
        "Symbol"
      end

      def rbi_class
        "Symbol"
      end

      def java_type
        JAVA_STRING_TYPE
      end
    end

    # This represents a field on a node that is the ID of a string interned
    # through the parser's constant pool and can be optionally null.
    class OptionalConstantField < Field
      def rbs_class
        "Symbol?"
      end

      def rbi_class
        "T.nilable(Symbol)"
      end

      def java_type
        JAVA_STRING_TYPE
      end
    end

    # This represents a field on a node that is a list of IDs that are associated
    # with strings interned through the parser's constant pool.
    class ConstantListField < Field
      def rbs_class
        "Array[Symbol]"
      end

      def rbi_class
        "T::Array[Symbol]"
      end

      def java_type
        "#{JAVA_STRING_TYPE}[]"
      end
    end

    # This represents a field on a node that is a string.
    class StringField < Field
      def rbs_class
        "String"
      end

      def rbi_class
        "String"
      end

      def java_type
        "byte[]"
      end
    end

    # This represents a field on a node that is a location.
    class LocationField < Field
      def semantic_field?
        false
      end

      def rbs_class
        "Location"
      end

      def rbi_class
        "Prism::Location"
      end

      def java_type
        "Location"
      end
    end

    # This represents a field on a node that is a location that is optional.
    class OptionalLocationField < Field
      def semantic_field?
        false
      end

      def rbs_class
        "Location?"
      end

      def rbi_class
        "T.nilable(Prism::Location)"
      end

      def java_type
        "Location"
      end
    end

    # This represents an integer field.
    class UInt8Field < Field
      def rbs_class
        "Integer"
      end

      def rbi_class
        "Integer"
      end

      def java_type
        "int"
      end
    end

    # This represents an integer field.
    class UInt32Field < Field
      def rbs_class
        "Integer"
      end

      def rbi_class
        "Integer"
      end

      def java_type
        "int"
      end
    end

    # This represents an arbitrarily-sized integer. When it gets to Ruby it will
    # be an Integer.
    class IntegerField < Field
      def rbs_class
        "Integer"
      end

      def rbi_class
        "Integer"
      end

      def java_type
        "Object"
      end
    end

    # This represents a double-precision floating point number. When it gets to
    # Ruby it will be a Float.
    class DoubleField < Field
      def rbs_class
        "Float"
      end

      def rbi_class
        "Float"
      end

      def java_type
        "double"
      end
    end

    # This class represents a node in the tree, configured by the config.yml file
    # in YAML format. It contains information about the name of the node and the
    # various child nodes it contains.
    class NodeType
      attr_reader :name, :type, :human, :flags, :fields, :newline, :comment

      def initialize(config, flags)
        @name = config.fetch("name")

        type = @name.gsub(/(?<=.)[A-Z]/, "_\\0")
        @type = "PM_#{type.upcase}"
        @human = type.downcase

        @fields =
          config.fetch("fields", []).map do |field|
            type = field_type_for(field.fetch("type"))

            options = field.transform_keys(&:to_sym)
            options.delete(:type)

            # If/when we have documentation on every field, this should be
            # changed to use fetch instead of delete.
            comment = options.delete(:comment)

            if kinds = options[:kind]
              kinds = [kinds] unless kinds.is_a?(Array)
              kinds = kinds.map do |kind|
                case kind
                when "non-void expression"
                  # the actual list of types would be way too long
                  "Node"
                when "pattern expression"
                  # the list of all possible types is too long with 37+ different classes
                  "Node"
                when Hash
                  kind = kind.fetch("on error")
                  REMOVE_ON_ERROR_TYPES ? nil : kind
                else
                  kind
                end
              end.compact
              if kinds.size == 1
                kinds = kinds.first
                kinds = nil if kinds == "Node"
              end
              options[:kind] = kinds
            else
              if type < NodeKindField
                raise "Missing kind in config.yml for field #{@name}##{options.fetch(:name)}"
              end
            end

            type.new(comment: comment, **options)
          end

        @flags = config.key?("flags") ? flags.fetch(config.fetch("flags")) : nil
        @newline = config.fetch("newline", true)
        @comment = config.fetch("comment")
      end

      def each_comment_line(&block)
        ConfigComment.new(comment).each_line(&block)
      end

      def each_comment_java_line(&block)
        ConfigComment.new(comment).each_java_line(&block)
      end

      def semantic_fields
        @semantic_fields ||= @fields.select(&:semantic_field?)
      end

      # Should emit serialized length of node so implementations can skip
      # the node to enable lazy parsing.
      def needs_serialized_length?
        name == "DefNode"
      end

      private

      def field_type_for(name)
        case name
        when "node"       then NodeField
        when "node?"      then OptionalNodeField
        when "node[]"     then NodeListField
        when "string"     then StringField
        when "constant"   then ConstantField
        when "constant?"  then OptionalConstantField
        when "constant[]" then ConstantListField
        when "location"   then LocationField
        when "location?"  then OptionalLocationField
        when "uint8"      then UInt8Field
        when "uint32"     then UInt32Field
        when "integer"    then IntegerField
        when "double"     then DoubleField
        else raise("Unknown field type: #{name.inspect}")
        end
      end
    end

    # This represents a token in the lexer.
    class Token
      attr_reader :name, :value, :comment

      def initialize(config)
        @name = config.fetch("name")
        @value = config["value"]
        @comment = config.fetch("comment")
      end
    end

    # Represents a set of flags that should be internally represented with an enum.
    class Flags
      # Represents an individual flag within a set of flags.
      class Flag
        attr_reader :name, :camelcase, :comment

        def initialize(config)
          @name = config.fetch("name")
          @camelcase = @name.split("_").map(&:capitalize).join
          @comment = config.fetch("comment")
        end
      end

      attr_reader :name, :human, :values, :comment

      def initialize(config)
        @name = config.fetch("name")
        @human = @name.gsub(/(?<=.)[A-Z]/, "_\\0").downcase
        @values = config.fetch("values").map { |flag| Flag.new(flag) }
        @comment = config.fetch("comment")
      end

      def self.empty
        new("name" => "", "values" => [], "comment" => "")
      end
    end

    class << self
      # This templates out a file using ERB with the given locals. The locals are
      # derived from the config.yml file.
      def render(name, write_to: nil)
        filepath = "templates/#{name}.erb"
        template = File.expand_path("../#{filepath}", __dir__)

        erb = read_template(template)
        extension = File.extname(filepath.gsub(".erb", ""))

        heading =
          case extension
          when ".rb"
            <<~HEADING
            # frozen_string_literal: true
            # :markup: markdown

            =begin
            --
            This file is generated by the templates/template.rb script and should not be
            modified manually. See #{filepath}
            if you are looking to modify the template
            ++
            =end

            HEADING
          when ".rbs"
            <<~HEADING
            # This file is generated by the templates/template.rb script and should not be
            # modified manually. See #{filepath}
            # if you are looking to modify the template

            HEADING
          when ".rbi"
            <<~HEADING
            # typed: strict

            =begin
            This file is generated by the templates/template.rb script and should not be
            modified manually. See #{filepath}
            if you are looking to modify the template
            =end

            HEADING
          else
            <<~HEADING
            /* :markup: markdown */

            /*----------------------------------------------------------------------------*/
            /* This file is generated by the templates/template.rb script and should not  */
            /* be modified manually. See                                                  */
            /* #{filepath.ljust(74)} */
            /* if you are looking to modify the                                           */
            /* template                                                                   */
            /*----------------------------------------------------------------------------*/

            HEADING
          end

        write_to ||= File.expand_path("../#{name}", __dir__)
        contents = heading + erb.result_with_hash(locals)

        if (extension == ".c" || extension == ".h") && !contents.ascii_only?
          # Enforce that we only have ASCII characters here. This is necessary
          # for non-UTF-8 locales that only allow ASCII characters in C source
          # files.
          contents.each_line.with_index(1) do |line, line_number|
            raise "Non-ASCII character on line #{line_number} of #{write_to}" unless line.ascii_only?
          end
        end

        FileUtils.mkdir_p(File.dirname(write_to))
        File.write(write_to, contents)
      end

      private

      def read_template(filepath)
        template = File.read(filepath, encoding: Encoding::UTF_8)
        erb = erb(template)
        erb.filename = filepath
        erb
      end

      def erb(template)
        ERB.new(template, trim_mode: "-")
      end

      def locals
        @locals ||=
          begin
            config = YAML.load_file(File.expand_path("../config.yml", __dir__))
            flags = config.fetch("flags").to_h { |flags| [flags["name"], Flags.new(flags)] }

            {
              errors: config.fetch("errors").map { |name| Error.new(name) },
              warnings: config.fetch("warnings").map { |name| Warning.new(name) },
              nodes: config.fetch("nodes").map { |node| NodeType.new(node, flags) }.sort_by(&:name),
              tokens: config.fetch("tokens").map { |token| Token.new(token) },
              flags: flags.values
            }
          end
      end
    end

    TEMPLATES = [
      "ext/prism/api_node.c",
      "include/prism/ast.h",
      "include/prism/diagnostic.h",
      "javascript/src/deserialize.js",
      "javascript/src/nodes.js",
      "javascript/src/visitor.js",
      "java/org/prism/Loader.java",
      "java/org/prism/Nodes.java",
      "java/org/prism/AbstractNodeVisitor.java",
      "lib/prism/compiler.rb",
      "lib/prism/dispatcher.rb",
      "lib/prism/dot_visitor.rb",
      "lib/prism/dsl.rb",
      "lib/prism/inspect_visitor.rb",
      "lib/prism/mutation_compiler.rb",
      "lib/prism/node.rb",
      "lib/prism/reflection.rb",
      "lib/prism/serialize.rb",
      "lib/prism/visitor.rb",
      "src/diagnostic.c",
      "src/node.c",
      "src/prettyprint.c",
      "src/serialize.c",
      "src/token_type.c",
      "rbi/prism/dsl.rbi",
      "rbi/prism/node.rbi",
      "rbi/prism/visitor.rbi",
      "sig/prism.rbs",
      "sig/prism/dsl.rbs",
      "sig/prism/mutation_compiler.rbs",
      "sig/prism/node.rbs",
      "sig/prism/visitor.rbs",
      "sig/prism/_private/dot_visitor.rbs"
    ]
  end
end

if __FILE__ == $0
  if ARGV.empty?
    Prism::Template::TEMPLATES.each { |filepath| Prism::Template.render(filepath) }
  else # ruby/ruby
    name, write_to = ARGV
    Prism::Template.render(name, write_to: write_to)
  end
end
prism-1.5.1/test/000077500000000000000000000000001506127434000136315ustar00rootroot00000000000000prism-1.5.1/test/prism/000077500000000000000000000000001506127434000147635ustar00rootroot00000000000000prism-1.5.1/test/prism/api/000077500000000000000000000000001506127434000155345ustar00rootroot00000000000000prism-1.5.1/test/prism/api/command_line_test.rb000066400000000000000000000057761506127434000215640ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class CommandLineTest < TestCase
    def test_command_line_p
      program = Prism.parse("1", command_line: "p").value
      statements = program.statements.body

      assert_equal 2, statements.length
      assert_kind_of CallNode, statements.last
      assert_equal :print, statements.last.name
    end

    def test_command_line_n
      program = Prism.parse("1", command_line: "n").value
      statements = program.statements.body

      assert_equal 1, statements.length
      assert_kind_of WhileNode, statements.first

      predicate = statements.first.predicate
      assert_kind_of CallNode, predicate
      assert_equal :gets, predicate.name

      arguments = predicate.arguments.arguments
      assert_equal 1, arguments.length
      assert_equal :$/, arguments.first.name
    end

    def test_command_line_a
      program = Prism.parse("1", command_line: "na").value
      statements = program.statements.body

      assert_equal 1, statements.length
      assert_kind_of WhileNode, statements.first

      statement = statements.first.statements.body.first
      assert_kind_of GlobalVariableWriteNode, statement
      assert_equal :$F, statement.name
    end

    def test_command_line_l
      program = Prism.parse("1", command_line: "nl").value
      statements = program.statements.body

      assert_equal 1, statements.length
      assert_kind_of WhileNode, statements.first

      predicate = statements.first.predicate
      assert_kind_of CallNode, predicate
      assert_equal :gets, predicate.name

      arguments = predicate.arguments
      assert arguments.contains_keywords?

      arguments = predicate.arguments.arguments
      assert_equal 2, arguments.length
      assert_equal :$/, arguments.first.name
      assert_equal "chomp", arguments.last.elements.first.key.unescaped
    end

    def test_command_line_e
      result = Prism.parse("1 if 2..3")
      assert_equal 2, result.warnings.length

      result = Prism.parse("1 if 2..3", command_line: "e")
      assert_equal 0, result.warnings.length
    end

    def test_command_line_x_implicit
      result = Prism.parse_statement(<<~RUBY, main_script: true)
        #!/bin/bash
        exit 1

        #!/usr/bin/env ruby
        1
      RUBY

      assert_kind_of IntegerNode, result
    end

    def test_command_line_x_explicit
      result = Prism.parse_statement(<<~RUBY, command_line: "x")
        exit 1

        #!/usr/bin/env ruby
        1
      RUBY

      assert_kind_of IntegerNode, result
    end

    def test_command_line_x_implicit_fail
      result = Prism.parse(<<~RUBY, main_script: true)
        #!/bin/bash
        exit 1
      RUBY

      assert_equal 1, result.errors.length
      assert_equal :load, result.errors.first.level
    end

    def test_command_line_x_explicit_fail
      result = Prism.parse(<<~RUBY, command_line: "x")
        exit 1
      RUBY

      assert_equal 1, result.errors.length
      assert_equal :load, result.errors.first.level
    end
  end
end
prism-1.5.1/test/prism/api/dump_test.rb000066400000000000000000000027211506127434000200670ustar00rootroot00000000000000# frozen_string_literal: true

return if ENV["PRISM_BUILD_MINIMAL"]

require_relative "../test_helper"

module Prism
  class DumpTest < TestCase
    Fixture.each do |fixture|
      define_method(fixture.test_name) { assert_dump(fixture) }
    end

    def test_dump
      filepath = __FILE__
      source = File.read(filepath, binmode: true, external_encoding: Encoding::UTF_8)

      assert_equal Prism.lex(source, filepath: filepath).value, Prism.lex_file(filepath).value
      assert_equal Prism.dump(source, filepath: filepath), Prism.dump_file(filepath)

      serialized = Prism.dump(source, filepath: filepath)
      ast1 = Prism.load(source, serialized).value
      ast2 = Prism.parse(source, filepath: filepath).value
      ast3 = Prism.parse_file(filepath).value

      assert_equal_nodes ast1, ast2
      assert_equal_nodes ast2, ast3
    end

    def test_dump_file
      assert_nothing_raised do
        Prism.dump_file(__FILE__)
      end

      error = assert_raise Errno::ENOENT do
        Prism.dump_file("idontexist.rb")
      end

      assert_equal "No such file or directory - idontexist.rb", error.message

      assert_raise TypeError do
        Prism.dump_file(nil)
      end
    end

    private

    def assert_dump(fixture)
      source = fixture.read

      result = Prism.parse(source, filepath: fixture.path)
      dumped = Prism.dump(source, filepath: fixture.path)

      assert_equal_nodes(result.value, Prism.load(source, dumped).value)
    end
  end
end
prism-1.5.1/test/prism/api/freeze_test.rb000066400000000000000000000030601506127434000203770ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class FreezeTest < TestCase
    def test_parse
      assert_frozen(Prism.parse("1 + 2; %i{foo} + %i{bar}", freeze: true))
    end

    def test_lex
      assert_frozen(Prism.lex("1 + 2; %i{foo} + %i{bar}", freeze: true))
    end

    def test_parse_lex
      assert_frozen(Prism.parse_lex("1 + 2; %i{foo} + %i{bar}", freeze: true))
      assert_frozen(Prism.parse_lex("# encoding: euc-jp\n%i{foo}", freeze: true))
    end

    def test_parse_comments
      assert_frozen(Prism.parse_comments("# comment", freeze: true))
    end

    def test_parse_stream
      assert_frozen(Prism.parse_stream(StringIO.new("1 + 2; %i{foo} + %i{bar}"), freeze: true))
    end

    if !ENV["PRISM_BUILD_MINIMAL"]
      def test_dump
        assert_frozen(Prism.dump("1 + 2; %i{foo} + %i{bar}", freeze: true))
      end
    end

    private

    def assert_frozen_each(value)
      assert_predicate value, :frozen?

      value.instance_variables.each do |name|
        case (child = value.instance_variable_get(name))
        when Array
          child.each { |item| assert_frozen_each(item) }
        when Hash
          child.each { |key, item| assert_frozen_each(key); assert_frozen_each(item) }
        else
          assert_frozen_each(child)
        end
      end
    end

    if defined?(Ractor.shareable?)
      def assert_frozen(value)
        assert_frozen_each(value)
        assert Ractor.shareable?(value), -> { binding.irb }
      end
    else
      alias assert_frozen assert_frozen_each
    end
  end
end
prism-1.5.1/test/prism/api/lex_test.rb000066400000000000000000000007711506127434000177150ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class LexTest < TestCase
    def test_lex_result
      result = Prism.lex("")
      assert_kind_of LexResult, result

      result = Prism.lex_file(__FILE__)
      assert_kind_of LexResult, result
    end

    def test_parse_lex_result
      result = Prism.parse_lex("")
      assert_kind_of ParseLexResult, result

      result = Prism.parse_lex_file(__FILE__)
      assert_kind_of ParseLexResult, result
    end
  end
end
prism-1.5.1/test/prism/api/parse_comments_test.rb000066400000000000000000000014021506127434000221340ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class ParseCommentsTest < TestCase
    def test_parse_comments
      comments = Prism.parse_comments("# foo")

      assert_kind_of Array, comments
      assert_equal 1, comments.length
    end

    def test_parse_file_comments
      comments = Prism.parse_file_comments(__FILE__)

      assert_kind_of Array, comments
      assert_equal 1, comments.length
    end

    def test_parse_file_comments_error
      error = assert_raise Errno::ENOENT do
        Prism.parse_file_comments("idontexist.rb")
      end

      assert_equal "No such file or directory - idontexist.rb", error.message

      assert_raise TypeError do
        Prism.parse_file_comments(nil)
      end
    end
  end
end
prism-1.5.1/test/prism/api/parse_stream_test.rb000066400000000000000000000041661506127434000216140ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class ParseStreamTest < TestCase
    def test_single_line
      io = StringIO.new("1 + 2")
      result = Prism.parse_stream(io)

      assert result.success?
      assert_kind_of Prism::CallNode, result.statement
    end

    def test_multi_line
      io = StringIO.new("1 + 2\n3 + 4")
      result = Prism.parse_stream(io)

      assert result.success?
      assert_kind_of Prism::CallNode, result.statement
      assert_kind_of Prism::CallNode, result.statement
    end

    def test_multi_read
      io = StringIO.new("a" * 4096 * 4)
      result = Prism.parse_stream(io)

      assert result.success?
      assert_kind_of Prism::CallNode, result.statement
    end

    def test___END__
      io = StringIO.new("1 + 2\n3 + 4\n__END__\n5 + 6")
      result = Prism.parse_stream(io)

      assert result.success?
      assert_equal 2, result.value.statements.body.length
      assert_equal "5 + 6", io.read
    end

    def test_false___END___in_string
      io = StringIO.new("1 + 2\n3 + 4\n\"\n__END__\n\"\n5 + 6")
      result = Prism.parse_stream(io)

      assert result.success?
      assert_equal 4, result.value.statements.body.length
    end

    def test_false___END___in_regexp
      io = StringIO.new("1 + 2\n3 + 4\n/\n__END__\n/\n5 + 6")
      result = Prism.parse_stream(io)

      assert result.success?
      assert_equal 4, result.value.statements.body.length
    end

    def test_false___END___in_list
      io = StringIO.new("1 + 2\n3 + 4\n%w[\n__END__\n]\n5 + 6")
      result = Prism.parse_stream(io)

      assert result.success?
      assert_equal 4, result.value.statements.body.length
    end

    def test_false___END___in_heredoc
      io = StringIO.new("1 + 2\n3 + 4\n<<-EOF\n__END__\nEOF\n5 + 6")
      result = Prism.parse_stream(io)

      assert result.success?
      assert_equal 4, result.value.statements.body.length
    end

    def test_nul_bytes
      io = StringIO.new("1 # \0\0\0 \n2 # \0\0\0\n3")
      result = Prism.parse_stream(io)

      assert result.success?
      assert_equal 3, result.value.statements.body.length
    end
  end
end
prism-1.5.1/test/prism/api/parse_success_test.rb000066400000000000000000000005131506127434000217610ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class ParseSuccessTest < TestCase
    def test_parse_success?
      assert Prism.parse_success?("1")
      refute Prism.parse_success?("<>")
    end

    def test_parse_file_success?
      assert Prism.parse_file_success?(__FILE__)
    end
  end
end
prism-1.5.1/test/prism/api/parse_test.rb000066400000000000000000000123361506127434000202370ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class ParseTest < TestCase
    def test_parse_result
      result = Prism.parse("")
      assert_kind_of ParseResult, result

      result = Prism.parse_file(__FILE__)
      assert_kind_of ParseResult, result
    end

    def test_parse_empty_string
      result = Prism.parse("")
      assert_equal [], result.value.statements.body
    end

    def test_parse_takes_file_path
      filepath = "filepath.rb"
      result = Prism.parse("def foo; __FILE__; end", filepath: filepath)

      assert_equal filepath, find_source_file_node(result.value).filepath
    end

    def test_parse_takes_line
      line = 4
      result = Prism.parse("def foo\n __FILE__\nend", line: line)

      assert_equal line, result.value.location.start_line
      assert_equal line + 1, find_source_file_node(result.value).location.start_line

      result = Prism.parse_lex("def foo\n __FILE__\nend", line: line)
      assert_equal line, result.value.first.location.start_line
    end

    def test_parse_takes_negative_lines
      line = -2
      result = Prism.parse("def foo\n __FILE__\nend", line: line)

      assert_equal line, result.value.location.start_line
      assert_equal line + 1, find_source_file_node(result.value).location.start_line

      result = Prism.parse_lex("def foo\n __FILE__\nend", line: line)
      assert_equal line, result.value.first.location.start_line
    end

    def test_parse_file
      node = Prism.parse_file(__FILE__).value
      assert_kind_of ProgramNode, node

      error = assert_raise Errno::ENOENT do
        Prism.parse_file("idontexist.rb")
      end

      assert_equal "No such file or directory - idontexist.rb", error.message

      assert_raise TypeError do
        Prism.parse_file(nil)
      end
    end

    def test_parse_tempfile
      Tempfile.create(["test_parse_tempfile", ".rb"]) do |t|
        t.puts ["begin\n", " end\n"]
        t.flush
        Prism.parse_file(t.path)
      end
    end

    if RUBY_ENGINE != "truffleruby"
      def test_parse_nonascii
        Dir.mktmpdir do |dir|
          path = File.join(dir, "\u{3042 3044 3046 3048 304a}.rb".encode(Encoding::Windows_31J))
          File.write(path, "ok")
          Prism.parse_file(path)
        end
      end
    end

    def test_parse_directory
      error = nil

      begin
        Prism.parse_file(__dir__)
      rescue SystemCallError => error
      end

      assert_kind_of Errno::EISDIR, error
    end

    def test_partial_script
      assert Prism.parse_failure?("break")
      assert Prism.parse_success?("break", partial_script: true)

      assert Prism.parse_failure?("next")
      assert Prism.parse_success?("next", partial_script: true)

      assert Prism.parse_failure?("redo")
      assert Prism.parse_success?("redo", partial_script: true)

      assert Prism.parse_failure?("yield")
      assert Prism.parse_success?("yield", partial_script: true)
    end

    def test_version
      assert Prism.parse_success?("1 + 1", version: "3.3")
      assert Prism.parse_success?("1 + 1", version: "3.3.0")
      assert Prism.parse_success?("1 + 1", version: "3.3.1")
      assert Prism.parse_success?("1 + 1", version: "3.3.9")
      assert Prism.parse_success?("1 + 1", version: "3.3.10")

      assert Prism.parse_success?("1 + 1", version: "3.4")
      assert Prism.parse_success?("1 + 1", version: "3.4.0")
      assert Prism.parse_success?("1 + 1", version: "3.4.9")
      assert Prism.parse_success?("1 + 1", version: "3.4.10")

      assert Prism.parse_success?("1 + 1", version: "3.5")
      assert Prism.parse_success?("1 + 1", version: "3.5.0")

      assert Prism.parse_success?("1 + 1", version: "latest")

      # Test edge case
      error = assert_raise(ArgumentError) { Prism.parse("1 + 1", version: "latest2") }
      assert_equal "invalid version: latest2", error.message

      assert_raise ArgumentError do
        Prism.parse("1 + 1", version: "3.3.a")
      end

      # Not supported version (too old)
      assert_raise ArgumentError do
        Prism.parse("1 + 1", version: "3.2.0")
      end

      # Not supported version (too new)
      assert_raise ArgumentError do
        Prism.parse("1 + 1", version: "3.6.0")
      end
    end

    def test_scopes
      assert_kind_of Prism::CallNode, Prism.parse_statement("foo")
      assert_kind_of Prism::LocalVariableReadNode, Prism.parse_statement("foo", scopes: [[:foo]])
      assert_kind_of Prism::LocalVariableReadNode, Prism.parse_statement("foo", scopes: [Prism.scope(locals: [:foo])])

      assert Prism.parse_failure?("foo(*)")
      assert Prism.parse_success?("foo(*)", scopes: [Prism.scope(forwarding: [:*])])

      assert Prism.parse_failure?("foo(**)")
      assert Prism.parse_success?("foo(**)", scopes: [Prism.scope(forwarding: [:**])])

      assert Prism.parse_failure?("foo(&)")
      assert Prism.parse_success?("foo(&)", scopes: [Prism.scope(forwarding: [:&])])

      assert Prism.parse_failure?("foo(...)")
      assert Prism.parse_success?("foo(...)", scopes: [Prism.scope(forwarding: [:"..."])])
    end

    private

    def find_source_file_node(program)
      queue = [program]
      while (node = queue.shift)
        return node if node.is_a?(SourceFileNode)
        queue.concat(node.compact_child_nodes)
      end
    end
  end
end
prism-1.5.1/test/prism/bom_test.rb000066400000000000000000000021071506127434000171240ustar00rootroot00000000000000# frozen_string_literal: true

# Don't bother checking this on these engines, this is such a specific Ripper
# test.
return if RUBY_ENGINE != "ruby"

require_relative "test_helper"

module Prism
  class BOMTest < TestCase
    def test_ident
      assert_bom("foo")
    end

    def test_back_reference
      assert_bom("$+")
    end

    def test_instance_variable
      assert_bom("@foo")
    end

    def test_class_variable
      assert_bom("@@foo")
    end

    def test_global_variable
      assert_bom("$foo")
    end

    def test_numbered_reference
      assert_bom("$1")
    end

    def test_percents
      assert_bom("%i[]")
      assert_bom("%r[]")
      assert_bom("%s[]")
      assert_bom("%q{}")
      assert_bom("%w[]")
      assert_bom("%x[]")
      assert_bom("%I[]")
      assert_bom("%W[]")
      assert_bom("%Q{}")
    end

    def test_string
      assert_bom("\"\"")
      assert_bom("''")
    end

    private

    def assert_bom(source)
      bommed = "\xEF\xBB\xBF#{source}"
      assert_equal Prism.lex_ripper(bommed), Prism.lex_compat(bommed).value
    end
  end
end
prism-1.5.1/test/prism/encoding/000077500000000000000000000000001506127434000165515ustar00rootroot00000000000000prism-1.5.1/test/prism/encoding/encodings_test.rb000066400000000000000000000066221506127434000221140ustar00rootroot00000000000000# frozen_string_literal: true

return if RUBY_ENGINE != "ruby"

require_relative "../test_helper"

module Prism
  class EncodingsTest < TestCase
    class ConstantContext < BasicObject
      def self.const_missing(const)
        const
      end
    end

    class IdentifierContext < BasicObject
      def method_missing(name, *)
        name
      end
    end

    # These test that we're correctly parsing codepoints for each alias of each
    # encoding that prism supports.
    each_encoding do |encoding, range|
      (encoding.names - %w[external internal filesystem locale]).each do |name|
        define_method(:"test_encoding_#{name}") do
          assert_encoding(encoding, name, range)
        end
      end
    end

    private

    def assert_encoding_constant(name, character)
      source = "# encoding: #{name}\n#{character}"
      expected = ConstantContext.new.instance_eval(source)

      result = Prism.parse(source)
      assert result.success?

      actual = result.value.statements.body.last
      assert_kind_of ConstantReadNode, actual
      assert_equal expected, actual.name
    end

    def assert_encoding_identifier(name, character)
      source = "# encoding: #{name}\n#{character}"
      expected = IdentifierContext.new.instance_eval(source)

      result = Prism.parse(source)
      assert result.success?

      actual = result.value.statements.body.last
      assert_kind_of CallNode, actual
      assert_equal expected, actual.name
    end

    # Check that we can properly parse every codepoint in the given encoding.
    def assert_encoding(encoding, name, range)
      # I'm not entirely sure, but I believe these codepoints are incorrect in
      # their parsing in CRuby. They all report as matching `[[:lower:]]` but
      # then they are parsed as constants. This is because CRuby determines if
      # an identifier is a constant or not by case folding it down to lowercase
      # and checking if there is a difference. And even though they report
      # themselves as lowercase, their case fold is different. I have reported
      # this bug upstream.
      case encoding
      when Encoding::UTF_8, Encoding::UTF_8_MAC, Encoding::UTF8_DoCoMo, Encoding::UTF8_KDDI, Encoding::UTF8_SoftBank, Encoding::CESU_8
        range = range.to_a - [
          0x01c5, 0x01c8, 0x01cb, 0x01f2, 0x1f88, 0x1f89, 0x1f8a, 0x1f8b,
          0x1f8c, 0x1f8d, 0x1f8e, 0x1f8f, 0x1f98, 0x1f99, 0x1f9a, 0x1f9b,
          0x1f9c, 0x1f9d, 0x1f9e, 0x1f9f, 0x1fa8, 0x1fa9, 0x1faa, 0x1fab,
          0x1fac, 0x1fad, 0x1fae, 0x1faf, 0x1fbc, 0x1fcc, 0x1ffc,
        ]
      when Encoding::Windows_1253
        range = range.to_a - [0xb5]
      end

      range.each do |codepoint|
        character = codepoint.chr(encoding)

        if character.match?(/[[:alpha:]]/)
          if character.match?(/[[:upper:]]/)
            assert_encoding_constant(name, character)
          else
            assert_encoding_identifier(name, character)
          end
        elsif character.match?(/[[:alnum:]]/)
          assert_encoding_identifier(name, "_#{character}")
        else
          next if ["/", "{"].include?(character)

          source = "# encoding: #{name}\n/(?##{character})/\n"
          assert Prism.parse_success?(source), "Expected #{source.inspect} to parse successfully."
        end
      rescue RangeError
        source = "# encoding: #{name}\n\\x#{codepoint.to_s(16)}"
        assert Prism.parse_failure?(source)
      end
    end
  end
end
prism-1.5.1/test/prism/encoding/regular_expression_encoding_test.rb000066400000000000000000000134351506127434000257310ustar00rootroot00000000000000# frozen_string_literal: true

return unless defined?(RubyVM::InstructionSequence)
return if RubyVM::InstructionSequence.compile("").to_a[4][:parser] == :prism

require_relative "../test_helper"

module Prism
  class RegularExpressionEncodingTest < TestCase
    each_encoding do |encoding, _|
      define_method(:"test_regular_expression_encoding_flags_#{encoding.name}") do
        assert_regular_expression_encoding_flags(encoding, ["/a/", "/Ä…/", "//"])
      end

      escapes = ["\\x00", "\\x7F", "\\x80", "\\xFF", "\\u{00}", "\\u{7F}", "\\u{80}", "\\M-\\C-?"]
      escapes = escapes.concat(escapes.product(escapes).map(&:join))

      define_method(:"test_regular_expression_escape_encoding_flags_#{encoding.name}") do
        assert_regular_expression_encoding_flags(encoding, escapes.map { |e| "/#{e}/" })
      end

      ["n", "u", "e", "s"].each do |modifier|
        define_method(:"test_regular_expression_encoding_modifiers_/#{modifier}_#{encoding.name}") do
          regexp_sources = ["abc", "garçon", "\\x80", "gar\\xC3\\xA7on", "gar\\u{E7}on", "abc\\u{FFFFFF}", "\\x80\\u{80}" ]

          assert_regular_expression_encoding_flags(
            encoding,
            regexp_sources.product(["n", "u", "e", "s"]).map { |r, modifier| "/#{r}/#{modifier}" }
          )
        end
      end
    end

    private

    def assert_regular_expression_encoding_flags(encoding, regexps)
      regexps.each do |regexp|
        regexp_modifier_used = regexp.end_with?("/u") || regexp.end_with?("/e") || regexp.end_with?("/s") || regexp.end_with?("/n")
        source = "# encoding: #{encoding.name}\n#{regexp}"

        encoding_errors = ["invalid multibyte char", "escaped non ASCII character in UTF-8 regexp", "differs from source encoding"]
        skipped_errors = ["invalid multibyte escape", "incompatible character encoding", "UTF-8 character in non UTF-8 regexp", "invalid Unicode range", "invalid Unicode list"]

        # TODO (nirvdrum 21-Feb-2024): Prism currently does not handle Regexp validation unless modifiers are used. So, skip processing those errors for now: https://github.com/ruby/prism/issues/2104
        unless regexp_modifier_used
          skipped_errors += encoding_errors
          encoding_errors.clear
        end

        expected =
          begin
            eval(source).encoding
          rescue SyntaxError => error
            if encoding_errors.find { |e| error.message.include?(e) }
              error.message.split("\n").map { |m| m[/: (.+?)$/, 1] }
            elsif skipped_errors.find { |e| error.message.include?(e) }
              next
            else
              raise
            end
          end

        actual =
          Prism.parse(source).then do |result|
            if result.success?
              regexp = result.statement

              actual_encoding = if regexp.forced_utf8_encoding?
                Encoding::UTF_8
              elsif regexp.forced_binary_encoding?
                Encoding::ASCII_8BIT
              elsif regexp.forced_us_ascii_encoding?
                Encoding::US_ASCII
              elsif regexp.ascii_8bit?
                Encoding::ASCII_8BIT
              elsif regexp.utf_8?
                Encoding::UTF_8
              elsif regexp.euc_jp?
                Encoding::EUC_JP
              elsif regexp.windows_31j?
                Encoding::Windows_31J
              else
                encoding
              end

              if regexp.utf_8? && actual_encoding != Encoding::UTF_8
                raise "expected regexp encoding to be UTF-8 due to '/u' modifier, but got #{actual_encoding.name}"
              elsif regexp.ascii_8bit? && (actual_encoding != Encoding::ASCII_8BIT && actual_encoding != Encoding::US_ASCII)
                raise "expected regexp encoding to be ASCII-8BIT or US-ASCII due to '/n' modifier, but got #{actual_encoding.name}"
              elsif regexp.euc_jp? && actual_encoding != Encoding::EUC_JP
                raise "expected regexp encoding to be EUC-JP due to '/e' modifier, but got #{actual_encoding.name}"
              elsif regexp.windows_31j? && actual_encoding != Encoding::Windows_31J
                raise "expected regexp encoding to be Windows-31J due to '/s' modifier, but got #{actual_encoding.name}"
              end

              if regexp.utf_8? && regexp.forced_utf8_encoding?
                raise "the forced_utf8 flag should not be set when the UTF-8 modifier (/u) is used"
              elsif regexp.ascii_8bit? && regexp.forced_binary_encoding?
                raise "the forced_ascii_8bit flag should not be set when the UTF-8 modifier (/u) is used"
              end

              actual_encoding
            else
              errors = result.errors.map(&:message)

              if errors.last&.include?("UTF-8 mixed within")
                nil
              else
                errors
              end
            end
          end

        # TODO (nirvdrum 22-Feb-2024): Remove this workaround once Prism better maps CRuby's error messages.
        # This class of error message is tricky. The part not being compared is a representation of the regexp.
        # Depending on the source encoding and any encoding modifiers being used, CRuby alters how the regexp is represented.
        # Sometimes it's an MBC string. Other times it uses hexadecimal character escapes. And in other cases it uses
        # the long-form Unicode escape sequences. This short-circuit checks that the error message is mostly correct.
        if expected.is_a?(Array) && actual.is_a?(Array)
          if expected.last.start_with?("/.../n has a non escaped non ASCII character in non ASCII-8BIT script:") &&
              actual.last.start_with?("/.../n has a non escaped non ASCII character in non ASCII-8BIT script:")
            expected.pop
            actual.pop
          end
        end

        assert_equal expected, actual
      end
    end
  end
end
prism-1.5.1/test/prism/encoding/string_encoding_test.rb000066400000000000000000000076401506127434000233200ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class StringEncodingTest < TestCase
    each_encoding do |encoding, _|
      define_method(:"test_#{encoding.name}") do
        assert_encoding(encoding)
      end
    end

    def test_coding
      actual = Prism.parse_statement("# coding: utf-8\n'string'").unescaped.encoding
      assert_equal Encoding::UTF_8, actual
    end

    def test_coding_with_whitespace
      actual = Prism.parse_statement("# coding \t \r  \v   :     \t \v    \r   ascii-8bit \n'string'").unescaped.encoding
      assert_equal Encoding::ASCII_8BIT, actual
    end

    def test_emacs_style
      actual = Prism.parse_statement("# -*- coding: utf-8 -*-\n'string'").unescaped.encoding
      assert_equal Encoding::UTF_8, actual
    end

    def test_utf_8_unix
      actual = Prism.parse_statement("# coding: utf-8-unix\n'string'").unescaped.encoding
      assert_equal Encoding::UTF_8, actual
    end

    def test_utf_8_dos
      actual = Prism.parse_statement("# coding: utf-8-dos\n'string'").unescaped.encoding
      assert_equal Encoding::UTF_8, actual
    end

    def test_utf_8_mac
      actual = Prism.parse_statement("# coding: utf-8-mac\n'string'").unescaped.encoding
      assert_equal Encoding::UTF_8, actual
    end

    def test_utf_8_star
      actual = Prism.parse_statement("# coding: utf-8-*\n'string'").unescaped.encoding
      assert_equal Encoding::UTF_8, actual
    end

    def test_first_lexed_token
      encoding = Prism.lex("# encoding: ascii-8bit").value[0][0].value.encoding
      assert_equal Encoding::ASCII_8BIT, encoding
    end

    if !ENV["PRISM_BUILD_MINIMAL"]
      # This test may be a little confusing. Basically when we use our strpbrk,
      # it takes into account the encoding of the file.
      def test_strpbrk_multibyte
        result = Prism.parse(<<~RUBY)
          # encoding: Shift_JIS
          %w[\x81\x5c]
        RUBY

        assert(result.errors.empty?)
        assert_equal(
          (+"\x81\x5c").force_encoding(Encoding::Shift_JIS),
          result.statement.elements.first.unescaped
        )
      end

      def test_slice_encoding
        slice = Prism.parse("# encoding: Shift_JIS\nã‚¢").value.slice
        assert_equal (+"ã‚¢").force_encoding(Encoding::SHIFT_JIS), slice
        assert_equal Encoding::SHIFT_JIS, slice.encoding
      end

      def test_multibyte_escapes
        [
          ["'", "'"],
          ["\"", "\""],
          ["`", "`"],
          ["/", "/"],
          ["<<'HERE'\n", "\nHERE"],
          ["<<-HERE\n", "\nHERE"]
        ].each do |opening, closing|
          assert Prism.parse_success?("# encoding: shift_jis\n'\\\x82\xA0'\n")
        end
      end
    end

    private

    def assert_encoding(encoding)
      escapes = ["\\x00", "\\x7F", "\\x80", "\\xFF", "\\u{00}", "\\u{7F}", "\\u{80}", "\\M-\\C-?"]
      escapes = escapes.concat(escapes.product(escapes).map(&:join))

      escapes.each do |escaped|
        source = "# encoding: #{encoding.name}\n\"#{escaped}\""

        expected =
          begin
            eval(source).encoding
          rescue SyntaxError => error
            if error.message.include?("UTF-8 mixed within")
              error.message[/UTF-8 mixed within .+? source/]
            else
              raise
            end
          end

        actual =
          Prism.parse(source).then do |result|
            if result.success?
              string = result.statement

              if string.forced_utf8_encoding?
                Encoding::UTF_8
              elsif string.forced_binary_encoding?
                Encoding::ASCII_8BIT
              else
                encoding
              end
            else
              error = result.errors.first

              if error.message.include?("mixed")
                error.message
              else
                raise error.message
              end
            end
          end

        assert_equal expected, actual
      end
    end
  end
end
prism-1.5.1/test/prism/encoding/symbol_encoding_test.rb000066400000000000000000000051601506127434000233120ustar00rootroot00000000000000# frozen_string_literal: true

return if RUBY_ENGINE != "ruby"

require_relative "../test_helper"

module Prism
  class SymbolEncodingTest < TestCase
    each_encoding do |encoding, _|
      define_method(:"test_symbols_#{encoding.name}") do
        assert_symbols(encoding)
      end

      define_method(:"test_escapes_#{encoding.name}") do
        assert_escapes(encoding)
      end
    end

    private

    def expected_encoding(source)
      eval(source).encoding
    end

    def actual_encoding(source, encoding)
      result = Prism.parse(source)

      if result.success?
        symbol = result.statement

        if symbol.forced_utf8_encoding?
          Encoding::UTF_8
        elsif symbol.forced_binary_encoding?
          Encoding::ASCII_8BIT
        elsif symbol.forced_us_ascii_encoding?
          Encoding::US_ASCII
        else
          encoding
        end
      else
        raise SyntaxError.new(result.errors.map(&:message).join("\n"))
      end
    end

    def assert_symbols(encoding)
      [:a, :Ä…, :+].each do |symbol|
        source = "# encoding: #{encoding.name}\n#{symbol.inspect}"

        expected =
          begin
            expected_encoding(source)
          rescue SyntaxError => error
            if error.message.include?("invalid multibyte")
              "invalid multibyte"
            else
              raise
            end
          end

        actual =
          begin
            actual_encoding(source, encoding)
          rescue SyntaxError => error
            if error.message.include?("invalid multibyte")
              "invalid multibyte"
            else
              raise
            end
          end

        assert_equal expected, actual
      end
    end

    def assert_escapes(encoding)
      escapes = ["\\x00", "\\x7F", "\\x80", "\\xFF", "\\u{00}", "\\u{7F}", "\\u{80}", "\\M-\\C-?"]
      escapes = escapes.concat(escapes.product(escapes).map(&:join))

      escapes.each do |escaped|
        source = "# encoding: #{encoding.name}\n:\"#{escaped}\""

        expected =
          begin
            expected_encoding(source)
          rescue SyntaxError => error
            if error.message.include?("UTF-8 mixed within")
              error.message[/UTF-8 mixed within .+? source/]
            else
              raise
            end
          end

        actual =
          begin
            actual_encoding(source, encoding)
          rescue SyntaxError => error
            if error.message.include?("mixed")
              error.message.split("\n", 2).first
            else
              raise
            end
          end

        assert_equal expected, actual
      end
    end
  end
end
prism-1.5.1/test/prism/errors/000077500000000000000000000000001506127434000162775ustar00rootroot00000000000000prism-1.5.1/test/prism/errors/1_2_3.txt000066400000000000000000000005451506127434000176470ustar00rootroot00000000000000(1, 2, 3)
  ^ unexpected ',', expecting end-of-input
  ^ unexpected ',', ignoring it
  ^ expected a matching `)`
  ^ unexpected ',', expecting end-of-input
  ^ unexpected ',', ignoring it
     ^ unexpected ',', expecting end-of-input
     ^ unexpected ',', ignoring it
        ^ unexpected ')', expecting end-of-input
        ^ unexpected ')', ignoring it

prism-1.5.1/test/prism/errors/aliasing_global_variable_with_global_number_variable.txt000066400000000000000000000001551506127434000316050ustar00rootroot00000000000000alias $a $1
         ^~ invalid argument being passed to `alias`; can't make alias for the number variables

prism-1.5.1/test/prism/errors/aliasing_global_variable_with_non_global_variable.txt000066400000000000000000000001741506127434000311100ustar00rootroot00000000000000alias $a b
         ^ invalid argument being passed to `alias`; expected a bare word, symbol, constant, or global variable

prism-1.5.1/test/prism/errors/aliasing_non_global_variable_with_global_variable.txt000066400000000000000000000001741506127434000311100ustar00rootroot00000000000000alias a $b
        ^~ invalid argument being passed to `alias`; expected a bare word, symbol, constant, or global variable

prism-1.5.1/test/prism/errors/alnum_delimiters.txt000066400000000000000000000000431506127434000223720ustar00rootroot00000000000000%qXfooX
^ unknown type of %string

prism-1.5.1/test/prism/errors/alnum_delimiters_2.txt000066400000000000000000000000431506127434000226130ustar00rootroot00000000000000%QXfooX
^ unknown type of %string

prism-1.5.1/test/prism/errors/alnum_delimiters_3.txt000066400000000000000000000000431506127434000226140ustar00rootroot00000000000000%wXfooX
^ unknown type of %string

prism-1.5.1/test/prism/errors/alnum_delimiters_4.txt000066400000000000000000000000431506127434000226150ustar00rootroot00000000000000%WxfooX
^ unknown type of %string

prism-1.5.1/test/prism/errors/alnum_delimiters_5.txt000066400000000000000000000000431506127434000226160ustar00rootroot00000000000000%iXfooX
^ unknown type of %string

prism-1.5.1/test/prism/errors/alnum_delimiters_6.txt000066400000000000000000000000431506127434000226170ustar00rootroot00000000000000%IXfooX
^ unknown type of %string

prism-1.5.1/test/prism/errors/alnum_delimiters_7.txt000066400000000000000000000000431506127434000226200ustar00rootroot00000000000000%xXfooX
^ unknown type of %string

prism-1.5.1/test/prism/errors/alnum_delimiters_8.txt000066400000000000000000000000431506127434000226210ustar00rootroot00000000000000%rXfooX
^ unknown type of %string

prism-1.5.1/test/prism/errors/alnum_delimiters_9.txt000066400000000000000000000000431506127434000226220ustar00rootroot00000000000000%sXfooX
^ unknown type of %string

prism-1.5.1/test/prism/errors/amperand_dot_after_endless_range.txt000066400000000000000000000001251506127434000255450ustar00rootroot000000000000000 if true...&.abs
            ^~ unexpected '&.'; ... is a non-associative operator

prism-1.5.1/test/prism/errors/argument_after_ellipsis.txt000066400000000000000000000001311506127434000237420ustar00rootroot00000000000000def foo(...); foo(..., 1); end
                       ^ unexpected argument after `...`

prism-1.5.1/test/prism/errors/argument_forwarding_only_effects_its_own_internals.txt000066400000000000000000000002351506127434000314650ustar00rootroot00000000000000def a(...); b(...); end; def c(x, y, z); b(...); end
                                           ^~~ unexpected ... when the parent method is not forwarding

prism-1.5.1/test/prism/errors/argument_forwarding_when_parent_is_not_forwarding.txt000066400000000000000000000001531506127434000312720ustar00rootroot00000000000000def a(x, y, z); b(...); end
                  ^~~ unexpected ... when the parent method is not forwarding

prism-1.5.1/test/prism/errors/arguments_after_block.txt000066400000000000000000000007471506127434000234100ustar00rootroot00000000000000a(&block, foo)
        ^ unexpected argument after a block argument
a(&block,)
        ^ unexpected argument after a block argument
a.(&block,)
         ^ unexpected argument after a block argument
a[&block,]
        ^ unexpected argument after a block argument
def a(&block)
  p(&block,)
          ^ unexpected argument after a block argument
  a.(&block,)
           ^ unexpected argument after a block argument
  a[&block,]
          ^ unexpected argument after a block argument
end

prism-1.5.1/test/prism/errors/arguments_binding_power_for_and.txt000066400000000000000000000002771506127434000254510ustar00rootroot00000000000000foo(*bar and baz)
         ^~~ unexpected 'and'; expected a `)` to close the arguments
                ^ unexpected ')', expecting end-of-input
                ^ unexpected ')', ignoring it

prism-1.5.1/test/prism/errors/arguments_invalid_comma.txt000066400000000000000000000000321506127434000237220ustar00rootroot00000000000000p(a,b
,)
^ invalid comma

prism-1.5.1/test/prism/errors/arguments_splat_after_star_star.txt000066400000000000000000000001651506127434000255150ustar00rootroot00000000000000def f(*, **); p(**, *); end
                    ^ unexpected `*` splat argument after a `**` keyword splat argument

prism-1.5.1/test/prism/errors/array_invalid_comma.txt000066400000000000000000000000271506127434000230370ustar00rootroot00000000000000[a
,]
^ invalid comma

prism-1.5.1/test/prism/errors/array_with_double_commas.txt000066400000000000000000000001021506127434000240730ustar00rootroot00000000000000[a:1,,]
     ^ unexpected ','; expected a `]` to close the array

prism-1.5.1/test/prism/errors/assign_to_numbered_parameter.txt000066400000000000000000000004461506127434000247530ustar00rootroot00000000000000a in _1
     ^~ _1 is reserved for numbered parameters
a => _1
     ^~ _1 is reserved for numbered parameters
1 => a, _1
        ^~ _1 is reserved for numbered parameters
1 in a, _1
        ^~ _1 is reserved for numbered parameters
/(?<_1>)/ =~ a
    ^~ _1 is reserved for numbered parameters

prism-1.5.1/test/prism/errors/bad_arguments.txt000066400000000000000000000005551506127434000216600ustar00rootroot00000000000000def foo(A, @a, $A, @@a);end
        ^ invalid formal argument; formal argument cannot be a constant
           ^~ invalid formal argument; formal argument cannot be an instance variable
               ^~ invalid formal argument; formal argument cannot be a global variable
                   ^~~ invalid formal argument; formal argument cannot be a class variable

prism-1.5.1/test/prism/errors/begin_at_toplevel.txt000066400000000000000000000001131506127434000225150ustar00rootroot00000000000000def foo; BEGIN {}; end
         ^~~~~ BEGIN is permitted only at toplevel

prism-1.5.1/test/prism/errors/binary_range_with_left_unary_range.txt000066400000000000000000000005011506127434000261330ustar00rootroot00000000000000..1..
   ^~ unexpected range operator; .. and ... are non-associative and cannot be chained
...1..
    ^~ unexpected range operator; .. and ... are non-associative and cannot be chained
    ^~ unexpected ..; .. is a non-associative operator
    ^~ unexpected .., expecting end-of-input
    ^~ unexpected .., ignoring it

prism-1.5.1/test/prism/errors/block_arg_and_block.txt000066400000000000000000000001321506127434000227530ustar00rootroot00000000000000foo(&1) { }
        ^~~ both block arg and actual block given; only one block is allowed

prism-1.5.1/test/prism/errors/block_args_in_array_assignment.txt000066400000000000000000000002171506127434000252620ustar00rootroot00000000000000matrix[5, &block] = 8
          ^~~~~~ unexpected block arg given in index assignment; blocks are not allowed in index assignment expressions

prism-1.5.1/test/prism/errors/block_beginning_with_brace_and_ending_with_end.txt000066400000000000000000000002711506127434000303700ustar00rootroot00000000000000x.each { x end
           ^~~ unexpected 'end', expecting end-of-input
           ^~~ unexpected 'end', ignoring it
              ^ expected a block beginning with `{` to end with `}`

prism-1.5.1/test/prism/errors/break_1.txt000066400000000000000000000001211506127434000203360ustar00rootroot00000000000000break 1,;
        ^ unexpected ';'; expected an argument
^~~~~~~~ Invalid break

prism-1.5.1/test/prism/errors/break_1_2_3.txt000066400000000000000000000004031506127434000210040ustar00rootroot00000000000000break(1, 2, 3)
       ^ unexpected ',', expecting end-of-input
       ^ unexpected ',', ignoring it
       ^ expected a matching `)`
             ^ unexpected ')', expecting end-of-input
             ^ unexpected ')', ignoring it
^~~~~~~~~~~~~ Invalid break

prism-1.5.1/test/prism/errors/call_with_block_and_write.txt000066400000000000000000000001461506127434000242150ustar00rootroot00000000000000foo {} &&= 1
^~~~~~ unexpected write target
       ^~~ unexpected operator after a call with a block

prism-1.5.1/test/prism/errors/call_with_block_operator_write.txt000066400000000000000000000001441506127434000253040ustar00rootroot00000000000000foo {} += 1
^~~~~~ unexpected write target
       ^~ unexpected operator after a call with a block

prism-1.5.1/test/prism/errors/call_with_block_or_write.txt000066400000000000000000000001461506127434000240730ustar00rootroot00000000000000foo {} ||= 1
^~~~~~ unexpected write target
       ^~~ unexpected operator after a call with a block

prism-1.5.1/test/prism/errors/cannot_assign_to_a_reserved_numbered_parameter.txt000066400000000000000000000010701506127434000305060ustar00rootroot00000000000000begin
  _1=:a;_2=:a;_3=:a;_4=:a;_5=:a
  ^~ _1 is reserved for numbered parameters
        ^~ _2 is reserved for numbered parameters
              ^~ _3 is reserved for numbered parameters
                    ^~ _4 is reserved for numbered parameters
                          ^~ _5 is reserved for numbered parameters
  _6=:a;_7=:a;_8=:a;_9=:a;_10=:a
  ^~ _6 is reserved for numbered parameters
        ^~ _7 is reserved for numbered parameters
              ^~ _8 is reserved for numbered parameters
                    ^~ _9 is reserved for numbered parameters
end

prism-1.5.1/test/prism/errors/case_without_clauses.txt000066400000000000000000000001001506127434000232440ustar00rootroot00000000000000case :a
^~~~ expected a `when` or `in` clause after `case`
end

prism-1.5.1/test/prism/errors/case_without_when_clauses_errors_on_else_clause.txt000066400000000000000000000001051506127434000307260ustar00rootroot00000000000000case :a
^~~~ expected a `when` or `in` clause after `case`
else
end

prism-1.5.1/test/prism/errors/check_value_expression.txt000066400000000000000000000011761506127434000235750ustar00rootroot000000000000001 => ^(return)
       ^~~~~~ unexpected void value expression
while true
  1 => ^(break)
         ^~~~~ unexpected void value expression
  1 => ^(next)
         ^~~~ unexpected void value expression
  1 => ^(redo)
         ^~~~ unexpected void value expression
  1 => ^(retry)
         ^~~~~ Invalid retry without rescue
         ^~~~~ unexpected void value expression
  1 => ^(2 => a)
         ^~~~~~ unexpected void value expression
end
1 => ^(if 1; (return) else (return) end)
              ^~~~~~ unexpected void value expression
1 => ^(unless 1; (return) else (return) end)
                  ^~~~~~ unexpected void value expression

prism-1.5.1/test/prism/errors/class_definition_in_method_body.txt000066400000000000000000000001221506127434000254130ustar00rootroot00000000000000def foo;class A;end;end
        ^~~~~ unexpected class definition in method body

prism-1.5.1/test/prism/errors/class_definition_in_method_defs.txt000066400000000000000000000004351506127434000254060ustar00rootroot00000000000000def foo(bar = class A;end);end
              ^~~~~ unexpected class definition in method body
def foo;rescue;class A;end;end
               ^~~~~ unexpected class definition in method body
def foo;ensure;class A;end;end
               ^~~~~ unexpected class definition in method body

prism-1.5.1/test/prism/errors/class_name.txt000066400000000000000000000001441506127434000211440ustar00rootroot00000000000000class 0.X end
      ^~~ unexpected constant path after `class`; class/module name must be CONSTANT

prism-1.5.1/test/prism/errors/command_call_in.txt000066400000000000000000000001621506127434000221360ustar00rootroot00000000000000foo 1 in a
      ^~ unexpected 'in', expecting end-of-input
      ^~ unexpected 'in', ignoring it
a = foo 2 in b

prism-1.5.1/test/prism/errors/command_calls.txt000066400000000000000000000001401506127434000216270ustar00rootroot00000000000000[a b]
  ^ unexpected local variable or method; expected a `,` separator for the array elements

prism-1.5.1/test/prism/errors/command_calls_10.txt000066400000000000000000000001071506127434000221320ustar00rootroot00000000000000+a b
   ^ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_11.txt000066400000000000000000000001151506127434000221320ustar00rootroot00000000000000a + b c
      ^ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_12.txt000066400000000000000000000001171506127434000221350ustar00rootroot00000000000000a && b c
       ^ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_13.txt000066400000000000000000000001171506127434000221360ustar00rootroot00000000000000a =~ b c
       ^ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_14.txt000066400000000000000000000001231506127434000221340ustar00rootroot00000000000000a = b, c d
         ^ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_15.txt000066400000000000000000000001171506127434000221400ustar00rootroot00000000000000a = *b c
       ^ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_16.txt000066400000000000000000000001331506127434000221370ustar00rootroot00000000000000a, b = c = d f
             ^ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_17.txt000066400000000000000000000002541506127434000221440ustar00rootroot00000000000000a ? b c : d e
     ^ expected a `:` after the true expression of a ternary operator
        ^ unexpected ':', expecting end-of-input
        ^ unexpected ':', ignoring it

prism-1.5.1/test/prism/errors/command_calls_18.txt000066400000000000000000000001271506127434000221440ustar00rootroot00000000000000defined? a b
           ^ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_19.txt000066400000000000000000000001151506127434000221420ustar00rootroot00000000000000! ! a b
      ^ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_2.txt000066400000000000000000000003231506127434000220530ustar00rootroot00000000000000{a: b c}
     ^ expected a `}` to close the hash literal
      ^ unexpected local variable or method, expecting end-of-input
       ^ unexpected '}', expecting end-of-input
       ^ unexpected '}', ignoring it

prism-1.5.1/test/prism/errors/command_calls_20.txt000066400000000000000000000001161506127434000221330ustar00rootroot00000000000000def f a = b c; end
           ^ expected a delimiter to close the parameters

prism-1.5.1/test/prism/errors/command_calls_21.txt000066400000000000000000000003201506127434000221310ustar00rootroot00000000000000def f(a = b c); end
            ^ unexpected local variable or method; expected a `)` to close the parameters
             ^ unexpected ')', expecting end-of-input
             ^ unexpected ')', ignoring it

prism-1.5.1/test/prism/errors/command_calls_22.txt000066400000000000000000000001371506127434000221400ustar00rootroot00000000000000a = b rescue c d
               ^ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_23.txt000066400000000000000000000001471506127434000221420ustar00rootroot00000000000000def a = b rescue c d
                   ^ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_24.txt000066400000000000000000000003551506127434000221440ustar00rootroot00000000000000->a=b c{}
     ^ expected a `do` keyword or a `{` to open the lambda block
         ^ unexpected end-of-input, assuming it is closing the parent top level context
         ^ expected a lambda block beginning with `do` to end with `end`

prism-1.5.1/test/prism/errors/command_calls_25.txt000066400000000000000000000005531506127434000221450ustar00rootroot00000000000000->(a=b c){}
      ^ expected a matching `)`
      ^ expected a `do` keyword or a `{` to open the lambda block
        ^ unexpected ')', expecting end-of-input
        ^ unexpected ')', ignoring it
           ^ unexpected end-of-input, assuming it is closing the parent top level context
           ^ expected a lambda block beginning with `do` to end with `end`

prism-1.5.1/test/prism/errors/command_calls_26.txt000066400000000000000000000001401506127434000221360ustar00rootroot00000000000000case; when a b; end
            ^ expected a delimiter after the predicates of a `when` clause

prism-1.5.1/test/prism/errors/command_calls_27.txt000066400000000000000000000001201506127434000221350ustar00rootroot00000000000000case; in a if a b; end
^~~~ expected a predicate for a case matching statement

prism-1.5.1/test/prism/errors/command_calls_28.txt000066400000000000000000000001241506127434000221420ustar00rootroot00000000000000case; in a unless a b; end
^~~~ expected a predicate for a case matching statement

prism-1.5.1/test/prism/errors/command_calls_29.txt000066400000000000000000000001361506127434000221460ustar00rootroot00000000000000begin; rescue a b; end
               ^ expected a closing delimiter for the `rescue` clause

prism-1.5.1/test/prism/errors/command_calls_3.txt000066400000000000000000000001131506127434000220510ustar00rootroot00000000000000...a b
     ^ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_30.txt000066400000000000000000000001431506127434000221340ustar00rootroot00000000000000begin; rescue a b => c; end
               ^ expected a closing delimiter for the `rescue` clause

prism-1.5.1/test/prism/errors/command_calls_31.txt000066400000000000000000000007201506127434000221360ustar00rootroot00000000000000true && not true
            ^~~~ expected a `(` after `not`
            ^~~~ unexpected 'true', expecting end-of-input

true || not true
            ^~~~ expected a `(` after `not`
            ^~~~ unexpected 'true', expecting end-of-input

true && not (true)
           ^ expected a `(` immediately after `not`
            ^ unexpected '(', expecting end-of-input

true && not
true
^~~~ expected a `(` after `not`
^~~~ unexpected 'true', expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_32.txt000066400000000000000000000011111506127434000221320ustar00rootroot00000000000000foo && return bar
              ^~~ unexpected local variable or method, expecting end-of-input

tap { foo && break bar }
                   ^~~ unexpected local variable or method, expecting end-of-input

tap { foo && next bar }
                  ^~~ unexpected local variable or method, expecting end-of-input

foo && return()
             ^ unexpected '(', expecting end-of-input

foo && return(bar)
             ^ unexpected '(', expecting end-of-input

foo && return(bar, baz)
             ^~~~~~~~~~ unexpected write target
             ^ unexpected '(', expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_4.txt000066400000000000000000000000711506127434000220550ustar00rootroot00000000000000if ...a b; end
        ^ expected `then` or `;` or '\n'

prism-1.5.1/test/prism/errors/command_calls_5.txt000066400000000000000000000001171506127434000220570ustar00rootroot00000000000000a b, c d
       ^ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/command_calls_6.txt000066400000000000000000000003731506127434000220640ustar00rootroot00000000000000a(b, c d)
       ^ unexpected local variable or method; expected a `)` to close the arguments
       ^ unexpected local variable or method, expecting end-of-input
        ^ unexpected ')', expecting end-of-input
        ^ unexpected ')', ignoring it

prism-1.5.1/test/prism/errors/command_calls_7.txt000066400000000000000000000003611506127434000220620ustar00rootroot00000000000000a(*b c)
     ^ unexpected local variable or method; expected a `)` to close the arguments
     ^ unexpected local variable or method, expecting end-of-input
      ^ unexpected ')', expecting end-of-input
      ^ unexpected ')', ignoring it

prism-1.5.1/test/prism/errors/command_calls_8.txt000066400000000000000000000003661506127434000220700ustar00rootroot00000000000000a(**b c)
      ^ unexpected local variable or method; expected a `)` to close the arguments
      ^ unexpected local variable or method, expecting end-of-input
       ^ unexpected ')', expecting end-of-input
       ^ unexpected ')', ignoring it

prism-1.5.1/test/prism/errors/command_calls_9.txt000066400000000000000000000003611506127434000220640ustar00rootroot00000000000000a(&b c)
     ^ unexpected local variable or method; expected a `)` to close the arguments
     ^ unexpected local variable or method, expecting end-of-input
      ^ unexpected ')', expecting end-of-input
      ^ unexpected ')', ignoring it

prism-1.5.1/test/prism/errors/conditional_predicate_closed.txt000066400000000000000000000002511506127434000247120ustar00rootroot00000000000000if 0 0; elsif 0 0; end
     ^ expected `then` or `;` or '\n'
                ^ expected `then` or `;` or '\n'
unless 0 0; end
         ^ expected `then` or `;` or '\n'

prism-1.5.1/test/prism/errors/constant_assignment_in_method.txt000066400000000000000000000000751506127434000251510ustar00rootroot00000000000000def foo();A=1;end
          ^~~ dynamic constant assignment

prism-1.5.1/test/prism/errors/constant_path_with_invalid_token_after.txt000066400000000000000000000001611506127434000270250ustar00rootroot00000000000000A::$b
   ^ expected a constant after the `::` operator
   ^~ unexpected global variable, expecting end-of-input

prism-1.5.1/test/prism/errors/content_after_unterminated_heredoc.txt000066400000000000000000000002361506127434000261440ustar00rootroot00000000000000<<~FOO.foo
   ^~~ unterminated heredoc; can't find string "FOO" anywhere before EOF
   ^~~ unterminated heredoc; can't find string "FOO" anywhere before EOF

prism-1.5.1/test/prism/errors/cr_without_lf_in_percent_expression.txt000066400000000000000000000000561506127434000263760ustar00rootroot00000000000000%
  ^ unterminated string meets end of file

prism-1.5.1/test/prism/errors/def_ivar.txt000066400000000000000000000001151506127434000206140ustar00rootroot00000000000000def @foo; end
    ^~~~ unexpected instance variable; expected a method name

prism-1.5.1/test/prism/errors/def_with_empty_expression_receiver.txt000066400000000000000000000001031506127434000262040ustar00rootroot00000000000000def ().a; end
    ^ expected a receiver for the method definition

prism-1.5.1/test/prism/errors/def_with_expression_receiver_and_no_identifier.txt000066400000000000000000000002101506127434000305050ustar00rootroot00000000000000def (a); end
       ^ expected a `.` or `::` after the receiver in a method definition
       ^ unexpected ';'; expected a method name

prism-1.5.1/test/prism/errors/def_with_multiple_statements_receiver.txt000066400000000000000000000003361506127434000267010ustar00rootroot00000000000000def (
a
b
^ expected a matching `)`
^ expected a `.` or `::` after the receiver in a method definition
 ^ expected a delimiter to close the parameters
).c; end
^ unexpected ')', ignoring it
 ^ unexpected '.', ignoring it

prism-1.5.1/test/prism/errors/defined_empty.txt000066400000000000000000000000761506127434000216570ustar00rootroot00000000000000defined?()
        ^ expected an expression after `defined?`

prism-1.5.1/test/prism/errors/defining_numbered_parameter.txt000066400000000000000000000000731506127434000245440ustar00rootroot00000000000000def _1; end
    ^~ _1 is reserved for numbered parameters

prism-1.5.1/test/prism/errors/defining_numbered_parameter_2.txt000066400000000000000000000001051506127434000247610ustar00rootroot00000000000000def self._1; end
         ^~ _1 is reserved for numbered parameters

prism-1.5.1/test/prism/errors/defs_endless_method.txt000066400000000000000000000007101506127434000230340ustar00rootroot00000000000000def f=(k,v)=1
    ^~ invalid method name; a setter method cannot be defined in an endless method definition

def obj.f=(k,v)=1
        ^~ invalid method name; a setter method cannot be defined in an endless method definition

def []=(k,v)=1
    ^~~ invalid method name; a setter method cannot be defined in an endless method definition

def obj.[]=(k,v)=1
        ^~~ invalid method name; a setter method cannot be defined in an endless method definition

do_not_allow_characters_other_than_0_9_a_f_and_A_F_in_u_Unicode_character_notation.txt000066400000000000000000000001321506127434000372610ustar00rootroot00000000000000prism-1.5.1/test/prism/errors"\u{000z}"
       ^ invalid Unicode escape sequence
       ^ unterminated Unicode escape

prism-1.5.1/test/prism/errors/do_not_allow_forward_arguments_in_blocks.txt000066400000000000000000000001131506127434000273470ustar00rootroot00000000000000a {|...|}
    ^~~ unexpected ... when the parent method is not forwarding

prism-1.5.1/test/prism/errors/do_not_allow_forward_arguments_in_lambda_literals.txt000066400000000000000000000001131506127434000312110ustar00rootroot00000000000000->(...) {}
   ^~~ unexpected ... when the parent method is not forwarding

do_not_allow_more_than_6_hexadecimal_digits_in_u_Unicode_character_notation.txt000066400000000000000000000001271506127434000362200ustar00rootroot00000000000000prism-1.5.1/test/prism/errors"\u{0000001}"
    ^~~~~~~ invalid Unicode escape sequence; maximum length is 6 digits

prism-1.5.1/test/prism/errors/do_not_allow_multiple_codepoints_in_a_single_character_literal.txt000066400000000000000000000001751506127434000337440ustar00rootroot00000000000000?\u{0001 0002}
         ^~~ invalid Unicode escape sequence; Multiple codepoints at single character literal are disallowed

prism-1.5.1/test/prism/errors/do_not_allow_trailing_commas_in_lambda_parameters.txt000066400000000000000000000000671506127434000311640ustar00rootroot00000000000000-> (a, b, ) {}
        ^ unexpected `,` in parameters

prism-1.5.1/test/prism/errors/do_not_allow_trailing_commas_in_method_parameters.txt000066400000000000000000000001011506127434000312110ustar00rootroot00000000000000def foo(a,b,c,);end
             ^ unexpected `,` in parameters

prism-1.5.1/test/prism/errors/dont_allow_return_inside_class_body.txt000066400000000000000000000001121506127434000263300ustar00rootroot00000000000000class A; return; end
         ^~~~~~ Invalid return in class/module body

prism-1.5.1/test/prism/errors/dont_allow_return_inside_module_body.txt000066400000000000000000000001141506127434000265120ustar00rootroot00000000000000module A; return; end
          ^~~~~~ Invalid return in class/module body

prism-1.5.1/test/prism/errors/dont_allow_return_inside_sclass_body.txt000066400000000000000000000001201506127434000265120ustar00rootroot00000000000000class << A; return; end
            ^~~~~~ Invalid return in class/module body

prism-1.5.1/test/prism/errors/dont_allow_setting_to_back_and_nth_reference.txt000066400000000000000000000001301506127434000301240ustar00rootroot00000000000000begin
$+ = nil
^~ Can't set variable $+
$1466 = nil
^~~~~ Can't set variable $1466
end

prism-1.5.1/test/prism/errors/double_arguments_forwarding.txt000066400000000000000000000001031506127434000246130ustar00rootroot00000000000000def foo(..., ...)
             ^~~ unexpected parameter order
end

prism-1.5.1/test/prism/errors/double_scope_numbered_parameters.txt000066400000000000000000000001331506127434000256040ustar00rootroot00000000000000-> { _1 + -> { _2 } }
               ^~ numbered parameter is already used in outer block

prism-1.5.1/test/prism/errors/double_scope_repeated_numbered_parameters.txt000066400000000000000000000001331506127434000274550ustar00rootroot00000000000000-> { _1 + -> { _1 } }
               ^~ numbered parameter is already used in outer block

prism-1.5.1/test/prism/errors/double_splat_followed_by_splat_argument.txt000066400000000000000000000001501506127434000272030ustar00rootroot00000000000000a(**kwargs, *args)
            ^~~~~ unexpected `*` splat argument after a `**` keyword splat argument

prism-1.5.1/test/prism/errors/double_splat_with_double_commas.txt000066400000000000000000000001021506127434000254320ustar00rootroot00000000000000[**a,,]
     ^ unexpected ','; expected a `]` to close the array

prism-1.5.1/test/prism/errors/duplicate_pattern_capture.txt000066400000000000000000000011611506127434000242710ustar00rootroot00000000000000case (); in [a, a]; end
                ^ duplicated variable name
case (); in [a, *a]; end
                 ^ duplicated variable name
case (); in {a: a, b: a}; end
                      ^ duplicated variable name
case (); in {a: a, **a}; end
                     ^ duplicated variable name
case (); in [a, {a:}]; end
                 ^ duplicated variable name
case (); in [a, {a: {a: {a: [a]}}}]; end
                             ^ duplicated variable name
case (); in a => a; end
                 ^ duplicated variable name
case (); in [A => a, {a: b => a}]; end
                              ^ duplicated variable name

prism-1.5.1/test/prism/errors/duplicate_pattern_hash_key.txt000066400000000000000000000001571506127434000244250ustar00rootroot00000000000000case (); in {a:, a:}; end
                 ^~ duplicated key name
                 ^ duplicated variable name

prism-1.5.1/test/prism/errors/duplicate_pattern_hash_key_2.txt000066400000000000000000000001061506127434000246400ustar00rootroot00000000000000case (); in {a:1, a:2}; end
                  ^~ duplicated key name

prism-1.5.1/test/prism/errors/duplicated_parameter_names.txt000066400000000000000000000000731506127434000244010ustar00rootroot00000000000000def foo(a,b,a);end
            ^ duplicated argument name

prism-1.5.1/test/prism/errors/duplicated_parameter_names_2.txt000066400000000000000000000000751506127434000246240ustar00rootroot00000000000000def foo(a,b,*a);end
             ^ duplicated argument name

prism-1.5.1/test/prism/errors/duplicated_parameter_names_3.txt000066400000000000000000000000771506127434000246270ustar00rootroot00000000000000def foo(a,b,**a);end
              ^ duplicated argument name

prism-1.5.1/test/prism/errors/duplicated_parameter_names_4.txt000066400000000000000000000000751506127434000246260ustar00rootroot00000000000000def foo(a,b,&a);end
             ^ duplicated argument name

prism-1.5.1/test/prism/errors/duplicated_parameter_names_5.txt000066400000000000000000000001041506127434000246200ustar00rootroot00000000000000def foo(a = 1,b,*c);end
                ^ unexpected parameter `*`

prism-1.5.1/test/prism/errors/dynamic_label_pattern.txt000066400000000000000000000001111506127434000233510ustar00rootroot00000000000000:a => 'a': | 1
           ^ expected a pattern expression after the key

prism-1.5.1/test/prism/errors/ellipsis_in_no_paren_call.txt000066400000000000000000000001461506127434000242270ustar00rootroot00000000000000def foo(...); foo 1, ...; end
                     ^~~ unexpected `...` in an non-parenthesized call

prism-1.5.1/test/prism/errors/endless_method_command_call.txt000066400000000000000000000001671506127434000245320ustar00rootroot00000000000000private :m, def hello = puts "Hello"
                             ^ unexpected string literal, expecting end-of-input

prism-1.5.1/test/prism/errors/escape_unicode_curly_whitespace.txt000066400000000000000000000001231506127434000254340ustar00rootroot00000000000000"\u{
    ^ invalid Unicode escape sequence
    ^ unterminated Unicode escape
61}"

prism-1.5.1/test/prism/errors/for_loop_delimiter.txt000066400000000000000000000001621506127434000227140ustar00rootroot00000000000000for a in b end
           ^~~ unexpected 'end'; expected a 'do', newline, or ';' after the 'for' loop collection

prism-1.5.1/test/prism/errors/for_loops_index_missing.txt000066400000000000000000000000661506127434000237640ustar00rootroot00000000000000for in 1..10
^~~ expected an index after `for`
i
end

prism-1.5.1/test/prism/errors/for_loops_only_end.txt000066400000000000000000000004001506127434000227230ustar00rootroot00000000000000for end
^~~ expected an index after `for`
   ^ expected an `in` after the index in a `for` statement
   ^ expected a collection after the `in` in a `for` statement
    ^~~ unexpected 'end'; expected a 'do', newline, or ';' after the 'for' loop collection

prism-1.5.1/test/prism/errors/forwarding_arg_after_keyword_rest.txt000066400000000000000000000000731506127434000260150ustar00rootroot00000000000000def f(**,...);end
         ^~~ unexpected parameter order

prism-1.5.1/test/prism/errors/forwarding_arg_and_block.txt000066400000000000000000000001721506127434000240270ustar00rootroot00000000000000def foo(...) = foo(...) { }
                        ^~~ both block arg and actual block given; only one block is allowed

prism-1.5.1/test/prism/errors/heredoc_unterminated.txt000066400000000000000000000006751506127434000232400ustar00rootroot00000000000000a=>{< 1 }
      ^ unexpected '.'; expected a value in the hash literal
      ^ expected a `}` to close the hash literal
                   ^ unexpected '}', expecting end-of-input
                   ^ unexpected '}', ignoring it

prism-1.5.1/test/prism/errors/interpolated_regular_expression_with_unknown_regexp_options.txt000066400000000000000000000000711506127434000334670ustar00rootroot00000000000000/#{foo}/AZaz
       ^~~~~ unknown regexp options - AZaz

prism-1.5.1/test/prism/errors/invalid_global_variable_write.txt000066400000000000000000000000711506127434000250630ustar00rootroot00000000000000$',
^~ Can't set variable $'
^~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_hex_escape.txt000066400000000000000000000000471506127434000226530ustar00rootroot00000000000000"\xx"
 ^~ invalid hex escape sequence

prism-1.5.1/test/prism/errors/invalid_multi_target.txt000066400000000000000000000000421506127434000232420ustar00rootroot00000000000000foo,
^~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_10.txt000066400000000000000000000000421506127434000235420ustar00rootroot00000000000000Foo,
^~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_11.txt000066400000000000000000000000461506127434000235470ustar00rootroot00000000000000::Foo,
^~~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_12.txt000066400000000000000000000000541506127434000235470ustar00rootroot00000000000000Foo::Foo,
^~~~~~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_13.txt000066400000000000000000000000541506127434000235500ustar00rootroot00000000000000Foo::foo,
^~~~~~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_14.txt000066400000000000000000000000541506127434000235510ustar00rootroot00000000000000foo[foo],
^~~~~~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_15.txt000066400000000000000000000000571506127434000235550ustar00rootroot00000000000000(foo, bar)
^~~~~~~~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_16.txt000066400000000000000000000000701506127434000235510ustar00rootroot00000000000000foo((foo, bar))
    ^~~~~~~~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_17.txt000066400000000000000000000000521506127434000235520ustar00rootroot00000000000000foo((*))
    ^~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_18.txt000066400000000000000000000001021506127434000235470ustar00rootroot00000000000000foo(((foo, bar), *))
    ^~~~~~~~~~~~~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_19.txt000066400000000000000000000000631506127434000235560ustar00rootroot00000000000000(foo, bar) + 1
^~~~~~~~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_2.txt000066400000000000000000000000641506127434000234670ustar00rootroot00000000000000foo = 1; foo,
         ^~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_20.txt000066400000000000000000000000661506127434000235510ustar00rootroot00000000000000(foo, bar) in baz
^~~~~~~~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_3.txt000066400000000000000000000000521506127434000234650ustar00rootroot00000000000000foo.bar,
^~~~~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_4.txt000066400000000000000000000000441506127434000234670ustar00rootroot00000000000000*foo,
^~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_5.txt000066400000000000000000000000441506127434000234700ustar00rootroot00000000000000@foo,
^~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_6.txt000066400000000000000000000000461506127434000234730ustar00rootroot00000000000000@@foo,
^~~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_7.txt000066400000000000000000000000441506127434000234720ustar00rootroot00000000000000$foo,
^~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_8.txt000066400000000000000000000000711506127434000234730ustar00rootroot00000000000000$1,
^~ Can't set variable $1
^~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_multi_target_9.txt000066400000000000000000000000711506127434000234740ustar00rootroot00000000000000$+,
^~ Can't set variable $+
^~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_number_underscores.txt000066400000000000000000000000611506127434000244470ustar00rootroot000000000000001__1
  ^ invalid underscore placement in number

prism-1.5.1/test/prism/errors/invalid_number_underscores_10.txt000066400000000000000000000000441506127434000247500ustar00rootroot0000000000000001_1_
    ^ trailing '_' in number

prism-1.5.1/test/prism/errors/invalid_number_underscores_11.txt000066400000000000000000000000461506127434000247530ustar00rootroot000000000000000d1_1_
     ^ trailing '_' in number

prism-1.5.1/test/prism/errors/invalid_number_underscores_12.txt000066400000000000000000000000461506127434000247540ustar00rootroot000000000000000x1_1_
     ^ trailing '_' in number

prism-1.5.1/test/prism/errors/invalid_number_underscores_2.txt000066400000000000000000000000651506127434000246740ustar00rootroot000000000000000b1__1
    ^ invalid underscore placement in number

prism-1.5.1/test/prism/errors/invalid_number_underscores_3.txt000066400000000000000000000000651506127434000246750ustar00rootroot000000000000000o1__1
    ^ invalid underscore placement in number

prism-1.5.1/test/prism/errors/invalid_number_underscores_4.txt000066400000000000000000000000631506127434000246740ustar00rootroot0000000000000001__1
   ^ invalid underscore placement in number

prism-1.5.1/test/prism/errors/invalid_number_underscores_5.txt000066400000000000000000000000651506127434000246770ustar00rootroot000000000000000d1__1
    ^ invalid underscore placement in number

prism-1.5.1/test/prism/errors/invalid_number_underscores_6.txt000066400000000000000000000000651506127434000247000ustar00rootroot000000000000000x1__1
    ^ invalid underscore placement in number

prism-1.5.1/test/prism/errors/invalid_number_underscores_7.txt000066400000000000000000000000421506127434000246740ustar00rootroot000000000000001_1_
   ^ trailing '_' in number

prism-1.5.1/test/prism/errors/invalid_number_underscores_8.txt000066400000000000000000000000461506127434000247010ustar00rootroot000000000000000b1_1_
     ^ trailing '_' in number

prism-1.5.1/test/prism/errors/invalid_number_underscores_9.txt000066400000000000000000000000461506127434000247020ustar00rootroot000000000000000o1_1_
     ^ trailing '_' in number

prism-1.5.1/test/prism/errors/invalid_operator_write_dot.txt000066400000000000000000000000511506127434000244550ustar00rootroot00000000000000foo.+= 1
     ^ unexpected write target

prism-1.5.1/test/prism/errors/invalid_operator_write_fcall.txt000066400000000000000000000000501506127434000247470ustar00rootroot00000000000000foo! += 1
^~~~ unexpected write target

prism-1.5.1/test/prism/errors/invalid_splat.txt000066400000000000000000000000431506127434000216660ustar00rootroot00000000000000(1
*a)
^~ unexpected write target

prism-1.5.1/test/prism/errors/it_with_ordinary_parameter.txt000066400000000000000000000001271506127434000244560ustar00rootroot00000000000000proc { || it }
          ^~ 'it' is not allowed when an ordinary parameter is defined

prism-1.5.1/test/prism/errors/keyword_args_in_array_assignment.txt000066400000000000000000000002271506127434000256550ustar00rootroot00000000000000matrix[5, axis: :y] = 8
          ^~~~~~~~ unexpected keyword arg given in index assignment; keywords are not allowed in index assignment expressions

prism-1.5.1/test/prism/errors/keywords_parameters_before_required_parameters.txt000066400000000000000000000000751506127434000306010ustar00rootroot00000000000000def foo(b:, a)
            ^ unexpected parameter order
end

prism-1.5.1/test/prism/errors/label_in_parentheses.txt000066400000000000000000000000371506127434000232060ustar00rootroot00000000000000("a":)
 ^~~~ unexpected label

prism-1.5.1/test/prism/errors/loop_conditional_is_closed.txt000066400000000000000000000003051506127434000244160ustar00rootroot00000000000000while 0 0; foo; end; until 0 0; foo; end
       ^ expected a predicate expression for the `while` statement
                            ^ expected a predicate expression for the `until` statement

prism-1.5.1/test/prism/errors/match_plus.txt000066400000000000000000000003011506127434000211710ustar00rootroot00000000000000a in b + c
       ^ unexpected '+', expecting end-of-input
       ^ unexpected '+', ignoring it
a => b + c
       ^ unexpected '+', expecting end-of-input
       ^ unexpected '+', ignoring it

prism-1.5.1/test/prism/errors/match_predicate_after_and_with_dot_method_call.txt000066400000000000000000000001131506127434000304060ustar00rootroot000000000000001 and 2 in 3.inspect
            ^ unexpected '.', expecting end-of-input

prism-1.5.1/test/prism/errors/match_predicate_after_and_with_opreator.txt000066400000000000000000000001101506127434000271150ustar00rootroot000000000000001 and 2 in 3 % 4
             ^ unexpected '%', expecting end-of-input

prism-1.5.1/test/prism/errors/match_predicate_after_or_with_dot_method_call.txt000066400000000000000000000001141506127434000302650ustar00rootroot00000000000000'a' or 1 in 1.upcase
             ^ unexpected '.', expecting end-of-input

prism-1.5.1/test/prism/errors/match_predicate_after_or_with_opreator.txt000066400000000000000000000001061506127434000270000ustar00rootroot000000000000001 or 2 in 3 + 4
            ^ unexpected '+', expecting end-of-input

prism-1.5.1/test/prism/errors/match_predicate_after_rescue_with_dot_method_call.txt000066400000000000000000000001241506127434000311340ustar00rootroot00000000000000'a' rescue 2 in 3.upcase
                 ^ unexpected '.', expecting end-of-input

prism-1.5.1/test/prism/errors/match_predicate_after_rescue_with_opreator.txt000066400000000000000000000001171506127434000276500ustar00rootroot000000000000001 rescue 2 in 3 << 4
                ^~ unexpected <<, expecting end-of-input

prism-1.5.1/test/prism/errors/match_required_after_and_with_dot_method_call.txt000066400000000000000000000001131506127434000302660ustar00rootroot000000000000001 and 2 => 3.inspect
            ^ unexpected '.', expecting end-of-input

prism-1.5.1/test/prism/errors/match_required_after_and_with_opreator.txt000066400000000000000000000001101506127434000267750ustar00rootroot000000000000001 and 2 => 3 - 4
             ^ unexpected '-', expecting end-of-input

prism-1.5.1/test/prism/errors/match_required_after_or_with_dot_method_call.txt000066400000000000000000000001111506127434000301420ustar00rootroot000000000000001 or 2 => 3.inspect
           ^ unexpected '.', expecting end-of-input

prism-1.5.1/test/prism/errors/match_required_after_or_with_opreator.txt000066400000000000000000000001061506127434000266600ustar00rootroot000000000000001 or 2 => 3 ^ 4
            ^ unexpected '^', expecting end-of-input

prism-1.5.1/test/prism/errors/match_required_after_rescue_with_dot_method_call.txt000066400000000000000000000001211506127434000310110ustar00rootroot000000000000001 rescue 2 => 3.inspect
               ^ unexpected '.', expecting end-of-input

prism-1.5.1/test/prism/errors/match_required_after_rescue_with_opreator.txt000066400000000000000000000001211506127434000275230ustar00rootroot000000000000001 rescue 2 => 3 ** 4
                ^~ unexpected '**', expecting end-of-input

prism-1.5.1/test/prism/errors/method_parameters_after_arguments_forwarding.txt000066400000000000000000000000771506127434000302370ustar00rootroot00000000000000def foo(..., a)
             ^ unexpected parameter order
end

prism-1.5.1/test/prism/errors/method_parameters_after_block.txt000066400000000000000000000001051506127434000250720ustar00rootroot00000000000000def foo(&block, a)
                ^ unexpected parameter order
end

prism-1.5.1/test/prism/errors/method_with_arguments_after_anonymous_block.txt000066400000000000000000000000731506127434000301030ustar00rootroot00000000000000def foo(&, a)
           ^ unexpected parameter order
end

prism-1.5.1/test/prism/errors/missing_terminator_in_parentheses.txt000066400000000000000000000000671506127434000260470ustar00rootroot00000000000000(0 0)
   ^ unexpected integer, expecting end-of-input

prism-1.5.1/test/prism/errors/module_definition_in_method_body.txt000066400000000000000000000001251506127434000255760ustar00rootroot00000000000000def foo;module A;end;end
        ^~~~~~ unexpected module definition in method body

prism-1.5.1/test/prism/errors/module_definition_in_method_body_within_block.txt000066400000000000000000000001461506127434000303350ustar00rootroot00000000000000def foo
  bar do
    module Foo;end
    ^~~~~~ unexpected module definition in method body
  end
end

prism-1.5.1/test/prism/errors/module_definition_in_method_defs.txt000066400000000000000000000004461506127434000255700ustar00rootroot00000000000000def foo(bar = module A;end);end
              ^~~~~~ unexpected module definition in method body
def foo;rescue;module A;end;end
               ^~~~~~ unexpected module definition in method body
def foo;ensure;module A;end;end
               ^~~~~~ unexpected module definition in method body

prism-1.5.1/test/prism/errors/module_name_recoverable.txt000066400000000000000000000003321506127434000236740ustar00rootroot00000000000000module Parent module end
              ^~~~~~ unexpected constant path after `module`; class/module name must be CONSTANT
                     ^~~ unexpected 'end', assuming it is closing the parent module definition

prism-1.5.1/test/prism/errors/multi_target_parens.txt000066400000000000000000000007051506127434000231120ustar00rootroot00000000000000( + ( * ) )
    ^~~~~ unexpected write target
( a ( * ) )
    ^~~~~ unexpected write target
( 1 + ( * ) )
      ^~~~~ unexpected write target
( .. ( * ) )
     ^~~~~ unexpected write target
( a = ( * ) )
      ^~~~~ unexpected write target
( * = ( * ) )
      ^~~~~ unexpected write target
( a if ( * ) )
       ^~~~~ unexpected write target
( 1; ( * ) )
     ^~~~~ unexpected write target
( def f() = ( * ) )
            ^~~~~ unexpected write target

prism-1.5.1/test/prism/errors/multi_target_star.txt000066400000000000000000000005341506127434000225730ustar00rootroot00000000000000[(*),]
 ^~~ unexpected write target
[1,(a,*b,(c,d)),1]
   ^~~~~~~~~~~~ unexpected write target
{a:(*),}
   ^~~ unexpected write target
[1+(*),]
   ^~~ unexpected write target
x=(*),1
  ^~~ unexpected write target
p((*),)
  ^~~ unexpected write target
p (*),1
  ^~~ unexpected write target
x = def f = (*),1
            ^~~ unexpected write target

prism-1.5.1/test/prism/errors/multiple_error_in_parameters_order.txt000066400000000000000000000001721506127434000262100ustar00rootroot00000000000000def foo(**args, a, b:)
                ^ unexpected parameter order
                   ^~ unexpected parameter order
end

prism-1.5.1/test/prism/errors/next_1.txt000066400000000000000000000001151506127434000202330ustar00rootroot00000000000000next 1,;
       ^ unexpected ';'; expected an argument
^~~~~~~ Invalid next

prism-1.5.1/test/prism/errors/next_1_2_3.txt000066400000000000000000000003731506127434000207040ustar00rootroot00000000000000next(1, 2, 3)
      ^ unexpected ',', expecting end-of-input
      ^ unexpected ',', ignoring it
      ^ expected a matching `)`
            ^ unexpected ')', expecting end-of-input
            ^ unexpected ')', ignoring it
^~~~~~~~~~~~ Invalid next

prism-1.5.1/test/prism/errors/non_assoc_equality.txt000066400000000000000000000017531506127434000227450ustar00rootroot000000000000001 == 2 == 3
       ^~ unexpected '=='; '==' is a non-associative operator
       ^~ unexpected '==', expecting end-of-input
       ^~ unexpected '==', ignoring it
1 != 2 != 3
       ^~ unexpected '!='; '!=' is a non-associative operator
       ^~ unexpected '!=', expecting end-of-input
       ^~ unexpected '!=', ignoring it
1 === 2 === 3
        ^~~ unexpected '==='; '===' is a non-associative operator
        ^~~ unexpected '===', expecting end-of-input
        ^~~ unexpected '===', ignoring it
1 =~ 2 =~ 3
       ^~ unexpected '=~'; '=~' is a non-associative operator
       ^~ unexpected '=~', expecting end-of-input
       ^~ unexpected '=~', ignoring it
1 !~ 2 !~ 3
       ^~ unexpected '!~'; '!~' is a non-associative operator
       ^~ unexpected '!~', expecting end-of-input
       ^~ unexpected '!~', ignoring it
1 <=> 2 <=> 3
        ^~~ unexpected '<=>'; '<=>' is a non-associative operator
        ^~~ unexpected '<=>', expecting end-of-input
        ^~~ unexpected '<=>', ignoring it

prism-1.5.1/test/prism/errors/non_assoc_range.txt000066400000000000000000000002171506127434000221760ustar00rootroot000000000000001....2
    ^ unexpected '.'; ... is a non-associative operator
    ^ unexpected '.', expecting end-of-input
    ^ unexpected '.', ignoring it

prism-1.5.1/test/prism/errors/numbered_and_write.txt000066400000000000000000000001021506127434000226660ustar00rootroot00000000000000tap { _1 &&= 1 }
      ^~ _1 is reserved for numbered parameters

prism-1.5.1/test/prism/errors/numbered_operator_write.txt000066400000000000000000000001011506127434000237560ustar00rootroot00000000000000tap { _1 += 1 }
      ^~ _1 is reserved for numbered parameters

prism-1.5.1/test/prism/errors/numbered_or_write.txt000066400000000000000000000001021506127434000225440ustar00rootroot00000000000000tap { _1 ||= 1 }
      ^~ _1 is reserved for numbered parameters

prism-1.5.1/test/prism/errors/numbered_parameters_in_block_arguments.txt000066400000000000000000000000771506127434000270150ustar00rootroot00000000000000foo { |_1| }
       ^~ _1 is reserved for numbered parameters

prism-1.5.1/test/prism/errors/optional_block_parameters_with_unary_operator.txt000066400000000000000000000001331506127434000304430ustar00rootroot00000000000000foo { |a = +b| }
           ^ unexpected '+'; unary calls are not allowed in this context

prism-1.5.1/test/prism/errors/optional_block_parameters_with_unary_operator_2.txt000066400000000000000000000001331506127434000306640ustar00rootroot00000000000000foo { |a = -b| }
           ^ unexpected '-'; unary calls are not allowed in this context

prism-1.5.1/test/prism/errors/optional_block_parameters_with_unary_operator_3.txt000066400000000000000000000001331506127434000306650ustar00rootroot00000000000000foo { |a = !b| }
           ^ unexpected '!'; unary calls are not allowed in this context

prism-1.5.1/test/prism/errors/optional_block_parameters_with_unary_operator_4.txt000066400000000000000000000001331506127434000306660ustar00rootroot00000000000000foo { |a = ~b| }
           ^ unexpected '~'; unary calls are not allowed in this context

prism-1.5.1/test/prism/errors/parameter_name_ending_with_bang_or_question_mark.txt000066400000000000000000000001561506127434000310310ustar00rootroot00000000000000def foo(x!,y?); end
        ^~ unexpected name for a parameter
           ^~ unexpected name for a parameter

prism-1.5.1/test/prism/errors/parameters_invalid_comma.txt000066400000000000000000000000411506127434000240600ustar00rootroot00000000000000def f(a
,b);end
^ invalid comma

prism-1.5.1/test/prism/errors/pattern_arithmetic_expressions.txt000066400000000000000000000001351506127434000253670ustar00rootroot00000000000000case 1; in -1**2; end
           ^~~~~ expected a pattern expression after the `in` keyword

prism-1.5.1/test/prism/errors/pattern_match_implicit_rest.txt000066400000000000000000000000741506127434000246210ustar00rootroot00000000000000a=>b, *,
        ^ expected a pattern expression after `,`

prism-1.5.1/test/prism/errors/pre_execution_context.txt000066400000000000000000000002451506127434000234560ustar00rootroot00000000000000BEGIN { 1 + }
            ^ unexpected '}'; expected an expression after the operator
            ^ unexpected '}', assuming it is closing the parent 'BEGIN' block

prism-1.5.1/test/prism/errors/pre_execution_missing_brace.txt000066400000000000000000000000571506127434000246000ustar00rootroot00000000000000BEGIN 1 }
     ^ expected a `{` after `BEGIN`

prism-1.5.1/test/prism/errors/range_and_bin_op.txt000066400000000000000000000002171506127434000223040ustar00rootroot000000000000001..2..3
    ^~ unexpected ..; .. is a non-associative operator
    ^~ unexpected .., expecting end-of-input
    ^~ unexpected .., ignoring it

prism-1.5.1/test/prism/errors/range_and_bin_op_2.txt000066400000000000000000000002161506127434000225240ustar00rootroot000000000000001..2..
    ^~ unexpected ..; .. is a non-associative operator
    ^~ unexpected .., expecting end-of-input
    ^~ unexpected .., ignoring it

prism-1.5.1/test/prism/errors/range_and_bin_op_3.txt000066400000000000000000000001131506127434000225210ustar00rootroot000000000000001.. || 2
     ^ unexpected '|'; expected an expression after the operator

prism-1.5.1/test/prism/errors/range_and_bin_op_4.txt000066400000000000000000000002171506127434000225270ustar00rootroot000000000000001.. & 2
    ^ unexpected '&'; .. is a non-associative operator
    ^ unexpected '&', expecting end-of-input
    ^ unexpected '&', ignoring it

prism-1.5.1/test/prism/errors/range_and_bin_op_5.txt000066400000000000000000000002511506127434000225260ustar00rootroot000000000000001.. * 2
    ^ unexpected *; .. is a non-associative operator
    ^ unexpected *, expecting end-of-input
      ^ unexpected write target
    ^~~ unexpected write target

prism-1.5.1/test/prism/errors/range_and_bin_op_6.txt000066400000000000000000000001231506127434000225250ustar00rootroot000000000000001.. / 2
    ^ unterminated regexp meets end of file; expected a closing delimiter

prism-1.5.1/test/prism/errors/range_and_bin_op_7.txt000066400000000000000000000000701506127434000225270ustar00rootroot000000000000001.. % 2
       ^ unterminated string meets end of file

prism-1.5.1/test/prism/errors/range_and_bin_op_8.txt000066400000000000000000000001311506127434000225260ustar00rootroot000000000000001.. ** 2
    ^~ unexpected **, expecting end-of-input
    ^~ unexpected **, ignoring it

prism-1.5.1/test/prism/errors/range_doubled.txt000066400000000000000000000001461506127434000216330ustar00rootroot00000000000000p(...1...)
      ^~~ unexpected range operator; .. and ... are non-associative and cannot be chained

prism-1.5.1/test/prism/errors/rational_number_with_exponential_portion.txt000066400000000000000000000002261506127434000274340ustar00rootroot000000000000001e1r; 1e1ri
   ^ unexpected local variable or method, expecting end-of-input
         ^~ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/regexp_unicode_too_short.txt000066400000000000000000000001551506127434000241410ustar00rootroot00000000000000/\u
 ^~ too short escape sequence: \u
^ unterminated regexp meets end of file; expected a closing delimiter

prism-1.5.1/test/prism/errors/regular_expression_with_unknown_regexp_options.txt000066400000000000000000000000631506127434000307160ustar00rootroot00000000000000/foo/AZaz
    ^~~~~ unknown regexp options - AZaz

prism-1.5.1/test/prism/errors/repeated_parameter_name_in_destructured_params.txt000066400000000000000000000001021506127434000305100ustar00rootroot00000000000000def f(a, (b, (a))); end
              ^ duplicated argument name

prism-1.5.1/test/prism/errors/rest_keywords_parameters_before_required_parameters.txt000066400000000000000000000001071506127434000316320ustar00rootroot00000000000000def foo(**rest, b:)
                ^~ unexpected parameter order
end

prism-1.5.1/test/prism/errors/return_1.txt000066400000000000000000000000741506127434000206000ustar00rootroot00000000000000return 1,;
         ^ unexpected ';'; expected an argument

prism-1.5.1/test/prism/errors/return_1_2_3.txt000066400000000000000000000003551506127434000212450ustar00rootroot00000000000000return(1, 2, 3)
        ^ unexpected ',', expecting end-of-input
        ^ unexpected ',', ignoring it
        ^ expected a matching `)`
              ^ unexpected ')', expecting end-of-input
              ^ unexpected ')', ignoring it

prism-1.5.1/test/prism/errors/returning_to_optional_parameters_multiple_times.txt000066400000000000000000000001301506127434000310150ustar00rootroot00000000000000def foo(a, b = 1, c, d = 2, e)
                       ^ unexpected parameter order
end

prism-1.5.1/test/prism/errors/semicolon_after_inheritance_operator.txt000066400000000000000000000001161506127434000264730ustar00rootroot00000000000000class Foo < Bar end
               ^ unexpected `end`, expecting ';' or '\n'

prism-1.5.1/test/prism/errors/setter_method_cannot_be_defined_in_an_endless_method_definition.txt000066400000000000000000000003341506127434000340250ustar00rootroot00000000000000def a=() = 42
    ^~ invalid method name; a setter method cannot be defined in an endless method definition

def []=() = 42
    ^~~ invalid method name; a setter method cannot be defined in an endless method definition

prism-1.5.1/test/prism/errors/shadow_args_in_block.txt000066400000000000000000000000561506127434000232020ustar00rootroot00000000000000tap{|a;a|}
       ^ duplicated argument name

prism-1.5.1/test/prism/errors/shadow_args_in_lambda.txt000066400000000000000000000003451506127434000233310ustar00rootroot00000000000000->a;b{}
   ^ expected a `do` keyword or a `{` to open the lambda block
       ^ unexpected end-of-input, assuming it is closing the parent top level context
       ^ expected a lambda block beginning with `do` to end with `end`

prism-1.5.1/test/prism/errors/singleton_class_delimiter.txt000066400000000000000000000002041506127434000242610ustar00rootroot00000000000000class < { _1, = 0 }
     ^~ _1 is reserved for numbered parameters

prism-1.5.1/test/prism/errors/top_level_constant_starting_with_downcased_identifier.txt000066400000000000000000000001741506127434000321430ustar00rootroot00000000000000::foo::A
  ^ expected a constant after the `::` operator
  ^~~ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/top_level_constant_with_downcased_identifier.txt000066400000000000000000000001711506127434000302250ustar00rootroot00000000000000::foo
  ^ expected a constant after the `::` operator
  ^~~ unexpected local variable or method, expecting end-of-input

prism-1.5.1/test/prism/errors/trailing_comma_after_block.txt000066400000000000000000000000541506127434000243570ustar00rootroot00000000000000p{|&,|}
    ^ unexpected `,` in parameters

prism-1.5.1/test/prism/errors/trailing_comma_in_calls.txt000066400000000000000000000000751506127434000236730ustar00rootroot00000000000000foo 1,
     ^ unexpected end-of-input; expected an argument

prism-1.5.1/test/prism/errors/unexpected_block.txt000066400000000000000000000001151506127434000223530ustar00rootroot00000000000000def foo = yield(&:+)
                ^~~ block argument should not be given

prism-1.5.1/test/prism/errors/unterminated_W_list.txt000066400000000000000000000001061506127434000230550ustar00rootroot00000000000000%w[
^~~ unterminated list; expected a closing delimiter for the `%w`

prism-1.5.1/test/prism/errors/unterminated_argument_expression.txt000066400000000000000000000003201506127434000257130ustar00rootroot00000000000000a %
  ^ unterminated quoted string meets end of file
   ^ unexpected end-of-input; expected an expression after the operator
   ^ unexpected end-of-input, assuming it is closing the parent top level context

prism-1.5.1/test/prism/errors/unterminated_block.txt000066400000000000000000000002261506127434000227110ustar00rootroot00000000000000foo {
     ^ unexpected end-of-input, assuming it is closing the parent top level context
     ^ expected a block beginning with `{` to end with `}`

prism-1.5.1/test/prism/errors/unterminated_embdoc.txt000066400000000000000000000000631506127434000230470ustar00rootroot00000000000000=begin
^~~~~~ embedded document meets end of file

prism-1.5.1/test/prism/errors/unterminated_embdoc_2.txt000066400000000000000000000000631506127434000232700ustar00rootroot00000000000000=begin
^~~~~~ embedded document meets end of file

prism-1.5.1/test/prism/errors/unterminated_empty_string.txt000066400000000000000000000000541506127434000243420ustar00rootroot00000000000000"
 ^ unterminated string meets end of file

prism-1.5.1/test/prism/errors/unterminated_global_variable.txt000066400000000000000000000001061506127434000247210ustar00rootroot00000000000000$
^ '$' without identifiers is not allowed as a global variable name

prism-1.5.1/test/prism/errors/unterminated_global_variable_2.txt000066400000000000000000000001071506127434000251430ustar00rootroot00000000000000$ 
^ '$' without identifiers is not allowed as a global variable name

prism-1.5.1/test/prism/errors/unterminated_i_list.txt000066400000000000000000000001061506127434000230770ustar00rootroot00000000000000%i[
^~~ unterminated list; expected a closing delimiter for the `%i`

prism-1.5.1/test/prism/errors/unterminated_interpolated_string.txt000066400000000000000000000000661506127434000257010ustar00rootroot00000000000000"hello
      ^ unterminated string meets end of file

prism-1.5.1/test/prism/errors/unterminated_interpolated_symbol.txt000066400000000000000000000001301506127434000256700ustar00rootroot00000000000000:"#
   ^ unterminated symbol; expected a closing delimiter for the interpolated symbol

prism-1.5.1/test/prism/errors/unterminated_method_parameters.txt000066400000000000000000000001131506127434000253150ustar00rootroot00000000000000foo(
    ^ unexpected end-of-input; expected a `)` to close the arguments

prism-1.5.1/test/prism/errors/unterminated_parenthesized_expression.txt000066400000000000000000000001751506127434000267460ustar00rootroot00000000000000(1 + 2
      ^ unexpected end-of-input, assuming it is closing the parent top level context
      ^ expected a matching `)`

prism-1.5.1/test/prism/errors/unterminated_regular_expression.txt000066400000000000000000000001161506127434000255350ustar00rootroot00000000000000/hello
^ unterminated regexp meets end of file; expected a closing delimiter

prism-1.5.1/test/prism/errors/unterminated_regular_expression_with_heredoc.txt000066400000000000000000000001401506127434000302560ustar00rootroot00000000000000<<-END + /b
         ^ unterminated regexp meets end of file; expected a closing delimiter
END

prism-1.5.1/test/prism/errors/unterminated_s_symbol.txt000066400000000000000000000001341506127434000234440ustar00rootroot00000000000000%s[abc
^~~ unterminated quoted string; expected a closing delimiter for the dynamic symbol

prism-1.5.1/test/prism/errors/unterminated_string.txt000066400000000000000000000000601506127434000231210ustar00rootroot00000000000000'hello
^ unterminated string meets end of file

prism-1.5.1/test/prism/errors/unterminated_unicode_brackets_should_be_a_syntax_error.txt000066400000000000000000000000501506127434000322610ustar00rootroot00000000000000?\u{3
 ^~~~ invalid Unicode list: \u{3

prism-1.5.1/test/prism/errors/unterminated_xstring.txt000066400000000000000000000001071506127434000233130ustar00rootroot00000000000000`hello
^ expected a closing delimiter for the `%x` or backtick string

prism-1.5.1/test/prism/errors/void_value_expression_in_arguments.txt000066400000000000000000000007461506127434000262360ustar00rootroot00000000000000foo(return)
    ^~~~~~ unexpected void value expression
foo(1, return)
       ^~~~~~ unexpected void value expression
foo(*return)
     ^~~~~~ unexpected void value expression
foo(**return)
      ^~~~~~ unexpected void value expression
foo(&return)
     ^~~~~~ unexpected void value expression
foo(return => 1)
    ^~~~~~ unexpected void value expression
foo(:a => return)
          ^~~~~~ unexpected void value expression
foo(a: return)
       ^~~~~~ unexpected void value expression

prism-1.5.1/test/prism/errors/void_value_expression_in_array.txt000066400000000000000000000006171506127434000253440ustar00rootroot00000000000000[return]
 ^~~~~~ unexpected void value expression
[1, return]
    ^~~~~~ unexpected void value expression
[ return => 1 ]
  ^~~~~~ unexpected void value expression
[ 1 => return ]
       ^~~~~~ unexpected void value expression
[ a: return ]
     ^~~~~~ unexpected void value expression
[ *return ]
   ^~~~~~ unexpected void value expression
[ **return ]
    ^~~~~~ unexpected void value expression

prism-1.5.1/test/prism/errors/void_value_expression_in_assignment.txt000066400000000000000000000003721506127434000263740ustar00rootroot00000000000000a = return
    ^~~~~~ unexpected void value expression
a = 1, return
       ^~~~~~ unexpected void value expression
a, b = return, 1
       ^~~~~~ unexpected void value expression
a, b = 1, *return
           ^~~~~~ unexpected void value expression

prism-1.5.1/test/prism/errors/void_value_expression_in_begin_statement.txt000066400000000000000000000013741506127434000273770ustar00rootroot00000000000000x = return 1
    ^~~~~~~~ unexpected void value expression
x = return, 1
    ^~~~~~ unexpected void value expression
x = 1, return
       ^~~~~~ unexpected void value expression
x, y = return
       ^~~~~~ unexpected void value expression
x = begin return ensure end
          ^~~~~~ unexpected void value expression
x = begin ensure return end
                 ^~~~~~ unexpected void value expression
x = begin return ensure return end
          ^~~~~~ unexpected void value expression
x = begin return; rescue; return end
          ^~~~~~ unexpected void value expression
x = begin return; rescue; return; else return end
          ^~~~~~ unexpected void value expression
x = begin; return; rescue; retry; end
           ^~~~~~ unexpected void value expression

prism-1.5.1/test/prism/errors/void_value_expression_in_binary_call.txt000066400000000000000000000003751506127434000265060ustar00rootroot000000000000001 + (return)
     ^~~~~~ unexpected void value expression
(return) + 1
 ^~~~~~ unexpected void value expression
1 and (return)
(return) and 1
 ^~~~~~ unexpected void value expression
1 or (return)
(return) or 1
 ^~~~~~ unexpected void value expression

prism-1.5.1/test/prism/errors/void_value_expression_in_call.txt000066400000000000000000000004221506127434000251330ustar00rootroot00000000000000(return).foo
 ^~~~~~ unexpected void value expression
(return).(1)
 ^~~~~~ unexpected void value expression
(return)[1]
 ^~~~~~ unexpected void value expression
(return)[1] = 2
 ^~~~~~ unexpected void value expression
(return)::foo
 ^~~~~~ unexpected void value expression

prism-1.5.1/test/prism/errors/void_value_expression_in_constant_path.txt000066400000000000000000000001741506127434000270710ustar00rootroot00000000000000(return)::A
 ^~~~~~ unexpected void value expression
class (return)::A; end
       ^~~~~~ unexpected void value expression

prism-1.5.1/test/prism/errors/void_value_expression_in_def.txt000066400000000000000000000003171506127434000247610ustar00rootroot00000000000000def (return).x
     ^~~~~~ unexpected void value expression
end
def x(a = return)
          ^~~~~~ unexpected void value expression
end
def x(a: return)
         ^~~~~~ unexpected void value expression
end

prism-1.5.1/test/prism/errors/void_value_expression_in_expression.txt000066400000000000000000000007731506127434000264300ustar00rootroot00000000000000(return) ? 1 : 1
 ^~~~~~ unexpected void value expression
(return)..1
 ^~~~~~ unexpected void value expression
1..(return)
    ^~~~~~ unexpected void value expression
(return)...1
 ^~~~~~ unexpected void value expression
1...(return)
     ^~~~~~ unexpected void value expression
(..(return))
    ^~~~~~ unexpected void value expression
(...(return))
     ^~~~~~ unexpected void value expression
((return)..)
  ^~~~~~ unexpected void value expression
((return)...)
  ^~~~~~ unexpected void value expression

prism-1.5.1/test/prism/errors/void_value_expression_in_hash.txt000066400000000000000000000003561506127434000251510ustar00rootroot00000000000000{ return => 1 }
  ^~~~~~ unexpected void value expression
{ 1 => return }
       ^~~~~~ unexpected void value expression
{ a: return }
     ^~~~~~ unexpected void value expression
{ **return }
    ^~~~~~ unexpected void value expression

prism-1.5.1/test/prism/errors/void_value_expression_in_modifier.txt000066400000000000000000000005631506127434000260240ustar00rootroot000000000000001 if (return)
      ^~~~~~ unexpected void value expression
1 unless (return)
          ^~~~~~ unexpected void value expression
1 while (return)
         ^~~~~~ unexpected void value expression
1 until (return)
         ^~~~~~ unexpected void value expression
(return) => a
 ^~~~~~ unexpected void value expression
(return) in a
 ^~~~~~ unexpected void value expression

prism-1.5.1/test/prism/errors/void_value_expression_in_statement.txt000066400000000000000000000010461506127434000262270ustar00rootroot00000000000000if (return)
    ^~~~~~ unexpected void value expression
end
unless (return)
        ^~~~~~ unexpected void value expression
end
while (return)
       ^~~~~~ unexpected void value expression
end
until (return)
       ^~~~~~ unexpected void value expression
end
case (return)
      ^~~~~~ unexpected void value expression
when 1
end
class A < (return)
           ^~~~~~ unexpected void value expression
end
class << (return)
          ^~~~~~ unexpected void value expression
end
for x in (return)
          ^~~~~~ unexpected void value expression
end

prism-1.5.1/test/prism/errors/void_value_expression_in_unary_call.txt000066400000000000000000000001541506127434000263530ustar00rootroot00000000000000+(return)
  ^~~~~~ unexpected void value expression
not return
    ^~~~~~ unexpected void value expression

prism-1.5.1/test/prism/errors/while_endless_method.txt000066400000000000000000000004301506127434000232220ustar00rootroot00000000000000while def f = g do end
                      ^ expected a predicate expression for the `while` statement
                      ^ unexpected end-of-input, assuming it is closing the parent top level context
                      ^ expected an `end` to close the `while` statement

prism-1.5.1/test/prism/errors/writing_numbered_parameter.txt000066400000000000000000000000761506127434000244470ustar00rootroot00000000000000-> { _1 = 0 }
     ^~ _1 is reserved for numbered parameters

prism-1.5.1/test/prism/errors/xstring_concat.txt000066400000000000000000000001101506127434000220550ustar00rootroot00000000000000<<`EOC` "bar"
^~~~~~~ expected a string for concatenation
echo foo
EOC

prism-1.5.1/test/prism/errors_test.rb000066400000000000000000000067701506127434000176750ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "test_helper"

module Prism
  class ErrorsTest < TestCase
    base = File.expand_path("errors", __dir__)
    filepaths = Dir["*.txt", base: base]

    if RUBY_VERSION < "3.0"
      filepaths -= [
        "cannot_assign_to_a_reserved_numbered_parameter.txt",
        "writing_numbered_parameter.txt",
        "targeting_numbered_parameter.txt",
        "defining_numbered_parameter.txt",
        "defining_numbered_parameter_2.txt",
        "numbered_parameters_in_block_arguments.txt",
        "numbered_and_write.txt",
        "numbered_or_write.txt",
        "numbered_operator_write.txt"
      ]
    end

    if RUBY_VERSION < "3.4"
      filepaths -= [
        "it_with_ordinary_parameter.txt",
        "block_args_in_array_assignment.txt",
        "keyword_args_in_array_assignment.txt"
      ]
    end

    if RUBY_VERSION < "3.4" || RUBY_RELEASE_DATE < "2024-07-24"
      filepaths -= ["dont_allow_return_inside_sclass_body.txt"]
    end

    filepaths.each do |filepath|
      define_method(:"test_#{File.basename(filepath, ".txt")}") do
        assert_errors(File.join(base, filepath))
      end
    end

    def test_newline_preceding_eof
      err = Prism.parse("foo(").errors.first
      assert_equal 1, err.location.start_line

      err = Prism.parse("foo(\n").errors.first
      assert_equal 1, err.location.start_line

      err = Prism.parse("foo(\n\n\n\n\n").errors.first
      assert_equal 5, err.location.start_line
    end

    def test_embdoc_ending
      source = <<~RUBY
        =begin\n=end
        =begin\n=end\0
        =begin\n=end\C-d
        =begin\n=end\C-z
      RUBY

      source.each_line do |line|
        assert_valid_syntax(source)
        assert_predicate Prism.parse(source), :success?
      end
    end

    def test_unterminated_string_closing
      statement = Prism.parse_statement("'hello")
      assert_equal statement.unescaped, "hello"
      assert_empty statement.closing
    end

    def test_unterminated_interpolated_string_closing
      statement = Prism.parse_statement('"hello')
      assert_equal statement.unescaped, "hello"
      assert_empty statement.closing
    end

    def test_unterminated_empty_string_closing
      statement = Prism.parse_statement('"')
      assert_empty statement.unescaped
      assert_empty statement.closing
    end

    def test_invalid_message_name
      assert_equal :"", Prism.parse_statement("+.@foo,+=foo").write_name
    end

    def test_circular_parameters
      source = <<~RUBY
        def foo(bar = bar) = 42
        def foo(bar: bar) = 42
        proc { |foo = foo| }
        proc { |foo: foo| }
      RUBY

      source.each_line do |line|
        assert_predicate Prism.parse(line, version: "3.3.0"), :failure?
        assert_predicate Prism.parse(line), :success?
      end
    end

    def test_private_endless_method
      source = <<~RUBY
        private def foo = puts "Hello"
      RUBY

      assert_predicate Prism.parse(source, version: "3.4"), :failure?
      assert_predicate Prism.parse(source), :success?
    end

    private

    def assert_errors(filepath)
      expected = File.read(filepath, binmode: true, external_encoding: Encoding::UTF_8)

      source = expected.lines.grep_v(/^\s*\^/).join.gsub(/\n*\z/, "")
      refute_valid_syntax(source)

      result = Prism.parse(source)
      errors = result.errors
      refute_empty errors, "Expected errors in #{filepath}"

      actual = result.errors_format
      assert_equal expected, actual, "Expected errors to match for #{filepath}"
    end
  end
end
prism-1.5.1/test/prism/fixtures/000077500000000000000000000000001506127434000166345ustar00rootroot00000000000000prism-1.5.1/test/prism/fixtures/alias.txt000066400000000000000000000003101506127434000204600ustar00rootroot00000000000000alias :foo :bar

alias %s[abc] %s[def]

alias :'abc' :'def'

alias :"abc#{1}" :'def'

alias $a $'

alias foo bar

alias $foo $bar

alias foo if

alias foo <=>

alias :== :eql?

alias A B

alias :A :B
prism-1.5.1/test/prism/fixtures/arithmetic.txt000066400000000000000000000001141506127434000215220ustar00rootroot00000000000000foo !bar

-foo*bar

+foo**bar

foo ~bar

foo << bar << baz

-1**2

-1.zero?
prism-1.5.1/test/prism/fixtures/arrays.txt000066400000000000000000000016351506127434000207030ustar00rootroot00000000000000[*a]

foo[bar, baz] = 1, 2, 3

[a: [:b, :c]]



[:a, :b,
:c,1,



:d,
]


[:a, :b,
:c,1,



:d


]

[foo => bar]

foo[bar][baz] = qux

foo[bar][baz]

[
]

foo[bar, baz]

foo[bar, baz] = qux

foo[0], bar[0] = 1, 2

foo[bar[baz] = qux]

foo[bar]

foo[bar] = baz

[**{}]

[**kw]

[1, **kw]

[1, **kw, **{}, **kw]

[
  foo => bar,
]


%i#one two three#

%w#one two three#

%x#one two three#


%i@one two three@

%w@one two three@

%x@one two three@


%i{one two three}

%w{one two three}

%x{one two three}

%w[\C:]

foo[] += 1

foo[] ||= 1

foo[] &&= 1

foo.foo[] += 1

foo.foo[] ||= 1

foo.foo[] &&= 1

foo[bar] += 1

foo[bar] ||= 1

foo[bar] &&= 1

foo.foo[bar] += 1

foo.foo[bar] ||= 1

foo.foo[bar] &&= 1

def f(*); a[*]; end

def f(*); a[1, *]; end

def f(*); a[*] = 1; end

def f(*); a[1, *] = 1; end

def f(*); a[*] += 1; end

def f(*); a[1, *] &&= 1; end

def f(*); rescue => a[*]; end

def f(*); rescue => a[1, *]; end
prism-1.5.1/test/prism/fixtures/begin_ensure.txt000066400000000000000000000003241506127434000220410ustar00rootroot00000000000000begin
a
ensure
b
end

begin; a; ensure; b; end

begin a
 ensure b
 end

begin a; ensure b; end

begin begin:s.l begin ensure Module.new do
  begin
    break
    ensure Module.new do
    end
  end
end end end end
prism-1.5.1/test/prism/fixtures/begin_rescue.txt000066400000000000000000000012231506127434000220250ustar00rootroot00000000000000begin; a; rescue; b; else; c; end

begin; a; rescue; b; else; c; ensure; d; end

begin; rescue ; end

begin; rescue ; ensure ; end

begin; rescue ; else ; end

begin
a
end

begin; a; end

begin a
 end

begin a; end

begin
a
rescue
b
rescue
c
rescue
d
end

begin
  a
rescue Exception => ex
  b
rescue AnotherException, OneMoreException => ex
  c
end

begin
  a
rescue Exception => ex
  b
ensure
  b
end

%!abc!

begin
a
rescue
b
end

begin;a;rescue;b;end

begin
a;rescue
b;end

begin
a
rescue Exception
b
end

begin
a
rescue Exception, CustomException
b
end

begin
  a
rescue Exception, CustomException => ex
  b
end

begin
  a
rescue Exception => ex
  b
end

prism-1.5.1/test/prism/fixtures/blocks.txt000066400000000000000000000006231506127434000206530ustar00rootroot00000000000000foo[bar] { baz }

foo[bar] do
baz
end

x.reduce(0) { |x, memo| memo += x }

foo do end

foo bar, (baz do end)

foo bar do end

foo bar baz do end

foo do |a = b[1]|
end

foo do
rescue
end

foo do
  bar do
    baz do
    end
  end
end

foo[bar] { baz }

foo { |x, y = 2, z:| x }

foo { |x| }

fork = 1
fork do |a|
end

fork { |a| }

C do
end

C {}

foo lambda { |
  a: 1,
  b: 2
  |
}

foo do |bar,| end
prism-1.5.1/test/prism/fixtures/boolean_operators.txt000066400000000000000000000000311506127434000231040ustar00rootroot00000000000000a &&= b

a += b

a ||= b
prism-1.5.1/test/prism/fixtures/booleans.txt000066400000000000000000000000141506127434000211720ustar00rootroot00000000000000false

true
prism-1.5.1/test/prism/fixtures/break.txt000066400000000000000000000005141506127434000204610ustar00rootroot00000000000000tap { break }

tap { break (1), (2), (3) }

tap { break 1 }

tap { break 1, 2,
3 }

tap { break 1, 2, 3 }

tap { break [1, 2, 3] }

tap { break(
  1
  2
) }

tap { break() }

tap { break(1) }

tap { (break 1) }

tap { foo && (break 1) }

foo { break 42 } == 42

foo { |a| break } == 42

while _ && break; end

until _ && break; end
prism-1.5.1/test/prism/fixtures/case.txt000066400000000000000000000007231506127434000203120ustar00rootroot00000000000000case :hi
when :hi
end

case true; when true; puts :hi; when false; puts :bye; end

case; when *foo; end

case :hi
when :hi
else
:b
end

case this; when FooBar, BazBonk; end

case
when foo == bar
end

case
when a
else
  # empty
end

case type;
  ;when :b;
  ;  else;
   end

case ;;;;;;;; when 1; end

case 1 in 2
when 3
end

case 1 in 2; when 3; end

case 1 in 2
in 3
end

case 1 in 2; in 3; end

case a
in b if c and d
  e
end

1.then do
  case 1
  in ^_1
  end
end
prism-1.5.1/test/prism/fixtures/case_in_hash_key.txt000066400000000000000000000000731506127434000226510ustar00rootroot00000000000000case 1
in 2
  A.print message:
in 3
  A.print message:
end
prism-1.5.1/test/prism/fixtures/classes.txt000066400000000000000000000005631506127434000210360ustar00rootroot00000000000000class A a = 1 end

class A; ensure; end

class A; rescue; else; ensure; end

class A < B
a = 1
end

class << not foo
end

class A; class << self; ensure; end; end

class A; class << self; rescue; else; ensure; end; end

class << foo.bar
end

class << foo.bar;end

class << self
end

class << self;end

class << self
1 + 2
end

class << self;1 + 2;end

class A < B[1]
end
prism-1.5.1/test/prism/fixtures/command_method_call.txt000066400000000000000000000005031506127434000233440ustar00rootroot00000000000000foo 1

foo bar 1

foo 1 if bar 2

foo 1 unless bar 2

foo 1 while bar 2

foo 1 until bar 2

foo 1 rescue bar 2

foo[bar 1]

foo 1 and bar 2

foo 1 or bar 2

not foo 1

foo = bar = baz 1

def foo = bar 1

1.foo 2

1.foo.bar 2

1.foo[2].bar 3

1.foo(2).bar 3

1.foo(&2).bar 3

!foo 1 and !bar 2

!foo 1 or !bar 2

not !foo 1
prism-1.5.1/test/prism/fixtures/comment_single.txt000066400000000000000000000000111506127434000223700ustar00rootroot00000000000000foo # Barprism-1.5.1/test/prism/fixtures/comments.txt000066400000000000000000000001671506127434000212260ustar00rootroot00000000000000a
 # Comment
b

c # Comment
d

e
# Comment
  .f

g
 # Comment
.h

i # Comment
.j

k # Comment
  .l

m
 # Comment
  &.n
prism-1.5.1/test/prism/fixtures/constants.txt000066400000000000000000000014311506127434000214100ustar00rootroot00000000000000A::B

A::B::C

a::B

A::B = 1

A = 1

ABC

Foo 1

Foo *bar

Foo **bar

Foo &bar

Foo::Bar *baz

Foo::Bar **baz

Foo::Bar &baz

::A::foo

::A = 1

::A::B = 1

::A::B

::A

A::false

A::B::true

A::&

A::`

A::!

A::!=

A::^

A::==

A::===

A::=~

A::>

A::>=

A::>>

A::<<

A::\
#
C

A::alias

A::and

A::begin

A::BEGIN

A::break

A::class

A::def

A::defined

A::do

A::else

A::elsif

A::end

A::END

A::ensure

A::false

A::for

A::if

A::in

A::next

A::nil

A::not

A::or

A::redo

A::rescue

A::retry

A::return

A::self

A::super

A::then

A::true

A::undef

A::unless

A::until

A::when

A::while

A::yield

A::__ENCODING__

A::__FILE__

A::__LINE__

A::<

A::<=>

A::<<

A::-

A::%

A::%i

A::%w

A::%x

A::%I

A::%W

A::|

A::+

A::/

A::*

A::**

A::~

A::_::
C

A::_..

A::__END__
prism-1.5.1/test/prism/fixtures/dash_heredocs.txt000066400000000000000000000004551506127434000221740ustar00rootroot00000000000000<<-EOF
  a
EOF

<<-FIRST + <<-SECOND
  a
FIRST
  b
SECOND

<<-`EOF`
  a
#{b}
EOF

<<-EOF #comment
  a
EOF

<<-EOF
  a
  b
  EOF

<<-"EOF"
  a
#{b}
EOF

<<-EOF
  a
#{b}
EOF

%#abc#

<<-EOF
  a
  b
EOF

<<-''


<<-'EOF'
  a #{1}
EOF

<<-A + <<-B
  a
A
  b
  #{2
  }
B

<<-A + <<-B
  a
A
  b
  #{
  2}
B
prism-1.5.1/test/prism/fixtures/defined.txt000066400000000000000000000002101506127434000207640ustar00rootroot00000000000000defined? 1 and defined? 2

defined?(x %= 2)

defined?(foo and bar)

defined? 1

defined?("foo"
)

defined?
1

defined?
(1)

defined?
()
prism-1.5.1/test/prism/fixtures/dos_endings.txt000066400000000000000000000002001506127434000216610ustar00rootroot00000000000000puts "hi"\
     "there"

%I{a\
b}

<<-E
    1 \
    2
    3
E

x = %



a = foo(<<~EOF.chop)

    baz
  EOF
prism-1.5.1/test/prism/fixtures/dstring.txt000066400000000000000000000002511506127434000210450ustar00rootroot00000000000000"foo
  bar"

"foo
  #{bar}"

"fo
o" "ba
r"

"
foo\
"

"
foo\\
"

"
foo\\\
"

"
foo\\\\
"

"
foo\\\\\
"

"
foo\
b\nar
#{}
"

"foo
\n#{}bar\n\n#{}
a\nb\n#{}\nc\n"

"
’"
prism-1.5.1/test/prism/fixtures/dsym_str.txt000066400000000000000000000000261506127434000212370ustar00rootroot00000000000000:"foo
  bar"

:"
’"
prism-1.5.1/test/prism/fixtures/embdoc_no_newline_at_end.txt000066400000000000000000000000131506127434000243470ustar00rootroot00000000000000=begin
=endprism-1.5.1/test/prism/fixtures/emoji_method_calls.txt000066400000000000000000000000151506127434000232120ustar00rootroot00000000000000foo.🌊 = 1
prism-1.5.1/test/prism/fixtures/encoding_binary.txt000066400000000000000000000000731506127434000225270ustar00rootroot00000000000000# encoding: binary

"\xcd"

:"\xcd"

/#{"\xcd"}/

%W[\xC0]
prism-1.5.1/test/prism/fixtures/encoding_euc_jp.txt000066400000000000000000000002031506127434000225030ustar00rootroot00000000000000# encoding: euc-jp

# \x8E indicates a double-byte character, \x01 is not a valid second byte in euc-jp
"\x8E\x01"

%W["\x8E\x01"]
prism-1.5.1/test/prism/fixtures/endless_methods.txt000066400000000000000000000001051506127434000225510ustar00rootroot00000000000000def foo = 1

def bar = A ""

def method = 1 + 2 + 3

x = def f = p 1
prism-1.5.1/test/prism/fixtures/endless_methods_command_call.txt000066400000000000000000000004271506127434000252510ustar00rootroot00000000000000private def foo = puts "Hello"
private def foo = puts "Hello", "World"
private def foo = puts "Hello" do expr end
private def foo() = puts "Hello"
private def foo(x) = puts x
private def obj.foo = puts "Hello"
private def obj.foo() = puts "Hello"
private def obj.foo(x) = puts x
prism-1.5.1/test/prism/fixtures/endless_range_in_conditional.txt000066400000000000000000000000501506127434000252520ustar00rootroot00000000000000if 1..2 ; end
if ..1 ; end
if 1.. ; end
prism-1.5.1/test/prism/fixtures/for.txt000066400000000000000000000002201506127434000201550ustar00rootroot00000000000000for i in 1..10
i
end

for i in 1..10; i; end

for i,j in 1..10
i
end

for i,j,k in 1..10
i
end

for i in 1..10 do
i
end

for i in 1..10; i; end
prism-1.5.1/test/prism/fixtures/global_variables.txt000066400000000000000000000005361506127434000226710ustar00rootroot00000000000000$global_variable

$_

$-w

$LOAD_PATH

$stdin

$stdout

$stderr

$!

$?

$~

$&

$`

$'

$+

$:

$;

$,

$DEBUG

$FILENAME

$0

$-0

$LOADED_FEATURES

$VERBOSE

$-K

:$global_variable

:$_

:$-w

:$LOAD_PATH

:$stdin

:$stdout

:$stderr

:$!

:$?

:$~

:$&

:$`

:$'

:$+

:$:

:$;

:$DEBUG

:$FILENAME

:$0

:$-0

:$LOADED_FEATURES

:$VERBOSE

:$-K
prism-1.5.1/test/prism/fixtures/hashes.txt000066400000000000000000000002631506127434000206510ustar00rootroot00000000000000{}

{
}

{ a => b, c => d }

{ a => b, **c }

{
      a: b,
      c: d



    }

{ a: b, c: d, **e, f: g }

{ "a": !b? }

a = 1
tap do
  b = 1
  { a:, b:, c:, D: }
end

{ a: -1 }
prism-1.5.1/test/prism/fixtures/heredoc.txt000066400000000000000000000000141506127434000210010ustar00rootroot00000000000000< 2

1 == 2

1 === 2

1 =~ 2

1 > 2

1 >= 2

1 >> 2

1 ^ 2

1 | 2

1 && 2

1 and 2

1 * 2 ** 3

1 * 2 + 3

1 or 2

1 || 2

1 + 2 * 3

(1 + 1)
prism-1.5.1/test/prism/fixtures/it.txt000066400000000000000000000000311506127434000200030ustar00rootroot00000000000000x do
  it
end

-> { it }
prism-1.5.1/test/prism/fixtures/it_assignment.txt000066400000000000000000000000311506127434000222330ustar00rootroot0000000000000042.tap { it = it; p it }
prism-1.5.1/test/prism/fixtures/it_indirect_writes.txt000066400000000000000000000004031506127434000232640ustar00rootroot00000000000000tap { it += 1 }

tap { it ||= 1 }

tap { it &&= 1 }

tap { it; it += 1 }

tap { it; it ||= 1 }

tap { it; it &&= 1 }

tap { it += 1; it }

tap { it ||= 1; it }

tap { it &&= 1; it }

tap { it; it += 1; it }

tap { it; it ||= 1; it }

tap { it; it &&= 1; it }
prism-1.5.1/test/prism/fixtures/it_read_and_assignment.txt000066400000000000000000000000371506127434000240560ustar00rootroot0000000000000042.tap { p it; it = it; p it }
prism-1.5.1/test/prism/fixtures/keyword_method_names.txt000066400000000000000000000001721506127434000236040ustar00rootroot00000000000000def def
end

def self.ensure
end

private def foo
  bar do
  end
end

def m(a, **nil)
end

%{abc}

%"abc"

def nil::a
end
prism-1.5.1/test/prism/fixtures/keywords.txt000066400000000000000000000001201506127434000212350ustar00rootroot00000000000000tap { redo }

begin; rescue; retry; end

self

__ENCODING__

__FILE__

__LINE__
prism-1.5.1/test/prism/fixtures/lambda.txt000066400000000000000000000002611506127434000206140ustar00rootroot00000000000000->(
  foo
) {}

->(x: "b#{a}") { }

->(a: b * 3) {}

-> foo = bar do end

-> foo: bar do end

def foo(*, **)
  ->() { bar(*, **) }
end

p{|a:
b|}

->(a:
b){}

->a:
b{}

->a:
{}
prism-1.5.1/test/prism/fixtures/leading_logical.txt000066400000000000000000000001101506127434000224620ustar00rootroot000000000000001
&& 2
&& 3

1
|| 2
|| 3

1
and 2
and 3

1
or 2
or 3

1
andfoo

2
orfoo
prism-1.5.1/test/prism/fixtures/method_calls.txt000066400000000000000000000024411506127434000220340ustar00rootroot00000000000000foo.bar %{baz}

a.b(c, d)

a.b()

foo
  .bar
  &.baz

a!

a.()

a.(1, 2, 3)

a::b

a::b c

foo.bar = 1

a?

a(&block)

a(**kwargs)

a.b.c

a(b, c)

a()

a(*args)

a b, c

a.b c, d

foo.foo, bar.bar = 1, 2

a&.b

a&.()

a&.b(c)

a&.b()

foo :a, :b if bar? or baz and qux

foo(:a,

	 :b
)

foo(*rest)

foo(:a, :h => [:x, :y], :a => :b, &:bar)

hi 123, { :there => :friend, **{}, whatup: :dog }

foo :a, b: true do |a, b| puts a end

hi there: :friend

hi :there => :friend, **{}, whatup: :dog

hi(:there => :friend, **{}, whatup: :dog)

foo({ a: true, b: false, }, &:block)

hi :there => :friend

foo(:a,
:b,
)

foo(
:a,
b: :c,
)

foo &:block

foo a: true, b: false, &:block

some_func 1, kwarg: 2

Kernel.Integer(10)

x.each { }

foo.map { $& }

A::B::C :foo

A::B::C(:foo)

A::B::C(:foo) { }

foo("a": -1)

foo bar: { baz: qux do end }

foo bar: { **kw do end }

foo "#{bar.map do "baz" end}" do end

foo class Bar baz do end end

foo module Bar baz do end end

foo [baz do end]

p begin 1.times do 1 end end

foo :a,
  if x
    bar do |a|
      a
    end
  end

foo :a,
  while x
    bar do |a|
      a
    end
  end,
  until x
    baz do
    end
  end

{} + A {}

{} + A { |a| a }

A {} + A {}

lst << A {}

"#{ join (" ") }"

"#{(v)}"

def f(*); p *; end

foo 1, Bar { 1 }

foo = 1
foo {}

@a.b "c#{name}": 42
prism-1.5.1/test/prism/fixtures/methods.txt000066400000000000000000000027311506127434000210430ustar00rootroot00000000000000def foo((bar, baz))
end

def foo((bar, baz), optional = 1, (bin, bag))
end


def a; ensure; end

def (b).a
end

def (a)::b
end

def false.a
end

def a(...)
end

def $var.a
end

def a.b
end

def @var.a
end

def a b:; end

%,abc,

def a(b:)
end

def a(**b)
end

def a(**)
end

a = 1; def a
end

def a b, c, d
end

def nil.a
end

def a b:, c: 1
end

def a(b:, c: 1)
end

def a(b:
  1, c:)
end

%.abc.

def a b = 1, c = 2
end

def a()
end

def a b, c = 2
end

def a b
end

def a; rescue; else; ensure; end

def a *b
end

def a(*)
end

def a
b = 1
end

def self.a
end

def true.a
end

def a
end

def hi
return :hi if true
:bye
end

def foo = 1
def bar = 2

def foo(bar) = 123

def foo = 123

def a(*); b(*); end

def a(*, **); b { c(*, **) }; end

def a(...); b(...); end

def a(...); b(1, 2, ...); end

def (c = b).a
end

def a &b
end

def a(&)
end

def @@var.a
end

def (a = b).C
end

def self.Array_function; end

Const = 1; def Const.a
end

def a(...); "foo#{b(...)}"; end

def foo
  {}.merge **bar, **baz, **qux
end

def bar(a: (1...10))
end

def bar(a: (...10))
end

def bar(a: (1...))
end

def bar(a = (1...10))
end

def bar(a = (...10))
end

def bar(a = (1...))
end

def method(a)
  item >> a {}
end

foo = 1
def foo.bar; end

def f(*); [*]; end

def f x:-a; end

def f x:+a; end

def f x:!a; end

def foo x:%(xx); end

def foo(...)
  bar(...)
end

def foo(bar = (def baz(bar) = bar; 1)) = 2

def (class Foo; end).foo(bar = 1) = 2

module Foo
  def clone(opts = nil || (return self))
  end
end
prism-1.5.1/test/prism/fixtures/modules.txt000066400000000000000000000002151506127434000210430ustar00rootroot00000000000000module A a = 1 end

%Q{aaa #{bbb} ccc}

module m::M
end

module A
 x = 1; rescue; end

module ::A
end

module A[]::B
end

module A[1]::B
end
prism-1.5.1/test/prism/fixtures/multi_write.txt000066400000000000000000000001341506127434000217370ustar00rootroot00000000000000foo = 1 rescue nil
foo, bar = 1 rescue nil
foo = 1, 2 rescue nil
foo, bar = 1, 2 rescue nil
prism-1.5.1/test/prism/fixtures/newline_terminated.txt000066400000000000000000000003241506127434000232510ustar00rootroot00000000000000# note that %i, %I, %w, and %W do not support newline termination in CRuby

% abc  
%	abc	 
%abc 
%
abc
 
%
abc
 
%abc 
%
abc
 
%

abc

 
%

abc
 
%
abc
 
%
abc
 
%
abc
 
%
abc

%
foo

%q
foo

%Q
foo

%r
foo
prism-1.5.1/test/prism/fixtures/next.txt000066400000000000000000000003621506127434000203540ustar00rootroot00000000000000tap { next }

tap { next (1), (2), (3) }

tap { next 1 }

tap { next 1, 2,
3 }

tap { next 1, 2, 3 }

tap { next [1, 2, 3] }

tap { next(
  1
  2
) }

tap { next
1 }

tap { next() }

tap { next(1) }

tap { (next 1) }

tap { foo && (next 1) }
prism-1.5.1/test/prism/fixtures/nils.txt000066400000000000000000000000521506127434000203370ustar00rootroot00000000000000nil

()

(
;
;
)

END { 1 }

BEGIN { 1 }

prism-1.5.1/test/prism/fixtures/non_alphanumeric_methods.txt000066400000000000000000000006631506127434000244470ustar00rootroot00000000000000def !
end

def !=
end

def !~
end

def %
end

def self.+
end

def &
end

def *
end

def **
end

%|abc|

def + **b
end

def +()
end

def + b
end

def self.+
end

def +
end

def +@
end

def -
end

def a.-;end

def -@
end

def /
end

def <
end

def <<
end

def <=
end

def <=>
end

def ==
end

def ===
end

def =~
end

def >
end

def >=
end

def >>
end

def []
end

def []=
end

def ^
end

def `
end

def self.`
end

def |
end

def ~
end
prism-1.5.1/test/prism/fixtures/not.txt000066400000000000000000000002771506127434000202030ustar00rootroot00000000000000not foo and not bar

not(foo and bar)

not foo

not foo and not
  bar


not foo and
    not
  bar


not foo and
  not


  bar

not(foo


)

not(


foo


  )

not foo .. bar

not (foo .. bar)
prism-1.5.1/test/prism/fixtures/numbers.txt000066400000000000000000000002571506127434000210540ustar00rootroot000000000000000

1

1.0

2

0b0

0b1

0b10

0d0

0d1

0d2

00

01

02

0o0

0o1

0o2

0x0

0x1

0x2

1i

1r

-1

1ri

1.2r

1.2ri

-1ri

-1.2r

-1.2ri

0o1r

0o1i

0o1ri

0d1r

0d1i

0b1ri
prism-1.5.1/test/prism/fixtures/patterns.txt000066400000000000000000000100351506127434000212340ustar00rootroot00000000000000foo => bar
foo => 1
foo => 1.0
foo => 1i
foo => 1r
foo => :foo
foo => %s[foo]
foo => :"foo"
foo => /foo/
foo => `foo`
foo => %x[foo]
foo => %i[foo]
foo => %I[foo]
foo => %w[foo]
foo => %W[foo]
foo => %q[foo]
foo => %Q[foo]
foo => "foo"
foo => nil
foo => self
foo => true
foo => false
foo => __FILE__
foo => __LINE__
foo => __ENCODING__
foo => -> { bar }

foo => 1 .. 1
foo => 1.0 .. 1.0
foo => 1i .. 1i
foo => 1r .. 1r
foo => :foo .. :foo
foo => %s[foo] .. %s[foo]
foo => :"foo" .. :"foo"
foo => /foo/ .. /foo/
foo => `foo` .. `foo`
foo => %x[foo] .. %x[foo]
foo => %i[foo] .. %i[foo]
foo => %I[foo] .. %I[foo]
foo => %w[foo] .. %w[foo]
foo => %W[foo] .. %W[foo]
foo => %q[foo] .. %q[foo]
foo => %Q[foo] .. %Q[foo]
foo => "foo" .. "foo"
foo => nil .. nil
foo => self .. self
foo => true .. true
foo => false .. false
foo => __FILE__ .. __FILE__
foo => __LINE__ .. __LINE__
foo => __ENCODING__ .. __ENCODING__
foo => -> { bar } .. -> { bar }

bar = 1; foo => ^bar
foo => ^@bar
foo => ^@@bar
foo => ^$bar

foo => ^(1)
foo => ^(nil)
foo => ^("bar" + "baz")

foo => Foo
foo => Foo::Bar::Baz
foo => ::Foo
foo => ::Foo::Bar::Baz

foo => Foo()
foo => Foo(1)
foo => Foo(1, 2, 3)
foo => Foo(bar)
foo => Foo(*bar, baz)
foo => Foo(bar, *baz)
foo => Foo(*bar, baz, *qux)

foo => Foo[]
foo => Foo[1]
foo => Foo[1, 2, 3]
foo => Foo[Foo[]]
foo => Foo[bar]
foo => Foo[*bar, baz]
foo => Foo[bar, *baz]
foo => Foo[*bar, baz, *qux]

foo => *bar
foo => *bar, baz, qux
foo => bar, *baz, qux
foo => bar, baz, *qux
foo => *bar, baz, *qux
foo => bar,;

foo => []
foo => [[[[[]]]]]

foo => [*bar]
foo => [*bar, baz, qux]
foo => [bar, *baz, qux]
foo => [bar, baz, *qux]
foo => [*bar, baz, *qux]

foo in bar
foo in 1
foo in 1.0
foo in 1i
foo in 1r
foo in :foo
foo in %s[foo]
foo in :"foo"
foo in /foo/
foo in `foo`
foo in %x[foo]
foo in %i[foo]
foo in %I[foo]
foo in %w[foo]
foo in %W[foo]
foo in %q[foo]
foo in %Q[foo]
foo in "foo"
foo in nil
foo in self
foo in true
foo in false
foo in __FILE__
foo in __LINE__
foo in __ENCODING__
foo in -> { bar }
foo in bar,;

case foo; in bar then end
case foo; in 1 then end
case foo; in 1.0 then end
case foo; in 1i then end
case foo; in 1r then end
case foo; in :foo then end
case foo; in %s[foo] then end
case foo; in :"foo" then end
case foo; in /foo/ then end
case foo; in `foo` then end
case foo; in %x[foo] then end
case foo; in %i[foo] then end
case foo; in %I[foo] then end
case foo; in %w[foo] then end
case foo; in %W[foo] then end
case foo; in %q[foo] then end
case foo; in %Q[foo] then end
case foo; in "foo" then end
case foo; in nil then end
case foo; in self then end
case foo; in true then end
case foo; in false then end
case foo; in __FILE__ then end
case foo; in __LINE__ then end
case foo; in __ENCODING__ then end
case foo; in -> { bar } then end

case foo; in bar if baz then end
case foo; in 1 if baz then end
case foo; in 1.0 if baz then end
case foo; in 1i if baz then end
case foo; in 1r if baz then end
case foo; in :foo if baz then end
case foo; in %s[foo] if baz then end
case foo; in :"foo" if baz then end
case foo; in /foo/ if baz then end
case foo; in `foo` if baz then end
case foo; in %x[foo] if baz then end
case foo; in %i[foo] if baz then end
case foo; in %I[foo] if baz then end
case foo; in %w[foo] if baz then end
case foo; in %W[foo] if baz then end
case foo; in %q[foo] if baz then end
case foo; in %Q[foo] if baz then end
case foo; in "foo" if baz then end
case foo; in nil if baz then end
case foo; in self if baz then end
case foo; in true if baz then end
case foo; in false if baz then end
case foo; in __FILE__ if baz then end
case foo; in __LINE__ if baz then end
case foo; in __ENCODING__ if baz then end
case foo; in -> { bar } if baz then end

if a in []
end

a => [
  b
]

foo in A[
  bar: B[
    value: a
  ]
]

foo in bar => baz
foo => bar => baz

foo, bar, baz = 1, 2
foo do
  [1, 2] => [foo, bar] => baz
end

foo => Object[{x:}]

1.then { 1 in ^_1 }

(
  a,
  b
) = c

case (); in [_a, _a]; end
case (); in [{a:1}, {a:2}]; end
a => ^({'a' => 'b'})

a in b, and c
a in b, or c
(a in b,) and c
(a in b,) or c

x => ^([*a.x])
x => ^([**a.x])
x => ^({ a: })
prism-1.5.1/test/prism/fixtures/procs.txt000066400000000000000000000004131506127434000205210ustar00rootroot00000000000000-> (a; b, c, d) { b }

-> do
ensure
end

-> do
rescue
else
ensure
end

-> { foo }

-> do; foo; end

-> a, b = 1, c:, d:, &e { a }

-> (a, b = 1, *c, d:, e:, **f, &g) { a }

-> (a, b = 1, *c, d:, e:, **f, &g) do
  a
end

-> (a) { -> b { a * b } }

-> ((a, b), *c) { }
prism-1.5.1/test/prism/fixtures/range_begin_open_exclusive.txt000066400000000000000000000000051506127434000247400ustar00rootroot00000000000000...2
prism-1.5.1/test/prism/fixtures/range_begin_open_inclusive.txt000066400000000000000000000000041506127434000247310ustar00rootroot00000000000000..2
prism-1.5.1/test/prism/fixtures/range_beginless.txt000066400000000000000000000001001506127434000225130ustar00rootroot00000000000000def f(x = ...?a); end

def f(x: ...?a); end

def f() ...:a; end
prism-1.5.1/test/prism/fixtures/range_end_open_exclusive.txt000066400000000000000000000000051506127434000244220ustar00rootroot000000000000002...
prism-1.5.1/test/prism/fixtures/range_end_open_inclusive.txt000066400000000000000000000000041506127434000244130ustar00rootroot000000000000002..
prism-1.5.1/test/prism/fixtures/ranges.txt000066400000000000000000000004021506127434000206500ustar00rootroot00000000000000(...2)

(..2)

foo ((1..1))

1...2

foo[...2]

{ foo: ...bar }

(1...)

1..2

{ foo: ..bar }

(1..)

1 .. ..1

1.. && 2

1.. == 2

1.. != 2

1.. === 2

1.. <=> 2

1.. =~ 2

1.. !~ 2

1.. < 2

1.. > 2

1.. <= 2

1.. >= 2

1.. << 2

1.. >> 2

1.. + 2

1.. - 2
prism-1.5.1/test/prism/fixtures/regex.txt000066400000000000000000000010101506127434000204770ustar00rootroot00000000000000foo /bar/

%r{abc}i

/a\b/

/aaa #$bbb/

/aaa #{bbb} ccc/

[/(?bar)/ =~ baz, foo]

/abc/i

%r/[a-z$._?][\w$.?#@~]*:/i

%r/([a-z$._?][\w$.?#@~]*)(\s+)(equ)/i

%r/[a-z$._?][\w$.?#@~]*/i

%r(
(?:[#$%_']|\(\)|\(,\)|\[\]|[0-9])*
  (?:[#$%_']+)
)

/(?#\))/ =~ "hi"

%r#pound#

/aaa #{bbb}/o

/(?)/ =~ ""; ab

/(?)(?)/ =~ ""; abc

/(?)/ =~ ""

a = 1
tap { /(?)/ =~ to_s }

/(?)/ =~ ""
/(?)/ =~ ""

/(?)/ =~ ""
def foo(nil:) = /(?)/ =~ ""

/(?-x:#)/x

/a
b\
c\
d\\\
e\\
f\
/

//
prism-1.5.1/test/prism/fixtures/regex_char_width.txt000066400000000000000000000000751506127434000227050ustar00rootroot00000000000000# encoding: sjis
/â…§(?.)â…©(?.)/ =~ 'â…§aâ…©b'
[a, b]
prism-1.5.1/test/prism/fixtures/regex_escape_encoding.txt000066400000000000000000000000761506127434000237000ustar00rootroot00000000000000# encoding: US-ASCII
str = "hello \xFC"
str =~ /hello \u{fc}/
prism-1.5.1/test/prism/fixtures/regex_with_fake_newlines.txt000066400000000000000000000004161506127434000244350ustar00rootroot00000000000000/
  \n
  \n
  exit
  \\n
  \n\n\n\n
  argh
  \\
  \\\
  foo\nbar
  \f
  ok
/

%r{
  \n
  \n
  exit
  \\n
  \n\n\n\n
  argh
  \\
  \\\
  foo\nbar
  \f
  ok
}

%r{
  #{123}\n
  \n
  exit\\\
  \\#{123}n
  \n#{123}\n\n\n
  argh\
  \\#{123}baz\\
  \\\
  foo\nbar
  \f
  ok
}
prism-1.5.1/test/prism/fixtures/repeat_parameters.txt000066400000000000000000000005361506127434000231040ustar00rootroot00000000000000def foo(a, _)
end

def foo(a, _, _)
end

def foo(a, _, _, _b)
end

def foo(a, _, _, _b, _b)
end

def foo(a, (b, *_c, d), (e, *_c, f))
end

def foo(_a, _a, b, c)
end

def foo((a, *_b, c), (d, *_b, e))
end

def foo(_a = 1, _a = 2)
end

def foo(_a:, _a:)
end

def foo(_a: 1, _a: 2)
end

def foo(_a, **_a)
end

def foo(_a, &_a)
end

def foo(_a, *_a)
end
prism-1.5.1/test/prism/fixtures/rescue.txt000066400000000000000000000006211506127434000206620ustar00rootroot00000000000000foo rescue nil

foo rescue
nil

tap { break rescue nil }

tap { next rescue nil }

return rescue nil

foo rescue nil || 1

foo rescue nil ? 1 : 2

begin; a; rescue *b; end

foo do |x|
  bar(y) rescue ArgumentError fail "baz"
end

if a = foo rescue nil
  bar
end

def some_method = other_method 42 rescue nil

def a
  a b:
rescue
end

foo if bar rescue baz

z = x y rescue c d

begin
rescue => A[]
end
prism-1.5.1/test/prism/fixtures/rescue_modifier.txt000066400000000000000000000001241506127434000225360ustar00rootroot00000000000000a rescue b if c

a = b rescue c if d

a, = b rescue c if d

def a = b rescue c if d
prism-1.5.1/test/prism/fixtures/return.txt000066400000000000000000000002531506127434000207140ustar00rootroot00000000000000return

return (1), (2), (3)

return *1

return 1

return 1, 2,
3

return 1, 2, 3

return [1, 2, 3]

return(
  1
  2
)

return()

return(1)

(return 1)

foo && (return 1)
prism-1.5.1/test/prism/fixtures/seattlerb/000077500000000000000000000000001506127434000206215ustar00rootroot00000000000000prism-1.5.1/test/prism/fixtures/seattlerb/BEGIN.txt000066400000000000000000000000151506127434000222020ustar00rootroot00000000000000BEGIN { 42 }
prism-1.5.1/test/prism/fixtures/seattlerb/README.rdoc000066400000000000000000000076371506127434000224440ustar00rootroot00000000000000= ruby_parser

home :: https://github.com/seattlerb/ruby_parser
bugs :: https://github.com/seattlerb/ruby_parser/issues
rdoc :: http://docs.seattlerb.org/ruby_parser

== DESCRIPTION:

ruby_parser (RP) is a ruby parser written in pure ruby (utilizing
racc--which does by default use a C extension). It outputs
s-expressions which can be manipulated and converted back to ruby via
the ruby2ruby gem.

As an example:

    def conditional1 arg1
      return 1 if arg1 == 0
      return 0
    end

becomes:

    s(:defn, :conditional1, s(:args, :arg1),
      s(:if,
        s(:call, s(:lvar, :arg1), :==, s(:lit, 0)),
        s(:return, s(:lit, 1)),
        nil),
      s(:return, s(:lit, 0)))

Tested against 801,039 files from the latest of all rubygems (as of 2013-05):

* 1.8 parser is at 99.9739% accuracy, 3.651 sigma
* 1.9 parser is at 99.9940% accuracy, 4.013 sigma
* 2.0 parser is at 99.9939% accuracy, 4.008 sigma
* 2.6 parser is at 99.9972% accuracy, 4.191 sigma
* 3.0 parser has a 100% parse rate.
  * Tested against 2,672,412 unique ruby files across 167k gems.
  * As do all the others now, basically.

== FEATURES/PROBLEMS:

* Pure ruby, no compiles.
* Includes preceding comment data for defn/defs/class/module nodes!
* Incredibly simple interface.
* Output is 100% equivalent to ParseTree.
  * Can utilize PT's SexpProcessor and UnifiedRuby for language processing.
* Known Issue: Speed is now pretty good, but can always improve:
  * RP parses a corpus of 3702 files in 125s (avg 108 Kb/s)
  * MRI+PT parsed the same in 67.38s (avg 200.89 Kb/s)
* Known Issue: Code is much better, but still has a long way to go.
* Known Issue: Totally awesome.
* Known Issue: line number values can be slightly off. Parsing LR sucks.

== SYNOPSIS:

  RubyParser.new.parse "1+1"
  # => s(:call, s(:lit, 1), :+, s(:lit, 1))

You can also use Ruby19Parser, Ruby18Parser, or RubyParser.for_current_ruby:

  RubyParser.for_current_ruby.parse "1+1"
  # => s(:call, s(:lit, 1), :+, s(:lit, 1))

== DEVELOPER NOTES:

To add a new version:

* New parser should be generated from lib/ruby_parser[23].yy.
* Extend lib/ruby_parser[23].yy with new class name.
* Add new version number to V2/V3 in Rakefile for rule creation.
* Add new `ruby_parse "x.y.z"` line to Rakefile for rake compare (line ~300).
* Require generated parser in lib/ruby_parser.rb.
* Add new V## = ::Ruby##Parser; end to ruby_parser.rb (bottom of file).
* Add empty TestRubyParserShared##Plus module and TestRubyParserV## to test/test_ruby_parser.rb.
* Extend Manifest.txt with generated file names.
* Add new version number to sexp_processor's pt_testcase.rb in all_versions.

Until all of these are done, you won't have a clean test run.

== REQUIREMENTS:

* ruby. woot.
* sexp_processor for Sexp and SexpProcessor classes, and testing.
* racc full package for parser development (compiling .y to .rb).

== INSTALL:

* sudo gem install ruby_parser

== LICENSE:

(The MIT License)

Copyright (c) Ryan Davis, seattle.rb

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
'Software'), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
prism-1.5.1/test/prism/fixtures/seattlerb/TestRubyParserShared.txt000066400000000000000000000012621506127434000254500ustar00rootroot00000000000000%I[


]

%I[
line2
line3
]

%W[


]

%W[
line2
line3
]

%i[


]

%i[
line2
line3
]

%r[


]

%w[


]

%w[
line2
line3
]

[
:line2,
:line3
]

class X         # line 1
  def self.y(a, # line 2
        b)      # line 3
    a + b       # line 4
  end           # line 5
end             # line 6


class X    # line 1
  class Y  # line 2
    Z = 42 # line 3
  end      # line 4
end        # line 5


class X    # line 1
  def y(a, # line 2
        b) # line 3
    a + b  # line 4
  end      # line 5
end        # line 6


module X
  X = [
    :line3,
    :line4,
  ]
end


module X   # line 1
  module Y # line 2
    Z = 42 # line 3
  end      # line 4
end        # line 5


x(
:line2,
:line3
)
prism-1.5.1/test/prism/fixtures/seattlerb/__ENCODING__.txt000066400000000000000000000000151506127434000233400ustar00rootroot00000000000000__ENCODING__
prism-1.5.1/test/prism/fixtures/seattlerb/alias_gvar_backref.txt000066400000000000000000000000201506127434000251370ustar00rootroot00000000000000alias $MATCH $&
prism-1.5.1/test/prism/fixtures/seattlerb/alias_resword.txt000066400000000000000000000000151506127434000242140ustar00rootroot00000000000000alias in out
prism-1.5.1/test/prism/fixtures/seattlerb/and_multi.txt000066400000000000000000000000341506127434000233330ustar00rootroot00000000000000true and
not false and
true
prism-1.5.1/test/prism/fixtures/seattlerb/aref_args_assocs.txt000066400000000000000000000000111506127434000246560ustar00rootroot00000000000000[1 => 2]
prism-1.5.1/test/prism/fixtures/seattlerb/aref_args_lit_assocs.txt000066400000000000000000000000141506127434000255310ustar00rootroot00000000000000[1, 2 => 3]
prism-1.5.1/test/prism/fixtures/seattlerb/args_kw_block.txt000066400000000000000000000000251506127434000241660ustar00rootroot00000000000000def f(a: 1, &b); end
prism-1.5.1/test/prism/fixtures/seattlerb/array_line_breaks.txt000066400000000000000000000000161506127434000250330ustar00rootroot00000000000000[
'a',
'b']
1
prism-1.5.1/test/prism/fixtures/seattlerb/array_lits_trailing_calls.txt000066400000000000000000000000151506127434000265760ustar00rootroot00000000000000%w[].b

[].b
prism-1.5.1/test/prism/fixtures/seattlerb/assoc__bare.txt000066400000000000000000000000071506127434000236170ustar00rootroot00000000000000{ y: }
prism-1.5.1/test/prism/fixtures/seattlerb/assoc_label.txt000066400000000000000000000000071506127434000236260ustar00rootroot00000000000000a(b:1)
prism-1.5.1/test/prism/fixtures/seattlerb/attr_asgn_colon_id.txt000066400000000000000000000000111506127434000252020ustar00rootroot00000000000000A::b = 1
prism-1.5.1/test/prism/fixtures/seattlerb/attrasgn_array_arg.txt000066400000000000000000000000161506127434000252310ustar00rootroot00000000000000a[[1, 2]] = 3
prism-1.5.1/test/prism/fixtures/seattlerb/attrasgn_array_lhs.txt000066400000000000000000000000531506127434000252470ustar00rootroot00000000000000[1, 2, 3, 4][from .. to] = ["a", "b", "c"]
prism-1.5.1/test/prism/fixtures/seattlerb/attrasgn_primary_dot_constant.txt000066400000000000000000000000101506127434000275160ustar00rootroot00000000000000a.B = 1
prism-1.5.1/test/prism/fixtures/seattlerb/backticks_interpolation_line.txt000066400000000000000000000000111506127434000272660ustar00rootroot00000000000000x `#{y}`
prism-1.5.1/test/prism/fixtures/seattlerb/bang_eq.txt000066400000000000000000000000071506127434000227530ustar00rootroot000000000000001 != 2
prism-1.5.1/test/prism/fixtures/seattlerb/bdot2.txt000066400000000000000000000000171506127434000223720ustar00rootroot00000000000000..10
; ..a
; c
prism-1.5.1/test/prism/fixtures/seattlerb/bdot3.txt000066400000000000000000000000211506127434000223660ustar00rootroot00000000000000...10
; ...a
; c
prism-1.5.1/test/prism/fixtures/seattlerb/begin_ensure_no_bodies.txt000066400000000000000000000000211506127434000260410ustar00rootroot00000000000000begin
ensure
end
prism-1.5.1/test/prism/fixtures/seattlerb/begin_rescue_else_ensure_bodies.txt000066400000000000000000000000551506127434000277320ustar00rootroot00000000000000begin
  1
rescue
  2
else
  3
ensure
  4
end
prism-1.5.1/test/prism/fixtures/seattlerb/begin_rescue_else_ensure_no_bodies.txt000066400000000000000000000000411506127434000304210ustar00rootroot00000000000000begin

rescue

else

ensure

end
prism-1.5.1/test/prism/fixtures/seattlerb/begin_rescue_ensure_no_bodies.txt000066400000000000000000000000301506127434000274070ustar00rootroot00000000000000begin
rescue
ensure
end
prism-1.5.1/test/prism/fixtures/seattlerb/block_arg__bare.txt000066400000000000000000000000161506127434000244320ustar00rootroot00000000000000def x(&); end
prism-1.5.1/test/prism/fixtures/seattlerb/block_arg_kwsplat.txt000066400000000000000000000000141506127434000250450ustar00rootroot00000000000000a { |**b| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_arg_opt_arg_block.txt000066400000000000000000000000261506127434000261700ustar00rootroot00000000000000a { |b, c=1, d, &e| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_arg_opt_splat.txt000066400000000000000000000000251506127434000253670ustar00rootroot00000000000000a { |b, c = 1, *d| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_arg_opt_splat_arg_block_omfg.txt000066400000000000000000000000321506127434000304000ustar00rootroot00000000000000a { |b, c=1, *d, e, &f| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_arg_optional.txt000066400000000000000000000000161506127434000252070ustar00rootroot00000000000000a { |b = 1| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_arg_scope.txt000066400000000000000000000000151506127434000244720ustar00rootroot00000000000000a { |b; c| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_arg_scope2.txt000066400000000000000000000000171506127434000245560ustar00rootroot00000000000000a {|b; c, d| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_arg_splat_arg.txt000066400000000000000000000000211506127434000253320ustar00rootroot00000000000000a { |b, *c, d| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_args_kwargs.txt000066400000000000000000000000301506127434000250370ustar00rootroot00000000000000f { |**kwargs| kwargs }
prism-1.5.1/test/prism/fixtures/seattlerb/block_args_no_kwargs.txt000066400000000000000000000000161506127434000255370ustar00rootroot00000000000000f { |**nil| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_args_opt1.txt000066400000000000000000000000311506127434000244250ustar00rootroot00000000000000f { |a, b = 42| [a, b] }
prism-1.5.1/test/prism/fixtures/seattlerb/block_args_opt2.txt000066400000000000000000000000231506127434000244270ustar00rootroot00000000000000a { | b=1, c=2 | }
prism-1.5.1/test/prism/fixtures/seattlerb/block_args_opt2_2.txt000066400000000000000000000000441506127434000246530ustar00rootroot00000000000000f { |a, b = 42, c = 24| [a, b, c] }
prism-1.5.1/test/prism/fixtures/seattlerb/block_args_opt3.txt000066400000000000000000000000531506127434000244330ustar00rootroot00000000000000f { |a, b = 42, c = 24, &d| [a, b, c, d] }
prism-1.5.1/test/prism/fixtures/seattlerb/block_call_defn_call_block_call.txt000066400000000000000000000000371506127434000276030ustar00rootroot00000000000000a def b(c)
 d
 end
 e.f do end
prism-1.5.1/test/prism/fixtures/seattlerb/block_call_dot_op2_brace_block.txt000066400000000000000000000000401506127434000273750ustar00rootroot00000000000000a.b c() do d end.e do |f| g end
prism-1.5.1/test/prism/fixtures/seattlerb/block_call_dot_op2_cmd_args_do_block.txt000066400000000000000000000000421506127434000305640ustar00rootroot00000000000000a.b c() do d end.e f do |g| h end
prism-1.5.1/test/prism/fixtures/seattlerb/block_call_operation_colon.txt000066400000000000000000000000201506127434000267110ustar00rootroot00000000000000a.b c do end::d
prism-1.5.1/test/prism/fixtures/seattlerb/block_call_operation_dot.txt000066400000000000000000000000171506127434000263730ustar00rootroot00000000000000a.b c do end.d
prism-1.5.1/test/prism/fixtures/seattlerb/block_call_paren_call_block_call.txt000066400000000000000000000000211506127434000277650ustar00rootroot00000000000000a (b)
c.d do end
prism-1.5.1/test/prism/fixtures/seattlerb/block_command_operation_colon.txt000066400000000000000000000000221506127434000274160ustar00rootroot00000000000000a :b do end::c :d
prism-1.5.1/test/prism/fixtures/seattlerb/block_command_operation_dot.txt000066400000000000000000000000211506127434000270710ustar00rootroot00000000000000a :b do end.c :d
prism-1.5.1/test/prism/fixtures/seattlerb/block_decomp_anon_splat_arg.txt000066400000000000000000000000171506127434000270500ustar00rootroot00000000000000f { |(*, a)| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_decomp_arg_splat.txt000066400000000000000000000000171506127434000260350ustar00rootroot00000000000000a { |(b, *)| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_decomp_arg_splat_arg.txt000066400000000000000000000000231506127434000266630ustar00rootroot00000000000000f { |(a, *b, c)| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_decomp_splat.txt000066400000000000000000000000151506127434000252020ustar00rootroot00000000000000f { |(*a)| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_kw.txt000066400000000000000000000000201506127434000231450ustar00rootroot00000000000000blah { |k:42| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_kw__required.txt000066400000000000000000000000211506127434000252050ustar00rootroot00000000000000blah do |k:| end
prism-1.5.1/test/prism/fixtures/seattlerb/block_kwarg_lvar.txt000066400000000000000000000000251506127434000246700ustar00rootroot00000000000000bl { |kw: :val| kw }
prism-1.5.1/test/prism/fixtures/seattlerb/block_kwarg_lvar_multiple.txt000066400000000000000000000000421506127434000266020ustar00rootroot00000000000000bl { |kw: :val, kw2: :val2 | kw }
prism-1.5.1/test/prism/fixtures/seattlerb/block_opt_arg.txt000066400000000000000000000000171506127434000241650ustar00rootroot00000000000000a { |b=1, c| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_opt_splat.txt000066400000000000000000000000221506127434000245330ustar00rootroot00000000000000a { |b = 1, *c| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_opt_splat_arg_block_omfg.txt000066400000000000000000000000271506127434000275530ustar00rootroot00000000000000a { |b=1, *c, d, &e| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_optarg.txt000066400000000000000000000000171506127434000240260ustar00rootroot00000000000000a { |b = :c| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_paren_splat.txt000066400000000000000000000000201506127434000250340ustar00rootroot00000000000000a { |(b, *c)| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_reg_optarg.txt000066400000000000000000000000221506127434000246570ustar00rootroot00000000000000a { |b, c = :d| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_return.txt000066400000000000000000000000341506127434000240500ustar00rootroot00000000000000return foo arg do |bar| end
prism-1.5.1/test/prism/fixtures/seattlerb/block_scope.txt000066400000000000000000000000131506127434000236370ustar00rootroot00000000000000a { |;b| }
prism-1.5.1/test/prism/fixtures/seattlerb/block_splat_reg.txt000066400000000000000000000000161506127434000245110ustar00rootroot00000000000000a { |*b, c| }
prism-1.5.1/test/prism/fixtures/seattlerb/bug169.txt000066400000000000000000000000101506127434000223660ustar00rootroot00000000000000m () {}
prism-1.5.1/test/prism/fixtures/seattlerb/bug179.txt000066400000000000000000000000121506127434000223710ustar00rootroot00000000000000p ()..nil
prism-1.5.1/test/prism/fixtures/seattlerb/bug190.txt000066400000000000000000000000071506127434000223660ustar00rootroot00000000000000%r'\''
prism-1.5.1/test/prism/fixtures/seattlerb/bug191.txt000066400000000000000000000000251506127434000223670ustar00rootroot00000000000000a ? "": b

a ? '': b
prism-1.5.1/test/prism/fixtures/seattlerb/bug202.txt000066400000000000000000000000271506127434000223620ustar00rootroot00000000000000$测试 = 1
测试 = 1
prism-1.5.1/test/prism/fixtures/seattlerb/bug236.txt000066400000000000000000000000201506127434000223620ustar00rootroot00000000000000x{|a,|}

x{|a|}
prism-1.5.1/test/prism/fixtures/seattlerb/bug290.txt000066400000000000000000000000201506127434000223620ustar00rootroot00000000000000begin
  foo
end
prism-1.5.1/test/prism/fixtures/seattlerb/bug_187.txt000066400000000000000000000000351506127434000225340ustar00rootroot00000000000000private def f
a.b do end
end
prism-1.5.1/test/prism/fixtures/seattlerb/bug_215.txt000066400000000000000000000000161506127434000225230ustar00rootroot00000000000000undef %s(foo)
prism-1.5.1/test/prism/fixtures/seattlerb/bug_249.txt000066400000000000000000000001041506127434000225300ustar00rootroot00000000000000mount (Class.new do
def initialize
end
 end).new, :at => 'endpoint'
prism-1.5.1/test/prism/fixtures/seattlerb/bug_and.txt000066400000000000000000000000331506127434000227550ustar00rootroot00000000000000true and
true

true and []
prism-1.5.1/test/prism/fixtures/seattlerb/bug_args__19.txt000066400000000000000000000000211506127434000236140ustar00rootroot00000000000000f { |(a, b)| d }
prism-1.5.1/test/prism/fixtures/seattlerb/bug_args_masgn.txt000066400000000000000000000000221506127434000243320ustar00rootroot00000000000000f { |(a, b), c| }
prism-1.5.1/test/prism/fixtures/seattlerb/bug_args_masgn2.txt000066400000000000000000000000271506127434000244210ustar00rootroot00000000000000f { |((a, b), c), d| }
prism-1.5.1/test/prism/fixtures/seattlerb/bug_args_masgn_outer_parens__19.txt000066400000000000000000000000241506127434000275720ustar00rootroot00000000000000f { |((k, v), i)| }
prism-1.5.1/test/prism/fixtures/seattlerb/bug_call_arglist_parens.txt000066400000000000000000000001371506127434000262300ustar00rootroot00000000000000      def f
        g ( 1), 2
      end


      def f()
        g (1), 2
      end


g ( 1), 2
prism-1.5.1/test/prism/fixtures/seattlerb/bug_case_when_regexp.txt000066400000000000000000000000331506127434000255210ustar00rootroot00000000000000case :x; when /x/ then end
prism-1.5.1/test/prism/fixtures/seattlerb/bug_comma.txt000066400000000000000000000000311506127434000233050ustar00rootroot00000000000000if test ?d, dir then end
prism-1.5.1/test/prism/fixtures/seattlerb/bug_cond_pct.txt000066400000000000000000000000351506127434000240060ustar00rootroot00000000000000case; when %r%blahblah%; end
prism-1.5.1/test/prism/fixtures/seattlerb/bug_hash_args.txt000066400000000000000000000000241506127434000241520ustar00rootroot00000000000000foo(:bar, baz: nil)
prism-1.5.1/test/prism/fixtures/seattlerb/bug_hash_args_trailing_comma.txt000066400000000000000000000000251506127434000272200ustar00rootroot00000000000000foo(:bar, baz: nil,)
prism-1.5.1/test/prism/fixtures/seattlerb/bug_hash_interp_array.txt000066400000000000000000000000161506127434000257160ustar00rootroot00000000000000{ "#{}": [] }
prism-1.5.1/test/prism/fixtures/seattlerb/bug_masgn_right.txt000066400000000000000000000000221506127434000245130ustar00rootroot00000000000000f { |a, (b, c)| }
prism-1.5.1/test/prism/fixtures/seattlerb/bug_not_parens.txt000066400000000000000000000000071506127434000243640ustar00rootroot00000000000000not(a)
prism-1.5.1/test/prism/fixtures/seattlerb/bug_op_asgn_rescue.txt000066400000000000000000000000231506127434000252060ustar00rootroot00000000000000a ||= b rescue nil
prism-1.5.1/test/prism/fixtures/seattlerb/call_and.txt000066400000000000000000000000061506127434000231130ustar00rootroot000000000000001 & 2
prism-1.5.1/test/prism/fixtures/seattlerb/call_arg_assoc.txt000066400000000000000000000000131506127434000243100ustar00rootroot00000000000000f(1, 2=>3)
prism-1.5.1/test/prism/fixtures/seattlerb/call_arg_assoc_kwsplat.txt000066400000000000000000000000211506127434000260540ustar00rootroot00000000000000f(1, kw: 2, **3)
prism-1.5.1/test/prism/fixtures/seattlerb/call_arg_kwsplat.txt000066400000000000000000000000121506127434000246640ustar00rootroot00000000000000a(b, **1)
prism-1.5.1/test/prism/fixtures/seattlerb/call_args_assoc_quoted.txt000066400000000000000000000000401506127434000260540ustar00rootroot00000000000000x "#{k}":42

x "k":42

x 'k':42
prism-1.5.1/test/prism/fixtures/seattlerb/call_args_assoc_trailing_comma.txt000066400000000000000000000000141506127434000275410ustar00rootroot00000000000000f(1, 2=>3,)
prism-1.5.1/test/prism/fixtures/seattlerb/call_args_command.txt000066400000000000000000000000121506127434000250000ustar00rootroot00000000000000a.b c.d 1
prism-1.5.1/test/prism/fixtures/seattlerb/call_array_arg.txt000066400000000000000000000000161506127434000243210ustar00rootroot000000000000001 == [:b, :c]
prism-1.5.1/test/prism/fixtures/seattlerb/call_array_block_call.txt000066400000000000000000000000241506127434000256340ustar00rootroot00000000000000a [ nil, b do end ]
prism-1.5.1/test/prism/fixtures/seattlerb/call_array_lambda_block_call.txt000066400000000000000000000000231506127434000271330ustar00rootroot00000000000000a [->() {}] do
end
prism-1.5.1/test/prism/fixtures/seattlerb/call_array_lit_inline_hash.txt000066400000000000000000000000211506127434000266750ustar00rootroot00000000000000a([:b, :c => 1])
prism-1.5.1/test/prism/fixtures/seattlerb/call_assoc.txt000066400000000000000000000000101506127434000234540ustar00rootroot00000000000000f(2=>3)
prism-1.5.1/test/prism/fixtures/seattlerb/call_assoc_new.txt000066400000000000000000000000071506127434000243330ustar00rootroot00000000000000f(a:3)
prism-1.5.1/test/prism/fixtures/seattlerb/call_assoc_new_if_multiline.txt000066400000000000000000000000311506127434000270700ustar00rootroot00000000000000a(b: if :c
1
else
2
end)
prism-1.5.1/test/prism/fixtures/seattlerb/call_assoc_trailing_comma.txt000066400000000000000000000000111506127434000265220ustar00rootroot00000000000000f(1=>2,)
prism-1.5.1/test/prism/fixtures/seattlerb/call_bang_command_call.txt000066400000000000000000000000101506127434000257440ustar00rootroot00000000000000! a.b 1
prism-1.5.1/test/prism/fixtures/seattlerb/call_bang_squiggle.txt000066400000000000000000000000071506127434000251610ustar00rootroot000000000000001 !~ 2
prism-1.5.1/test/prism/fixtures/seattlerb/call_begin_call_block_call.txt000066400000000000000000000000271506127434000266000ustar00rootroot00000000000000a begin
b.c do end
end
prism-1.5.1/test/prism/fixtures/seattlerb/call_block_arg_named.txt000066400000000000000000000000101506127434000254330ustar00rootroot00000000000000x(&blk)
prism-1.5.1/test/prism/fixtures/seattlerb/call_carat.txt000066400000000000000000000000061506127434000234430ustar00rootroot000000000000001 ^ 2
prism-1.5.1/test/prism/fixtures/seattlerb/call_colon2.txt000066400000000000000000000000051506127434000235440ustar00rootroot00000000000000A::b
prism-1.5.1/test/prism/fixtures/seattlerb/call_colon_parens.txt000066400000000000000000000000061506127434000250330ustar00rootroot000000000000001::()
prism-1.5.1/test/prism/fixtures/seattlerb/call_div.txt000066400000000000000000000000061506127434000231330ustar00rootroot000000000000001 / 2
prism-1.5.1/test/prism/fixtures/seattlerb/call_dot_parens.txt000066400000000000000000000000051506127434000245060ustar00rootroot000000000000001.()
prism-1.5.1/test/prism/fixtures/seattlerb/call_env.txt000066400000000000000000000000101506127434000231340ustar00rootroot00000000000000a.happy
prism-1.5.1/test/prism/fixtures/seattlerb/call_eq3.txt000066400000000000000000000000101506127434000230340ustar00rootroot000000000000001 === 2
prism-1.5.1/test/prism/fixtures/seattlerb/call_gt.txt000066400000000000000000000000061506127434000227630ustar00rootroot000000000000001 > 2
prism-1.5.1/test/prism/fixtures/seattlerb/call_kwsplat.txt000066400000000000000000000000071506127434000240370ustar00rootroot00000000000000a(**1)
prism-1.5.1/test/prism/fixtures/seattlerb/call_leading_dots.txt000066400000000000000000000000101506127434000250000ustar00rootroot00000000000000a
.b
.c
prism-1.5.1/test/prism/fixtures/seattlerb/call_leading_dots_comment.txt000066400000000000000000000000141506127434000265260ustar00rootroot00000000000000a
.b
#.c
.d
prism-1.5.1/test/prism/fixtures/seattlerb/call_lt.txt000066400000000000000000000000061506127434000227700ustar00rootroot000000000000001 < 2
prism-1.5.1/test/prism/fixtures/seattlerb/call_lte.txt000066400000000000000000000000071506127434000231360ustar00rootroot000000000000001 <= 2
prism-1.5.1/test/prism/fixtures/seattlerb/call_not.txt000066400000000000000000000000071506127434000231520ustar00rootroot00000000000000not 42
prism-1.5.1/test/prism/fixtures/seattlerb/call_pipe.txt000066400000000000000000000000061506127434000233060ustar00rootroot000000000000001 | 2
prism-1.5.1/test/prism/fixtures/seattlerb/call_rshift.txt000066400000000000000000000000071506127434000236510ustar00rootroot000000000000001 >> 2
prism-1.5.1/test/prism/fixtures/seattlerb/call_self_brackets.txt000066400000000000000000000000101506127434000251530ustar00rootroot00000000000000self[1]
prism-1.5.1/test/prism/fixtures/seattlerb/call_spaceship.txt000066400000000000000000000000101506127434000243230ustar00rootroot000000000000001 <=> 2
prism-1.5.1/test/prism/fixtures/seattlerb/call_stabby_do_end_with_block.txt000066400000000000000000000000271506127434000273550ustar00rootroot00000000000000a -> do 1 end do 2 end
prism-1.5.1/test/prism/fixtures/seattlerb/call_stabby_with_braces_block.txt000066400000000000000000000000241506127434000273610ustar00rootroot00000000000000a -> { 1 } do 2 end
prism-1.5.1/test/prism/fixtures/seattlerb/call_star.txt000066400000000000000000000000061506127434000233220ustar00rootroot000000000000001 * 2
prism-1.5.1/test/prism/fixtures/seattlerb/call_star2.txt000066400000000000000000000000071506127434000234050ustar00rootroot000000000000001 ** 2
prism-1.5.1/test/prism/fixtures/seattlerb/call_trailing_comma.txt000066400000000000000000000000061506127434000253360ustar00rootroot00000000000000f(1,)
prism-1.5.1/test/prism/fixtures/seattlerb/call_trailing_dots.txt000066400000000000000000000000101506127434000252060ustar00rootroot00000000000000a.
b.
c
prism-1.5.1/test/prism/fixtures/seattlerb/call_unary_bang.txt000066400000000000000000000000031506127434000244730ustar00rootroot00000000000000!1
prism-1.5.1/test/prism/fixtures/seattlerb/case_in.txt000066400000000000000000000013541506127434000227660ustar00rootroot00000000000000case :a
in  "b": 
end

case :a
in %I[a b]
end

case :a
in %W[a b]
end

case :a
in %i[a b]
end

case :a
in %w[a b]
end

case :a
in (...10)
end

case :a
in (..10)
end

case :a
in (1...)
end

case :a
in (1...3)
end

case :a
in (42)
end

case :a
in **nil
end

case :a
in /regexp/
end

case :a
in :b, *_, :c
end

case :a
in :b, [:c]
end

case :a
in Symbol()
end

case :a
in Symbol(*lhs, x, *rhs)
end

case :a
in Symbol[*lhs, x, *rhs]
end

case :a
in [->(b) { true }, c]
end

case :a
in [:a, b, c, [:d, *e, nil]]
end

case :a
in [A, *, B]
end

case :a
in [[:b, c], [:d, ^e]]
end

case :a
in []
end

case :a
in [^(a)]
end

case :a
in [^@a, ^$b, ^@@c]
end

case :a
in `echo hi`
end

case :a
in nil, nil, nil
end

case :a
in { "b": }
end

case :a
in {}
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_31.txt000066400000000000000000000000351506127434000232640ustar00rootroot00000000000000case :a
in [:b, *c]
  :d
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_37.txt000066400000000000000000000000451506127434000232730ustar00rootroot00000000000000case :a
in { b: [Hash, *] }
  :c
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_42.txt000066400000000000000000000000371506127434000232700ustar00rootroot00000000000000case :a
in :b, *_ then nil
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_42_2.txt000066400000000000000000000000411506127434000235040ustar00rootroot00000000000000case :a
in A(*list) then nil
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_47.txt000066400000000000000000000000401506127434000232670ustar00rootroot00000000000000case :a
in [*, :b, :c]
  :d
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_67.txt000066400000000000000000000000341506127434000232740ustar00rootroot00000000000000case :a
in 1.. then nil
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_86.txt000066400000000000000000000000541506127434000232770ustar00rootroot00000000000000case [:a, :b]
in ::NilClass, * then nil
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_86_2.txt000066400000000000000000000000541506127434000235200ustar00rootroot00000000000000case [:a, :b]
in *, ::NilClass then nil
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_array_pat_const.txt000066400000000000000000000000311506127434000262250ustar00rootroot00000000000000case :a
in B[c]
  :d
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_array_pat_const2.txt000066400000000000000000000000341506127434000263120ustar00rootroot00000000000000case :a
in B::C[d]
  :e
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_array_pat_paren_assign.txt000066400000000000000000000000361506127434000275550ustar00rootroot00000000000000case :a
in B(C => d)
  :d
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_const.txt000066400000000000000000000000351506127434000241670ustar00rootroot00000000000000case Array
in Class
  :b
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_else.txt000066400000000000000000000000501506127434000237660ustar00rootroot00000000000000case Array
in Class
  :b
else
  :c
end

prism-1.5.1/test/prism/fixtures/seattlerb/case_in_find.txt000066400000000000000000000000341506127434000237600ustar00rootroot00000000000000case :a
  in *a, :+, *b
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_find_array.txt000066400000000000000000000000351506127434000251570ustar00rootroot00000000000000case :a
in [*, :b, c, *]
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_hash_pat.txt000066400000000000000000000000551506127434000246320ustar00rootroot00000000000000case :a
in { b: 'c', d: "e" } then
  :f
end

prism-1.5.1/test/prism/fixtures/seattlerb/case_in_hash_pat_assign.txt000066400000000000000000000000711506127434000261740ustar00rootroot00000000000000case :a
in { b: Integer => x, d: "e", f: } then
  :g
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_hash_pat_paren_assign.txt000066400000000000000000000000351506127434000273610ustar00rootroot00000000000000case :a
in B(a: 42)
  :d
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_hash_pat_paren_true.txt000066400000000000000000000000421506127434000270520ustar00rootroot00000000000000case :a
in b: true then
  :c
end

prism-1.5.1/test/prism/fixtures/seattlerb/case_in_hash_pat_rest.txt000066400000000000000000000000441506127434000256650ustar00rootroot00000000000000case :a
in b: c, **rest then :d
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_hash_pat_rest_solo.txt000066400000000000000000000000361506127434000267220ustar00rootroot00000000000000case :a
in **rest then :d
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_if_unless_post_mod.txt000066400000000000000000000000651506127434000267370ustar00rootroot00000000000000case :a
in A if true
  :C
in D unless false
  :E
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_multiple.txt000066400000000000000000000000461506127434000246760ustar00rootroot00000000000000case :a
in A::B
  :C
in D::E
  :F
end
prism-1.5.1/test/prism/fixtures/seattlerb/case_in_or.txt000066400000000000000000000000331506127434000234570ustar00rootroot00000000000000case :a
in B | C
  :d
end

prism-1.5.1/test/prism/fixtures/seattlerb/class_comments.txt000066400000000000000000000001101506127434000243640ustar00rootroot00000000000000# blah 1
# blah 2

class X
  # blah 3
  def blah
    # blah 4
  end
end
prism-1.5.1/test/prism/fixtures/seattlerb/cond_unary_minus.txt000066400000000000000000000000131506127434000247300ustar00rootroot00000000000000if -1; end
prism-1.5.1/test/prism/fixtures/seattlerb/const_2_op_asgn_or2.txt000066400000000000000000000000151506127434000252150ustar00rootroot00000000000000::X::Y ||= 1
prism-1.5.1/test/prism/fixtures/seattlerb/const_3_op_asgn_or.txt000066400000000000000000000000121506127434000251310ustar00rootroot00000000000000::X ||= 1
prism-1.5.1/test/prism/fixtures/seattlerb/const_op_asgn_and1.txt000066400000000000000000000000111506127434000251110ustar00rootroot00000000000000::X &= 1
prism-1.5.1/test/prism/fixtures/seattlerb/const_op_asgn_and2.txt000066400000000000000000000000121506127434000251130ustar00rootroot00000000000000::X &&= 1
prism-1.5.1/test/prism/fixtures/seattlerb/const_op_asgn_or.txt000066400000000000000000000000131506127434000247100ustar00rootroot00000000000000X::Y ||= 1
prism-1.5.1/test/prism/fixtures/seattlerb/defined_eh_parens.txt000066400000000000000000000000151506127434000250000ustar00rootroot00000000000000defined?(42)
prism-1.5.1/test/prism/fixtures/seattlerb/defn_arg_asplat_arg.txt000066400000000000000000000000361506127434000253230ustar00rootroot00000000000000def call(interp, *, args) end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_arg_forward_args.txt000066400000000000000000000000361506127434000256660ustar00rootroot00000000000000def a(x, ...); b(x, ...); end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_args_forward_args.txt000066400000000000000000000000521506127434000260470ustar00rootroot00000000000000def a(x, y, z, ...); b(:get, z, ...); end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_comments.txt000066400000000000000000000000401506127434000241750ustar00rootroot00000000000000# blah 1
# blah 2

def blah
end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_endless_command.txt000066400000000000000000000000421506127434000255050ustar00rootroot00000000000000def some_method = other_method 42
prism-1.5.1/test/prism/fixtures/seattlerb/defn_endless_command_rescue.txt000066400000000000000000000000541506127434000270560ustar00rootroot00000000000000def some_method = other_method 42 rescue 24
prism-1.5.1/test/prism/fixtures/seattlerb/defn_forward_args.txt000066400000000000000000000000301506127434000250270ustar00rootroot00000000000000def a(...); b(...); end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_forward_args__no_parens.txt000066400000000000000000000000271506127434000272400ustar00rootroot00000000000000def f ...
  m(...)
end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_kwarg_env.txt000066400000000000000000000000561506127434000243420ustar00rootroot00000000000000def test(**testing) test_splat(**testing) end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_kwarg_kwarg.txt000066400000000000000000000000311506127434000246560ustar00rootroot00000000000000def f(a, b: 1, c: 2) end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_kwarg_kwsplat.txt000066400000000000000000000000251506127434000252330ustar00rootroot00000000000000def a(b: 1, **c) end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_kwarg_kwsplat_anon.txt000066400000000000000000000000241506127434000262450ustar00rootroot00000000000000def a(b: 1, **) end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_kwarg_lvar.txt000066400000000000000000000000331506127434000245110ustar00rootroot00000000000000def fun(kw: :val); kw; end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_kwarg_no_parens.txt000066400000000000000000000000171506127434000255330ustar00rootroot00000000000000def f a: 1
end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_kwarg_val.txt000066400000000000000000000000221506127434000243250ustar00rootroot00000000000000def f(a, b:1) end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_no_kwargs.txt000066400000000000000000000000221506127434000243420ustar00rootroot00000000000000def x(**nil); end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_oneliner.txt000066400000000000000000000000341506127434000241660ustar00rootroot00000000000000def exec(cmd) = system(cmd)
prism-1.5.1/test/prism/fixtures/seattlerb/defn_oneliner_eq2.txt000066400000000000000000000000351506127434000247360ustar00rootroot00000000000000class X
  def ==(o) = 42
end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_oneliner_noargs.txt000066400000000000000000000000221506127434000255340ustar00rootroot00000000000000def exec = system
prism-1.5.1/test/prism/fixtures/seattlerb/defn_oneliner_noargs_parentheses.txt000066400000000000000000000000241506127434000301370ustar00rootroot00000000000000def exec() = system
prism-1.5.1/test/prism/fixtures/seattlerb/defn_oneliner_rescue.txt000066400000000000000000000002031506127434000255320ustar00rootroot00000000000000def exec(cmd)
  system(cmd)
rescue
  nil
end


def exec(cmd)
  system(cmd) rescue nil
end


def exec(cmd) = system(cmd) rescue nil
prism-1.5.1/test/prism/fixtures/seattlerb/defn_opt_last_arg.txt000066400000000000000000000000261506127434000250320ustar00rootroot00000000000000def m arg = false
end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_opt_reg.txt000066400000000000000000000000241506127434000240110ustar00rootroot00000000000000def f(a=nil, b) end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_opt_splat_arg.txt000066400000000000000000000000311506127434000252060ustar00rootroot00000000000000def f (a = 1, *b, c) end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_powarg.txt000066400000000000000000000000221506127434000236470ustar00rootroot00000000000000def f(**opts) end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_reg_opt_reg.txt000066400000000000000000000000301506127434000246430ustar00rootroot00000000000000def f(a, b = :c, d) end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_splat_arg.txt000066400000000000000000000000201506127434000243220ustar00rootroot00000000000000def f(*, a) end
prism-1.5.1/test/prism/fixtures/seattlerb/defn_unary_not.txt000066400000000000000000000000221506127434000243660ustar00rootroot00000000000000def !@; true; end
prism-1.5.1/test/prism/fixtures/seattlerb/defns_reserved.txt000066400000000000000000000000251506127434000243550ustar00rootroot00000000000000def self.return; end
prism-1.5.1/test/prism/fixtures/seattlerb/defs_as_arg_with_do_block_inside.txt000066400000000000000000000000371506127434000300410ustar00rootroot00000000000000p def self.b; x.y do; end; end
prism-1.5.1/test/prism/fixtures/seattlerb/defs_comments.txt000066400000000000000000000000451506127434000242070ustar00rootroot00000000000000# blah 1
# blah 2

def self.blah
end
prism-1.5.1/test/prism/fixtures/seattlerb/defs_endless_command.txt000066400000000000000000000000441506127434000255140ustar00rootroot00000000000000def x.some_method = other_method 42
prism-1.5.1/test/prism/fixtures/seattlerb/defs_endless_command_rescue.txt000066400000000000000000000000561506127434000270650ustar00rootroot00000000000000def x.some_method = other_method 42 rescue 24
prism-1.5.1/test/prism/fixtures/seattlerb/defs_kwarg.txt000066400000000000000000000000241506127434000234720ustar00rootroot00000000000000def self.a b: 1
end
prism-1.5.1/test/prism/fixtures/seattlerb/defs_oneliner.txt000066400000000000000000000000411506127434000241710ustar00rootroot00000000000000def self.exec(cmd) = system(cmd)
prism-1.5.1/test/prism/fixtures/seattlerb/defs_oneliner_eq2.txt000066400000000000000000000000421506127434000247410ustar00rootroot00000000000000class X
  def self.==(o) = 42
end
prism-1.5.1/test/prism/fixtures/seattlerb/defs_oneliner_rescue.txt000066400000000000000000000002221506127434000255400ustar00rootroot00000000000000def self.exec(cmd)
  system(cmd)
rescue
  nil
end


def self.exec(cmd)
  system(cmd) rescue nil
end


def self.exec(cmd) = system(cmd) rescue nil
prism-1.5.1/test/prism/fixtures/seattlerb/difficult0_.txt000066400000000000000000000000371506127434000235520ustar00rootroot00000000000000p <<-END+'b
  a
  END
  c'+'d'
prism-1.5.1/test/prism/fixtures/seattlerb/difficult1_line_numbers.txt000066400000000000000000000001521506127434000261540ustar00rootroot00000000000000if true
  p 1
  a.b 2
  c.d 3, 4
  e.f 5
  g.h 6, 7
  p(1)
  a.b(2)
  c.d(3, 4)
  e.f(5)
  g.h(6, 7)
end

prism-1.5.1/test/prism/fixtures/seattlerb/difficult1_line_numbers2.txt000066400000000000000000000000621506127434000262360ustar00rootroot00000000000000if true then
  p("a")
  b = 1
  p b
  c =1
end
a

prism-1.5.1/test/prism/fixtures/seattlerb/difficult2_.txt000066400000000000000000000000251506127434000235510ustar00rootroot000000000000001 ? b('') : 2
a d: 3
prism-1.5.1/test/prism/fixtures/seattlerb/difficult3_.txt000066400000000000000000000000231506127434000235500ustar00rootroot00000000000000f { |a, (b, *c)| }
prism-1.5.1/test/prism/fixtures/seattlerb/difficult3_2.txt000066400000000000000000000000161506127434000236340ustar00rootroot00000000000000f { |*a, b| }
prism-1.5.1/test/prism/fixtures/seattlerb/difficult3_3.txt000066400000000000000000000000221506127434000236320ustar00rootroot00000000000000f { |*a, b, &c| }
prism-1.5.1/test/prism/fixtures/seattlerb/difficult3_4.txt000066400000000000000000000000221506127434000236330ustar00rootroot00000000000000a=b ? true: false
prism-1.5.1/test/prism/fixtures/seattlerb/difficult3_5.txt000066400000000000000000000000241506127434000236360ustar00rootroot00000000000000f ->() { g do end }
prism-1.5.1/test/prism/fixtures/seattlerb/difficult3__10.txt000066400000000000000000000000231506127434000240500ustar00rootroot00000000000000f { |a, (*b, c)| }
prism-1.5.1/test/prism/fixtures/seattlerb/difficult3__11.txt000066400000000000000000000000171506127434000240540ustar00rootroot00000000000000f { |a, (*)| }
prism-1.5.1/test/prism/fixtures/seattlerb/difficult3__12.txt000066400000000000000000000000221506127434000240510ustar00rootroot00000000000000f { |a, (*, b)| }
prism-1.5.1/test/prism/fixtures/seattlerb/difficult3__6.txt000066400000000000000000000000261506127434000240000ustar00rootroot00000000000000f { |a, (b, *c, d)| }
prism-1.5.1/test/prism/fixtures/seattlerb/difficult3__7.txt000066400000000000000000000000221506127434000237750ustar00rootroot00000000000000f { |a, (b, *)| }
prism-1.5.1/test/prism/fixtures/seattlerb/difficult3__8.txt000066400000000000000000000000251506127434000240010ustar00rootroot00000000000000f { |a, (b, *, c)| }
prism-1.5.1/test/prism/fixtures/seattlerb/difficult3__9.txt000066400000000000000000000000201506127434000237750ustar00rootroot00000000000000f { |a, (*b)| }
prism-1.5.1/test/prism/fixtures/seattlerb/difficult4__leading_dots.txt000066400000000000000000000000051506127434000262650ustar00rootroot00000000000000a
.b
prism-1.5.1/test/prism/fixtures/seattlerb/difficult4__leading_dots2.txt000066400000000000000000000000061506127434000263500ustar00rootroot000000000000001
..3
prism-1.5.1/test/prism/fixtures/seattlerb/difficult6_.txt000066400000000000000000000000321506127434000235530ustar00rootroot00000000000000->(a, b=nil) { p [a, b] }
prism-1.5.1/test/prism/fixtures/seattlerb/difficult6__7.txt000066400000000000000000000000141506127434000240010ustar00rootroot00000000000000a.b (1) {c}
prism-1.5.1/test/prism/fixtures/seattlerb/difficult6__8.txt000066400000000000000000000000151506127434000240030ustar00rootroot00000000000000a::b (1) {c}
prism-1.5.1/test/prism/fixtures/seattlerb/difficult7_.txt000066400000000000000000000001041506127434000235540ustar00rootroot00000000000000      {
        a: lambda { b ? c() : d },
        e: nil,
      }

prism-1.5.1/test/prism/fixtures/seattlerb/do_bug.txt000066400000000000000000000000421506127434000226150ustar00rootroot00000000000000a 1
a.b do |c|
  # do nothing
end
prism-1.5.1/test/prism/fixtures/seattlerb/do_lambda.txt000066400000000000000000000000141506127434000232570ustar00rootroot00000000000000->() do end
prism-1.5.1/test/prism/fixtures/seattlerb/dot2_nil__26.txt000066400000000000000000000000041506127434000235340ustar00rootroot00000000000000a..
prism-1.5.1/test/prism/fixtures/seattlerb/dot3_nil__26.txt000066400000000000000000000000051506127434000235360ustar00rootroot00000000000000a...
prism-1.5.1/test/prism/fixtures/seattlerb/dstr_evstr.txt000066400000000000000000000000151506127434000235550ustar00rootroot00000000000000"#{'a'}#{b}"
prism-1.5.1/test/prism/fixtures/seattlerb/dstr_evstr_empty_end.txt000066400000000000000000000000141506127434000256200ustar00rootroot00000000000000:"#{field}"
prism-1.5.1/test/prism/fixtures/seattlerb/dstr_lex_state.txt000066400000000000000000000000111506127434000243760ustar00rootroot00000000000000"#{p:a}"
prism-1.5.1/test/prism/fixtures/seattlerb/dstr_str.txt000066400000000000000000000000131506127434000232200ustar00rootroot00000000000000"#{'a'} b"
prism-1.5.1/test/prism/fixtures/seattlerb/dsym_esc_to_sym.txt000066400000000000000000000000221506127434000245540ustar00rootroot00000000000000:"Variet\303\240"
prism-1.5.1/test/prism/fixtures/seattlerb/dsym_to_sym.txt000066400000000000000000000000411506127434000237230ustar00rootroot00000000000000alias :"<<" :">>"

alias :<< :>>
prism-1.5.1/test/prism/fixtures/seattlerb/eq_begin_line_numbers.txt000066400000000000000000000000401506127434000256670ustar00rootroot000000000000001
=begin
comment
comment
=end
2
prism-1.5.1/test/prism/fixtures/seattlerb/eq_begin_why_wont_people_use_their_spacebar.txt000066400000000000000000000000361506127434000323430ustar00rootroot00000000000000h[k]=begin
       42
     end
prism-1.5.1/test/prism/fixtures/seattlerb/evstr_evstr.txt000066400000000000000000000000131506127434000237420ustar00rootroot00000000000000"#{a}#{b}"
prism-1.5.1/test/prism/fixtures/seattlerb/evstr_str.txt000066400000000000000000000000111506127434000234050ustar00rootroot00000000000000"#{a} b"
prism-1.5.1/test/prism/fixtures/seattlerb/expr_not_bang.txt000066400000000000000000000000061506127434000242030ustar00rootroot00000000000000! a b
prism-1.5.1/test/prism/fixtures/seattlerb/f_kw.txt000066400000000000000000000000201506127434000223000ustar00rootroot00000000000000def x k:42; end
prism-1.5.1/test/prism/fixtures/seattlerb/f_kw__required.txt000066400000000000000000000000161506127434000243440ustar00rootroot00000000000000def x k:; end
prism-1.5.1/test/prism/fixtures/seattlerb/flip2_env_lvar.txt000066400000000000000000000000211506127434000242630ustar00rootroot00000000000000if a..b then end
prism-1.5.1/test/prism/fixtures/seattlerb/float_with_if_modifier.txt000066400000000000000000000000131506127434000260500ustar00rootroot000000000000001.0if true
prism-1.5.1/test/prism/fixtures/seattlerb/heredoc__backslash_dos_format.txt000066400000000000000000000000441506127434000273600ustar00rootroot00000000000000str = <<-XXX
before\
after
XXX

prism-1.5.1/test/prism/fixtures/seattlerb/heredoc_backslash_nl.txt000066400000000000000000000001351506127434000254760ustar00rootroot00000000000000"  why would someone do this? \
  blah
"

<<-DESC
  why would someone do this? \
  blah
DESC
prism-1.5.1/test/prism/fixtures/seattlerb/heredoc_bad_hex_escape.txt000066400000000000000000000000251506127434000257620ustar00rootroot00000000000000s = < do end

f -> {}

f ->() do end

f ->() {}
prism-1.5.1/test/prism/fixtures/seattlerb/lasgn_arg_rescue_arg.txt000066400000000000000000000000171506127434000255140ustar00rootroot00000000000000a = 1 rescue 2
prism-1.5.1/test/prism/fixtures/seattlerb/lasgn_call_bracket_rescue_arg.txt000066400000000000000000000000221506127434000273450ustar00rootroot00000000000000a = b(1) rescue 2
prism-1.5.1/test/prism/fixtures/seattlerb/lasgn_call_nobracket_rescue_arg.txt000066400000000000000000000000211506127434000277010ustar00rootroot00000000000000a = b 1 rescue 2
prism-1.5.1/test/prism/fixtures/seattlerb/lasgn_command.txt000066400000000000000000000000121506127434000241550ustar00rootroot00000000000000a = b.c 1
prism-1.5.1/test/prism/fixtures/seattlerb/lasgn_env.txt000066400000000000000000000000071506127434000233330ustar00rootroot00000000000000a = 42
prism-1.5.1/test/prism/fixtures/seattlerb/lasgn_ivar_env.txt000066400000000000000000000000101506127434000243460ustar00rootroot00000000000000@a = 42
prism-1.5.1/test/prism/fixtures/seattlerb/lasgn_lasgn_command_call.txt000066400000000000000000000000141506127434000263360ustar00rootroot00000000000000a = b = c 1
prism-1.5.1/test/prism/fixtures/seattlerb/lasgn_middle_splat.txt000066400000000000000000000000151506127434000252030ustar00rootroot00000000000000a = b, *c, d
prism-1.5.1/test/prism/fixtures/seattlerb/magic_encoding_comment.txt000066400000000000000000000001341506127434000260300ustar00rootroot00000000000000# encoding: utf-8
class ExampleUTF8ClassNameVarietà; def self.è; così = :però; end
end

prism-1.5.1/test/prism/fixtures/seattlerb/masgn_anon_splat_arg.txt000066400000000000000000000000111506127434000255260ustar00rootroot00000000000000*, a = b
prism-1.5.1/test/prism/fixtures/seattlerb/masgn_arg_colon_arg.txt000066400000000000000000000000141506127434000253360ustar00rootroot00000000000000a, b::c = d
prism-1.5.1/test/prism/fixtures/seattlerb/masgn_arg_ident.txt000066400000000000000000000000131506127434000244750ustar00rootroot00000000000000a, b.C = d
prism-1.5.1/test/prism/fixtures/seattlerb/masgn_arg_splat_arg.txt000066400000000000000000000000151506127434000253500ustar00rootroot00000000000000a, *b, c = d
prism-1.5.1/test/prism/fixtures/seattlerb/masgn_colon2.txt000066400000000000000000000000171506127434000237410ustar00rootroot00000000000000a, b::C = 1, 2
prism-1.5.1/test/prism/fixtures/seattlerb/masgn_colon3.txt000066400000000000000000000000201506127434000237340ustar00rootroot00000000000000::A, ::B = 1, 2
prism-1.5.1/test/prism/fixtures/seattlerb/masgn_command_call.txt000066400000000000000000000000131506127434000251520ustar00rootroot00000000000000a, = b.c 1
prism-1.5.1/test/prism/fixtures/seattlerb/masgn_double_paren.txt000066400000000000000000000000121506127434000251770ustar00rootroot00000000000000((a,b))=c
prism-1.5.1/test/prism/fixtures/seattlerb/masgn_lhs_splat.txt000066400000000000000000000000151506127434000245340ustar00rootroot00000000000000*a = 1, 2, 3
prism-1.5.1/test/prism/fixtures/seattlerb/masgn_paren.txt000066400000000000000000000000151506127434000236500ustar00rootroot00000000000000(a, b) = c.d
prism-1.5.1/test/prism/fixtures/seattlerb/masgn_splat_arg.txt000066400000000000000000000000121506127434000245140ustar00rootroot00000000000000*a, b = c
prism-1.5.1/test/prism/fixtures/seattlerb/masgn_splat_arg_arg.txt000066400000000000000000000000151506127434000253500ustar00rootroot00000000000000*a, b, c = d
prism-1.5.1/test/prism/fixtures/seattlerb/masgn_star.txt000066400000000000000000000000061506127434000235140ustar00rootroot00000000000000* = 1
prism-1.5.1/test/prism/fixtures/seattlerb/masgn_var_star_var.txt000066400000000000000000000000141506127434000252330ustar00rootroot00000000000000a, *, b = c
prism-1.5.1/test/prism/fixtures/seattlerb/messy_op_asgn_lineno.txt000066400000000000000000000000201506127434000255640ustar00rootroot00000000000000a (B::C *= d e)
prism-1.5.1/test/prism/fixtures/seattlerb/method_call_assoc_trailing_comma.txt000066400000000000000000000000131506127434000300640ustar00rootroot00000000000000a.f(1=>2,)
prism-1.5.1/test/prism/fixtures/seattlerb/method_call_trailing_comma.txt000066400000000000000000000000101506127434000266710ustar00rootroot00000000000000a.f(1,)
prism-1.5.1/test/prism/fixtures/seattlerb/mlhs_back_anonsplat.txt000066400000000000000000000000171506127434000253620ustar00rootroot00000000000000a, b, c, * = f
prism-1.5.1/test/prism/fixtures/seattlerb/mlhs_back_splat.txt000066400000000000000000000000201506127434000245000ustar00rootroot00000000000000a, b, c, *s = f
prism-1.5.1/test/prism/fixtures/seattlerb/mlhs_front_anonsplat.txt000066400000000000000000000000171506127434000256120ustar00rootroot00000000000000*, x, y, z = f
prism-1.5.1/test/prism/fixtures/seattlerb/mlhs_front_splat.txt000066400000000000000000000000201506127434000247300ustar00rootroot00000000000000*s, x, y, z = f
prism-1.5.1/test/prism/fixtures/seattlerb/mlhs_keyword.txt000066400000000000000000000000211506127434000240620ustar00rootroot00000000000000a.!=(true, true)
prism-1.5.1/test/prism/fixtures/seattlerb/mlhs_mid_anonsplat.txt000066400000000000000000000000301506127434000252260ustar00rootroot00000000000000a, b, c, *, x, y, z = f
prism-1.5.1/test/prism/fixtures/seattlerb/mlhs_mid_splat.txt000066400000000000000000000000311506127434000243530ustar00rootroot00000000000000a, b, c, *s, x, y, z = f
prism-1.5.1/test/prism/fixtures/seattlerb/mlhs_rescue.txt000066400000000000000000000000231506127434000236660ustar00rootroot00000000000000a, b = f rescue 42
prism-1.5.1/test/prism/fixtures/seattlerb/module_comments.txt000066400000000000000000000001161506127434000245520ustar00rootroot00000000000000# blah 1
  
  # blah 2

module X
  # blah 3
  def blah
    # blah 4
  end
end
prism-1.5.1/test/prism/fixtures/seattlerb/multiline_hash_declaration.txt000066400000000000000000000000541506127434000267330ustar00rootroot00000000000000f(state:
 {
})

f(state: {
})

f(state: {})
prism-1.5.1/test/prism/fixtures/seattlerb/non_interpolated_symbol_array_line_breaks.txt000066400000000000000000000000141506127434000320420ustar00rootroot00000000000000%i(
a
b
)
1
prism-1.5.1/test/prism/fixtures/seattlerb/non_interpolated_word_array_line_breaks.txt000066400000000000000000000000141506127434000315100ustar00rootroot00000000000000%w(
a
b
)
1
prism-1.5.1/test/prism/fixtures/seattlerb/op_asgn_command_call.txt000066400000000000000000000000141506127434000254740ustar00rootroot00000000000000a ||= b.c 2
prism-1.5.1/test/prism/fixtures/seattlerb/op_asgn_dot_ident_command_call.txt000066400000000000000000000000141506127434000275250ustar00rootroot00000000000000A.B ||= c 1
prism-1.5.1/test/prism/fixtures/seattlerb/op_asgn_index_command_call.txt000066400000000000000000000000211506127434000266610ustar00rootroot00000000000000a[:b] ||= c 1, 2
prism-1.5.1/test/prism/fixtures/seattlerb/op_asgn_primary_colon_const_command_call.txt000066400000000000000000000000141506127434000316370ustar00rootroot00000000000000A::B *= c d
prism-1.5.1/test/prism/fixtures/seattlerb/op_asgn_primary_colon_identifier1.txt000066400000000000000000000000121506127434000302210ustar00rootroot00000000000000A::b += 1
prism-1.5.1/test/prism/fixtures/seattlerb/op_asgn_primary_colon_identifier_command_call.txt000066400000000000000000000000141506127434000326330ustar00rootroot00000000000000A::b *= c d
prism-1.5.1/test/prism/fixtures/seattlerb/op_asgn_val_dot_ident_command_call.txt000066400000000000000000000000141506127434000303670ustar00rootroot00000000000000a.b ||= c 1
prism-1.5.1/test/prism/fixtures/seattlerb/parse_def_special_name.txt000066400000000000000000000000161506127434000260070ustar00rootroot00000000000000def next; end
prism-1.5.1/test/prism/fixtures/seattlerb/parse_if_not_canonical.txt000066400000000000000000000000521506127434000260360ustar00rootroot00000000000000if not var.nil? then 'foo' else 'bar'
end
prism-1.5.1/test/prism/fixtures/seattlerb/parse_if_not_noncanonical.txt000066400000000000000000000000521506127434000265510ustar00rootroot00000000000000if not var.nil? then 'foo' else 'bar'
end
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_block.txt000066400000000000000000000000131506127434000246470ustar00rootroot00000000000000a = 42
p a
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_block_inline_comment.txt000066400000000000000000000000201506127434000277250ustar00rootroot00000000000000a
b # comment
c
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_block_inline_comment_leading_newlines.txt000066400000000000000000000000451506127434000333230ustar00rootroot00000000000000


a
b # comment
# another comment
c
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_block_inline_multiline_comment.txt000066400000000000000000000000421506127434000320130ustar00rootroot00000000000000a
b # comment
# another comment
c
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_call_ivar_arg_no_parens_line_break.txt000066400000000000000000000000061506127434000325630ustar00rootroot00000000000000a @b

prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_call_ivar_line_break_paren.txt000066400000000000000000000000071506127434000310540ustar00rootroot00000000000000a(@b
)
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_call_no_args.txt000066400000000000000000000000301506127434000261770ustar00rootroot00000000000000f do |x, y|
  x + y
end
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_defn_complex.txt000066400000000000000000000000511506127434000262220ustar00rootroot00000000000000def x(y)
  p(y)
  y *= 2
  return y;
end
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_defn_no_parens.txt000066400000000000000000000000261506127434000265410ustar00rootroot00000000000000def f

end

def f
end
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_defn_no_parens_args.txt000066400000000000000000000000141506127434000275520ustar00rootroot00000000000000def f a
end
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_dot2.txt000066400000000000000000000000161506127434000244300ustar00rootroot000000000000000..
4
a..
b
c
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_dot2_open.txt000066400000000000000000000000161506127434000254510ustar00rootroot000000000000000..
; a..
; c
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_dot3.txt000066400000000000000000000000201506127434000244240ustar00rootroot000000000000000...
4
a...
b
c
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_dot3_open.txt000066400000000000000000000000201506127434000254450ustar00rootroot000000000000000...
; a...
; c
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_dstr_escaped_newline.txt000066400000000000000000000000171506127434000277420ustar00rootroot00000000000000"a\n#{
}"
true
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_dstr_soft_newline.txt000066400000000000000000000000161506127434000273100ustar00rootroot00000000000000"a
#{
}"
true
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_evstr_after_break.txt000066400000000000000000000000141506127434000272460ustar00rootroot00000000000000"a"\
"#{b}"
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_hash_lit.txt000066400000000000000000000000161506127434000253530ustar00rootroot00000000000000{
:s1 => 1,
}
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_heredoc.txt000066400000000000000000000001321506127434000251700ustar00rootroot00000000000000      string = <<-HEREDOC.strip
        very long string
      HEREDOC
      puts string

prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_heredoc_evstr.txt000066400000000000000000000000161506127434000264140ustar00rootroot00000000000000<<-A
a
#{b}
A
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_heredoc_hardnewline.txt000066400000000000000000000000621506127434000275520ustar00rootroot00000000000000<<-EOFOO
\n\n\n\n\n\n\n\n\n
EOFOO

class Foo
end

prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_heredoc_regexp_chars.txt000066400000000000000000000001141506127434000277220ustar00rootroot00000000000000      string = <<-"^D"
        very long string
      ^D
      puts string

prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_iter_call_no_parens.txt000066400000000000000000000000321506127434000275600ustar00rootroot00000000000000f a do |x, y|
  x + y
end
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_iter_call_parens.txt000066400000000000000000000000331506127434000270650ustar00rootroot00000000000000f(a) do |x, y|
  x + y
end
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_multiline_str.txt000066400000000000000000000000101506127434000264440ustar00rootroot00000000000000"a
b"
1
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_multiline_str_literal_n.txt000066400000000000000000000000111506127434000304760ustar00rootroot00000000000000"a\nb"
1
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_newlines.txt000066400000000000000000000000071506127434000254040ustar00rootroot00000000000000true


prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_op_asgn.txt000066400000000000000000000000441506127434000252070ustar00rootroot00000000000000      foo +=
        bar
      baz

prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_postexe.txt000066400000000000000000000000141506127434000252450ustar00rootroot00000000000000END {
foo
}
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_preexe.txt000066400000000000000000000000161506127434000250500ustar00rootroot00000000000000BEGIN {
foo
}
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_rescue.txt000066400000000000000000000000451506127434000250500ustar00rootroot00000000000000begin
  a
rescue
  b
rescue
  c
end

prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_return.txt000066400000000000000000000001171506127434000251010ustar00rootroot00000000000000      def blah
        if true then
          return 42
        end
      end

prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_str_with_newline_escape.txt000066400000000000000000000000161506127434000304640ustar00rootroot00000000000000a("\n", true)
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_to_ary.txt000066400000000000000000000000131506127434000250520ustar00rootroot00000000000000a,
b = c
d
prism-1.5.1/test/prism/fixtures/seattlerb/parse_line_trailing_newlines.txt000066400000000000000000000000051506127434000272730ustar00rootroot00000000000000a 
b
prism-1.5.1/test/prism/fixtures/seattlerb/parse_opt_call_args_assocs_comma.txt000066400000000000000000000000111506127434000301040ustar00rootroot000000000000001[2=>3,]
prism-1.5.1/test/prism/fixtures/seattlerb/parse_opt_call_args_lit_comma.txt000066400000000000000000000000061506127434000274050ustar00rootroot000000000000001[2,]
prism-1.5.1/test/prism/fixtures/seattlerb/parse_pattern_019.txt000066400000000000000000000000341506127434000246170ustar00rootroot00000000000000case 0
in -1..1
  true
end

prism-1.5.1/test/prism/fixtures/seattlerb/parse_pattern_044.txt000066400000000000000000000000411506127434000246130ustar00rootroot00000000000000case obj
in Object[]
  true
end

prism-1.5.1/test/prism/fixtures/seattlerb/parse_pattern_051.txt000066400000000000000000000000461506127434000246160ustar00rootroot00000000000000case [0, 1, 2]
in [0, 1,]
  true
end

prism-1.5.1/test/prism/fixtures/seattlerb/parse_pattern_058.txt000066400000000000000000000000551506127434000246250ustar00rootroot00000000000000case {a: 0}
in {a:, **rest}
  [a, rest]
end

prism-1.5.1/test/prism/fixtures/seattlerb/parse_pattern_058_2.txt000066400000000000000000000000431506127434000250430ustar00rootroot00000000000000case {a: 0}
in {a:, **}
  [a]
end

prism-1.5.1/test/prism/fixtures/seattlerb/parse_pattern_069.txt000066400000000000000000000000411506127434000246220ustar00rootroot00000000000000case :a
in Object[b: 1]
  1
end

prism-1.5.1/test/prism/fixtures/seattlerb/parse_pattern_076.txt000066400000000000000000000000511506127434000246210ustar00rootroot00000000000000case {a: 1}
in {a: 1, **nil}
  true
end

prism-1.5.1/test/prism/fixtures/seattlerb/parse_until_not_canonical.txt000066400000000000000000000000371506127434000265760ustar00rootroot00000000000000until not var.nil?
  'foo'
end
prism-1.5.1/test/prism/fixtures/seattlerb/parse_until_not_noncanonical.txt000066400000000000000000000000371506127434000273110ustar00rootroot00000000000000until not var.nil?
  'foo'
end
prism-1.5.1/test/prism/fixtures/seattlerb/parse_while_not_canonical.txt000066400000000000000000000000371506127434000265530ustar00rootroot00000000000000while not var.nil?
  'foo'
end
prism-1.5.1/test/prism/fixtures/seattlerb/parse_while_not_noncanonical.txt000066400000000000000000000000371506127434000272660ustar00rootroot00000000000000while not var.nil?
  'foo'
end
prism-1.5.1/test/prism/fixtures/seattlerb/pctW_lineno.txt000066400000000000000000000000351506127434000236410ustar00rootroot00000000000000%W(a\nb
c d
e\
f
gy h\y i\y)
prism-1.5.1/test/prism/fixtures/seattlerb/pct_Q_backslash_nl.txt000066400000000000000000000000101506127434000251230ustar00rootroot00000000000000%q{ \
}
prism-1.5.1/test/prism/fixtures/seattlerb/pct_nl.txt000066400000000000000000000000101506127434000226300ustar00rootroot00000000000000x = %


prism-1.5.1/test/prism/fixtures/seattlerb/pct_w_heredoc_interp_nested.txt000066400000000000000000000000371506127434000271120ustar00rootroot00000000000000%W( 1 #{< 1

return 1, :z => 1, :w => 2

return y :z=>1

return y z:1

return y(z:1)

return y(z=>1)
prism-1.5.1/test/prism/fixtures/seattlerb/rhs_asgn.txt000066400000000000000000000000101506127434000231550ustar00rootroot0000000000000042 => n
prism-1.5.1/test/prism/fixtures/seattlerb/ruby21_numbers.txt000066400000000000000000000000161506127434000242360ustar00rootroot00000000000000[1i, 2r, 3ri]
prism-1.5.1/test/prism/fixtures/seattlerb/safe_attrasgn.txt000066400000000000000000000000111506127434000241730ustar00rootroot00000000000000a&.b = 1
prism-1.5.1/test/prism/fixtures/seattlerb/safe_attrasgn_constant.txt000066400000000000000000000000111506127434000261040ustar00rootroot00000000000000a&.B = 1
prism-1.5.1/test/prism/fixtures/seattlerb/safe_call.txt000066400000000000000000000000051506127434000232660ustar00rootroot00000000000000a&.b
prism-1.5.1/test/prism/fixtures/seattlerb/safe_call_after_newline.txt000066400000000000000000000000061506127434000261710ustar00rootroot00000000000000a
&.b
prism-1.5.1/test/prism/fixtures/seattlerb/safe_call_dot_parens.txt000066400000000000000000000000061506127434000255050ustar00rootroot00000000000000a&.()
prism-1.5.1/test/prism/fixtures/seattlerb/safe_call_newline.txt000066400000000000000000000000061506127434000250100ustar00rootroot00000000000000a&.b

prism-1.5.1/test/prism/fixtures/seattlerb/safe_call_operator.txt000066400000000000000000000000071506127434000252030ustar00rootroot00000000000000a&.> 1
prism-1.5.1/test/prism/fixtures/seattlerb/safe_call_rhs_newline.txt000066400000000000000000000000121506127434000256610ustar00rootroot00000000000000c = a&.b

prism-1.5.1/test/prism/fixtures/seattlerb/safe_calls.txt000066400000000000000000000000131506127434000234500ustar00rootroot00000000000000a&.b&.c(1)
prism-1.5.1/test/prism/fixtures/seattlerb/safe_op_asgn.txt000066400000000000000000000000141506127434000240010ustar00rootroot00000000000000a&.b += x 1
prism-1.5.1/test/prism/fixtures/seattlerb/safe_op_asgn2.txt000066400000000000000000000000141506127434000240630ustar00rootroot00000000000000a&.b ||=
x;
prism-1.5.1/test/prism/fixtures/seattlerb/slashy_newlines_within_string.txt000066400000000000000000000000561506127434000275420ustar00rootroot00000000000000puts "hello\
 my\
 dear\
 friend"

a + b
    
prism-1.5.1/test/prism/fixtures/seattlerb/stabby_arg_no_paren.txt000066400000000000000000000000061506127434000253540ustar00rootroot00000000000000->a{}
prism-1.5.1/test/prism/fixtures/seattlerb/stabby_arg_opt_splat_arg_block_omfg.txt000066400000000000000000000000301506127434000305700ustar00rootroot00000000000000->(b, c=1, *d, e, &f){}
prism-1.5.1/test/prism/fixtures/seattlerb/stabby_block_iter_call.txt000066400000000000000000000000321506127434000260310ustar00rootroot00000000000000x -> () do
a.b do
end
end
prism-1.5.1/test/prism/fixtures/seattlerb/stabby_block_iter_call_no_target_with_arg.txt000066400000000000000000000000331506127434000317600ustar00rootroot00000000000000x -> () do
a(1) do
end
end
prism-1.5.1/test/prism/fixtures/seattlerb/stabby_block_kw.txt000066400000000000000000000000161506127434000245160ustar00rootroot00000000000000-> (k:42) { }
prism-1.5.1/test/prism/fixtures/seattlerb/stabby_block_kw__required.txt000066400000000000000000000000141506127434000265530ustar00rootroot00000000000000-> (k:) { }
prism-1.5.1/test/prism/fixtures/seattlerb/stabby_proc_scope.txt000066400000000000000000000000141506127434000250550ustar00rootroot00000000000000->(a; b) {}
prism-1.5.1/test/prism/fixtures/seattlerb/str_backslashes.txt000066400000000000000000000003151506127434000245340ustar00rootroot00000000000000x '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'
prism-1.5.1/test/prism/fixtures/seattlerb/str_double_double_escaped_newline.txt000066400000000000000000000000121506127434000302540ustar00rootroot00000000000000a "\\n";b
prism-1.5.1/test/prism/fixtures/seattlerb/str_double_escaped_newline.txt000066400000000000000000000000111506127434000267210ustar00rootroot00000000000000a "\n";b
prism-1.5.1/test/prism/fixtures/seattlerb/str_double_newline.txt000066400000000000000000000000101506127434000252340ustar00rootroot00000000000000a "
";b
prism-1.5.1/test/prism/fixtures/seattlerb/str_evstr.txt000066400000000000000000000000111506127434000234050ustar00rootroot00000000000000"a #{b}"
prism-1.5.1/test/prism/fixtures/seattlerb/str_evstr_escape.txt000066400000000000000000000000211506127434000247260ustar00rootroot00000000000000"a #{b}\302\275"
prism-1.5.1/test/prism/fixtures/seattlerb/str_heredoc_interp.txt000066400000000000000000000000221506127434000252360ustar00rootroot00000000000000<<""
#{x}
blah2


prism-1.5.1/test/prism/fixtures/seattlerb/str_interp_ternary_or_label.txt000066400000000000000000000000301506127434000271470ustar00rootroot00000000000000"#{a.b? ? ""+a+"": ""}"
prism-1.5.1/test/prism/fixtures/seattlerb/str_lit_concat_bad_encodings.txt000066400000000000000000000002041506127434000272240ustar00rootroot00000000000000"\xE3\xD3\x8B\xE3\x83\xBC\x83\xE3\x83\xE3\x82\xB3\xA3\x82\x99" \
        "\xE3\x83\xB3\xE3\x83\x8F\xE3\x82\x9A\xC3\xBD;foo@bar.com"
prism-1.5.1/test/prism/fixtures/seattlerb/str_newline_hash_line_number.txt000066400000000000000000000000161506127434000272720ustar00rootroot00000000000000"\n\n\n\n#"
1
prism-1.5.1/test/prism/fixtures/seattlerb/str_pct_Q_nested.txt000066400000000000000000000000331506127434000246560ustar00rootroot00000000000000%Q[before [#{nest}] after]
prism-1.5.1/test/prism/fixtures/seattlerb/str_pct_nested_nested.txt000066400000000000000000000000251506127434000257410ustar00rootroot00000000000000%{ { #{ "#{1}" } } }
prism-1.5.1/test/prism/fixtures/seattlerb/str_pct_q.txt000066400000000000000000000000121506127434000233510ustar00rootroot00000000000000%q{a b c}
prism-1.5.1/test/prism/fixtures/seattlerb/str_single_double_escaped_newline.txt000066400000000000000000000000121506127434000302630ustar00rootroot00000000000000a '\\n';b
prism-1.5.1/test/prism/fixtures/seattlerb/str_single_escaped_newline.txt000066400000000000000000000000111506127434000267300ustar00rootroot00000000000000a '\n';b
prism-1.5.1/test/prism/fixtures/seattlerb/str_single_newline.txt000066400000000000000000000000101506127434000252430ustar00rootroot00000000000000a '
';b
prism-1.5.1/test/prism/fixtures/seattlerb/str_str.txt000066400000000000000000000000131506127434000230540ustar00rootroot00000000000000"a #{'b'}"
prism-1.5.1/test/prism/fixtures/seattlerb/str_str_str.txt000066400000000000000000000000151506127434000237460ustar00rootroot00000000000000"a #{'b'} c"
prism-1.5.1/test/prism/fixtures/seattlerb/super_arg.txt000066400000000000000000000000111506127434000233410ustar00rootroot00000000000000super 42
prism-1.5.1/test/prism/fixtures/seattlerb/symbol_empty.txt000066400000000000000000000000041506127434000240770ustar00rootroot00000000000000:''
prism-1.5.1/test/prism/fixtures/seattlerb/symbol_list.txt000066400000000000000000000000161506127434000237170ustar00rootroot00000000000000%I[#{a} #{b}]
prism-1.5.1/test/prism/fixtures/seattlerb/symbols.txt000066400000000000000000000000121506127434000230430ustar00rootroot00000000000000%i(a b c)
prism-1.5.1/test/prism/fixtures/seattlerb/symbols_empty.txt000066400000000000000000000000051506127434000242630ustar00rootroot00000000000000%i()
prism-1.5.1/test/prism/fixtures/seattlerb/symbols_empty_space.txt000066400000000000000000000000061506127434000254370ustar00rootroot00000000000000%i( )
prism-1.5.1/test/prism/fixtures/seattlerb/symbols_interp.txt000066400000000000000000000000201506127434000244230ustar00rootroot00000000000000%i(a b#{1+1} c)
prism-1.5.1/test/prism/fixtures/seattlerb/thingy.txt000066400000000000000000000000201506127434000226540ustar00rootroot00000000000000f.(42)

f::(42)
prism-1.5.1/test/prism/fixtures/seattlerb/uminus_float.txt000066400000000000000000000000051506127434000240620ustar00rootroot00000000000000-0.0
prism-1.5.1/test/prism/fixtures/seattlerb/unary_minus.txt000066400000000000000000000000031506127434000237240ustar00rootroot00000000000000-a
prism-1.5.1/test/prism/fixtures/seattlerb/unary_plus.txt000066400000000000000000000000031506127434000235540ustar00rootroot00000000000000+a
prism-1.5.1/test/prism/fixtures/seattlerb/unary_plus_on_literal.txt000066400000000000000000000000041506127434000257650ustar00rootroot00000000000000+:a
prism-1.5.1/test/prism/fixtures/seattlerb/unary_tilde.txt000066400000000000000000000000031506127434000236720ustar00rootroot00000000000000~a
prism-1.5.1/test/prism/fixtures/seattlerb/utf8_bom.txt000066400000000000000000000000371506127434000231050ustar00rootroot00000000000000#!/usr/bin/env ruby -w
p 0

prism-1.5.1/test/prism/fixtures/seattlerb/when_splat.txt000066400000000000000000000000321506127434000235210ustar00rootroot00000000000000case a; when *b then; end
prism-1.5.1/test/prism/fixtures/seattlerb/words_interp.txt000066400000000000000000000000121506127434000240720ustar00rootroot00000000000000%W(#{1}b)
prism-1.5.1/test/prism/fixtures/single_method_call_with_bang.txt000066400000000000000000000000051506127434000252260ustar00rootroot00000000000000foo!
prism-1.5.1/test/prism/fixtures/single_quote_heredocs.txt000066400000000000000000000000601506127434000237430ustar00rootroot00000000000000<<-'EOS'
    cd L:\Work\MG3710IQPro\Develop
EOS
prism-1.5.1/test/prism/fixtures/spanning_heredoc.txt000066400000000000000000000017771506127434000227170ustar00rootroot00000000000000# test regex, string, and lists that span a heredoc thanks to an escaped newline

# ripper incorrectly creates a "b\nb" token instead of two separate string tokens
pp <<-A.gsub(/b\
a
A
b/, "")

# ripper incorrectly creates a "d\nd" token instead of two separate string tokens
pp <<-A, "d\
c
A
d"

# ripper gets this right
pp <<-A, %q[f\
e
A
f]

# ripper incorrectly creates a "h\nh" token instead of two separate string tokens
pp <<-A, %Q[h\
g
A
h]

# ripper can't parse this successfully, though ruby runs it correctly
pp <<-A, %w[j\
i
A
j]

# ripper can't parse this successfully, though ruby runs it correctly
# TODO: prism does not include the "\n" in "l\nl" in the AST like ruby does
pp <<-A, %W[l\
k
A
l]

# ripper can't parse this successfully, though ruby runs it correctly
pp <<-A, %i[n\
m
A
n]

# ripper gets this one wrong in the same way that prism does ...
# TODO: prism does not include the "\n" in "p\np" in the AST like ruby does
pp <<-A, %I[p\
o
A
p]

<)/ =~ ''

<=

:>>

:>

:<=>

:<=

:<<

:<

:__LINE__

:__FILE__

:__ENCODING__
prism-1.5.1/test/prism/fixtures/ternary_operator.txt000066400000000000000000000002041506127434000227700ustar00rootroot00000000000000a ? b : c

a ? defined? b : defined? c

empty??true:nil

empty??false:nil

empty??nil:nil

a??nil:nil

a ?var1 : var2

nil??_a =2:1
prism-1.5.1/test/prism/fixtures/tilde_heredocs.txt000066400000000000000000000006341506127434000223550ustar00rootroot00000000000000<<~EOF
  a
#{1}
  a
EOF

<<~EOF
  a
EOF

<<~EOF
	a
  b
		c
EOF

<<~EOF
  #{1} a
EOF

<<~EOF
  a #{1}
EOF

<<~EOF
  a
 #{1}
EOF

<<~EOF
  a
  #{1}
EOF

<<~EOF
  a
  b
EOF

<<~EOF
  a
   b
EOF

<<~EOF
			a
		b
EOF

<<~'EOF'
  a #{1}
EOF

<<~EOF
	a
	 b
EOF

<<~EOF
	 a
	b
EOF

<<~EOF
  	a
        b
EOF

<<~EOF
  a

  b
EOF

<<~EOF
  a

  b
EOF

<<~EOF
  a



  b
EOF

<<~EOF

  #{1}a
    EOF

<<~EOT
  #{1}
	b
EOT
prism-1.5.1/test/prism/fixtures/undef.txt000066400000000000000000000001651506127434000205000ustar00rootroot00000000000000undef a

undef a, b

undef if

undef <=>

undef :a

undef :a, :b, :c

undef :'abc'

undef :"abc#{1}"

undef Constant
prism-1.5.1/test/prism/fixtures/unescaping.txt000066400000000000000000000000671506127434000215340ustar00rootroot00000000000000["\c#{1}"]

/\c#{1}/

"\c#{1}"

<<~HERE
   \c#{1}
HERE
prism-1.5.1/test/prism/fixtures/unless.txt000066400000000000000000000002361506127434000207070ustar00rootroot00000000000000unless true; 1; end

unless true
1 else 2 end

1 unless true

tap { break unless true }

tap { next unless true }

return unless true

foo :a, :b unless bar?
prism-1.5.1/test/prism/fixtures/unparser/000077500000000000000000000000001506127434000204735ustar00rootroot00000000000000prism-1.5.1/test/prism/fixtures/unparser/LICENSE000066400000000000000000000020411506127434000214750ustar00rootroot00000000000000Copyright (c) 2013 Markus Schirp

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
prism-1.5.1/test/prism/fixtures/unparser/corpus/000077500000000000000000000000001506127434000220065ustar00rootroot00000000000000prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/000077500000000000000000000000001506127434000234425ustar00rootroot00000000000000prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/alias.txt000066400000000000000000000000401506127434000252660ustar00rootroot00000000000000alias $foo $bar
alias :foo :bar
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/assignment.txt000066400000000000000000000013171506127434000263550ustar00rootroot00000000000000$a = 1
($a, $b) = [1, 2]
((a,), b) = 1
(*a) = []
(*foo) = [1, 2]
(@@a, @@b) = [1, 2]
(@a, @b) = [1, 2]
(a, (b, c)) = [1, [2, 3]]
(a, *) = [1, 2]
(a, *foo) = [1, 2]
(a, b) = [1, 2]
(a, b) = foo
(a,) = foo
(a.foo, a.bar) = [1, 2]
(a[*foo], a[1]) = [1, 2]
(a[0], a[1]) = [1, 2]
(*c.foo) = 1
::Foo = ::Bar
@@a = 1
@a = 1
CONST = 1
Name::Spaced::CONST = 1
a = ((b, c) = 1)
a = 1
foo = foo()
foo.[]=()
foo.[]=(1, 2)
foo.[]=true
foo[*index] = value
foo[1..2] = value
foo[] = 1
foo[a, b] = value
foo[index] = value
x = %()
x.x=%()
x[%()] = bar
a[%()] ||= bar
@a ||= %()
x = <<-HEREDOC
  #{}
HEREDOC
x.x=<<-HEREDOC
  #{}
HEREDOC
x[] = <<-HEREDOC
  #{}
HEREDOC
a[<<-HEREDOC] ||= bar
  #{}
HEREDOC
@a ||= <<-HEREDOC
  #{}
HEREDOC
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/block.txt000066400000000000000000000013421506127434000252750ustar00rootroot00000000000000foo {
}
foo { |a|
}
foo { |a,|
}
foo { |a,; x|
}
foo { |a, b|
}
foo(1) {
  nil
}
foo { |a, *b|
  nil
}
foo { |a, *|
  nil
}
foo {
  bar
}
foo.bar { |(a, b), c|
  d
}
foo.bar { |*a; b|
}
foo.bar { |a; b|
}
foo.bar { |; a, b|
}
foo.bar { |*|
  d
}
foo.bar { |(*)|
  d
}
foo.bar { |((*))|
  d
}
foo.bar { |(a, (*))|
  d
}
foo.bar { |(a, b)|
  d
}
foo.bar {
}.baz
m do
rescue Exception => e
end
m do
  foo
rescue Exception => bar
  bar
end
m do
  bar
rescue SomeError, *bar
  baz
end
m do
  bar
rescue SomeError, *bar => exception
  baz
end
m do
  bar
rescue *bar
  baz
end
m do
  bar
rescue LoadError
end
m do
  bar
rescue
else
  baz
end
m do
  bar
rescue *bar => exception
  baz
end
m do
ensure
end
m do
rescue
ensure
end
bar {
  _1 + _2
}
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/case.txt000066400000000000000000000004351506127434000251200ustar00rootroot00000000000000case
when bar
  baz
when baz
  bar
end
case foo
when bar
when baz
  bar
end
case foo
when bar
  baz
when baz
  bar
end
case foo
when bar, baz
  :other
end
case foo
when *bar
  :value
end
case foo
when bar
  baz
else
  :foo
end
case foo
when *bar | baz
end
case foo
when *bar.baz=1
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/class.txt000066400000000000000000000003261506127434000253110ustar00rootroot00000000000000class A
end

class << a
end

class << a
  b
end

class A::B
end

class A::B::C
end

class A < B
end

class A < B::C
end

class A::B < C::D
end

class A
  include(B.new)

  def foo
    :bar
  end
end

class ::A
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/def.txt000066400000000000000000000016221506127434000247420ustar00rootroot00000000000000def foo
  a
rescue
  b
else
  c
ensure
  d
end

def foo
  a rescue b
rescue
  b
else
  c
ensure
  d
end

def foo(bar:, baz:)
end

def foo
end

def foo
  bar
end

def foo
  foo
rescue
  bar
ensure
  baz
end

def foo
  bar
ensure
  baz
end

def foo
  bar
rescue
  baz
end

def foo(bar)
  bar
end

def foo(bar, baz)
  bar
end

def foo(bar = ())
  bar
end

def foo(bar = (baz; nil))
end

def foo(bar = true)
  bar
end

def foo(bar, baz = true)
  bar
end

def foo(bar: 1)
end

def foo(bar: baz)
end

def foo(bar: bar())
end

def foo(*)
  bar
end

def foo(*bar)
  bar
end

def foo(bar, *baz)
  bar
end

def foo(baz = true, *bor)
  bar
end

def foo(baz = true, *bor, &block)
  bar
end

def foo(bar, baz = true, *bor)
  bar
end

def foo(&block)
  bar
end

def foo(bar, &block)
  bar
end

def foo
  bar
  baz
end

def f(((a)))
end

def foo(bar:, baz: "value")
end

def f
  <<-HEREDOC
    #{}
  HEREDOC
end

def f
  %()
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/defined.txt000066400000000000000000000000711506127434000255770ustar00rootroot00000000000000defined?(@foo)
defined?(Foo)
defined?(((a, b) = [1, 2]))
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/defs.txt000066400000000000000000000004131506127434000251220ustar00rootroot00000000000000def self.foo
end

def self.foo
  bar
end

def self.foo
  bar
  baz
end

def Foo.bar
  bar
end

def (foo { |bar|
}).bar
  bar
end

def (foo(1)).bar
  bar
end

def (Foo::Bar.baz).bar
  baz
end

def (Foo::Bar).bar
  baz
end

def Foo.bar
  baz
end

def foo.bar
  baz
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/dstr.txt000066400000000000000000000004541506127434000251620ustar00rootroot00000000000000if true
  "#{}a"
end
if true
  <<-HEREDOC
a
#{}a
b
  HEREDOC
  x
end
<<-HEREDOC
\#{}\#{}
#{}
#{}
#{}
HEREDOC
<<-HEREDOC rescue nil
#{}
a
HEREDOC
"a#$1"
"a#$a"
"a#@a"
"a#@@a"
if true
  return <<-HEREDOC
    #{42}
  HEREDOC
end
foo(<<-HEREDOC)
  #{bar}
HEREDOC
foo(<<-HEREDOC) { |x|
  #{bar}
HEREDOC
}
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/empty.txt000066400000000000000000000000001506127434000253270ustar00rootroot00000000000000prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/empty_begin.txt000066400000000000000000000000031506127434000264760ustar00rootroot00000000000000()
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/flipflop.txt000066400000000000000000000001401506127434000260110ustar00rootroot00000000000000if ((i == 4)..(i == 4))
  foo
end
if ((i == 4)...(i == 4))
  foo
end
if ..foo
end
if foo..;
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/for.txt000066400000000000000000000001701506127434000247670ustar00rootroot00000000000000bar(for a in bar do
  baz
end)
for a in bar do
  baz
end
for (a, *b) in bar do
  baz
end
for (a, b) in bar do
  baz
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/hookexe.txt000066400000000000000000000000421506127434000256410ustar00rootroot00000000000000BEGIN {
  foo
}
bar
END {
  baz
}
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/if.txt000066400000000000000000000003671506127434000246070ustar00rootroot00000000000000if /foo/
  bar
end
if 3
  9
end
if 4
  5
else
  6
end
unless 3
  nil
end
unless 3
  9
end
if foo
end

module A
  foo = bar if foo
end

module B
  foo = bar unless foo
end
unless foo
  foo = bar
end
if foo { |pair|
  pair
}
  pair = :foo
  foo
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/kwbegin.txt000066400000000000000000000010231506127434000256250ustar00rootroot00000000000000begin
rescue
end

begin
ensure
end

begin
  a
end

begin
  a
rescue
  b
end

begin
  a
  b
rescue
  b
end

begin
rescue A
end

begin
rescue A => foo
end

begin
  a
rescue A
  b
rescue B
  c
ensure
  d
end

begin
  begin
    foo
    bar
  rescue
  end
rescue
  baz
  bar
end

begin
  raise(Exception) rescue foo = bar
rescue Exception
end

begin
  foo
rescue => bar
  bar
end

begin
  foo
rescue Exception, Other => bar
  bar
end

begin
  bar
rescue SomeError, *bar => exception
  baz
end

class << self
  undef :bar rescue nil
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/lambda.txt000066400000000000000000000001211506127434000254150ustar00rootroot00000000000000lambda {
}
lambda { |a, b|
  a
}
->() {
}
->(a) {
}
->(a, b) {
}
->(a, b; c) {
}
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/literal.txt000066400000000000000000000016251506127434000256430ustar00rootroot00000000000000{ "foo" => <<-HEREDOC, "bar" => :baz }
  #{}
HEREDOC
{ "foo" => %(), "bar" => :baz }
["foo", %()]
a(<<-HEREDOC).a
  #{}
HEREDOC
a(%()).a
{ "foo" => <<-HEREDOC, **baz }
  #{}
HEREDOC
{ "foo" => %(), **baz }
"#@a #@@a #$a"
0
++1
1
1
1r
1.5r
1.3r
5i
-5i
0.6i
-0.6i
1000000000000000000000000000000i
1ri
"foo" "bar"
"foobar #{baz}"
"foo#{1}bar"
"\\\\#{}"
"#{}\#{}"
"\#{}#{}"
"foo\\\#{@bar}"
"\""
"foo bar"
"foo\nbar"
`foo`
`foo#{@bar}`
`)`
`\``
`"`
:foo
:"A B"
:foo
:"A B"
:"A\"B"
:""
/foo/
/[^-+',.\/:@[:alnum:]\[\]]+/
/foo#{@bar}/
/foo#{@bar}/imx
/#{"\u0000"}/
/\n/
/\n/
/\n/x
/\/\//x
:"foo#{bar}baz"
:"#{"foo"}"
(0.0 / 0.0)..1
1..(0.0 / 0.0)
(0.0 / 0.0)..100
-0.1
0.1
[1, 2]
[1, (), n2]
[1]
[]
[1, *@foo]
[*@foo, 1]
[*@foo, *@baz]
{}
{ () => () }
{ 1 => 2 }
{ 1 => 2, 3 => 4 }
{ a: (1 rescue foo), b: 2 }
{ a: 1, b: 2 }
{ a: :a }
{ :"a b" => 1 }
{ :-@ => 1 }
"#{}
#{}\na"
foo {
  "#{}
#{}\na"
}
:"a\\
b"
`  x
#{foo}
#`
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/module.txt000066400000000000000000000001531506127434000254670ustar00rootroot00000000000000module A
end

module A::B
end

module A::B::C
end

module A
  include(B.new)

  def foo
    :bar
  end
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/opasgn.txt000066400000000000000000000003521506127434000254720ustar00rootroot00000000000000a += 2
a -= 2
a **= 2
a *= 2
a /= 2
a &&= b
a ||= 2
(a ||= 2).bar
(h ||= {})[k] = v
a.b += 2
a.b -= 2
a.b **= 2
a.b *= 2
a.b /= 2
a.b &&= b
a.b ||= 2
a[b] += 2
a[b] -= 2
a[b] **= 2
a[b] *= 2
a[b] /= 2
a[b] &&= b
a[b] ||= 2
foo.A += 1
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/pattern.txt000066400000000000000000000006311506127434000256600ustar00rootroot00000000000000case foo
in A[1, 2, *a, 3] then
  true
in [1, 2, ] then
  y
in A(x:) then
  true
in {**a} then
  true
in {} if true then
  true
in [x, y, *] then
  true
in {a: 1, aa: 2} then
  true
in {} then
  true
in {**nil} then
  true
in {"a": 1} then
  true
in 1 | 2 then
  true
in 1 => a then
  true
in ^x then
  true
in 1
in 2 then
  true
else
  true
end
case foo
in A[1, 2, *a, 3]
end
case foo
in A
else
end
1 in [a]
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/pragma.txt000066400000000000000000000000471506127434000254530ustar00rootroot00000000000000__ENCODING__
__FILE__
__LINE__
__dir__
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/range.txt000066400000000000000000000000301506127434000252700ustar00rootroot00000000000000(1..)
1..2
(1...)
1...2
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/rescue.txt000066400000000000000000000001011506127434000254610ustar00rootroot00000000000000foo rescue bar
foo rescue return bar
x = (foo rescue return bar)
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/send.txt000066400000000000000000000017501506127434000251370ustar00rootroot00000000000000module A
  foo ||= ((a, _) = b)
end

module A
  local = 1
  local.bar
end
class A
end.bar
module A
end.bar
begin
rescue
end.bar
case (def foo
end; :bar)
when bar
end.baz
case foo
when bar
end.baz
class << self
end.bar
def self.foo
end.bar
def foo
end.bar
until foo
end.bar
while foo
end.bar
loop {
}.bar
if foo
end.baz
(/bar/ =~ :foo).foo
(1..2).max
(foo =~ /bar/).foo
/bar/ =~ :foo
/bar/ =~ foo
1..2.max
A.foo
FOO()
a&.b
a.foo
foo
foo << (bar * baz)
foo =~ /bar/
foo(&(foo || bar))
foo(&block)
foo(*args, &block)
foo(*arguments)
foo(1, 2)
foo(bar)
foo(bar, *args)
foo(foo =~ /bar/)
foo.bar(&baz)
foo.bar(*arga, foo, *argb)
foo.bar(*args)
foo.bar(*args, foo)
foo.bar(:baz, &baz)
foo.bar(baz: boz)
foo.bar(foo, "baz" => boz)
foo.bar(foo, *args)
foo.bar(foo, *args, &block)
foo.bar(foo, {})
foo.bar({ foo: boz }, boz)
foo.bar=:baz
foo(a: b)
foo.&(a: b)
foo.&(**a)
foo[*baz]
foo[1, 2]
foo[]
self.foo
self.foo=:bar
(a + b) / (c - d)
(a + b) / c.-(e, f)
(a + b) / c.-(*f)
x(**foo)
foo&.!
foo.~(b)
a&.+(b)
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/since/000077500000000000000000000000001506127434000245435ustar00rootroot00000000000000prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/since/27.txt000066400000000000000000000000271506127434000255330ustar00rootroot00000000000000-> {
  _1 + _2
}
(..1)
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/since/30.txt000066400000000000000000000000641506127434000255260ustar00rootroot000000000000001 => [a]
1 => [*]
1 in [*, 42, *]
1 in [*, a, *foo]
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/since/31.txt000066400000000000000000000000641506127434000255270ustar00rootroot00000000000000def foo(&)
  bar(&)
end

def foo(a, &)
  bar(&)
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/since/32.txt000066400000000000000000000002011506127434000255210ustar00rootroot00000000000000def foo(argument, **)
  bar(argument, **)
end

def foo(argument, *)
  bar(argument, *)
end

def foo(**)
  { default: 1, ** }
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/singletons.txt000066400000000000000000000000241506127434000263640ustar00rootroot00000000000000false
nil
self
true
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/super.txt000066400000000000000000000002401506127434000253350ustar00rootroot00000000000000super
super()
super(a)
super(a, b)
super(&block)
super(a, &block)
super(a {
  foo
})
super {
  foo
}
super(a) {
  foo
}
super() {
  foo
}
super(a, b) {
  foo
}
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/unary.txt000066400000000000000000000001011506127434000253310ustar00rootroot00000000000000!1
!(!1)
!(!(foo || bar))
!(!1).baz
~a
-a
+a
-(-a).foo
+(+a).foo
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/undef.txt000066400000000000000000000000341506127434000253010ustar00rootroot00000000000000undef :foo
undef :foo, :bar
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/variables.txt000066400000000000000000000001031506127434000261450ustar00rootroot00000000000000a
@a
@@a
$a
$1
$`
CONST
SCOPED::CONST
::TOPLEVEL
::TOPLEVEL::CONST
prism-1.5.1/test/prism/fixtures/unparser/corpus/literal/while.txt000066400000000000000000000011551506127434000253150ustar00rootroot00000000000000module A
  foo { |bar|
    while foo
      foo = bar
    end
  }
end

def foo
  foo = bar while foo != baz
end

module A
  foo = bar while foo
end

module A
  foo = bar until foo
end

module A
  while foo
    foo = bar
  end
end

module A
  each { |baz|
    while foo
      foo = bar
    end
  }
end

module A
  each { |foo|
    while foo
      foo = bar
    end
  }
end
x = (begin
  foo
end while baz)
begin
  foo
end while baz
begin
  foo
  bar
end until baz
begin
  foo
  bar
end while baz
while false
end
while false
  3
end
while (foo {
})
  :body
end
until false
end
until false
  3
end
until (foo {
})
  :body
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/semantic/000077500000000000000000000000001506127434000236115ustar00rootroot00000000000000prism-1.5.1/test/prism/fixtures/unparser/corpus/semantic/and.txt000066400000000000000000000001161506127434000251120ustar00rootroot00000000000000a...b or c...d
a...b and c...d

if a...b or c...d
end

if a...b and c...d
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/semantic/block.txt000066400000000000000000000002251506127434000254430ustar00rootroot00000000000000foo do
end

foo do
rescue
end

foo do
  nil rescue nil
  nil
end

foo do |a|
end

foo(<<-DOC) do |a|
  b
DOC
  a
end

foo(<<-DOC) do
  b
DOC
  a
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/semantic/def.txt000066400000000000000000000000701506127434000251050ustar00rootroot00000000000000def foo
  (a - b)
end

def foo
  a rescue Exception
end
prism-1.5.1/test/prism/fixtures/unparser/corpus/semantic/dstr.txt000066400000000000000000000011411506127434000253230ustar00rootroot00000000000000<

Parts of the source are derived from ruby_parser:
Copyright (c) Ryan Davis, seattle.rb

MIT License

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
prism-1.5.1/test/prism/fixtures/whitequark/__ENCODING__.txt000066400000000000000000000000151506127434000235370ustar00rootroot00000000000000__ENCODING__
prism-1.5.1/test/prism/fixtures/whitequark/__ENCODING___legacy_.txt000066400000000000000000000000151506127434000252220ustar00rootroot00000000000000__ENCODING__
prism-1.5.1/test/prism/fixtures/whitequark/alias.txt000066400000000000000000000000171506127434000226500ustar00rootroot00000000000000alias :foo bar
prism-1.5.1/test/prism/fixtures/whitequark/alias_gvar.txt000066400000000000000000000000311506127434000236630ustar00rootroot00000000000000alias $a $+

alias $a $b
prism-1.5.1/test/prism/fixtures/whitequark/ambiuous_quoted_label_in_ternary_operator.txt000066400000000000000000000000201506127434000322620ustar00rootroot00000000000000a ? b & '': nil
prism-1.5.1/test/prism/fixtures/whitequark/and.txt000066400000000000000000000000301506127434000223140ustar00rootroot00000000000000foo && bar

foo and bar
prism-1.5.1/test/prism/fixtures/whitequark/and_asgn.txt000066400000000000000000000000351506127434000233310ustar00rootroot00000000000000foo.a &&= 1

foo[0, 1] &&= 2
prism-1.5.1/test/prism/fixtures/whitequark/and_or_masgn.txt000066400000000000000000000000511506127434000242040ustar00rootroot00000000000000foo && (a, b = bar)

foo || (a, b = bar)
prism-1.5.1/test/prism/fixtures/whitequark/anonymous_blockarg.txt000066400000000000000000000000301506127434000254460ustar00rootroot00000000000000def foo(&); bar(&); end
prism-1.5.1/test/prism/fixtures/whitequark/arg.txt000066400000000000000000000000461506127434000223320ustar00rootroot00000000000000def f(foo); end

def f(foo, bar); end
prism-1.5.1/test/prism/fixtures/whitequark/arg_combinations.txt000066400000000000000000000005151506127434000251000ustar00rootroot00000000000000def f &b; end

def f *r, &b; end

def f *r, p, &b; end

def f ; end

def f a, &b; end

def f a, *r, &b; end

def f a, *r, p, &b; end

def f a, o=1, &b; end

def f a, o=1, *r, &b; end

def f a, o=1, *r, p, &b; end

def f a, o=1, p, &b; end

def f o=1, &b; end

def f o=1, *r, &b; end

def f o=1, *r, p, &b; end

def f o=1, p, &b; end
prism-1.5.1/test/prism/fixtures/whitequark/arg_duplicate_ignored.txt000066400000000000000000000000511506127434000260670ustar00rootroot00000000000000def foo(_, _); end

def foo(_a, _a); end
prism-1.5.1/test/prism/fixtures/whitequark/arg_label.txt000066400000000000000000000000621506127434000234670ustar00rootroot00000000000000def foo
 a:b end

def foo() a:b end

f { || a:b }
prism-1.5.1/test/prism/fixtures/whitequark/arg_scope.txt000066400000000000000000000000161506127434000235200ustar00rootroot00000000000000lambda{|;a|a}
prism-1.5.1/test/prism/fixtures/whitequark/args.txt000066400000000000000000000012631506127434000225170ustar00rootroot00000000000000def f &b; end

def f (((a))); end

def f ((*)); end

def f ((*, p)); end

def f ((*r)); end

def f ((*r, p)); end

def f ((a, *)); end

def f ((a, *, p)); end

def f ((a, *r)); end

def f ((a, *r, p)); end

def f ((a, a1)); end

def f (foo: 1, &b); end

def f (foo: 1, bar: 2, **baz, &b); end

def f **baz, &b; end

def f *, **; end

def f *r, &b; end

def f *r, p, &b; end

def f ; end

def f a, &b; end

def f a, *r, &b; end

def f a, *r, p, &b; end

def f a, o=1, &b; end

def f a, o=1, *r, &b; end

def f a, o=1, *r, p, &b; end

def f a, o=1, p, &b; end

def f foo:
; end

def f foo: -1
; end

def f o=1, &b; end

def f o=1, *r, &b; end

def f o=1, *r, p, &b; end

def f o=1, p, &b; end
prism-1.5.1/test/prism/fixtures/whitequark/args_args_assocs.txt000066400000000000000000000000571506127434000251060ustar00rootroot00000000000000fun(foo, :foo => 1)

fun(foo, :foo => 1, &baz)
prism-1.5.1/test/prism/fixtures/whitequark/args_args_assocs_comma.txt000066400000000000000000000000251506127434000262550ustar00rootroot00000000000000foo[bar, :baz => 1,]
prism-1.5.1/test/prism/fixtures/whitequark/args_args_comma.txt000066400000000000000000000000121506127434000246760ustar00rootroot00000000000000foo[bar,]
prism-1.5.1/test/prism/fixtures/whitequark/args_args_star.txt000066400000000000000000000000451506127434000245610ustar00rootroot00000000000000fun(foo, *bar)

fun(foo, *bar, &baz)
prism-1.5.1/test/prism/fixtures/whitequark/args_assocs_comma.txt000066400000000000000000000000201506127434000252340ustar00rootroot00000000000000foo[:baz => 1,]
prism-1.5.1/test/prism/fixtures/whitequark/args_block_pass.txt000066400000000000000000000000121506127434000247060ustar00rootroot00000000000000fun(&bar)
prism-1.5.1/test/prism/fixtures/whitequark/args_cmd.txt000066400000000000000000000000131506127434000233320ustar00rootroot00000000000000fun(f bar)
prism-1.5.1/test/prism/fixtures/whitequark/args_star.txt000066400000000000000000000000331506127434000235420ustar00rootroot00000000000000fun(*bar)

fun(*bar, &baz)
prism-1.5.1/test/prism/fixtures/whitequark/array_assocs.txt000066400000000000000000000000321506127434000242450ustar00rootroot00000000000000[ 1 => 2 ]

[ 1, 2 => 3 ]
prism-1.5.1/test/prism/fixtures/whitequark/array_plain.txt000066400000000000000000000000071506127434000240570ustar00rootroot00000000000000[1, 2]
prism-1.5.1/test/prism/fixtures/whitequark/array_splat.txt000066400000000000000000000000401506127434000240740ustar00rootroot00000000000000[*foo]

[1, *foo, 2]

[1, *foo]
prism-1.5.1/test/prism/fixtures/whitequark/array_symbols.txt000066400000000000000000000000141506127434000244420ustar00rootroot00000000000000%i[foo bar]
prism-1.5.1/test/prism/fixtures/whitequark/array_symbols_empty.txt000066400000000000000000000000131506127434000256570ustar00rootroot00000000000000%I()

%i[]
prism-1.5.1/test/prism/fixtures/whitequark/array_symbols_interp.txt000066400000000000000000000000361506127434000260270ustar00rootroot00000000000000%I[foo #{bar}]

%I[foo#{bar}]
prism-1.5.1/test/prism/fixtures/whitequark/array_words.txt000066400000000000000000000000141506127434000241100ustar00rootroot00000000000000%w[foo bar]
prism-1.5.1/test/prism/fixtures/whitequark/array_words_empty.txt000066400000000000000000000000131506127434000253250ustar00rootroot00000000000000%W()

%w[]
prism-1.5.1/test/prism/fixtures/whitequark/array_words_interp.txt000066400000000000000000000000471506127434000254770ustar00rootroot00000000000000%W[foo #{bar}]

%W[foo #{bar}foo#@baz]
prism-1.5.1/test/prism/fixtures/whitequark/asgn_cmd.txt000066400000000000000000000000371506127434000233340ustar00rootroot00000000000000foo = bar = m foo

foo = m foo
prism-1.5.1/test/prism/fixtures/whitequark/asgn_mrhs.txt000066400000000000000000000000521506127434000235370ustar00rootroot00000000000000foo = *bar

foo = bar, 1

foo = baz, *bar
prism-1.5.1/test/prism/fixtures/whitequark/back_ref.txt000066400000000000000000000000031506127434000233060ustar00rootroot00000000000000$+
prism-1.5.1/test/prism/fixtures/whitequark/bang.txt000066400000000000000000000000051506127434000224630ustar00rootroot00000000000000!foo
prism-1.5.1/test/prism/fixtures/whitequark/bang_cmd.txt000066400000000000000000000000071506127434000233100ustar00rootroot00000000000000!m foo
prism-1.5.1/test/prism/fixtures/whitequark/begin_cmdarg.txt000066400000000000000000000000351506127434000241600ustar00rootroot00000000000000p begin 1.times do 1 end end
prism-1.5.1/test/prism/fixtures/whitequark/beginless_erange_after_newline.txt000066400000000000000000000000131506127434000277510ustar00rootroot00000000000000foo
...100
prism-1.5.1/test/prism/fixtures/whitequark/beginless_irange_after_newline.txt000066400000000000000000000000121506127434000277540ustar00rootroot00000000000000foo
..100
prism-1.5.1/test/prism/fixtures/whitequark/beginless_range.txt000066400000000000000000000000161506127434000247050ustar00rootroot00000000000000...100

..100
prism-1.5.1/test/prism/fixtures/whitequark/block_arg_combinations.txt000066400000000000000000000006611506127434000262540ustar00rootroot00000000000000f{  }

f{ | | }

f{ |&b| }

f{ |*, &b| }

f{ |*r, p, &b| }

f{ |*s, &b| }

f{ |*s| }

f{ |*| }

f{ |;
a
| }

f{ |;a| }

f{ |a, &b| }

f{ |a, *, &b| }

f{ |a, *r, p, &b| }

f{ |a, *s, &b| }

f{ |a, *s| }

f{ |a, *| }

f{ |a, c| }

f{ |a, o=1, &b| }

f{ |a, o=1, *r, p, &b| }

f{ |a, o=1, o1=2, *r, &b| }

f{ |a, o=1, p, &b| }

f{ |a,| }

f{ |a| }

f{ |o=1, &b| }

f{ |o=1, *r, &b| }

f{ |o=1, *r, p, &b| }

f{ |o=1, p, &b| }

f{ || }
prism-1.5.1/test/prism/fixtures/whitequark/block_kwarg.txt000066400000000000000000000000141506127434000240410ustar00rootroot00000000000000f{ |foo:| }
prism-1.5.1/test/prism/fixtures/whitequark/block_kwarg_combinations.txt000066400000000000000000000001061506127434000266100ustar00rootroot00000000000000f{ |**baz, &b| }

f{ |foo: 1, &b| }

f{ |foo: 1, bar: 2, **baz, &b| }
prism-1.5.1/test/prism/fixtures/whitequark/blockarg.txt000066400000000000000000000000231506127434000233400ustar00rootroot00000000000000def f(&block); end
prism-1.5.1/test/prism/fixtures/whitequark/blockargs.txt000066400000000000000000000010471506127434000235320ustar00rootroot00000000000000f{  }

f{ | | }

f{ |&b| }

f{ |**baz, &b| }

f{ |*, &b| }

f{ |*r, p, &b| }

f{ |*s, &b| }

f{ |*s| }

f{ |*| }

f{ |;
a
| }

f{ |;a| }

f{ |a, &b| }

f{ |a, *, &b| }

f{ |a, *r, p, &b| }

f{ |a, *s, &b| }

f{ |a, *s| }

f{ |a, *| }

f{ |a, b,| }

f{ |a, c| }

f{ |a, o=1, &b| }

f{ |a, o=1, *r, p, &b| }

f{ |a, o=1, o1=2, *r, &b| }

f{ |a, o=1, p, &b| }

f{ |a,| }

f{ |a| }

f{ |a| }

f{ |a| }

f{ |foo: 1, &b| }

f{ |foo: 1, bar: 2, **baz, &b| }

f{ |foo:| }

f{ |o=1, &b| }

f{ |o=1, *r, &b| }

f{ |o=1, *r, p, &b| }

f{ |o=1, p, &b| }

f{ || }
prism-1.5.1/test/prism/fixtures/whitequark/bug_435.txt000066400000000000000000000000171506127434000227270ustar00rootroot00000000000000"#{-> foo {}}"
prism-1.5.1/test/prism/fixtures/whitequark/bug_447.txt000066400000000000000000000000341506127434000227310ustar00rootroot00000000000000m [] do end

m [], 1 do end
prism-1.5.1/test/prism/fixtures/whitequark/bug_452.txt000066400000000000000000000000461506127434000227300ustar00rootroot00000000000000td (1_500).toString(); td.num do; end
prism-1.5.1/test/prism/fixtures/whitequark/bug_466.txt000066400000000000000000000000341506127434000227320ustar00rootroot00000000000000foo "#{(1+1).to_i}" do; end
prism-1.5.1/test/prism/fixtures/whitequark/bug_473.txt000066400000000000000000000000121506127434000227240ustar00rootroot00000000000000m "#{[]}"
prism-1.5.1/test/prism/fixtures/whitequark/bug_480.txt000066400000000000000000000000151506127434000227250ustar00rootroot00000000000000m "#{}#{()}"
prism-1.5.1/test/prism/fixtures/whitequark/bug_481.txt000066400000000000000000000000351506127434000227300ustar00rootroot00000000000000m def x(); end; 1.tap do end
prism-1.5.1/test/prism/fixtures/whitequark/bug_ascii_8bit_in_literal.txt000066400000000000000000000001331506127434000266330ustar00rootroot00000000000000# coding:utf-8
         "\xD0\xBF\xD1\x80\xD0\xBE\xD0\xB2\xD0\xB5\xD1\x80\xD0\xBA\xD0\xB0"
prism-1.5.1/test/prism/fixtures/whitequark/bug_cmd_string_lookahead.txt000066400000000000000000000000221506127434000265500ustar00rootroot00000000000000desc "foo" do end
prism-1.5.1/test/prism/fixtures/whitequark/bug_cmdarg.txt000066400000000000000000000000711506127434000236510ustar00rootroot00000000000000assert do: true

assert dogs

f x: -> do meth do end end
prism-1.5.1/test/prism/fixtures/whitequark/bug_def_no_paren_eql_begin.txt000066400000000000000000000000301506127434000270330ustar00rootroot00000000000000def foo
=begin
=end
end
prism-1.5.1/test/prism/fixtures/whitequark/bug_do_block_in_call_args.txt000066400000000000000000000000421506127434000266630ustar00rootroot00000000000000bar def foo; self.each do end end
prism-1.5.1/test/prism/fixtures/whitequark/bug_do_block_in_cmdarg.txt000066400000000000000000000000221506127434000261670ustar00rootroot00000000000000tap (proc do end)
prism-1.5.1/test/prism/fixtures/whitequark/bug_do_block_in_hash_brace.txt000066400000000000000000000003421506127434000270160ustar00rootroot00000000000000p :foo, {"a": proc do end, b: proc do end}

p :foo, {** proc do end, b: proc do end}

p :foo, {:a => proc do end, b: proc do end}

p :foo, {a: proc do end, b: proc do end}

p :foo, {proc do end => proc do end, b: proc do end}
prism-1.5.1/test/prism/fixtures/whitequark/bug_heredoc_do.txt000066400000000000000000000000301506127434000245020ustar00rootroot00000000000000f <<-TABLE do
TABLE
end
prism-1.5.1/test/prism/fixtures/whitequark/bug_interp_single.txt000066400000000000000000000000211506127434000252510ustar00rootroot00000000000000"#{1}"

%W"#{1}"
prism-1.5.1/test/prism/fixtures/whitequark/bug_lambda_leakage.txt000066400000000000000000000000241506127434000253030ustar00rootroot00000000000000->(scope) {}; scope
prism-1.5.1/test/prism/fixtures/whitequark/bug_regex_verification.txt000066400000000000000000000000061506127434000262660ustar00rootroot00000000000000/#)/x
prism-1.5.1/test/prism/fixtures/whitequark/bug_rescue_empty_else.txt000066400000000000000000000000431506127434000261270ustar00rootroot00000000000000begin; rescue LoadError; else; end
prism-1.5.1/test/prism/fixtures/whitequark/bug_while_not_parens_do.txt000066400000000000000000000000301506127434000264310ustar00rootroot00000000000000while not (true) do end
prism-1.5.1/test/prism/fixtures/whitequark/case_cond.txt000066400000000000000000000000331506127434000234730ustar00rootroot00000000000000case; when foo; 'foo'; end
prism-1.5.1/test/prism/fixtures/whitequark/case_cond_else.txt000066400000000000000000000000471506127434000245100ustar00rootroot00000000000000case; when foo; 'foo'; else 'bar'; end
prism-1.5.1/test/prism/fixtures/whitequark/case_expr.txt000066400000000000000000000000371506127434000235320ustar00rootroot00000000000000case foo; when 'bar'; bar; end
prism-1.5.1/test/prism/fixtures/whitequark/case_expr_else.txt000066400000000000000000000000511506127434000245360ustar00rootroot00000000000000case foo; when 'bar'; bar; else baz; end
prism-1.5.1/test/prism/fixtures/whitequark/casgn_scoped.txt000066400000000000000000000000161506127434000242060ustar00rootroot00000000000000Bar::Foo = 10
prism-1.5.1/test/prism/fixtures/whitequark/casgn_toplevel.txt000066400000000000000000000000131506127434000245600ustar00rootroot00000000000000::Foo = 10
prism-1.5.1/test/prism/fixtures/whitequark/casgn_unscoped.txt000066400000000000000000000000111506127434000245440ustar00rootroot00000000000000Foo = 10
prism-1.5.1/test/prism/fixtures/whitequark/character.txt000066400000000000000000000000031506127434000235060ustar00rootroot00000000000000?a
prism-1.5.1/test/prism/fixtures/whitequark/class.txt000066400000000000000000000000361506127434000226650ustar00rootroot00000000000000class Foo end

class Foo; end
prism-1.5.1/test/prism/fixtures/whitequark/class_super.txt000066400000000000000000000000251506127434000241010ustar00rootroot00000000000000class Foo < Bar; end
prism-1.5.1/test/prism/fixtures/whitequark/class_super_label.txt000066400000000000000000000000251506127434000252400ustar00rootroot00000000000000class Foo < a:b; end
prism-1.5.1/test/prism/fixtures/whitequark/comments_before_leading_dot__27.txt000066400000000000000000000000711506127434000277260ustar00rootroot00000000000000a #
  #
&.foo


a #
  #
.foo


a #
#
&.foo


a #
#
.foo

prism-1.5.1/test/prism/fixtures/whitequark/complex.txt000066400000000000000000000000311506127434000232220ustar00rootroot0000000000000042.1i

42.1ri

42i

42ri
prism-1.5.1/test/prism/fixtures/whitequark/cond_begin.txt000066400000000000000000000000231506127434000236430ustar00rootroot00000000000000if (bar); foo; end
prism-1.5.1/test/prism/fixtures/whitequark/cond_begin_masgn.txt000066400000000000000000000000321506127434000250300ustar00rootroot00000000000000if (bar; a, b = foo); end
prism-1.5.1/test/prism/fixtures/whitequark/cond_eflipflop.txt000066400000000000000000000000401506127434000245360ustar00rootroot00000000000000!(foo...bar)

if foo...bar; end
prism-1.5.1/test/prism/fixtures/whitequark/cond_eflipflop_with_beginless_range.txt000066400000000000000000000000171506127434000310040ustar00rootroot00000000000000if ...bar; end
prism-1.5.1/test/prism/fixtures/whitequark/cond_eflipflop_with_endless_range.txt000066400000000000000000000000171506127434000304660ustar00rootroot00000000000000if foo...; end
prism-1.5.1/test/prism/fixtures/whitequark/cond_iflipflop.txt000066400000000000000000000000361506127434000245470ustar00rootroot00000000000000!(foo..bar)

if foo..bar; end
prism-1.5.1/test/prism/fixtures/whitequark/cond_iflipflop_with_beginless_range.txt000066400000000000000000000000161506127434000310070ustar00rootroot00000000000000if ..bar; end
prism-1.5.1/test/prism/fixtures/whitequark/cond_iflipflop_with_endless_range.txt000066400000000000000000000000161506127434000304710ustar00rootroot00000000000000if foo..; end
prism-1.5.1/test/prism/fixtures/whitequark/cond_match_current_line.txt000066400000000000000000000000261506127434000264270ustar00rootroot00000000000000!/wat/

if /wat/; end
prism-1.5.1/test/prism/fixtures/whitequark/const_op_asgn.txt000066400000000000000000000001161506127434000244130ustar00rootroot00000000000000::A += 1

A += 1

B::A += 1

def x; ::A ||= 1; end

def x; self::A ||= 1; end
prism-1.5.1/test/prism/fixtures/whitequark/const_scoped.txt000066400000000000000000000000111506127434000242340ustar00rootroot00000000000000Bar::Foo
prism-1.5.1/test/prism/fixtures/whitequark/const_toplevel.txt000066400000000000000000000000061506127434000246150ustar00rootroot00000000000000::Foo
prism-1.5.1/test/prism/fixtures/whitequark/const_unscoped.txt000066400000000000000000000000041506127434000246010ustar00rootroot00000000000000Foo
prism-1.5.1/test/prism/fixtures/whitequark/cpath.txt000066400000000000000000000000501506127434000226530ustar00rootroot00000000000000module ::Foo; end

module Bar::Foo; end
prism-1.5.1/test/prism/fixtures/whitequark/cvar.txt000066400000000000000000000000061506127434000225100ustar00rootroot00000000000000@@foo
prism-1.5.1/test/prism/fixtures/whitequark/cvasgn.txt000066400000000000000000000000131506127434000230340ustar00rootroot00000000000000@@var = 10
prism-1.5.1/test/prism/fixtures/whitequark/dedenting_heredoc.txt000066400000000000000000000005131506127434000252120ustar00rootroot00000000000000p <<~"E"
    x
  #{"  y"}
E

p <<~"E"
    x
  #{foo}
E

p <<~E
	x
        y
E

p <<~E
	x
    y
E

p <<~E
    	x
        y
E

p <<~E
        	x
	y
E

p <<~E
    x
  \	y
E

p <<~E
    x
  \  y
E

p <<~E
  E

p <<~E
  x

y
E

p <<~E
  x
    
  y
E

p <<~E
  x
    y
E

p <<~E
  x
E

p <<~E
  ð
E

p <<~E
E

p <<~`E`
    x
  #{foo}
E
dedenting_interpolating_heredoc_fake_line_continuation.txt000066400000000000000000000000331506127434000346560ustar00rootroot00000000000000prism-1.5.1/test/prism/fixtures/whitequark<<~'FOO'
  baz\\
  qux
FOO
prism-1.5.1/test/prism/fixtures/whitequark/dedenting_non_interpolating_heredoc_line_continuation.txt000066400000000000000000000000321506127434000346200ustar00rootroot00000000000000<<~'FOO'
  baz\
  qux
FOO
prism-1.5.1/test/prism/fixtures/whitequark/def.txt000066400000000000000000000001361506127434000223170ustar00rootroot00000000000000def BEGIN; end

def END; end

def String; end

def String=; end

def foo; end

def until; end
prism-1.5.1/test/prism/fixtures/whitequark/defined.txt000066400000000000000000000000531506127434000231550ustar00rootroot00000000000000defined? @foo

defined? foo

defined?(foo)
prism-1.5.1/test/prism/fixtures/whitequark/defs.txt000066400000000000000000000001451506127434000225020ustar00rootroot00000000000000def (foo).foo; end

def String.foo; end

def String::foo; end

def self.foo; end

def self::foo; end
prism-1.5.1/test/prism/fixtures/whitequark/emit_arg_inside_procarg0_legacy.txt000066400000000000000000000000111506127434000300140ustar00rootroot00000000000000f{ |a| }
prism-1.5.1/test/prism/fixtures/whitequark/empty_stmt.txt000066400000000000000000000000011506127434000237550ustar00rootroot00000000000000
prism-1.5.1/test/prism/fixtures/whitequark/endless_comparison_method.txt000066400000000000000000000002641506127434000270120ustar00rootroot00000000000000def !=(other) = do_something

def !=(other) = do_something

def <=(other) = do_something

def ==(other) = do_something

def ===(other) = do_something

def >=(other) = do_something
prism-1.5.1/test/prism/fixtures/whitequark/endless_method.txt000066400000000000000000000001171506127434000245550ustar00rootroot00000000000000def foo() = 42

def inc(x) = x + 1

def obj.foo() = 42

def obj.inc(x) = x + 1
prism-1.5.1/test/prism/fixtures/whitequark/endless_method_command_syntax.txt000066400000000000000000000004271506127434000276650ustar00rootroot00000000000000def foo = puts "Hello"

def foo() = puts "Hello"

def foo(x) = puts x

def obj.foo = puts "Hello"

def obj.foo() = puts "Hello"

def obj.foo(x) = puts x

def rescued(x) = raise "to be caught" rescue "instance #{x}"

def self.rescued(x) = raise "to be caught" rescue "class #{x}"
prism-1.5.1/test/prism/fixtures/whitequark/endless_method_forwarded_args_legacy.txt000066400000000000000000000000301506127434000311440ustar00rootroot00000000000000def foo(...) = bar(...)
prism-1.5.1/test/prism/fixtures/whitequark/endless_method_with_rescue_mod.txt000066400000000000000000000000601506127434000300120ustar00rootroot00000000000000def m() = 1 rescue 2

def self.m() = 1 rescue 2
prism-1.5.1/test/prism/fixtures/whitequark/endless_method_without_args.txt000066400000000000000000000001271506127434000273550ustar00rootroot00000000000000def foo = 42

def foo = 42 rescue nil

def self.foo = 42

def self.foo = 42 rescue nil
prism-1.5.1/test/prism/fixtures/whitequark/ensure.txt000066400000000000000000000000361506127434000230610ustar00rootroot00000000000000begin; meth; ensure; bar; end
prism-1.5.1/test/prism/fixtures/whitequark/ensure_empty.txt000066400000000000000000000000211506127434000242710ustar00rootroot00000000000000begin ensure end
prism-1.5.1/test/prism/fixtures/whitequark/false.txt000066400000000000000000000000061506127434000226470ustar00rootroot00000000000000false
prism-1.5.1/test/prism/fixtures/whitequark/find_pattern.txt000066400000000000000000000002541506127434000242370ustar00rootroot00000000000000case foo; in *, 42, * then true; end

case foo; in Array[*, 1, *] then true; end

case foo; in String(*, 1, *) then true; end

case foo; in [*x, 1 => a, *y] then true; end
prism-1.5.1/test/prism/fixtures/whitequark/float.txt000066400000000000000000000000141506127434000226610ustar00rootroot00000000000000-1.33

1.33
prism-1.5.1/test/prism/fixtures/whitequark/for.txt000066400000000000000000000000611506127434000223440ustar00rootroot00000000000000for a in foo do p a; end

for a in foo; p a; end
prism-1.5.1/test/prism/fixtures/whitequark/for_mlhs.txt000066400000000000000000000000351506127434000233700ustar00rootroot00000000000000for a, b in foo; p a, b; end
prism-1.5.1/test/prism/fixtures/whitequark/forward_arg.txt000066400000000000000000000000341506127434000240530ustar00rootroot00000000000000def foo(...); bar(...); end
prism-1.5.1/test/prism/fixtures/whitequark/forward_arg_with_open_args.txt000066400000000000000000000004451506127434000271510ustar00rootroot00000000000000(def foo ...
  bar(...)
end)

(def foo ...; bar(...); end)

def foo ...
end

def foo ...; bar(...); end

def foo a, ...
  bar(...)
end

def foo a, ...; bar(...); end

def foo a, b = 1, ...
end

def foo b = 1, ...
  bar(...)
end

def foo b = 1, ...; bar(...); end

def foo(a, ...) bar(...) end
prism-1.5.1/test/prism/fixtures/whitequark/forward_args_legacy.txt000066400000000000000000000001161506127434000255630ustar00rootroot00000000000000def foo(...); bar(...); end

def foo(...); end

def foo(...); super(...); end
prism-1.5.1/test/prism/fixtures/whitequark/forwarded_argument_with_kwrestarg.txt000066400000000000000000000000561506127434000305650ustar00rootroot00000000000000def foo(argument, **); bar(argument, **); end
prism-1.5.1/test/prism/fixtures/whitequark/forwarded_argument_with_restarg.txt000066400000000000000000000000541506127434000302210ustar00rootroot00000000000000def foo(argument, *); bar(argument, *); end
prism-1.5.1/test/prism/fixtures/whitequark/forwarded_kwrestarg.txt000066400000000000000000000000321506127434000256220ustar00rootroot00000000000000def foo(**); bar(**); end
prism-1.5.1/test/prism/fixtures/whitequark/forwarded_kwrestarg_with_additional_kwarg.txt000066400000000000000000000000521506127434000322420ustar00rootroot00000000000000def foo(**); bar(**, from_foo: true); end
prism-1.5.1/test/prism/fixtures/whitequark/forwarded_restarg.txt000066400000000000000000000000301506127434000252560ustar00rootroot00000000000000def foo(*); bar(*); end
prism-1.5.1/test/prism/fixtures/whitequark/gvar.txt000066400000000000000000000000051506127434000225130ustar00rootroot00000000000000$foo
prism-1.5.1/test/prism/fixtures/whitequark/gvasgn.txt000066400000000000000000000000121506127434000230370ustar00rootroot00000000000000$var = 10
prism-1.5.1/test/prism/fixtures/whitequark/hash_empty.txt000066400000000000000000000000041506127434000237140ustar00rootroot00000000000000{ }
prism-1.5.1/test/prism/fixtures/whitequark/hash_hashrocket.txt000066400000000000000000000000461506127434000247170ustar00rootroot00000000000000{ 1 => 2 }

{ 1 => 2, :foo => "bar" }
prism-1.5.1/test/prism/fixtures/whitequark/hash_kwsplat.txt000066400000000000000000000000221506127434000242430ustar00rootroot00000000000000{ foo: 2, **bar }
prism-1.5.1/test/prism/fixtures/whitequark/hash_label.txt000066400000000000000000000000131506127434000236350ustar00rootroot00000000000000{ foo: 2 }
prism-1.5.1/test/prism/fixtures/whitequark/hash_label_end.txt000066400000000000000000000000631506127434000244700ustar00rootroot00000000000000f(a ? "a":1)

{ 'foo': 2 }

{ 'foo': 2, 'bar': {}}
prism-1.5.1/test/prism/fixtures/whitequark/hash_pair_value_omission.txt000066400000000000000000000000321506127434000266260ustar00rootroot00000000000000{BAR:}

{a:, b:}

{puts:}
prism-1.5.1/test/prism/fixtures/whitequark/heredoc.txt000066400000000000000000000001021506127434000231630ustar00rootroot00000000000000<<'HERE'
foo
bar
HERE

<(**nil) {}

def f(**nil); end

m { |**nil| }
prism-1.5.1/test/prism/fixtures/whitequark/kwoptarg.txt000066400000000000000000000000231506127434000234120ustar00rootroot00000000000000def f(foo: 1); end
prism-1.5.1/test/prism/fixtures/whitequark/kwoptarg_with_kwrestarg_and_forwarded_args.txt000066400000000000000000000000351506127434000324340ustar00rootroot00000000000000def f(a: nil, **); b(**) end
prism-1.5.1/test/prism/fixtures/whitequark/kwrestarg_named.txt000066400000000000000000000000221506127434000247300ustar00rootroot00000000000000def f(**foo); end
prism-1.5.1/test/prism/fixtures/whitequark/kwrestarg_unnamed.txt000066400000000000000000000000171506127434000252770ustar00rootroot00000000000000def f(**); end
prism-1.5.1/test/prism/fixtures/whitequark/lbrace_arg_after_command_args.txt000066400000000000000000000000271506127434000275340ustar00rootroot00000000000000let (:a) { m do; end }
prism-1.5.1/test/prism/fixtures/whitequark/lparenarg_after_lvar__since_25.txt000066400000000000000000000000401506127434000275610ustar00rootroot00000000000000foo (-1.3).abs

meth (-1.3).abs
prism-1.5.1/test/prism/fixtures/whitequark/lvar.txt000066400000000000000000000000041506127434000225170ustar00rootroot00000000000000foo
prism-1.5.1/test/prism/fixtures/whitequark/lvar_injecting_match.txt000066400000000000000000000001151506127434000257300ustar00rootroot00000000000000/(?a)/ =~ 'a'; /#{}(?b)/ =~ 'b'; a; b

/(?bar)/ =~ 'bar'; match
prism-1.5.1/test/prism/fixtures/whitequark/lvasgn.txt000066400000000000000000000000161506127434000230500ustar00rootroot00000000000000var = 10; var
prism-1.5.1/test/prism/fixtures/whitequark/marg_combinations.txt000066400000000000000000000003251506127434000252540ustar00rootroot00000000000000def f (((a))); end

def f ((*)); end

def f ((*, p)); end

def f ((*r)); end

def f ((*r, p)); end

def f ((a, *)); end

def f ((a, *, p)); end

def f ((a, *r)); end

def f ((a, *r, p)); end

def f ((a, a1)); end
prism-1.5.1/test/prism/fixtures/whitequark/masgn.txt000066400000000000000000000000711506127434000226640ustar00rootroot00000000000000(foo, bar) = 1, 2

foo, bar = 1, 2

foo, bar, baz = 1, 2
prism-1.5.1/test/prism/fixtures/whitequark/masgn_attr.txt000066400000000000000000000001001506127434000237070ustar00rootroot00000000000000self.A, foo = foo

self.a, self[1, 2] = foo

self::a, foo = foo
prism-1.5.1/test/prism/fixtures/whitequark/masgn_cmd.txt000066400000000000000000000000211506127434000235020ustar00rootroot00000000000000foo, bar = m foo
prism-1.5.1/test/prism/fixtures/whitequark/masgn_const.txt000066400000000000000000000000431506127434000240710ustar00rootroot00000000000000::A, foo = foo

self::A, foo = foo
prism-1.5.1/test/prism/fixtures/whitequark/masgn_nested.txt000066400000000000000000000000371506127434000242300ustar00rootroot00000000000000((b, )) = foo

a, (b, c) = foo
prism-1.5.1/test/prism/fixtures/whitequark/masgn_splat.txt000066400000000000000000000002141506127434000240660ustar00rootroot00000000000000* = bar

*, c, d = bar

*b = bar

*b, c = bar

@foo, @@bar = *foo

a, * = bar

a, *, c = bar

a, *b = bar

a, *b, c = bar

a, b = *foo, bar
prism-1.5.1/test/prism/fixtures/whitequark/method_definition_in_while_cond.txt000066400000000000000000000002771506127434000301400ustar00rootroot00000000000000while def foo a = tap do end; end; break; end

while def foo; tap do end; end; break; end

while def self.foo a = tap do end; end; break; end

while def self.foo; tap do end; end; break; end
prism-1.5.1/test/prism/fixtures/whitequark/module.txt000066400000000000000000000000201506127434000230360ustar00rootroot00000000000000module Foo; end
prism-1.5.1/test/prism/fixtures/whitequark/multiple_args_with_trailing_comma.txt000066400000000000000000000000151506127434000305240ustar00rootroot00000000000000f{ |a, b,| }
prism-1.5.1/test/prism/fixtures/whitequark/multiple_pattern_matches.txt000066400000000000000000000000651506127434000266560ustar00rootroot00000000000000{a: 0} => a:
{a: 0} => a:

{a: 0} in a:
{a: 0} in a:
prism-1.5.1/test/prism/fixtures/whitequark/newline_in_hash_argument.txt000066400000000000000000000001131506127434000266100ustar00rootroot00000000000000case foo
in a:
0
true
in "b":
0
true
end

obj.set "foo":
1

obj.set foo:
1
prism-1.5.1/test/prism/fixtures/whitequark/nil.txt000066400000000000000000000000041506127434000223350ustar00rootroot00000000000000nil
prism-1.5.1/test/prism/fixtures/whitequark/nil_expression.txt000066400000000000000000000000161506127434000246170ustar00rootroot00000000000000()

begin end
prism-1.5.1/test/prism/fixtures/whitequark/non_lvar_injecting_match.txt000066400000000000000000000000351506127434000266030ustar00rootroot00000000000000/#{1}(?bar)/ =~ 'bar'
prism-1.5.1/test/prism/fixtures/whitequark/not.txt000066400000000000000000000000311506127434000223530ustar00rootroot00000000000000not foo

not()

not(foo)
prism-1.5.1/test/prism/fixtures/whitequark/not_cmd.txt000066400000000000000000000000121506127434000231750ustar00rootroot00000000000000not m foo
prism-1.5.1/test/prism/fixtures/whitequark/not_masgn__24.txt000066400000000000000000000000161506127434000242070ustar00rootroot00000000000000!(a, b = foo)
prism-1.5.1/test/prism/fixtures/whitequark/nth_ref.txt000066400000000000000000000000041506127434000232000ustar00rootroot00000000000000$10
prism-1.5.1/test/prism/fixtures/whitequark/numbered_args_after_27.txt000066400000000000000000000001021506127434000260600ustar00rootroot00000000000000-> do _1 + _9 end

-> { _1 + _9}

m do _1 + _9 end

m { _1 + _9 }
prism-1.5.1/test/prism/fixtures/whitequark/numparam_outside_block.txt000066400000000000000000000001241506127434000263040ustar00rootroot00000000000000_1

class << foo; _1; end

class A; _1; end

def self.m; _1; end

module A; _1; end
prism-1.5.1/test/prism/fixtures/whitequark/numparam_ruby_bug_19025.txt000066400000000000000000000000171506127434000260350ustar00rootroot00000000000000p { [_1 **2] }
prism-1.5.1/test/prism/fixtures/whitequark/op_asgn.txt000066400000000000000000000000441506127434000232050ustar00rootroot00000000000000foo.A += 1

foo.a += 1

foo::a += 1
prism-1.5.1/test/prism/fixtures/whitequark/op_asgn_cmd.txt000066400000000000000000000001011506127434000240220ustar00rootroot00000000000000foo.A += m foo

foo.a += m foo

foo::A += m foo

foo::a += m foo
prism-1.5.1/test/prism/fixtures/whitequark/op_asgn_index.txt000066400000000000000000000000171506127434000243740ustar00rootroot00000000000000foo[0, 1] += 2
prism-1.5.1/test/prism/fixtures/whitequark/op_asgn_index_cmd.txt000066400000000000000000000000231506127434000252140ustar00rootroot00000000000000foo[0, 1] += m foo
prism-1.5.1/test/prism/fixtures/whitequark/optarg.txt000066400000000000000000000000551506127434000230550ustar00rootroot00000000000000def f foo = 1; end

def f(foo=1, bar=2); end
prism-1.5.1/test/prism/fixtures/whitequark/or.txt000066400000000000000000000000271506127434000222000ustar00rootroot00000000000000foo or bar

foo || bar
prism-1.5.1/test/prism/fixtures/whitequark/or_asgn.txt000066400000000000000000000000351506127434000232070ustar00rootroot00000000000000foo.a ||= 1

foo[0, 1] ||= 2
prism-1.5.1/test/prism/fixtures/whitequark/parser_bug_272.txt000066400000000000000000000000201506127434000242740ustar00rootroot00000000000000a @b do |c|;end
prism-1.5.1/test/prism/fixtures/whitequark/parser_bug_490.txt000066400000000000000000000002051506127434000243030ustar00rootroot00000000000000def m; class << self; A = nil; end; end

def m; class << self; class C; end; end; end

def m; class << self; module M; end; end; end
prism-1.5.1/test/prism/fixtures/whitequark/parser_bug_507.txt000066400000000000000000000000241506127434000243010ustar00rootroot00000000000000m = -> *args do end
prism-1.5.1/test/prism/fixtures/whitequark/parser_bug_518.txt000066400000000000000000000000201506127434000242770ustar00rootroot00000000000000class A < B
end
prism-1.5.1/test/prism/fixtures/whitequark/parser_bug_525.txt000066400000000000000000000000411506127434000243000ustar00rootroot00000000000000m1 :k => m2 do; m3() do end; end
prism-1.5.1/test/prism/fixtures/whitequark/parser_bug_604.txt000066400000000000000000000000171506127434000243010ustar00rootroot00000000000000m a + b do end
prism-1.5.1/test/prism/fixtures/whitequark/parser_bug_640.txt000066400000000000000000000000301506127434000242740ustar00rootroot00000000000000<<~FOO
  baz\
  qux
FOO
prism-1.5.1/test/prism/fixtures/whitequark/parser_bug_645.txt000066400000000000000000000000171506127434000243060ustar00rootroot00000000000000-> (arg={}) {}
prism-1.5.1/test/prism/fixtures/whitequark/parser_bug_830.txt000066400000000000000000000000051506127434000242770ustar00rootroot00000000000000/\(/
prism-1.5.1/test/prism/fixtures/whitequark/parser_bug_989.txt000066400000000000000000000000311506127434000243150ustar00rootroot00000000000000	<<-HERE
		content
	HERE
prism-1.5.1/test/prism/fixtures/whitequark/parser_drops_truncated_parts_of_squiggly_heredoc.txt000066400000000000000000000000231506127434000336420ustar00rootroot00000000000000<<~HERE
  #{}
HERE
prism-1.5.1/test/prism/fixtures/whitequark/parser_slash_slash_n_escaping_in_literals.txt000066400000000000000000000003231506127434000322120ustar00rootroot00000000000000"a\
b"

%I{a\
b}

%Q{a\
b}

%W{a\
b}

%i{a\
b}

%q{a\
b}

%r{a\
b}

%s{a\
b}

%w{a\
b}

%x{a\
b}

%{a\
b}

'a\
b'

/a\
b/

:"a\
b"

:'a\
b'

<<-"HERE"
a\
b
HERE

<<-'HERE'
a\
b
HERE

<<-`HERE`
a\
b
HERE

`a\
b`
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching__FILE__LINE_literals.txt000066400000000000000000000001611506127434000307110ustar00rootroot00000000000000        case [__FILE__, __LINE__ + 1, __ENCODING__]
          in [__FILE__, __LINE__, __ENCODING__]
        end

prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_blank_else.txt000066400000000000000000000000331506127434000272630ustar00rootroot00000000000000case 1; in 2; 3; else; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_const_pattern.txt000066400000000000000000000003211506127434000300470ustar00rootroot00000000000000case foo; in A() then true; end

case foo; in A(1, 2) then true; end

case foo; in A(x:) then true; end

case foo; in A[1, 2] then true; end

case foo; in A[] then true; end

case foo; in A[x:] then true; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_constants.txt000066400000000000000000000001411506127434000272000ustar00rootroot00000000000000case foo; in ::A then true; end

case foo; in A then true; end

case foo; in A::B then true; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_else.txt000066400000000000000000000000361506127434000261170ustar00rootroot00000000000000case 1; in 2; 3; else; 4; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_explicit_array_match.txt000066400000000000000000000005601506127434000313640ustar00rootroot00000000000000case foo; in [*, x] then true; end

case foo; in [*x, y] then true; end

case foo; in [x, *, y] then true; end

case foo; in [x, *y, z] then true; end

case foo; in [x, y, *] then true; end

case foo; in [x, y, *z] then true; end

case foo; in [x, y,] then true; end

case foo; in [x, y] then true; end

case foo; in [x,] then nil; end

case foo; in [x] then nil; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_expr_in_paren.txt000066400000000000000000000000401506127434000300130ustar00rootroot00000000000000case foo; in (1) then true; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_hash.txt000066400000000000000000000012641506127434000261160ustar00rootroot00000000000000case foo; 
        in a: {b:}, c:
          p c
      ; end

case foo; 
        in {Foo: 42
        }
          false
      ; end

case foo; 
        in {a:
              2}
          false
      ; end

case foo; 
        in {a:
        }
          true
      ; end

case foo; 
        in {a: 1
        }
          false
      ; end

case foo; in ** then true; end

case foo; in **a then true; end

case foo; in a: 1 then true; end

case foo; in a: 1, _a:, ** then true; end

case foo; in a: 1, b: 2 then true; end

case foo; in a: then true; end

case foo; in a:, b: then true; end

case foo; in { a: 1 } then true; end

case foo; in { a: 1, } then true; end

case foo; in {} then true; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_if_unless_modifiers.txt000066400000000000000000000001071506127434000312160ustar00rootroot00000000000000case foo; in x if true; nil; end

case foo; in x unless true; nil; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_implicit_array_match.txt000066400000000000000000000004231506127434000313530ustar00rootroot00000000000000case foo; in * then nil; end

case foo; in *x then nil; end

case foo; in *x, y, z then nil; end

case foo; in 1, "a", [], {} then nil; end

case foo; in x, *y, z then nil; end

case foo; in x, then nil; end

case foo; in x, y then nil; end

case foo; in x, y, then nil; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_keyword_variable.txt000066400000000000000000000000411506127434000305140ustar00rootroot00000000000000case foo; in self then true; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_lambda.txt000066400000000000000000000000451506127434000264070ustar00rootroot00000000000000case foo; in ->{ 42 } then true; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_match_alt.txt000066400000000000000000000000421506127434000271200ustar00rootroot00000000000000case foo; in 1 | 2 then true; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_match_as.txt000066400000000000000000000000431506127434000267440ustar00rootroot00000000000000case foo; in 1 => a then true; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_nil_pattern.txt000066400000000000000000000000421506127434000275030ustar00rootroot00000000000000case foo; in **nil then true; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_no_body.txt000066400000000000000000000000241506127434000266150ustar00rootroot00000000000000case foo; in 1; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_ranges.txt000066400000000000000000000003121506127434000264430ustar00rootroot00000000000000case foo; in ...2 then true; end

case foo; in ..2 then true; end

case foo; in 1.. then true; end

case foo; in 1... then true; end

case foo; in 1...2 then true; end

case foo; in 1..2 then true; end
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_single_line.txt000066400000000000000000000000311506127434000274520ustar00rootroot000000000000001 => [a]; a

1 in [a]; a
pattern_matching_single_line_allowed_omission_of_parentheses.txt000066400000000000000000000002171506127434000361150ustar00rootroot00000000000000prism-1.5.1/test/prism/fixtures/whitequark[1, 2] => a, b; a

[1, 2] in a, b; a

{a: 1} => a:; a

{a: 1} in a:; a

{key: :value} => key: value; value

{key: :value} in key: value; value
prism-1.5.1/test/prism/fixtures/whitequark/pattern_matching_single_match.txt000066400000000000000000000000331506127434000276210ustar00rootroot00000000000000case foo; in x then x; end
prism-1.5.1/test/prism/fixtures/whitequark/pin_expr.txt000066400000000000000000000003621506127434000234060ustar00rootroot00000000000000case foo; in ^$TestPatternMatching; end

case foo; in ^(0+0) then nil; end

case foo; in ^(1
); end

case foo; in ^(42) then nil; end

case foo; in ^@@TestPatternMatching; end

case foo; in ^@a; end

case foo; in { foo: ^(42) } then nil; end
prism-1.5.1/test/prism/fixtures/whitequark/postexe.txt000066400000000000000000000000121506127434000232410ustar00rootroot00000000000000END { 1 }
prism-1.5.1/test/prism/fixtures/whitequark/preexe.txt000066400000000000000000000000141506127434000230440ustar00rootroot00000000000000BEGIN { 1 }
prism-1.5.1/test/prism/fixtures/whitequark/procarg0.txt000066400000000000000000000000421506127434000232720ustar00rootroot00000000000000m { |(foo, bar)| } 

m { |foo| } 
prism-1.5.1/test/prism/fixtures/whitequark/procarg0_legacy.txt000066400000000000000000000000111506127434000246120ustar00rootroot00000000000000f{ |a| }
prism-1.5.1/test/prism/fixtures/whitequark/range_exclusive.txt000066400000000000000000000000061506127434000247400ustar00rootroot000000000000001...2
prism-1.5.1/test/prism/fixtures/whitequark/range_inclusive.txt000066400000000000000000000000051506127434000247310ustar00rootroot000000000000001..2
prism-1.5.1/test/prism/fixtures/whitequark/rational.txt000066400000000000000000000000131506127434000233640ustar00rootroot0000000000000042.1r

42r
prism-1.5.1/test/prism/fixtures/whitequark/regex_interp.txt000066400000000000000000000000171506127434000242520ustar00rootroot00000000000000/foo#{bar}baz/
prism-1.5.1/test/prism/fixtures/whitequark/regex_plain.txt000066400000000000000000000000131506127434000240500ustar00rootroot00000000000000/source/im
prism-1.5.1/test/prism/fixtures/whitequark/resbody_list.txt000066400000000000000000000000501506127434000242560ustar00rootroot00000000000000begin; meth; rescue Exception; bar; end
prism-1.5.1/test/prism/fixtures/whitequark/resbody_list_mrhs.txt000066400000000000000000000000551506127434000253140ustar00rootroot00000000000000begin; meth; rescue Exception, foo; bar; end
prism-1.5.1/test/prism/fixtures/whitequark/resbody_list_var.txt000066400000000000000000000000501506127434000251260ustar00rootroot00000000000000begin; meth; rescue foo => ex; bar; end
prism-1.5.1/test/prism/fixtures/whitequark/resbody_var.txt000066400000000000000000000001121506127434000240720ustar00rootroot00000000000000begin; meth; rescue => @ex; bar; end

begin; meth; rescue => ex; bar; end
prism-1.5.1/test/prism/fixtures/whitequark/rescue.txt000066400000000000000000000000361506127434000230460ustar00rootroot00000000000000begin; meth; rescue; foo; end
prism-1.5.1/test/prism/fixtures/whitequark/rescue_else.txt000066400000000000000000000000511506127434000240530ustar00rootroot00000000000000begin; meth; rescue; foo; else; bar; end
prism-1.5.1/test/prism/fixtures/whitequark/rescue_else_ensure.txt000066400000000000000000000000641506127434000254400ustar00rootroot00000000000000begin; meth; rescue; baz; else foo; ensure; bar end
prism-1.5.1/test/prism/fixtures/whitequark/rescue_ensure.txt000066400000000000000000000000531506127434000244260ustar00rootroot00000000000000begin; meth; rescue; baz; ensure; bar; end
prism-1.5.1/test/prism/fixtures/whitequark/rescue_in_lambda_block.txt000066400000000000000000000000221506127434000262010ustar00rootroot00000000000000-> do rescue; end
prism-1.5.1/test/prism/fixtures/whitequark/rescue_mod.txt000066400000000000000000000000201506127434000236760ustar00rootroot00000000000000meth rescue bar
prism-1.5.1/test/prism/fixtures/whitequark/rescue_mod_asgn.txt000066400000000000000000000000261506127434000247140ustar00rootroot00000000000000foo = meth rescue bar
prism-1.5.1/test/prism/fixtures/whitequark/rescue_mod_masgn.txt000066400000000000000000000000361506127434000250720ustar00rootroot00000000000000foo, bar = meth rescue [1, 2]
prism-1.5.1/test/prism/fixtures/whitequark/rescue_mod_op_assign.txt000066400000000000000000000000271506127434000257470ustar00rootroot00000000000000foo += meth rescue bar
prism-1.5.1/test/prism/fixtures/whitequark/rescue_without_begin_end.txt000066400000000000000000000000371506127434000266240ustar00rootroot00000000000000meth do; foo; rescue; bar; end
prism-1.5.1/test/prism/fixtures/whitequark/restarg_named.txt000066400000000000000000000000211506127434000243650ustar00rootroot00000000000000def f(*foo); end
prism-1.5.1/test/prism/fixtures/whitequark/restarg_unnamed.txt000066400000000000000000000000161506127434000247340ustar00rootroot00000000000000def f(*); end
prism-1.5.1/test/prism/fixtures/whitequark/return.txt000066400000000000000000000000521506127434000230750ustar00rootroot00000000000000return

return foo

return()

return(foo)
prism-1.5.1/test/prism/fixtures/whitequark/return_block.txt000066400000000000000000000000261506127434000242500ustar00rootroot00000000000000return fun foo do end
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_10279.txt000066400000000000000000000000311506127434000241330ustar00rootroot00000000000000{a: if true then 42 end}
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_10653.txt000066400000000000000000000001361506127434000241350ustar00rootroot00000000000000false ? raise do end : tap do end

false ? raise {} : tap {}

true ? 1.tap do |n| p n end : 0
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_11107.txt000066400000000000000000000000311506127434000241220ustar00rootroot00000000000000p ->() do a() do end end
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_11380.txt000066400000000000000000000000351506127434000241310ustar00rootroot00000000000000p -> { :hello }, a: 1 do end
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_11873.txt000066400000000000000000000004211506127434000241370ustar00rootroot00000000000000a b(c d), "x" do end

a b(c d), /x/ do end

a b(c d), /x/m do end

a b(c(d)), "x" do end

a b(c(d)), /x/ do end

a b(c(d)), /x/m do end

a b{c d}, "x" do end

a b{c d}, /x/ do end

a b{c d}, /x/m do end

a b{c(d)}, "x" do end

a b{c(d)}, /x/ do end

a b{c(d)}, /x/m do end
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_11873_a.txt000066400000000000000000000006751506127434000244520ustar00rootroot00000000000000a b(c d), 1 do end

a b(c d), 1.0 do end

a b(c d), 1.0i do end

a b(c d), 1.0r do end

a b(c d), :e do end

a b(c(d)), 1 do end

a b(c(d)), 1.0 do end

a b(c(d)), 1.0i do end

a b(c(d)), 1.0r do end

a b(c(d)), :e do end

a b{c d}, 1 do end

a b{c d}, 1.0 do end

a b{c d}, 1.0i do end

a b{c d}, 1.0r do end

a b{c d}, :e do end

a b{c(d)}, 1 do end

a b{c(d)}, 1.0 do end

a b{c(d)}, 1.0i do end

a b{c(d)}, 1.0r do end

a b{c(d)}, :e do end
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_11873_b.txt000066400000000000000000000000321506127434000244360ustar00rootroot00000000000000p p{p(p);p p}, tap do end
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_11989.txt000066400000000000000000000000251506127434000241470ustar00rootroot00000000000000p <<~"E"
  x\n   y
E
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_11990.txt000066400000000000000000000000231506127434000241350ustar00rootroot00000000000000p <<~E "  y"
  x
E
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_12073.txt000066400000000000000000000000621506127434000241310ustar00rootroot00000000000000a = 1; a b: 1

def foo raise; raise A::B, ''; end
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_12402.txt000066400000000000000000000006661506127434000241370ustar00rootroot00000000000000foo += raise bar rescue nil

foo += raise(bar) rescue nil

foo = raise bar rescue nil

foo = raise(bar) rescue nil

foo.C += raise bar rescue nil

foo.C += raise(bar) rescue nil

foo.m += raise bar rescue nil

foo.m += raise(bar) rescue nil

foo::C ||= raise bar rescue nil

foo::C ||= raise(bar) rescue nil

foo::m += raise bar rescue nil

foo::m += raise(bar) rescue nil

foo[0] += raise bar rescue nil

foo[0] += raise(bar) rescue nil
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_12669.txt000066400000000000000000000001131506127434000241410ustar00rootroot00000000000000a += b += raise :x

a += b = raise :x

a = b += raise :x

a = b = raise :x
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_12686.txt000066400000000000000000000000211506127434000241360ustar00rootroot00000000000000f (g rescue nil)
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_13547.txt000066400000000000000000000000121506127434000241330ustar00rootroot00000000000000meth[] {}
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_14690.txt000066400000000000000000000000301506127434000241330ustar00rootroot00000000000000let () { m(a) do; end }
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_15789.txt000066400000000000000000000000521506127434000241510ustar00rootroot00000000000000m ->(a = ->{_1}) {a}

m ->(a: ->{_1}) {a}
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_18878.txt000066400000000000000000000000241506127434000241520ustar00rootroot00000000000000Foo::Bar { |a| 42 }
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_19281.txt000066400000000000000000000000771506127434000241470ustar00rootroot00000000000000a.b (1;2),(3),(4)

a.b (;),(),()

p (1;2),(3),(4)

p (;),(),()
prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_19539.txt000066400000000000000000000000721506127434000241500ustar00rootroot00000000000000<<' FOO'
[Bug #19539]
 FOO


<<-' FOO'
[Bug #19539]
 FOO

prism-1.5.1/test/prism/fixtures/whitequark/ruby_bug_9669.txt000066400000000000000000000000421506127434000240700ustar00rootroot00000000000000def a b:
return
end

o = {
a:
1
}
prism-1.5.1/test/prism/fixtures/whitequark/sclass.txt000066400000000000000000000000271506127434000230500ustar00rootroot00000000000000class << foo; nil; end
prism-1.5.1/test/prism/fixtures/whitequark/self.txt000066400000000000000000000000051506127434000225050ustar00rootroot00000000000000self
prism-1.5.1/test/prism/fixtures/whitequark/send_attr_asgn.txt000066400000000000000000000000551506127434000245540ustar00rootroot00000000000000foo.A = 1

foo.a = 1

foo::A = 1

foo::a = 1
prism-1.5.1/test/prism/fixtures/whitequark/send_attr_asgn_conditional.txt000066400000000000000000000000111506127434000271270ustar00rootroot00000000000000a&.b = 1
prism-1.5.1/test/prism/fixtures/whitequark/send_binary_op.txt000066400000000000000000000003111506127434000245470ustar00rootroot00000000000000foo != 1

foo !~ 1

foo % 1

foo & 1

foo * 1

foo ** 1

foo + 1

foo - 1

foo / 1

foo < 1

foo << 1

foo <= 1

foo <=> 1

foo == 1

foo === 1

foo =~ 1

foo > 1

foo >= 1

foo >> 1

foo ^ 1

foo | 1
prism-1.5.1/test/prism/fixtures/whitequark/send_block_chain_cmd.txt000066400000000000000000000002561506127434000256540ustar00rootroot00000000000000meth 1 do end.fun bar

meth 1 do end.fun bar do end

meth 1 do end.fun {}

meth 1 do end.fun(bar)

meth 1 do end.fun(bar) {}

meth 1 do end::fun bar

meth 1 do end::fun(bar)
prism-1.5.1/test/prism/fixtures/whitequark/send_block_conditional.txt000066400000000000000000000000141506127434000262420ustar00rootroot00000000000000foo&.bar {}
prism-1.5.1/test/prism/fixtures/whitequark/send_call.txt000066400000000000000000000000221506127434000234770ustar00rootroot00000000000000foo.(1)

foo::(1)
prism-1.5.1/test/prism/fixtures/whitequark/send_conditional.txt000066400000000000000000000000051506127434000250700ustar00rootroot00000000000000a&.b
prism-1.5.1/test/prism/fixtures/whitequark/send_index.txt000066400000000000000000000000121506127434000236720ustar00rootroot00000000000000foo[1, 2]
prism-1.5.1/test/prism/fixtures/whitequark/send_index_asgn.txt000066400000000000000000000000161506127434000247060ustar00rootroot00000000000000foo[1, 2] = 3
prism-1.5.1/test/prism/fixtures/whitequark/send_index_asgn_legacy.txt000066400000000000000000000000161506127434000262320ustar00rootroot00000000000000foo[1, 2] = 3
prism-1.5.1/test/prism/fixtures/whitequark/send_index_cmd.txt000066400000000000000000000000131506127434000245160ustar00rootroot00000000000000foo[m bar]
prism-1.5.1/test/prism/fixtures/whitequark/send_index_legacy.txt000066400000000000000000000000121506127434000252160ustar00rootroot00000000000000foo[1, 2]
prism-1.5.1/test/prism/fixtures/whitequark/send_lambda.txt000066400000000000000000000000331506127434000240060ustar00rootroot00000000000000-> * { }

-> do end

->{ }
prism-1.5.1/test/prism/fixtures/whitequark/send_lambda_args.txt000066400000000000000000000000261506127434000250240ustar00rootroot00000000000000-> (a) { }

->(a) { }
prism-1.5.1/test/prism/fixtures/whitequark/send_lambda_args_noparen.txt000066400000000000000000000000271506127434000265470ustar00rootroot00000000000000-> a: 1 { }

-> a: { }
prism-1.5.1/test/prism/fixtures/whitequark/send_lambda_args_shadow.txt000066400000000000000000000000241506127434000263670ustar00rootroot00000000000000->(a; foo, bar) { }
prism-1.5.1/test/prism/fixtures/whitequark/send_lambda_legacy.txt000066400000000000000000000000061506127434000253320ustar00rootroot00000000000000->{ }
prism-1.5.1/test/prism/fixtures/whitequark/send_op_asgn_conditional.txt000066400000000000000000000000131506127434000265750ustar00rootroot00000000000000a&.b &&= 1
prism-1.5.1/test/prism/fixtures/whitequark/send_plain.txt000066400000000000000000000000361506127434000236740ustar00rootroot00000000000000foo.fun

foo::Fun()

foo::fun
prism-1.5.1/test/prism/fixtures/whitequark/send_plain_cmd.txt000066400000000000000000000000501506127434000245130ustar00rootroot00000000000000foo.fun bar

foo::Fun bar

foo::fun bar
prism-1.5.1/test/prism/fixtures/whitequark/send_self.txt000066400000000000000000000000221506127434000235150ustar00rootroot00000000000000fun

fun!

fun(1)
prism-1.5.1/test/prism/fixtures/whitequark/send_self_block.txt000066400000000000000000000000531506127434000246730ustar00rootroot00000000000000fun do end

fun { }

fun() { }

fun(1) { }
prism-1.5.1/test/prism/fixtures/whitequark/send_unary_op.txt000066400000000000000000000000211506127434000244170ustar00rootroot00000000000000+foo

-foo

~foo
prism-1.5.1/test/prism/fixtures/whitequark/slash_newline_in_heredocs.txt000066400000000000000000000000711506127434000267540ustar00rootroot00000000000000<<-E
    1 \
    2
    3
E


<<~E
    1 \
    2
    3
E

prism-1.5.1/test/prism/fixtures/whitequark/space_args_arg.txt000066400000000000000000000000101506127434000245100ustar00rootroot00000000000000fun (1)
prism-1.5.1/test/prism/fixtures/whitequark/space_args_arg_block.txt000066400000000000000000000000541506127434000256720ustar00rootroot00000000000000foo.fun (1) {}

foo::fun (1) {}

fun (1) {}
prism-1.5.1/test/prism/fixtures/whitequark/space_args_arg_call.txt000066400000000000000000000000151506127434000255100ustar00rootroot00000000000000fun (1).to_i
prism-1.5.1/test/prism/fixtures/whitequark/space_args_arg_newline.txt000066400000000000000000000000111506127434000262320ustar00rootroot00000000000000fun (1
)
prism-1.5.1/test/prism/fixtures/whitequark/space_args_block.txt000066400000000000000000000000121506127434000250330ustar00rootroot00000000000000fun () {}
prism-1.5.1/test/prism/fixtures/whitequark/space_args_cmd.txt000066400000000000000000000000141506127434000245060ustar00rootroot00000000000000fun (f bar)
prism-1.5.1/test/prism/fixtures/whitequark/string___FILE__.txt000066400000000000000000000000111506127434000244520ustar00rootroot00000000000000__FILE__
prism-1.5.1/test/prism/fixtures/whitequark/string_concat.txt000066400000000000000000000000171506127434000244140ustar00rootroot00000000000000"foo#@a" "bar"
prism-1.5.1/test/prism/fixtures/whitequark/string_dvar.txt000066400000000000000000000000171506127434000241010ustar00rootroot00000000000000"#@a #@@a #$a"
prism-1.5.1/test/prism/fixtures/whitequark/string_interp.txt000066400000000000000000000000171506127434000244460ustar00rootroot00000000000000"foo#{bar}baz"
prism-1.5.1/test/prism/fixtures/whitequark/string_plain.txt000066400000000000000000000000251506127434000242470ustar00rootroot00000000000000%q(foobar)

'foobar'
prism-1.5.1/test/prism/fixtures/whitequark/super.txt000066400000000000000000000000371506127434000227170ustar00rootroot00000000000000super foo

super()

super(foo)
prism-1.5.1/test/prism/fixtures/whitequark/super_block.txt000066400000000000000000000000441506127434000240670ustar00rootroot00000000000000super do end

super foo, bar do end
prism-1.5.1/test/prism/fixtures/whitequark/symbol_interp.txt000066400000000000000000000000201506127434000244370ustar00rootroot00000000000000:"foo#{bar}baz"
prism-1.5.1/test/prism/fixtures/whitequark/symbol_plain.txt000066400000000000000000000000151506127434000242450ustar00rootroot00000000000000:'foo'

:foo
prism-1.5.1/test/prism/fixtures/whitequark/ternary.txt000066400000000000000000000000141506127434000232400ustar00rootroot00000000000000foo ? 1 : 2
prism-1.5.1/test/prism/fixtures/whitequark/ternary_ambiguous_symbol.txt000066400000000000000000000000161506127434000267020ustar00rootroot00000000000000t=1;(foo)?t:T
prism-1.5.1/test/prism/fixtures/whitequark/trailing_forward_arg.txt000066400000000000000000000000511506127434000257430ustar00rootroot00000000000000def foo(a, b, ...); bar(a, 42, ...); end
prism-1.5.1/test/prism/fixtures/whitequark/true.txt000066400000000000000000000000051506127434000225330ustar00rootroot00000000000000true
prism-1.5.1/test/prism/fixtures/whitequark/unary_num_pow_precedence.txt000066400000000000000000000000411506127434000266330ustar00rootroot00000000000000+2.0 ** 10

-2 ** 10

-2.0 ** 10
prism-1.5.1/test/prism/fixtures/whitequark/undef.txt000066400000000000000000000000341506127434000226570ustar00rootroot00000000000000undef foo, :bar, :"foo#{1}"
prism-1.5.1/test/prism/fixtures/whitequark/unless.txt000066400000000000000000000000571506127434000230740ustar00rootroot00000000000000unless foo then bar; end

unless foo; bar; end
prism-1.5.1/test/prism/fixtures/whitequark/unless_else.txt000066400000000000000000000001031506127434000240740ustar00rootroot00000000000000unless foo then bar; else baz; end

unless foo; bar; else baz; end
prism-1.5.1/test/prism/fixtures/whitequark/unless_mod.txt000066400000000000000000000000171506127434000237270ustar00rootroot00000000000000bar unless foo
prism-1.5.1/test/prism/fixtures/whitequark/until.txt000066400000000000000000000000531506127434000227120ustar00rootroot00000000000000until foo do meth end

until foo; meth end
prism-1.5.1/test/prism/fixtures/whitequark/until_mod.txt000066400000000000000000000000171506127434000235510ustar00rootroot00000000000000meth until foo
prism-1.5.1/test/prism/fixtures/whitequark/until_post.txt000066400000000000000000000000311506127434000237530ustar00rootroot00000000000000begin meth end until foo
prism-1.5.1/test/prism/fixtures/whitequark/var_and_asgn.txt000066400000000000000000000000101506127434000241720ustar00rootroot00000000000000a &&= 1
prism-1.5.1/test/prism/fixtures/whitequark/var_op_asgn.txt000066400000000000000000000000661506127434000240610ustar00rootroot00000000000000@@var |= 10

@a |= 1

a += 1

def a; @@var |= 10; end
prism-1.5.1/test/prism/fixtures/whitequark/var_op_asgn_cmd.txt000066400000000000000000000000151506127434000246760ustar00rootroot00000000000000foo += m foo
prism-1.5.1/test/prism/fixtures/whitequark/var_or_asgn.txt000066400000000000000000000000101506127434000240500ustar00rootroot00000000000000a ||= 1
prism-1.5.1/test/prism/fixtures/whitequark/when_multi.txt000066400000000000000000000000461506127434000237340ustar00rootroot00000000000000case foo; when 'bar', 'baz'; bar; end
prism-1.5.1/test/prism/fixtures/whitequark/when_splat.txt000066400000000000000000000000541506127434000237240ustar00rootroot00000000000000case foo; when 1, *baz; bar; when *foo; end
prism-1.5.1/test/prism/fixtures/whitequark/when_then.txt000066400000000000000000000000431506127434000235350ustar00rootroot00000000000000case foo; when 'bar' then bar; end
prism-1.5.1/test/prism/fixtures/whitequark/while.txt000066400000000000000000000000531506127434000226670ustar00rootroot00000000000000while foo do meth end

while foo; meth end
prism-1.5.1/test/prism/fixtures/whitequark/while_mod.txt000066400000000000000000000000171506127434000235260ustar00rootroot00000000000000meth while foo
prism-1.5.1/test/prism/fixtures/whitequark/while_post.txt000066400000000000000000000000311506127434000237300ustar00rootroot00000000000000begin meth end while foo
prism-1.5.1/test/prism/fixtures/whitequark/xstring_interp.txt000066400000000000000000000000171506127434000246360ustar00rootroot00000000000000`foo#{bar}baz`
prism-1.5.1/test/prism/fixtures/whitequark/xstring_plain.txt000066400000000000000000000000111506127434000244320ustar00rootroot00000000000000`foobar`
prism-1.5.1/test/prism/fixtures/whitequark/zsuper.txt000066400000000000000000000000061506127434000231050ustar00rootroot00000000000000super
prism-1.5.1/test/prism/fixtures/xstring.txt000066400000000000000000000001201506127434000210640ustar00rootroot00000000000000%x[foo]

`foo #{bar} baz`

`foo`

%x{
  foo
}

``

%x{}

`
foo\
b\nar
`

`
’`
prism-1.5.1/test/prism/fixtures/xstring_with_backslash.txt000066400000000000000000000000071506127434000241360ustar00rootroot00000000000000`f\oo`
prism-1.5.1/test/prism/fixtures/yield.txt000066400000000000000000000001411506127434000204770ustar00rootroot00000000000000def foo; yield; end

def foo; yield(); end

def foo; yield(1); end

def foo; yield(1, 2, 3); end
prism-1.5.1/test/prism/fixtures_test.rb000066400000000000000000000021041506127434000202150ustar00rootroot00000000000000# frozen_string_literal: true

return if RUBY_VERSION < "3.2.0"

require_relative "test_helper"

module Prism
  class FixturesTest < TestCase
    except = []

    if RUBY_VERSION < "3.3.0"
      # Ruby < 3.3.0 cannot parse heredocs where there are leading whitespace
      # characters in the heredoc start.
      # Example: <<~'   EOF' or <<-'  EOF'
      # https://bugs.ruby-lang.org/issues/19539
      except << "heredocs_leading_whitespace.txt"
      except << "whitequark/ruby_bug_19539.txt"

      # https://bugs.ruby-lang.org/issues/19025
      except << "whitequark/numparam_ruby_bug_19025.txt"
      # https://bugs.ruby-lang.org/issues/18878
      except << "whitequark/ruby_bug_18878.txt"
      # https://bugs.ruby-lang.org/issues/19281
      except << "whitequark/ruby_bug_19281.txt"
    end

    # Leaving these out until they are supported by parse.y.
    except << "leading_logical.txt"
    except << "endless_methods_command_call.txt"

    Fixture.each(except: except) do |fixture|
      define_method(fixture.test_name) { assert_valid_syntax(fixture.read) }
    end
  end
end
prism-1.5.1/test/prism/fuzzer_test.rb000066400000000000000000000044151506127434000177000ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "test_helper"

module Prism
  # These tests are simply to exercise snippets found by the fuzzer that caused
  # invalid memory access.
  class FuzzerTest < TestCase
    def self.snippet(name, source)
      define_method(:"test_fuzzer_#{name}") { Prism.profile(source) }
    end

    snippet "incomplete global variable", "$"
    snippet "incomplete symbol", ":"
    snippet "incomplete escaped string", '"\\'
    snippet "trailing comment", "1\n#\n"
    snippet "comment followed by whitespace at end of file", "1\n#\n "
    snippet "trailing asterisk", "a *"
    snippet "incomplete decimal number", "0d"
    snippet "incomplete binary number", "0b"
    snippet "incomplete octal number", "0o"
    snippet "incomplete hex number", "0x"
    snippet "incomplete escaped list", "%w[\\"
    snippet "incomplete escaped regex", "/a\\"
    snippet "unterminated heredoc with unterminated escape at end of file", "<= "3.2.0")

require_relative "test_helper"

module Prism
  class LexTest < TestCase
    except = [
      # It seems like there are some oddities with nested heredocs and ripper.
      # Waiting for feedback on https://bugs.ruby-lang.org/issues/19838.
      "seattlerb/heredoc_nested.txt",
      "whitequark/dedenting_heredoc.txt",
      # Ripper seems to have a bug that the regex portions before and after
      # the heredoc are combined into a single token. See
      # https://bugs.ruby-lang.org/issues/19838.
      "spanning_heredoc.txt",
      "spanning_heredoc_newlines.txt",
      # Prism emits a single :on_tstring_content in <<- style heredocs when there
      # is a line continuation preceded by escaped backslashes. It should emit two, same
      # as if the backslashes are not present.
      "heredocs_with_fake_newlines.txt",
    ]

    if RUBY_VERSION < "3.3.0"
      # This file has changed behavior in Ripper in Ruby 3.3, so we skip it if
      # we're on an earlier version.
      except << "seattlerb/pct_w_heredoc_interp_nested.txt"

      # Ruby < 3.3.0 cannot parse heredocs where there are leading whitespace
      # characters in the heredoc start.
      # Example: <<~'   EOF' or <<-'  EOF'
      # https://bugs.ruby-lang.org/issues/19539
      except << "heredocs_leading_whitespace.txt"
      except << "whitequark/ruby_bug_19539.txt"

      # https://bugs.ruby-lang.org/issues/19025
      except << "whitequark/numparam_ruby_bug_19025.txt"
      # https://bugs.ruby-lang.org/issues/18878
      except << "whitequark/ruby_bug_18878.txt"
      # https://bugs.ruby-lang.org/issues/19281
      except << "whitequark/ruby_bug_19281.txt"
    end

    # https://bugs.ruby-lang.org/issues/20925
    except << "leading_logical.txt"

    # https://bugs.ruby-lang.org/issues/17398#note-12
    except << "endless_methods_command_call.txt"

    Fixture.each(except: except) do |fixture|
      define_method(fixture.test_name) { assert_lex(fixture) }
    end

    def test_lex_file
      assert_nothing_raised do
        Prism.lex_file(__FILE__)
      end

      error = assert_raise Errno::ENOENT do
        Prism.lex_file("idontexist.rb")
      end

      assert_equal "No such file or directory - idontexist.rb", error.message

      assert_raise TypeError do
        Prism.lex_file(nil)
      end
    end

    def test_parse_lex
      node, tokens = Prism.parse_lex("def foo; end").value

      assert_kind_of ProgramNode, node
      assert_equal 5, tokens.length
    end

    def test_parse_lex_file
      node, tokens = Prism.parse_lex_file(__FILE__).value

      assert_kind_of ProgramNode, node
      refute_empty tokens

      error = assert_raise Errno::ENOENT do
        Prism.parse_lex_file("idontexist.rb")
      end

      assert_equal "No such file or directory - idontexist.rb", error.message

      assert_raise TypeError do
        Prism.parse_lex_file(nil)
      end
    end

    private

    def assert_lex(fixture)
      source = fixture.read

      result = Prism.lex_compat(source)
      assert_equal [], result.errors

      Prism.lex_ripper(source).zip(result.value).each do |(ripper, prism)|
        assert_equal ripper, prism
      end
    end
  end
end
prism-1.5.1/test/prism/library_symbols_test.rb000066400000000000000000000056731506127434000215760ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "test_helper"

return if RUBY_PLATFORM !~ /linux/
return if RUBY_PLATFORM =~ /powerpc64le/

module Prism
  #
  #  examine a prism dll or static archive for expected external symbols.
  #  these tests only work on a linux system right now.
  #
  class LibrarySymbolsTest < TestCase
    def setup
      super

      @libprism_a = File.expand_path("../../build/libprism.a", __dir__)
      @libprism_so = File.expand_path("../../build/libprism.so", __dir__)
      @prism_so = File.expand_path("../../lib/prism/prism.so", __dir__)
    end

    # objdump runner and helpers
    def objdump(path)
      assert_path_exist(path)
      %x(objdump --section=.text --syms #{path}).split("\n")
    end

    def global_objdump_symbols(path)
      objdump(path).select { |line| line[17] == "g" }
    end

    def hidden_global_objdump_symbols(path)
      global_objdump_symbols(path).select { |line| line =~ / \.hidden / }
    end

    def visible_global_objdump_symbols(path)
      global_objdump_symbols(path).reject { |line| line =~ / \.hidden / }
    end

    # nm runner and helpers
    def nm(path)
      assert_path_exist(path)
      %x(nm #{path}).split("\n")
    end

    def global_nm_symbols(path)
      nm(path).select { |line| line[17] == "T" }
    end

    def local_nm_symbols(path)
      nm(path).select { |line| line[17] == "t" }
    end

    # dig the symbol name out of each line. works for both `objdump` and `nm` output.
    def names(symbol_lines)
      symbol_lines.map { |line| line.split(/\s+/).last }
    end

    #
    #  static archive - libprism.a
    #
    def test_libprism_a_contains_nothing_globally_visible
      omit("libprism.a is not built") unless File.exist?(@libprism_a)

      assert_empty(names(visible_global_objdump_symbols(@libprism_a)))
    end

    def test_libprism_a_contains_hidden_pm_symbols
      omit("libprism.a is not built") unless File.exist?(@libprism_a)

      names(hidden_global_objdump_symbols(@libprism_a)).tap do |symbols|
        assert_includes(symbols, "pm_parse")
        assert_includes(symbols, "pm_version")
      end
    end

    #
    #  shared object - libprism.so
    #
    def test_libprism_so_exports_only_the_necessary_functions
      omit("libprism.so is not built") unless File.exist?(@libprism_so)

      names(global_nm_symbols(@libprism_so)).tap do |symbols|
        assert_includes(symbols, "pm_parse")
        assert_includes(symbols, "pm_version")
      end
      names(local_nm_symbols(@libprism_so)).tap do |symbols|
        assert_includes(symbols, "pm_encoding_utf_8_isupper_char")
      end
      # TODO: someone who uses this library needs to finish this test
    end

    #
    #  shared object - prism.so
    #
    def test_prism_so_exports_only_the_C_extension_init_function
      omit("prism.so is not built") unless File.exist?(@prism_so)

      names(global_nm_symbols(@prism_so)).tap do |symbols|
        assert_equal(["Init_prism"], symbols)
      end
    end
  end
end
prism-1.5.1/test/prism/locals_test.rb000066400000000000000000000200651506127434000176270ustar00rootroot00000000000000# frozen_string_literal: true

# This test is going to use the RubyVM::InstructionSequence class to compile
# local tables and compare against them to ensure we have the same locals in the
# same order. This is important to guarantee that we compile indices correctly
# on CRuby (in terms of compatibility).
#
# There have also been changes made in other versions of Ruby, so we only want
# to test on the most recent versions.
return if !defined?(RubyVM::InstructionSequence) || RUBY_VERSION < "3.4.0"

# If we're on Ruby 3.4.0 and the default parser is Prism, then there is no point
# in comparing the locals because they will be the same.
return if RubyVM::InstructionSequence.compile("").to_a[4][:parser] == :prism

# In Ruby 3.4.0, the local table for method forwarding changed. But 3.4.0 can
# refer to the dev version, so while 3.4.0 still isn't released, we need to
# check if we have a high enough revision.
return if RubyVM::InstructionSequence.compile("def foo(...); end").to_a[13][2][2][10].length != 1

# Omit tests if running on a 32-bit machine because there is a bug with how
# Ruby is handling large ISeqs on 32-bit machines
return if RUBY_PLATFORM =~ /i686/

require_relative "test_helper"

module Prism
  class LocalsTest < TestCase
    except = [
      # Skip this fixture because it has a different number of locals because
      # CRuby is eliminating dead code.
      "whitequark/ruby_bug_10653.txt",

      # Leaving these out until they are supported by parse.y.
      "leading_logical.txt",
      "endless_methods_command_call.txt"
    ]

    Fixture.each(except: except) do |fixture|
      define_method(fixture.test_name) { assert_locals(fixture) }
    end

    def setup
      @previous_default_external = Encoding.default_external
      ignore_warnings { Encoding.default_external = Encoding::UTF_8 }
    end

    def teardown
      ignore_warnings { Encoding.default_external = @previous_default_external }
    end

    private

    def assert_locals(fixture)
      source = fixture.read

      expected = cruby_locals(source)
      actual = prism_locals(source)

      assert_equal(expected, actual)
    end

    # A wrapper around a RubyVM::InstructionSequence that provides a more
    # convenient interface for accessing parts of the iseq.
    class ISeq
      attr_reader :parts

      def initialize(parts)
        @parts = parts
      end

      def type
        parts[0]
      end

      def local_table
        parts[10]
      end

      def instructions
        parts[13]
      end

      def each_child
        instructions.each do |instruction|
          # Only look at arrays. Other instructions are line numbers or
          # tracepoint events.
          next unless instruction.is_a?(Array)

          instruction.each do |opnd|
            # Only look at arrays. Other operands are literals.
            next unless opnd.is_a?(Array)

            # Only look at instruction sequences. Other operands are literals.
            next unless opnd[0] == "YARVInstructionSequence/SimpleDataFormat"

            yield ISeq.new(opnd)
          end
        end
      end
    end

    # Used to hold the place of a local that will be in the local table but
    # cannot be accessed directly from the source code. For example, the
    # iteration variable in a for loop or the positional parameter on a method
    # definition that is destructured.
    AnonymousLocal = Object.new

    # For the given source, compiles with CRuby and returns a list of all of the
    # sets of local variables that were encountered.
    def cruby_locals(source)
      locals = [] #: Array[Array[Symbol | Integer]]
      stack = [ISeq.new(ignore_warnings { RubyVM::InstructionSequence.compile(source) }.to_a)]

      while (iseq = stack.pop)
        names = [*iseq.local_table]
        names.map!.with_index do |name, index|
          # When an anonymous local variable is present in the iseq's local
          # table, it is represented as the stack offset from the top.
          # However, when these are dumped to binary and read back in, they
          # are replaced with the symbol :#arg_rest. To consistently handle
          # this, we replace them here with their index.
          if name == :"#arg_rest"
            names.length - index + 1
          else
            name
          end
        end

        locals << names
        iseq.each_child { |child| stack << child }
      end

      locals
    end

    # For the given source, parses with prism and returns a list of all of the
    # sets of local variables that were encountered.
    def prism_locals(source)
      locals = [] #: Array[Array[Symbol | Integer]]
      stack = [Prism.parse(source).value] #: Array[Prism::node]

      while (node = stack.pop)
        case node
        when BlockNode, DefNode, LambdaNode
          names = node.locals
          params = nil

          if node.is_a?(DefNode)
            params = node.parameters
          elsif node.parameters.is_a?(NumberedParametersNode)
            # nothing
          elsif node.parameters.is_a?(ItParametersNode)
            names.unshift(AnonymousLocal)
          else
            params = node.parameters&.parameters
          end

          # prism places parameters in the same order that they appear in the
          # source. CRuby places them in the order that they need to appear
          # according to their own internal calling convention. We mimic that
          # order here so that we can compare properly.
          if params
            sorted = [
              *params.requireds.map do |required|
                if required.is_a?(RequiredParameterNode)
                  required.name
                else
                  AnonymousLocal
                end
              end,
              *params.optionals.map(&:name),
              *((params.rest.name || :*) if params.rest && !params.rest.is_a?(ImplicitRestNode)),
              *params.posts.map do |post|
                if post.is_a?(RequiredParameterNode)
                  post.name
                else
                  AnonymousLocal
                end
              end,
              *params.keywords.grep(RequiredKeywordParameterNode).map(&:name),
              *params.keywords.grep(OptionalKeywordParameterNode).map(&:name),
            ]

            sorted << AnonymousLocal if params.keywords.any?

            if params.keyword_rest.is_a?(ForwardingParameterNode)
              if sorted.length == 0
                sorted.push(:"...")
              else
                sorted.push(:*, :**, :&, :"...")
              end
            elsif params.keyword_rest.is_a?(KeywordRestParameterNode)
              sorted << (params.keyword_rest.name || :**)
            end

            # Recurse down the parameter tree to find any destructured
            # parameters and add them after the other parameters.
            param_stack = params.requireds.concat(params.posts).grep(MultiTargetNode).reverse
            while (param = param_stack.pop)
              case param
              when MultiTargetNode
                param_stack.concat(param.rights.reverse)
                param_stack << param.rest if param.rest&.expression && !sorted.include?(param.rest.expression.name)
                param_stack.concat(param.lefts.reverse)
              when RequiredParameterNode
                sorted << param.name
              when SplatNode
                sorted << param.expression.name
              end
            end

            if params.block
              sorted << (params.block.name || :&)
            end

            names = sorted.concat(names - sorted)
          end

          names.map!.with_index do |name, index|
            if name == AnonymousLocal
              names.length - index + 1
            else
              name
            end
          end

          locals << names
        when ClassNode, ModuleNode, ProgramNode, SingletonClassNode
          locals << node.locals
        when ForNode
          locals << [2]
        when PostExecutionNode
          locals.push([], [])
        when InterpolatedRegularExpressionNode
          locals << [] if node.once?
        end

        stack.concat(node.compact_child_nodes)
      end

      locals
    end
  end
end
prism-1.5.1/test/prism/magic_comment_test.rb000066400000000000000000000062551506127434000211610ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "test_helper"

module Prism
  class MagicCommentTest < TestCase
    if RUBY_ENGINE == "ruby"
      class MagicCommentRipper < Ripper
        attr_reader :magic_comments

        def initialize(*)
          super
          @magic_comments = []
        end

        def on_magic_comment(key, value)
          @magic_comments << [key, value]
          super
        end
      end

      Fixture.each do |fixture|
        define_method(fixture.test_name) { assert_magic_comments(fixture) }
      end
    end

    def test_encoding
      assert_magic_encoding(Encoding::US_ASCII, "# encoding: ascii")
    end

    def test_coding
      assert_magic_encoding(Encoding::US_ASCII, "# coding: ascii")
    end

    def test_eNcOdInG
      assert_magic_encoding(Encoding::US_ASCII, "# eNcOdInG: ascii")
    end

    def test_CoDiNg
      assert_magic_encoding(Encoding::US_ASCII, "# CoDiNg: ascii")
    end

    def test_encoding_whitespace
      assert_magic_encoding(Encoding::US_ASCII, "# \s\t\v encoding \s\t\v : \s\t\v ascii \s\t\v")
    end

    def test_emacs_encoding
      assert_magic_encoding(Encoding::US_ASCII, "# -*- encoding: ascii -*-")
    end

    def test_emacs_coding
      assert_magic_encoding(Encoding::US_ASCII, "# -*- coding: ascii -*-")
    end

    def test_emacs_eNcOdInG
      assert_magic_encoding(Encoding::US_ASCII, "# -*- eNcOdInG: ascii -*-")
    end

    def test_emacs_CoDiNg
      assert_magic_encoding(Encoding::US_ASCII, "# -*- CoDiNg: ascii -*-")
    end

    def test_emacs_whitespace
      assert_magic_encoding(Encoding::US_ASCII, "# -*- \s\t\v encoding \s\t\v : \s\t\v ascii \s\t\v -*-")
    end

    def test_emacs_multiple
      assert_magic_encoding(Encoding::US_ASCII, "# -*- foo: bar; encoding: ascii -*-")
    end

    def test_coding_whitespace
      assert_magic_encoding(Encoding::ASCII_8BIT, "# coding \t \r  \v   :     \t \v    \r   ascii-8bit")
    end

    def test_vim
      assert_magic_encoding(Encoding::Windows_31J, "# vim: filetype=ruby, fileencoding=windows-31j, tabsize=3, shiftwidth=3")
    end

    private

    def assert_magic_encoding(expected, line)
      source = %Q{#{line}\n""}
      actual = Prism.parse(source).encoding

      # Compare against our expectation.
      assert_equal expected, actual

      # Compare against Ruby's expectation.
      if defined?(RubyVM::InstructionSequence)
        previous = $VERBOSE
        expected =
          begin
            $VERBOSE = nil
            RubyVM::InstructionSequence.compile(source).eval.encoding
          ensure
            $VERBOSE = previous
          end
        assert_equal expected, actual
      end
    end

    def assert_magic_comments(fixture)
      source = fixture.read

      # Check that we get the correct number of magic comments when lexing with
      # ripper.
      expected = MagicCommentRipper.new(source).tap(&:parse).magic_comments
      actual = Prism.parse(source).magic_comments

      assert_equal expected.length, actual.length
      expected.zip(actual).each do |(expected_key, expected_value), magic_comment|
        assert_equal expected_key, magic_comment.key
        assert_equal expected_value, magic_comment.value
      end
    end
  end
end
prism-1.5.1/test/prism/newline_offsets_test.rb000066400000000000000000000007341506127434000215450ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "test_helper"

module Prism
  class NewlineOffsetsTest < TestCase
    Fixture.each do |fixture|
      define_method(fixture.test_name) { assert_newline_offsets(fixture) }
    end

    private

    def assert_newline_offsets(fixture)
      source = fixture.read

      expected = [0]
      source.b.scan("\n") { expected << $~.offset(0)[0] + 1 }

      assert_equal expected, Prism.parse(source).source.offsets
    end
  end
end
prism-1.5.1/test/prism/newline_test.rb000066400000000000000000000054761506127434000200240ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "test_helper"

return unless defined?(RubyVM::InstructionSequence)

module Prism
  class NewlineTest < TestCase
    skips = %w[
      errors_test.rb
      locals_test.rb
      regexp_test.rb
      test_helper.rb
      unescape_test.rb
      encoding/regular_expression_encoding_test.rb
      encoding/string_encoding_test.rb
      result/breadth_first_search_test.rb
      result/static_literals_test.rb
      result/warnings_test.rb
      ruby/parser_test.rb
      ruby/ruby_parser_test.rb
    ]

    base = __dir__
    (Dir["{,api/,encoding/,result/,ruby/}*.rb", base: base] - skips).each do |relative|
      define_method(:"test_#{relative}") do
        assert_newlines(base, relative)
      end
    end

    private

    def assert_newlines(base, relative)
      filepath = File.join(base, relative)
      source = File.read(filepath, binmode: true, external_encoding: Encoding::UTF_8)
      expected = rubyvm_lines(source)

      result = Prism.parse_file(filepath)
      assert_empty result.errors
      actual = prism_lines(result)

      source.each_line.with_index(1) do |line, line_number|
        # Lines like `while (foo = bar)` result in two line flags in the
        # bytecode but only one newline flag in the AST. We need to remove the
        # extra line flag from the bytecode to make the test pass.
        if line.match?(/while \(/)
          index = expected.index(line_number)
          expected.delete_at(index) if index
        end

        # Lines like `foo =` where the value is on the next line result in
        # another line flag in the bytecode but only one newline flag in the
        # AST.
        if line.match?(/^\s+\w+ =$/)
          if source.lines[line_number].match?(/^\s+case/)
            actual[actual.index(line_number)] += 1
          else
            actual.delete_at(actual.index(line_number))
          end
        end

        if line.match?(/^\s+\w+ = \[$/)
          if !expected.include?(line_number) && !expected.include?(line_number + 2)
            actual[actual.index(line_number)] += 1
          end
        end
      end

      assert_equal expected, actual
    end

    def rubyvm_lines(source)
      queue = [ignore_warnings { RubyVM::InstructionSequence.compile(source) }]
      lines = []

      while iseq = queue.shift
        lines.concat(iseq.trace_points.filter_map { |line, event| line if event == :line })
        iseq.each_child { |insn| queue << insn unless insn.label.start_with?("ensure in ") }
      end

      lines.sort
    end

    def prism_lines(result)
      result.mark_newlines!

      queue = [result.value]
      newlines = []

      while node = queue.shift
        queue.concat(node.compact_child_nodes)
        newlines << result.source.line(node.location.start_offset) if node&.newline_flag?
      end

      newlines.sort
    end
  end
end
prism-1.5.1/test/prism/onigmo_test.rb000066400000000000000000000036221506127434000176420ustar00rootroot00000000000000# frozen_string_literal: true

return if RUBY_ENGINE != "ruby"

require_relative "test_helper"

begin
  require "onigmo"
rescue LoadError
  # In CRuby's CI, we're not going to test against the parser gem because we
  # don't want to have to install it. So in this case we'll just skip this test.
  return
end

module Prism
  class OnigmoTest < TestCase
    def test_ONIGERR_PARSE_DEPTH_LIMIT_OVER
      assert_error(%Q{#{"(" * 4096}a#{")" * 4096}}, "parse depth limit over")
    end

    def test_ONIGERR_EMPTY_CHAR_CLASS
      assert_error("[]", "empty char-class")
    end

    def test_ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED
      assert_error("*", "target of repeat operator is not specified")
      assert_error("+", "target of repeat operator is not specified")
      assert_error("?", "target of repeat operator is not specified")
    end

    def test_ONIGERR_EMPTY_GROUP_NAME
      assert_error("(?<>)", "group name is empty")
    end

    def test_ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS
      assert_error("(", "end pattern with unmatched parenthesis")
      assert_error("(|", "end pattern with unmatched parenthesis")
      assert_error("(?<", "end pattern with unmatched parenthesis")
    end

    def test_ONIGERR_END_PATTERN_IN_GROUP
      assert_error("(?", "end pattern in group")
      assert_error("(?#", "end pattern in group")
    end

    def test_ONIGERR_UNDEFINED_GROUP_OPTION
      assert_error("(?P", "undefined group option")
    end

    def test_ONIGERR_UNMATCHED_CLOSE_PARENTHESIS
      assert_error(")", "unmatched close parenthesis")
    end

    private

    def assert_error(source, message)
      result = Prism.parse("/#{source}/")

      assert result.failure?, "Expected #{source.inspect} to error"
      assert_equal message, result.errors.first.message

      error = assert_raise(ArgumentError) { Onigmo.parse(source) }
      assert_equal message, error.message
    end
  end
end
prism-1.5.1/test/prism/percent_delimiter_string_test.rb000066400000000000000000000033131506127434000234330ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "test_helper"

module Prism
  module PercentDelimiterTests
    def test_newline_terminator_with_lf_crlf
      str = l "\n123456\r\n"
      assert_parse "123456", str
    end

    def test_newline_terminator_with_lf_crlf_with_extra_cr
      str = l "\n123456\r\r\n"
      assert_parse "123456\r", str
    end

    def test_newline_terminator_with_crlf_pair
      str = l "\r\n123456\r\n"
      assert_parse "123456", str
    end

    def test_newline_terminator_with_crlf_crlf_with_extra_cr
      str = l "\r\n123456\r\r\n"
      assert_parse "123456\r", str
    end

    def test_newline_terminator_with_cr_cr
      str = l "\r123456\r;\n"
      assert_parse "123456", str
    end

    def test_newline_terminator_with_crlf_lf
      str = l "\r\n123456\n;\n"
      assert_parse "123456", str
    end

    def test_cr_crlf
      str = l "\r1\r\n \r"
      assert_parse "1\n ", str
    end

    def test_lf_crlf
      str = l "\n1\r\n \n"
      assert_parse "1", str
    end

    def test_lf_lf
      str = l "\n1\n \n"
      assert_parse "1", str
    end

    def assert_parse(expected, str)
      assert_equal expected, find_node(str).unescaped
    end
  end

  class PercentDelimiterStringTest < TestCase
    include PercentDelimiterTests

    def find_node(str)
      tree = Prism.parse str
      tree.value.breadth_first_search { |x| Prism::StringNode === x }
    end

    def l(str)
      "%" + str
    end
  end

  class PercentDelimiterRegexpTest < TestCase
    include PercentDelimiterTests

    def l(str)
      "%r" + str
    end

    def find_node(str)
      tree = Prism.parse str
      tree.value.breadth_first_search { |x| Prism::RegularExpressionNode === x }
    end
  end
end
prism-1.5.1/test/prism/ractor_test.rb000066400000000000000000000043361506127434000176470ustar00rootroot00000000000000# frozen_string_literal: true

return unless defined?(Ractor) && Process.respond_to?(:fork)

require_relative "test_helper"

module Prism
  class RactorTest < TestCase
    def test_version
      assert_match(/\A\d+\.\d+\.\d+\z/, with_ractor { Prism::VERSION })
    end

    def test_parse_file
      assert_equal("Prism::ParseResult", with_ractor(__FILE__) { |filepath| Prism.parse_file(filepath).class })
    end

    def test_lex_file
      assert_equal("Prism::LexResult", with_ractor(__FILE__) { |filepath| Prism.lex_file(filepath).class })
    end

    def test_parse_file_comments
      assert_equal("Array", with_ractor(__FILE__) { |filepath| Prism.parse_file_comments(filepath).class })
    end

    def test_parse_lex_file
      assert_equal("Prism::ParseLexResult", with_ractor(__FILE__) { |filepath| Prism.parse_lex_file(filepath).class })
    end

    def test_parse_success
      assert_equal("true", with_ractor("1 + 1") { |source| Prism.parse_success?(source) })
    end

    def test_parse_failure
      assert_equal("true", with_ractor("1 +") { |source| Prism.parse_failure?(source) })
    end

    def test_string_query_local
      assert_equal("true", with_ractor("foo") { |source| StringQuery.local?(source) })
    end

    def test_string_query_constant
      assert_equal("true", with_ractor("FOO") { |source| StringQuery.constant?(source) })
    end

    def test_string_query_method_name
      assert_equal("true", with_ractor("foo?") { |source| StringQuery.method_name?(source) })
    end

    if !ENV["PRISM_BUILD_MINIMAL"]
      def test_dump_file
        result = with_ractor(__FILE__) { |filepath| Prism.dump_file(filepath) }
        assert_operator(result, :start_with?, "PRISM")
      end
    end

    private

    # Note that this must be done in a subprocess, otherwise it can mess up
    # CRuby's test suite.
    def with_ractor(*arguments, &block)
      IO.popen("-") do |reader|
        if reader
          reader.gets.chomp
        else
          ractor = ignore_warnings { Ractor.new(*arguments, &block) }

          # Somewhere in the Ruby 3.5.* series, Ractor#take was removed and
          # Ractor#value was added.
          puts(ractor.respond_to?(:value) ? ractor.value : ractor.take)
        end
      end
    end
  end
end
prism-1.5.1/test/prism/regexp_test.rb000066400000000000000000000152461506127434000176510ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "test_helper"

module Prism
  class RegexpTest < TestCase
    ############################################################################
    # These tests test the actual use case of extracting named capture groups
    ############################################################################

    def test_named_captures_with_arrows
      assert_equal([:foo], named_captures("(?bar)"))
    end

    def test_named_captures_with_single_quotes
      assert_equal([:foo], named_captures("(?'foo'bar)"))
    end

    def test_nested_named_captures_with_arrows
      assert_equal([:foo, :bar], named_captures("(?(?baz))"))
    end

    def test_nested_named_captures_with_single_quotes
      assert_equal([:foo, :bar], named_captures("(?'foo'(?'bar'baz))"))
    end

    def test_allows_duplicate_named_captures
      assert_equal([:foo], named_captures("(?bar)(?baz)"))
    end

    def test_named_capture_inside_fake_range_quantifier
      assert_equal([:foo], named_captures("foo{1, (?2)}"))
    end

    def test_fake_named_captures_inside_character_sets
      assert_equal([], named_captures("[a-z(?)]"))
    end

    def test_fake_named_capture_inside_character_set_with_escaped_ending
      assert_equal([], named_captures("[a-z\\](?)]"))
    end

    ############################################################################
    # These tests test the rest of the AST. They are not exhaustive, but they
    # should cover the most common cases. We test these to make sure we don't
    # accidentally regress and stop being able to extract named captures.
    ############################################################################

    def test_alternation
      assert_valid_regexp("foo|bar")
    end

    def test_anchors
      assert_valid_regexp("^foo$")
    end

    def test_any
      assert_valid_regexp(".")
    end

    def test_posix_character_classes
      assert_valid_regexp("[[:digit:]]")
    end

    def test_negated_posix_character_classes
      assert_valid_regexp("[[:^digit:]]")
    end

    def test_invalid_posix_character_classes_should_fall_back_to_regular_classes
      assert_valid_regexp("[[:foo]]")
    end

    def test_character_sets
      assert_valid_regexp("[abc]")
    end

    def test_nested_character_sets
      assert_valid_regexp("[[abc]]")
    end

    def test_nested_character_sets_with_operators
      assert_valid_regexp("[[abc] && [def]]")
    end

    def test_named_capture_inside_nested_character_set
      assert_equal([], named_captures("[foo (?bar)]"))
    end

    def test_negated_character_sets
      assert_valid_regexp("[^abc]")
    end

    def test_character_ranges
      assert_valid_regexp("[a-z]")
    end

    def test_negated_character_ranges
      assert_valid_regexp("[^a-z]")
    end

    def test_comments
      assert_valid_regexp("(?#foo)")
    end

    def test_comments_with_escaped_parentheses
      assert_valid_regexp("(?#foo\\)\\))")
    end

    def test_non_capturing_groups
      assert_valid_regexp("(?:foo)")
    end

    def test_positive_lookaheads
      assert_valid_regexp("(?=foo)")
    end

    def test_negative_lookaheads
      assert_valid_regexp("(?!foo)")
    end

    def test_positive_lookbehinds
      assert_valid_regexp("(?<=foo)")
    end

    def test_negative_lookbehinds
      assert_valid_regexp("(?foo)")
    end

    def test_absence_operator
      assert_valid_regexp("(?~foo)")
    end

    def test_conditional_expression_with_index
      assert_valid_regexp("(?(1)foo)")
    end

    def test_conditional_expression_with_name
      assert_valid_regexp("(?(foo)bar)")
    end

    def test_conditional_expression_with_group
      assert_valid_regexp("(?()bar)")
    end

    def test_options_on_groups
      assert_valid_regexp("(?imxdau:foo)")
    end

    def test_options_on_groups_getting_turned_off
      assert_valid_regexp("(?-imx:foo)")
    end

    def test_options_on_groups_some_getting_turned_on_some_getting_turned_off
      assert_valid_regexp("(?im-x:foo)")
    end

    def test_star_quantifier
      assert_valid_regexp("foo*")
    end

    def test_plus_quantifier
      assert_valid_regexp("foo+")
    end

    def test_question_mark_quantifier
      assert_valid_regexp("foo?")
    end

    def test_endless_range_quantifier
      assert_valid_regexp("foo{1,}")
    end

    def test_beginless_range_quantifier
      assert_valid_regexp("foo{,1}")
    end

    def test_range_quantifier
      assert_valid_regexp("foo{1,2}")
    end

    def test_fake_range_quantifier_because_of_spaces
      assert_valid_regexp("foo{1, 2}")
    end

    def test_fake_range_quantifier_because_unclosed
      assert_valid_regexp("\\A{")
    end

    ############################################################################
    # These test that flag values are correct.
    ############################################################################

    def test_flag_ignorecase
      assert_equal(Regexp::IGNORECASE, options("i"))
    end

    def test_flag_extended
      assert_equal(Regexp::EXTENDED, options("x"))
    end

    def test_flag_multiline
      assert_equal(Regexp::MULTILINE, options("m"))
    end

    def test_flag_fixedencoding
      assert_equal(Regexp::FIXEDENCODING, options("e"))
      assert_equal(Regexp::FIXEDENCODING, options("u"))
      assert_equal(Regexp::FIXEDENCODING, options("s"))
    end

    def test_flag_noencoding
      assert_equal(Regexp::NOENCODING, options("n"))
    end

    def test_flag_once
      assert_equal(0, options("o"))
    end

    def test_flag_combined
      value = Regexp::IGNORECASE | Regexp::MULTILINE | Regexp::EXTENDED
      assert_equal(value, options("mix"))
    end

    def test_last_encoding_option_wins
      regex = "/foo/nu"
      option = Prism.parse_statement(regex).options

      assert_equal Regexp::FIXEDENCODING, option

      regex = "/foo/un"
      option = Prism.parse_statement(regex).options

      assert_equal Regexp::NOENCODING, option
    end

    private

    def assert_valid_regexp(source)
      assert Prism.parse_success?("/#{source}/ =~ \"\"")
    end

    def named_captures(source)
      Prism.parse("/#{source}/ =~ \"\"").value.locals
    end

    def options(flags)
      options =
        ["/foo/#{flags}", "/foo\#{1}/#{flags}"].map do |source|
          Prism.parse_statement(source).options
        end

      # Check that we get the same set of options from both regular expressions
      # and interpolated regular expressions.
      assert_equal(1, options.uniq.length)

      # Return the options from the first regular expression since we know they
      # are the same.
      options.first
    end
  end
end
prism-1.5.1/test/prism/result/000077500000000000000000000000001506127434000163015ustar00rootroot00000000000000prism-1.5.1/test/prism/result/attribute_write_test.rb000066400000000000000000000022241506127434000231020ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class AttributeWriteTest < TestCase
    module Target
      def self.value
        2
      end

      def self.value=(value)
        2
      end

      def self.[]=(index, value)
        2
      end
    end

    def test_named_call_with_operator
      assert_attribute_write("Target.value = 1")
    end

    def test_named_call_without_operator
      assert_attribute_write("Target.value=(1)")
    end

    def test_indexed_call_with_operator
      assert_attribute_write("Target[0] = 1")
    end

    def test_indexed_call_without_operator
      refute_attribute_write("Target.[]=(0, 1)")
    end

    def test_comparison_operators
      refute_attribute_write("Target.value == 1")
      refute_attribute_write("Target.value === 1")
    end

    private

    def assert_attribute_write(source)
      call = Prism.parse_statement(source)
      assert(call.attribute_write?)
      assert_equal(1, eval(source))
    end

    def refute_attribute_write(source)
      call = Prism.parse_statement(source)
      refute(call.attribute_write?)
      refute_equal(1, eval(source))
    end
  end
end
prism-1.5.1/test/prism/result/breadth_first_search_test.rb000066400000000000000000000006321506127434000240330ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class BreadthFirstSearchTest < TestCase
    def test_breadth_first_search
      result = Prism.parse("[1 + 2, 2]")
      found =
        result.value.breadth_first_search do |node|
          node.is_a?(IntegerNode) && node.value == 2
        end

      refute_nil found
      assert_equal 8, found.start_offset
    end
  end
end
prism-1.5.1/test/prism/result/comments_test.rb000066400000000000000000000071551506127434000215220ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class CommentsTest < TestCase
    def test_comment_inline
      source = "# comment"
      assert_equal [0], Prism.parse(source).source.offsets

      assert_comment(
        source,
        InlineComment,
        start_offset: 0,
        end_offset: 9,
        start_line: 1,
        end_line: 1,
        start_column: 0,
        end_column: 9
      )
    end

    def test_comment_inline_def
      source = <<~RUBY
      def foo
        # a comment
      end
      RUBY

      assert_comment(
        source,
        InlineComment,
        start_offset: 10,
        end_offset: 21,
        start_line: 2,
        end_line: 2,
        start_column: 2,
        end_column: 13
      )
    end

    def test___END__
      result = Prism.parse(<<~RUBY)
        __END__
        comment
      RUBY

      data_loc = result.data_loc
      assert_equal 0, data_loc.start_offset
      assert_equal 16, data_loc.end_offset
    end

    def test___END__crlf
      result = Prism.parse("__END__\r\ncomment\r\n")

      data_loc = result.data_loc
      assert_equal 0, data_loc.start_offset
      assert_equal 18, data_loc.end_offset
    end

    def test_comment_embedded_document
      source = <<~RUBY
        =begin
        comment
        =end
      RUBY

      assert_comment(
        source,
        EmbDocComment,
        start_offset: 0,
        end_offset: 20,
        start_line: 1,
        end_line: 4,
        start_column: 0,
        end_column: 0
      )
    end

    def test_comment_embedded_document_with_content_on_same_line
      source = <<~RUBY
        =begin other stuff
        =end
      RUBY

      assert_comment(
        source,
        EmbDocComment,
        start_offset: 0,
        end_offset: 24,
        start_line: 1,
        end_line: 3,
        start_column: 0,
        end_column: 0
      )
    end

    def test_attaching_comments
      source = <<~RUBY
        # Foo class
        class Foo
          # bar method
          def bar
            # baz invocation
            baz
          end # bar end
        end # Foo end
      RUBY

      result = Prism.parse(source)
      result.attach_comments!
      tree = result.value
      class_node = tree.statements.body.first
      method_node = class_node.body.body.first
      call_node = method_node.body.body.first

      assert_equal("# Foo class\n# Foo end", class_node.location.comments.map { |c| c.location.slice }.join("\n"))
      assert_equal("# bar method\n# bar end", method_node.location.comments.map { |c| c.location.slice }.join("\n"))
      assert_equal("# baz invocation", call_node.location.comments.map { |c| c.location.slice }.join("\n"))
    end

    private

    def assert_comment(source, type, start_offset:, end_offset:, start_line:, end_line:, start_column:, end_column:)
      result = Prism.parse(source)
      assert result.errors.empty?, result.errors.map(&:message).join("\n")
      assert_kind_of type, result.comments.first

      location = result.comments.first.location
      assert_equal start_offset, location.start_offset, -> { "Expected start_offset to be #{start_offset}" }
      assert_equal end_offset, location.end_offset, -> { "Expected end_offset to be #{end_offset}" }
      assert_equal start_line, location.start_line, -> { "Expected start_line to be #{start_line}" }
      assert_equal end_line, location.end_line, -> { "Expected end_line to be #{end_line}" }
      assert_equal start_column, location.start_column, -> { "Expected start_column to be #{start_column}" }
      assert_equal end_column, location.end_column, -> { "Expected end_column to be #{end_column}" }
    end
  end
end
prism-1.5.1/test/prism/result/constant_path_node_test.rb000066400000000000000000000042661506127434000235470ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class ConstantPathNodeTest < TestCase
    def test_full_name_for_constant_path
      source = <<~RUBY
        Foo:: # comment
          Bar::Baz::
            Qux
      RUBY

      constant_path = Prism.parse_statement(source)
      assert_equal("Foo::Bar::Baz::Qux", constant_path.full_name)
    end

    def test_full_name_for_constant_path_with_self
      source = <<~RUBY
        self:: # comment
          Bar::Baz::
            Qux
      RUBY

      constant_path = Prism.parse_statement(source)
      assert_raise(ConstantPathNode::DynamicPartsInConstantPathError) do
        constant_path.full_name
      end
    end

    def test_full_name_for_constant_path_with_variable
      source = <<~RUBY
        foo:: # comment
          Bar::Baz::
            Qux
      RUBY

      constant_path = Prism.parse_statement(source)

      assert_raise(ConstantPathNode::DynamicPartsInConstantPathError) do
        constant_path.full_name
      end
    end

    def test_full_name_for_constant_path_target
      source = <<~RUBY
        Foo:: # comment
          Bar::Baz::
            Qux, Something = [1, 2]
      RUBY

      node = Prism.parse_statement(source)
      assert_equal("Foo::Bar::Baz::Qux", node.lefts.first.full_name)
    end

    def test_full_name_for_constant_path_with_stovetop_start
      source = <<~RUBY
        ::Foo:: # comment
          Bar::Baz::
            Qux, Something = [1, 2]
      RUBY

      node = Prism.parse_statement(source)
      assert_equal("::Foo::Bar::Baz::Qux", node.lefts.first.full_name)
    end

    def test_full_name_for_constant_path_target_with_non_constant_parent
      source = <<~RUBY
        self::Foo, Bar = [1, 2]
      RUBY

      constant_target = Prism.parse_statement(source)
      dynamic, static = constant_target.lefts

      assert_raise(ConstantPathNode::DynamicPartsInConstantPathError) do
        dynamic.full_name
      end

      assert_equal("Bar", static.full_name)
    end

    def test_full_name_for_constant_read_node
      source = <<~RUBY
        Bar
      RUBY

      constant = Prism.parse_statement(source)
      assert_equal("Bar", constant.full_name)
    end
  end
end
prism-1.5.1/test/prism/result/equality_test.rb000066400000000000000000000016361506127434000215300ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class EqualityTest < TestCase
    def test_equality
      assert_operator Prism.parse_statement("1"), :===, Prism.parse_statement("1")
      assert_operator Prism.parse("1").value, :===, Prism.parse("1").value

      complex_source = "class Something; @var = something.else { _1 }; end"
      assert_operator Prism.parse_statement(complex_source), :===, Prism.parse_statement(complex_source)

      refute_operator Prism.parse_statement("1"), :===, Prism.parse_statement("2")
      refute_operator Prism.parse_statement("1"), :===, Prism.parse_statement("0x1")

      complex_source_1 = "class Something; @var = something.else { _1 }; end"
      complex_source_2 = "class Something; @var = something.else { _2 }; end"
      refute_operator Prism.parse_statement(complex_source_1), :===, Prism.parse_statement(complex_source_2)
    end
  end
end
prism-1.5.1/test/prism/result/heredoc_test.rb000066400000000000000000000012331506127434000212750ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class HeredocTest < TestCase
    def test_heredoc?
      refute Prism.parse_statement("\"foo\"").heredoc?
      refute Prism.parse_statement("\"foo \#{1}\"").heredoc?
      refute Prism.parse_statement("`foo`").heredoc?
      refute Prism.parse_statement("`foo \#{1}`").heredoc?

      assert Prism.parse_statement("<<~HERE\nfoo\nHERE\n").heredoc?
      assert Prism.parse_statement("<<~HERE\nfoo \#{1}\nHERE\n").heredoc?
      assert Prism.parse_statement("<<~`HERE`\nfoo\nHERE\n").heredoc?
      assert Prism.parse_statement("<<~`HERE`\nfoo \#{1}\nHERE\n").heredoc?
    end
  end
end
prism-1.5.1/test/prism/result/implicit_array_test.rb000066400000000000000000000027251506127434000227030ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class ImplicitArrayTest < TestCase
    def test_call_node
      assert_implicit_array("a.a = *b")
      assert_implicit_array("a.a = 1, 2, 3")
      assert_implicit_array("a[a] = *b")
      assert_implicit_array("a[a] = 1, 2, 3")
    end

    def test_class_variable_write_node
      assert_implicit_array("@@a = *b")
      assert_implicit_array("@@a = 1, 2, 3")
    end

    def test_constant_path_write_node
      assert_implicit_array("A::A = *b")
      assert_implicit_array("A::A = 1, 2, 3")
    end

    def test_constant_write_node
      assert_implicit_array("A = *b")
      assert_implicit_array("A = 1, 2, 3")
    end

    def test_global_variable_write_node
      assert_implicit_array("$a = *b")
      assert_implicit_array("$a = 1, 2, 3")
    end

    def test_instance_variable_write_node
      assert_implicit_array("@a = *b")
      assert_implicit_array("@a = 1, 2, 3")
    end

    def test_local_variable_write_node
      assert_implicit_array("a = *b")
      assert_implicit_array("a = 1, 2, 3")
    end

    def test_multi_write_node
      assert_implicit_array("a, b, c = *b")
      assert_implicit_array("a, b, c = 1, 2, 3")
    end

    private

    def assert_implicit_array(source)
      assert Prism.parse_success?(source)
      assert Prism.parse_failure?("if #{source} then end")

      assert_valid_syntax(source)
      refute_valid_syntax("if #{source} then end")
    end
  end
end
prism-1.5.1/test/prism/result/index_write_test.rb000066400000000000000000000034351506127434000222130ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class IndexWriteTest < TestCase
    def test_keywords_3_3
      assert_parse_success(<<~RUBY, "3.3.0")
        foo[bar: 1] = 1
        foo[bar: 1] &&= 1
        foo[bar: 1] ||= 1
        foo[bar: 1] += 1
      RUBY

      assert_parse_success(<<~RUBY, "3.3.0")
        def foo(**)
          bar[**] = 1
          bar[**] &&= 1
          bar[**] ||= 1
          bar[**] += 1
        end
      RUBY
    end

    def test_block_3_3
      assert_parse_success(<<~RUBY, "3.3.0")
        foo[&bar] = 1
        foo[&bar] &&= 1
        foo[&bar] ||= 1
        foo[&bar] += 1
      RUBY

      assert_parse_success(<<~RUBY, "3.3.0")
        def foo(&)
          bar[&] = 1
          bar[&] &&= 1
          bar[&] ||= 1
          bar[&] += 1
        end
      RUBY
    end

    def test_keywords_latest
      assert_parse_failure(<<~RUBY)
        foo[bar: 1] = 1
        foo[bar: 1] &&= 1
        foo[bar: 1] ||= 1
        foo[bar: 1] += 1
      RUBY

      assert_parse_failure(<<~RUBY)
        def foo(**)
          bar[**] = 1
          bar[**] &&= 1
          bar[**] ||= 1
          bar[**] += 1
        end
      RUBY
    end

    def test_block_latest
      assert_parse_failure(<<~RUBY)
        foo[&bar] = 1
        foo[&bar] &&= 1
        foo[&bar] ||= 1
        foo[&bar] += 1
      RUBY

      assert_parse_failure(<<~RUBY)
        def foo(&)
          bar[&] = 1
          bar[&] &&= 1
          bar[&] ||= 1
          bar[&] += 1
        end
      RUBY
    end

    private

    def assert_parse_success(source, version = "latest")
      assert Prism.parse_success?(source, version: version)
    end

    def assert_parse_failure(source, version = "latest")
      assert Prism.parse_failure?(source, version: version)
    end
  end
end
prism-1.5.1/test/prism/result/integer_base_flags_test.rb000066400000000000000000000017641506127434000235000ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class IntegerBaseFlagsTest < TestCase
    # Through some bit hackery, we want to allow consumers to use the integer
    # base flags as the base itself. It has a nice property that the current
    # alignment provides them in the correct order. So here we test that our
    # assumption holds so that it doesn't change out from under us.
    #
    # In C, this would look something like:
    #
    #     ((flags & ~DECIMAL) >> 1) || 10
    #
    # We have to do some other work in Ruby because 0 is truthy and ~ on an
    # integer doesn't have a fixed width.
    def test_flags
      assert_equal 2, base("0b1")
      assert_equal 8, base("0o1")
      assert_equal 10, base("0d1")
      assert_equal 16, base("0x1")
    end

    private

    def base(source)
      node = Prism.parse_statement(source)
      value = (node.send(:flags) & (0b111100 - IntegerBaseFlags::DECIMAL)) >> 1
      value == 0 ? 10 : value
    end
  end
end
prism-1.5.1/test/prism/result/integer_parse_test.rb000066400000000000000000000022541506127434000225170ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class IntegerParseTest < TestCase
    def test_integer_parse
      assert_integer_parse(1)
      assert_integer_parse(50)
      assert_integer_parse(100)
      assert_integer_parse(100, "1_0_0")
      assert_integer_parse(8, "0_1_0")

      assert_integer_parse(10, "0b1010")
      assert_integer_parse(10, "0B1010")
      assert_integer_parse(10, "0o12")
      assert_integer_parse(10, "0O12")
      assert_integer_parse(10, "012")
      assert_integer_parse(10, "0d10")
      assert_integer_parse(10, "0D10")
      assert_integer_parse(10, "0xA")
      assert_integer_parse(10, "0XA")

      assert_integer_parse(2**32)
      assert_integer_parse(2**64 + 2**32)
      assert_integer_parse(2**128 + 2**64 + 2**32)

      num = 99 ** 99
      assert_integer_parse(num, "0b#{num.to_s(2)}")
      assert_integer_parse(num, "0o#{num.to_s(8)}")
      assert_integer_parse(num, "0d#{num.to_s(10)}")
      assert_integer_parse(num, "0x#{num.to_s(16)}")
    end

    private

    def assert_integer_parse(expected, source = expected.to_s)
      assert_equal expected, Prism.parse_statement(source).value
    end
  end
end
prism-1.5.1/test/prism/result/named_capture_test.rb000066400000000000000000000011551506127434000224760ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class NamedCaptureTest < TestCase
    def test_hex_escapes
      assert_equal :😀, parse_name("\\xf0\\x9f\\x98\\x80")
    end

    def test_unicode_escape
      assert_equal :ã—, parse_name("\\u3057")
    end

    def test_unicode_escapes_bracess
      assert_equal :😀, parse_name("\\u{1f600}")
    end

    def test_octal_escapes
      assert_equal :😀, parse_name("\\xf0\\x9f\\x98\\200")
    end

    private

    def parse_name(content)
      Prism.parse_statement("/(?<#{content}>)/ =~ ''").targets.first.name
    end
  end
end
prism-1.5.1/test/prism/result/node_id_test.rb000066400000000000000000000010711506127434000212650ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class NodeIdTest < TestCase
    Fixture.each do |fixture|
      define_method(fixture.test_name) { assert_node_ids(fixture.read) }
    end

    private

    def assert_node_ids(source)
      queue = [Prism.parse(source).value]
      node_ids = []

      while (node = queue.shift)
        node_ids << node.node_id
        queue.concat(node.compact_child_nodes)
      end

      node_ids.sort!
      refute_includes node_ids, 0
      assert_equal node_ids, node_ids.uniq
    end
  end
end
prism-1.5.1/test/prism/result/numeric_value_test.rb000066400000000000000000000015071506127434000225260ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class NumericValueTest < TestCase
    def test_numeric_value
      assert_equal 123, Prism.parse_statement("123").value
      assert_equal 3.14, Prism.parse_statement("3.14").value
      assert_equal 42i, Prism.parse_statement("42i").value
      assert_equal 42.1ri, Prism.parse_statement("42.1ri").value
      assert_equal 3.14i, Prism.parse_statement("3.14i").value
      assert_equal 42r, Prism.parse_statement("42r").value
      assert_equal 0.5r, Prism.parse_statement("0.5r").value
      assert_equal 42ri, Prism.parse_statement("42ri").value
      assert_equal 0.5ri, Prism.parse_statement("0.5ri").value
      assert_equal 0xFFr, Prism.parse_statement("0xFFr").value
      assert_equal 0xFFri, Prism.parse_statement("0xFFri").value
    end
  end
end
prism-1.5.1/test/prism/result/overlap_test.rb000066400000000000000000000027021506127434000213360ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class OverlapTest < TestCase
    Fixture.each do |fixture|
      define_method(fixture.test_name) { assert_overlap(fixture) }
    end

    private

    # Check that the location ranges of each node in the tree are a superset of
    # their respective child nodes.
    def assert_overlap(fixture)
      queue = [Prism.parse_file(fixture.full_path).value]

      while (current = queue.shift)
        # We only want to compare parent/child location overlap in the case that
        # we are not looking at a heredoc. That's because heredoc locations are
        # special in that they only use the declaration of the heredoc.
        compare = !(current.is_a?(StringNode) ||
                    current.is_a?(XStringNode) ||
                    current.is_a?(InterpolatedStringNode) ||
                    current.is_a?(InterpolatedXStringNode)) ||
        !current.opening&.start_with?("<<")

        current.child_nodes.each do |child|
          # child_nodes can return nil values, so we need to skip those.
          next unless child

          # Now that we know we have a child node, add that to the queue.
          queue << child

          if compare
            assert_operator current.location.start_offset, :<=, child.location.start_offset
            assert_operator current.location.end_offset, :>=, child.location.end_offset
          end
        end
      end
    end
  end
end
prism-1.5.1/test/prism/result/regular_expression_options_test.rb000066400000000000000000000017611506127434000253650ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class RegularExpressionOptionsTest < TestCase
    def test_options
      assert_equal "", Prism.parse_statement("__FILE__").filepath
      assert_equal "foo.rb", Prism.parse_statement("__FILE__", filepath: "foo.rb").filepath

      assert_equal 1, Prism.parse_statement("foo").location.start_line
      assert_equal 10, Prism.parse_statement("foo", line: 10).location.start_line

      refute Prism.parse_statement("\"foo\"").frozen?
      assert Prism.parse_statement("\"foo\"", frozen_string_literal: true).frozen?
      refute Prism.parse_statement("\"foo\"", frozen_string_literal: false).frozen?

      assert_kind_of CallNode, Prism.parse_statement("foo")
      assert_kind_of LocalVariableReadNode, Prism.parse_statement("foo", scopes: [[:foo]])
      assert_equal 1, Prism.parse_statement("foo", scopes: [[:foo], []]).depth

      assert_equal [:foo], Prism.parse("foo", scopes: [[:foo]]).value.locals
    end
  end
end
prism-1.5.1/test/prism/result/source_location_test.rb000066400000000000000000000747051506127434000230720ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class SourceLocationTest < TestCase
    def test_AliasGlobalVariableNode
      assert_location(AliasGlobalVariableNode, "alias $foo $bar")
    end

    def test_AliasMethodNode
      assert_location(AliasMethodNode, "alias foo bar")
    end

    def test_AlternationPatternNode
      assert_location(AlternationPatternNode, "foo => bar | baz", 7...16, &:pattern)
    end

    def test_AndNode
      assert_location(AndNode, "foo and bar")
      assert_location(AndNode, "foo && bar")
    end

    def test_ArgumentsNode
      assert_location(ArgumentsNode, "foo(bar, baz, qux)", 4...17, &:arguments)
    end

    def test_ArrayNode
      assert_location(ArrayNode, "[foo, bar, baz]")
      assert_location(ArrayNode, "%i[foo bar baz]")
      assert_location(ArrayNode, "%I[foo bar baz]")
      assert_location(ArrayNode, "%w[foo bar baz]")
      assert_location(ArrayNode, "%W[foo bar baz]")
    end

    def test_ArrayPatternNode
      assert_location(ArrayPatternNode, "foo => bar, baz", 7...15, &:pattern)
      assert_location(ArrayPatternNode, "foo => [bar, baz]", 7...17, &:pattern)
      assert_location(ArrayPatternNode, "foo => *bar", 7...11, &:pattern)
      assert_location(ArrayPatternNode, "foo => []", 7...9, &:pattern)
      assert_location(ArrayPatternNode, "foo => Foo[]", 7...12, &:pattern)
      assert_location(ArrayPatternNode, "foo => Foo[bar]", 7...15, &:pattern)
    end

    def test_AssocNode
      assert_location(AssocNode, "{ '': 1 }", 2...7) { |node| node.elements.first }
      assert_location(AssocNode, "{ foo: :bar }", 2...11) { |node| node.elements.first }
      assert_location(AssocNode, "{ :foo => :bar }", 2...14) { |node| node.elements.first }
      assert_location(AssocNode, "foo(bar: :baz)", 4...13) { |node| node.arguments.arguments.first.elements.first }
    end

    def test_AssocSplatNode
      assert_location(AssocSplatNode, "{ **foo }", 2...7) { |node| node.elements.first }
      assert_location(AssocSplatNode, "foo(**bar)", 4...9) { |node| node.arguments.arguments.first.elements.first }
    end

    def test_BackReferenceReadNode
      assert_location(BackReferenceReadNode, "$+")
    end

    def test_BeginNode
      assert_location(BeginNode, "begin foo end")
      assert_location(BeginNode, "begin foo rescue bar end")
      assert_location(BeginNode, "begin foo; rescue bar\nelse baz end")
      assert_location(BeginNode, "begin foo; rescue bar\nelse baz\nensure qux end")

      assert_location(BeginNode, "class Foo\nrescue then end", 0..25, &:body)
      assert_location(BeginNode, "module Foo\nrescue then end", 0..26, &:body)
    end

    def test_BlockArgumentNode
      assert_location(BlockArgumentNode, "foo(&bar)", 4...8, &:block)
    end

    def test_BlockLocalVariableNode
      assert_location(BlockLocalVariableNode, "foo { |;bar| }", 8...11) do |node|
        node.block.parameters.locals.first
      end
    end

    def test_BlockNode
      assert_location(BlockNode, "foo {}", 4...6, &:block)
      assert_location(BlockNode, "foo do end", 4...10, &:block)
    end

    def test_BlockParameterNode
      assert_location(BlockParameterNode, "def foo(&bar) end", 8...12) { |node| node.parameters.block }
    end

    def test_BlockParametersNode
      assert_location(BlockParametersNode, "foo { || }", 6...8) { |node| node.block.parameters }
      assert_location(BlockParametersNode, "foo { |bar| baz }", 6...11) { |node| node.block.parameters }
      assert_location(BlockParametersNode, "foo { |bar; baz| baz }", 6...16) { |node| node.block.parameters }

      assert_location(BlockParametersNode, "-> () {}", 3...5, &:parameters)
      assert_location(BlockParametersNode, "-> (bar) { baz }", 3...8, &:parameters)
      assert_location(BlockParametersNode, "-> (bar; baz) { baz }", 3...13, &:parameters)
    end

    def test_BreakNode
      assert_location(BreakNode, "tap { break }", 6...11) { |node| node.block.body.body.first }
      assert_location(BreakNode, "tap { break foo }", 6...15) { |node| node.block.body.body.first }
      assert_location(BreakNode, "tap { break foo, bar }", 6...20) { |node| node.block.body.body.first }
      assert_location(BreakNode, "tap { break(foo) }", 6...16) { |node| node.block.body.body.first }
    end

    def test_CallNode
      assert_location(CallNode, "foo")
      assert_location(CallNode, "foo?")
      assert_location(CallNode, "foo!")

      assert_location(CallNode, "foo()")
      assert_location(CallNode, "foo?()")
      assert_location(CallNode, "foo!()")

      assert_location(CallNode, "foo(bar)")
      assert_location(CallNode, "foo?(bar)")
      assert_location(CallNode, "foo!(bar)")

      assert_location(CallNode, "!foo")
      assert_location(CallNode, "~foo")
      assert_location(CallNode, "+foo")
      assert_location(CallNode, "-foo")

      assert_location(CallNode, "not foo")
      assert_location(CallNode, "not(foo)")
      assert_location(CallNode, "not()")

      assert_location(CallNode, "foo + bar")
      assert_location(CallNode, "foo -\n  bar")

      assert_location(CallNode, "Foo()")
      assert_location(CallNode, "Foo(bar)")

      assert_location(CallNode, "Foo::Bar()")
      assert_location(CallNode, "Foo::Bar(baz)")

      assert_location(CallNode, "Foo::bar")
      assert_location(CallNode, "Foo::bar()")
      assert_location(CallNode, "Foo::bar(baz)")

      assert_location(CallNode, "Foo.bar")
      assert_location(CallNode, "Foo.bar()")
      assert_location(CallNode, "Foo.bar(baz)")

      assert_location(CallNode, "foo::bar")
      assert_location(CallNode, "foo::bar()")
      assert_location(CallNode, "foo::bar(baz)")

      assert_location(CallNode, "foo.bar")
      assert_location(CallNode, "foo.bar()")
      assert_location(CallNode, "foo.bar(baz)")

      assert_location(CallNode, "foo&.bar")
      assert_location(CallNode, "foo&.bar()")
      assert_location(CallNode, "foo&.bar(baz)")

      assert_location(CallNode, "foo[]")
      assert_location(CallNode, "foo[bar]")
      assert_location(CallNode, "foo[bar, baz]")

      assert_location(CallNode, "foo[] = 1")
      assert_location(CallNode, "foo[bar] = 1")
      assert_location(CallNode, "foo[bar, baz] = 1")

      assert_location(CallNode, "foo.()")
      assert_location(CallNode, "foo.(bar)")

      assert_location(CallNode, "foo&.()")
      assert_location(CallNode, "foo&.(bar)")

      assert_location(CallNode, "foo::()")
      assert_location(CallNode, "foo::(bar)")
      assert_location(CallNode, "foo::(bar, baz)")

      assert_location(CallNode, "foo bar baz")
      assert_location(CallNode, "foo bar('baz')")
    end

    def test_CallAndWriteNode
      assert_location(CallAndWriteNode, "foo.foo &&= bar")
    end

    def test_CallOperatorWriteNode
      assert_location(CallOperatorWriteNode, "foo.foo += bar")
    end

    def test_CallOrWriteNode
      assert_location(CallOrWriteNode, "foo.foo ||= bar")
    end

    def test_CallTargetNode
      assert_location(CallTargetNode, "foo.bar, = baz", 0...7) do |node|
        node.lefts.first
      end
    end

    def test_CapturePatternNode
      assert_location(CapturePatternNode, "case foo; in bar => baz; end", 13...23) do |node|
        node.conditions.first.pattern
      end
    end

    def test_CaseNode
      assert_location(CaseNode, "case foo; when bar; end")
      assert_location(CaseNode, "case foo; when bar; else; end")
      assert_location(CaseNode, "case foo; when bar; when baz; end")
      assert_location(CaseNode, "case foo; when bar; when baz; else; end")
    end

    def test_CaseMatchNode
      assert_location(CaseMatchNode, "case foo; in bar; end")
      assert_location(CaseMatchNode, "case foo; in bar; else; end")
      assert_location(CaseMatchNode, "case foo; in bar; in baz; end")
      assert_location(CaseMatchNode, "case foo; in bar; in baz; else; end")
    end

    def test_ClassNode
      assert_location(ClassNode, "class Foo end")
      assert_location(ClassNode, "class Foo < Bar; end")
    end

    def test_ClassVariableAndWriteNode
      assert_location(ClassVariableAndWriteNode, "@@foo &&= bar")
    end

    def test_ClassVariableOperatorWriteNode
      assert_location(ClassVariableOperatorWriteNode, "@@foo += bar")
    end

    def test_ClassVariableOrWriteNode
      assert_location(ClassVariableOrWriteNode, "@@foo ||= bar")
    end

    def test_ClassVariableReadNode
      assert_location(ClassVariableReadNode, "@@foo")
    end

    def test_ClassVariableTargetNode
      assert_location(ClassVariableTargetNode, "@@foo, @@bar = baz", 0...5) do |node|
        node.lefts.first
      end
    end

    def test_ClassVariableWriteNode
      assert_location(ClassVariableWriteNode, "@@foo = bar")
    end

    def test_ConstantPathAndWriteNode
      assert_location(ConstantPathAndWriteNode, "Parent::Child &&= bar")
    end

    def test_ConstantPathNode
      assert_location(ConstantPathNode, "Foo::Bar")
      assert_location(ConstantPathNode, "::Foo")
      assert_location(ConstantPathNode, "::Foo::Bar")
    end

    def test_ConstantPathOperatorWriteNode
      assert_location(ConstantPathOperatorWriteNode, "Parent::Child += bar")
    end

    def test_ConstantPathOrWriteNode
      assert_location(ConstantPathOrWriteNode, "Parent::Child ||= bar")
    end

    def test_ConstantPathTargetNode
      assert_location(ConstantPathTargetNode, "::Foo, ::Bar = baz", 0...5) do |node|
        node.lefts.first
      end
    end

    def test_ConstantPathWriteNode
      assert_location(ConstantPathWriteNode, "Foo::Bar = baz")
      assert_location(ConstantPathWriteNode, "::Foo = bar")
      assert_location(ConstantPathWriteNode, "::Foo::Bar = baz")
    end

    def test_ConstantAndWriteNode
      assert_location(ConstantAndWriteNode, "Foo &&= bar")
    end

    def test_ConstantOperatorWriteNode
      assert_location(ConstantOperatorWriteNode, "Foo += bar")
    end

    def test_ConstantOrWriteNode
      assert_location(ConstantOrWriteNode, "Foo ||= bar")
    end

    def test_ConstantReadNode
      assert_location(ConstantReadNode, "Foo")
    end

    def test_ConstantTargetNode
      assert_location(ConstantTargetNode, "Foo, Bar = baz", 0...3) do |node|
        node.lefts.first
      end
    end

    def test_ConstantWriteNode
      assert_location(ConstantWriteNode, "Foo = bar")
    end

    def test_DefNode
      assert_location(DefNode, "def foo; bar; end")
      assert_location(DefNode, "def foo = bar")
      assert_location(DefNode, "def foo.bar; baz; end")
      assert_location(DefNode, "def foo.bar = baz")
    end

    def test_DefinedNode
      assert_location(DefinedNode, "defined? foo")
      assert_location(DefinedNode, "defined?(foo)")
    end

    def test_ElseNode
      assert_location(ElseNode, "if foo; bar; else; baz; end", 13...27, &:subsequent)
      assert_location(ElseNode, "foo ? bar : baz", 10...15, &:subsequent)
    end

    def test_EmbeddedStatementsNode
      assert_location(EmbeddedStatementsNode, '"foo #{bar} baz"', 5...11) { |node| node.parts[1] }
    end

    def test_EmbeddedVariableNode
      assert_location(EmbeddedVariableNode, '"foo #@@bar baz"', 5...11) { |node| node.parts[1] }
    end

    def test_EnsureNode
      assert_location(EnsureNode, "begin; foo; ensure; bar; end", 12...28, &:ensure_clause)
    end

    def test_FalseNode
      assert_location(FalseNode, "false")
    end

    def test_FindPatternNode
      assert_location(FindPatternNode, "case foo; in *, bar, *; end", 13...22) do |node|
        node.conditions.first.pattern
      end
    end

    def test_FlipFlopNode
      assert_location(FlipFlopNode, "if foo..bar; end", 3..11, &:predicate)
    end

    def test_FloatNode
      assert_location(FloatNode, "0.0")
      assert_location(FloatNode, "1.0")
      assert_location(FloatNode, "1.0e10")
      assert_location(FloatNode, "1.0e-10")
    end

    def test_ForNode
      assert_location(ForNode, "for foo in bar; end")
      assert_location(ForNode, "for foo, bar in baz do end")
    end

    def test_ForwardingArgumentsNode
      assert_location(ForwardingArgumentsNode, "def foo(...); bar(...); end", 18...21) do |node|
        node.body.body.first.arguments.arguments.first
      end
    end

    def test_ForwardingParameterNode
      assert_location(ForwardingParameterNode, "def foo(...); end", 8...11) do |node|
        node.parameters.keyword_rest
      end
    end

    def test_ForwardingSuperNode
      assert_location(ForwardingSuperNode, "super")
      assert_location(ForwardingSuperNode, "super {}")
    end

    def test_GlobalVariableAndWriteNode
      assert_location(GlobalVariableAndWriteNode, "$foo &&= bar")
    end

    def test_GlobalVariableOperatorWriteNode
      assert_location(GlobalVariableOperatorWriteNode, "$foo += bar")
    end

    def test_GlobalVariableOrWriteNode
      assert_location(GlobalVariableOrWriteNode, "$foo ||= bar")
    end

    def test_GlobalVariableReadNode
      assert_location(GlobalVariableReadNode, "$foo")
    end

    def test_GlobalVariableTargetNode
      assert_location(GlobalVariableTargetNode, "$foo, $bar = baz", 0...4) do |node|
        node.lefts.first
      end
    end

    def test_GlobalVariableWriteNode
      assert_location(GlobalVariableWriteNode, "$foo = bar")
    end

    def test_HashNode
      assert_location(HashNode, "{ foo: 2 }")
      assert_location(HashNode, "{ \nfoo: 2, \nbar: 3 \n}")
    end

    def test_HashPatternNode
      assert_location(HashPatternNode, "case foo; in bar: baz; end", 13...21) do |node|
        node.conditions.first.pattern
      end
    end

    def test_IfNode
      assert_location(IfNode, "if type in 1;elsif type in B;end")
    end

    def test_ImaginaryNode
      assert_location(ImaginaryNode, "1i")
      assert_location(ImaginaryNode, "1ri")
    end

    def test_ImplicitNode
      assert_location(ImplicitNode, "{ foo: }", 2...6) do |node|
        node.elements.first.value
      end

      assert_location(ImplicitNode, "{ Foo: }", 2..6) do |node|
        node.elements.first.value
      end

      assert_location(ImplicitNode, "foo = 1; { foo: }", 11..15) do |node|
        node.elements.first.value
      end
    end

    def test_ImplicitRestNode
      assert_location(ImplicitRestNode, "foo, = bar", 3..4, &:rest)

      assert_location(ImplicitRestNode, "for foo, in bar do end", 7..8) do |node|
        node.index.rest
      end

      assert_location(ImplicitRestNode, "foo { |bar,| }", 10..11) do |node|
        node.block.parameters.parameters.rest
      end

      assert_location(ImplicitRestNode, "foo in [bar,]", 11..12) do |node|
        node.pattern.rest
      end
    end

    def test_InNode
      assert_location(InNode, "case foo; in bar; end", 10...16) do |node|
        node.conditions.first
      end
    end

    def test_IndexAndWriteNode
      assert_location(IndexAndWriteNode, "foo[foo] &&= bar")
    end

    def test_IndexOperatorWriteNode
      assert_location(IndexOperatorWriteNode, "foo[foo] += bar")
    end

    def test_IndexOrWriteNode
      assert_location(IndexOrWriteNode, "foo[foo] ||= bar")
    end

    def test_IndexTargetNode
      assert_location(IndexTargetNode, "foo[bar], = qux", 0...8) do |node|
        node.lefts.first
      end
    end

    def test_InstanceVariableAndWriteNode
      assert_location(InstanceVariableAndWriteNode, "@foo &&= bar")
    end

    def test_InstanceVariableOperatorWriteNode
      assert_location(InstanceVariableOperatorWriteNode, "@foo += bar")
    end

    def test_InstanceVariableOrWriteNode
      assert_location(InstanceVariableOrWriteNode, "@foo ||= bar")
    end

    def test_InstanceVariableReadNode
      assert_location(InstanceVariableReadNode, "@foo")
    end

    def test_InstanceVariableTargetNode
      assert_location(InstanceVariableTargetNode, "@foo, @bar = baz", 0...4) do |node|
        node.lefts.first
      end
    end

    def test_InstanceVariableWriteNode
      assert_location(InstanceVariableWriteNode, "@foo = bar")
    end

    def test_IntegerNode
      assert_location(IntegerNode, "0")
      assert_location(IntegerNode, "1")
      assert_location(IntegerNode, "1_000")
      assert_location(IntegerNode, "0x1")
      assert_location(IntegerNode, "0x1_000")
      assert_location(IntegerNode, "0b1")
      assert_location(IntegerNode, "0b1_000")
      assert_location(IntegerNode, "0o1")
      assert_location(IntegerNode, "0o1_000")
    end

    def test_InterpolatedMatchLastLineNode
      assert_location(InterpolatedMatchLastLineNode, "if /foo \#{bar}/ then end", 3...15, &:predicate)
    end

    def test_InterpolatedRegularExpressionNode
      assert_location(InterpolatedRegularExpressionNode, "/\#{foo}/")
      assert_location(InterpolatedRegularExpressionNode, "/\#{foo}/io")
    end

    def test_InterpolatedStringNode
      assert_location(InterpolatedStringNode, "\"foo \#@bar baz\"")
      assert_location(InterpolatedStringNode, "<<~A\nhello \#{1} world\nA", 0...4)
      assert_location(InterpolatedStringNode, '"foo" "bar"')
    end

    def test_InterpolatedSymbolNode
      assert_location(InterpolatedSymbolNode, ':"#{foo}bar"')
    end

    def test_InterpolatedXStringNode
      assert_location(InterpolatedXStringNode, '`foo #{bar} baz`')
    end

    def test_ItLocalVariableReadNode
      assert_location(ItLocalVariableReadNode, "-> { it }", 5...7) do |node|
        node.body.body.first
      end

      assert_location(ItLocalVariableReadNode, "foo { it }", 6...8) do |node|
        node.block.body.body.first
      end

      assert_location(CallNode, "-> { it }", 5...7, version: "3.3.0") do |node|
        node.body.body.first
      end

      assert_location(ItLocalVariableReadNode, "-> { it }", 5...7, version: "3.4.0") do |node|
        node.body.body.first
      end
    end

    def test_ItParametersNode
      assert_location(ItParametersNode, "-> { it }", &:parameters)
    end

    def test_KeywordHashNode
      assert_location(KeywordHashNode, "foo(a, b: 1)", 7...11) { |node| node.arguments.arguments[1] }
    end

    def test_KeywordRestParameterNode
      assert_location(KeywordRestParameterNode, "def foo(**); end", 8...10) do |node|
        node.parameters.keyword_rest
      end

      assert_location(KeywordRestParameterNode, "def foo(**bar); end", 8...13) do |node|
        node.parameters.keyword_rest
      end
    end

    def test_LambdaNode
      assert_location(LambdaNode, "-> { foo }")
      assert_location(LambdaNode, "-> do foo end")
    end

    def test_LocalVariableAndWriteNode
      assert_location(LocalVariableAndWriteNode, "foo &&= bar")
      assert_location(LocalVariableAndWriteNode, "foo = 1; foo &&= bar", 9...20)
    end

    def test_LocalVariableOperatorWriteNode
      assert_location(LocalVariableOperatorWriteNode, "foo += bar")
      assert_location(LocalVariableOperatorWriteNode, "foo = 1; foo += bar", 9...19)
    end

    def test_LocalVariableOrWriteNode
      assert_location(LocalVariableOrWriteNode, "foo ||= bar")
      assert_location(LocalVariableOrWriteNode, "foo = 1; foo ||= bar", 9...20)
    end

    def test_LocalVariableReadNode
      assert_location(LocalVariableReadNode, "foo = 1; foo", 9...12)
    end

    def test_LocalVariableTargetNode
      assert_location(LocalVariableTargetNode, "foo, bar = baz", 0...3) do |node|
        node.lefts.first
      end
    end

    def test_LocalVariableWriteNode
      assert_location(LocalVariableWriteNode, "foo = bar")
    end

    def test_MatchLastLineNode
      assert_location(MatchLastLineNode, "if /foo/ then end", 3...8, &:predicate)
    end

    def test_MatchPredicateNode
      assert_location(MatchPredicateNode, "foo in bar")
    end

    def test_MatchRequiredNode
      assert_location(MatchRequiredNode, "foo => bar")
    end

    def test_MatchWriteNode
      assert_location(MatchWriteNode, "/(?)/ =~ foo")
    end

    def test_ModuleNode
      assert_location(ModuleNode, "module Foo end")
    end

    def test_MultiTargetNode
      assert_location(MultiTargetNode, "for foo, bar in baz do end", 4...12, &:index)
      assert_location(MultiTargetNode, "foo, (bar, baz) = qux", 5...15) { |node| node.lefts.last }
      assert_location(MultiTargetNode, "def foo((bar)); end", 8...13) do |node|
        node.parameters.requireds.first
      end
    end

    def test_MultiWriteNode
      assert_location(MultiWriteNode, "foo, bar = baz")
      assert_location(MultiWriteNode, "(foo, bar) = baz")
      assert_location(MultiWriteNode, "((foo, bar)) = baz")
    end

    def test_NextNode
      assert_location(NextNode, "tap { next }", 6...10) { |node| node.block.body.body.first }
      assert_location(NextNode, "tap { next foo }", 6...14) { |node| node.block.body.body.first }
      assert_location(NextNode, "tap { next foo, bar }", 6...19) { |node| node.block.body.body.first }
      assert_location(NextNode, "tap { next(foo) }", 6...15) { |node| node.block.body.body.first }
    end

    def test_NilNode
      assert_location(NilNode, "nil")
    end

    def test_NoKeywordsParameterNode
      assert_location(NoKeywordsParameterNode, "def foo(**nil); end", 8...13) { |node| node.parameters.keyword_rest }
    end

    def test_NumberedParametersNode
      assert_location(NumberedParametersNode, "-> { _1 }", &:parameters)
      assert_location(NumberedParametersNode, "foo { _1 }", 4...10) { |node| node.block.parameters }
    end

    def test_NumberedReferenceReadNode
      assert_location(NumberedReferenceReadNode, "$1")
    end

    def test_OptionalKeywordParameterNode
      assert_location(OptionalKeywordParameterNode, "def foo(bar: nil); end", 8...16) do |node|
        node.parameters.keywords.first
      end
    end

    def test_OptionalParameterNode
      assert_location(OptionalParameterNode, "def foo(bar = nil); end", 8...17) do |node|
        node.parameters.optionals.first
      end
    end

    def test_OrNode
      assert_location(OrNode, "foo || bar")
      assert_location(OrNode, "foo or bar")
    end

    def test_ParametersNode
      assert_location(ParametersNode, "def foo(bar, baz); end", 8...16, &:parameters)
    end

    def test_ParenthesesNode
      assert_location(ParenthesesNode, "()")
      assert_location(ParenthesesNode, "(foo)")
      assert_location(ParenthesesNode, "foo (bar), baz", 4...9) { |node| node.arguments.arguments.first }
      assert_location(ParenthesesNode, "def (foo).bar; end", 4...9, &:receiver)
    end

    def test_PinnedExpressionNode
      assert_location(PinnedExpressionNode, "foo in ^(bar)", 7...13, &:pattern)
    end

    def test_PinnedVariableNode
      assert_location(PinnedVariableNode, "bar = 1; foo in ^bar", 16...20, &:pattern)
      assert_location(PinnedVariableNode, "proc { 1 in ^it }.call(1)", 12...15) do |node|
        node.receiver.block.body.body.first.pattern
      end
    end

    def test_PostExecutionNode
      assert_location(PostExecutionNode, "END {}")
      assert_location(PostExecutionNode, "END { foo }")
    end

    def test_PreExecutionNode
      assert_location(PreExecutionNode, "BEGIN {}")
      assert_location(PreExecutionNode, "BEGIN { foo }")
    end

    def test_RangeNode
      assert_location(RangeNode, "1..2")
      assert_location(RangeNode, "1...2")

      assert_location(RangeNode, "..2")
      assert_location(RangeNode, "...2")

      assert_location(RangeNode, "1..")
      assert_location(RangeNode, "1...")
    end

    def test_RationalNode
      assert_location(RationalNode, "1r")
      assert_location(RationalNode, "1.0r")
    end

    def test_RedoNode
      assert_location(RedoNode, "tap { redo }", 6...10) { |node| node.block.body.body.first }
    end

    def test_RegularExpressionNode
      assert_location(RegularExpressionNode, "/foo/")
      assert_location(RegularExpressionNode, "/foo/io")
    end

    def test_RequiredKeywordParameterNode
      assert_location(RequiredKeywordParameterNode, "def foo(bar:); end", 8...12) do |node|
        node.parameters.keywords.first
      end
    end

    def test_RequiredParameterNode
      assert_location(RequiredParameterNode, "def foo(bar); end", 8...11) do |node|
        node.parameters.requireds.first
      end
    end

    def test_RescueNode
      code = <<~RUBY
      begin
        body
      rescue TypeError
      rescue ArgumentError
      end
      RUBY
      assert_location(RescueNode, code, 13...50) { |node| node.rescue_clause }
      assert_location(RescueNode, code, 30...50) { |node| node.rescue_clause.subsequent }
    end

    def test_RescueModifierNode
      assert_location(RescueModifierNode, "foo rescue bar")
    end

    def test_RestParameterNode
      assert_location(RestParameterNode, "def foo(*bar); end", 8...12) do |node|
        node.parameters.rest
      end
    end

    def test_RetryNode
      assert_location(RetryNode, "begin; rescue; retry; end", 15...20) { |node| node.rescue_clause.statements.body.first }
    end

    def test_ReturnNode
      assert_location(ReturnNode, "return")
      assert_location(ReturnNode, "return foo")
      assert_location(ReturnNode, "return foo, bar")
      assert_location(ReturnNode, "return(foo)")
    end

    def test_SelfNode
      assert_location(SelfNode, "self")
    end

    def test_ShareableConstantNode
      source = <<~RUBY
        # shareable_constant_value: literal
        C = { foo: 1 }
      RUBY

      assert_location(ShareableConstantNode, source, 36...50)
    end

    def test_SingletonClassNode
      assert_location(SingletonClassNode, "class << self; end")
    end

    def test_SourceEncodingNode
      assert_location(SourceEncodingNode, "__ENCODING__")
    end

    def test_SourceFileNode
      assert_location(SourceFileNode, "__FILE__")
    end

    def test_SourceLineNode
      assert_location(SourceLineNode, "__LINE__")
    end

    def test_SplatNode
      assert_location(SplatNode, "*foo = bar", 0...4, &:rest)
    end

    def test_StatementsNode
      assert_location(StatementsNode, "foo { 1 }", 6...7) { |node| node.block.body }

      assert_location(StatementsNode, "(1)", 1...2, &:body)

      assert_location(StatementsNode, "def foo; 1; end", 9...10, &:body)
      assert_location(StatementsNode, "def foo = 1", 10...11, &:body)
      assert_location(StatementsNode, "def foo; 1\n2; end", 9...12, &:body)

      assert_location(StatementsNode, "if foo; bar; end", 8...11, &:statements)
      assert_location(StatementsNode, "foo if bar", 0...3, &:statements)

      assert_location(StatementsNode, "if foo; foo; elsif bar; bar; end", 24...27) { |node| node.subsequent.statements }
      assert_location(StatementsNode, "if foo; foo; else; bar; end", 19...22) { |node| node.subsequent.statements }

      assert_location(StatementsNode, "unless foo; bar; end", 12...15, &:statements)
      assert_location(StatementsNode, "foo unless bar", 0...3, &:statements)

      assert_location(StatementsNode, "case; when foo; bar; end", 16...19) { |node| node.conditions.first.statements }

      assert_location(StatementsNode, "while foo; bar; end", 11...14, &:statements)
      assert_location(StatementsNode, "foo while bar", 0...3, &:statements)

      assert_location(StatementsNode, "until foo; bar; end", 11...14, &:statements)
      assert_location(StatementsNode, "foo until bar", 0...3, &:statements)

      assert_location(StatementsNode, "for foo in bar; baz; end", 16...19, &:statements)

      assert_location(StatementsNode, "begin; foo; end", 7...10, &:statements)
      assert_location(StatementsNode, "begin; rescue; foo; end", 15...18) { |node| node.rescue_clause.statements }
      assert_location(StatementsNode, "begin; ensure; foo; end", 15...18) { |node| node.ensure_clause.statements }
      assert_location(StatementsNode, "begin; rescue; else; foo; end", 21...24) { |node| node.else_clause.statements }

      assert_location(StatementsNode, "class Foo; foo; end", 11...14, &:body)
      assert_location(StatementsNode, "module Foo; foo; end", 12...15, &:body)
      assert_location(StatementsNode, "class << self; foo; end", 15...18, &:body)

      assert_location(StatementsNode, "-> { foo }", 5...8, &:body)
      assert_location(StatementsNode, "BEGIN { foo }", 8...11, &:statements)
      assert_location(StatementsNode, "END { foo }", 6...9, &:statements)

      assert_location(StatementsNode, "\"\#{foo}\"", 3...6) { |node| node.parts.first.statements }
    end

    def test_StringNode
      assert_location(StringNode, '"foo"')
      assert_location(StringNode, '%q[foo]')
    end

    def test_SuperNode
      assert_location(SuperNode, "super foo")
      assert_location(SuperNode, "super foo, bar")

      assert_location(SuperNode, "super()")
      assert_location(SuperNode, "super(foo)")
      assert_location(SuperNode, "super(foo, bar)")

      assert_location(SuperNode, "super() {}")
    end

    def test_SymbolNode
      assert_location(SymbolNode, ":foo")
    end

    def test_TrueNode
      assert_location(TrueNode, "true")
    end

    def test_UndefNode
      assert_location(UndefNode, "undef foo")
      assert_location(UndefNode, "undef foo, bar")
    end

    def test_UnlessNode
      assert_location(UnlessNode, "foo unless bar")
      assert_location(UnlessNode, "unless bar; foo; end")
    end

    def test_UntilNode
      assert_location(UntilNode, "foo = bar until baz")
      assert_location(UntilNode, "until bar;baz;end")
    end

    def test_WhenNode
      assert_location(WhenNode, "case foo; when bar; end", 10...18) { |node| node.conditions.first }
    end

    def test_WhileNode
      assert_location(WhileNode, "foo = bar while foo != baz")
      assert_location(WhileNode, "while a;bar;baz;end")
    end

    def test_XStringNode
      assert_location(XStringNode, "`foo`")
      assert_location(XStringNode, "%x[foo]")
    end

    def test_YieldNode
      assert_location(YieldNode, "def test; yield; end", 10...15) { |node| node.body.body.first }
      assert_location(YieldNode, "def test; yield foo; end", 10...19) { |node| node.body.body.first }
      assert_location(YieldNode, "def test; yield foo, bar; end", 10...24) { |node| node.body.body.first }
      assert_location(YieldNode, "def test; yield(foo); end", 10...20) { |node| node.body.body.first }
    end

    def test_all_tested
      expected = Prism.constants.grep(/.Node$/).sort - %i[MissingNode ProgramNode]
      actual = SourceLocationTest.instance_methods(false).grep(/.Node$/).map { |name| name[5..].to_sym }.sort
      assert_equal expected, actual
    end

    private

    def assert_location(kind, source, expected = 0...source.length, **options)
      result = Prism.parse(source, **options)
      assert result.success?

      node = result.value.statements.body.last
      node = yield node if block_given?

      if expected.begin == 0
        assert_equal 0, node.location.start_column
      end

      if expected.end == source.length
        assert_equal source.split("\n").last.length, node.location.end_column
      end

      assert_kind_of kind, node
      assert_equal expected.begin, node.location.start_offset
      assert_equal expected.end, node.location.end_offset
    end
  end
end
prism-1.5.1/test/prism/result/static_inspect_test.rb000066400000000000000000000053721506127434000227100ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class StaticInspectTest < TestCase
    def test_false
      assert_equal "false", static_inspect("false")
    end

    def test_float
      assert_equal "0.25", static_inspect("0.25")
      assert_equal "5.125", static_inspect("5.125")

      assert_equal "0.0", static_inspect("0.0")
      assert_equal "-0.0", static_inspect("-0.0")

      assert_equal "1.0e+100", static_inspect("1e100")
      assert_equal "-1.0e+100", static_inspect("-1e100")

      assert_equal "Infinity", static_inspect("1e1000")
      assert_equal "-Infinity", static_inspect("-1e1000")
    end

    def test_imaginary
      assert_equal "(0+1i)", static_inspect("1i")
      assert_equal "(0-1i)", static_inspect("-1i")
    end

    def test_integer
      assert_equal "1000", static_inspect("1_0_0_0")
      assert_equal "10000000000000000000000000000", static_inspect("1_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0")
    end

    def test_nil
      assert_equal "nil", static_inspect("nil")
    end

    def test_rational
      assert_equal "(0/1)", static_inspect("0r")
      assert_equal "(1/1)", static_inspect("1r")
      assert_equal "(1/1)", static_inspect("1.0r")
      assert_equal "(77777/1000)", static_inspect("77.777r")
    end

    def test_regular_expression
      assert_equal "/.*/", static_inspect("/.*/")
      assert_equal "/.*/i", static_inspect("/.*/i")
      assert_equal "/.*/", static_inspect("/.*/u")
      assert_equal "/.*/n", static_inspect("/.*/un")
    end

    def test_source_encoding
      assert_equal "#", static_inspect("__ENCODING__")
      assert_equal "#", static_inspect("__ENCODING__", encoding: "Windows-31J")
    end

    def test_source_file
      assert_equal __FILE__.inspect, static_inspect("__FILE__", filepath: __FILE__, frozen_string_literal: true)
    end

    def test_source_line
      assert_equal "1", static_inspect("__LINE__")
      assert_equal "5", static_inspect("__LINE__", line: 5)
    end

    def test_string
      assert_equal "\"\"", static_inspect('""', frozen_string_literal: true)
      assert_equal "\"Hello, World!\"", static_inspect('"Hello, World!"', frozen_string_literal: true)
      assert_equal "\"\\a\"", static_inspect("\"\\a\"", frozen_string_literal: true)
    end

    def test_symbol
      assert_equal ":foo", static_inspect(":foo")
      assert_equal ":foo", static_inspect("%s[foo]")
    end

    def test_true
      assert_equal "true", static_inspect("true")
    end

    private

    def static_inspect(source, **options)
      warnings = Prism.parse("{ #{source} => 1, #{source} => 1 }", **options).warnings
      warnings.last.message[/^key (.+) is duplicated and overwritten on line \d/, 1]
    end
  end
end
prism-1.5.1/test/prism/result/static_literals_test.rb000066400000000000000000000046651506127434000230660ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class StaticLiteralsTest < TestCase
    def test_static_literals
      assert_warning("1")
      assert_warning("0xA", "10", "10")
      assert_warning("0o10", "8", "8")
      assert_warning("0b10", "2", "2")
      assert_warning("1_000", "1000", "1000")
      assert_warning((2**32).to_s(10), "0x#{(2**32).to_s(16)}", (2**32).to_s(10))
      assert_warning((2**64).to_s(10), "0x#{(2**64).to_s(16)}", (2**64).to_s(10))

      refute_warning("1", "-1")
      refute_warning((2**32).to_s(10), "-0x#{(2**32).to_s(16)}")
      refute_warning((2**64).to_s(10), "-0x#{(2**64).to_s(16)}")

      assert_warning("__LINE__", "2", "2")
      assert_warning("3", "__LINE__", "3")

      assert_warning("1.0")
      assert_warning("1e2", "100.0", "100.0")

      assert_warning("1r", "1r", "(1/1)")
      assert_warning("1.0r", "1.0r", "(1/1)")

      assert_warning("1i", "1i", "(0+1i)")
      assert_warning("1.0i", "1.0i", "(0+1.0i)")

      assert_warning("1ri", "1ri", "(0+(1/1)*i)")
      assert_warning("1.0ri", "1.0ri", "(0+(1/1)*i)")

      assert_warning("__FILE__", "\"#{__FILE__}\"", __FILE__)
      assert_warning("\"#{__FILE__}\"")
      assert_warning("\"foo\"")

      assert_warning("/foo/")

      refute_warning("/foo/", "/foo/i")

      assert_warning(":foo")
      assert_warning("%s[foo]", ":foo", ":foo")

      assert_warning("true")
      assert_warning("false")
      assert_warning("nil")
      assert_warning("__ENCODING__", "__ENCODING__", "#")
    end

    private

    class NullWarning
      def message
        ""
      end
    end

    def parse_warnings(left, right)
      warnings = []

      warnings << (Prism.parse(<<~RUBY, filepath: __FILE__).warnings.first || NullWarning.new)
        {
          #{left} => 1,
          #{right} => 2
        }
      RUBY

      warnings << (Prism.parse(<<~RUBY, filepath: __FILE__).warnings.first || NullWarning.new)
        case foo
        when #{left}
        when #{right}
        end
      RUBY

      warnings
    end

    def assert_warning(left, right = left, message = left)
      hash_keys, when_clauses = parse_warnings(left, right)

      assert_include hash_keys.message, message
      assert_include hash_keys.message, "line 3"
      assert_include when_clauses.message, "line 3"
    end

    def refute_warning(left, right)
      assert_empty parse_warnings(left, right).grep_v(NullWarning)
    end
  end
end
prism-1.5.1/test/prism/result/string_test.rb000066400000000000000000000015231506127434000211740ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class StringTest < TestCase
    def test_regular_expression_node_unescaped_frozen
      node = Prism.parse_statement("/foo/")
      assert_predicate node.unescaped, :frozen?
    end

    def test_source_file_node_filepath_frozen
      node = Prism.parse_statement("__FILE__")
      assert_predicate node.filepath, :frozen?
    end

    def test_string_node_unescaped_frozen
      node = Prism.parse_statement('"foo"')
      assert_predicate node.unescaped, :frozen?
    end

    def test_symbol_node_unescaped_frozen
      node = Prism.parse_statement(":foo")
      assert_predicate node.unescaped, :frozen?
    end

    def test_xstring_node_unescaped_frozen
      node = Prism.parse_statement("`foo`")
      assert_predicate node.unescaped, :frozen?
    end
  end
end
prism-1.5.1/test/prism/result/warnings_test.rb000066400000000000000000000426271506127434000215300ustar00rootroot00000000000000# frozen_string_literal: true

return if RUBY_VERSION < "3.1"

require_relative "../test_helper"

module Prism
  class WarningsTest < TestCase
    def test_ambiguous_uminus
      assert_warning("a -b", "ambiguous first argument")
    end

    def test_ambiguous_uplus
      assert_warning("a +b", "ambiguous first argument")
    end

    def test_ambiguous_ustar
      assert_warning("a *b", "argument prefix")
    end

    def test_ambiguous_regexp
      assert_warning("a /b/", "wrap regexp in parentheses")
    end

    def test_ambiguous_ampersand
      assert_warning("a &b", "argument prefix")
      assert_warning("a &:+", "argument prefix")

      refute_warning("a &:b")
      refute_warning("a &:'b'")
      refute_warning("a &:\"b\"")
    end

    def test_binary_operator
      [
        [:**, "argument prefix"],
        [:*, "argument prefix"],
        [:<<, "here document"],
        [:&, "argument prefix"],
        [:+, "unary operator"],
        [:-, "unary operator"],
        [:/, "regexp literal"],
        [:%, "string literal"]
      ].each do |(operator, warning)|
        assert_warning("puts 1 #{operator}0", warning)
        assert_warning("puts :a #{operator}0", warning)
        assert_warning("m = 1; puts m #{operator}0", warning)
      end
    end

    def test_equal_in_conditional
      assert_warning("if a = 1; end; a = a", "should be ==")
    end

    def test_dot_dot_dot_eol
      assert_warning("_ = foo...", "... at EOL")
      assert_warning("def foo(...) = bar ...", "... at EOL")

      assert_warning("_ = foo... #", "... at EOL")
      assert_warning("_ = foo... \t\v\f\n", "... at EOL")

      refute_warning("p foo...bar")
      refute_warning("p foo...      bar")
    end

    def test_END_in_method
      assert_warning("def foo; END {}; end", "END in method")
    end

    def test_duplicated_hash_key
      assert_warning("{ a: 1, a: 2 }", "duplicated and overwritten")
      assert_warning("{ a: 1, **{ a: 2 } }", "duplicated and overwritten")
    end

    def test_duplicated_when_clause
      assert_warning("case 1; when 1, 1; end", "when' clause")
    end

    def test_float_out_of_range
      assert_warning("_ = 1.0e100000", "out of range")
    end

    def test_indentation_mismatch
      assert_warning("if true\n  end", "mismatched indentations at 'end' with 'if'")
      assert_warning("if true\n  elsif true\nend", "mismatched indentations at 'elsif' with 'if'")
      assert_warning("if true\n  else\nend", "mismatched indentations at 'else' with 'if'", "mismatched indentations at 'end' with 'else'")

      assert_warning("unless true\n  end", "mismatched indentations at 'end' with 'unless'")
      assert_warning("unless true\n  else\nend", "mismatched indentations at 'else' with 'unless'", "mismatched indentations at 'end' with 'else'")

      assert_warning("while true\n  end", "mismatched indentations at 'end' with 'while'")
      assert_warning("until true\n  end", "mismatched indentations at 'end' with 'until'")

      assert_warning("begin\n  end", "mismatched indentations at 'end' with 'begin'")
      assert_warning("begin\n  rescue\nend", "mismatched indentations at 'rescue' with 'begin'")
      assert_warning("begin\n  ensure\nend", "mismatched indentations at 'ensure' with 'begin'")
      assert_warning("begin\nrescue\n  else\nend", "mismatched indentations at 'else' with 'begin'", "mismatched indentations at 'end' with 'else'")
      assert_warning("begin\n  rescue\n    ensure\n      end", "mismatched indentations at 'rescue' with 'begin'", "mismatched indentations at 'ensure' with 'begin'", "mismatched indentations at 'end' with 'begin'");

      assert_warning("def foo\n  end", "mismatched indentations at 'end' with 'def'")
      assert_warning("def foo\n  rescue\nend", "mismatched indentations at 'rescue' with 'def'")
      assert_warning("def foo\n  ensure\nend", "mismatched indentations at 'ensure' with 'def'")
      assert_warning("def foo\nrescue\n  else\nend", "mismatched indentations at 'else' with 'def'", "mismatched indentations at 'end' with 'else'")
      assert_warning("def foo\n  rescue\n    ensure\n      end", "mismatched indentations at 'rescue' with 'def'", "mismatched indentations at 'ensure' with 'def'", "mismatched indentations at 'end' with 'def'");

      assert_warning("class Foo\n  end", "mismatched indentations at 'end' with 'class'")
      assert_warning("class Foo\n  rescue\nend", "mismatched indentations at 'rescue' with 'class'")
      assert_warning("class Foo\n  ensure\nend", "mismatched indentations at 'ensure' with 'class'")
      assert_warning("class Foo\nrescue\n  else\nend", "mismatched indentations at 'else' with 'class'", "mismatched indentations at 'end' with 'else'")
      assert_warning("class Foo\n  rescue\n    ensure\n      end", "mismatched indentations at 'rescue' with 'class'", "mismatched indentations at 'ensure' with 'class'", "mismatched indentations at 'end' with 'class'");

      assert_warning("module Foo\n  end", "mismatched indentations at 'end' with 'module'")
      assert_warning("module Foo\n  rescue\nend", "mismatched indentations at 'rescue' with 'module'")
      assert_warning("module Foo\n  ensure\nend", "mismatched indentations at 'ensure' with 'module'")
      assert_warning("module Foo\nrescue\n  else\nend", "mismatched indentations at 'else' with 'module'", "mismatched indentations at 'end' with 'else'")
      assert_warning("module Foo\n  rescue\n    ensure\n      end", "mismatched indentations at 'rescue' with 'module'", "mismatched indentations at 'ensure' with 'module'", "mismatched indentations at 'end' with 'module'");

      assert_warning("class << foo\n  end", "mismatched indentations at 'end' with 'class'")
      assert_warning("class << foo\n  rescue\nend", "mismatched indentations at 'rescue' with 'class'")
      assert_warning("class << foo\n  ensure\nend", "mismatched indentations at 'ensure' with 'class'")
      assert_warning("class << foo\nrescue\n  else\nend", "mismatched indentations at 'else' with 'class'", "mismatched indentations at 'end' with 'else'")
      assert_warning("class << foo\n  rescue\n    ensure\n      end", "mismatched indentations at 'rescue' with 'class'", "mismatched indentations at 'ensure' with 'class'", "mismatched indentations at 'end' with 'class'");

      assert_warning("case 1; when 2\n  end", "mismatched indentations at 'end' with 'case'")
      assert_warning("case 1; in 2\n  end", "mismatched indentations at 'end' with 'case'")

      assert_warning("  case 1\nwhen 2\n  end", "mismatched indentations at 'when' with 'case'")
      refute_warning("case 1\n  when 2\n    when 3\nend") # case/when allows more indentation

      assert_warning("-> {\n  }", "mismatched indentations at '}' with '->'")
      assert_warning("-> do\n  end", "mismatched indentations at 'end' with '->'")
      assert_warning("-> do\n  rescue\nend", "mismatched indentations at 'rescue' with '->'")
      assert_warning("-> do\n  ensure\nend", "mismatched indentations at 'ensure' with '->'")
      assert_warning("-> do\nrescue\n  else\nend", "mismatched indentations at 'else' with '->'", "mismatched indentations at 'end' with 'else'")
      assert_warning("-> do\n  rescue\n    ensure\n      end", "mismatched indentations at 'rescue' with '->'", "mismatched indentations at 'ensure' with '->'", "mismatched indentations at 'end' with '->'");
      assert_warning("foo do\nrescue\n  else\nend", "mismatched indentations at 'end' with 'else'")

      refute_warning("class Foo; end") # same line
      refute_warning("; class Foo\nend") # non whitespace on opening line
      refute_warning("\tclass Foo\n        end") # tab stop matches space
      refute_warning("    \tclass Foo\n        end") # tab stop matches space
    end

    def test_integer_in_flip_flop
      assert_warning("1 if 2..foo", "integer")
    end

    def test_literal_in_conditionals
      sources = [
        "if (a = 2); a; end",
        "if ($a = 2); end",
        "if (@a = 2); end",
        "if a; elsif b = 2; b end",
        "unless (a = 2); a; end",
        "unless ($a = 2); end",
        "unless (@a = 2); end",
        "while (a = 2); a; end",
        "while ($a = 2); end",
        "while (@a = 2); end",
        "until (a = 2); a; end",
        "until ($a = 2); end",
        "until (@a = 2); end",
        "foo if (a, b = 2); [a, b]",
        "foo if a = 2 and a",
        "(@foo = 1) ? a : b",
        "!(a = 2) and a",
        "not a = 2 and a"
      ]

      if RUBY_VERSION >= "3.3"
        sources.push(
          "if (@@a = 2); end",
          "unless (@@a = 2); end",
          "while (@@a = 2); end",
          "until (@@a = 2); end"
        )
      end

      sources.each do |source|
        assert_warning(source, "= literal' in conditional, should be ==")
      end
    end

    def test_keyword_eol
      assert_warning("if\ntrue; end", "end of line")
      assert_warning("if true\nelsif\nfalse; end", "end of line")
    end

    def test_numbered_reference
      assert_warning("_ = _ = $999999999999999999999", "too big for a number variable, always nil")
    end

    def test_shareable_constant_value
      assert_warning("foo # shareable_constant_value: none", "ignored")
      assert_warning("\v  # shareable_constant_value: none", "ignored")

      refute_warning("# shareable_constant_value: none")
      refute_warning("    # shareable_constant_value: none")
      refute_warning("\t\t# shareable_constant_value: none")
    end

    def test_string_in_predicate
      assert_warning("if 'foo'; end", "string")
      assert_warning("if \"\#{foo}\"; end", "string")
      assert_warning("if __FILE__; end", "string")
    end

    def test_symbol_in_predicate
      assert_warning("if :foo; end", "symbol")
      assert_warning("if :\"\#{foo}\"; end", "symbol")
    end

    def test_literal_in_predicate
      assert_warning("if __LINE__; end", "literal")
      assert_warning("if __ENCODING__; end", "literal")
      assert_warning("if 1; end", "literal")
      assert_warning("if 1.0; end", "literal")
      assert_warning("if 1r; end", "literal")
      assert_warning("if 1i; end", "literal")
    end

    def test_regexp_in_predicate
      assert_warning("if /foo/; end", "regex")
      assert_warning("if /foo\#{bar}/; end", "regex")
    end

    def test_unused_local_variables
      assert_warning("foo = 1", "unused")

      refute_warning("foo = 1", compare: false, command_line: "e")
      refute_warning("foo = 1", compare: false, scopes: [[]])

      assert_warning("def foo; bar = 1; end", "unused")
      assert_warning("def foo; bar, = 1; end", "unused")

      refute_warning("def foo; bar &&= 1; end")
      refute_warning("def foo; bar ||= 1; end")
      refute_warning("def foo; bar += 1; end")

      refute_warning("def foo; bar = bar; end")
      refute_warning("def foo; bar = bar = 1; end")
      refute_warning("def foo; bar = (bar = 1); end")
      refute_warning("def foo; bar = begin; bar = 1; end; end")
      refute_warning("def foo; bar = (qux; bar = 1); end")
      refute_warning("def foo; bar, = bar = 1; end")
      refute_warning("def foo; bar, = 1, bar = 1; end")

      refute_warning("def foo(bar); end")
      refute_warning("def foo(bar = 1); end")
      refute_warning("def foo((bar)); end")
      refute_warning("def foo(*bar); end")
      refute_warning("def foo(*, bar); end")
      refute_warning("def foo(*, (bar)); end")
      refute_warning("def foo(bar:); end")
      refute_warning("def foo(**bar); end")
      refute_warning("def foo(&bar); end")
      refute_warning("->(bar) {}")
      refute_warning("->(; bar) {}", compare: false)

      refute_warning("def foo; bar = 1; tap { bar }; end")
      refute_warning("def foo; bar = 1; tap { baz = bar; baz }; end")

      refute_warning("def foo; bar = 1; end", line: -2, compare: false)
    end

    def test_void_statements
      assert_warning("foo = 1; foo", "a variable in void")
      assert_warning("@foo", "a variable in void")
      assert_warning("@@foo", "a variable in void")
      assert_warning("$foo", "a variable in void")
      assert_warning("$+", "a variable in void")
      assert_warning("$1", "a variable in void")

      assert_warning("self", "self in void")
      assert_warning("nil", "nil in void")
      assert_warning("true", "true in void")
      assert_warning("false", "false in void")

      assert_warning("1", "literal in void")
      assert_warning("1.0", "literal in void")
      assert_warning("1r", "literal in void")
      assert_warning("1i", "literal in void")
      assert_warning(":foo", "literal in void")
      assert_warning("\"foo\"", "literal in void")
      assert_warning("\"foo\#{1}\"", "literal in void")
      assert_warning("/foo/", "literal in void")
      assert_warning("/foo\#{1}/", "literal in void")

      assert_warning("Foo", "constant in void")
      assert_warning("::Foo", ":: in void")
      assert_warning("Foo::Bar", ":: in void")

      assert_warning("1..2", ".. in void")
      assert_warning("1..", ".. in void")
      assert_warning("..2", ".. in void")
      assert_warning("1...2", "... in void")
      assert_warning("1...;", "... in void")
      assert_warning("...2", "... in void")

      assert_warning("defined?(foo)", "defined? in void")

      assert_warning("1 + 1", "+ in void")
      assert_warning("1 - 1", "- in void")
      assert_warning("1 * 1", "* in void")
      assert_warning("1 / 1", "/ in void")
      assert_warning("1 % 1", "% in void")
      assert_warning("1 | 1", "| in void")
      assert_warning("1 ^ 1", "^ in void")
      assert_warning("1 & 1", "& in void")
      assert_warning("1 > 1", "> in void")
      assert_warning("1 < 1", "< in void")

      assert_warning("1 ** 1", "** in void")
      assert_warning("1 <= 1", "<= in void")
      assert_warning("1 >= 1", ">= in void")
      assert_warning("1 != 1", "!= in void")
      assert_warning("1 == 1", "== in void")
      assert_warning("1 <=> 1", "<=> in void")

      assert_warning("+foo", "+@ in void")
      assert_warning("-foo", "-@ in void")

      assert_warning("def foo; @bar; @baz; end", "variable in void")
      refute_warning("def foo; @bar; end")
      refute_warning("@foo", compare: false, scopes: [[]])
    end

    def test_unreachable_statement
      assert_warning("begin; rescue; retry; foo; end", "statement not reached")

      assert_warning("return; foo", "statement not reached")

      assert_warning("tap { break; foo }", "statement not reached")
      assert_warning("tap { break 1; foo }", "statement not reached")

      assert_warning("tap { next; foo }", "statement not reached")
      assert_warning("tap { next 1; foo }", "statement not reached")

      assert_warning("tap { redo; foo }", "statement not reached")
    end

    if windows?
      def test_shebang_ending_with_carriage_return
        refute_warning("#!ruby\r\np(123)\n", compare: false)
      end
    else
      def test_shebang_ending_with_carriage_return
        msg = "shebang line ending with \\r may cause problems"

        assert_warning(<<~RUBY, msg, compare: false, main_script: true)
          #!ruby\r
          p(123)
        RUBY

        assert_warning(<<~RUBY, msg, compare: false, main_script: true)
          #!ruby \r
          p(123)
        RUBY

        assert_warning(<<~RUBY, msg, compare: false, main_script: true)
          #!ruby -Eutf-8\r
          p(123)
        RUBY

        # Used with the `-x` object, to ignore the script up until the first
        # shebang that mentioned "ruby".
        assert_warning(<<~SCRIPT, msg, compare: false, main_script: true)
          #!/usr/bin/env bash
          # Some initial shell script or other content
          # that Ruby should ignore
          echo "This is shell script part"
          exit 0

          #! /usr/bin/env ruby -Eutf-8\r
          # Ruby script starts here
          puts "Hello from Ruby!"
        SCRIPT

        refute_warning("#ruby not_a_shebang\r\n", compare: false, main_script: true)

        # CRuby doesn't emit the warning if a malformed file only has `\r` and
        # not `\n`. https://bugs.ruby-lang.org/issues/20700.
        refute_warning("#!ruby\r", compare: false, main_script: true)
      end
    end

    def test_warnings_verbosity
      warning = Prism.parse("def foo; END { }; end").warnings.first
      assert_equal "END in method; use at_exit", warning.message
      assert_equal :default, warning.level

      warning = Prism.parse("foo /regexp/").warnings.first
      assert_equal "ambiguous `/`; wrap regexp in parentheses or add a space after `/` operator", warning.message
      assert_equal :verbose, warning.level
    end

    private

    def assert_warning(source, *messages, compare: true, **options)
      warnings = Prism.parse(source, **options).warnings
      assert_equal messages.length, warnings.length, "Expected #{messages.length} warning(s) in #{source.inspect}, got #{warnings.map(&:message).inspect}"

      warnings.zip(messages).each do |warning, message|
        assert_include warning.message, message
      end

      if compare && defined?(RubyVM::AbstractSyntaxTree)
        stderr = capture_stderr { RubyVM::AbstractSyntaxTree.parse(source) }
        messages.each { |message| assert_include stderr, message }
      end
    end

    def refute_warning(source, compare: true, **options)
      assert_empty Prism.parse(source, **options).warnings

      if compare && defined?(RubyVM::AbstractSyntaxTree)
        assert_empty capture_stderr { RubyVM::AbstractSyntaxTree.parse(source) }
      end
    end

    def capture_stderr
      stderr, $stderr, verbose, $VERBOSE = $stderr, StringIO.new, $VERBOSE, true

      begin
        yield
        $stderr.string
      ensure
        $stderr, $VERBOSE = stderr, verbose
      end
    end
  end
end
prism-1.5.1/test/prism/ruby/000077500000000000000000000000001506127434000157445ustar00rootroot00000000000000prism-1.5.1/test/prism/ruby/compiler_test.rb000066400000000000000000000012231506127434000211400ustar00rootroot00000000000000# frozen_string_literal: true
# typed: ignore

require_relative "../test_helper"

module Prism
  class CompilerTest < TestCase
    class SExpressions < Prism::Compiler
      def visit_arguments_node(node)
        [:arguments, super]
      end

      def visit_call_node(node)
        [:call, super]
      end

      def visit_integer_node(node)
        [:integer]
      end

      def visit_program_node(node)
        [:program, super]
      end
    end

    def test_compiler
      expected = [:program, [[[:call, [[:integer], [:arguments, [[:integer]]]]]]]]
      assert_equal expected, Prism.parse("1 + 2").value.accept(SExpressions.new)
    end
  end
end
prism-1.5.1/test/prism/ruby/desugar_compiler_test.rb000066400000000000000000000104201506127434000226510ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class DesugarCompilerTest < TestCase
    def test_and_write
      assert_desugars("(AndNode (ClassVariableReadNode) (ClassVariableWriteNode (CallNode)))", "@@foo &&= bar")
      assert_not_desugared("Foo::Bar &&= baz", "Desugaring would execute Foo twice or need temporary variables")
      assert_desugars("(AndNode (ConstantReadNode) (ConstantWriteNode (CallNode)))", "Foo &&= bar")
      assert_desugars("(AndNode (GlobalVariableReadNode) (GlobalVariableWriteNode (CallNode)))", "$foo &&= bar")
      assert_desugars("(AndNode (InstanceVariableReadNode) (InstanceVariableWriteNode (CallNode)))", "@foo &&= bar")
      assert_desugars("(AndNode (LocalVariableReadNode) (LocalVariableWriteNode (CallNode)))", "foo &&= bar")
      assert_desugars("(AndNode (LocalVariableReadNode) (LocalVariableWriteNode (CallNode)))", "foo = 1; foo &&= bar")
    end

    def test_or_write
      assert_desugars("(IfNode (DefinedNode (ClassVariableReadNode)) (StatementsNode (ClassVariableReadNode)) (ElseNode (StatementsNode (ClassVariableWriteNode (CallNode)))))", "@@foo ||= bar")
      assert_not_desugared("Foo::Bar ||= baz", "Desugaring would execute Foo twice or need temporary variables")
      assert_desugars("(IfNode (DefinedNode (ConstantReadNode)) (StatementsNode (ConstantReadNode)) (ElseNode (StatementsNode (ConstantWriteNode (CallNode)))))", "Foo ||= bar")
      assert_desugars("(IfNode (DefinedNode (GlobalVariableReadNode)) (StatementsNode (GlobalVariableReadNode)) (ElseNode (StatementsNode (GlobalVariableWriteNode (CallNode)))))", "$foo ||= bar")
      assert_desugars("(OrNode (InstanceVariableReadNode) (InstanceVariableWriteNode (CallNode)))", "@foo ||= bar")
      assert_desugars("(OrNode (LocalVariableReadNode) (LocalVariableWriteNode (CallNode)))", "foo ||= bar")
      assert_desugars("(OrNode (LocalVariableReadNode) (LocalVariableWriteNode (CallNode)))", "foo = 1; foo ||= bar")
    end

    def test_operator_write
      assert_desugars("(ClassVariableWriteNode (CallNode (ClassVariableReadNode) (ArgumentsNode (CallNode))))", "@@foo += bar")
      assert_not_desugared("Foo::Bar += baz", "Desugaring would execute Foo twice or need temporary variables")
      assert_desugars("(ConstantWriteNode (CallNode (ConstantReadNode) (ArgumentsNode (CallNode))))", "Foo += bar")
      assert_desugars("(GlobalVariableWriteNode (CallNode (GlobalVariableReadNode) (ArgumentsNode (CallNode))))", "$foo += bar")
      assert_desugars("(InstanceVariableWriteNode (CallNode (InstanceVariableReadNode) (ArgumentsNode (CallNode))))", "@foo += bar")
      assert_desugars("(LocalVariableWriteNode (CallNode (LocalVariableReadNode) (ArgumentsNode (CallNode))))", "foo += bar")
      assert_desugars("(LocalVariableWriteNode (CallNode (LocalVariableReadNode) (ArgumentsNode (CallNode))))", "foo = 1; foo += bar")
    end

    private

    def ast_inspect(node)
      parts = [node.class.name.split("::").last]

      node.deconstruct_keys(nil).each do |_, value|
        case value
        when Node
          parts << ast_inspect(value)
        when Array
          parts.concat(value.map { |element| ast_inspect(element) })
        end
      end

      "(#{parts.join(" ")})"
    end

    # Ensure every node is only present once in the AST.
    # If the same node is present twice it would most likely indicate it is executed twice, which is invalid semantically.
    # This also acts as a sanity check that Node#child_nodes returns only nodes or nil (which caught a couple bugs).
    def ensure_every_node_once_in_ast(node, all_nodes = {}.compare_by_identity)
      if all_nodes.include?(node)
        raise "#{node.inspect} is present multiple times in the desugared AST and likely executed multiple times"
      else
        all_nodes[node] = true
      end
      node.child_nodes.each do |child|
        ensure_every_node_once_in_ast(child, all_nodes) unless child.nil?
      end
    end

    def assert_desugars(expected, source)
      ast = Prism.parse(source).value.accept(DesugarCompiler.new)
      assert_equal expected, ast_inspect(ast.statements.body.last)

      ensure_every_node_once_in_ast(ast)
    end

    def assert_not_desugared(source, reason)
      ast = Prism.parse(source).value
      assert_equal_nodes(ast, ast.accept(DesugarCompiler.new))
    end
  end
end
prism-1.5.1/test/prism/ruby/dispatcher_test.rb000066400000000000000000000027521506127434000214640ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class DispatcherTest < TestCase
    class TestListener
      attr_reader :events_received

      def initialize
        @events_received = []
      end

      def on_call_node_enter(node)
        events_received << :on_call_node_enter
      end

      def on_call_node_leave(node)
        events_received << :on_call_node_leave
      end

      def on_integer_node_enter(node)
        events_received << :on_integer_node_enter
      end
    end

    def test_dispatching_events
      listener_manual = TestListener.new
      listener_public = TestListener.new

      dispatcher = Dispatcher.new
      dispatcher.register(listener_manual, :on_call_node_enter, :on_call_node_leave, :on_integer_node_enter)
      dispatcher.register_public_methods(listener_public)

      root = Prism.parse(<<~RUBY).value
        def foo
          something(1, 2, 3)
        end
      RUBY

      dispatcher.dispatch(root)

      [listener_manual, listener_public].each do |listener|
        assert_equal([:on_call_node_enter, :on_integer_node_enter, :on_integer_node_enter, :on_integer_node_enter, :on_call_node_leave], listener.events_received)
        listener.events_received.clear
      end

      dispatcher.dispatch_once(root.statements.body.first.body.body.first)

      [listener_manual, listener_public].each do |listener|
        assert_equal([:on_call_node_enter, :on_call_node_leave], listener.events_received)
      end
    end
  end
end
prism-1.5.1/test/prism/ruby/location_test.rb000066400000000000000000000240461506127434000211460ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class LocationTest < TestCase
    def test_join
      call = Prism.parse_statement("1234 + 567")
      receiver = call.receiver
      argument = call.arguments.arguments.first

      joined = receiver.location.join(argument.location)
      assert_equal 0, joined.start_offset
      assert_equal 10, joined.length

      assert_raise(RuntimeError, "Incompatible locations") do
        argument.location.join(receiver.location)
      end

      other_argument = Prism.parse_statement("1234 + 567").arguments.arguments.first

      assert_raise(RuntimeError, "Incompatible sources") do
        other_argument.location.join(receiver.location)
      end

      assert_raise(RuntimeError, "Incompatible sources") do
        receiver.location.join(other_argument.location)
      end
    end

    def test_character_offsets
      program = Prism.parse("😀 + 😀\n😠||= ðŸ˜").value

      # first 😀
      location = program.statements.body.first.receiver.location
      assert_equal 0, location.start_character_offset
      assert_equal 1, location.end_character_offset
      assert_equal 0, location.start_character_column
      assert_equal 1, location.end_character_column

      # second 😀
      location = program.statements.body.first.arguments.arguments.first.location
      assert_equal 4, location.start_character_offset
      assert_equal 5, location.end_character_offset
      assert_equal 4, location.start_character_column
      assert_equal 5, location.end_character_column

      # first ðŸ˜
      location = program.statements.body.last.name_loc
      assert_equal 6, location.start_character_offset
      assert_equal 7, location.end_character_offset
      assert_equal 0, location.start_character_column
      assert_equal 1, location.end_character_column

      # second ðŸ˜
      location = program.statements.body.last.value.location
      assert_equal 12, location.start_character_offset
      assert_equal 13, location.end_character_offset
      assert_equal 6, location.start_character_column
      assert_equal 7, location.end_character_column
    end

    def test_code_units
      program = Prism.parse("😀 + 😀\n😠||= ðŸ˜").value

      # first 😀
      location = program.statements.body.first.receiver.location

      assert_equal 0, location.start_code_units_offset(Encoding::UTF_8)
      assert_equal 0, location.start_code_units_offset(Encoding::UTF_16LE)
      assert_equal 0, location.start_code_units_offset(Encoding::UTF_32LE)

      assert_equal 1, location.end_code_units_offset(Encoding::UTF_8)
      assert_equal 2, location.end_code_units_offset(Encoding::UTF_16LE)
      assert_equal 1, location.end_code_units_offset(Encoding::UTF_32LE)

      assert_equal 0, location.start_code_units_column(Encoding::UTF_8)
      assert_equal 0, location.start_code_units_column(Encoding::UTF_16LE)
      assert_equal 0, location.start_code_units_column(Encoding::UTF_32LE)

      assert_equal 1, location.end_code_units_column(Encoding::UTF_8)
      assert_equal 2, location.end_code_units_column(Encoding::UTF_16LE)
      assert_equal 1, location.end_code_units_column(Encoding::UTF_32LE)

      # second 😀
      location = program.statements.body.first.arguments.arguments.first.location

      assert_equal 4, location.start_code_units_offset(Encoding::UTF_8)
      assert_equal 5, location.start_code_units_offset(Encoding::UTF_16LE)
      assert_equal 4, location.start_code_units_offset(Encoding::UTF_32LE)

      assert_equal 5, location.end_code_units_offset(Encoding::UTF_8)
      assert_equal 7, location.end_code_units_offset(Encoding::UTF_16LE)
      assert_equal 5, location.end_code_units_offset(Encoding::UTF_32LE)

      assert_equal 4, location.start_code_units_column(Encoding::UTF_8)
      assert_equal 5, location.start_code_units_column(Encoding::UTF_16LE)
      assert_equal 4, location.start_code_units_column(Encoding::UTF_32LE)

      assert_equal 5, location.end_code_units_column(Encoding::UTF_8)
      assert_equal 7, location.end_code_units_column(Encoding::UTF_16LE)
      assert_equal 5, location.end_code_units_column(Encoding::UTF_32LE)

      # first ðŸ˜
      location = program.statements.body.last.name_loc

      assert_equal 6, location.start_code_units_offset(Encoding::UTF_8)
      assert_equal 8, location.start_code_units_offset(Encoding::UTF_16LE)
      assert_equal 6, location.start_code_units_offset(Encoding::UTF_32LE)

      assert_equal 7, location.end_code_units_offset(Encoding::UTF_8)
      assert_equal 10, location.end_code_units_offset(Encoding::UTF_16LE)
      assert_equal 7, location.end_code_units_offset(Encoding::UTF_32LE)

      assert_equal 0, location.start_code_units_column(Encoding::UTF_8)
      assert_equal 0, location.start_code_units_column(Encoding::UTF_16LE)
      assert_equal 0, location.start_code_units_column(Encoding::UTF_32LE)

      assert_equal 1, location.end_code_units_column(Encoding::UTF_8)
      assert_equal 2, location.end_code_units_column(Encoding::UTF_16LE)
      assert_equal 1, location.end_code_units_column(Encoding::UTF_32LE)

      # second ðŸ˜
      location = program.statements.body.last.value.location

      assert_equal 12, location.start_code_units_offset(Encoding::UTF_8)
      assert_equal 15, location.start_code_units_offset(Encoding::UTF_16LE)
      assert_equal 12, location.start_code_units_offset(Encoding::UTF_32LE)

      assert_equal 13, location.end_code_units_offset(Encoding::UTF_8)
      assert_equal 17, location.end_code_units_offset(Encoding::UTF_16LE)
      assert_equal 13, location.end_code_units_offset(Encoding::UTF_32LE)

      assert_equal 6, location.start_code_units_column(Encoding::UTF_8)
      assert_equal 7, location.start_code_units_column(Encoding::UTF_16LE)
      assert_equal 6, location.start_code_units_column(Encoding::UTF_32LE)

      assert_equal 7, location.end_code_units_column(Encoding::UTF_8)
      assert_equal 9, location.end_code_units_column(Encoding::UTF_16LE)
      assert_equal 7, location.end_code_units_column(Encoding::UTF_32LE)
    end

    def test_cached_code_units
      result = Prism.parse("😀 + 😀\n😠||= ðŸ˜")

      utf8_cache = result.code_units_cache(Encoding::UTF_8)
      utf16_cache = result.code_units_cache(Encoding::UTF_16LE)
      utf32_cache = result.code_units_cache(Encoding::UTF_32LE)

      # first 😀
      location = result.value.statements.body.first.receiver.location

      assert_equal 0, location.cached_start_code_units_offset(utf8_cache)
      assert_equal 0, location.cached_start_code_units_offset(utf16_cache)
      assert_equal 0, location.cached_start_code_units_offset(utf32_cache)

      assert_equal 1, location.cached_end_code_units_offset(utf8_cache)
      assert_equal 2, location.cached_end_code_units_offset(utf16_cache)
      assert_equal 1, location.cached_end_code_units_offset(utf32_cache)

      assert_equal 0, location.cached_start_code_units_column(utf8_cache)
      assert_equal 0, location.cached_start_code_units_column(utf16_cache)
      assert_equal 0, location.cached_start_code_units_column(utf32_cache)

      assert_equal 1, location.cached_end_code_units_column(utf8_cache)
      assert_equal 2, location.cached_end_code_units_column(utf16_cache)
      assert_equal 1, location.cached_end_code_units_column(utf32_cache)

      # second 😀
      location = result.value.statements.body.first.arguments.arguments.first.location

      assert_equal 4, location.cached_start_code_units_offset(utf8_cache)
      assert_equal 5, location.cached_start_code_units_offset(utf16_cache)
      assert_equal 4, location.cached_start_code_units_offset(utf32_cache)

      assert_equal 5, location.cached_end_code_units_offset(utf8_cache)
      assert_equal 7, location.cached_end_code_units_offset(utf16_cache)
      assert_equal 5, location.cached_end_code_units_offset(utf32_cache)

      assert_equal 4, location.cached_start_code_units_column(utf8_cache)
      assert_equal 5, location.cached_start_code_units_column(utf16_cache)
      assert_equal 4, location.cached_start_code_units_column(utf32_cache)

      assert_equal 5, location.cached_end_code_units_column(utf8_cache)
      assert_equal 7, location.cached_end_code_units_column(utf16_cache)
      assert_equal 5, location.cached_end_code_units_column(utf32_cache)
    end

    def test_code_units_binary_valid_utf8
      program = Prism.parse(<<~RUBY).value
        # -*- encoding: binary -*-

        😀 + 😀
      RUBY

      receiver = program.statements.body.first.receiver
      assert_equal "😀".b.to_sym, receiver.name

      location = receiver.location
      assert_equal 1, location.end_code_units_column(Encoding::UTF_8)
      assert_equal 2, location.end_code_units_column(Encoding::UTF_16LE)
      assert_equal 1, location.end_code_units_column(Encoding::UTF_32LE)
    end

    def test_code_units_binary_invalid_utf8
      program = Prism.parse(<<~RUBY).value
        # -*- encoding: binary -*-

        \x90 + \x90
      RUBY

      receiver = program.statements.body.first.receiver
      assert_equal "\x90".b.to_sym, receiver.name

      location = receiver.location
      assert_equal 1, location.end_code_units_column(Encoding::UTF_8)
      assert_equal 1, location.end_code_units_column(Encoding::UTF_16LE)
      assert_equal 1, location.end_code_units_column(Encoding::UTF_32LE)
    end

    def test_chop
      location = Prism.parse("foo").value.location

      assert_equal "fo", location.chop.slice
      assert_equal "", location.chop.chop.chop.slice

      # Check that we don't go negative.
      10.times { location = location.chop }
      assert_equal "", location.slice
    end

    def test_slice_lines
      method = Prism.parse_statement("\nprivate def foo\nend\n").arguments.arguments.first

      assert_equal "private def foo\nend\n", method.slice_lines
    end

    def test_adjoin
      program = Prism.parse("foo.bar = 1").value

      location = program.statements.body.first.message_loc
      adjoined = location.adjoin("=")

      assert_kind_of Location, adjoined
      refute_equal location, adjoined

      assert_equal 4, adjoined.start_offset
      assert_equal 9, adjoined.end_offset
    end
  end
end
prism-1.5.1/test/prism/ruby/parameters_signature_test.rb000066400000000000000000000037721506127434000235650ustar00rootroot00000000000000# frozen_string_literal: true

return if RUBY_VERSION < "3.2"

require_relative "../test_helper"

module Prism
  class ParametersSignatureTest < TestCase
    def test_req
      assert_parameters([[:req, :a]], "a")
    end

    def test_req_destructure
      assert_parameters([[:req]], "(a, b)")
    end

    def test_opt
      assert_parameters([[:opt, :a]], "a = 1")
    end

    def test_rest
      assert_parameters([[:rest, :a]], "*a")
    end

    def test_rest_anonymous
      assert_parameters([[:rest, :*]], "*")
    end

    def test_post
      assert_parameters([[:rest, :a], [:req, :b]], "*a, b")
    end

    def test_post_destructure
      assert_parameters([[:rest, :a], [:req]], "*a, (b, c)")
    end

    def test_keyreq
      assert_parameters([[:keyreq, :a]], "a:")
    end

    def test_key
      assert_parameters([[:key, :a]], "a: 1")
    end

    def test_keyrest
      assert_parameters([[:keyrest, :a]], "**a")
    end

    def test_nokey
      assert_parameters([[:nokey]], "**nil")
    end

    def test_keyrest_anonymous
      assert_parameters([[:keyrest, :**]], "**")
    end

    if RUBY_ENGINE == "ruby"
      def test_key_ordering
        assert_parameters([[:keyreq, :a], [:keyreq, :b], [:key, :c], [:key, :d]], "a:, c: 1, b:, d: 2")
      end
    end

    def test_block
      assert_parameters([[:block, :a]], "&a")
    end

    def test_block_anonymous
      assert_parameters([[:block, :&]], "&")
    end

    def test_forwarding
      assert_parameters([[:rest, :*], [:keyrest, :**], [:block, :&]], "...")
    end

    private

    def assert_parameters(expected, source)
      # Compare against our expectation.
      assert_equal(expected, signature(source))

      # Compare against Ruby's expectation.
      object = Object.new
      eval("def object.m(#{source}); end")
      assert_equal(expected, object.method(:m).parameters)
    end

    def signature(source)
      program = Prism.parse("def m(#{source}); end").value
      program.statements.body.first.parameters.signature
    end
  end
end
prism-1.5.1/test/prism/ruby/parser_test.rb000066400000000000000000000244401506127434000206300ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

begin
  verbose, $VERBOSE = $VERBOSE, nil
  require "parser/ruby33"
  require "prism/translation/parser33"
  require "prism/translation/parser34"
rescue LoadError
  # In CRuby's CI, we're not going to test against the parser gem because we
  # don't want to have to install it. So in this case we'll just skip this test.
  return
ensure
  $VERBOSE = verbose
end

# First, opt in to every AST feature.
Parser::Builders::Default.modernize
Prism::Translation::Parser::Builder.modernize

# The parser gem rejects some strings that would most likely lead to errors
# in consumers due to encoding problems. RuboCop however monkey-patches this
# method out in order to accept such code.
# https://github.com/whitequark/parser/blob/v3.3.6.0/lib/parser/builders/default.rb#L2289-L2295
Parser::Builders::Default.prepend(
  Module.new {
    def string_value(token)
      value(token)
    end
  }
)

# Modify the source map == check so that it doesn't check against the node
# itself so we don't get into a recursive loop.
Parser::Source::Map.prepend(
  Module.new {
    def ==(other)
      self.class == other.class &&
        (instance_variables - %i[@node]).map do |ivar|
          instance_variable_get(ivar) == other.instance_variable_get(ivar)
        end.reduce(:&)
    end
  }
)

# Next, ensure that we're comparing the nodes and also comparing the source
# ranges so that we're getting all of the necessary information.
Parser::AST::Node.prepend(
  Module.new {
    def ==(other)
      super && (location == other.location)
    end
  }
)

module Prism
  class ParserTest < TestCase
    # These files contain code with valid syntax that can't be parsed.
    skip_syntax_error = [
      # alias/undef with %s(abc) symbol literal
      "alias.txt",
      "seattlerb/bug_215.txt",

      # 1.. && 2
      "ranges.txt",

      # Cannot yet handling leading logical operators.
      "leading_logical.txt",

      # Ruby >= 3.5 specific syntax
      "endless_methods_command_call.txt",
    ]

    # These files contain code that is being parsed incorrectly by the parser
    # gem, and therefore we don't want to compare against our translation.
    skip_incorrect = [
      # https://github.com/whitequark/parser/issues/1017
      "spanning_heredoc.txt",
      "spanning_heredoc_newlines.txt",

      # https://github.com/whitequark/parser/issues/1021
      "seattlerb/heredoc_nested.txt",

      # https://github.com/whitequark/parser/issues/1016
      "whitequark/unary_num_pow_precedence.txt",

      # https://github.com/whitequark/parser/issues/950
      "whitequark/dedenting_interpolating_heredoc_fake_line_continuation.txt",

      # Contains an escaped multibyte character. This is supposed to drop to backslash
      "seattlerb/regexp_escape_extended.txt",

      # https://github.com/whitequark/parser/issues/1020
      # These contain consecutive \r characters, followed by \n. Prism only receives
      # the already modified source buffer which dropped one \r but must know the
      # original code to parse it correctly.
      "seattlerb/heredoc_with_extra_carriage_returns_windows.txt",
      "seattlerb/heredoc_with_only_carriage_returns_windows.txt",
      "seattlerb/heredoc_with_only_carriage_returns.txt",

      # https://github.com/whitequark/parser/issues/1026
      # Regex with \c escape
      "unescaping.txt",
      "seattlerb/regexp_esc_C_slash.txt",
    ]

    # These files are failing to translate their lexer output into the lexer
    # output expected by the parser gem, so we'll skip them for now.
    skip_tokens = [
      "dash_heredocs.txt",
      "embdoc_no_newline_at_end.txt",
      "methods.txt",
      "seattlerb/bug169.txt",
      "seattlerb/case_in.txt",
      "seattlerb/difficult4__leading_dots2.txt",
      "seattlerb/difficult6__7.txt",
      "seattlerb/difficult6__8.txt",
      "seattlerb/heredoc_unicode.txt",
      "seattlerb/parse_line_heredoc.txt",
      "seattlerb/pct_w_heredoc_interp_nested.txt",
      "seattlerb/required_kwarg_no_value.txt",
      "seattlerb/TestRubyParserShared.txt",
      "unparser/corpus/literal/assignment.txt",
      "unparser/corpus/literal/literal.txt",
      "whitequark/args.txt",
      "whitequark/beginless_erange_after_newline.txt",
      "whitequark/beginless_irange_after_newline.txt",
      "whitequark/forward_arg_with_open_args.txt",
      "whitequark/kwarg_no_paren.txt",
      "whitequark/lbrace_arg_after_command_args.txt",
      "whitequark/multiple_pattern_matches.txt",
      "whitequark/newline_in_hash_argument.txt",
      "whitequark/pattern_matching_expr_in_paren.txt",
      "whitequark/pattern_matching_hash.txt",
      "whitequark/ruby_bug_14690.txt",
      "whitequark/ruby_bug_9669.txt",
      "whitequark/space_args_arg_block.txt",
      "whitequark/space_args_block.txt"
    ]

    Fixture.each(except: skip_syntax_error) do |fixture|
      define_method(fixture.test_name) do
        assert_equal_parses(
          fixture,
          compare_asts: !skip_incorrect.include?(fixture.path),
          compare_tokens: !skip_tokens.include?(fixture.path),
          compare_comments: fixture.path != "embdoc_no_newline_at_end.txt"
        )
      end
    end

    def test_non_prism_builder_class_deprecated
      warnings = capture_warnings { Prism::Translation::Parser33.new(Parser::Builders::Default.new) }

      assert_include(warnings, "#{__FILE__}:#{__LINE__ - 2}")
      assert_include(warnings, "is not a `Prism::Translation::Parser::Builder` subclass")

      warnings = capture_warnings { Prism::Translation::Parser33.new }
      assert_empty(warnings)
    end

    if RUBY_VERSION >= "3.3"
      def test_current_parser_for_current_ruby
        major, minor, _patch = Gem::Version.new(RUBY_VERSION).segments
        # Let's just hope there never is a Ruby 3.10 or similar
        expected = major * 10 + minor
        assert_equal(expected, Translation::ParserCurrent.new.version)
      end
    end

    def test_invalid_syntax
      code = <<~RUBY
        foo do
          case bar
          when
          end
        end
      RUBY
      buffer = Parser::Source::Buffer.new("(string)")
      buffer.source = code

      parser = Prism::Translation::Parser33.new
      parser.diagnostics.all_errors_are_fatal = true
      assert_raise(Parser::SyntaxError) { parser.tokenize(buffer) }
    end

    def test_it_block_parameter_syntax
      it_fixture_path = Pathname(__dir__).join("../../../test/prism/fixtures/it.txt")

      buffer = Parser::Source::Buffer.new(it_fixture_path)
      buffer.source = it_fixture_path.read
      actual_ast = Prism::Translation::Parser34.new.tokenize(buffer)[0]

      it_block_parameter_sexp = parse_sexp {
        s(:begin,
        s(:itblock,
          s(:send, nil, :x), :it,
          s(:lvar, :it)),
        s(:itblock,
          s(:lambda), :it,
          s(:lvar, :it)))
      }

      assert_equal(it_block_parameter_sexp, actual_ast.to_sexp)
    end

    private

    def assert_equal_parses(fixture, compare_asts: true, compare_tokens: true, compare_comments: true)
      buffer = Parser::Source::Buffer.new(fixture.path, 1)
      buffer.source = fixture.read

      parser = Parser::Ruby33.new
      parser.diagnostics.consumer = ->(*) {}
      parser.diagnostics.all_errors_are_fatal = true

      expected_ast, expected_comments, expected_tokens =
        ignore_warnings { parser.tokenize(buffer) }

      actual_ast, actual_comments, actual_tokens =
        ignore_warnings { Prism::Translation::Parser33.new.tokenize(buffer) }

      if expected_ast == actual_ast
        if !compare_asts && !Fixture.custom_base_path?
          puts "#{fixture.path} is now passing"
        end

        assert_equal expected_ast, actual_ast, -> { assert_equal_asts_message(expected_ast, actual_ast) }

        begin
          assert_equal_tokens(expected_tokens, actual_tokens)
        rescue Test::Unit::AssertionFailedError
          raise if compare_tokens
        else
          puts "#{fixture.path} is now passing" if !compare_tokens && !Fixture.custom_base_path?
        end

        assert_equal_comments(expected_comments, actual_comments) if compare_comments
      elsif compare_asts
        assert_equal expected_ast, actual_ast, -> { assert_equal_asts_message(expected_ast, actual_ast) }
      end
    end

    def assert_equal_asts_message(expected_ast, actual_ast)
      queue = [[expected_ast, actual_ast]]

      while (left, right = queue.shift)
        if left.type != right.type
          return "expected: #{left.type}\nactual: #{right.type}"
        end

        if left.location != right.location
          return "expected:\n#{left.inspect}\n#{left.location.inspect}\nactual:\n#{right.inspect}\n#{right.location.inspect}"
        end

        if left.type == :str && left.children[0] != right.children[0]
          return "expected: #{left.inspect}\nactual: #{right.inspect}"
        end

        left.children.zip(right.children).each do |left_child, right_child|
          queue << [left_child, right_child] if left_child.is_a?(Parser::AST::Node)
        end
      end

      "expected: #{expected_ast.inspect}\nactual: #{actual_ast.inspect}"
    end

    def assert_equal_tokens(expected_tokens, actual_tokens)
      if expected_tokens != actual_tokens
        index = 0
        max_index = [expected_tokens, actual_tokens].map(&:size).max

        while index <= max_index
          expected_token = expected_tokens.fetch(index, [])
          actual_token = actual_tokens.fetch(index, [])

          index += 1

          # There are a lot of tokens that have very specific meaning according
          # to the context of the parser. We don't expose that information in
          # prism, so we need to normalize these tokens a bit.
          if expected_token[0] == :kDO_BLOCK && actual_token[0] == :kDO
            actual_token[0] = expected_token[0]
          end

          # Now we can assert that the tokens are actually equal.
          assert_equal expected_token, actual_token, -> {
            "expected: #{expected_token.inspect}\n" \
            "actual: #{actual_token.inspect}"
          }
        end
      end
    end

    def assert_equal_comments(expected_comments, actual_comments)
      assert_equal expected_comments, actual_comments, -> {
        "expected: #{expected_comments.inspect}\n" \
        "actual: #{actual_comments.inspect}"
      }
    end

    def parse_sexp(&block)
      Class.new { extend AST::Sexp }.instance_eval(&block).to_sexp
    end
  end
end
prism-1.5.1/test/prism/ruby/pattern_test.rb000066400000000000000000000061731506127434000210140ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class PatternTest < TestCase
    def test_invalid_syntax
      assert_raise(Pattern::CompilationError) { scan("", "<>") }
    end

    def test_invalid_constant
      assert_raise(Pattern::CompilationError) { scan("", "Foo") }
    end

    def test_invalid_nested_constant
      assert_raise(Pattern::CompilationError) { scan("", "Foo::Bar") }
    end

    def test_regexp_with_interpolation
      assert_raise(Pattern::CompilationError) { scan("", "/\#{foo}/") }
    end

    def test_string_with_interpolation
      assert_raise(Pattern::CompilationError) { scan("", '"#{foo}"') }
    end

    def test_symbol_with_interpolation
      assert_raise(Pattern::CompilationError) { scan("", ":\"\#{foo}\"") }
    end

    def test_invalid_node
      assert_raise(Pattern::CompilationError) { scan("", "IntegerNode[^foo]") }
    end

    def test_self
      assert_raise(Pattern::CompilationError) { scan("", "self") }
    end

    def test_array_pattern_no_constant
      results = scan("1 + 2", "[IntegerNode]")

      assert_equal 1, results.length
    end

    def test_array_pattern
      results = scan("1 + 2", "CallNode[name: :+, receiver: IntegerNode, arguments: [IntegerNode]]")

      assert_equal 1, results.length
    end

    def test_alternation_pattern
      results = scan("Foo + Bar + 1", "ConstantReadNode | IntegerNode")

      assert_equal 3, results.length
      assert_equal 1, results.grep(IntegerNode).first.value
    end

    def test_constant_read_node
      results = scan("Foo + Bar + Baz", "ConstantReadNode")

      assert_equal 3, results.length
      assert_equal %w[Bar Baz Foo], results.map(&:slice).sort
    end

    def test_object_const
      results = scan("1 + 2 + 3", "IntegerNode[]")

      assert_equal 3, results.length
    end

    def test_constant_path
      results = scan("Foo + Bar + Baz", "Prism::ConstantReadNode")

      assert_equal 3, results.length
    end

    def test_hash_pattern_no_constant
      results = scan("Foo + Bar + Baz", "{ name: :+ }")

      assert_equal 2, results.length
    end

    def test_hash_pattern_regexp
      results = scan("Foo + Bar + Baz", "{ name: /^[[:punct:]]$/ }")

      assert_equal 2, results.length
      assert_equal ["Prism::CallNode"], results.map { |node| node.class.name }.uniq
    end

    def test_nil
      results = scan("foo", "{ receiver: nil }")

      assert_equal 1, results.length
    end

    def test_regexp_options
      results = scan("@foo + @bar + @baz", "InstanceVariableReadNode[name: /^@B/i]")

      assert_equal 2, results.length
    end

    def test_string_empty
      results = scan("", "''")

      assert_empty results
    end

    def test_symbol_empty
      results = scan("", ":''")

      assert_empty results
    end

    def test_symbol_plain
      results = scan("@foo", "{ name: :\"@foo\" }")

      assert_equal 1, results.length
    end

    def test_symbol
      results = scan("@foo", "{ name: :@foo }")

      assert_equal 1, results.length
    end

    private

    def scan(source, query)
      Prism::Pattern.new(query).scan(Prism.parse(source).value).to_a
    end
  end
end
prism-1.5.1/test/prism/ruby/reflection_test.rb000066400000000000000000000007661506127434000214730ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class ReflectionTest < TestCase
    def test_fields_for
      fields = Reflection.fields_for(CallNode)
      methods = CallNode.instance_methods(false)

      fields.each do |field|
        if field.is_a?(Reflection::FlagsField)
          field.flags.each do |flag|
            assert_includes methods, flag
          end
        else
          assert_includes methods, field.name
        end
      end
    end
  end
end
prism-1.5.1/test/prism/ruby/relocation_test.rb000066400000000000000000000152651506127434000215000ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class RelocationTest < TestCase
    def test_repository_filepath
      repository = Relocation.filepath(__FILE__).lines
      declaration = Prism.parse_file(__FILE__).value.statements.body[1]

      assert_equal 5, declaration.save(repository).start_line
    end

    def test_filepath
      repository = Relocation.filepath(__FILE__).filepath
      declaration = Prism.parse_file(__FILE__).value.statements.body[1]

      assert_equal __FILE__, declaration.save(repository).filepath
    end

    def test_lines
      source = "class Foo😀\nend"
      repository = Relocation.string(source).lines
      declaration = Prism.parse(source).value.statements.body.first

      node_entry = declaration.save(repository)
      location_entry = declaration.save_location(repository)

      assert_equal 1, node_entry.start_line
      assert_equal 2, node_entry.end_line

      assert_equal 1, location_entry.start_line
      assert_equal 2, location_entry.end_line
    end

    def test_offsets
      source = "class Foo😀\nend"
      repository = Relocation.string(source).offsets
      declaration = Prism.parse(source).value.statements.body.first

      node_entry = declaration.constant_path.save(repository)
      location_entry = declaration.constant_path.save_location(repository)

      assert_equal 6, node_entry.start_offset
      assert_equal 13, node_entry.end_offset

      assert_equal 6, location_entry.start_offset
      assert_equal 13, location_entry.end_offset
    end

    def test_character_offsets
      source = "class Foo😀\nend"
      repository = Relocation.string(source).character_offsets
      declaration = Prism.parse(source).value.statements.body.first

      node_entry = declaration.constant_path.save(repository)
      location_entry = declaration.constant_path.save_location(repository)

      assert_equal 6, node_entry.start_character_offset
      assert_equal 10, node_entry.end_character_offset

      assert_equal 6, location_entry.start_character_offset
      assert_equal 10, location_entry.end_character_offset
    end

    def test_code_unit_offsets
      source = "class Foo😀\nend"
      repository = Relocation.string(source).code_unit_offsets(Encoding::UTF_16LE)
      declaration = Prism.parse(source).value.statements.body.first

      node_entry = declaration.constant_path.save(repository)
      location_entry = declaration.constant_path.save_location(repository)

      assert_equal 6, node_entry.start_code_units_offset
      assert_equal 11, node_entry.end_code_units_offset

      assert_equal 6, location_entry.start_code_units_offset
      assert_equal 11, location_entry.end_code_units_offset
    end

    def test_columns
      source = "class Foo😀\nend"
      repository = Relocation.string(source).columns
      declaration = Prism.parse(source).value.statements.body.first

      node_entry = declaration.constant_path.save(repository)
      location_entry = declaration.constant_path.save_location(repository)

      assert_equal 6, node_entry.start_column
      assert_equal 13, node_entry.end_column

      assert_equal 6, location_entry.start_column
      assert_equal 13, location_entry.end_column
    end

    def test_character_columns
      source = "class Foo😀\nend"
      repository = Relocation.string(source).character_columns
      declaration = Prism.parse(source).value.statements.body.first

      node_entry = declaration.constant_path.save(repository)
      location_entry = declaration.constant_path.save_location(repository)

      assert_equal 6, node_entry.start_character_column
      assert_equal 10, node_entry.end_character_column

      assert_equal 6, location_entry.start_character_column
      assert_equal 10, location_entry.end_character_column
    end

    def test_code_unit_columns
      source = "class Foo😀\nend"
      repository = Relocation.string(source).code_unit_columns(Encoding::UTF_16LE)
      declaration = Prism.parse(source).value.statements.body.first

      node_entry = declaration.constant_path.save(repository)
      location_entry = declaration.constant_path.save_location(repository)

      assert_equal 6, node_entry.start_code_units_column
      assert_equal 11, node_entry.end_code_units_column

      assert_equal 6, location_entry.start_code_units_column
      assert_equal 11, location_entry.end_code_units_column
    end

    def test_leading_comments
      source = "# leading\nclass Foo\nend"
      repository = Relocation.string(source).leading_comments
      declaration = Prism.parse(source).value.statements.body.first

      node_entry = declaration.save(repository)
      location_entry = declaration.save_location(repository)

      assert_equal ["# leading"], node_entry.leading_comments.map(&:slice)
      assert_equal ["# leading"], location_entry.leading_comments.map(&:slice)
    end

    def test_trailing_comments
      source = "class Foo\nend\n# trailing"
      repository = Relocation.string(source).trailing_comments
      declaration = Prism.parse(source).value.statements.body.first

      node_entry = declaration.save(repository)
      location_entry = declaration.save_location(repository)

      assert_equal ["# trailing"], node_entry.trailing_comments.map(&:slice)
      assert_equal ["# trailing"], location_entry.trailing_comments.map(&:slice)
    end

    def test_comments
      source = "# leading\nclass Foo\nend\n# trailing"
      repository = Relocation.string(source).comments
      declaration = Prism.parse(source).value.statements.body.first

      node_entry = declaration.save(repository)
      location_entry = declaration.save_location(repository)

      assert_equal ["# leading", "# trailing"], node_entry.comments.map(&:slice)
      assert_equal ["# leading", "# trailing"], location_entry.comments.map(&:slice)
    end

    def test_misconfiguration
      assert_raise Relocation::Repository::ConfigurationError do
        Relocation.string("").comments.leading_comments
      end

      assert_raise Relocation::Repository::ConfigurationError do
        Relocation.string("").comments.trailing_comments
      end

      assert_raise Relocation::Repository::ConfigurationError do
        Relocation.string("").code_unit_offsets(Encoding::UTF_8).code_unit_offsets(Encoding::UTF_16LE)
      end

      assert_raise Relocation::Repository::ConfigurationError do
        Relocation.string("").lines.lines
      end
    end

    def test_missing_values
      source = "class Foo; end"
      repository = Relocation.string(source).lines

      declaration = Prism.parse(source).value.statements.body.first
      entry = declaration.constant_path.save(repository)

      assert_raise Relocation::Entry::MissingValueError do
        entry.start_offset
      end
    end
  end
end
prism-1.5.1/test/prism/ruby/ripper_test.rb000066400000000000000000000044651506127434000206420ustar00rootroot00000000000000# frozen_string_literal: true

return if RUBY_VERSION < "3.3" || RUBY_ENGINE != "ruby"

require_relative "../test_helper"

module Prism
  class RipperTest < TestCase
    # Skip these tests that Ripper is reporting the wrong results for.
    incorrect = [
      # Not yet supported.
      "leading_logical.txt",

      # Ripper incorrectly attributes the block to the keyword.
      "seattlerb/block_break.txt",
      "seattlerb/block_next.txt",
      "seattlerb/block_return.txt",
      "whitequark/break_block.txt",
      "whitequark/next_block.txt",
      "whitequark/return_block.txt",

      # Ripper is not accounting for locals created by patterns using the **
      # operator within an `in` clause.
      "seattlerb/parse_pattern_058.txt",

      # Ripper cannot handle named capture groups in regular expressions.
      "regex.txt",
      "regex_char_width.txt",
      "whitequark/lvar_injecting_match.txt",

      # Ripper fails to understand some structures that span across heredocs.
      "spanning_heredoc.txt",

      # https://bugs.ruby-lang.org/issues/17398#note-12
      "endless_methods_command_call.txt",
    ]

    # Skip these tests that we haven't implemented yet.
    omitted = [
      "dos_endings.txt",
      "heredocs_with_fake_newlines.txt",
      "heredocs_with_ignored_newlines.txt",
      "seattlerb/block_call_dot_op2_brace_block.txt",
      "seattlerb/block_command_operation_colon.txt",
      "seattlerb/block_command_operation_dot.txt",
      "seattlerb/heredoc__backslash_dos_format.txt",
      "seattlerb/heredoc_backslash_nl.txt",
      "seattlerb/heredoc_nested.txt",
      "seattlerb/heredoc_squiggly_blank_line_plus_interpolation.txt",
      "tilde_heredocs.txt",
      "unparser/corpus/semantic/dstr.txt",
      "whitequark/dedenting_heredoc.txt",
      "whitequark/parser_drops_truncated_parts_of_squiggly_heredoc.txt",
      "whitequark/parser_slash_slash_n_escaping_in_literals.txt",
      "whitequark/ruby_bug_18878.txt",
      "whitequark/send_block_chain_cmd.txt",
      "whitequark/slash_newline_in_heredocs.txt"
    ]

    Fixture.each(except: incorrect | omitted) do |fixture|
      define_method(fixture.test_name) { assert_ripper(fixture.read) }
    end

    private

    def assert_ripper(source)
      assert_equal Ripper.sexp_raw(source), Prism::Translation::Ripper.sexp_raw(source)
    end
  end
end
prism-1.5.1/test/prism/ruby/ruby_parser_test.rb000066400000000000000000000106651506127434000216750ustar00rootroot00000000000000# frozen_string_literal: true

return if RUBY_ENGINE == "jruby"

require_relative "../test_helper"

begin
  require "ruby_parser"
rescue LoadError
  # In CRuby's CI, we're not going to test against the ruby_parser gem because
  # we don't want to have to install it. So in this case we'll just skip this
  # test.
  return
end

module Prism
  class RubyParserTest < TestCase
    todos = [
      "encoding_euc_jp.txt",
      "regex_char_width.txt",
      "seattlerb/masgn_colon3.txt",
      "seattlerb/messy_op_asgn_lineno.txt",
      "seattlerb/op_asgn_primary_colon_const_command_call.txt",
      "seattlerb/regexp_esc_C_slash.txt",
      "seattlerb/str_lit_concat_bad_encodings.txt",
      "strings.txt",
      "unescaping.txt",
      "whitequark/masgn_const.txt",
      "whitequark/pattern_matching_constants.txt",
      "whitequark/pattern_matching_single_match.txt",
      "whitequark/ruby_bug_12402.txt",
    ]

    # https://github.com/seattlerb/ruby_parser/issues/344
    failures = [
      "alias.txt",
      "dsym_str.txt",
      "dos_endings.txt",
      "heredocs_with_fake_newlines.txt",
      "heredocs_with_ignored_newlines.txt",
      "leading_logical.txt",
      "method_calls.txt",
      "methods.txt",
      "multi_write.txt",
      "not.txt",
      "patterns.txt",
      "regex.txt",
      "seattlerb/and_multi.txt",
      "seattlerb/heredoc__backslash_dos_format.txt",
      "seattlerb/heredoc_bad_hex_escape.txt",
      "seattlerb/heredoc_bad_oct_escape.txt",
      "seattlerb/heredoc_with_extra_carriage_horrible_mix.txt",
      "seattlerb/heredoc_with_extra_carriage_returns_windows.txt",
      "seattlerb/heredoc_with_only_carriage_returns_windows.txt",
      "seattlerb/heredoc_with_only_carriage_returns.txt",
      "spanning_heredoc_newlines.txt",
      "spanning_heredoc.txt",
      "symbols.txt",
      "tilde_heredocs.txt",
      "unparser/corpus/literal/literal.txt",
      "while.txt",
      "whitequark/cond_eflipflop.txt",
      "whitequark/cond_iflipflop.txt",
      "whitequark/cond_match_current_line.txt",
      "whitequark/dedenting_heredoc.txt",
      "whitequark/lvar_injecting_match.txt",
      "whitequark/not.txt",
      "whitequark/numparam_ruby_bug_19025.txt",
      "whitequark/op_asgn_cmd.txt",
      "whitequark/parser_bug_640.txt",
      "whitequark/parser_slash_slash_n_escaping_in_literals.txt",
      "whitequark/pattern_matching_single_line_allowed_omission_of_parentheses.txt",
      "whitequark/pattern_matching_single_line.txt",
      "whitequark/ruby_bug_11989.txt",
      "whitequark/ruby_bug_18878.txt",
      "whitequark/ruby_bug_19281.txt",
      "whitequark/slash_newline_in_heredocs.txt",

      # Ruby >= 3.5 specific syntax
      "endless_methods_command_call.txt",
    ]

    Fixture.each(except: failures) do |fixture|
      define_method(fixture.test_name) do
        assert_ruby_parser(fixture, todos.include?(fixture.path))
      end
    end

    private

    def assert_ruby_parser(fixture, allowed_failure)
      source = fixture.read
      expected = ignore_warnings { ::RubyParser.new.parse(source, fixture.path) }
      actual = Prism::Translation::RubyParser.new.parse(source, fixture.path)
      on_failure = -> { message(expected, actual) }

      if !allowed_failure
        assert_equal(expected, actual, on_failure)

        unless actual.nil?
          assert_equal(expected.line, actual.line, on_failure)
          assert_equal(expected.file, actual.file, on_failure)
        end
      elsif expected == actual && expected.line && actual.line && expected.file == actual.file
        puts "#{name} now passes"
      end
    end

    def message(expected, actual)
      if expected == actual
        nil
      elsif expected.is_a?(Sexp) && actual.is_a?(Sexp)
        if expected.line != actual.line
          "expected: (#{expected.inspect} line=#{expected.line}), actual: (#{actual.inspect} line=#{actual.line})"
        elsif expected.file != actual.file
          "expected: (#{expected.inspect} file=#{expected.file}), actual: (#{actual.inspect} file=#{actual.file})"
        elsif expected.length != actual.length
          "expected: (#{expected.inspect} length=#{expected.length}), actual: (#{actual.inspect} length=#{actual.length})"
        else
          expected.zip(actual).find do |expected_field, actual_field|
            result = message(expected_field, actual_field)
            break result if result
          end
        end
      else
        "expected: #{expected.inspect}, actual: #{actual.inspect}"
      end
    end
  end
end
prism-1.5.1/test/prism/ruby/string_query_test.rb000066400000000000000000000040341506127434000220640ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class StringQueryTest < TestCase
    def test_local?
      assert_predicate StringQuery.new("a"), :local?
      assert_predicate StringQuery.new("a1"), :local?
      assert_predicate StringQuery.new("self"), :local?

      assert_predicate StringQuery.new("_a"), :local?
      assert_predicate StringQuery.new("_1"), :local?

      assert_predicate StringQuery.new("😀"), :local?
      assert_predicate StringQuery.new("ã‚¢".encode("Windows-31J")), :local?

      refute_predicate StringQuery.new("1"), :local?
      refute_predicate StringQuery.new("A"), :local?
    end

    def test_constant?
      assert_predicate StringQuery.new("A"), :constant?
      assert_predicate StringQuery.new("A1"), :constant?
      assert_predicate StringQuery.new("A_B"), :constant?
      assert_predicate StringQuery.new("BEGIN"), :constant?

      assert_predicate StringQuery.new("À"), :constant?
      assert_predicate StringQuery.new("A".encode("US-ASCII")), :constant?

      refute_predicate StringQuery.new("a"), :constant?
      refute_predicate StringQuery.new("1"), :constant?
    end

    def test_method_name?
      assert_predicate StringQuery.new("a"), :method_name?
      assert_predicate StringQuery.new("A"), :method_name?
      assert_predicate StringQuery.new("__FILE__"), :method_name?

      assert_predicate StringQuery.new("a?"), :method_name?
      assert_predicate StringQuery.new("a!"), :method_name?
      assert_predicate StringQuery.new("a="), :method_name?

      assert_predicate StringQuery.new("+"), :method_name?
      assert_predicate StringQuery.new("<<"), :method_name?
      assert_predicate StringQuery.new("==="), :method_name?

      assert_predicate StringQuery.new("_0"), :method_name?

      refute_predicate StringQuery.new("1"), :method_name?
      refute_predicate StringQuery.new("_1"), :method_name?
    end

    def test_invalid_encoding
      assert_raise ArgumentError do
        StringQuery.new("A".encode("UTF-16LE")).local?
      end
    end
  end
end
prism-1.5.1/test/prism/ruby/tunnel_test.rb000066400000000000000000000013371506127434000206410ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "../test_helper"

module Prism
  class TunnelTest < TestCase
    def test_tunnel
      program = Prism.parse("foo(1) +\n  bar(2, 3) +\n  baz(3, 4, 5)").value

      tunnel = program.tunnel(1, 4).last
      assert_kind_of IntegerNode, tunnel
      assert_equal 1, tunnel.value

      tunnel = program.tunnel(2, 6).last
      assert_kind_of IntegerNode, tunnel
      assert_equal 2, tunnel.value

      tunnel = program.tunnel(3, 9).last
      assert_kind_of IntegerNode, tunnel
      assert_equal 4, tunnel.value

      tunnel = program.tunnel(3, 8)
      assert_equal [ProgramNode, StatementsNode, CallNode, ArgumentsNode, CallNode, ArgumentsNode], tunnel.map(&:class)
    end
  end
end
prism-1.5.1/test/prism/snapshots_test.rb000066400000000000000000000046361506127434000204020ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "test_helper"

# We don't want to generate snapshots when running
# against files outside of the project folder.
return if Prism::TestCase::Fixture.custom_base_path?

module Prism
  class SnapshotsTest < TestCase
    # When we pretty-print the trees to compare against the snapshots, we want
    # to be certain that we print with the same external encoding. This is
    # because methods like Symbol#inspect take into account external encoding
    # and it could change how the snapshot is generated. On machines with
    # certain settings (like LANG=C or -Eascii-8bit) this could have been
    # changed. So here we're going to force it to be UTF-8 to keep the snapshots
    # consistent.
    def setup
      @previous_default_external = Encoding.default_external
      ignore_warnings { Encoding.default_external = Encoding::UTF_8 }
    end

    def teardown
      ignore_warnings { Encoding.default_external = @previous_default_external }
    end

    except = []

    # These fail on TruffleRuby due to a difference in Symbol#inspect:
    # :测试 vs :"测试"
    if RUBY_ENGINE == "truffleruby"
      except.push(
        "emoji_method_calls.txt",
        "seattlerb/bug202.txt",
        "seattlerb/magic_encoding_comment.txt"
      )
    end

    Fixture.each(except: except) do |fixture|
      define_method(fixture.test_name) { assert_snapshot(fixture) }
    end

    private

    def assert_snapshot(fixture)
      source = fixture.read

      result = Prism.parse(source, filepath: fixture.path)
      assert result.success?

      printed = PP.pp(result.value, +"", 79)
      snapshot = fixture.snapshot_path

      if File.exist?(snapshot)
        saved = File.read(snapshot)

        # If the snapshot file exists, but the printed value does not match the
        # snapshot, then update the snapshot file.
        if printed != saved
          File.write(snapshot, printed)
          warn("Updated snapshot at #{snapshot}.")
        end

        # If the snapshot file exists, then assert that the printed value
        # matches the snapshot.
        assert_equal(saved, printed)
      else
        # If the snapshot file does not yet exist, then write it out now.
        directory = File.dirname(snapshot)
        FileUtils.mkdir_p(directory) unless File.directory?(directory)

        File.write(snapshot, printed)
        warn("Created snapshot at #{snapshot}.")
      end
    end
  end
end
prism-1.5.1/test/prism/snippets_test.rb000066400000000000000000000024331506127434000202160ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "test_helper"

module Prism
  class SnippetsTest < TestCase
    except = [
      "encoding_binary.txt",
      "newline_terminated.txt",
      "seattlerb/begin_rescue_else_ensure_no_bodies.txt",
      "seattlerb/case_in.txt",
      "seattlerb/parse_line_defn_no_parens.txt",
      "seattlerb/pct_nl.txt",
      "seattlerb/str_heredoc_interp.txt",
      "spanning_heredoc_newlines.txt",
      "unparser/corpus/semantic/dstr.txt",
      "whitequark/dedenting_heredoc.txt",
      "whitequark/multiple_pattern_matches.txt"
    ]

    Fixture.each(except: except) do |fixture|
      define_method(fixture.test_name) { assert_snippets(fixture) }
    end

    private

    # We test every snippet (separated by \n\n) in isolation to ensure the
    # parser does not try to read bytes further than the end of each snippet.
    def assert_snippets(fixture)
      fixture.read.split(/(?<=\S)\n\n(?=\S)/).each do |snippet|
        snippet = snippet.rstrip

        result = Prism.parse(snippet, filepath: fixture.path)
        assert result.success?

        if !ENV["PRISM_BUILD_MINIMAL"]
          dumped = Prism.dump(snippet, filepath: fixture.path)
          assert_equal_nodes(result.value, Prism.load(snippet, dumped).value)
        end
      end
    end
  end
end
prism-1.5.1/test/prism/test_helper.rb000066400000000000000000000301421506127434000176260ustar00rootroot00000000000000# frozen_string_literal: true

require "prism"
require "pp"
require "ripper"
require "stringio"
require "test/unit"
require "tempfile"

puts "Using prism backend: #{Prism::BACKEND}" if ENV["PRISM_FFI_BACKEND"]

# It is useful to have a diff even if the strings to compare are big
# However, ruby/ruby does not have a version of Test::Unit with access to
# max_diff_target_string_size
if defined?(Test::Unit::Assertions::AssertionMessage)
  Test::Unit::Assertions::AssertionMessage.max_diff_target_string_size = 5000
end

module Prism
  # A convenience method for retrieving the first statement in the source string
  # parsed by Prism.
  def self.parse_statement(source, **options)
    parse(source, **options).value.statements.body.first
  end

  class ParseResult < Result
    # Returns the first statement in the body of the parsed source.
    def statement
      value.statements.body.first
    end
  end

  class TestCase < ::Test::Unit::TestCase
    # We have a set of fixtures that we use to test various aspects of the
    # parser. They are all represented as .txt files under the
    # test/prism/fixtures directory. Typically in test files you will find calls
    # to Fixture.each which yields Fixture objects to the given block. These
    # are used to define test methods that assert against each fixture in some
    # way.
    class Fixture
      BASE = ENV.fetch("FIXTURE_BASE", File.join(__dir__, "fixtures"))

      attr_reader :path

      def initialize(path)
        @path = path
      end

      def read
        File.read(full_path, binmode: true, external_encoding: Encoding::UTF_8)
      end

      def full_path
        File.join(BASE, path)
      end

      def snapshot_path
        File.join(File.expand_path("../..", __dir__), "snapshots", path)
      end

      def test_name
        :"test_#{path}"
      end

      def self.each(except: [], &block)
        glob_pattern = ENV.fetch("FOCUS") { custom_base_path? ? File.join("**", "*.rb") : File.join("**", "*.txt") }
        paths = Dir[glob_pattern, base: BASE] - except
        paths.each { |path| yield Fixture.new(path) }
      end

      def self.custom_base_path?
        ENV.key?("FIXTURE_BASE")
      end
    end

    # Yield each encoding that we want to test, along with a range of the
    # codepoints that should be tested.
    def self.each_encoding
      codepoints_1byte = 0...0x100

      yield Encoding::ASCII_8BIT, codepoints_1byte
      yield Encoding::US_ASCII, codepoints_1byte

      if !ENV["PRISM_BUILD_MINIMAL"]
        yield Encoding::Windows_1253, codepoints_1byte
      end

      # By default we don't test every codepoint in these encodings because it
      # takes a very long time.
      return unless ENV["PRISM_TEST_ALL_ENCODINGS"]

      yield Encoding::CP850, codepoints_1byte
      yield Encoding::CP852, codepoints_1byte
      yield Encoding::CP855, codepoints_1byte
      yield Encoding::GB1988, codepoints_1byte
      yield Encoding::IBM437, codepoints_1byte
      yield Encoding::IBM720, codepoints_1byte
      yield Encoding::IBM737, codepoints_1byte
      yield Encoding::IBM775, codepoints_1byte
      yield Encoding::IBM852, codepoints_1byte
      yield Encoding::IBM855, codepoints_1byte
      yield Encoding::IBM857, codepoints_1byte
      yield Encoding::IBM860, codepoints_1byte
      yield Encoding::IBM861, codepoints_1byte
      yield Encoding::IBM862, codepoints_1byte
      yield Encoding::IBM863, codepoints_1byte
      yield Encoding::IBM864, codepoints_1byte
      yield Encoding::IBM865, codepoints_1byte
      yield Encoding::IBM866, codepoints_1byte
      yield Encoding::IBM869, codepoints_1byte
      yield Encoding::ISO_8859_1, codepoints_1byte
      yield Encoding::ISO_8859_2, codepoints_1byte
      yield Encoding::ISO_8859_3, codepoints_1byte
      yield Encoding::ISO_8859_4, codepoints_1byte
      yield Encoding::ISO_8859_5, codepoints_1byte
      yield Encoding::ISO_8859_6, codepoints_1byte
      yield Encoding::ISO_8859_7, codepoints_1byte
      yield Encoding::ISO_8859_8, codepoints_1byte
      yield Encoding::ISO_8859_9, codepoints_1byte
      yield Encoding::ISO_8859_10, codepoints_1byte
      yield Encoding::ISO_8859_11, codepoints_1byte
      yield Encoding::ISO_8859_13, codepoints_1byte
      yield Encoding::ISO_8859_14, codepoints_1byte
      yield Encoding::ISO_8859_15, codepoints_1byte
      yield Encoding::ISO_8859_16, codepoints_1byte
      yield Encoding::KOI8_R, codepoints_1byte
      yield Encoding::KOI8_U, codepoints_1byte
      yield Encoding::MACCENTEURO, codepoints_1byte
      yield Encoding::MACCROATIAN, codepoints_1byte
      yield Encoding::MACCYRILLIC, codepoints_1byte
      yield Encoding::MACGREEK, codepoints_1byte
      yield Encoding::MACICELAND, codepoints_1byte
      yield Encoding::MACROMAN, codepoints_1byte
      yield Encoding::MACROMANIA, codepoints_1byte
      yield Encoding::MACTHAI, codepoints_1byte
      yield Encoding::MACTURKISH, codepoints_1byte
      yield Encoding::MACUKRAINE, codepoints_1byte
      yield Encoding::TIS_620, codepoints_1byte
      yield Encoding::Windows_1250, codepoints_1byte
      yield Encoding::Windows_1251, codepoints_1byte
      yield Encoding::Windows_1252, codepoints_1byte
      yield Encoding::Windows_1254, codepoints_1byte
      yield Encoding::Windows_1255, codepoints_1byte
      yield Encoding::Windows_1256, codepoints_1byte
      yield Encoding::Windows_1257, codepoints_1byte
      yield Encoding::Windows_1258, codepoints_1byte
      yield Encoding::Windows_874, codepoints_1byte

      codepoints_2bytes = 0...0x10000

      yield Encoding::Big5, codepoints_2bytes
      yield Encoding::Big5_HKSCS, codepoints_2bytes
      yield Encoding::Big5_UAO, codepoints_2bytes
      yield Encoding::CP949, codepoints_2bytes
      yield Encoding::CP950, codepoints_2bytes
      yield Encoding::CP951, codepoints_2bytes
      yield Encoding::EUC_KR, codepoints_2bytes
      yield Encoding::GBK, codepoints_2bytes
      yield Encoding::GB12345, codepoints_2bytes
      yield Encoding::GB2312, codepoints_2bytes
      yield Encoding::MACJAPANESE, codepoints_2bytes
      yield Encoding::Shift_JIS, codepoints_2bytes
      yield Encoding::SJIS_DoCoMo, codepoints_2bytes
      yield Encoding::SJIS_KDDI, codepoints_2bytes
      yield Encoding::SJIS_SoftBank, codepoints_2bytes
      yield Encoding::Windows_31J, codepoints_2bytes

      codepoints_unicode = (0...0x110000)

      yield Encoding::UTF_8, codepoints_unicode
      yield Encoding::UTF8_MAC, codepoints_unicode
      yield Encoding::UTF8_DoCoMo, codepoints_unicode
      yield Encoding::UTF8_KDDI, codepoints_unicode
      yield Encoding::UTF8_SoftBank, codepoints_unicode
      yield Encoding::CESU_8, codepoints_unicode

      codepoints_eucjp = [
        *(0...0x10000),
        *(0...0x10000).map { |bytes| bytes | 0x8F0000 }
      ]

      yield Encoding::CP51932, codepoints_eucjp
      yield Encoding::EUC_JP, codepoints_eucjp
      yield Encoding::EUCJP_MS, codepoints_eucjp
      yield Encoding::EUC_JIS_2004, codepoints_eucjp

      codepoints_emacs_mule = [
        *(0...0x80),
        *((0x81...0x90).flat_map { |byte1| (0x90...0x100).map { |byte2| byte1 << 8 | byte2 } }),
        *((0x90...0x9C).flat_map { |byte1| (0xA0...0x100).flat_map { |byte2| (0xA0...0x100).flat_map { |byte3| byte1 << 16 | byte2 << 8 | byte3 } } }),
        *((0xF0...0xF5).flat_map { |byte2| (0xA0...0x100).flat_map { |byte3| (0xA0...0x100).flat_map { |byte4| 0x9C << 24 | byte3 << 16 | byte3 << 8 | byte4 } } }),
      ]

      yield Encoding::EMACS_MULE, codepoints_emacs_mule
      yield Encoding::STATELESS_ISO_2022_JP, codepoints_emacs_mule
      yield Encoding::STATELESS_ISO_2022_JP_KDDI, codepoints_emacs_mule

      codepoints_gb18030 = [
        *(0...0x80),
        *((0x81..0xFE).flat_map { |byte1| (0x40...0x100).map { |byte2| byte1 << 8 | byte2 } }),
        *((0x81..0xFE).flat_map { |byte1| (0x30...0x40).flat_map { |byte2| (0x81..0xFE).flat_map { |byte3| (0x2F...0x41).map { |byte4| byte1 << 24 | byte2 << 16 | byte3 << 8 | byte4 } } } }),
      ]

      yield Encoding::GB18030, codepoints_gb18030

      codepoints_euc_tw = [
        *(0..0x7F),
        *(0xA1..0xFF).flat_map { |byte1| (0xA1..0xFF).map { |byte2| (byte1 << 8) | byte2 } },
        *(0xA1..0xB0).flat_map { |byte2| (0xA1..0xFF).flat_map { |byte3| (0xA1..0xFF).flat_map { |byte4| 0x8E << 24 | byte2 << 16 | byte3 << 8 | byte4 } } }
      ]

      yield Encoding::EUC_TW, codepoints_euc_tw
    end

    # True if the current platform is Windows.
    def self.windows?
      RbConfig::CONFIG["host_os"].match?(/bccwin|cygwin|djgpp|mingw|mswin|wince/i)
    end

    private

    if RUBY_ENGINE == "ruby" && RubyVM::InstructionSequence.compile("").to_a[4][:parser] != :prism
      # Check that the given source is valid syntax by compiling it with RubyVM.
      def check_syntax(source)
        ignore_warnings { RubyVM::InstructionSequence.compile(source) }
      end

      # Assert that the given source is valid Ruby syntax by attempting to
      # compile it, and then implicitly checking that it does not raise an
      # syntax errors.
      def assert_valid_syntax(source)
        check_syntax(source)
      end

      # Refute that the given source is invalid Ruby syntax by attempting to
      # compile it and asserting that it raises a SyntaxError.
      def refute_valid_syntax(source)
        assert_raise(SyntaxError) { check_syntax(source) }
      end
    else
      def assert_valid_syntax(source)
      end

      def refute_valid_syntax(source)
      end
    end

    # CRuby has this same method, so define it so that we don't accidentally
    # break CRuby CI.
    def assert_raises(*args, &block)
      raise "Use assert_raise instead"
    end

    def assert_equal_nodes(expected, actual, compare_location: true, parent: nil)
      assert_equal expected.class, actual.class

      case expected
      when Array
        assert_equal(
          expected.size,
          actual.size,
          -> { "Arrays were different sizes. Parent: #{parent.pretty_inspect}" }
        )

        expected.zip(actual).each do |(expected_element, actual_element)|
          assert_equal_nodes(
            expected_element,
            actual_element,
            compare_location: compare_location,
            parent: actual
          )
        end
      when SourceFileNode
        expected_deconstruct = expected.deconstruct_keys(nil)
        actual_deconstruct = actual.deconstruct_keys(nil)
        assert_equal expected_deconstruct.keys, actual_deconstruct.keys

        # Filepaths can be different if test suites were run on different
        # machines. We accommodate for this by comparing the basenames, and not
        # the absolute filepaths.
        expected_filepath = expected_deconstruct.delete(:filepath)
        actual_filepath = actual_deconstruct.delete(:filepath)

        assert_equal expected_deconstruct, actual_deconstruct
        assert_equal File.basename(expected_filepath), File.basename(actual_filepath)
      when Node
        deconstructed_expected = expected.deconstruct_keys(nil)
        deconstructed_actual = actual.deconstruct_keys(nil)
        assert_equal deconstructed_expected.keys, deconstructed_actual.keys

        deconstructed_expected.each_key do |key|
          assert_equal_nodes(
            deconstructed_expected[key],
            deconstructed_actual[key],
            compare_location: compare_location,
            parent: actual
          )
        end
      when Location
        assert_operator actual.start_offset, :<=, actual.end_offset, -> {
          "start_offset > end_offset for #{actual.inspect}, parent is #{parent.pretty_inspect}"
        }

        if compare_location
          assert_equal(
            expected.start_offset,
            actual.start_offset,
            -> { "Start locations were different. Parent: #{parent.pretty_inspect}" }
          )

          assert_equal(
            expected.end_offset,
            actual.end_offset,
            -> { "End locations were different. Parent: #{parent.pretty_inspect}" }
          )
        end
      else
        assert_equal expected, actual
      end
    end

    def capture_warnings
      $stderr = StringIO.new
      yield
      $stderr.string
    ensure
      $stderr = STDERR
    end

    def ignore_warnings
      capture_warnings { return yield }
    end
  end
end
prism-1.5.1/test/prism/unescape_test.rb000066400000000000000000000175611506127434000201640ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "test_helper"

return if Prism::BACKEND == :FFI
return if RUBY_VERSION < "3.1.0"
return if RUBY_VERSION >= "3.4.0"

module Prism
  class UnescapeTest < TestCase
    module Context
      class Base
        attr_reader :left, :right

        def initialize(left, right)
          @left = left
          @right = right
        end

        def name
          "#{left}#{right}".delete("\n")
        end

        private

        def code(escape)
          "#{left}\\#{escape}#{right}".b
        end

        def ruby(escape)
          previous, $VERBOSE = $VERBOSE, nil

          begin
            yield eval(code(escape))
          rescue SyntaxError
            :error
          ensure
            $VERBOSE = previous
          end
        end

        def prism(escape)
          result = Prism.parse(code(escape), encoding: "binary")

          if result.success?
            yield result.statement
          else
            :error
          end
        end

        def `(command)
          command
        end
      end

      class List < Base
        def ruby_result(escape)
          ruby(escape) { |value| value.first.to_s }
        end

        def prism_result(escape)
          prism(escape) { |node| node.elements.first.unescaped }
        end
      end

      class Symbol < Base
        def ruby_result(escape)
          ruby(escape, &:to_s)
        end

        def prism_result(escape)
          prism(escape, &:unescaped)
        end
      end

      class String < Base
        def ruby_result(escape)
          ruby(escape, &:itself)
        end

        def prism_result(escape)
          prism(escape, &:unescaped)
        end
      end

      class Heredoc < Base
        def ruby_result(escape)
          ruby(escape, &:itself)
        end

        def prism_result(escape)
          prism(escape) do |node|
            case node.type
            when :interpolated_string_node, :interpolated_x_string_node
              node.parts.flat_map(&:unescaped).join
            else
              node.unescaped
            end
          end
        end
      end

      class RegExp < Base
        def ruby_result(escape)
          ruby(escape, &:source)
        end

        def prism_result(escape)
          prism(escape, &:unescaped)
        end
      end
    end

    def test_char; assert_context(Context::String.new("?", "")); end
    def test_sqte; assert_context(Context::String.new("'", "'")); end
    def test_dqte; assert_context(Context::String.new("\"", "\"")); end
    def test_lwrq; assert_context(Context::String.new("%q[", "]")); end
    def test_uprq; assert_context(Context::String.new("%Q[", "]")); end
    def test_dstr; assert_context(Context::String.new("%[", "]")); end
    def test_xstr; assert_context(Context::String.new("`", "`")); end
    def test_lwrx; assert_context(Context::String.new("%x[", "]")); end
    def test_h0_1; assert_context(Context::String.new("<")); end
    def test_uprw; assert_context(Context::List.new("%W[", "]")); end
    def test_lwri; assert_context(Context::List.new("%i[", "]")); end
    def test_upri; assert_context(Context::List.new("%I[", "]")); end
    def test_lwrs; assert_context(Context::Symbol.new("%s[", "]")); end
    def test_sym1; assert_context(Context::Symbol.new(":'", "'")); end
    def test_sym2; assert_context(Context::Symbol.new(":\"", "\"")); end
    def test_reg1; assert_context(Context::RegExp.new("/", "/")); end
    def test_reg2; assert_context(Context::RegExp.new("%r[", "]")); end
    def test_reg3; assert_context(Context::RegExp.new("%r<", ">")); end
    def test_reg4; assert_context(Context::RegExp.new("%r{", "}")); end
    def test_reg5; assert_context(Context::RegExp.new("%r(", ")")); end
    def test_reg6; assert_context(Context::RegExp.new("%r|", "|")); end

    private

    def assert_context(context)
      octal = [*("0".."7")]
      hex = [*("a".."f"), *("A".."F"), *("0".."9")]

      (0...256).each do |ord|
        # I think this might be a bug in Ruby.
        next if context.name == "?" && ord == 0xFF

        # We don't currently support scanning for the number of capture groups
        # to validate backreferences so these are all going to fail.
        next if (context.name == "//" || context.name.start_with?("%r")) && ord.chr.start_with?(/\d/)

        # \u is passed directly on to the regular expression engine and it is
        # responsible for handling syntax errors. In this case we do not check
        # it because it would require going through the compiler.
        next if context.is_a?(Context::RegExp) && ord.chr == "u"

        # \a \b \c ...
        assert_unescape(context, ord.chr)
      end

      # \\r\n
      assert_unescape(context, "\r\n")

      # We don't currently support scanning for the number of capture groups to
      # validate backreferences so these are all going to fail.
      if context.name != "//" && !context.name.start_with?("%r")
        # \00 \01 \02 ...
        octal.product(octal).each { |digits| assert_unescape(context, digits.join) }

        # \000 \001 \002 ...
        octal.product(octal).product(octal).each { |digits| assert_unescape(context, digits.join) }
      end

      # \x0 \x1 \x2 ...
      hex.each { |digit| assert_unescape(context, "x#{digit}") }

      # \x00 \x01 \x02 ...
      hex.product(hex).each { |digits| assert_unescape(context, "x#{digits.join}") }

      # \u0000 \u0001 \u0002 ...
      assert_unescape(context, "u#{["5"].concat(hex.sample(3)).join}")

      # The behavior of whitespace in the middle of these escape sequences
      # changed in Ruby 3.3.0, so we only want to test against latest.
      if RUBY_VERSION >= "3.3.0"
        # \u{00  00} ...
        assert_unescape(context, "u{00#{["5"].concat(hex.sample(3)).join} \t\v 00#{["5"].concat(hex.sample(3)).join}}")
      end

      (0...128).each do |ord|
        chr = ord.chr
        next if chr == "\\" || !chr.match?(/[[:print:]]/)

        # \C-a \C-b \C-c ...
        assert_unescape(context, "C-#{chr}")

        # \C-\a \C-\b \C-\c ...
        assert_unescape(context, "C-\\#{chr}")

        # \ca \cb \cc ...
        assert_unescape(context, "c#{chr}")

        # \M-a \M-b \M-c ...
        assert_unescape(context, "M-#{chr}")

        # \M-\C-a \M-\C-b \M-\C-c ...
        assert_unescape(context, "M-\\C-#{chr}")

        # \M-\ca \M-\cb \M-\cc ...
        assert_unescape(context, "M-\\c#{chr}")

        # \c\M-a \c\M-b \c\M-c ...
        assert_unescape(context, "c\\M-#{chr}")
      end
    end

    def assert_unescape(context, escape)
      expected = context.ruby_result(escape)
      actual = context.prism_result(escape)

      message = -> do
        "Expected #{context.name} to unescape #{escape.inspect} to " \
          "#{expected.inspect}, but got #{actual.inspect}"
      end

      if expected == :error || actual == :error
        assert_equal expected, actual, message
      else
        assert_equal expected.bytes, actual.bytes, message
      end
    end
  end
end
prism-1.5.1/test/prism/version_test.rb000066400000000000000000000002701506127434000200330ustar00rootroot00000000000000# frozen_string_literal: true

require_relative "test_helper"

module Prism
  class VersionTest < TestCase
    def test_prism_version_is_set
      refute_nil VERSION
    end
  end
end