yarp 0.12.0 → 0.13.0

data/docs/mapping.md

@@ -1,117 +1,117 @@
 # Mapping
 
-When considering the previous CRuby parser versus YARP, this document should be helpful to understand how various concepts are mapped.
+When considering the previous CRuby parser versus prism, this document should be helpful to understand how various concepts are mapped.
 
 ## Nodes
 
-The following table shows how the various CRuby nodes are mapped to YARP nodes.
+The following table shows how the various CRuby nodes are mapped to prism nodes.
 
-| CRuby | YARP |
+| CRuby | prism |
 | --- | --- |
 | `NODE_SCOPE` | |
 | `NODE_BLOCK` | |
-| `NODE_IF` | `YP_IF_NODE` |
-| `NODE_UNLESS` | `YP_UNLESS_NODE` |
-| `NODE_CASE` | `YP_CASE_NODE` |
-| `NODE_CASE2` | `YP_CASE_NODE` (with a null predicate) |
+| `NODE_IF` | `PM_IF_NODE` |
+| `NODE_UNLESS` | `PM_UNLESS_NODE` |
+| `NODE_CASE` | `PM_CASE_NODE` |
+| `NODE_CASE2` | `PM_CASE_NODE` (with a null predicate) |
 | `NODE_CASE3` | |
-| `NODE_WHEN` | `YP_WHEN_NODE` |
-| `NODE_IN` | `YP_IN_NODE` |
-| `NODE_WHILE` | `YP_WHILE_NODE` |
-| `NODE_UNTIL` | `YP_UNTIL_NODE` |
-| `NODE_ITER` | `YP_CALL_NODE` (with a non-null block) |
-| `NODE_FOR` | `YP_FOR_NODE` |
-| `NODE_FOR_MASGN` | `YP_FOR_NODE` (with a multi-write node as the index) |
-| `NODE_BREAK` | `YP_BREAK_NODE` |
-| `NODE_NEXT` | `YP_NEXT_NODE` |
-| `NODE_REDO` | `YP_REDO_NODE` |
-| `NODE_RETRY` | `YP_RETRY_NODE` |
-| `NODE_BEGIN` | `YP_BEGIN_NODE` |
-| `NODE_RESCUE` | `YP_RESCUE_NODE` |
+| `NODE_WHEN` | `PM_WHEN_NODE` |
+| `NODE_IN` | `PM_IN_NODE` |
+| `NODE_WHILE` | `PM_WHILE_NODE` |
+| `NODE_UNTIL` | `PM_UNTIL_NODE` |
+| `NODE_ITER` | `PM_CALL_NODE` (with a non-null block) |
+| `NODE_FOR` | `PM_FOR_NODE` |
+| `NODE_FOR_MASGN` | `PM_FOR_NODE` (with a multi-write node as the index) |
+| `NODE_BREAK` | `PM_BREAK_NODE` |
+| `NODE_NEXT` | `PM_NEXT_NODE` |
+| `NODE_REDO` | `PM_REDO_NODE` |
+| `NODE_RETRY` | `PM_RETRY_NODE` |
+| `NODE_BEGIN` | `PM_BEGIN_NODE` |
+| `NODE_RESCUE` | `PM_RESCUE_NODE` |
 | `NODE_RESBODY` | |
