Implement context validation on parse

docs/syntax.md

@@ -236,7 +236,7 @@ We have contextual limitations on some types:
 
 These contextual limitation is introduced at RBS 3.3.
 The parser accepts those types even if it doesn't satisfy contextual limitation, but warning is reported with `rbs validate` command.
-We plan to change the parser to reject those types if it breaks the contextual limitations in next release -- `3.4`.
+Since RBS 4.0, it is reported during parsing.
 
 #### Limitations on `void` types
 

ext/rbs_extension/main.c

@@ -7,6 +7,7 @@
 #include "rbs_string_bridging.h"
 
 #include "ruby/vm.h"
+#include "rbs/parser.h"
 
 /**
  * Raises `RBS::ParsingError` or `RuntimeError` on `tok` with message constructed with given `fmt`.
@@ -101,7 +102,7 @@ static VALUE parse_type_try(VALUE a) {
     }
 
     rbs_node_t *type;
-    rbs_parse_type(parser, &type);
+    rbs_parse_type(parser, &type, SkipValidation);
 
     raise_error_if_any(parser, arg->buffer);
 
@@ -187,7 +188,7 @@ static VALUE parse_method_type_try(VALUE a) {
     }
 
     rbs_method_type_t *method_type = NULL;
-    rbs_parse_method_type(parser, &method_type);
+    rbs_parse_method_type(parser, &method_type, SkipValidation);
 
     raise_error_if_any(parser, arg->buffer);
 

include/rbs/parser.h

@@ -126,8 +126,24 @@ rbs_ast_comment_t *rbs_parser_get_comment(rbs_parser_t *parser, int subject_line
 
 void rbs_parser_set_error(rbs_parser_t *parser, rbs_token_t tok, bool syntax_error, const char *fmt, ...) RBS_ATTRIBUTE_FORMAT(4, 5);
 
-bool rbs_parse_type(rbs_parser_t *parser, rbs_node_t **type);
-bool rbs_parse_method_type(rbs_parser_t *parser, rbs_method_type_t **method_type);
+/**
+ * rbs_type_parsing_option_t represents the validation rules for type parsing.
+ * It controls whether certain types are allowed in specific contexts.
+ * */
+typedef struct {
+    bool no_void;              /* If true, `void` type is not allowed.*/
+    bool no_void_allowed_here; /* If true, `void` type is not allowed, but it's allowed in one depth.*/
+    bool no_self;              /* If true, `self` type is not allowed.*/
+    bool no_classish;          /* If true, `class` or `instance` types are not allowed.*/
+} rbs_type_parsing_option_t;
+
+/**
+ * SkipValidation is a rbs_type_parsing_option_t that allows all types.
+ * */
+extern const rbs_type_parsing_option_t SkipValidation;
+
+bool rbs_parse_type(rbs_parser_t *parser, rbs_node_t **type, rbs_type_parsing_option_t validation);
+bool rbs_parse_method_type(rbs_parser_t *parser, rbs_method_type_t **method_type, rbs_type_parsing_option_t validation);
 bool rbs_parse_signature(rbs_parser_t *parser, rbs_signature_t **signature);
 
 bool rbs_parse_type_params(rbs_parser_t *parser, bool module_type_params, rbs_node_list_t **params);

lib/rbs/cli/validate.rb

@@ -4,31 +4,18 @@ module RBS
   class CLI
     class Validate
       class Errors
-        def initialize(limit:, exit_error:)
+        def initialize(limit:)
           @limit = limit
-          @exit_error = exit_error
           @errors = []
-          @has_syntax_error = false
         end
 
         def add(error)
-          if error.instance_of?(WillSyntaxError)
-            RBS.logger.warn(build_message(error))
-            @has_syntax_error = true
-          else
-            @errors << error
-          end
+          @errors << error
           finish if @limit == 1
         end
 
         def finish
-          if @errors.empty?
-            if @exit_error && @has_syntax_error
-              exit 1
-            else
-              # success
-            end
-          else
+          unless @errors.empty?
             @errors.each do |error|
               RBS.logger.error(build_message(error))
             end
@@ -53,7 +40,6 @@ def initialize(args:, options:)
         @env = Environment.from_loader(loader).resolve_type_names
         @builder = DefinitionBuilder.new(env: @env)
         @validator = Validator.new(env: @env)
