rbs 3.3.2 → 3.4.0.pre.1

data/ext/rbs_extension/lexer.re

@@ -97,7 +97,11 @@ start:
       "as"            { return next_token(state, kAS); }
       "__todo__"      { return next_token(state, k__TODO__); }
 
-      dqstring = ["] ("\\"[abefnrstv"\\] | [^"\\\x00])* ["];
+      unicode_char = "\\u" [0-9a-fA-F]{4};
+      oct_char = "\\x" [0-9a-f]{1,2};
+      hex_char = "\\" [0-7]{1,3};
+
+      dqstring = ["] (unicode_char | oct_char | hex_char | "\\" [^xu] | [^\\"\x00])* ["];
       sqstring = ['] ("\\"['\\] | [^'\x00])* ['];
 
       dqstring     { return next_token(state, tDQSTRING); }

data/ext/rbs_extension/parser.c

@@ -276,6 +276,14 @@ static VALUE parse_function_param(parserstate *state) {
     param_range.start = type_range.start;
     param_range.end = name_range.end;
 
+    if (!is_keyword_token(state->current_token.type)) {
+      raise_syntax_error(
+        state,
+        state->current_token,
+        "unexpected token for function parameter name"
+      );
+    }
+
     VALUE name = rb_to_symbol(rbs_unquote_string(state, state->current_token.range, 0));
     VALUE location = rbs_new_location(state->buffer, param_range);
     rbs_loc *loc = rbs_check_location(location);
@@ -503,6 +511,7 @@ PARSE_KEYWORDS:
 
     case tUIDENT:
     case tLIDENT:
+    case tQIDENT:
     case tULIDENT:
     case tULLIDENT:
     case tBANGIDENT:
@@ -714,7 +723,7 @@ VALUE parse_record_attributes(parserstate *state) {
       case tINTEGER:
       case kTRUE:
       case kFALSE:
-        key = rb_funcall(parse_type(state), rb_intern("literal"), 0);
+        key = rb_funcall(parse_simple(state), rb_intern("literal"), 0);
         break;
       default:
         raise_syntax_error(
@@ -1476,8 +1485,8 @@ InstanceSingletonKind parse_instance_singleton_kind(parserstate *state, bool all
 
 /**
  * def_member ::= {kDEF} method_name `:` <method_types>
- *              | {kPRIVATE2} kDEF method_name `:` <method_types>
- *              | {kPUBLIC2} kDEF method_name `:` <method_types>
+ *              | {kPRIVATE} kDEF method_name `:` <method_types>
+ *              | {kPUBLIC} kDEF method_name `:` <method_types>
  *
  * method_types ::= {} <method_type>
  *                | {} <`...`>

data/ext/rbs_extension/unescape.c

@@ -1,49 +1,5 @@
 #include "rbs_extension.h"
 
-static VALUE DQ_REGEXP = 0;
-static VALUE SQ_REGEXP = 0;
-static VALUE HASH = 0;
-
-static const char *dq_regexp_str = "\\\\[abefnrstv\"\\\\]";
-static const char *sq_regexp_str = "\\\\[\'\\\\]";
-
-static ID gsub = 0;
-
-void rbs_unescape_string(VALUE string, bool dq_string) {
-  if (!DQ_REGEXP) {
-    DQ_REGEXP = rb_reg_new(dq_regexp_str, strlen(dq_regexp_str), 0);
-    rb_global_variable(&DQ_REGEXP);
-  }
-
-  if (!SQ_REGEXP) {
-    SQ_REGEXP = rb_reg_new(sq_regexp_str, strlen(sq_regexp_str), 0);
-    rb_global_variable(&SQ_REGEXP);
-  }
-
-  if (!gsub) {
-    gsub = rb_intern("gsub!");
-  }
-
-  if (!HASH) {
-    HASH = rb_hash_new();
-    rb_global_variable(&HASH);
-    rb_hash_aset(HASH, rb_str_new_literal("\\a"), rb_str_new_literal("\a"));
-    rb_hash_aset(HASH, rb_str_new_literal("\\b"), rb_str_new_literal("\b"));
-    rb_hash_aset(HASH, rb_str_new_literal("\\e"), rb_str_new_literal("\033"));
-    rb_hash_aset(HASH, rb_str_new_literal("\\f"), rb_str_new_literal("\f"));
-    rb_hash_aset(HASH, rb_str_new_literal("\\n"), rb_str_new_literal("\n"));
-    rb_hash_aset(HASH, rb_str_new_literal("\\r"), rb_str_new_literal("\r"));
-    rb_hash_aset(HASH, rb_str_new_literal("\\s"), rb_str_new_literal(" "));
-    rb_hash_aset(HASH, rb_str_new_literal("\\t"), rb_str_new_literal("\t"));
-    rb_hash_aset(HASH, rb_str_new_literal("\\v"), rb_str_new_literal("\v"));
-    rb_hash_aset(HASH, rb_str_new_literal("\\\""), rb_str_new_literal("\""));
-    rb_hash_aset(HASH, rb_str_new_literal("\\\'"), rb_str_new_literal("'"));
-    rb_hash_aset(HASH, rb_str_new_literal("\\\\"), rb_str_new_literal("\\"));
-  }
-
-  rb_funcall(string, gsub, 2, dq_string ? DQ_REGEXP : SQ_REGEXP, HASH);
-}
-
 VALUE rbs_unquote_string(parserstate *state, range rg, int offset_bytes) {
   VALUE string = state->lexstate->string;
   rb_encoding *enc = rb_enc_get(string);
@@ -65,8 +21,12 @@ VALUE rbs_unquote_string(parserstate *state, range rg, int offset_bytes) {
   char *buffer = RSTRING_PTR(state->lexstate->string) + rg.start.byte_pos + offset_bytes;
   VALUE str = rb_enc_str_new(buffer, byte_length, enc);
 
-  rbs_unescape_string(str, first_char == '\"');
-
-  return str;
+  return rb_funcall(
+    RBS_Types_Literal,
+    rb_intern("unescape_string"),
+    2,
+    str,
+    first_char == '\"' ? Qtrue : Qfalse
+  );
 }
 

data/lib/rbs/cli/diff.rb

@@ -13,6 +13,7 @@ module RBS
         library_options = library_options
         before_path = []
         after_path = []
+        detail = false
 
         opt = OptionParser.new do |o|
           o.banner = <<~HELP
@@ -35,6 +36,7 @@ module RBS
           o.on("--type-name NAME") { |arg| type_name = arg }
           o.on("--before DIR")     { |arg| before_path << arg }
           o.on("--after DIR")      { |arg| after_path << arg }
+          o.on("--[no-]detail")    { |arg| detail = arg }
         end
         opt.parse!(argv)
 
@@ -47,7 +49,8 @@ module RBS
           type_name: TypeName(type_name).absolute!,
           library_options: library_options,
           after_path: after_path,
-          before_path: before_path
+          before_path: before_path,
+          detail: detail,
         )
       end
 

data/lib/rbs/cli/validate.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+module RBS
+  class CLI
+    class Validate
+      class Errors
+        def initialize(limit:, exit_error:)
+          @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
+          finish if @limit == 1
+        end
+
+        def finish
+          if @errors.empty?
+            if @exit_error && @has_syntax_error
+              exit 1
+            else
+              # success
+            end
+          else
+            @errors.each do |error|
+              RBS.logger.error(build_message(error))
+            end
+            exit 1
+          end
+        end
+
+        private
+
+        def build_message(error)
+          if error.respond_to?(:detailed_message)
+            highlight = RBS.logger_output ? RBS.logger_output.tty? : true
+            error.detailed_message(highlight: highlight)
+          else
+            "#{error.message} (#{error.class})"
+          end
+        end
+      end
+
+      def initialize(args:, options:)
+        loader = options.loader()
+        @env = Environment.from_loader(loader).resolve_type_names
+        @builder = DefinitionBuilder.new(env: @env)
+        @validator = Validator.new(env: @env, resolver: Resolver::TypeNameResolver.new(@env))
+        exit_error = false
+        limit = nil #: Integer?
+        OptionParser.new do |opts|
+          opts.banner = <<EOU
+Usage: rbs validate
+
+Validate RBS files. It ensures the type names in RBS files are present and the type applications have correct arity.
+
+Examples:
+
+  $ rbs validate
+EOU
+
+          opts.on("--silent") do
+            RBS.print_warning { "`--silent` option is deprecated." }
+          end
+          opts.on("--[no-]exit-error-on-syntax-error", "exit(1) if syntax error is detected") {|bool|
+            exit_error = bool
+          }
+          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)
+      end
+
+      def run
+        validate_class_module_definition
+        validate_class_module_alias_definition
+        validate_interface
+        validate_constant
+        validate_global
+        validate_type_alias
+
+        @errors.finish
+      end
+
+      private
+
+      def validate_class_module_definition
+        @env.class_decls.each do |name, decl|
+          RBS.logger.info "Validating class/module definition: `#{name}`..."
+          @builder.build_instance(name).each_type do |type|
+            @validator.validate_type type, context: nil
+          rescue BaseError => error
+            @errors.add(error)
+          end
+          @builder.build_singleton(name).each_type do |type|
+            @validator.validate_type type, context: nil
+          rescue BaseError => error
+            @errors.add(error)
+          end
+
+          case decl
+          when Environment::ClassEntry
+            decl.decls.each do |decl|
+              if super_class = decl.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)
+                end
+              end
+            end
+          when Environment::ModuleEntry
+            decl.decls.each do |decl|
+              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)
+                end
+              end
+            end
+          end
+
+          d = decl.primary.decl
+
+          @validator.validate_type_params(
+            d.type_params,
+            type_name: name,
+            location: d.location&.aref(:type_params)
+          )
+
+          d.type_params.each do |param|
+            if ub = param.upper_bound
+              void_type_context_validator(ub)
+              no_self_type_validator(ub)
+              no_classish_type_validator(ub)
+            end
+          end
+
+          decl.decls.each do |d|
+            d.decl.each_member do |member|
+              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
+              when AST::Members::Var
+                void_type_context_validator(member.type)
+                if member.is_a?(AST::Members::ClassVariable)
+                  no_self_type_validator(member.type)
+                end
+              end
+            end
+          end
+        rescue BaseError => error
+          @errors.add(error)
+        end
+      end
+
+      def validate_class_module_alias_definition
+        @env.class_alias_decls.each do |name, entry|
+          RBS.logger.info "Validating class/module alias definition: `#{name}`..."
+          @validator.validate_class_alias(entry: entry)
+        rescue BaseError => error
+          @errors.add error
+        end
+      end
+
+      def validate_interface
+        @env.interface_decls.each do |name, decl|
+          RBS.logger.info "Validating interface: `#{name}`..."
+          @builder.build_interface(name).each_type do |type|
+            @validator.validate_type type, context: nil
+          end
+
+          @validator.validate_type_params(
+            decl.decl.type_params,
+            type_name: name,
+            location: decl.decl.location&.aref(:type_params)
+          )
+
+          decl.decl.members.each do |member|
+            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
+          @errors.add(error)
+        end
+      end
+
+      def validate_constant
+        @env.constant_decls.each do |name, const|
+          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
+      end
+
+      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
+      end
+
+      def validate_type_alias
+        @env.type_alias_decls.each do |name, decl|
+          RBS.logger.info "Validating alias: `#{name}`..."
+          @builder.expand_alias1(name).tap do |type|
+            @validator.validate_type type, context: nil
+          end
+          @validator.validate_type_alias(entry: decl)
+          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

data/lib/rbs/cli.rb

@@ -10,6 +10,7 @@ module RBS
   class CLI
     autoload :ColoredIO, 'rbs/cli/colored_io'
     autoload :Diff, 'rbs/cli/diff'
+    autoload :Validate, 'rbs/cli/validate'
 
     class LibraryOptions
       attr_accessor :core_root
@@ -444,200 +445,7 @@ EOU
     end
 
     def run_validate(args, options)
-      stdout = stdout()
-      exit_error = false
-
-      OptionParser.new do |opts|
-        opts.banner = <<EOU
-Usage: rbs validate
-
-Validate RBS files. It ensures the type names in RBS files are present and the type applications have correct arity.
-
-Examples:
-
-  $ rbs validate
-EOU
-
-        opts.on("--silent") do
-          stdout = StringIO.new
-        end
-        opts.on("--[no-]exit-error-on-syntax-error", "exit(1) if syntax error is detected") {|bool|
-          exit_error = bool
-        }
-      end.parse!(args)
-
-      loader = options.loader()
-      env = Environment.from_loader(loader).resolve_type_names
-
-      builder = DefinitionBuilder.new(env: env)
-      validator = Validator.new(env: env, resolver: Resolver::TypeNameResolver.new(env))
-
-      syntax_errors = [] #: Array[String]
-
-      no_self_type_validator = ->(type) {
-        # @type var type: Types::t | MethodType
-        if type.has_self_type?
-          syntax_errors << "#{type.location}: `self` type is not allowed in this context"
-        end
-      }
-
-      no_classish_type_validator = ->(type) {
-        # @type var type: Types::t | MethodType
-        if type.has_classish_type?
-          syntax_errors << "#{type.location}: `instance` or `class` type is not allowed in this context"
-        end
-      }
-
-      void_type_context_validator = ->(type, allowed_here = false) {
-        # @type var type: Types::t | MethodType
-        if allowed_here
-          next if type.is_a?(Types::Bases::Void)
-        end
-        if type.with_nonreturn_void?
-          syntax_errors << "#{type.location}: `void` type is only allowed in return type or generics parameter"
-        end
-      }
-
-      env.class_decls.each do |name, decl|
-        stdout.puts "Validating class/module definition: `#{name}`..."
-        builder.build_instance(name).each_type do |type|
-          validator.validate_type type, context: nil
-        end
-        builder.build_singleton(name).each_type do |type|
-          validator.validate_type type, context: nil
-        end
-
-        case decl
-        when Environment::ClassEntry
-          decl.decls.each do |decl|
-            if super_class = decl.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]
-              end
-            end
-          end
-        when Environment::ModuleEntry
-          decl.decls.each do |decl|
-            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]
-              end
-            end
-          end
-        end
-
-        d = decl.primary.decl
-
-        validator.validate_type_params(
-          d.type_params,
-          type_name: name,
-          location: d.location&.aref(:type_params)
-        )
-
-        d.type_params.each do |param|
-          if ub = param.upper_bound
-            void_type_context_validator[ub]
-            no_self_type_validator[ub]
-            no_classish_type_validator[ub]
-          end
-        end
-
-        decl.decls.each do |d|
-          d.decl.each_member do |member|
-            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
-            when AST::Members::Var
-              void_type_context_validator[member.type]
-              if member.is_a?(AST::Members::ClassVariable)
-                no_self_type_validator[member.type]
-              end
-            end
-          end
-        end
-      end
-
-      env.class_alias_decls.each do |name, entry|
-        stdout.puts "Validating class/module alias definition: `#{name}`..."
-        validator.validate_class_alias(entry: entry)
-      end
-
-      env.interface_decls.each do |name, decl|
-        stdout.puts "Validating interface: `#{name}`..."
-        builder.build_interface(name).each_type do |type|
-          validator.validate_type type, context: nil
-        end
-
-        validator.validate_type_params(
-          decl.decl.type_params,
-          type_name: name,
-          location: decl.decl.location&.aref(:type_params)
-        )
-
-        decl.decl.members.each do |member|
-          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
-      end
-
-      env.constant_decls.each do |name, const|
-        stdout.puts "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]
-      end
-
-      env.global_decls.each do |name, global|
-        stdout.puts "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]
-      end
-
-      env.type_alias_decls.each do |name, decl|
-        stdout.puts "Validating alias: `#{name}`..."
-        builder.expand_alias1(name).tap do |type|
-          validator.validate_type type, context: nil
-        end
-        validator.validate_type_alias(entry: decl)
-        no_self_type_validator[decl.decl.type]
-        no_classish_type_validator[decl.decl.type]
-        void_type_context_validator[decl.decl.type]
-      end
-
-      unless syntax_errors.empty?
-        syntax_errors.sort!
-        syntax_errors.uniq!
-        syntax_errors.each do |message|
-          self.stdout.puts message
-        end
-        exit 1 if exit_error
-      end
+      CLI::Validate.new(args: args, options: options).run
     end
 
     def run_constant(args, options)

data/lib/rbs/collection/config.rb

@@ -64,12 +64,11 @@ module RBS
       end
 
       def sources
-        @sources ||= (
-          @data['sources']
-            .map { |c| Sources.from_config_entry(c, base_directory: @config_path.dirname) }
-            .push(Sources::Stdlib.instance)
-            .push(Sources::Rubygems.instance)
-        )
+        @sources ||= [
+          Sources::Stdlib.instance,
+          Sources::Rubygems.instance,
+          *@data['sources'].map { |c| Sources.from_config_entry(c, base_directory: @config_path.dirname) }
+        ]
       end
 
       def gems

data/lib/rbs/collection/sources/git.rb

@@ -248,7 +248,7 @@ module RBS
               if gem_name
                 versions[gem_name.to_s] ||= Set[]
 
-                if version
+                if version && !version.basename.to_s.start_with?('_')
                   versions[gem_name.to_s] << version.basename.to_s
                 end
               end

data/lib/rbs/collection.rb

@@ -2,6 +2,7 @@
 
 require 'yaml'
 
+require_relative './cli/colored_io'
 require_relative './collection/sources'
 require_relative './collection/config'
 require_relative './collection/config/lockfile'