-| `NODE_ENSURE` | `YP_ENSURE_NODE` |
-| `NODE_AND` | `YP_AND_NODE` |
-| `NODE_OR` | `YP_OR_NODE` |
-| `NODE_MASGN` | `YP_MULTI_WRITE_NODE` |
-| `NODE_LASGN` | `YP_LOCAL_VARIABLE_WRITE_NODE` |
-| `NODE_DASGN` | `YP_LOCAL_VARIABLE_WRITE_NODE` |
-| `NODE_GASGN` | `YP_GLOBAL_VARIABLE_WRITE_NODE` |
-| `NODE_IASGN` | `YP_INSTANCE_VARIABLE_WRITE_NODE` |
-| `NODE_CDECL` | `YP_CONSTANT_PATH_WRITE_NODE` |
-| `NODE_CVASGN` | `YP_CLASS_VARIABLE_WRITE_NODE` |
+| `NODE_ENSURE` | `PM_ENSURE_NODE` |
+| `NODE_AND` | `PM_AND_NODE` |
+| `NODE_OR` | `PM_OR_NODE` |
+| `NODE_MASGN` | `PM_MULTI_WRITE_NODE` |
+| `NODE_LASGN` | `PM_LOCAL_VARIABLE_WRITE_NODE` |
+| `NODE_DASGN` | `PM_LOCAL_VARIABLE_WRITE_NODE` |
+| `NODE_GASGN` | `PM_GLOBAL_VARIABLE_WRITE_NODE` |
+| `NODE_IASGN` | `PM_INSTANCE_VARIABLE_WRITE_NODE` |
+| `NODE_CDECL` | `PM_CONSTANT_PATH_WRITE_NODE` |
+| `NODE_CVASGN` | `PM_CLASS_VARIABLE_WRITE_NODE` |
 | `NODE_OP_ASGN1` | |
 | `NODE_OP_ASGN2` | |
-| `NODE_OP_ASGN_AND` | `YP_OPERATOR_AND_ASSIGNMENT_NODE` |
-| `NODE_OP_ASGN_OR` | `YP_OPERATOR_OR_ASSIGNMENT_NODE` |
+| `NODE_OP_ASGN_AND` | `PM_OPERATOR_AND_ASSIGNMENT_NODE` |
+| `NODE_OP_ASGN_OR` | `PM_OPERATOR_OR_ASSIGNMENT_NODE` |
 | `NODE_OP_CDECL` | |
-| `NODE_CALL` | `YP_CALL_NODE` |
-| `NODE_OPCALL` | `YP_CALL_NODE` (with an operator as the method) |
-| `NODE_FCALL` | `YP_CALL_NODE` (with a null receiver and parentheses) |
-| `NODE_VCALL` | `YP_CALL_NODE` (with a null receiver and parentheses or arguments) |
-| `NODE_QCALL` | `YP_CALL_NODE` (with a &. operator) |
-| `NODE_SUPER` | `YP_SUPER_NODE` |
-| `NODE_ZSUPER` | `YP_FORWARDING_SUPER_NODE` |
-| `NODE_LIST` | `YP_ARRAY_NODE` |
-| `NODE_ZLIST` | `YP_ARRAY_NODE` (with no child elements) |
-| `NODE_VALUES` | `YP_ARGUMENTS_NODE` |
-| `NODE_HASH` | `YP_HASH_NODE` |
-| `NODE_RETURN` | `YP_RETURN_NODE` |
-| `NODE_YIELD` | `YP_YIELD_NODE` |
-| `NODE_LVAR` | `YP_LOCAL_VARIABLE_READ_NODE` |
-| `NODE_DVAR` | `YP_LOCAL_VARIABLE_READ_NODE` |
-| `NODE_GVAR` | `YP_GLOBAL_VARIABLE_READ_NODE` |
-| `NODE_IVAR` | `YP_INSTANCE_VARIABLE_READ_NODE` |
-| `NODE_CONST` | `YP_CONSTANT_PATH_READ_NODE` |
-| `NODE_CVAR` | `YP_CLASS_VARIABLE_READ_NODE` |
-| `NODE_NTH_REF` | `YP_NUMBERED_REFERENCE_READ_NODE` |
-| `NODE_BACK_REF` | `YP_BACK_REFERENCE_READ_NODE` |
+| `NODE_CALL` | `PM_CALL_NODE` |
+| `NODE_OPCALL` | `PM_CALL_NODE` (with an operator as the method) |
+| `NODE_FCALL` | `PM_CALL_NODE` (with a null receiver and parentheses) |
+| `NODE_VCALL` | `PM_CALL_NODE` (with a null receiver and parentheses or arguments) |
+| `NODE_QCALL` | `PM_CALL_NODE` (with a &. operator) |
+| `NODE_SUPER` | `PM_SUPER_NODE` |
+| `NODE_ZSUPER` | `PM_FORWARDING_SUPER_NODE` |
+| `NODE_LIST` | `PM_ARRAY_NODE` |
+| `NODE_ZLIST` | `PM_ARRAY_NODE` (with no child elements) |
+| `NODE_VALUES` | `PM_ARGUMENTS_NODE` |
+| `NODE_HASH` | `PM_HASH_NODE` |
+| `NODE_RETURN` | `PM_RETURN_NODE` |
+| `NODE_YIELD` | `PM_YIELD_NODE` |
+| `NODE_LVAR` | `PM_LOCAL_VARIABLE_READ_NODE` |
+| `NODE_DVAR` | `PM_LOCAL_VARIABLE_READ_NODE` |
+| `NODE_GVAR` | `PM_GLOBAL_VARIABLE_READ_NODE` |
+| `NODE_IVAR` | `PM_INSTANCE_VARIABLE_READ_NODE` |
+| `NODE_CONST` | `PM_CONSTANT_PATH_READ_NODE` |
+| `NODE_CVAR` | `PM_CLASS_VARIABLE_READ_NODE` |
+| `NODE_NTH_REF` | `PM_NUMBERED_REFERENCE_READ_NODE` |
+| `NODE_BACK_REF` | `PM_BACK_REFERENCE_READ_NODE` |
 | `NODE_MATCH` | |
