yarp 0.11.0 → 0.12.0

data/include/yarp/diagnostic.h

@@ -32,6 +32,7 @@ typedef enum {
     YP_ERR_ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT,
     YP_ERR_ARGUMENT_SPLAT_AFTER_SPLAT,
     YP_ERR_ARGUMENT_TERM_PAREN,
+    YP_ERR_ARGUMENT_UNEXPECTED_BLOCK,
     YP_ERR_ARRAY_ELEMENT,
     YP_ERR_ARRAY_EXPRESSION,
     YP_ERR_ARRAY_EXPRESSION_AFTER_STAR,
@@ -49,7 +50,7 @@ typedef enum {
     YP_ERR_CANNOT_PARSE_STRING_PART,
     YP_ERR_CASE_EXPRESSION_AFTER_CASE,
     YP_ERR_CASE_EXPRESSION_AFTER_WHEN,
-    YP_ERR_CASE_LONELY_ELSE,
+    YP_ERR_CASE_MISSING_CONDITIONS,
     YP_ERR_CASE_TERM,
     YP_ERR_CLASS_IN_METHOD,
     YP_ERR_CLASS_NAME,
@@ -129,6 +130,7 @@ typedef enum {
     YP_ERR_INVALID_NUMBER_DECIMAL,
     YP_ERR_INVALID_NUMBER_HEXADECIMAL,
     YP_ERR_INVALID_NUMBER_OCTAL,
+    YP_ERR_INVALID_NUMBER_UNDERSCORE,
     YP_ERR_INVALID_PERCENT,
     YP_ERR_INVALID_TOKEN,
     YP_ERR_INVALID_VARIABLE_GLOBAL,
@@ -150,7 +152,10 @@ typedef enum {
     YP_ERR_MULTI_ASSIGN_MULTI_SPLATS,
     YP_ERR_NOT_EXPRESSION,
     YP_ERR_NUMBER_LITERAL_UNDERSCORE,
+    YP_ERR_NUMBERED_PARAMETER_NOT_ALLOWED,
+    YP_ERR_NUMBERED_PARAMETER_OUTER_SCOPE,
     YP_ERR_OPERATOR_MULTI_ASSIGN,
+    YP_ERR_OPERATOR_WRITE_BLOCK,
     YP_ERR_PARAMETER_ASSOC_SPLAT_MULTI,
     YP_ERR_PARAMETER_BLOCK_MULTI,
     YP_ERR_PARAMETER_NAME_REPEAT,
@@ -194,11 +199,11 @@ typedef enum {
     YP_ERR_TERNARY_COLON,
     YP_ERR_TERNARY_EXPRESSION_FALSE,
     YP_ERR_TERNARY_EXPRESSION_TRUE,
-    YP_ERR_UNDEF_ARGUMENT,
     YP_ERR_UNARY_RECEIVER_BANG,
     YP_ERR_UNARY_RECEIVER_MINUS,
     YP_ERR_UNARY_RECEIVER_PLUS,
     YP_ERR_UNARY_RECEIVER_TILDE,
+    YP_ERR_UNDEF_ARGUMENT,
     YP_ERR_UNTIL_TERM,
     YP_ERR_WHILE_TERM,
     YP_ERR_WRITE_TARGET_READONLY,

data/include/yarp/enc/yp_encoding.h

@@ -60,7 +60,7 @@ size_t yp_encoding_utf_8_alnum_char(const uint8_t *b, ptrdiff_t n);
 
 // This lookup table is referenced in both the UTF-8 encoding file and the
 // parser directly in order to speed up the default encoding processing.
-extern uint8_t yp_encoding_unicode_table[256];
+extern const uint8_t yp_encoding_unicode_table[256];
 
 // These are the encodings that are supported by the parser. They are defined in
 // their own files in the src/enc directory.

data/include/yarp/parser.h

@@ -277,12 +277,22 @@ typedef struct yp_scope {
     // The IDs of the locals in the given scope.
     yp_constant_id_list_t locals;
 
+    // A pointer to the previous scope in the linked list.
+    struct yp_scope *previous;
+
     // A boolean indicating whether or not this scope can see into its parent.
     // If closed is true, then the scope cannot see into its parent.
     bool closed;
 
-    // A pointer to the previous scope in the linked list.
-    struct yp_scope *previous;
+    // A boolean indicating whether or not this scope has explicit parameters.
+    // This is necessary to determine whether or not numbered parameters are
+    // allowed.
+    bool explicit_params;
+
+    // A boolean indicating whether or not this scope has numbered parameters.
+    // This is necessary to determine if child blocks are allowed to use
+    // numbered parameters.
+    bool numbered_params;
 } yp_scope_t;
 
 // This struct represents the overall parser. It contains a reference to the
@@ -291,7 +301,6 @@ typedef struct yp_scope {
 // it's considering.
 struct yp_parser {
     yp_lex_state_t lex_state; // the current state of the lexer
-    bool command_start;       // whether or not we're at the beginning of a command
     int enclosure_nesting;    // tracks the current nesting of (), [], and {}
 
     // Used to temporarily track the nesting of enclosures to determine if a {
@@ -338,17 +347,11 @@ struct yp_parser {
     yp_scope_t *current_scope;          // the current local scope
 
     yp_context_node_t *current_context; // the current parsing context
-    bool recovering; // whether or not we're currently recovering from a syntax error
 
     // The encoding functions for the current file is attached to the parser as
     // it's parsing so that it can change with a magic comment.
     yp_encoding_t encoding;
 
-    // Whether or not the encoding has been changed by a magic comment. We use
-    // this to provide a fast path for the lexer instead of going through the
-    // function pointer.
-    bool encoding_changed;
-
     // When the encoding that is being used to parse the source is changed by
     // YARP, we provide the ability here to call out to a user-defined function.
     yp_encoding_changed_callback_t encoding_changed_callback;
@@ -367,13 +370,6 @@ struct yp_parser {
     // be called whenever a new token is lexed by the parser.
     yp_lex_callback_t *lex_callback;
 
-    // This flag indicates that we are currently parsing a pattern matching
-    // expression and impacts that calculation of newlines.
-    bool pattern_matching_newlines;
-
-    // This flag indicates that we are currently parsing a keyword argument.
-    bool in_keyword_arg;
-
     // This is the path of the file being parsed
     // We use the filepath when constructing SourceFileNodes
     yp_string_t filepath_string;
@@ -384,6 +380,38 @@ struct yp_parser {
 
     // This is the list of newline offsets in the source file.
     yp_newline_list_t newline_list;
+
+    // We want to add a flag to integer nodes that indicates their base. We only
+    // want to parse these once, but we don't have space on the token itself to
+    // communicate this information. So we store it here and pass it through
+    // when we find tokens that we need it for.
+    yp_node_flags_t integer_base;
+
+    // Whether or not we're at the beginning of a command
+    bool command_start;
+
+    // Whether or not we're currently recovering from a syntax error
+    bool recovering;
+
+    // Whether or not the encoding has been changed by a magic comment. We use
+    // this to provide a fast path for the lexer instead of going through the
+    // function pointer.
+    bool encoding_changed;
+
+    // This flag indicates that we are currently parsing a pattern matching
+    // expression and impacts that calculation of newlines.
+    bool pattern_matching_newlines;
+
+    // This flag indicates that we are currently parsing a keyword argument.
+    bool in_keyword_arg;
+
+    // Whether or not the parser has seen a token that has semantic meaning
+    // (i.e., a token that is not a comment or whitespace).
+    bool semantic_token_seen;
+
+    // Whether or not we have found a frozen_string_literal magic comment with
+    // a true value.
+    bool frozen_string_literal;
 };
 
 #endif // YARP_PARSER_H

data/include/yarp/util/yp_char.h

@@ -31,19 +31,31 @@ size_t yp_strspn_decimal_digit(const uint8_t *string, ptrdiff_t length);
 size_t yp_strspn_hexadecimal_digit(const uint8_t *string, ptrdiff_t length);
 
 // Returns the number of characters at the start of the string that are octal
-// digits or underscores.  Disallows searching past the given maximum number of
+// digits or underscores. Disallows searching past the given maximum number of
 // characters.
-size_t yp_strspn_octal_number(const uint8_t *string, ptrdiff_t length);
+//
+// If multiple underscores are found in a row or if an underscore is
+// found at the end of the number, then the invalid pointer is set to the index
+// of the first invalid underscore.
+size_t yp_strspn_octal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid);
 
 // Returns the number of characters at the start of the string that are decimal
 // digits or underscores. Disallows searching past the given maximum number of
 // characters.
-size_t yp_strspn_decimal_number(const uint8_t *string, ptrdiff_t length);
+//
+// If multiple underscores are found in a row or if an underscore is
+// found at the end of the number, then the invalid pointer is set to the index
+// of the first invalid underscore.
+size_t yp_strspn_decimal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid);
 
 // Returns the number of characters at the start of the string that are
 // hexadecimal digits or underscores. Disallows searching past the given maximum
 // number of characters.
-size_t yp_strspn_hexadecimal_number(const uint8_t *string, ptrdiff_t length);
+//
+// If multiple underscores are found in a row or if an underscore is
+// found at the end of the number, then the invalid pointer is set to the index
+// of the first invalid underscore.
+size_t yp_strspn_hexadecimal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid);
 
 // Returns the number of characters at the start of the string that are regexp
 // options. Disallows searching past the given maximum number of characters.
@@ -52,7 +64,11 @@ size_t yp_strspn_regexp_option(const uint8_t *string, ptrdiff_t length);
 // Returns the number of characters at the start of the string that are binary
 // digits or underscores. Disallows searching past the given maximum number of
 // characters.
-size_t yp_strspn_binary_number(const uint8_t *string, ptrdiff_t length);
+//
+// If multiple underscores are found in a row or if an underscore is
+// found at the end of the number, then the invalid pointer is set to the index
+// of the first invalid underscore.
+size_t yp_strspn_binary_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid);
 
 // Returns true if the given character is a whitespace character.
 bool yp_char_is_whitespace(const uint8_t b);

data/include/yarp/version.h

@@ -1,4 +1,4 @@
 #define YP_VERSION_MAJOR 0
-#define YP_VERSION_MINOR 11
+#define YP_VERSION_MINOR 12
 #define YP_VERSION_PATCH 0
-#define YP_VERSION "0.11.0"
+#define YP_VERSION "0.12.0"

data/lib/yarp/mutation_visitor.rb

@@ -10,8 +10,13 @@ module YARP
   # visited. This is useful for consumers that want to mutate the tree, as you
   # can change subtrees in place without effecting the rest of the tree.
   class MutationVisitor < BasicVisitor
-    # Copy a AliasNode node
-    def visit_alias_node(node)
+    # Copy a AliasGlobalVariableNode node
+    def visit_alias_global_variable_node(node)
+      node.copy(new_name: visit(node.new_name), old_name: visit(node.old_name))
+    end
+
+    # Copy a AliasMethodNode node
+    def visit_alias_method_node(node)
       node.copy(new_name: visit(node.new_name), old_name: visit(node.old_name))
     end
 
@@ -335,6 +340,11 @@ module YARP
       node.copy(numeric: visit(node.numeric))
     end
 
+    # Copy a ImplicitNode node
+    def visit_implicit_node(node)
+      node.copy(value: visit(node.value))
+    end
+
     # Copy a InNode node
     def visit_in_node(node)
       node.copy(pattern: visit(node.pattern), statements: visit(node.statements))
@@ -375,6 +385,11 @@ module YARP
       node.copy
     end
 
+    # Copy a InterpolatedMatchLastLineNode node
+    def visit_interpolated_match_last_line_node(node)
+      node.copy(parts: visit_all(node.parts))
+    end
+
     # Copy a InterpolatedRegularExpressionNode node
     def visit_interpolated_regular_expression_node(node)
       node.copy(parts: visit_all(node.parts))
@@ -445,6 +460,11 @@ module YARP
       node.copy(value: visit(node.value))
     end
 
+    # Copy a MatchLastLineNode node
+    def visit_match_last_line_node(node)
+      node.copy
+    end
+
     # Copy a MatchPredicateNode node
     def visit_match_predicate_node(node)
       node.copy(value: visit(node.value), pattern: visit(node.pattern))
@@ -455,6 +475,11 @@ module YARP
       node.copy(value: visit(node.value), pattern: visit(node.pattern))
     end
 
+    # Copy a MatchWriteNode node
+    def visit_match_write_node(node)
+      node.copy(call: visit(node.call))
+    end
+
     # Copy a MissingNode node
     def visit_missing_node(node)
       node.copy
@@ -507,7 +532,7 @@ module YARP
 
     # Copy a ParametersNode node
     def visit_parameters_node(node)
-      node.copy(requireds: visit_all(node.requireds), optionals: visit_all(node.optionals), posts: visit_all(node.posts), rest: visit(node.rest), keywords: visit_all(node.keywords), keyword_rest: visit(node.keyword_rest), block: visit(node.block))
+      node.copy(requireds: visit_all(node.requireds), optionals: visit_all(node.optionals), rest: visit(node.rest), posts: visit_all(node.posts), keywords: visit_all(node.keywords), keyword_rest: visit(node.keyword_rest), block: visit(node.block))
     end
 
     # Copy a ParenthesesNode node