gitextract_vw5g09h3/ ├── .bazelignore ├── .bazelrc ├── .dockerignore ├── .ghci.repl ├── .ghci.sample ├── .gitattributes ├── .github/ │ └── workflows/ │ ├── bazel.yml.disabled │ └── haskell.yml ├── .gitignore ├── .gitmodules ├── .hlint.yaml ├── .hspec ├── .licenses/ │ └── semantic/ │ └── cabal/ │ ├── MonadRandom.txt │ ├── QuickCheck.txt │ ├── StateVar.txt │ ├── adjunctions.txt │ ├── aeson-pretty.txt │ ├── aeson.txt │ ├── algebraic-graphs.txt │ ├── ansi-terminal.txt │ ├── ansi-wl-pprint.txt │ ├── array.txt │ ├── asn1-encoding.txt │ ├── asn1-parse.txt │ ├── asn1-types.txt │ ├── async.txt │ ├── attoparsec-iso8601.txt │ ├── attoparsec.txt │ ├── base-compat-batteries.txt │ ├── base-compat.txt │ ├── base-orphans.txt │ ├── base-prelude.txt │ ├── base.txt │ ├── base64-bytestring.txt │ ├── basement.txt │ ├── bifunctors.txt │ ├── binary.txt │ ├── blaze-builder.txt │ ├── byteable.txt │ ├── bytestring.txt │ ├── call-stack.txt │ ├── case-insensitive.txt │ ├── cereal.txt │ ├── charset.txt │ ├── clock.txt │ ├── cmark-gfm.txt │ ├── colour.txt │ ├── comonad.txt │ ├── connection.txt │ ├── constraints.txt │ ├── containers.txt │ ├── contravariant.txt │ ├── cookie.txt │ ├── cryptonite.txt │ ├── data-default-class.txt │ ├── deepseq-generics.txt │ ├── deepseq.txt │ ├── directory-tree.txt │ ├── directory.txt │ ├── distributive.txt │ ├── dlist.txt │ ├── enclosed-exceptions.txt │ ├── erf.txt │ ├── exceptions.txt │ ├── fastsum.txt │ ├── filepath.txt │ ├── fingertree.txt │ ├── foldl.txt │ ├── freer-cofreer.txt │ ├── fused-effects.txt │ ├── generic-monoid.txt │ ├── generics-sop.txt │ ├── ghc-boot-th.txt │ ├── ghc-boot.txt │ ├── ghc-heap.txt │ ├── ghc-prim.txt │ ├── ghc-tcplugins-extra.txt │ ├── ghc-typelits-extra.txt │ ├── ghc-typelits-knownnat.txt │ ├── ghc-typelits-natnormalise.txt │ ├── ghc.txt │ ├── ghci.txt │ ├── gitrev.txt │ ├── hashable.txt │ ├── haskeline.txt │ ├── haskell-lexer.txt │ ├── haskell-src.txt │ ├── haskell-tree-sitter.txt │ ├── heap.txt │ ├── hostname.txt │ ├── hourglass.txt │ ├── hpc.txt │ ├── http-api-data.txt │ ├── insert-ordered-containers.txt │ ├── integer-gmp.txt │ ├── integer-logarithms.txt │ ├── invariant.txt │ ├── kan-extensions.txt │ ├── kdt.txt │ ├── keys.txt │ ├── lens.txt │ ├── lifted-async.txt │ ├── lifted-base.txt │ ├── machines.txt │ ├── managed.txt │ ├── math-functions.txt │ ├── megaparsec.txt │ ├── memory.txt │ ├── mersenne-random-pure64.txt │ ├── mime-types.txt │ ├── mmorph.txt │ ├── monad-control.txt │ ├── mtl.txt │ ├── mwc-random.txt │ ├── neat-interpolation.txt │ ├── network-uri.txt │ ├── network.txt │ ├── old-locale.txt │ ├── old-time.txt │ ├── optional-args.txt │ ├── optparse-applicative.txt │ ├── parallel.txt │ ├── parsec.txt │ ├── parser-combinators.txt │ ├── parsers.txt │ ├── pem.txt │ ├── pointed.txt │ ├── pretty.txt │ ├── prettyprinter.txt │ ├── primitive.txt │ ├── process.txt │ ├── profunctors.txt │ ├── proto3-suite.txt │ ├── proto3-wire.txt │ ├── quickcheck-instances.txt │ ├── random.txt │ ├── recursion-schemes.txt │ ├── reducers.txt │ ├── reflection.txt │ ├── rts.txt │ ├── safe.txt │ ├── scientific.txt │ ├── semigroupoids.txt │ ├── semigroups.txt │ ├── semilattices.txt │ ├── servant.txt │ ├── shelly.txt │ ├── singleton-bool.txt │ ├── socks.txt │ ├── sop-core.txt │ ├── split.txt │ ├── stm-chans.txt │ ├── stm.txt │ ├── streaming-commons.txt │ ├── string-conversions.txt │ ├── swagger2.txt │ ├── syb.txt │ ├── system-fileio.txt │ ├── system-filepath.txt │ ├── tagged.txt │ ├── template-haskell.txt │ ├── temporary.txt │ ├── terminfo.txt │ ├── text.txt │ ├── tf-random.txt │ ├── th-abstraction.txt │ ├── these.txt │ ├── time-locale-compat.txt │ ├── time.txt │ ├── tls.txt │ ├── transformers-base.txt │ ├── transformers-compat.txt │ ├── transformers.txt │ ├── turtle.txt │ ├── unix-compat.txt │ ├── unix.txt │ ├── unliftio-core.txt │ ├── unordered-containers.txt │ ├── utf8-string.txt │ ├── uuid-types.txt │ ├── vault.txt │ ├── vector-builder.txt │ ├── vector-instances.txt │ ├── vector-th-unbox.txt │ ├── vector.txt │ ├── void.txt │ ├── x509-store.txt │ ├── x509-system.txt │ ├── x509-validation.txt │ ├── x509.txt │ └── zlib.txt ├── .stylish-haskell.yaml ├── BUILD.bazel ├── CODEOWNERS ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── Dockerfile ├── HACKING.md ├── README.md ├── WORKSPACE ├── build/ │ ├── common.bzl │ └── example_repos.bzl ├── cabal.project ├── cabal.project.ci ├── docs/ │ ├── adding-new-languages.md │ ├── build.md │ ├── codegen.md │ ├── coding-style.md │ ├── configuration.md │ ├── core-grammar.md │ ├── development.md │ ├── examples.md │ ├── grammar-development-guide.md │ ├── why-haskell.md │ ├── why-tree-sitter.md │ └── 💡ProTip!.md ├── hie.yaml ├── notices/ │ └── THIRD_PARTY_NOTICE.md ├── proto/ │ └── semantic.proto ├── script/ │ ├── astgen │ ├── bootstrap │ ├── bootstrap-bazel │ ├── build-and-upload │ ├── clone-example-repos │ ├── fix-broken-cabal-store │ ├── generate-example │ ├── ghci-flags │ ├── profile │ ├── protoc │ ├── publish │ └── repl ├── semantic/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── app/ │ │ └── Main.hs │ ├── bench/ │ │ ├── Main.hs │ │ ├── Tagging.hs │ │ └── bench-fixtures/ │ │ ├── python/ │ │ │ ├── function-definition.py │ │ │ ├── if-statement-functions.py │ │ │ └── simple-assignment.py │ │ └── ruby/ │ │ ├── function-definition.rb │ │ ├── if-statement-functions.rb │ │ └── simple-assignment.rb │ ├── semantic.cabal │ ├── src/ │ │ ├── Control/ │ │ │ ├── Carrier/ │ │ │ │ └── Parse/ │ │ │ │ ├── Measured.hs │ │ │ │ └── Simple.hs │ │ │ └── Effect/ │ │ │ ├── Parse.hs │ │ │ ├── Sum/ │ │ │ │ └── Project.hs │ │ │ └── Timeout.hs │ │ ├── Data/ │ │ │ ├── Blob/ │ │ │ │ └── IO.hs │ │ │ ├── Blob.hs │ │ │ ├── Duration.hs │ │ │ ├── Edit.hs │ │ │ ├── Error.hs │ │ │ ├── Flag.hs │ │ │ ├── Graph/ │ │ │ │ └── Algebraic.hs │ │ │ ├── Handle.hs │ │ │ ├── Maybe/ │ │ │ │ └── Exts.hs │ │ │ └── Semigroup/ │ │ │ └── App.hs │ │ ├── Parsing/ │ │ │ ├── Parser.hs │ │ │ └── TreeSitter.hs │ │ ├── Semantic/ │ │ │ ├── Api/ │ │ │ │ ├── Bridge.hs │ │ │ │ ├── StackGraph.hs │ │ │ │ ├── Symbols.hs │ │ │ │ └── Terms.hs │ │ │ ├── Api.hs │ │ │ ├── CLI.hs │ │ │ ├── Config.hs │ │ │ ├── Env.hs │ │ │ ├── IO.hs │ │ │ ├── Task/ │ │ │ │ └── Files.hs │ │ │ ├── Task.hs │ │ │ ├── Telemetry/ │ │ │ │ ├── AsyncQueue.hs │ │ │ │ ├── Error.hs │ │ │ │ ├── Log.hs │ │ │ │ └── Stat.hs │ │ │ ├── Telemetry.hs │ │ │ ├── Util/ │ │ │ │ └── Pretty.hs │ │ │ ├── Util.hs │ │ │ └── Version.hs │ │ └── Serializing/ │ │ ├── Format.hs │ │ └── SExpression/ │ │ └── Precise.hs │ └── test/ │ ├── Data/ │ │ ├── Graph/ │ │ │ └── Spec.hs │ │ ├── Language/ │ │ │ └── Spec.hs │ │ └── Semigroup/ │ │ └── App/ │ │ └── Spec.hs │ ├── Examples.hs │ ├── Generators.hs │ ├── Integration/ │ │ └── Spec.hs │ ├── Properties.hs │ ├── Semantic/ │ │ ├── CLI/ │ │ │ └── Spec.hs │ │ ├── IO/ │ │ │ └── Spec.hs │ │ ├── Spec.hs │ │ └── Stat/ │ │ └── Spec.hs │ ├── Spec.hs │ ├── SpecHelpers.hs │ ├── Tags/ │ │ └── Spec.hs │ └── fixtures/ │ ├── base.rb │ ├── cli/ │ │ ├── blank.json │ │ ├── diff-empty-language.json │ │ ├── diff-no-after.json │ │ ├── diff-no-before.json │ │ ├── diff-no-language.json │ │ ├── diff-null-after.json │ │ ├── diff-null-before.json │ │ ├── diff-null-both-sides.json │ │ ├── diff-tree.json │ │ ├── diff-tree.toc.json │ │ ├── diff-unsupported-language.json │ │ ├── diff.json │ │ ├── parse-tree-empty.json │ │ ├── parse-tree.json │ │ ├── parse-tree.symbols.json │ │ ├── parse-trees.json │ │ └── parse.json │ ├── go/ │ │ ├── analysis/ │ │ │ ├── bar/ │ │ │ │ ├── bar.go │ │ │ │ └── rab.go │ │ │ ├── foo/ │ │ │ │ └── foo.go │ │ │ ├── main.go │ │ │ └── main1.go │ │ ├── corpus/ │ │ │ ├── array-types.A.go │ │ │ ├── array-types.B.go │ │ │ ├── array-types.diffA-B.txt │ │ │ ├── array-types.diffB-A.txt │ │ │ ├── array-types.parseA.txt │ │ │ ├── array-types.parseB.txt │ │ │ ├── array-with-implicit-length.A.go │ │ │ ├── array-with-implicit-length.B.go │ │ │ ├── array-with-implicit-length.diffA-B.txt │ │ │ ├── array-with-implicit-length.diffB-A.txt │ │ │ ├── array-with-implicit-length.parseA.txt │ │ │ ├── array-with-implicit-length.parseB.txt │ │ │ ├── assignment-statements.A.go │ │ │ ├── assignment-statements.B.go │ │ │ ├── assignment-statements.diffA-B.txt │ │ │ ├── assignment-statements.diffB-A.txt │ │ │ ├── assignment-statements.parseA.txt │ │ │ ├── assignment-statements.parseB.txt │ │ │ ├── binary-expressions.A.go │ │ │ ├── binary-expressions.B.go │ │ │ ├── binary-expressions.diffA-B.txt │ │ │ ├── binary-expressions.diffB-A.txt │ │ │ ├── binary-expressions.parseA.txt │ │ │ ├── binary-expressions.parseB.txt │ │ │ ├── call-expressions.A.go │ │ │ ├── call-expressions.B.go │ │ │ ├── call-expressions.diffA-B.txt │ │ │ ├── call-expressions.diffB-A.txt │ │ │ ├── call-expressions.parseA.txt │ │ │ ├── call-expressions.parseB.txt │ │ │ ├── case-statements.A.go │ │ │ ├── case-statements.B.go │ │ │ ├── case-statements.diffA-B.txt │ │ │ ├── case-statements.diffB-A.txt │ │ │ ├── case-statements.parseA.txt │ │ │ ├── case-statements.parseB.txt │ │ │ ├── channel-types.A.go │ │ │ ├── channel-types.B.go │ │ │ ├── channel-types.diffA-B.txt │ │ │ ├── channel-types.diffB-A.txt │ │ │ ├── channel-types.parseA.txt │ │ │ ├── channel-types.parseB.txt │ │ │ ├── comment.A.go │ │ │ ├── comment.B.go │ │ │ ├── comment.diffA-B.txt │ │ │ ├── comment.diffB-A.txt │ │ │ ├── comment.parseA.txt │ │ │ ├── comment.parseB.txt │ │ │ ├── const-declarations-with-types.A.go │ │ │ ├── const-declarations-with-types.B.go │ │ │ ├── const-declarations-with-types.diffA-B.txt │ │ │ ├── const-declarations-with-types.diffB-A.txt │ │ │ ├── const-declarations-with-types.parseA.txt │ │ │ ├── const-declarations-with-types.parseB.txt │ │ │ ├── const-declarations-without-types.A.go │ │ │ ├── const-declarations-without-types.B.go │ │ │ ├── const-declarations-without-types.diffA-B.txt │ │ │ ├── const-declarations-without-types.diffB-A.txt │ │ │ ├── const-declarations-without-types.parseA.txt │ │ │ ├── const-declarations-without-types.parseB.txt │ │ │ ├── const-with-implicit-values.A.go │ │ │ ├── const-with-implicit-values.B.go │ │ │ ├── const-with-implicit-values.diffA-B.txt │ │ │ ├── const-with-implicit-values.diffB-A.txt │ │ │ ├── const-with-implicit-values.parseA.txt │ │ │ ├── const-with-implicit-values.parseB.txt │ │ │ ├── constructors.A.go │ │ │ ├── constructors.B.go │ │ │ ├── constructors.diffA-B.txt │ │ │ ├── constructors.diffB-A.txt │ │ │ ├── constructors.parseA.txt │ │ │ ├── constructors.parseB.txt │ │ │ ├── float-literals.A.go │ │ │ ├── float-literals.B.go │ │ │ ├── float-literals.diffA-B.txt │ │ │ ├── float-literals.diffB-A.txt │ │ │ ├── float-literals.parseA.txt │ │ │ ├── float-literals.parseB.txt │ │ │ ├── for-statements.A.go │ │ │ ├── for-statements.B.go │ │ │ ├── for-statements.diffA-B.txt │ │ │ ├── for-statements.diffB-A.txt │ │ │ ├── for-statements.parseA.txt │ │ │ ├── for-statements.parseB.txt │ │ │ ├── function-declarations.A.go │ │ │ ├── function-declarations.B.go │ │ │ ├── function-declarations.diffA-B.txt │ │ │ ├── function-declarations.diffB-A.txt │ │ │ ├── function-declarations.parseA.txt │ │ │ ├── function-declarations.parseB.txt │ │ │ ├── function-literals.A.go │ │ │ ├── function-literals.B.go │ │ │ ├── function-literals.diffA-B.txt │ │ │ ├── function-literals.diffB-A.txt │ │ │ ├── function-literals.parseA.txt │ │ │ ├── function-literals.parseB.txt │ │ │ ├── function-types.A.go │ │ │ ├── function-types.B.go │ │ │ ├── function-types.diffA-B.txt │ │ │ ├── function-types.diffB-A.txt │ │ │ ├── function-types.parseA.txt │ │ │ ├── function-types.parseB.txt │ │ │ ├── go-and-defer-statements.A.go │ │ │ ├── go-and-defer-statements.B.go │ │ │ ├── go-and-defer-statements.diffA-B.txt │ │ │ ├── go-and-defer-statements.diffB-A.txt │ │ │ ├── go-and-defer-statements.parseA.txt │ │ │ ├── go-and-defer-statements.parseB.txt │ │ │ ├── grouped-import-declarations.A.go │ │ │ ├── grouped-import-declarations.B.go │ │ │ ├── grouped-import-declarations.diffA-B.txt │ │ │ ├── grouped-import-declarations.diffB-A.txt │ │ │ ├── grouped-import-declarations.parseA.txt │ │ │ ├── grouped-import-declarations.parseB.txt │ │ │ ├── grouped-var-declarations.A.go │ │ │ ├── grouped-var-declarations.B.go │ │ │ ├── grouped-var-declarations.diffA-B.txt │ │ │ ├── grouped-var-declarations.diffB-A.txt │ │ │ ├── grouped-var-declarations.parseA.txt │ │ │ ├── grouped-var-declarations.parseB.txt │ │ │ ├── if-statements.A.go │ │ │ ├── if-statements.B.go │ │ │ ├── if-statements.diffA-B.txt │ │ │ ├── if-statements.diffB-A.txt │ │ │ ├── if-statements.parseA.txt │ │ │ ├── if-statements.parseB.txt │ │ │ ├── imaginary-literals.A.go │ │ │ ├── imaginary-literals.B.go │ │ │ ├── imaginary-literals.diffA-B.txt │ │ │ ├── imaginary-literals.diffB-A.txt │ │ │ ├── imaginary-literals.parseA.txt │ │ │ ├── imaginary-literals.parseB.txt │ │ │ ├── import-statements.A.go │ │ │ ├── import-statements.B.go │ │ │ ├── import-statements.diffA-B.txt │ │ │ ├── import-statements.diffB-A.txt │ │ │ ├── import-statements.parseA.txt │ │ │ ├── import-statements.parseB.txt │ │ │ ├── increment-decrement-statements.A.go │ │ │ ├── increment-decrement-statements.B.go │ │ │ ├── increment-decrement-statements.diffA-B.txt │ │ │ ├── increment-decrement-statements.diffB-A.txt │ │ │ ├── increment-decrement-statements.parseA.txt │ │ │ ├── increment-decrement-statements.parseB.txt │ │ │ ├── int-literals.A.go │ │ │ ├── int-literals.B.go │ │ │ ├── int-literals.diffA-B.txt │ │ │ ├── int-literals.diffB-A.txt │ │ │ ├── int-literals.parseA.txt │ │ │ ├── int-literals.parseB.txt │ │ │ ├── interface-types.A.go │ │ │ ├── interface-types.B.go │ │ │ ├── interface-types.diffA-B.txt │ │ │ ├── interface-types.diffB-A.txt │ │ │ ├── interface-types.parseA.txt │ │ │ ├── interface-types.parseB.txt │ │ │ ├── label-statements.A.go │ │ │ ├── label-statements.B.go │ │ │ ├── label-statements.diffA-B.txt │ │ │ ├── label-statements.diffB-A.txt │ │ │ ├── label-statements.parseA.txt │ │ │ ├── label-statements.parseB.txt │ │ │ ├── map-literals.A.go │ │ │ ├── map-literals.B.go │ │ │ ├── map-literals.diffA-B.txt │ │ │ ├── map-literals.diffB-A.txt │ │ │ ├── map-literals.parseA.txt │ │ │ ├── map-literals.parseB.txt │ │ │ ├── map-types.A.go │ │ │ ├── map-types.B.go │ │ │ ├── map-types.diffA-B.txt │ │ │ ├── map-types.diffB-A.txt │ │ │ ├── map-types.parseA.txt │ │ │ ├── map-types.parseB.txt │ │ │ ├── method-declarations.A.go │ │ │ ├── method-declarations.B.go │ │ │ ├── method-declarations.diffA-B.txt │ │ │ ├── method-declarations.diffB-A.txt │ │ │ ├── method-declarations.parseA.txt │ │ │ ├── method-declarations.parseB.txt │ │ │ ├── modifying-struct-fields.A.go │ │ │ ├── modifying-struct-fields.B.go │ │ │ ├── modifying-struct-fields.diffA-B.txt │ │ │ ├── modifying-struct-fields.diffB-A.txt │ │ │ ├── modifying-struct-fields.parseA.txt │ │ │ ├── modifying-struct-fields.parseB.txt │ │ │ ├── parameter-declarations-with-types.A.go │ │ │ ├── parameter-declarations-with-types.B.go │ │ │ ├── parameter-declarations-with-types.diffA-B.txt │ │ │ ├── parameter-declarations-with-types.diffB-A.txt │ │ │ ├── parameter-declarations-with-types.parseA.txt │ │ │ ├── parameter-declarations-with-types.parseB.txt │ │ │ ├── pointer-types.A.go │ │ │ ├── pointer-types.B.go │ │ │ ├── pointer-types.diffA-B.txt │ │ │ ├── pointer-types.diffB-A.txt │ │ │ ├── pointer-types.parseA.txt │ │ │ ├── pointer-types.parseB.txt │ │ │ ├── qualified-types.A.go │ │ │ ├── qualified-types.B.go │ │ │ ├── qualified-types.diffA-B.txt │ │ │ ├── qualified-types.diffB-A.txt │ │ │ ├── qualified-types.parseA.txt │ │ │ ├── qualified-types.parseB.txt │ │ │ ├── rune-literals.A.go │ │ │ ├── rune-literals.B.go │ │ │ ├── rune-literals.diffA-B.txt │ │ │ ├── rune-literals.diffB-A.txt │ │ │ ├── rune-literals.parseA.txt │ │ │ ├── rune-literals.parseB.txt │ │ │ ├── select-statements.A.go │ │ │ ├── select-statements.B.go │ │ │ ├── select-statements.diffA-B.txt │ │ │ ├── select-statements.diffB-A.txt │ │ │ ├── select-statements.parseA.txt │ │ │ ├── select-statements.parseB.txt │ │ │ ├── selector-expressions.A.go │ │ │ ├── selector-expressions.B.go │ │ │ ├── selector-expressions.diffA-B.txt │ │ │ ├── selector-expressions.diffB-A.txt │ │ │ ├── selector-expressions.parseA.txt │ │ │ ├── selector-expressions.parseB.txt │ │ │ ├── send-statements.A.go │ │ │ ├── send-statements.B.go │ │ │ ├── send-statements.diffA-B.txt │ │ │ ├── send-statements.diffB-A.txt │ │ │ ├── send-statements.parseA.txt │ │ │ ├── send-statements.parseB.txt │ │ │ ├── short-var-declarations.A.go │ │ │ ├── short-var-declarations.B.go │ │ │ ├── short-var-declarations.diffA-B.txt │ │ │ ├── short-var-declarations.diffB-A.txt │ │ │ ├── short-var-declarations.parseA.txt │ │ │ ├── short-var-declarations.parseB.txt │ │ │ ├── single-import-declarations.A.go │ │ │ ├── single-import-declarations.B.go │ │ │ ├── single-import-declarations.diffA-B.txt │ │ │ ├── single-import-declarations.diffB-A.txt │ │ │ ├── single-import-declarations.parseA.txt │ │ │ ├── single-import-declarations.parseB.txt │ │ │ ├── single-import-declarationsA.parseA.txt │ │ │ ├── single-line-function-declarations.A.go │ │ │ ├── single-line-function-declarations.B.go │ │ │ ├── single-line-function-declarations.diffA-B.txt │ │ │ ├── single-line-function-declarations.diffB-A.txt │ │ │ ├── single-line-function-declarations.parseA.txt │ │ │ ├── single-line-function-declarations.parseB.txt │ │ │ ├── slice-expressions.A.go │ │ │ ├── slice-expressions.B.go │ │ │ ├── slice-expressions.diffA-B.txt │ │ │ ├── slice-expressions.diffB-A.txt │ │ │ ├── slice-expressions.parseA.txt │ │ │ ├── slice-expressions.parseB.txt │ │ │ ├── slice-literals.A.go │ │ │ ├── slice-literals.B.go │ │ │ ├── slice-literals.diffA-B.txt │ │ │ ├── slice-literals.diffB-A.txt │ │ │ ├── slice-literals.parseA.txt │ │ │ ├── slice-literals.parseB.txt │ │ │ ├── slice-types.A.go │ │ │ ├── slice-types.B.go │ │ │ ├── slice-types.diffA-B.txt │ │ │ ├── slice-types.diffB-A.txt │ │ │ ├── slice-types.parseA.txt │ │ │ ├── slice-types.parseB.txt │ │ │ ├── string-literals.A.go │ │ │ ├── string-literals.B.go │ │ │ ├── string-literals.diffA-B.txt │ │ │ ├── string-literals.diffB-A.txt │ │ │ ├── string-literals.parseA.txt │ │ │ ├── string-literals.parseB.txt │ │ │ ├── struct-field-declarations.A.go │ │ │ ├── struct-field-declarations.B.go │ │ │ ├── struct-field-declarations.diffA-B.txt │ │ │ ├── struct-field-declarations.diffB-A.txt │ │ │ ├── struct-field-declarations.parseA.txt │ │ │ ├── struct-field-declarations.parseB.txt │ │ │ ├── struct-literals.A.go │ │ │ ├── struct-literals.B.go │ │ │ ├── struct-literals.diffA-B.txt │ │ │ ├── struct-literals.diffB-A.txt │ │ │ ├── struct-literals.parseA.txt │ │ │ ├── struct-literals.parseB.txt │ │ │ ├── struct-types.A.go │ │ │ ├── struct-types.B.go │ │ │ ├── struct-types.diffA-B.txt │ │ │ ├── struct-types.diffB-A.txt │ │ │ ├── struct-types.parseA.txt │ │ │ ├── struct-types.parseB.txt │ │ │ ├── switch-statement.parseA.txt │ │ │ ├── switch-statements.A.go │ │ │ ├── switch-statements.B.go │ │ │ ├── switch-statements.diffA-B.txt │ │ │ ├── switch-statements.diffB-A.txt │ │ │ ├── switch-statements.parseA.txt │ │ │ ├── switch-statements.parseB.txt │ │ │ ├── type-aliases.A.go │ │ │ ├── type-aliases.B.go │ │ │ ├── type-aliases.diffA-B.txt │ │ │ ├── type-aliases.diffB-A.txt │ │ │ ├── type-aliases.parseA.txt │ │ │ ├── type-aliases.parseB.txt │ │ │ ├── type-assertion-expressions.A.go │ │ │ ├── type-assertion-expressions.B.go │ │ │ ├── type-assertion-expressions.diffA-B.txt │ │ │ ├── type-assertion-expressions.diffB-A.txt │ │ │ ├── type-assertion-expressions.parseA.txt │ │ │ ├── type-assertion-expressions.parseB.txt │ │ │ ├── type-conversion-expressions.A.go │ │ │ ├── type-conversion-expressions.B.go │ │ │ ├── type-conversion-expressions.diffA-B.txt │ │ │ ├── type-conversion-expressions.diffB-A.txt │ │ │ ├── type-conversion-expressions.parseA.txt │ │ │ ├── type-conversion-expressions.parseB.txt │ │ │ ├── type-declarations.A.go │ │ │ ├── type-declarations.B.go │ │ │ ├── type-declarations.diffA-B.txt │ │ │ ├── type-declarations.diffB-A.txt │ │ │ ├── type-declarations.parseA.txt │ │ │ ├── type-declarations.parseB.txt │ │ │ ├── type-switch-statements.A.go │ │ │ ├── type-switch-statements.B.go │ │ │ ├── type-switch-statements.diffA-B.txt │ │ │ ├── type-switch-statements.diffB-A.txt │ │ │ ├── type-switch-statements.parseA.txt │ │ │ ├── type-switch-statements.parseB.txt │ │ │ ├── unary-expressions.A.go │ │ │ ├── unary-expressions.B.go │ │ │ ├── unary-expressions.diffA-B.txt │ │ │ ├── unary-expressions.diffB-A.txt │ │ │ ├── unary-expressions.parseA.txt │ │ │ ├── unary-expressions.parseB.txt │ │ │ ├── var-declarations-with-no-expressions.A.go │ │ │ ├── var-declarations-with-no-expressions.B.go │ │ │ ├── var-declarations-with-no-expressions.diffA-B.txt │ │ │ ├── var-declarations-with-no-expressions.diffB-A.txt │ │ │ ├── var-declarations-with-no-expressions.parseA.txt │ │ │ ├── var-declarations-with-no-expressions.parseB.txt │ │ │ ├── var-declarations-with-types.A.go │ │ │ ├── var-declarations-with-types.B.go │ │ │ ├── var-declarations-with-types.diffA-B.txt │ │ │ ├── var-declarations-with-types.diffB-A.txt │ │ │ ├── var-declarations-with-types.parseA.txt │ │ │ ├── var-declarations-with-types.parseB.txt │ │ │ ├── var-declarations-without-types.A.go │ │ │ ├── var-declarations-without-types.B.go │ │ │ ├── var-declarations-without-types.diffA-B.txt │ │ │ ├── var-declarations-without-types.diffB-A.txt │ │ │ ├── var-declarations-without-types.parseA.txt │ │ │ ├── var-declarations-without-types.parseB.txt │ │ │ ├── variadic-function-declarations.A.go │ │ │ ├── variadic-function-declarations.B.go │ │ │ ├── variadic-function-declarations.diffA-B.txt │ │ │ ├── variadic-function-declarations.diffB-A.txt │ │ │ ├── variadic-function-declarations.parseA.txt │ │ │ └── variadic-function-declarations.parseB.txt │ │ ├── import-graph/ │ │ │ ├── main.go │ │ │ └── main.json │ │ ├── matching/ │ │ │ ├── for.go │ │ │ └── integers.go │ │ ├── tags/ │ │ │ ├── method.go │ │ │ └── simple_functions.go │ │ └── toc/ │ │ ├── method-with-receiver.A.go │ │ └── method-with-receiver.B.go │ ├── haskell/ │ │ └── corpus/ │ │ ├── algebraic-datatype-declarations.A.hs │ │ ├── algebraic-datatype-declarations.B.hs │ │ ├── algebraic-datatype-declarations.diffA-B.txt │ │ ├── algebraic-datatype-declarations.diffB-A.txt │ │ ├── algebraic-datatype-declarations.parseA.txt │ │ ├── algebraic-datatype-declarations.parseB.txt │ │ ├── blank.A.hs │ │ ├── blank.parseA.txt │ │ ├── cpp-directives.A.hs │ │ ├── cpp-directives.B.hs │ │ ├── cpp-directives.diffA-B.txt │ │ ├── cpp-directives.diffB-A.txt │ │ ├── cpp-directives.parseA.txt │ │ ├── cpp-directives.parseB.txt │ │ ├── default-declaration.A.hs │ │ ├── default-declaration.B.hs │ │ ├── default-declaration.diffA-B.txt │ │ ├── default-declaration.diffB-A.txt │ │ ├── default-declaration.parseA.txt │ │ ├── default-declaration.parseB.txt │ │ ├── expressions.A.hs │ │ ├── expressions.B.hs │ │ ├── expressions.diffA-B.txt │ │ ├── expressions.diffB-A.txt │ │ ├── expressions.parseA.txt │ │ ├── expressions.parseB.txt │ │ ├── function-declarations.A.hs │ │ ├── function-declarations.B.hs │ │ ├── function-declarations.diffA-B.txt │ │ ├── function-declarations.diffB-A.txt │ │ ├── function-declarations.parseA.txt │ │ ├── function-declarations.parseB.txt │ │ ├── gadt-declarations.A.hs │ │ ├── gadt-declarations.B.hs │ │ ├── gadt-declarations.diffA-B.txt │ │ ├── gadt-declarations.diffB-A.txt │ │ ├── gadt-declarations.parseA.txt │ │ ├── gadt-declarations.parseB.txt │ │ ├── import-declaration.A.hs │ │ ├── import-declaration.B.hs │ │ ├── import-declaration.diffA-B.txt │ │ ├── import-declaration.diffB-A.txt │ │ ├── import-declaration.parseA.txt │ │ ├── import-declaration.parseB.txt │ │ ├── layout.A.hs │ │ ├── layout.B.hs │ │ ├── layout.diffA-B.txt │ │ ├── layout.diffB-A.txt │ │ ├── layout.parseA.txt │ │ ├── layout.parseB.txt │ │ ├── literals.A.hs │ │ ├── literals.B.hs │ │ ├── literals.diffA-B.txt │ │ ├── literals.diffB-A.txt │ │ ├── literals.parseA.txt │ │ ├── literals.parseB.txt │ │ ├── module-declaration1.A.hs │ │ ├── module-declaration1.B.hs │ │ ├── module-declaration1.diffA-B.txt │ │ ├── module-declaration1.diffB-A.txt │ │ ├── module-declaration1.parseA.txt │ │ ├── module-declaration1.parseB.txt │ │ ├── module-declaration2.A.hs │ │ ├── module-declaration2.B.hs │ │ ├── module-declaration2.diffA-B.txt │ │ ├── module-declaration2.diffB-A.txt │ │ ├── module-declaration2.parseA.txt │ │ ├── module-declaration2.parseB.txt │ │ ├── module-declaration3.A.hs │ │ ├── module-declaration3.B.hs │ │ ├── module-declaration3.diffA-B.txt │ │ ├── module-declaration3.diffB-A.txt │ │ ├── module-declaration3.parseA.txt │ │ ├── module-declaration3.parseB.txt │ │ ├── module-declaration4.A.hs │ │ ├── module-declaration4.B.hs │ │ ├── module-declaration4.diffA-B.txt │ │ ├── module-declaration4.diffB-A.txt │ │ ├── module-declaration4.parseA.txt │ │ ├── module-declaration4.parseB.txt │ │ ├── module-declaration5.A.hs │ │ ├── module-declaration5.B.hs │ │ ├── module-declaration5.diffA-B.txt │ │ ├── module-declaration5.diffB-A.txt │ │ ├── module-declaration5.parseA.txt │ │ ├── module-declaration5.parseB.txt │ │ ├── newtype-declaration.A.hs │ │ ├── newtype-declaration.B.hs │ │ ├── newtype-declaration.diffA-B.txt │ │ ├── newtype-declaration.diffB-A.txt │ │ ├── newtype-declaration.parseA.txt │ │ ├── newtype-declaration.parseB.txt │ │ ├── standalone-deriving-declaration.A.hs │ │ ├── standalone-deriving-declaration.B.hs │ │ ├── standalone-deriving-declaration.diffA-B.txt │ │ ├── standalone-deriving-declaration.diffB-A.txt │ │ ├── standalone-deriving-declaration.parseA.txt │ │ ├── standalone-deriving-declaration.parseB.txt │ │ ├── statements.A.hs │ │ ├── statements.B.hs │ │ ├── statements.diffA-B.txt │ │ ├── statements.diffB-A.txt │ │ ├── statements.parseA.txt │ │ ├── statements.parseB.txt │ │ ├── tempate-haskell.A.hs │ │ ├── tempate-haskell.parseA.txt │ │ ├── template-haskell.B.hs │ │ ├── type-class-declarations.A.hs │ │ ├── type-class-declarations.B.hs │ │ ├── type-class-declarations.diffA-B.txt │ │ ├── type-class-declarations.diffB-A.txt │ │ ├── type-class-declarations.parseA.txt │ │ ├── type-class-declarations.parseB.txt │ │ ├── type-class-instance-declarations.A.hs │ │ ├── type-class-instance-declarations.B.hs │ │ ├── type-class-instance-declarations.diffA-B.txt │ │ ├── type-class-instance-declarations.diffB-A.txt │ │ ├── type-class-instance-declarations.parseA.txt │ │ ├── type-class-instance-declarations.parseB.txt │ │ ├── type-family-declarations.A.hs │ │ ├── type-family-declarations.B.hs │ │ ├── type-family-declarations.diffA-B.txt │ │ ├── type-family-declarations.diffB-A.txt │ │ ├── type-family-declarations.parseA.txt │ │ ├── type-family-declarations.parseB.txt │ │ ├── type-signatures.A.hs │ │ ├── type-signatures.B.hs │ │ ├── type-signatures.diffA-B.txt │ │ ├── type-signatures.diffB-A.txt │ │ ├── type-signatures.parseA.txt │ │ ├── type-signatures.parseB.txt │ │ ├── type-synonyms.A.hs │ │ ├── type-synonyms.B.hs │ │ ├── type-synonyms.diffA-B.txt │ │ ├── type-synonyms.diffB-A.txt │ │ ├── type-synonyms.parseA.txt │ │ └── type-synonyms.parseB.txt │ ├── java/ │ │ └── corpus/ │ │ ├── ArrayAccess.A.java │ │ ├── ArrayAccess.B.java │ │ ├── ArrayAccess.diffA-B.txt │ │ ├── ArrayAccess.diffB-A.txt │ │ ├── ArrayAccess.parseA.txt │ │ ├── ArrayAccess.parseB.txt │ │ ├── AssertStatement.A.java │ │ ├── AssertStatement.B.java │ │ ├── AssertStatement.diffA-B.txt │ │ ├── AssertStatement.diffB-A.txt │ │ ├── AssertStatement.parseA.txt │ │ ├── AssertStatement.parseB.txt │ │ ├── Binary.A.java │ │ ├── Binary.B.java │ │ ├── Binary.diffA-B.txt │ │ ├── Binary.diffB-A.txt │ │ ├── Binary.parseA.txt │ │ ├── Binary.parseB.txt │ │ ├── Boolean.A.java │ │ ├── Boolean.B.java │ │ ├── Boolean.diffA-B.txt │ │ ├── Boolean.diffB-A.txt │ │ ├── Boolean.parseA.txt │ │ ├── Boolean.parseB.txt │ │ ├── Char.A.java │ │ ├── Char.B.java │ │ ├── Char.diffA-B.txt │ │ ├── Char.diffB-A.txt │ │ ├── Char.parseA.txt │ │ ├── Char.parseB.txt │ │ ├── ClassBody.A.java │ │ ├── ClassBody.B.java │ │ ├── ClassBody.diffA-B.txt │ │ ├── ClassBody.diffB-A.txt │ │ ├── ClassBody.parseA.txt │ │ ├── ClassBody.parseB.txt │ │ ├── ClassLiteral.A.java │ │ ├── ClassLiteral.B.java │ │ ├── ClassLiteral.diffA-B.txt │ │ ├── ClassLiteral.diffB-A.txt │ │ ├── ClassLiteral.parseA.txt │ │ ├── ClassLiteral.parseB.txt │ │ ├── Comment.A.java │ │ ├── Comment.B.java │ │ ├── Comment.diffA-B.txt │ │ ├── Comment.diffB-A.txt │ │ ├── Comment.parseA.txt │ │ ├── Comment.parseB.txt │ │ ├── Continue.A.java │ │ ├── Continue.B.java │ │ ├── Continue.diffA-B.txt │ │ ├── Continue.diffB-A.txt │ │ ├── Continue.parseA.txt │ │ ├── Continue.parseB.txt │ │ ├── Continue0.A.java │ │ ├── Continue1.A.java │ │ ├── Dims.A.java │ │ ├── Dims.B.java │ │ ├── Dims.diffA-B.txt │ │ ├── Dims.diffB-A.txt │ │ ├── Dims.parseA.txt │ │ ├── Dims.parseB.txt │ │ ├── DoWhile.A.java │ │ ├── DoWhile.B.java │ │ ├── DoWhile.diffA-B.txt │ │ ├── DoWhile.diffB-A.txt │ │ ├── DoWhile.parseA.txt │ │ ├── DoWhile.parseB.txt │ │ ├── EnumDeclaration.A.java │ │ ├── EnumDeclaration.B.java │ │ ├── EnumDeclaration.diffA-B.txt │ │ ├── EnumDeclaration.diffB-A.txt │ │ ├── EnumDeclaration.parseA.txt │ │ ├── EnumDeclaration.parseB.txt │ │ ├── FieldAccess.A.java │ │ ├── FieldAccess.B.java │ │ ├── FieldAccess.diffA-B.txt │ │ ├── FieldAccess.diffB-A.txt │ │ ├── FieldAccess.parseA.txt │ │ ├── FieldAccess.parseB.txt │ │ ├── Float.A.java │ │ ├── Float.B.java │ │ ├── Float.diffA-B.txt │ │ ├── Float.diffB-A.txt │ │ ├── Float.parseA.txt │ │ ├── Float.parseB.txt │ │ ├── For.A.java │ │ ├── For.B.java │ │ ├── For.diffA-B.txt │ │ ├── For.diffB-A.txt │ │ ├── For.parseA.txt │ │ ├── For.parseB.txt │ │ ├── If.A.java │ │ ├── If.B.java │ │ ├── If.diffA-B.txt │ │ ├── If.diffB-A.txt │ │ ├── If.parseA.txt │ │ ├── If.parseB.txt │ │ ├── Import.A.java │ │ ├── Import.B.java │ │ ├── Import.diffA-B.txt │ │ ├── Import.diffB-A.txt │ │ ├── Import.parseA.txt │ │ ├── Import.parseB.txt │ │ ├── Int.A.java │ │ ├── Int.B.java │ │ ├── Int.diffA-B.txt │ │ ├── Int.diffB-A.txt │ │ ├── Int.parseA.txt │ │ ├── Int.parseB.txt │ │ ├── Interface.A.java │ │ ├── Interface.B.java │ │ ├── Interface.diffA-B.txt │ │ ├── Interface.diffB-A.txt │ │ ├── Interface.parseA.txt │ │ ├── Interface.parseB.txt │ │ ├── Lambda.A.java │ │ ├── Lambda.B.java │ │ ├── Lambda.diffA-B.txt │ │ ├── Lambda.diffB-A.txt │ │ ├── Lambda.parseA.txt │ │ ├── Lambda.parseB.txt │ │ ├── ScopedIdentifier.A.java │ │ ├── ScopedIdentifier.B.java │ │ ├── ScopedIdentifier.diffA-B.txt │ │ ├── ScopedIdentifier.diffB-A.txt │ │ ├── ScopedIdentifier.parseA.txt │ │ ├── ScopedIdentifier.parseB.txt │ │ ├── SpreadParameter.A.java │ │ ├── SpreadParameter.B.java │ │ ├── SpreadParameter.diffA-B.txt │ │ ├── SpreadParameter.diffB-A.txt │ │ ├── SpreadParameter.parseA.txt │ │ ├── SpreadParameter.parseB.txt │ │ ├── String.A.java │ │ ├── String.B.java │ │ ├── String.diffA-B.txt │ │ ├── String.diffB-A.txt │ │ ├── String.parseA.txt │ │ ├── String.parseB.txt │ │ ├── Switch.A.java │ │ ├── Switch.B.java │ │ ├── Switch.diffA-B.txt │ │ ├── Switch.diffB-A.txt │ │ ├── Switch.parseA.txt │ │ ├── Switch.parseB.txt │ │ ├── Throws.A.java │ │ ├── Throws.B.java │ │ ├── TryCatches.A.java │ │ ├── TryCatches.B.java │ │ ├── TryWithResourcesStatement.A.java │ │ ├── TryWithResourcesStatement.B.java │ │ ├── TryWithResourcesStatement.diffA-B.txt │ │ ├── TryWithResourcesStatement.diffB-A.txt │ │ ├── TryWithResourcesStatement.parseA.txt │ │ ├── TryWithResourcesStatement.parseB.txt │ │ ├── TypeArgument.A.java │ │ ├── TypeArgument.B.java │ │ ├── TypeArgument.diffA-B.txt │ │ ├── TypeArgument.diffB-A.txt │ │ ├── TypeArgument.parseA.txt │ │ ├── TypeArgument.parseB.txt │ │ ├── Update.A.java │ │ ├── Update.B.java │ │ ├── Update.diffA-B.txt │ │ ├── Update.diffB-A.txt │ │ ├── Update.parseA.txt │ │ ├── Update.parseB.txt │ │ ├── VariableDeclaration.A.java │ │ ├── VariableDeclaration.B.java │ │ ├── VariableDeclaration.diffA-B.txt │ │ ├── VariableDeclaration.diffB-A.txt │ │ ├── VariableDeclaration.parseA.txt │ │ ├── VariableDeclaration.parseB.txt │ │ ├── While.A.java │ │ ├── While.B.java │ │ ├── While.diffA-B.txt │ │ ├── While.diffB-A.txt │ │ ├── While.parseA.txt │ │ ├── While.parseB.txt │ │ ├── Wildcard.A.java │ │ ├── Wildcard.B.java │ │ ├── Wildcard.diffA-B.txt │ │ ├── Wildcard.diffB-A.txt │ │ ├── Wildcard.parseA.txt │ │ ├── Wildcard.parseB.txt │ │ ├── array-access.java │ │ ├── assertStatement.java │ │ ├── assertStringLiteral.java │ │ ├── enum.java │ │ ├── methodReference.java │ │ ├── modifier-abstract.java │ │ ├── modifier-private.java │ │ ├── modifier-protected.java │ │ ├── modifier-public.java │ │ ├── modifier-static.java │ │ ├── null.java │ │ ├── package.java │ │ ├── return.java │ │ ├── try.java │ │ └── try_with_resources.java │ ├── javascript/ │ │ ├── analysis/ │ │ │ ├── exports/ │ │ │ │ ├── lib.js │ │ │ │ └── main.js │ │ │ ├── foo.js │ │ │ ├── main.js │ │ │ └── main2.js │ │ ├── corpus/ │ │ │ ├── anonymous-function.A.js │ │ │ ├── anonymous-function.B.js │ │ │ ├── anonymous-function.diffA-B.txt │ │ │ ├── anonymous-function.diffB-A.txt │ │ │ ├── anonymous-function.parseA.txt │ │ │ ├── anonymous-function.parseB.txt │ │ │ ├── anonymous-parameterless-function.A.js │ │ │ ├── anonymous-parameterless-function.B.js │ │ │ ├── anonymous-parameterless-function.diffA-B.txt │ │ │ ├── anonymous-parameterless-function.diffB-A.txt │ │ │ ├── anonymous-parameterless-function.parseA.txt │ │ │ ├── anonymous-parameterless-function.parseB.txt │ │ │ ├── array.A.js │ │ │ ├── array.B.js │ │ │ ├── array.diffA-B.txt │ │ │ ├── array.diffB-A.txt │ │ │ ├── array.parseA.txt │ │ │ ├── array.parseB.txt │ │ │ ├── arrow-function.A.js │ │ │ ├── arrow-function.B.js │ │ │ ├── arrow-function.diffA-B.txt │ │ │ ├── arrow-function.diffB-A.txt │ │ │ ├── arrow-function.parseA.txt │ │ │ ├── arrow-function.parseB.txt │ │ │ ├── assignment-pattern.A.js │ │ │ ├── assignment-pattern.B.js │ │ │ ├── assignment-pattern.diffA-B.txt │ │ │ ├── assignment-pattern.diffB-A.txt │ │ │ ├── assignment-pattern.parseA.txt │ │ │ ├── assignment-pattern.parseB.txt │ │ │ ├── assignment.A.js │ │ │ ├── assignment.B.js │ │ │ ├── assignment.diffA-B.txt │ │ │ ├── assignment.diffB-A.txt │ │ │ ├── assignment.parseA.txt │ │ │ ├── assignment.parseB.txt │ │ │ ├── bitwise-operator.A.js │ │ │ ├── bitwise-operator.B.js │ │ │ ├── bitwise-operator.diffA-B.txt │ │ │ ├── bitwise-operator.diffB-A.txt │ │ │ ├── bitwise-operator.parseA.txt │ │ │ ├── bitwise-operator.parseB.txt │ │ │ ├── boolean-operator.A.js │ │ │ ├── boolean-operator.B.js │ │ │ ├── boolean-operator.diffA-B.txt │ │ │ ├── boolean-operator.diffB-A.txt │ │ │ ├── boolean-operator.parseA.txt │ │ │ ├── boolean-operator.parseB.txt │ │ │ ├── break.A.js │ │ │ ├── break.B.js │ │ │ ├── break.diffA-B.txt │ │ │ ├── break.diffB-A.txt │ │ │ ├── break.parseA.txt │ │ │ ├── break.parseB.txt │ │ │ ├── chained-callbacks.A.js │ │ │ ├── chained-callbacks.B.js │ │ │ ├── chained-callbacks.diffA-B.txt │ │ │ ├── chained-callbacks.diffB-A.txt │ │ │ ├── chained-callbacks.parseA.txt │ │ │ ├── chained-callbacks.parseB.txt │ │ │ ├── chained-property-access.A.js │ │ │ ├── chained-property-access.B.js │ │ │ ├── chained-property-access.diffA-B.txt │ │ │ ├── chained-property-access.diffB-A.txt │ │ │ ├── chained-property-access.parseA.txt │ │ │ ├── chained-property-access.parseB.txt │ │ │ ├── class.A.js │ │ │ ├── class.B.js │ │ │ ├── class.diffA-B.txt │ │ │ ├── class.diffB-A.txt │ │ │ ├── class.parseA.txt │ │ │ ├── class.parseB.txt │ │ │ ├── comma-operator.A.js │ │ │ ├── comma-operator.B.js │ │ │ ├── comma-operator.diffA-B.txt │ │ │ ├── comma-operator.diffB-A.txt │ │ │ ├── comma-operator.parseA.txt │ │ │ ├── comma-operator.parseB.txt │ │ │ ├── comment.A.js │ │ │ ├── comment.B.js │ │ │ ├── comment.diffA-B.txt │ │ │ ├── comment.diffB-A.txt │ │ │ ├── comment.parseA.txt │ │ │ ├── comment.parseB.txt │ │ │ ├── constructor-call.A.js │ │ │ ├── constructor-call.B.js │ │ │ ├── constructor-call.diffA-B.txt │ │ │ ├── constructor-call.diffB-A.txt │ │ │ ├── constructor-call.parseA.txt │ │ │ ├── constructor-call.parseB.txt │ │ │ ├── continue.A.js │ │ │ ├── continue.B.js │ │ │ ├── continue.diffA-B.txt │ │ │ ├── continue.diffB-A.txt │ │ │ ├── continue.parseA.txt │ │ │ ├── continue.parseB.txt │ │ │ ├── delete-operator.A.js │ │ │ ├── delete-operator.B.js │ │ │ ├── delete-operator.diffA-B.txt │ │ │ ├── delete-operator.diffB-A.txt │ │ │ ├── delete-operator.parseA.txt │ │ │ ├── delete-operator.parseB.txt │ │ │ ├── do-while-statement.A.js │ │ │ ├── do-while-statement.B.js │ │ │ ├── do-while-statement.diffA-B.txt │ │ │ ├── do-while-statement.diffB-A.txt │ │ │ ├── do-while-statement.parseA.txt │ │ │ ├── do-while-statement.parseB.txt │ │ │ ├── export.A.js │ │ │ ├── export.B.js │ │ │ ├── export.diffA-B.txt │ │ │ ├── export.diffB-A.txt │ │ │ ├── export.parseA.txt │ │ │ ├── export.parseB.txt │ │ │ ├── false.A.js │ │ │ ├── false.B.js │ │ │ ├── false.diffA-B.txt │ │ │ ├── false.diffB-A.txt │ │ │ ├── false.parseA.txt │ │ │ ├── false.parseB.txt │ │ │ ├── for-in-statement.A.js │ │ │ ├── for-in-statement.B.js │ │ │ ├── for-in-statement.diffA-B.txt │ │ │ ├── for-in-statement.diffB-A.txt │ │ │ ├── for-in-statement.parseA.txt │ │ │ ├── for-in-statement.parseB.txt │ │ │ ├── for-loop-with-in-statement.A.js │ │ │ ├── for-loop-with-in-statement.B.js │ │ │ ├── for-loop-with-in-statement.diffA-B.txt │ │ │ ├── for-loop-with-in-statement.diffB-A.txt │ │ │ ├── for-loop-with-in-statement.parseA.txt │ │ │ ├── for-loop-with-in-statement.parseB.txt │ │ │ ├── for-of-statement.A.js │ │ │ ├── for-of-statement.B.js │ │ │ ├── for-of-statement.diffA-B.txt │ │ │ ├── for-of-statement.diffB-A.txt │ │ │ ├── for-of-statement.parseA.txt │ │ │ ├── for-of-statement.parseB.txt │ │ │ ├── for-statement.A.js │ │ │ ├── for-statement.B.js │ │ │ ├── for-statement.diffA-B.txt │ │ │ ├── for-statement.diffB-A.txt │ │ │ ├── for-statement.parseA.txt │ │ │ ├── for-statement.parseB.txt │ │ │ ├── function-call-args.A.js │ │ │ ├── function-call-args.B.js │ │ │ ├── function-call-args.diffA-B.txt │ │ │ ├── function-call-args.diffB-A.txt │ │ │ ├── function-call-args.parseA.txt │ │ │ ├── function-call-args.parseB.txt │ │ │ ├── function-call.A.js │ │ │ ├── function-call.B.js │ │ │ ├── function-call.diffA-B.txt │ │ │ ├── function-call.diffB-A.txt │ │ │ ├── function-call.parseA.txt │ │ │ ├── function-call.parseB.txt │ │ │ ├── function.A.js │ │ │ ├── function.B.js │ │ │ ├── function.diffA-B.txt │ │ │ ├── function.diffB-A.txt │ │ │ ├── function.parseA.txt │ │ │ ├── function.parseB.txt │ │ │ ├── generator-function.A.js │ │ │ ├── generator-function.B.js │ │ │ ├── generator-function.diffA-B.txt │ │ │ ├── generator-function.diffB-A.txt │ │ │ ├── generator-function.parseA.txt │ │ │ ├── generator-function.parseB.txt │ │ │ ├── identifier.A.js │ │ │ ├── identifier.B.js │ │ │ ├── identifier.diffA-B.txt │ │ │ ├── identifier.diffB-A.txt │ │ │ ├── identifier.parseA.txt │ │ │ ├── identifier.parseB.txt │ │ │ ├── if-else.A.js │ │ │ ├── if-else.B.js │ │ │ ├── if-else.diffA-B.txt │ │ │ ├── if-else.diffB-A.txt │ │ │ ├── if-else.parseA.txt │ │ │ ├── if-else.parseB.txt │ │ │ ├── if.A.js │ │ │ ├── if.B.js │ │ │ ├── if.diffA-B.txt │ │ │ ├── if.diffB-A.txt │ │ │ ├── if.parseA.txt │ │ │ ├── if.parseB.txt │ │ │ ├── import.A.js │ │ │ ├── import.B.js │ │ │ ├── import.diffA-B.txt │ │ │ ├── import.diffB-A.txt │ │ │ ├── import.parseA.txt │ │ │ ├── import.parseB.txt │ │ │ ├── jsx.A.js │ │ │ ├── jsx.B.js │ │ │ ├── jsx.diffA-B.txt │ │ │ ├── jsx.diffB-A.txt │ │ │ ├── jsx.parseA.txt │ │ │ ├── jsx.parseB.txt │ │ │ ├── math-assignment-operator.A.js │ │ │ ├── math-assignment-operator.B.js │ │ │ ├── math-assignment-operator.diffA-B.txt │ │ │ ├── math-assignment-operator.diffB-A.txt │ │ │ ├── math-assignment-operator.parseA.txt │ │ │ ├── math-assignment-operator.parseB.txt │ │ │ ├── math-operator.A.js │ │ │ ├── math-operator.B.js │ │ │ ├── math-operator.diffA-B.txt │ │ │ ├── math-operator.diffB-A.txt │ │ │ ├── math-operator.parseA.txt │ │ │ ├── math-operator.parseB.txt │ │ │ ├── member-access-assignment.A.js │ │ │ ├── member-access-assignment.B.js │ │ │ ├── member-access-assignment.diffA-B.txt │ │ │ ├── member-access-assignment.diffB-A.txt │ │ │ ├── member-access-assignment.parseA.txt │ │ │ ├── member-access-assignment.parseB.txt │ │ │ ├── member-access.A.js │ │ │ ├── member-access.B.js │ │ │ ├── member-access.diffA-B.txt │ │ │ ├── member-access.diffB-A.txt │ │ │ ├── member-access.parseA.txt │ │ │ ├── member-access.parseB.txt │ │ │ ├── method-call.A.js │ │ │ ├── method-call.B.js │ │ │ ├── method-call.diffA-B.txt │ │ │ ├── method-call.diffB-A.txt │ │ │ ├── method-call.parseA.txt │ │ │ ├── method-call.parseB.txt │ │ │ ├── named-function.A.js │ │ │ ├── named-function.B.js │ │ │ ├── named-function.diffA-B.txt │ │ │ ├── named-function.diffB-A.txt │ │ │ ├── named-function.parseA.txt │ │ │ ├── named-function.parseB.txt │ │ │ ├── nested-do-while-in-function.A.js │ │ │ ├── nested-do-while-in-function.B.js │ │ │ ├── nested-do-while-in-function.diffA-B.txt │ │ │ ├── nested-do-while-in-function.diffB-A.txt │ │ │ ├── nested-do-while-in-function.parseA.txt │ │ │ ├── nested-do-while-in-function.parseB.txt │ │ │ ├── nested-functions.A.js │ │ │ ├── nested-functions.B.js │ │ │ ├── nested-functions.diffA-B.txt │ │ │ ├── nested-functions.diffB-A.txt │ │ │ ├── nested-functions.parseA.txt │ │ │ ├── nested-functions.parseB.txt │ │ │ ├── null.A.js │ │ │ ├── null.B.js │ │ │ ├── null.diffA-B.txt │ │ │ ├── null.diffB-A.txt │ │ │ ├── null.parseA.txt │ │ │ ├── null.parseB.txt │ │ │ ├── number.A.js │ │ │ ├── number.B.js │ │ │ ├── number.diffA-B.txt │ │ │ ├── number.diffB-A.txt │ │ │ ├── number.parseA.txt │ │ │ ├── number.parseB.txt │ │ │ ├── object.A.js │ │ │ ├── object.B.js │ │ │ ├── object.diffA-B.txt │ │ │ ├── object.diffB-A.txt │ │ │ ├── object.parseA.txt │ │ │ ├── object.parseB.txt │ │ │ ├── objects-with-methods.A.js │ │ │ ├── objects-with-methods.B.js │ │ │ ├── objects-with-methods.diffA-B.txt │ │ │ ├── objects-with-methods.diffB-A.txt │ │ │ ├── objects-with-methods.parseA.txt │ │ │ ├── objects-with-methods.parseB.txt │ │ │ ├── regex.A.js │ │ │ ├── regex.B.js │ │ │ ├── regex.diffA-B.txt │ │ │ ├── regex.diffB-A.txt │ │ │ ├── regex.parseA.txt │ │ │ ├── regex.parseB.txt │ │ │ ├── relational-operator.A.js │ │ │ ├── relational-operator.B.js │ │ │ ├── relational-operator.diffA-B.txt │ │ │ ├── relational-operator.diffB-A.txt │ │ │ ├── relational-operator.parseA.txt │ │ │ ├── relational-operator.parseB.txt │ │ │ ├── return-statement.A.js │ │ │ ├── return-statement.B.js │ │ │ ├── return-statement.diffA-B.txt │ │ │ ├── return-statement.diffB-A.txt │ │ │ ├── return-statement.parseA.txt │ │ │ ├── return-statement.parseB.txt │ │ │ ├── string.A.js │ │ │ ├── string.B.js │ │ │ ├── string.diffA-B.txt │ │ │ ├── string.diffB-A.txt │ │ │ ├── string.parseA.txt │ │ │ ├── string.parseB.txt │ │ │ ├── subscript-access-assignment.A.js │ │ │ ├── subscript-access-assignment.B.js │ │ │ ├── subscript-access-assignment.diffA-B.txt │ │ │ ├── subscript-access-assignment.diffB-A.txt │ │ │ ├── subscript-access-assignment.parseA.txt │ │ │ ├── subscript-access-assignment.parseB.txt │ │ │ ├── subscript-access-string.A.js │ │ │ ├── subscript-access-string.B.js │ │ │ ├── subscript-access-string.diffA-B.txt │ │ │ ├── subscript-access-string.diffB-A.txt │ │ │ ├── subscript-access-string.parseA.txt │ │ │ ├── subscript-access-string.parseB.txt │ │ │ ├── subscript-access-variable.A.js │ │ │ ├── subscript-access-variable.B.js │ │ │ ├── subscript-access-variable.diffA-B.txt │ │ │ ├── subscript-access-variable.diffB-A.txt │ │ │ ├── subscript-access-variable.parseA.txt │ │ │ ├── subscript-access-variable.parseB.txt │ │ │ ├── switch-statement.A.js │ │ │ ├── switch-statement.B.js │ │ │ ├── switch-statement.diffA-B.txt │ │ │ ├── switch-statement.diffB-A.txt │ │ │ ├── switch-statement.parseA.txt │ │ │ ├── switch-statement.parseB.txt │ │ │ ├── template-string.A.js │ │ │ ├── template-string.B.js │ │ │ ├── template-string.diffA-B.txt │ │ │ ├── template-string.diffB-A.txt │ │ │ ├── template-string.parseA.txt │ │ │ ├── template-string.parseB.txt │ │ │ ├── ternary.A.js │ │ │ ├── ternary.B.js │ │ │ ├── ternary.diffA-B.txt │ │ │ ├── ternary.diffB-A.txt │ │ │ ├── ternary.parseA.txt │ │ │ ├── ternary.parseB.txt │ │ │ ├── this-expression.A.js │ │ │ ├── this-expression.B.js │ │ │ ├── this-expression.diffA-B.txt │ │ │ ├── this-expression.diffB-A.txt │ │ │ ├── this-expression.parseA.txt │ │ │ ├── this-expression.parseB.txt │ │ │ ├── throw-statement.A.js │ │ │ ├── throw-statement.B.js │ │ │ ├── throw-statement.diffA-B.txt │ │ │ ├── throw-statement.diffB-A.txt │ │ │ ├── throw-statement.parseA.txt │ │ │ ├── throw-statement.parseB.txt │ │ │ ├── true.A.js │ │ │ ├── true.B.js │ │ │ ├── true.diffA-B.txt │ │ │ ├── true.diffB-A.txt │ │ │ ├── true.parseA.txt │ │ │ ├── true.parseB.txt │ │ │ ├── try-statement.A.js │ │ │ ├── try-statement.B.js │ │ │ ├── try-statement.diffA-B.txt │ │ │ ├── try-statement.diffB-A.txt │ │ │ ├── try-statement.parseA.txt │ │ │ ├── try-statement.parseB.txt │ │ │ ├── type-operator.A.js │ │ │ ├── type-operator.B.js │ │ │ ├── type-operator.diffA-B.txt │ │ │ ├── type-operator.diffB-A.txt │ │ │ ├── type-operator.parseA.txt │ │ │ ├── type-operator.parseB.txt │ │ │ ├── undefined.A.js │ │ │ ├── undefined.B.js │ │ │ ├── undefined.diffA-B.txt │ │ │ ├── undefined.diffB-A.txt │ │ │ ├── undefined.parseA.txt │ │ │ ├── undefined.parseB.txt │ │ │ ├── var-declaration.A.js │ │ │ ├── var-declaration.B.js │ │ │ ├── var-declaration.diffA-B.txt │ │ │ ├── var-declaration.diffB-A.txt │ │ │ ├── var-declaration.parseA.txt │ │ │ ├── var-declaration.parseB.txt │ │ │ ├── variable.A.js │ │ │ ├── variable.B.js │ │ │ ├── variable.diffA-B.txt │ │ │ ├── variable.diffB-A.txt │ │ │ ├── variable.parseA.txt │ │ │ ├── variable.parseB.txt │ │ │ ├── variadic-function-declarations.parseA.txt │ │ │ ├── void-operator.A.js │ │ │ ├── void-operator.B.js │ │ │ ├── void-operator.diffA-B.txt │ │ │ ├── void-operator.diffB-A.txt │ │ │ ├── void-operator.parseA.txt │ │ │ ├── void-operator.parseB.txt │ │ │ ├── while-statement.A.js │ │ │ ├── while-statement.B.js │ │ │ ├── while-statement.diffA-B.txt │ │ │ ├── while-statement.diffB-A.txt │ │ │ ├── while-statement.parseA.txt │ │ │ ├── while-statement.parseB.txt │ │ │ ├── yield.A.js │ │ │ ├── yield.B.js │ │ │ ├── yield.diffA-B.txt │ │ │ ├── yield.diffB-A.txt │ │ │ ├── yield.parseA.txt │ │ │ └── yield.parseB.txt │ │ ├── reprinting/ │ │ │ └── map.json │ │ ├── tags/ │ │ │ └── simple_function_with_docs.js │ │ └── toc/ │ │ ├── duplicate-parent.A.js │ │ ├── duplicate-parent.B.js │ │ ├── erroneous-duplicate-method.A.js │ │ ├── erroneous-duplicate-method.B.js │ │ └── starts-with-newline.js │ ├── json/ │ │ ├── corpus/ │ │ │ ├── array.A.json │ │ │ ├── array.B.json │ │ │ ├── array.parseA.txt │ │ │ ├── array.parseB.txt │ │ │ ├── boolean.A.json │ │ │ ├── boolean.B.json │ │ │ ├── boolean.parseA.txt │ │ │ ├── boolean.parseB.txt │ │ │ ├── hash.A.json │ │ │ ├── hash.B.json │ │ │ ├── hash.parseA.txt │ │ │ ├── hash.parseB.txt │ │ │ ├── null.A.json │ │ │ ├── null.B.json │ │ │ ├── null.parseA.txt │ │ │ ├── null.parseB.txt │ │ │ ├── number.A.json │ │ │ ├── number.B.json │ │ │ ├── number.parseA.txt │ │ │ ├── number.parseB.txt │ │ │ ├── string.A.json │ │ │ ├── string.B.json │ │ │ ├── string.parseA.txt │ │ │ └── string.parseB.txt │ │ └── rewriting/ │ │ ├── add_keys.json │ │ └── add_keys_expected.json │ ├── markdown/ │ │ ├── corpus/ │ │ │ └── example.A.md │ │ └── toc/ │ │ ├── headings.A.md │ │ └── headings.B.md │ ├── php/ │ │ └── analysis/ │ │ ├── bar.php │ │ ├── foo.php │ │ ├── main.php │ │ ├── main_once.php │ │ └── namespaces.php │ ├── python/ │ │ ├── analysis/ │ │ │ ├── a.py │ │ │ ├── b/ │ │ │ │ ├── __init__.py │ │ │ │ └── c.py │ │ │ ├── c/ │ │ │ │ ├── __init__.py │ │ │ │ └── utils.py │ │ │ ├── main.py │ │ │ ├── main1.py │ │ │ ├── main2.py │ │ │ ├── main3.py │ │ │ ├── multiple_inheritance.py │ │ │ └── subclass.py │ │ ├── corpus/ │ │ │ ├── assert-statement.A.py │ │ │ ├── assert-statement.B.py │ │ │ ├── assert-statement.diffA-B.txt │ │ │ ├── assert-statement.diffB-A.txt │ │ │ ├── assert-statement.parseA.txt │ │ │ ├── assert-statement.parseB.txt │ │ │ ├── assignment.A.py │ │ │ ├── assignment.B.py │ │ │ ├── assignment.diffA-B.txt │ │ │ ├── assignment.diffB-A.txt │ │ │ ├── assignment.parseA.txt │ │ │ ├── assignment.parseB.txt │ │ │ ├── async-function-definition.A.py │ │ │ ├── async-function-definition.B.py │ │ │ ├── async-function-definition.diffA-B.txt │ │ │ ├── async-function-definition.diffB-A.txt │ │ │ ├── async-function-definition.parseA.txt │ │ │ ├── async-function-definition.parseB.txt │ │ │ ├── attribute.A.py │ │ │ ├── attribute.B.py │ │ │ ├── attribute.diffA-B.txt │ │ │ ├── attribute.diffB-A.txt │ │ │ ├── attribute.parseA.txt │ │ │ ├── attribute.parseB.txt │ │ │ ├── augmented-assignment.A.py │ │ │ ├── augmented-assignment.B.py │ │ │ ├── augmented-assignment.diffA-B.txt │ │ │ ├── augmented-assignment.diffB-A.txt │ │ │ ├── augmented-assignment.parseA.txt │ │ │ ├── augmented-assignment.parseB.txt │ │ │ ├── await.A.py │ │ │ ├── await.B.py │ │ │ ├── await.diffA-B.txt │ │ │ ├── await.diffB-A.txt │ │ │ ├── await.parseA.txt │ │ │ ├── await.parseB.txt │ │ │ ├── binary-operator.A.py │ │ │ ├── binary-operator.B.py │ │ │ ├── binary-operator.diffA-B.txt │ │ │ ├── binary-operator.diffB-A.txt │ │ │ ├── binary-operator.parseA.txt │ │ │ ├── binary-operator.parseB.txt │ │ │ ├── boolean-operator.A.py │ │ │ ├── boolean-operator.B.py │ │ │ ├── boolean-operator.diffA-B.txt │ │ │ ├── boolean-operator.diffB-A.txt │ │ │ ├── boolean-operator.parseA.txt │ │ │ ├── boolean-operator.parseB.txt │ │ │ ├── boolean.A.py │ │ │ ├── boolean.B.py │ │ │ ├── boolean.diffA-B.txt │ │ │ ├── boolean.diffB-A.txt │ │ │ ├── boolean.parseA.txt │ │ │ ├── boolean.parseB.txt │ │ │ ├── break-statement.A.py │ │ │ ├── break-statement.B.py │ │ │ ├── break-statement.diffA-B.txt │ │ │ ├── break-statement.diffB-A.txt │ │ │ ├── break-statement.parseA.txt │ │ │ ├── break-statement.parseB.txt │ │ │ ├── call.A.py │ │ │ ├── call.B.py │ │ │ ├── call.diffA-B.txt │ │ │ ├── call.diffB-A.txt │ │ │ ├── call.parseA.txt │ │ │ ├── call.parseB.txt │ │ │ ├── class-definition.A.py │ │ │ ├── class-definition.B.py │ │ │ ├── class-definition.diffA-B.txt │ │ │ ├── class-definition.diffB-A.txt │ │ │ ├── class-definition.parseA.txt │ │ │ ├── class-definition.parseB.txt │ │ │ ├── comment.A.py │ │ │ ├── comment.B.py │ │ │ ├── comment.diffA-B.txt │ │ │ ├── comment.diffB-A.txt │ │ │ ├── comment.parseA.txt │ │ │ ├── comment.parseB.txt │ │ │ ├── comparison-operator.A.py │ │ │ ├── comparison-operator.B.py │ │ │ ├── comparison-operator.diffA-B.txt │ │ │ ├── comparison-operator.diffB-A.txt │ │ │ ├── comparison-operator.parseA.txt │ │ │ ├── comparison-operator.parseB.txt │ │ │ ├── concatenated-string.A.py │ │ │ ├── concatenated-string.B.py │ │ │ ├── concatenated-string.diffA-B.txt │ │ │ ├── concatenated-string.diffB-A.txt │ │ │ ├── concatenated-string.parseA.txt │ │ │ ├── concatenated-string.parseB.txt │ │ │ ├── conditional-expression.A.py │ │ │ ├── conditional-expression.B.py │ │ │ ├── conditional-expression.diffA-B.txt │ │ │ ├── conditional-expression.diffB-A.txt │ │ │ ├── conditional-expression.parseA.txt │ │ │ ├── conditional-expression.parseB.txt │ │ │ ├── continue-statement.A.py │ │ │ ├── continue-statement.B.py │ │ │ ├── continue-statement.diffA-B.txt │ │ │ ├── continue-statement.diffB-A.txt │ │ │ ├── continue-statement.parseA.txt │ │ │ ├── continue-statement.parseB.txt │ │ │ ├── decorated-definition.A.py │ │ │ ├── decorated-definition.B.py │ │ │ ├── decorated-definition.diffA-B.txt │ │ │ ├── decorated-definition.diffB-A.txt │ │ │ ├── decorated-definition.parseA.txt │ │ │ ├── decorated-definition.parseB.txt │ │ │ ├── delete-statement.A.py │ │ │ ├── delete-statement.B.py │ │ │ ├── delete-statement.diffA-B.txt │ │ │ ├── delete-statement.diffB-A.txt │ │ │ ├── delete-statement.parseA.txt │ │ │ ├── delete-statement.parseB.txt │ │ │ ├── dictionary-comprehension.A.py │ │ │ ├── dictionary-comprehension.B.py │ │ │ ├── dictionary-comprehension.diffA-B.txt │ │ │ ├── dictionary-comprehension.diffB-A.txt │ │ │ ├── dictionary-comprehension.parseA.txt │ │ │ ├── dictionary-comprehension.parseB.txt │ │ │ ├── dictionary.A.py │ │ │ ├── dictionary.B.py │ │ │ ├── dictionary.diffA-B.txt │ │ │ ├── dictionary.diffB-A.txt │ │ │ ├── dictionary.parseA.txt │ │ │ ├── dictionary.parseB.txt │ │ │ ├── dotted-name.A.py │ │ │ ├── dotted-name.B.py │ │ │ ├── dotted-name.diffA-B.txt │ │ │ ├── dotted-name.diffB-A.txt │ │ │ ├── dotted-name.parseA.txt │ │ │ ├── dotted-name.parseB.txt │ │ │ ├── ellipsis.A.py │ │ │ ├── ellipsis.B.py │ │ │ ├── ellipsis.diffA-B.txt │ │ │ ├── ellipsis.diffB-A.txt │ │ │ ├── ellipsis.parseA.txt │ │ │ ├── ellipsis.parseB.txt │ │ │ ├── exec-statement.A.py │ │ │ ├── exec-statement.B.py │ │ │ ├── exec-statement.diffA-B.txt │ │ │ ├── exec-statement.diffB-A.txt │ │ │ ├── exec-statement.parseA.txt │ │ │ ├── exec-statement.parseB.txt │ │ │ ├── expression-statement.A.py │ │ │ ├── expression-statement.B.py │ │ │ ├── expression-statement.diffA-B.txt │ │ │ ├── expression-statement.diffB-A.txt │ │ │ ├── expression-statement.parseA.txt │ │ │ ├── expression-statement.parseB.txt │ │ │ ├── float.A.py │ │ │ ├── float.B.py │ │ │ ├── float.diffA-B.txt │ │ │ ├── float.diffB-A.txt │ │ │ ├── float.parseA.txt │ │ │ ├── float.parseB.txt │ │ │ ├── for-statement.A.py │ │ │ ├── for-statement.B.py │ │ │ ├── for-statement.diffA-B.txt │ │ │ ├── for-statement.diffB-A.txt │ │ │ ├── for-statement.parseA.txt │ │ │ ├── for-statement.parseB.txt │ │ │ ├── function-definition.A.py │ │ │ ├── function-definition.B.py │ │ │ ├── function-definition.diffA-B.txt │ │ │ ├── function-definition.diffB-A.txt │ │ │ ├── function-definition.parseA.txt │ │ │ ├── function-definition.parseB.txt │ │ │ ├── future_import_statement.A.py │ │ │ ├── future_import_statement.B.py │ │ │ ├── future_import_statement.diffA-B.txt │ │ │ ├── future_import_statement.diffB-A.txt │ │ │ ├── future_import_statement.parseA.txt │ │ │ ├── future_import_statement.parseB.txt │ │ │ ├── generator-expression.A.py │ │ │ ├── generator-expression.B.py │ │ │ ├── generator-expression.diffA-B.txt │ │ │ ├── generator-expression.diffB-A.txt │ │ │ ├── generator-expression.parseA.txt │ │ │ ├── generator-expression.parseB.txt │ │ │ ├── global-statement.A.py │ │ │ ├── global-statement.B.py │ │ │ ├── global-statement.diffA-B.txt │ │ │ ├── global-statement.diffB-A.txt │ │ │ ├── global-statement.parseA.txt │ │ │ ├── global-statement.parseB.txt │ │ │ ├── identifier.A.py │ │ │ ├── identifier.B.py │ │ │ ├── identifier.diffA-B.txt │ │ │ ├── identifier.diffB-A.txt │ │ │ ├── identifier.parseA.txt │ │ │ ├── identifier.parseB.txt │ │ │ ├── if-statement.A.py │ │ │ ├── if-statement.B.py │ │ │ ├── if-statement.diffA-B.txt │ │ │ ├── if-statement.diffB-A.txt │ │ │ ├── if-statement.parseA.txt │ │ │ ├── if-statement.parseB.txt │ │ │ ├── import-from-statement.A.py │ │ │ ├── import-from-statement.B.py │ │ │ ├── import-from-statement.diffA-B.txt │ │ │ ├── import-from-statement.diffB-A.txt │ │ │ ├── import-from-statement.parseA.txt │ │ │ ├── import-from-statement.parseB.txt │ │ │ ├── import-statement.A.py │ │ │ ├── import-statement.B.py │ │ │ ├── import-statement.diffA-B.txt │ │ │ ├── import-statement.diffB-A.txt │ │ │ ├── import-statement.parseA.txt │ │ │ ├── import-statement.parseB.txt │ │ │ ├── integer.A.py │ │ │ ├── integer.B.py │ │ │ ├── integer.diffA-B.txt │ │ │ ├── integer.diffB-A.txt │ │ │ ├── integer.parseA.txt │ │ │ ├── integer.parseB.txt │ │ │ ├── keyword-identifier.A.py │ │ │ ├── keyword-identifier.B.py │ │ │ ├── keyword-identifier.diffA-B.txt │ │ │ ├── keyword-identifier.diffB-A.txt │ │ │ ├── keyword-identifier.parseA.txt │ │ │ ├── keyword-identifier.parseB.txt │ │ │ ├── lambda.A.py │ │ │ ├── lambda.B.py │ │ │ ├── lambda.diffA-B.txt │ │ │ ├── lambda.diffB-A.txt │ │ │ ├── lambda.parseA.txt │ │ │ ├── lambda.parseB.txt │ │ │ ├── list-comprehension.A.py │ │ │ ├── list-comprehension.B.py │ │ │ ├── list-comprehension.diffA-B.txt │ │ │ ├── list-comprehension.diffB-A.txt │ │ │ ├── list-comprehension.parseA.txt │ │ │ ├── list-comprehension.parseB.txt │ │ │ ├── list.A.py │ │ │ ├── list.B.py │ │ │ ├── list.diffA-B.txt │ │ │ ├── list.diffB-A.txt │ │ │ ├── list.parseA.txt │ │ │ ├── list.parseB.txt │ │ │ ├── non-local-statement.A.py │ │ │ ├── non-local-statement.B.py │ │ │ ├── non-local-statement.diffA-B.txt │ │ │ ├── non-local-statement.diffB-A.txt │ │ │ ├── non-local-statement.parseA.txt │ │ │ ├── non-local-statement.parseB.txt │ │ │ ├── none.A.py │ │ │ ├── none.B.py │ │ │ ├── none.diffA-B.txt │ │ │ ├── none.diffB-A.txt │ │ │ ├── none.parseA.txt │ │ │ ├── none.parseB.txt │ │ │ ├── not.A.py │ │ │ ├── not.B.py │ │ │ ├── not.diffA-B.txt │ │ │ ├── not.diffB-A.txt │ │ │ ├── not.parseA.txt │ │ │ ├── not.parseB.txt │ │ │ ├── pass-statement.A.py │ │ │ ├── pass-statement.B.py │ │ │ ├── pass-statement.diffA-B.txt │ │ │ ├── pass-statement.diffB-A.txt │ │ │ ├── pass-statement.parseA.txt │ │ │ ├── pass-statement.parseB.txt │ │ │ ├── print-statement.A.py │ │ │ ├── print-statement.B.py │ │ │ ├── print-statement.diffA-B.txt │ │ │ ├── print-statement.diffB-A.txt │ │ │ ├── print-statement.parseA.txt │ │ │ ├── print-statement.parseB.txt │ │ │ ├── raise-statement.A.py │ │ │ ├── raise-statement.B.py │ │ │ ├── raise-statement.diffA-B.txt │ │ │ ├── raise-statement.diffB-A.txt │ │ │ ├── raise-statement.parseA.txt │ │ │ ├── raise-statement.parseB.txt │ │ │ ├── return-statement.A.py │ │ │ ├── return-statement.B.py │ │ │ ├── return-statement.diffA-B.txt │ │ │ ├── return-statement.diffB-A.txt │ │ │ ├── return-statement.parseA.txt │ │ │ ├── return-statement.parseB.txt │ │ │ ├── set-comprehension.A.py │ │ │ ├── set-comprehension.B.py │ │ │ ├── set-comprehension.diffA-B.txt │ │ │ ├── set-comprehension.diffB-A.txt │ │ │ ├── set-comprehension.parseA.txt │ │ │ ├── set-comprehension.parseB.txt │ │ │ ├── set.A.py │ │ │ ├── set.B.py │ │ │ ├── set.diffA-B.txt │ │ │ ├── set.diffB-A.txt │ │ │ ├── set.parseA.txt │ │ │ ├── set.parseB.txt │ │ │ ├── slice.A.py │ │ │ ├── slice.B.py │ │ │ ├── slice.diffA-B.txt │ │ │ ├── slice.diffB-A.txt │ │ │ ├── slice.parseA.txt │ │ │ ├── slice.parseB.txt │ │ │ ├── string.A.py │ │ │ ├── string.B.py │ │ │ ├── string.diffA-B.txt │ │ │ ├── string.diffB-A.txt │ │ │ ├── string.parseA.txt │ │ │ ├── string.parseB.txt │ │ │ ├── subscript.A.py │ │ │ ├── subscript.B.py │ │ │ ├── subscript.diffA-B.txt │ │ │ ├── subscript.diffB-A.txt │ │ │ ├── subscript.parseA.txt │ │ │ ├── subscript.parseB.txt │ │ │ ├── try-statement.A.py │ │ │ ├── try-statement.B.py │ │ │ ├── try-statement.diffA-B.txt │ │ │ ├── try-statement.diffB-A.txt │ │ │ ├── try-statement.parseA.txt │ │ │ ├── try-statement.parseB.txt │ │ │ ├── tuple.A.py │ │ │ ├── tuple.B.py │ │ │ ├── tuple.diffA-B.txt │ │ │ ├── tuple.diffB-A.txt │ │ │ ├── tuple.parseA.txt │ │ │ ├── tuple.parseB.txt │ │ │ ├── unary-operator.A.py │ │ │ ├── unary-operator.B.py │ │ │ ├── unary-operator.diffA-B.txt │ │ │ ├── unary-operator.diffB-A.txt │ │ │ ├── unary-operator.parseA.txt │ │ │ ├── unary-operator.parseB.txt │ │ │ ├── while-statement.A.py │ │ │ ├── while-statement.B.py │ │ │ ├── while-statement.diffA-B.txt │ │ │ ├── while-statement.diffB-A.txt │ │ │ ├── while-statement.parseA.txt │ │ │ ├── while-statement.parseB.txt │ │ │ ├── with-statement.A.py │ │ │ ├── with-statement.B.py │ │ │ ├── with-statement.diffA-B.txt │ │ │ ├── with-statement.diffB-A.txt │ │ │ ├── with-statement.parseA.txt │ │ │ ├── with-statement.parseB.txt │ │ │ ├── with.A.py │ │ │ ├── with.B.py │ │ │ ├── with.diffA-B.txt │ │ │ ├── with.diffB-A.txt │ │ │ ├── with.parseA.txt │ │ │ ├── with.parseB.txt │ │ │ ├── yield.A.py │ │ │ ├── yield.B.py │ │ │ ├── yield.diffA-B.txt │ │ │ ├── yield.diffB-A.txt │ │ │ ├── yield.parseA.txt │ │ │ └── yield.parseB.txt │ │ ├── graphing/ │ │ │ ├── conditional/ │ │ │ │ └── conditional.py │ │ │ ├── simple/ │ │ │ │ └── simple.py │ │ │ ├── typeerror/ │ │ │ │ └── typeerror.py │ │ │ └── unbound/ │ │ │ └── unbound.py │ │ ├── import-graph/ │ │ │ ├── main.json │ │ │ └── main.py │ │ ├── matching/ │ │ │ ├── docstrings.py │ │ │ └── docstrings_nested.py │ │ ├── reprinting/ │ │ │ ├── function.out.py │ │ │ └── function.py │ │ └── tags/ │ │ ├── class.py │ │ ├── multiline.py │ │ ├── simple_function_with_docs.py │ │ └── simple_functions.py │ ├── ruby/ │ │ ├── analysis/ │ │ │ ├── break.rb │ │ │ ├── call.rb │ │ │ ├── classes.rb │ │ │ ├── early-return.rb │ │ │ ├── foo.rb │ │ │ ├── line.rb │ │ │ ├── load-wrap.rb │ │ │ ├── load.rb │ │ │ ├── main.rb │ │ │ ├── modules.rb │ │ │ ├── next.rb │ │ │ ├── preluded.rb │ │ │ ├── puts.rb │ │ │ ├── src/ │ │ │ │ ├── foo.rb │ │ │ │ └── main.rb │ │ │ └── subclass.rb │ │ ├── corpus/ │ │ │ ├── alias.A.rb │ │ │ ├── alias.parseA.txt │ │ │ ├── and-or.A.rb │ │ │ ├── and-or.B.rb │ │ │ ├── and-or.diffA-B.txt │ │ │ ├── and-or.diffB-A.txt │ │ │ ├── and-or.parseA.txt │ │ │ ├── and-or.parseB.txt │ │ │ ├── array.A.rb │ │ │ ├── array.B.rb │ │ │ ├── array.diffA-B.txt │ │ │ ├── array.diffB-A.txt │ │ │ ├── array.parseA.txt │ │ │ ├── array.parseB.txt │ │ │ ├── assignment.A.rb │ │ │ ├── assignment.B.rb │ │ │ ├── assignment.diffA-B.txt │ │ │ ├── assignment.diffB-A.txt │ │ │ ├── assignment.parseA.txt │ │ │ ├── assignment.parseB.txt │ │ │ ├── begin-block.A.rb │ │ │ ├── begin-block.B.rb │ │ │ ├── begin-block.diffA-B.txt │ │ │ ├── begin-block.diffB-A.txt │ │ │ ├── begin-block.parseA.txt │ │ │ ├── begin-block.parseB.txt │ │ │ ├── begin.A.rb │ │ │ ├── begin.B.rb │ │ │ ├── begin.diffA-B.txt │ │ │ ├── begin.diffB-A.txt │ │ │ ├── begin.parseA.txt │ │ │ ├── begin.parseB.txt │ │ │ ├── binary.A.rb │ │ │ ├── binary.parseA.txt │ │ │ ├── bitwise-operator.A.rb │ │ │ ├── bitwise-operator.B.rb │ │ │ ├── bitwise-operator.diffA-B.txt │ │ │ ├── bitwise-operator.diffB-A.txt │ │ │ ├── bitwise-operator.parseA.txt │ │ │ ├── bitwise-operator.parseB.txt │ │ │ ├── boolean-operator.A.rb │ │ │ ├── boolean-operator.B.rb │ │ │ ├── boolean-operator.diffA-B.txt │ │ │ ├── boolean-operator.diffB-A.txt │ │ │ ├── boolean-operator.parseA.txt │ │ │ ├── boolean-operator.parseB.txt │ │ │ ├── break.A.rb │ │ │ ├── break.B.rb │ │ │ ├── break.diffA-B.txt │ │ │ ├── break.diffB-A.txt │ │ │ ├── break.parseA.txt │ │ │ ├── break.parseB.txt │ │ │ ├── calls.A.rb │ │ │ ├── calls.parseA.txt │ │ │ ├── chained-string.A.rb │ │ │ ├── chained-string.parseA.txt │ │ │ ├── class.A.rb │ │ │ ├── class.B.rb │ │ │ ├── class.diffA-B.txt │ │ │ ├── class.diffB-A.txt │ │ │ ├── class.parseA.txt │ │ │ ├── class.parseB.txt │ │ │ ├── comment.A.rb │ │ │ ├── comment.B.rb │ │ │ ├── comment.diffA-B.txt │ │ │ ├── comment.diffB-A.txt │ │ │ ├── comment.parseA.txt │ │ │ ├── comment.parseB.txt │ │ │ ├── comparision-operator.A.rb │ │ │ ├── comparision-operator.B.rb │ │ │ ├── comparision-operator.diffA-B.txt │ │ │ ├── comparision-operator.diffB-A.txt │ │ │ ├── comparision-operator.parseA.txt │ │ │ ├── comparision-operator.parseB.txt │ │ │ ├── conditional-assignment.A.rb │ │ │ ├── conditional-assignment.B.rb │ │ │ ├── conditional-assignment.diffA-B.txt │ │ │ ├── conditional-assignment.diffB-A.txt │ │ │ ├── conditional-assignment.parseA.txt │ │ │ ├── conditional-assignment.parseB.txt │ │ │ ├── delimiter.A.rb │ │ │ ├── delimiter.B.rb │ │ │ ├── delimiter.diffA-B.txt │ │ │ ├── delimiter.diffB-A.txt │ │ │ ├── delimiter.parseA.txt │ │ │ ├── delimiter.parseB.txt │ │ │ ├── element-reference.A.rb │ │ │ ├── element-reference.B.rb │ │ │ ├── element-reference.diffA-B.txt │ │ │ ├── element-reference.diffB-A.txt │ │ │ ├── element-reference.parseA.txt │ │ │ ├── element-reference.parseB.txt │ │ │ ├── else.A.rb │ │ │ ├── else.B.rb │ │ │ ├── else.diffA-B.txt │ │ │ ├── else.diffB-A.txt │ │ │ ├── else.parseA.txt │ │ │ ├── else.parseB.txt │ │ │ ├── elsif.A.rb │ │ │ ├── elsif.B.rb │ │ │ ├── elsif.diffA-B.txt │ │ │ ├── elsif.diffB-A.txt │ │ │ ├── elsif.parseA.txt │ │ │ ├── elsif.parseB.txt │ │ │ ├── empty-statement.A.rb │ │ │ ├── empty-statement.parseA.txt │ │ │ ├── end-block.A.rb │ │ │ ├── end-block.B.rb │ │ │ ├── end-block.diffA-B.txt │ │ │ ├── end-block.diffB-A.txt │ │ │ ├── end-block.parseA.txt │ │ │ ├── end-block.parseB.txt │ │ │ ├── ensure.A.rb │ │ │ ├── ensure.B.rb │ │ │ ├── ensure.diffA-B.txt │ │ │ ├── ensure.diffB-A.txt │ │ │ ├── ensure.parseA.txt │ │ │ ├── ensure.parseB.txt │ │ │ ├── for.A.rb │ │ │ ├── for.B.rb │ │ │ ├── for.diffA-B.txt │ │ │ ├── for.diffB-A.txt │ │ │ ├── for.parseA.txt │ │ │ ├── for.parseB.txt │ │ │ ├── hash.A.rb │ │ │ ├── hash.B.rb │ │ │ ├── hash.diffA-B.txt │ │ │ ├── hash.diffB-A.txt │ │ │ ├── hash.parseA.txt │ │ │ ├── hash.parseB.txt │ │ │ ├── heredoc.A.rb │ │ │ ├── heredoc.B.rb │ │ │ ├── heredoc.diffA-B.txt │ │ │ ├── heredoc.diffB-A.txt │ │ │ ├── heredoc.parseA.txt │ │ │ ├── heredoc.parseB.txt │ │ │ ├── if-unless-modifiers.A.rb │ │ │ ├── if-unless-modifiers.B.rb │ │ │ ├── if-unless-modifiers.diffA-B.txt │ │ │ ├── if-unless-modifiers.diffB-A.txt │ │ │ ├── if-unless-modifiers.parseA.txt │ │ │ ├── if-unless-modifiers.parseB.txt │ │ │ ├── if.A.rb │ │ │ ├── if.B.rb │ │ │ ├── if.diffA-B.txt │ │ │ ├── if.diffB-A.txt │ │ │ ├── if.parseA.txt │ │ │ ├── if.parseB.txt │ │ │ ├── interpolation.A.rb │ │ │ ├── interpolation.B.rb │ │ │ ├── interpolation.diffA-B.txt │ │ │ ├── interpolation.diffB-A.txt │ │ │ ├── interpolation.parseA.txt │ │ │ ├── interpolation.parseB.txt │ │ │ ├── keywords.A.rb │ │ │ ├── keywords.parseA.txt │ │ │ ├── lambda-dash-rocket.A.rb │ │ │ ├── lambda-dash-rocket.B.rb │ │ │ ├── lambda-dash-rocket.diffA-B.txt │ │ │ ├── lambda-dash-rocket.diffB-A.txt │ │ │ ├── lambda-dash-rocket.parseA.txt │ │ │ ├── lambda-dash-rocket.parseB.txt │ │ │ ├── lambda.A.rb │ │ │ ├── lambda.B.rb │ │ │ ├── lambda.diffA-B.txt │ │ │ ├── lambda.diffB-A.txt │ │ │ ├── lambda.parseA.txt │ │ │ ├── lambda.parseB.txt │ │ │ ├── literals.A.rb │ │ │ ├── literals.parseA.txt │ │ │ ├── math-assignment.A.rb │ │ │ ├── math-assignment.B.rb │ │ │ ├── math-assignment.diffA-B.txt │ │ │ ├── math-assignment.diffB-A.txt │ │ │ ├── math-assignment.parseA.txt │ │ │ ├── math-assignment.parseB.txt │ │ │ ├── method-calls-hash-args.A.rb │ │ │ ├── method-calls-hash-args.B.rb │ │ │ ├── method-calls-hash-args.diffA-B.txt │ │ │ ├── method-calls-hash-args.diffB-A.txt │ │ │ ├── method-calls-hash-args.parseA.txt │ │ │ ├── method-calls-hash-args.parseB.txt │ │ │ ├── method-calls-keyword-args.A.rb │ │ │ ├── method-calls-keyword-args.B.rb │ │ │ ├── method-calls-keyword-args.diffA-B.txt │ │ │ ├── method-calls-keyword-args.diffB-A.txt │ │ │ ├── method-calls-keyword-args.parseA.txt │ │ │ ├── method-calls-keyword-args.parseB.txt │ │ │ ├── method-calls.A.rb │ │ │ ├── method-calls.B.rb │ │ │ ├── method-calls.diffA-B.txt │ │ │ ├── method-calls.diffB-A.txt │ │ │ ├── method-calls.parseA.txt │ │ │ ├── method-calls.parseB.txt │ │ │ ├── method-declaration-keyword-param.A.rb │ │ │ ├── method-declaration-keyword-param.B.rb │ │ │ ├── method-declaration-keyword-param.diffA-B.txt │ │ │ ├── method-declaration-keyword-param.diffB-A.txt │ │ │ ├── method-declaration-keyword-param.parseA.txt │ │ │ ├── method-declaration-keyword-param.parseB.txt │ │ │ ├── method-declaration-param-default.A.rb │ │ │ ├── method-declaration-param-default.B.rb │ │ │ ├── method-declaration-param-default.diffA-B.txt │ │ │ ├── method-declaration-param-default.diffB-A.txt │ │ │ ├── method-declaration-param-default.parseA.txt │ │ │ ├── method-declaration-param-default.parseB.txt │ │ │ ├── method-declaration-params.A.rb │ │ │ ├── method-declaration-params.B.rb │ │ │ ├── method-declaration-params.diffA-B.txt │ │ │ ├── method-declaration-params.diffB-A.txt │ │ │ ├── method-declaration-params.parseA.txt │ │ │ ├── method-declaration-params.parseB.txt │ │ │ ├── method-declaration-required-keyword-param.A.rb │ │ │ ├── method-declaration-required-keyword-param.B.rb │ │ │ ├── method-declaration-required-keyword-param.diffA-B.txt │ │ │ ├── method-declaration-required-keyword-param.diffB-A.txt │ │ │ ├── method-declaration-required-keyword-param.parseA.txt │ │ │ ├── method-declaration-required-keyword-param.parseB.txt │ │ │ ├── method-declaration-unnamed-param.A.rb │ │ │ ├── method-declaration-unnamed-param.B.rb │ │ │ ├── method-declaration-unnamed-param.diffA-B.txt │ │ │ ├── method-declaration-unnamed-param.diffB-A.txt │ │ │ ├── method-declaration-unnamed-param.parseA.txt │ │ │ ├── method-declaration-unnamed-param.parseB.txt │ │ │ ├── method-declaration.A.rb │ │ │ ├── method-declaration.B.rb │ │ │ ├── method-declaration.diffA-B.txt │ │ │ ├── method-declaration.diffB-A.txt │ │ │ ├── method-declaration.parseA.txt │ │ │ ├── method-declaration.parseB.txt │ │ │ ├── method-invocation.A.rb │ │ │ ├── method-invocation.B.rb │ │ │ ├── method-invocation.diffA-B.txt │ │ │ ├── method-invocation.diffB-A.txt │ │ │ ├── method-invocation.parseA.txt │ │ │ ├── method-invocation.parseB.txt │ │ │ ├── methods.A.rb │ │ │ ├── methods.parseA.txt │ │ │ ├── misc.A.rb │ │ │ ├── misc.parseA.txt │ │ │ ├── module.A.rb │ │ │ ├── module.B.rb │ │ │ ├── module.diffA-B.txt │ │ │ ├── module.diffB-A.txt │ │ │ ├── module.parseA.txt │ │ │ ├── module.parseB.txt │ │ │ ├── multiple-assignments.A.rb │ │ │ ├── multiple-assignments.B.rb │ │ │ ├── multiple-assignments.diffA-B.txt │ │ │ ├── multiple-assignments.diffB-A.txt │ │ │ ├── multiple-assignments.parseA.txt │ │ │ ├── multiple-assignments.parseB.txt │ │ │ ├── next.A.rb │ │ │ ├── next.parseA.txt │ │ │ ├── number.A.rb │ │ │ ├── number.B.rb │ │ │ ├── number.diffA-B.txt │ │ │ ├── number.diffB-A.txt │ │ │ ├── number.parseA.txt │ │ │ ├── number.parseB.txt │ │ │ ├── percent-array.A.rb │ │ │ ├── percent-array.B.rb │ │ │ ├── percent-array.diffA-B.txt │ │ │ ├── percent-array.diffB-A.txt │ │ │ ├── percent-array.parseA.txt │ │ │ ├── percent-array.parseB.txt │ │ │ ├── pseudo-variables.A.rb │ │ │ ├── pseudo-variables.B.rb │ │ │ ├── pseudo-variables.diffA-B.txt │ │ │ ├── pseudo-variables.diffB-A.txt │ │ │ ├── pseudo-variables.parseA.txt │ │ │ ├── pseudo-variables.parseB.txt │ │ │ ├── regex.A.rb │ │ │ ├── regex.B.rb │ │ │ ├── regex.diffA-B.txt │ │ │ ├── regex.diffB-A.txt │ │ │ ├── regex.parseA.txt │ │ │ ├── regex.parseB.txt │ │ │ ├── relational-operator.A.rb │ │ │ ├── relational-operator.B.rb │ │ │ ├── relational-operator.diffA-B.txt │ │ │ ├── relational-operator.diffB-A.txt │ │ │ ├── relational-operator.parseA.txt │ │ │ ├── relational-operator.parseB.txt │ │ │ ├── require.A.rb │ │ │ ├── require.B.rb │ │ │ ├── require.diffA-B.txt │ │ │ ├── require.diffB-A.txt │ │ │ ├── require.parseA.txt │ │ │ ├── require.parseB.txt │ │ │ ├── rescue-empty.A.rb │ │ │ ├── rescue-empty.B.rb │ │ │ ├── rescue-empty.diffA-B.txt │ │ │ ├── rescue-empty.diffB-A.txt │ │ │ ├── rescue-empty.parseA.txt │ │ │ ├── rescue-empty.parseB.txt │ │ │ ├── rescue-last-ex.A.rb │ │ │ ├── rescue-last-ex.B.rb │ │ │ ├── rescue-last-ex.diffA-B.txt │ │ │ ├── rescue-last-ex.diffB-A.txt │ │ │ ├── rescue-last-ex.parseA.txt │ │ │ ├── rescue-last-ex.parseB.txt │ │ │ ├── rescue-modifier.A.rb │ │ │ ├── rescue-modifier.B.rb │ │ │ ├── rescue-modifier.diffA-B.txt │ │ │ ├── rescue-modifier.diffB-A.txt │ │ │ ├── rescue-modifier.parseA.txt │ │ │ ├── rescue-modifier.parseB.txt │ │ │ ├── rescue-modifier2.A.rb │ │ │ ├── rescue-modifier2.B.rb │ │ │ ├── rescue-modifier2.diffA-B.txt │ │ │ ├── rescue-modifier2.diffB-A.txt │ │ │ ├── rescue-modifier2.parseA.txt │ │ │ ├── rescue-modifier2.parseB.txt │ │ │ ├── rescue.A.rb │ │ │ ├── rescue.B.rb │ │ │ ├── rescue.diffA-B.txt │ │ │ ├── rescue.diffB-A.txt │ │ │ ├── rescue.parseA.txt │ │ │ ├── rescue.parseB.txt │ │ │ ├── return.A.rb │ │ │ ├── return.B.rb │ │ │ ├── return.diffA-B.txt │ │ │ ├── return.diffB-A.txt │ │ │ ├── return.parseA.txt │ │ │ ├── return.parseB.txt │ │ │ ├── singleton-class.A.rb │ │ │ ├── singleton-class.parseA.txt │ │ │ ├── string.A.rb │ │ │ ├── string.B.rb │ │ │ ├── string.diffA-B.txt │ │ │ ├── string.diffB-A.txt │ │ │ ├── string.parseA.txt │ │ │ ├── string.parseB.txt │ │ │ ├── subshell.A.rb │ │ │ ├── subshell.B.rb │ │ │ ├── subshell.diffA-B.txt │ │ │ ├── subshell.diffB-A.txt │ │ │ ├── subshell.parseA.txt │ │ │ ├── subshell.parseB.txt │ │ │ ├── symbol.A.rb │ │ │ ├── symbol.B.rb │ │ │ ├── symbol.diffA-B.txt │ │ │ ├── symbol.diffB-A.txt │ │ │ ├── symbol.parseA.txt │ │ │ ├── symbol.parseB.txt │ │ │ ├── ternary.A.rb │ │ │ ├── ternary.B.rb │ │ │ ├── ternary.diffA-B.txt │ │ │ ├── ternary.diffB-A.txt │ │ │ ├── ternary.parseA.txt │ │ │ ├── ternary.parseB.txt │ │ │ ├── unary.A.rb │ │ │ ├── unary.parseA.txt │ │ │ ├── undef.A.rb │ │ │ ├── undef.parseA.txt │ │ │ ├── unless.A.rb │ │ │ ├── unless.B.rb │ │ │ ├── unless.diffA-B.txt │ │ │ ├── unless.diffB-A.txt │ │ │ ├── unless.parseA.txt │ │ │ ├── unless.parseB.txt │ │ │ ├── until.A.rb │ │ │ ├── until.B.rb │ │ │ ├── until.diffA-B.txt │ │ │ ├── until.diffB-A.txt │ │ │ ├── until.parseA.txt │ │ │ ├── until.parseB.txt │ │ │ ├── when-else.A.rb │ │ │ ├── when-else.B.rb │ │ │ ├── when-else.diffA-B.txt │ │ │ ├── when-else.diffB-A.txt │ │ │ ├── when-else.parseA.txt │ │ │ ├── when-else.parseB.txt │ │ │ ├── when.A.rb │ │ │ ├── when.B.rb │ │ │ ├── when.diffA-B.txt │ │ │ ├── when.diffB-A.txt │ │ │ ├── when.parseA.txt │ │ │ ├── when.parseB.txt │ │ │ ├── while.A.rb │ │ │ ├── while.B.rb │ │ │ ├── while.diffA-B.txt │ │ │ ├── while.diffB-A.txt │ │ │ ├── while.parseA.txt │ │ │ ├── while.parseB.txt │ │ │ ├── yield.A.rb │ │ │ ├── yield.B.rb │ │ │ ├── yield.diffA-B.txt │ │ │ ├── yield.diffB-A.txt │ │ │ ├── yield.parseA.txt │ │ │ └── yield.parseB.txt │ │ ├── import-graph/ │ │ │ ├── app.json │ │ │ └── app.rb │ │ ├── reprinting/ │ │ │ ├── function.out.rb │ │ │ ├── function.rb │ │ │ └── infix.rb │ │ ├── tags/ │ │ │ ├── class_module.rb │ │ │ ├── simple_method.rb │ │ │ ├── simple_method_with_docs.rb │ │ │ └── unicode_identifiers.rb │ │ └── toc/ │ │ ├── classes.A.rb │ │ ├── classes.B.rb │ │ ├── lambda.A.rb │ │ ├── lambda.B.rb │ │ ├── method-starts-with-two-identifiers.A.rb │ │ ├── method-starts-with-two-identifiers.B.rb │ │ ├── methods.A.rb │ │ ├── methods.B.rb │ │ ├── methods.X.rb │ │ ├── unicode.A.rb │ │ └── unicode.B.rb │ ├── tsx/ │ │ └── corpus/ │ │ ├── jsx-elements.A.tsx │ │ ├── jsx-elements.B.tsx │ │ ├── jsx-elements.diffA-B.txt │ │ ├── jsx-elements.diffB-A.txt │ │ ├── jsx-elements.parseA.txt │ │ └── jsx-elements.parseB.txt │ └── typescript/ │ ├── analysis/ │ │ ├── .gitignore │ │ ├── a.ts │ │ ├── access_control/ │ │ │ ├── adder.ts │ │ │ ├── private_field_definition.ts │ │ │ ├── private_method.ts │ │ │ └── private_static_field_definition.ts │ │ ├── await.ts │ │ ├── bad-export.ts │ │ ├── band.ts │ │ ├── baz.ts │ │ ├── bor.ts │ │ ├── bxor.ts │ │ ├── class1.ts │ │ ├── class2.ts │ │ ├── complement.ts │ │ ├── delete.ts │ │ ├── early-return.ts │ │ ├── foo/ │ │ │ └── b.ts │ │ ├── foo.ts │ │ ├── foo2.ts │ │ ├── lshift.ts │ │ ├── main.ts │ │ ├── main1.ts │ │ ├── main2.ts │ │ ├── main3.ts │ │ ├── main4.ts │ │ ├── main5.ts │ │ ├── main6.ts │ │ ├── main7.ts │ │ ├── pip.ts │ │ ├── rshift.ts │ │ ├── sequence-expression.ts │ │ ├── unsignedrshift.ts │ │ └── void.ts │ ├── corpus/ │ │ ├── ambient-declarations.A.ts │ │ ├── ambient-declarations.B.ts │ │ ├── ambient-declarations.diffA-B.txt │ │ ├── ambient-declarations.diffB-A.txt │ │ ├── ambient-declarations.parseA.txt │ │ ├── ambient-declarations.parseB.txt │ │ ├── ambient-exports.A.ts │ │ ├── ambient-exports.B.ts │ │ ├── ambient-exports.diffA-B.txt │ │ ├── ambient-exports.diffB-A.txt │ │ ├── ambient-exports.parseA.txt │ │ ├── ambient-exports.parseB.txt │ │ ├── ambient-type-declarations.A.ts │ │ ├── ambient-type-declarations.B.ts │ │ ├── ambient-type-declarations.diffA-B.txt │ │ ├── ambient-type-declarations.diffB-A.txt │ │ ├── ambient-type-declarations.parseA.txt │ │ ├── ambient-type-declarations.parseB.txt │ │ ├── anonymous-function.A.ts │ │ ├── anonymous-function.B.ts │ │ ├── anonymous-function.diffA-B.txt │ │ ├── anonymous-function.diffB-A.txt │ │ ├── anonymous-function.parseA.txt │ │ ├── anonymous-function.parseB.txt │ │ ├── anonymous-parameterless-function.A.ts │ │ ├── anonymous-parameterless-function.B.ts │ │ ├── anonymous-parameterless-function.diffA-B.txt │ │ ├── anonymous-parameterless-function.diffB-A.txt │ │ ├── anonymous-parameterless-function.parseA.txt │ │ ├── anonymous-parameterless-function.parseB.txt │ │ ├── array-type.A.ts │ │ ├── array-type.B.ts │ │ ├── array-type.diffA-B.txt │ │ ├── array-type.diffB-A.txt │ │ ├── array-type.parseA.txt │ │ ├── array-type.parseB.txt │ │ ├── array.A.ts │ │ ├── array.B.ts │ │ ├── array.diffA-B.txt │ │ ├── array.diffB-A.txt │ │ ├── array.parseA.txt │ │ ├── array.parseB.txt │ │ ├── arrow-function.A.ts │ │ ├── arrow-function.B.ts │ │ ├── arrow-function.diffA-B.txt │ │ ├── arrow-function.diffB-A.txt │ │ ├── arrow-function.parseA.txt │ │ ├── arrow-function.parseB.txt │ │ ├── assignment-pattern.A.ts │ │ ├── assignment-pattern.B.ts │ │ ├── assignment-pattern.diffA-B.txt │ │ ├── assignment-pattern.diffB-A.txt │ │ ├── assignment-pattern.parseA.txt │ │ ├── assignment-pattern.parseB.txt │ │ ├── assignment.A.ts │ │ ├── assignment.B.ts │ │ ├── assignment.diffA-B.txt │ │ ├── assignment.diffB-A.txt │ │ ├── assignment.parseA.txt │ │ ├── assignment.parseB.txt │ │ ├── bitwise-operator.A.ts │ │ ├── bitwise-operator.B.ts │ │ ├── bitwise-operator.diffA-B.txt │ │ ├── bitwise-operator.diffB-A.txt │ │ ├── bitwise-operator.parseA.txt │ │ ├── bitwise-operator.parseB.txt │ │ ├── boolean-operator.A.ts │ │ ├── boolean-operator.B.ts │ │ ├── boolean-operator.diffA-B.txt │ │ ├── boolean-operator.diffB-A.txt │ │ ├── boolean-operator.parseA.txt │ │ ├── boolean-operator.parseB.txt │ │ ├── break.A.ts │ │ ├── break.B.ts │ │ ├── break.diffA-B.txt │ │ ├── break.diffB-A.txt │ │ ├── break.parseA.txt │ │ ├── break.parseB.txt │ │ ├── chained-callbacks.A.ts │ │ ├── chained-callbacks.B.ts │ │ ├── chained-callbacks.diffA-B.txt │ │ ├── chained-callbacks.diffB-A.txt │ │ ├── chained-callbacks.parseA.txt │ │ ├── chained-callbacks.parseB.txt │ │ ├── chained-property-access.A.ts │ │ ├── chained-property-access.B.ts │ │ ├── chained-property-access.diffA-B.txt │ │ ├── chained-property-access.diffB-A.txt │ │ ├── chained-property-access.parseA.txt │ │ ├── chained-property-access.parseB.txt │ │ ├── class.A.ts │ │ ├── class.B.ts │ │ ├── class.diffA-B.txt │ │ ├── class.diffB-A.txt │ │ ├── class.parseA.txt │ │ ├── class.parseB.txt │ │ ├── comma-operator.A.ts │ │ ├── comma-operator.B.ts │ │ ├── comma-operator.diffA-B.txt │ │ ├── comma-operator.diffB-A.txt │ │ ├── comma-operator.parseA.txt │ │ ├── comma-operator.parseB.txt │ │ ├── comment.A.ts │ │ ├── comment.B.ts │ │ ├── comment.diffA-B.txt │ │ ├── comment.diffB-A.txt │ │ ├── comment.parseA.txt │ │ ├── comment.parseB.txt │ │ ├── constructor-call.A.ts │ │ ├── constructor-call.B.ts │ │ ├── constructor-call.diffA-B.txt │ │ ├── constructor-call.diffB-A.txt │ │ ├── constructor-call.parseA.txt │ │ ├── constructor-call.parseB.txt │ │ ├── continue.A.ts │ │ ├── continue.B.ts │ │ ├── continue.diffA-B.txt │ │ ├── continue.diffB-A.txt │ │ ├── continue.parseA.txt │ │ ├── continue.parseB.txt │ │ ├── delete-operator.A.ts │ │ ├── delete-operator.B.ts │ │ ├── delete-operator.diffA-B.txt │ │ ├── delete-operator.diffB-A.txt │ │ ├── delete-operator.parseA.txt │ │ ├── delete-operator.parseB.txt │ │ ├── do-while-statement.A.ts │ │ ├── do-while-statement.B.ts │ │ ├── do-while-statement.diffA-B.txt │ │ ├── do-while-statement.diffB-A.txt │ │ ├── do-while-statement.parseA.txt │ │ ├── do-while-statement.parseB.txt │ │ ├── export-assignments.A.ts │ │ ├── export-assignments.B.ts │ │ ├── export-assignments.diffA-B.txt │ │ ├── export-assignments.diffB-A.txt │ │ ├── export-assignments.parseA.txt │ │ ├── export-assignments.parseB.txt │ │ ├── export.A.ts │ │ ├── export.B.ts │ │ ├── export.diffA-B.txt │ │ ├── export.diffB-A.txt │ │ ├── export.parseA.txt │ │ ├── export.parseB.txt │ │ ├── false.A.ts │ │ ├── false.B.ts │ │ ├── false.diffA-B.txt │ │ ├── false.diffB-A.txt │ │ ├── false.parseA.txt │ │ ├── false.parseB.txt │ │ ├── for-in-statement.A.ts │ │ ├── for-in-statement.B.ts │ │ ├── for-in-statement.diffA-B.txt │ │ ├── for-in-statement.diffB-A.txt │ │ ├── for-in-statement.parseA.txt │ │ ├── for-in-statement.parseB.txt │ │ ├── for-loop-with-in-statement.A.ts │ │ ├── for-loop-with-in-statement.B.ts │ │ ├── for-loop-with-in-statement.diffA-B.txt │ │ ├── for-loop-with-in-statement.diffB-A.txt │ │ ├── for-loop-with-in-statement.parseA.txt │ │ ├── for-loop-with-in-statement.parseB.txt │ │ ├── for-of-statement.A.ts │ │ ├── for-of-statement.B.ts │ │ ├── for-of-statement.diffA-B.txt │ │ ├── for-of-statement.diffB-A.txt │ │ ├── for-of-statement.parseA.txt │ │ ├── for-of-statement.parseB.txt │ │ ├── for-statement.A.ts │ │ ├── for-statement.B.ts │ │ ├── for-statement.diffA-B.txt │ │ ├── for-statement.diffB-A.txt │ │ ├── for-statement.parseA.txt │ │ ├── for-statement.parseB.txt │ │ ├── function-call-args.A.ts │ │ ├── function-call-args.B.ts │ │ ├── function-call-args.diffA-B.txt │ │ ├── function-call-args.diffB-A.txt │ │ ├── function-call-args.parseA.txt │ │ ├── function-call-args.parseB.txt │ │ ├── function-call.A.ts │ │ ├── function-call.B.ts │ │ ├── function-call.diffA-B.txt │ │ ├── function-call.diffB-A.txt │ │ ├── function-call.parseA.txt │ │ ├── function-call.parseB.txt │ │ ├── function-type.A.ts │ │ ├── function-type.B.ts │ │ ├── function-type.diffA-B.txt │ │ ├── function-type.diffB-A.txt │ │ ├── function-type.parseA.txt │ │ ├── function-type.parseB.txt │ │ ├── function.A.ts │ │ ├── function.B.ts │ │ ├── function.diffA-B.txt │ │ ├── function.diffB-A.txt │ │ ├── function.parseA.txt │ │ ├── function.parseB.txt │ │ ├── generator-function.A.ts │ │ ├── generator-function.B.ts │ │ ├── generator-function.diffA-B.txt │ │ ├── generator-function.diffB-A.txt │ │ ├── generator-function.parseA.txt │ │ ├── generator-function.parseB.txt │ │ ├── identifier.A.ts │ │ ├── identifier.B.ts │ │ ├── identifier.diffA-B.txt │ │ ├── identifier.diffB-A.txt │ │ ├── identifier.parseA.txt │ │ ├── identifier.parseB.txt │ │ ├── if-else.A.ts │ │ ├── if-else.B.ts │ │ ├── if-else.diffA-B.txt │ │ ├── if-else.diffB-A.txt │ │ ├── if-else.parseA.txt │ │ ├── if-else.parseB.txt │ │ ├── if.A.ts │ │ ├── if.B.ts │ │ ├── if.diffA-B.txt │ │ ├── if.diffB-A.txt │ │ ├── if.parseA.txt │ │ ├── if.parseB.txt │ │ ├── import.A.ts │ │ ├── import.B.ts │ │ ├── import.diffA-B.txt │ │ ├── import.diffB-A.txt │ │ ├── import.parseA.txt │ │ ├── import.parseB.txt │ │ ├── interface.A.ts │ │ ├── interface.B.ts │ │ ├── interface.diffA-B.txt │ │ ├── interface.diffB-A.txt │ │ ├── interface.parseA.txt │ │ ├── interface.parseB.txt │ │ ├── intersection-type.A.ts │ │ ├── intersection-type.B.ts │ │ ├── intersection-type.diffA-B.txt │ │ ├── intersection-type.diffB-A.txt │ │ ├── intersection-type.parseA.txt │ │ ├── intersection-type.parseB.txt │ │ ├── math-assignment-operator.A.ts │ │ ├── math-assignment-operator.B.ts │ │ ├── math-assignment-operator.diffA-B.txt │ │ ├── math-assignment-operator.diffB-A.txt │ │ ├── math-assignment-operator.parseA.txt │ │ ├── math-assignment-operator.parseB.txt │ │ ├── math-operator.A.ts │ │ ├── math-operator.B.ts │ │ ├── math-operator.diffA-B.txt │ │ ├── math-operator.diffB-A.txt │ │ ├── math-operator.parseA.txt │ │ ├── math-operator.parseB.txt │ │ ├── member-access-assignment.A.ts │ │ ├── member-access-assignment.B.ts │ │ ├── member-access-assignment.diffA-B.txt │ │ ├── member-access-assignment.diffB-A.txt │ │ ├── member-access-assignment.parseA.txt │ │ ├── member-access-assignment.parseB.txt │ │ ├── member-access.A.ts │ │ ├── member-access.B.ts │ │ ├── member-access.diffA-B.txt │ │ ├── member-access.diffB-A.txt │ │ ├── member-access.parseA.txt │ │ ├── member-access.parseB.txt │ │ ├── method-call.A.ts │ │ ├── method-call.B.ts │ │ ├── method-call.diffA-B.txt │ │ ├── method-call.diffB-A.txt │ │ ├── method-call.parseA.txt │ │ ├── method-call.parseB.txt │ │ ├── method-definition.A.ts │ │ ├── method-definition.B.ts │ │ ├── method-definition.diffA-B.txt │ │ ├── method-definition.diffB-A.txt │ │ ├── method-definition.parseA.txt │ │ ├── method-definition.parseB.txt │ │ ├── module-declarations.A.ts │ │ ├── module-declarations.B.ts │ │ ├── module-declarations.diffA-B.txt │ │ ├── module-declarations.diffB-A.txt │ │ ├── module-declarations.parseA.txt │ │ ├── module-declarations.parseB.txt │ │ ├── named-function.A.ts │ │ ├── named-function.B.ts │ │ ├── named-function.diffA-B.txt │ │ ├── named-function.diffB-A.txt │ │ ├── named-function.parseA.txt │ │ ├── named-function.parseB.txt │ │ ├── nested-do-while-in-function.A.ts │ │ ├── nested-do-while-in-function.B.ts │ │ ├── nested-do-while-in-function.diffA-B.txt │ │ ├── nested-do-while-in-function.diffB-A.txt │ │ ├── nested-do-while-in-function.parseA.txt │ │ ├── nested-do-while-in-function.parseB.txt │ │ ├── nested-functions.A.ts │ │ ├── nested-functions.B.ts │ │ ├── nested-functions.diffA-B.txt │ │ ├── nested-functions.diffB-A.txt │ │ ├── nested-functions.parseA.txt │ │ ├── nested-functions.parseB.txt │ │ ├── null.A.ts │ │ ├── null.B.ts │ │ ├── null.diffA-B.txt │ │ ├── null.diffB-A.txt │ │ ├── null.parseA.txt │ │ ├── null.parseB.txt │ │ ├── number.A.ts │ │ ├── number.B.ts │ │ ├── number.diffA-B.txt │ │ ├── number.diffB-A.txt │ │ ├── number.parseA.txt │ │ ├── number.parseB.txt │ │ ├── object.A.ts │ │ ├── object.B.ts │ │ ├── object.diffA-B.txt │ │ ├── object.diffB-A.txt │ │ ├── object.parseA.txt │ │ ├── object.parseB.txt │ │ ├── objects-with-methods.A.ts │ │ ├── objects-with-methods.B.ts │ │ ├── objects-with-methods.diffA-B.txt │ │ ├── objects-with-methods.diffB-A.txt │ │ ├── objects-with-methods.parseA.txt │ │ ├── objects-with-methods.parseB.txt │ │ ├── public-field-definition.A.ts │ │ ├── public-field-definition.B.ts │ │ ├── public-field-definition.diffA-B.txt │ │ ├── public-field-definition.diffB-A.txt │ │ ├── public-field-definition.parseA.txt │ │ ├── public-field-definition.parseB.txt │ │ ├── regex.A.ts │ │ ├── regex.B.ts │ │ ├── regex.diffA-B.txt │ │ ├── regex.diffB-A.txt │ │ ├── regex.parseA.txt │ │ ├── regex.parseB.txt │ │ ├── relational-operator.A.ts │ │ ├── relational-operator.B.ts │ │ ├── relational-operator.diffA-B.txt │ │ ├── relational-operator.diffB-A.txt │ │ ├── relational-operator.parseA.txt │ │ ├── relational-operator.parseB.txt │ │ ├── return-statement.A.ts │ │ ├── return-statement.B.ts │ │ ├── return-statement.diffA-B.txt │ │ ├── return-statement.diffB-A.txt │ │ ├── return-statement.parseA.txt │ │ ├── return-statement.parseB.txt │ │ ├── string.A.ts │ │ ├── string.B.ts │ │ ├── string.diffA-B.txt │ │ ├── string.diffB-A.txt │ │ ├── string.parseA.txt │ │ ├── string.parseB.txt │ │ ├── subscript-access-assignment.A.ts │ │ ├── subscript-access-assignment.B.ts │ │ ├── subscript-access-assignment.diffA-B.txt │ │ ├── subscript-access-assignment.diffB-A.txt │ │ ├── subscript-access-assignment.parseA.txt │ │ ├── subscript-access-assignment.parseB.txt │ │ ├── subscript-access-string.A.ts │ │ ├── subscript-access-string.B.ts │ │ ├── subscript-access-string.diffA-B.txt │ │ ├── subscript-access-string.diffB-A.txt │ │ ├── subscript-access-string.parseA.txt │ │ ├── subscript-access-string.parseB.txt │ │ ├── subscript-access-variable.A.ts │ │ ├── subscript-access-variable.B.ts │ │ ├── subscript-access-variable.diffA-B.txt │ │ ├── subscript-access-variable.diffB-A.txt │ │ ├── subscript-access-variable.parseA.txt │ │ ├── subscript-access-variable.parseB.txt │ │ ├── switch-statement.A.ts │ │ ├── switch-statement.B.ts │ │ ├── switch-statement.diffA-B.txt │ │ ├── switch-statement.diffB-A.txt │ │ ├── switch-statement.parseA.txt │ │ ├── switch-statement.parseB.txt │ │ ├── template-string.A.ts │ │ ├── template-string.B.ts │ │ ├── template-string.diffA-B.txt │ │ ├── template-string.diffB-A.txt │ │ ├── template-string.parseA.txt │ │ ├── template-string.parseB.txt │ │ ├── ternary.A.ts │ │ ├── ternary.B.ts │ │ ├── ternary.diffA-B.txt │ │ ├── ternary.diffB-A.txt │ │ ├── ternary.parseA.txt │ │ ├── ternary.parseB.txt │ │ ├── this-expression.A.ts │ │ ├── this-expression.B.ts │ │ ├── this-expression.diffA-B.txt │ │ ├── this-expression.diffB-A.txt │ │ ├── this-expression.parseA.txt │ │ ├── this-expression.parseB.txt │ │ ├── throw-statement.A.ts │ │ ├── throw-statement.B.ts │ │ ├── throw-statement.diffA-B.txt │ │ ├── throw-statement.diffB-A.txt │ │ ├── throw-statement.parseA.txt │ │ ├── throw-statement.parseB.txt │ │ ├── true.A.ts │ │ ├── true.B.ts │ │ ├── true.diffA-B.txt │ │ ├── true.diffB-A.txt │ │ ├── true.parseA.txt │ │ ├── true.parseB.txt │ │ ├── try-statement.A.ts │ │ ├── try-statement.B.ts │ │ ├── try-statement.diffA-B.txt │ │ ├── try-statement.diffB-A.txt │ │ ├── try-statement.parseA.txt │ │ ├── try-statement.parseB.txt │ │ ├── tuple-type.A.ts │ │ ├── tuple-type.B.ts │ │ ├── tuple-type.diffA-B.txt │ │ ├── tuple-type.diffB-A.txt │ │ ├── tuple-type.parseA.txt │ │ ├── tuple-type.parseB.txt │ │ ├── type-assertions.A.ts │ │ ├── type-assertions.B.ts │ │ ├── type-assertions.diffA-B.txt │ │ ├── type-assertions.diffB-A.txt │ │ ├── type-assertions.parseA.txt │ │ ├── type-assertions.parseB.txt │ │ ├── type-operator.A.ts │ │ ├── type-operator.B.ts │ │ ├── type-operator.diffA-B.txt │ │ ├── type-operator.diffB-A.txt │ │ ├── type-operator.parseA.txt │ │ ├── type-operator.parseB.txt │ │ ├── typeof-types.A.ts │ │ ├── typeof-types.B.ts │ │ ├── typeof-types.diffA-B.txt │ │ ├── typeof-types.diffB-A.txt │ │ ├── typeof-types.parseA.txt │ │ ├── typeof-types.parseB.txt │ │ ├── undefined.A.ts │ │ ├── undefined.B.ts │ │ ├── undefined.diffA-B.txt │ │ ├── undefined.diffB-A.txt │ │ ├── undefined.parseA.txt │ │ ├── undefined.parseB.txt │ │ ├── union-type.A.ts │ │ ├── union-type.B.ts │ │ ├── union-type.diffA-B.txt │ │ ├── union-type.diffB-A.txt │ │ ├── union-type.parseA.txt │ │ ├── union-type.parseB.txt │ │ ├── var-declaration.A.ts │ │ ├── var-declaration.B.ts │ │ ├── var-declaration.diffA-B.txt │ │ ├── var-declaration.diffB-A.txt │ │ ├── var-declaration.parseA.txt │ │ ├── var-declaration.parseB.txt │ │ ├── variable.A.ts │ │ ├── variable.B.ts │ │ ├── variable.diffA-B.txt │ │ ├── variable.diffB-A.txt │ │ ├── variable.parseA.txt │ │ ├── variable.parseB.txt │ │ ├── void-operator.A.ts │ │ ├── void-operator.B.ts │ │ ├── void-operator.diffA-B.txt │ │ ├── void-operator.diffB-A.txt │ │ ├── void-operator.parseA.txt │ │ ├── void-operator.parseB.txt │ │ ├── while-statement.A.ts │ │ ├── while-statement.B.ts │ │ ├── while-statement.diffA-B.txt │ │ ├── while-statement.diffB-A.txt │ │ ├── while-statement.parseA.txt │ │ ├── while-statement.parseB.txt │ │ ├── yield.A.ts │ │ ├── yield.B.ts │ │ ├── yield.diffA-B.txt │ │ ├── yield.diffB-A.txt │ │ ├── yield.parseA.txt │ │ └── yield.parseB.txt │ ├── import-graph/ │ │ ├── app.json │ │ └── app.ts │ └── tags/ │ ├── class.ts │ └── module.ts ├── semantic-analysis/ │ ├── .ghci.repl │ ├── .gitignore │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── cabal.project │ ├── hie.yaml │ ├── python.tsg │ ├── script/ │ │ ├── ghci-flags │ │ └── repl │ ├── semantic-analysis.cabal │ └── src/ │ └── Analysis/ │ ├── Analysis/ │ │ ├── Concrete.hs │ │ ├── DeadCode.hs │ │ ├── Exception.hs │ │ └── Typecheck.hs │ ├── Blob.hs │ ├── Carrier/ │ │ ├── Env/ │ │ │ ├── Monovariant.hs │ │ │ └── Precise.hs │ │ ├── Fail/ │ │ │ └── WithLoc.hs │ │ ├── Statement/ │ │ │ └── State.hs │ │ └── Store/ │ │ ├── Monovariant.hs │ │ └── Precise.hs │ ├── Data/ │ │ └── Snoc.hs │ ├── Effect/ │ │ ├── Domain.hs │ │ ├── Env.hs │ │ ├── Statement.hs │ │ └── Store.hs │ ├── File.hs │ ├── FlowInsensitive.hs │ ├── Functor/ │ │ └── Named.hs │ ├── Module.hs │ ├── Name.hs │ ├── Project.hs │ ├── Reference.hs │ ├── Syntax/ │ │ └── Python.hs │ ├── Syntax.hs │ └── VM.hs ├── semantic-ast/ │ ├── BUILD.bazel │ ├── CHANGELOG.md │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── app/ │ │ └── Main.hs │ ├── semantic-ast.cabal │ └── src/ │ ├── AST/ │ │ ├── Deserialize.hs │ │ ├── Element.hs │ │ ├── GenerateSyntax.hs │ │ ├── Grammar/ │ │ │ ├── Examples.hs │ │ │ └── TH.hs │ │ ├── Marshal/ │ │ │ └── JSON.hs │ │ ├── Parse.hs │ │ ├── TestHelpers.hs │ │ ├── Token.hs │ │ ├── Traversable1/ │ │ │ └── Class.hs │ │ ├── Traversable1.hs │ │ └── Unmarshal.hs │ └── System/ │ └── Path/ │ └── Fixture.hs ├── semantic-codeql/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-codeql.cabal │ ├── src/ │ │ └── Language/ │ │ ├── CodeQL/ │ │ │ ├── AST.hs │ │ │ ├── Grammar.hs │ │ │ └── Tags.hs │ │ └── CodeQL.hs │ └── test/ │ └── PreciseTest.hs ├── semantic-go/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-go.cabal │ ├── src/ │ │ └── Language/ │ │ ├── Go/ │ │ │ ├── AST.hs │ │ │ ├── Grammar.hs │ │ │ └── Tags.hs │ │ └── Go.hs │ └── test/ │ └── PreciseTest.hs ├── semantic-java/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-java.cabal │ ├── src/ │ │ └── Language/ │ │ ├── Java/ │ │ │ ├── AST.hs │ │ │ ├── Grammar.hs │ │ │ └── Tags.hs │ │ └── Java.hs │ └── test/ │ └── PreciseTest.hs ├── semantic-json/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-json.cabal │ ├── src/ │ │ └── Language/ │ │ ├── JSON/ │ │ │ ├── AST.hs │ │ │ └── Grammar.hs │ │ └── JSON.hs │ └── test/ │ └── PreciseTest.hs ├── semantic-parse/ │ ├── BUILD.bazel │ ├── CHANGELOG.md │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── app/ │ │ └── Main.hs │ └── semantic-parse.cabal ├── semantic-php/ │ ├── BUILD.bazel │ ├── CHANGELOG.md │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-php.cabal │ └── src/ │ └── Language/ │ ├── PHP/ │ │ ├── AST.hs │ │ ├── Grammar.hs │ │ └── Tags.hs │ └── PHP.hs ├── semantic-proto/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-proto.cabal │ └── src/ │ └── Proto/ │ ├── Semantic.hs │ ├── Semantic_Fields.hs │ └── Semantic_JSON.hs ├── semantic-python/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── bench/ │ │ └── Bench.hs │ ├── semantic-python.cabal │ ├── src/ │ │ ├── Language/ │ │ │ ├── Python/ │ │ │ │ ├── AST.hs │ │ │ │ ├── Core.hs │ │ │ │ ├── Failure.hs │ │ │ │ ├── Grammar.hs │ │ │ │ ├── Patterns.hs │ │ │ │ ├── ScopeGraph.hs │ │ │ │ └── Tags.hs │ │ │ └── Python.hs │ │ └── Prelude.score │ ├── test/ │ │ ├── CoreTest.hs │ │ ├── Directive.hs │ │ ├── Instances.hs │ │ ├── PreciseTest.hs │ │ └── fixtures/ │ │ ├── 1-01-empty-module.py │ │ ├── 1-02-pass-statement.py │ │ ├── 1-03-empty-tuple.py │ │ ├── 1-04-toplevel-assignment.py │ │ ├── 1-05-exec-statement-fails.py │ │ ├── 2-01-return-statement.py │ │ ├── 2-02-return-doesnt-translate.py │ │ ├── 2-03-return-in-if-statement.py │ │ ├── 2-04-multiple-assign.py │ │ ├── 2-05-function-call.py │ │ ├── 2-06-nested-function-definition.py │ │ ├── 2-07-closure-over-scope.py │ │ ├── 2-08-function-decorator.py │ │ ├── 3-01-empty-class-definition.py │ │ ├── 3-02-defining-instance-method.py │ │ ├── 3-03-functions-know-their-own-names.py │ │ ├── 4-01-lambda-literals.py │ │ ├── 4-02-nonetype.py │ │ ├── 4-03-not-expression.py │ │ ├── 5-01-simple-reference.py │ │ ├── 5-02-simple-function.py │ │ ├── 5-03-function-argument.py │ │ └── cheese/ │ │ ├── 6-01-imports.py │ │ ├── 6-01-qualified-imports.py │ │ └── ints.py │ └── test-graphing/ │ └── GraphTest.hs ├── semantic-ruby/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── app/ │ │ └── Main.hs │ ├── bench/ │ │ ├── Main.hs │ │ └── Parsing.hs │ ├── semantic-ruby.cabal │ ├── src/ │ │ └── Language/ │ │ ├── Ruby/ │ │ │ ├── AST.hs │ │ │ ├── Grammar.hs │ │ │ └── Tags.hs │ │ └── Ruby.hs │ └── test/ │ └── PreciseTest.hs ├── semantic-rust/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-rust.cabal │ ├── src/ │ │ └── Language/ │ │ ├── Rust/ │ │ │ ├── AST.hs │ │ │ ├── Grammar.hs │ │ │ └── Tags.hs │ │ └── Rust.hs │ └── test/ │ └── Test.hs ├── semantic-scope-graph/ │ ├── BUILD.bazel │ ├── CHANGELOG.md │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-scope-graph.cabal │ └── src/ │ ├── Control/ │ │ ├── Carrier/ │ │ │ └── Sketch/ │ │ │ └── ScopeGraph.hs │ │ └── Effect/ │ │ ├── ScopeGraph/ │ │ │ └── Properties/ │ │ │ ├── Declaration.hs │ │ │ ├── Function.hs │ │ │ └── Reference.hs │ │ └── ScopeGraph.hs │ ├── Data/ │ │ ├── Hole.hs │ │ ├── Module.hs │ │ └── ScopeGraph.hs │ └── Scope/ │ ├── Graph/ │ │ ├── AdjacencyList.hs │ │ └── Convert.hs │ ├── Info.hs │ ├── Path.hs │ ├── Reference.hs │ ├── Scope.hs │ └── Types.hs ├── semantic-source/ │ ├── BUILD.bazel │ ├── CHANGELOG.md │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── cabal.project │ ├── cabal.project.ci │ ├── semantic-source.cabal │ ├── src/ │ │ └── Source/ │ │ ├── Language.hs │ │ ├── Loc.hs │ │ ├── Range.hs │ │ ├── Source.hs │ │ └── Span.hs │ └── test/ │ ├── Range/ │ │ └── Test.hs │ ├── Source/ │ │ └── Test.hs │ └── Test.hs ├── semantic-tags/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-tags.cabal │ ├── src/ │ │ └── Tags/ │ │ ├── Tag.hs │ │ └── Tagging/ │ │ └── Precise.hs │ └── test/ │ └── Test.hs ├── semantic-tsx/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-tsx.cabal │ ├── src/ │ │ └── Language/ │ │ ├── TSX/ │ │ │ ├── AST.hs │ │ │ ├── Grammar.hs │ │ │ └── Tags.hs │ │ └── TSX.hs │ └── test/ │ └── PreciseTest.hs ├── semantic-typescript/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-typescript.cabal │ ├── src/ │ │ └── Language/ │ │ ├── TypeScript/ │ │ │ ├── AST.hs │ │ │ ├── Grammar.hs │ │ │ └── Tags.hs │ │ └── TypeScript.hs │ └── test/ │ └── PreciseTest.hs ├── stack-snapshot.yaml └── stackage_snapshot.json