-| `NODE_MATCH2` | `YP_CALL_NODE` (with regular expression as receiver) |
-| `NODE_MATCH3` | `YP_CALL_NODE` (with regular expression as only argument) |
+| `NODE_MATCH2` | `PM_CALL_NODE` (with regular expression as receiver) |
+| `NODE_MATCH3` | `PM_CALL_NODE` (with regular expression as only argument) |
 | `NODE_LIT` | |
-| `NODE_STR` | `YP_STRING_NODE` |
-| `NODE_DSTR` | `YP_INTERPOLATED_STRING_NODE` |
-| `NODE_XSTR` | `YP_X_STRING_NODE` |
-| `NODE_DXSTR` | `YP_INTERPOLATED_X_STRING_NODE` |
-| `NODE_EVSTR` | `YP_STRING_INTERPOLATED_NODE` |
-| `NODE_DREGX` | `YP_INTERPOLATED_REGULAR_EXPRESSION_NODE` |
+| `NODE_STR` | `PM_STRING_NODE` |
+| `NODE_DSTR` | `PM_INTERPOLATED_STRING_NODE` |
+| `NODE_XSTR` | `PM_X_STRING_NODE` |
+| `NODE_DXSTR` | `PM_INTERPOLATED_X_STRING_NODE` |
+| `NODE_EVSTR` | `PM_STRING_INTERPOLATED_NODE` |
+| `NODE_DREGX` | `PM_INTERPOLATED_REGULAR_EXPRESSION_NODE` |
 | `NODE_ONCE` | |
-| `NODE_ARGS` | `YP_PARAMETERS_NODE` |
+| `NODE_ARGS` | `PM_PARAMETERS_NODE` |
 | `NODE_ARGS_AUX` | |
-| `NODE_OPT_ARG` | `YP_OPTIONAL_PARAMETER_NODE` |
-| `NODE_KW_ARG` | `YP_KEYWORD_PARAMETER_NODE` |
-| `NODE_POSTARG` | `YP_REQUIRED_PARAMETER_NODE` |
+| `NODE_OPT_ARG` | `PM_OPTIONAL_PARAMETER_NODE` |
+| `NODE_KW_ARG` | `PM_KEYWORD_PARAMETER_NODE` |
+| `NODE_POSTARG` | `PM_REQUIRED_PARAMETER_NODE` |
 | `NODE_ARGSCAT` | |
 | `NODE_ARGSPUSH` | |