-        exit_error = false
         limit = nil #: Integer?
         OptionParser.new do |opts|
           opts.banner = <<EOU
@@ -70,14 +56,14 @@ def initialize(args:, options:)
             RBS.print_warning { "`--silent` option is deprecated because it's silent by default. You can use --log-level option of rbs command to display more information." }
           end
           opts.on("--[no-]exit-error-on-syntax-error", "exit(1) if syntax error is detected") {|bool|
-            exit_error = bool
+            RBS.print_warning { "`--[no-]exit-error-on-syntax-error` option is deprecated because it's built in during parsing." }
           }
           opts.on("--fail-fast", "Exit immediately as soon as a validation error is found.") do |arg|
             limit = 1
           end
         end.parse!(args)
 
-        @errors = Errors.new(limit: limit, exit_error: exit_error)
+        @errors = Errors.new(limit: limit)
       end
 
       def run
@@ -112,9 +98,6 @@ def validate_class_module_definition
             entry.each_decl do |decl|
               if super_class = decl.super_class
                 super_class.args.each do |arg|
-                  void_type_context_validator(arg, true)
-                  no_self_type_validator(arg)
-                  no_classish_type_validator(arg)
                   @validator.validate_type(arg, context: nil)
                 end
               end
@@ -123,9 +106,6 @@ def validate_class_module_definition
             entry.each_decl do |decl|
               decl.self_types.each do |self_type|
                 self_type.args.each do |arg|
-                  void_type_context_validator(arg, true)
-                  no_self_type_validator(arg)
-                  no_classish_type_validator(arg)
                   @validator.validate_type(arg, context: nil)
                 end
 
@@ -153,9 +133,6 @@ def validate_class_module_definition
 
           d.type_params.each do |param|
             if ub = param.upper_bound_type
-              void_type_context_validator(ub)
-              no_self_type_validator(ub)
-              no_classish_type_validator(ub)
               @validator.validate_type(ub, context: nil)
             end
 
@@ -167,9 +144,6 @@ def validate_class_module_definition
             end
 
             if dt = param.default_type
-              void_type_context_validator(dt, true)
-              no_self_type_validator(dt)
-              no_classish_type_validator(dt)
               @validator.validate_type(dt, context: nil)
             end
           end
@@ -183,18 +157,7 @@ def validate_class_module_definition
                 case member
                 when AST::Members::MethodDefinition
                   @validator.validate_method_definition(member, type_name: name)
-                  member.overloads.each do |ov|
-                    void_type_context_validator(ov.method_type)
-                  end
-                when AST::Members::Attribute
-                  void_type_context_validator(member.type)
                 when AST::Members::Mixin
-                  member.args.each do |arg|
-                    no_self_type_validator(arg)
-                    unless arg.is_a?(Types::Bases::Void)
-                      void_type_context_validator(arg, true)
-                    end
-                  end
                   params =
                     if member.name.class?
                       module_decl = @env.normalized_module_entry(member.name) or raise
@@ -206,10 +169,6 @@ def validate_class_module_definition
                   InvalidTypeApplicationError.check!(type_name: member.name, params: params, args: member.args, location: member.location)
                 when AST::Members::Var
                   @validator.validate_variable(member)
-                  void_type_context_validator(member.type)
-                  if member.is_a?(AST::Members::ClassVariable)
-                    no_self_type_validator(member.type)
-                  end
                 end
               end
             else
@@ -245,9 +204,6 @@ def validate_interface
 
           decl.decl.type_params.each do |param|
             if ub = param.upper_bound_type
-              void_type_context_validator(ub)
-              no_self_type_validator(ub)
-              no_classish_type_validator(ub)
               @validator.validate_type(ub, context: nil)
             end
 
@@ -259,9 +215,6 @@ def validate_interface
             end
 
             if dt = param.default_type
-              void_type_context_validator(dt, true)
-              no_self_type_validator(dt)
-              no_classish_type_validator(dt)
               @validator.validate_type(dt, context: nil)
             end
           end
@@ -272,10 +225,6 @@ def validate_interface
             case member
             when AST::Members::MethodDefinition
               @validator.validate_method_definition(member, type_name: name)
-              member.overloads.each do |ov|
-                void_type_context_validator(ov.method_type)
-                no_classish_type_validator(ov.method_type)
-              end
             end
           end
         rescue BaseError => error