-| `NODE_SPLAT` | `YP_SPLAT_NODE` |
-| `NODE_BLOCK_PASS` | `YP_BLOCK_ARGUMENT_NODE` |
-| `NODE_DEFN` | `YP_DEF_NODE` (with a null receiver) |
-| `NODE_DEFS` | `YP_DEF_NODE` (with a non-null receiver) |
-| `NODE_ALIAS` | `YP_ALIAS_NODE` |
-| `NODE_VALIAS` | `YP_ALIAS_NODE` (with a global variable first argument) |
-| `NODE_UNDEF` | `YP_UNDEF_NODE` |
-| `NODE_CLASS` | `YP_CLASS_NODE` |
-| `NODE_MODULE` | `YP_MODULE_NODE` |
-| `NODE_SCLASS` | `YP_S_CLASS_NODE` |
-| `NODE_COLON2` | `YP_CONSTANT_PATH_NODE` |
-| `NODE_COLON3` | `YP_CONSTANT_PATH_NODE` (with a null receiver) |
-| `NODE_DOT2` | `YP_RANGE_NODE` (with a .. operator) |
-| `NODE_DOT3` | `YP_RANGE_NODE` (with a ... operator) |
-| `NODE_FLIP2` | `YP_RANGE_NODE` (with a .. operator) |
-| `NODE_FLIP3` | `YP_RANGE_NODE` (with a ... operator) |
-| `NODE_SELF` | `YP_SELF_NODE` |
-| `NODE_NIL` | `YP_NIL_NODE` |
-| `NODE_TRUE` | `YP_TRUE_NODE` |
-| `NODE_FALSE` | `YP_FALSE_NODE` |
+| `NODE_SPLAT` | `PM_SPLAT_NODE` |
+| `NODE_BLOCK_PASS` | `PM_BLOCK_ARGUMENT_NODE` |
+| `NODE_DEFN` | `PM_DEF_NODE` (with a null receiver) |
+| `NODE_DEFS` | `PM_DEF_NODE` (with a non-null receiver) |
+| `NODE_ALIAS` | `PM_ALIAS_NODE` |
+| `NODE_VALIAS` | `PM_ALIAS_NODE` (with a global variable first argument) |
+| `NODE_UNDEF` | `PM_UNDEF_NODE` |
+| `NODE_CLASS` | `PM_CLASS_NODE` |
+| `NODE_MODULE` | `PM_MODULE_NODE` |
+| `NODE_SCLASS` | `PM_S_CLASS_NODE` |
+| `NODE_COLON2` | `PM_CONSTANT_PATH_NODE` |
+| `NODE_COLON3` | `PM_CONSTANT_PATH_NODE` (with a null receiver) |
+| `NODE_DOT2` | `PM_RANGE_NODE` (with a .. operator) |
+| `NODE_DOT3` | `PM_RANGE_NODE` (with a ... operator) |
+| `NODE_FLIP2` | `PM_RANGE_NODE` (with a .. operator) |
+| `NODE_FLIP3` | `PM_RANGE_NODE` (with a ... operator) |
+| `NODE_SELF` | `PM_SELF_NODE` |
+| `NODE_NIL` | `PM_NIL_NODE` |
+| `NODE_TRUE` | `PM_TRUE_NODE` |
+| `NODE_FALSE` | `PM_FALSE_NODE` |
 | `NODE_ERRINFO` | |
-| `NODE_DEFINED` | `YP_DEFINED_NODE` |
-| `NODE_POSTEXE` | `YP_POST_EXECUTION_NODE` |
-| `NODE_DSYM` | `YP_INTERPOLATED_SYMBOL_NODE` |
-| `NODE_ATTRASGN` | `YP_CALL_NODE` (with a message that ends with =) |
-| `NODE_LAMBDA` | `YP_LAMBDA_NODE` |
-| `NODE_ARYPTN` | `YP_ARRAY_PATTERN_NODE` |
-| `NODE_HSHPTN` | `YP_HASH_PATTERN_NODE` |
-| `NODE_FNDPTN` | `YP_FIND_PATTERN_NODE` |
-| `NODE_ERROR` | `YP_MISSING_NODE` |
+| `NODE_DEFINED` | `PM_DEFINED_NODE` |
+| `NODE_POSTEXE` | `PM_POST_EXECUTION_NODE` |
+| `NODE_DSYM` | `PM_INTERPOLATED_SYMBOL_NODE` |
+| `NODE_ATTRASGN` | `PM_CALL_NODE` (with a message that ends with =) |
+| `NODE_LAMBDA` | `PM_LAMBDA_NODE` |
+| `NODE_ARYPTN` | `PM_ARRAY_PATTERN_NODE` |
+| `NODE_HSHPTN` | `PM_HASH_PATTERN_NODE` |
+| `NODE_FNDPTN` | `PM_FIND_PATTERN_NODE` |
+| `NODE_ERROR` | `PM_MISSING_NODE` |
 | `NODE_LAST` | |
 ```

data/docs/ripper.md

@@ -2,12 +2,12 @@
 
 To test the parser, we compare against the output from `Ripper`, both for testing the lexer and testing the parser. The lexer test suite is much more feature complete at the moment.
 
-To lex source code using `YARP`, you typically would run `YARP.lex(source)`. If you want to instead get output that `Ripper` would normally produce, you can run `YARP.lex_compat(source)`. This will produce tokens that should be equivalent to `Ripper`.
+To lex source code using `prism`, you typically would run `Prism.lex(source)`. If you want to instead get output that `Ripper` would normally produce, you can run `Prism.lex_compat(source)`. This will produce tokens that should be equivalent to `Ripper`.
 
-To parse source code using `YARP`, you typically would run `YARP.parse(source)`. If you want to instead using the `Ripper` streaming interface, you can inherit from `YARP::RipperCompat` and override the `on_*` methods. This will produce a syntax tree that should be equivalent to `Ripper`. That would look like:
+To parse source code using `prism`, you typically would run `Prism.parse(source)`. If you want to instead using the `Ripper` streaming interface, you can inherit from `Prism::RipperCompat` and override the `on_*` methods. This will produce a syntax tree that should be equivalent to `Ripper`. That would look like:
 
 ```ruby
-class ArithmeticRipper < YARP::RipperCompat
+class ArithmeticRipper < Prism::RipperCompat
   def on_binary(left, operator, right)
     left.public_send(operator, right)
   end
@@ -33,4 +33,4 @@ end
 ArithmeticRipper.new("1 + 2 - 3").parse # => [0]
 ```
 
-There are also APIs for building trees similar to the s-expression builders in `Ripper`. The method names are the same. These include `YARP::RipperCompat.sexp_raw(source)` and `YARP::RipperCompat.sexp(source)`.
+There are also APIs for building trees similar to the s-expression builders in `Ripper`. The method names are the same. These include `Prism::RipperCompat.sexp_raw(source)` and `Prism::RipperCompat.sexp(source)`.

data/docs/ruby_api.md

@@ -1,6 +1,6 @@
 # Ruby API
 
-The `yarp` gem provides a Ruby API for accessing the syntax tree.
+The `prism` gem provides a Ruby API for accessing the syntax tree.
 
 For the most part, the API for accessing the tree mirrors that found in the [Syntax Tree](https://github.com/ruby-syntax-tree/syntax_tree) project. This means:
 
@@ -9,17 +9,17 @@ For the most part, the API for accessing the tree mirrors that found in the [Syn
 * Nodes respond to the pattern matching interfaces `#deconstruct` and `#deconstruct_keys`
 
 Every entry in `config.yml` will generate a Ruby class as well as the code that builds the nodes themselves.
-Creating a syntax tree involves calling one of the class methods on the `YARP` module.
+Creating a syntax tree involves calling one of the class methods on the `Prism` module.
 The full API is documented below.
 
 ## API
 