@@ -288,9 +237,6 @@ def validate_constant
           RBS.logger.info "Validating constant: `#{name}`..."
           @validator.validate_type const.decl.type, context: const.context
           @builder.ensure_namespace!(name.namespace, location: const.decl.location)
-          no_self_type_validator(const.decl.type)
-          no_classish_type_validator(const.decl.type)
-          void_type_context_validator(const.decl.type)
         rescue BaseError => error
           @errors.add(error)
         end
@@ -300,9 +246,6 @@ def validate_global
         @env.global_decls.each do |name, global|
           RBS.logger.info "Validating global: `#{name}`..."
           @validator.validate_type global.decl.type, context: nil
-          no_self_type_validator(global.decl.type)
-          no_classish_type_validator(global.decl.type)
-          void_type_context_validator(global.decl.type)
         rescue BaseError => error
           @errors.add(error)
         end
@@ -325,9 +268,6 @@ def validate_type_alias
 
           decl.decl.type_params.each do |param|
             if ub = param.upper_bound_type
-              void_type_context_validator(ub)
-              no_self_type_validator(ub)
-              no_classish_type_validator(ub)
               @validator.validate_type(ub, context: nil)
             end
 
@@ -339,45 +279,15 @@ def validate_type_alias
             end
 
             if dt = param.default_type
-              void_type_context_validator(dt, true)
-              no_self_type_validator(dt)
-              no_classish_type_validator(dt)
               @validator.validate_type(dt, context: nil)
             end
           end
 
           TypeParamDefaultReferenceError.check!(decl.decl.type_params)
-
-          no_self_type_validator(decl.decl.type)
-          no_classish_type_validator(decl.decl.type)
-          void_type_context_validator(decl.decl.type)
         rescue BaseError => error
           @errors.add(error)
         end
       end
-
-      private
-
-      def no_self_type_validator(type)
-        if type.has_self_type?
-          @errors.add WillSyntaxError.new("`self` type is not allowed in this context", location: type.location)
-        end
-      end
-
-      def no_classish_type_validator(type)
-        if type.has_classish_type?
-          @errors.add WillSyntaxError.new("`instance` or `class` type is not allowed in this context", location: type.location)
-        end
-      end
-
-      def void_type_context_validator(type, allowed_here = false)
-        if allowed_here
-          return if type.is_a?(Types::Bases::Void)
-        end
-        if type.with_nonreturn_void?
-          @errors.add WillSyntaxError.new("`void` type is only allowed in return type or generics parameter", location: type.location)
-        end
-      end
     end
   end
 end

lib/rbs/errors.rb

@@ -591,17 +591,6 @@ def location
     end
   end
 
-  class WillSyntaxError < DefinitionError
-    include DetailedMessageable
-
-    attr_reader :location
-
-    def initialize(message, location:)
-      super "#{Location.to_string(location)}: #{message}"
-      @location = location
-    end
-  end
-
   class TypeParamDefaultReferenceError < DefinitionError
     include DetailedMessageable
 

lib/rbs/prototype/rb.rb

@@ -372,8 +372,8 @@ def process(node, decls:, comments:, context:)
                        end
 
           value_node = node.children.last
-          type = if value_node.nil?
-                  # Give up type prediction when node is MASGN.
+          type = if value_node.nil? || value_node.type == :SELF
+                  # Give up type prediction when node is MASGN or SELF.
                   Types::Bases::Any.new(location: nil)
                 else
                   literal_to_type(value_node)

sig/cli/validate.rbs

@@ -3,11 +3,9 @@ module RBS
     class Validate
       class Errors
         @limit: Integer?
-        @exit_error: boolish
-        @has_syntax_error: bool
         @errors: Array[BaseError]
 
-        def initialize: (limit: Integer?, exit_error: boolish) -> void
+        def initialize: (limit: Integer?) -> void
 
         def add: (BaseError) -> void
 

sig/errors.rbs

@@ -387,14 +387,6 @@ module RBS
     def location: () -> AST::Declarations::AliasDecl::loc?
   end
 
-  class WillSyntaxError < BaseError
-    include RBS::DetailedMessageable
-
-    def initialize: (String message, location: Location[untyped, untyped]?) -> void
-
-    attr_reader location: Location[untyped, untyped]?
-  end
-
   class TypeParamDefaultReferenceError < BaseError
     include DetailedMessageable