-* `YARP.dump(source, filepath)` - parse the syntax tree corresponding to the given source string and filepath, and serialize it to a string. Filepath can be nil.
-* `YARP.dump_file(filepath)` - parse the syntax tree corresponding to the given source file and serialize it to a string
-* `YARP.lex(source)` - parse the tokens corresponding to the given source string and return them as an array within a parse result
-* `YARP.lex_file(filepath)` - parse the tokens corresponding to the given source file and return them as an array within a parse result
-* `YARP.parse(source)` - parse the syntax tree corresponding to the given source string and return it within a parse result
-* `YARP.parse_file(filepath)` - parse the syntax tree corresponding to the given source file and return it within a parse result
-* `YARP.parse_lex(source)` - parse the syntax tree corresponding to the given source string and return it within a parse result, along with the tokens
-* `YARP.parse_lex_file(filepath)` - parse the syntax tree corresponding to the given source file and return it within a parse result, along with the tokens
-* `YARP.load(source, serialized)` - load the serialized syntax tree using the source as a reference into a syntax tree
+* `Prism.dump(source, filepath)` - parse the syntax tree corresponding to the given source string and filepath, and serialize it to a string. Filepath can be nil.
+* `Prism.dump_file(filepath)` - parse the syntax tree corresponding to the given source file and serialize it to a string
+* `Prism.lex(source)` - parse the tokens corresponding to the given source string and return them as an array within a parse result
+* `Prism.lex_file(filepath)` - parse the tokens corresponding to the given source file and return them as an array within a parse result
+* `Prism.parse(source)` - parse the syntax tree corresponding to the given source string and return it within a parse result
+* `Prism.parse_file(filepath)` - parse the syntax tree corresponding to the given source file and return it within a parse result
+* `Prism.parse_lex(source)` - parse the syntax tree corresponding to the given source string and return it within a parse result, along with the tokens
+* `Prism.parse_lex_file(filepath)` - parse the syntax tree corresponding to the given source file and return it within a parse result, along with the tokens
+* `Prism.load(source, serialized)` - load the serialized syntax tree using the source as a reference into a syntax tree

data/docs/serialization.md

@@ -1,6 +1,6 @@
 # Serialization
 
-YARP ships with the ability to serialize a syntax tree to a single string.
+Prism ships with the ability to serialize a syntax tree to a single string.
 The string can then be deserialized back into a syntax tree using a language other than C.
 This is useful for using the parsing logic in other tools without having to write a parser in that language.
 The syntax tree still requires a copy of the original source, as for the most part it just contains byte offsets into the source string.
@@ -50,7 +50,7 @@ The comment type is one of:
 ## Structure
 
 The serialized string representing the syntax tree is composed of three parts: the header, the body, and the constant pool.
-The header contains information like the version of YARP that serialized the tree.
+The header contains information like the version of prism that serialized the tree.
 The body contains the actual nodes in the tree.
 The constant pool contains constants that were interned while parsing.
 
@@ -58,10 +58,11 @@ The header is structured like the following table:
 
 | # bytes | field |
 | --- | --- |
-| `4` | "YARP" |
+| `5` | "PRISM" |
 | `1` | major version number |
 | `1` | minor version number |
 | `1` | patch version number |
+| `1` | 1 indicates only semantics fields were serialized, 0 indicates all fields were serialized (including location fields) |
 | string | the encoding name |
 | varint | number of comments |
 | comment* | comments |
@@ -116,42 +117,42 @@ After the constant pool, the contents of the owned constants are serialized. Thi
 The relevant APIs and struct definitions are listed below:
 
 ```c
-// A yp_buffer_t is a simple memory buffer that stores data in a contiguous
+// A pm_buffer_t is a simple memory buffer that stores data in a contiguous
 // block of memory. It is used to store the serialized representation of a
-// YARP tree.
+// prism tree.
 typedef struct {
   char *value;
   size_t length;
   size_t capacity;
-} yp_buffer_t;
+} pm_buffer_t;
 
-// Initialize a yp_buffer_t with its default values.
-bool yp_buffer_init(yp_buffer_t *);
+// Initialize a pm_buffer_t with its default values.
+bool pm_buffer_init(pm_buffer_t *);
 
 // Free the memory associated with the buffer.
-void yp_buffer_free(yp_buffer_t *);
+void pm_buffer_free(pm_buffer_t *);
 
 // Parse and serialize the AST represented by the given source to the given
 // buffer.
-void yp_parse_serialize(const uint8_t *source, size_t length, yp_buffer_t *buffer, const char *metadata);
+void pm_parse_serialize(const uint8_t *source, size_t length, pm_buffer_t *buffer, const char *metadata);
 ```
 
-Typically you would use a stack-allocated `yp_buffer_t` and call `yp_parse_serialize`, as in:
+Typically you would use a stack-allocated `pm_buffer_t` and call `pm_parse_serialize`, as in:
 
 ```c
 void
 serialize(const uint8_t *source, size_t length) {
-  yp_buffer_t buffer;
-  if (!yp_buffer_init(&buffer)) return;
+  pm_buffer_t buffer;
+  if (!pm_buffer_init(&buffer)) return;
 
-  yp_parse_serialize(source, length, &buffer, NULL);
+  pm_parse_serialize(source, length, &buffer, NULL);
   // Do something with the serialized string.
 
-  yp_buffer_free(&buffer);
+  pm_buffer_free(&buffer);
 }
 ```
 
-The final argument to `yp_parse_serialize` controls the metadata of the source.
+The final argument to `pm_parse_serialize` controls the metadata of the source.
 This includes the filepath that the source is associated with, and any nested local variables scopes that are necessary to properly parse the file (in the case of parsing an `eval`).
 Note that no `varint` are used here to make it easier to produce the metadata for the caller, and also serialized size is less important here.
 The metadata is a serialized format itself, and is structured as follows:

data/docs/testing.md

@@ -1,6 +1,6 @@
 # Testing
 
-This document explains how to test YARP, both locally, and against existing test suites.
+This document explains how to test prism, both locally, and against existing test suites.
 
 ## Test suite
 
@@ -8,13 +8,13 @@ This document explains how to test YARP, both locally, and against existing test
 
 ### Unit tests
 
-These test specific YARP implementation details like comments, errors, and regular expressions. There are corresponding files for each thing being tested (like `test/errors_test.rb`).
+These test specific prism implementation details like comments, errors, and regular expressions. There are corresponding files for each thing being tested (like `test/errors_test.rb`).
 
 ### Snapshot tests
 
-Snapshot tests ensure that parsed output is equivalent to previous parsed output. There are many categorized examples of valid syntax within the `test/yarp/fixtures/` directory. When the test suite runs, it will parse all of this syntax, and compare it against corresponding files in the `test/yarp/snapshots/` directory. For example, `test/yarp/fixtures/strings.txt` has a corresponding `test/yarp/snapshots/strings.txt`.
+Snapshot tests ensure that parsed output is equivalent to previous parsed output. There are many categorized examples of valid syntax within the `test/prism/fixtures/` directory. When the test suite runs, it will parse all of this syntax, and compare it against corresponding files in the `test/prism/snapshots/` directory. For example, `test/prism/fixtures/strings.txt` has a corresponding `test/prism/snapshots/strings.txt`.
 
-If the parsed files do not match, it will raise an error. If there is not a corresponding file in the `test/yarp/snapshots/` directory, one will be created so that it exists for the next test run.
+If the parsed files do not match, it will raise an error. If there is not a corresponding file in the `test/prism/snapshots/` directory, one will be created so that it exists for the next test run.
 
 ### Testing against repositories
 
@@ -24,7 +24,7 @@ To test the parser against a repository, you can run `FILEPATHS='/path/to/reposi
 
 As you are working, you will likely want to test your code locally. `test.rb` is ignored by git, so it can be used for local testing. There are also two executables which may help you:
 
-1. **bin/lex** takes a filepath and compares YARP's lexed output to Ripper's lexed output. It prints any lexed output that doesn't match. It does some minor transformations to the lexed output in order to compare them, like split YARP's heredoc tokens to mirror Ripper's.
+1. **bin/lex** takes a filepath and compares prism's lexed output to Ripper's lexed output. It prints any lexed output that doesn't match. It does some minor transformations to the lexed output in order to compare them, like split prism's heredoc tokens to mirror Ripper's.
 
 ```
 $ bin/lex test.rb
@@ -42,7 +42,7 @@ $ VERBOSE=1 bin/lex test.rb
 $ bin/lex -e "1 + 2"
 ```
 
-2. **bin/parse** takes a filepath and outputs YARP's parsed node structure generated from reading the file.
+2. **bin/parse** takes a filepath and outputs prism's parsed node structure generated from reading the file.
 
 ```
 $ bin/parse test.rb