rbs 3.2.2 → 3.3.0.pre.1

data/ext/rbs_extension/lexer.h

@@ -60,6 +60,7 @@ enum TokenType {
   kVOID,            /* void */
   kUSE,             /* use */
   kAS,              /* as */
+  k__TODO__,        /* __todo__ */
 
   tLIDENT,          /* Identifiers starting with lower case */
   tUIDENT,          /* Identifiers starting with upper case */

data/ext/rbs_extension/lexer.re

@@ -95,6 +95,7 @@ start:
       "void"          { return next_token(state, kVOID); }
       "use"           { return next_token(state, kUSE); }
       "as"            { return next_token(state, kAS); }
+      "__todo__"      { return next_token(state, k__TODO__); }
 
       dqstring = ["] ("\\"[abefnrstv"\\] | [^"\\\x00])* ["];
       sqstring = ['] ("\\"['\\] | [^'\x00])* ['];

data/ext/rbs_extension/lexstate.c

@@ -59,6 +59,7 @@ static const char *RBS_TOKENTYPE_NAMES[] = {
   "kVOID",            /* void */
   "kUSE",             /* use */
   "kAS",              /* as */
+  "k__TODO__",        /* __todo__ */
 
   "tLIDENT",          /* Identifiers starting with lower case */
   "tUIDENT",          /* Identifiers starting with upper case */

data/ext/rbs_extension/parser.c

@@ -39,6 +39,7 @@
   case kUNTYPED: \
   case kUSE: \
   case kAS: \
+  case k__TODO__: \
   /* nop */
 
 typedef struct {
@@ -898,6 +899,11 @@ static VALUE parse_simple(parserstate *state) {
     return rbs_base_type(RBS_Types_Bases_Void, rbs_location_current_token(state));
   case kUNTYPED:
     return rbs_base_type(RBS_Types_Bases_Any, rbs_location_current_token(state));
+  case k__TODO__: {
+    VALUE type = rbs_base_type(RBS_Types_Bases_Any, rbs_location_current_token(state));
+    rb_funcall(type, rb_intern("todo!"), 0);
+    return type;
+  }
   case tINTEGER: {
     VALUE literal = rb_funcall(
       string_of_loc(state, state->current_token.range.start, state->current_token.range.end),

data/goodcheck.yml

@@ -13,9 +13,9 @@ rules:
     glob:
       - "{core,stdlib}/**/*.rbs"
     fail:
-      - "def `send`: (String | Symbol arg0, *untyped arg1) -> untyped"
+      - "def `send`: (interned arg0, *untyped arg1) -> untyped"
     pass:
-      - "def `send`: (String | Symbol, *untyped) -> untyped"
+      - "def `send`: (interned, *untyped) -> untyped"
 
   - id: rbs.prefer_boolish
     pattern:

data/lib/rbs/annotate/formatter.rb

@@ -59,10 +59,20 @@ module RBS
 
       def self.each_part(doc, &block)
         if block
-          if doc.file
-            yield doc
+          document =
+            case doc
+            when String
+              raise
+            when RDoc::Comment
+              document = doc.parse
+            when RDoc::Markup::Document
+              document = doc
+            end
+
+          if document.file
+            yield document
           else
-            doc.each do |d|
+            document.each do |d|
               each_part(d, &block)
             end
           end

data/lib/rbs/annotate/rdoc_source.rb

@@ -47,7 +47,16 @@ module RBS
       def docs
         if ds = yield
           unless ds.empty?
-            ds.map(&:comment)
+            ds.map do |code_object|
+              case comment = code_object.comment
+              when String
+                raise
+              when RDoc::Comment
+                comment.parse
+              when RDoc::Markup::Document
+                comment
+              end
+            end
           end
         end
       end

data/lib/rbs/cli/colored_io.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RBS
+  class CLI
+    class ColoredIO
+      attr_reader :stdout
+
+      def initialize(stdout:)
+        @stdout = stdout
+      end
+
+      def puts_red(string)
+        if can_display_colors?
+          puts "\e[31m#{string}\e[m"
+        else
+          puts string
+        end
+      end
+
+      def puts_green(string)
+        if can_display_colors?
+          puts "\e[32m#{string}\e[m"
+        else
+          puts string
+        end
+      end
+
+      def puts(...)
+        stdout.puts(...)
+      end
+
+      private
+
+      # https://github.com/rubygems/rubygems/blob/ed65279100234a17d65d71fe26de5083984ac5b8/bundler/lib/bundler/vendor/thor/lib/thor/shell/color.rb#L99-L109
+      def can_display_colors?
+        are_colors_supported? && !are_colors_disabled?
+      end
+
+      def are_colors_supported?
+        stdout.tty? && ENV["TERM"] != "dumb"
+      end
+
+      def are_colors_disabled?
+        !ENV['NO_COLOR'].nil? && !ENV.fetch('NO_COLOR', '').empty?
+      end
+    end
+  end
+end

data/lib/rbs/cli/diff.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RBS
+  class CLI
+    class Diff
+      def initialize(argv:, library_options:, stdout: $stdout, stderr: $stderr)
+        @format = nil
+        @stdout = stdout
+        @stderr = stderr
+
+        # @type var type_name: String?
+        type_name = nil
+        library_options = library_options
+        before_path = []
+        after_path = []
+
+        opt = OptionParser.new do |o|
+          o.banner = <<~HELP
+            [Experimental] This command is experimental. API and output compatibility is not guaranteed.
+
+            Usage:
+              rbs diff --format markdown --type-name Foo --before before_sig --after after_sig
+
+            Print diff for rbs environment dir
+
+            Examples:
+
+              # Diff dir1 and dir2 for Foo
+              $ rbs diff --format markdown --type-name Foo --before dir1 --after dir2
+
+              # Confirmation of methods related to Time class added by including stdlib/time
+              $ rbs diff --format diff --type-name Time --after stdlib/time
+          HELP
+          o.on("--format NAME")    { |arg| @format = arg }
+          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 }
+        end
+        opt.parse!(argv)
+
+        unless @format && type_name && ["markdown", "diff"].include?(@format)
+          @stderr.puts opt.banner
+          exit 1
+        end
+
+        @diff = RBS::Diff.new(
+          type_name: TypeName(type_name).absolute!,
+          library_options: library_options,
+          after_path: after_path,
+          before_path: before_path
+        )
+      end
+
+      def run
+        public_send("run_#{@format}")
+      end
+
+      def run_diff
+        first = true
+        io = RBS::CLI::ColoredIO.new(stdout: @stdout)
+        @diff.each_diff do |before, after|
+          io.puts if !first
+          io.puts_red   "- #{before}"
+          io.puts_green "+ #{after}"
+          first = false
+        end
+      end
+
+      def run_markdown
+        @stdout.puts "| before | after |"
+        @stdout.puts "| --- | --- |"
+        @diff.each_diff do |before, after|
+          before.gsub!("|", "\\|")
+          after.gsub!("|", "\\|")
+          @stdout.puts "| `#{before}` | `#{after}` |"
+        end
+      end
+    end
+  end
+end

data/lib/rbs/cli.rb

@@ -8,6 +8,9 @@ require "stringio"
 
 module RBS
   class CLI
+    autoload :ColoredIO, 'rbs/cli/colored_io'
+    autoload :Diff, 'rbs/cli/diff'
+
     class LibraryOptions
       attr_accessor :core_root
       attr_accessor :config_path
@@ -90,7 +93,7 @@ module RBS
       @stderr = stderr
     end
 
-    COMMANDS = [:ast, :annotate, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :parse, :test, :collection, :subtract]
+    COMMANDS = [:ast, :annotate, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :parse, :test, :collection, :subtract, :diff]
 
     def parse_logging_options(opts)
       opts.on("--log-level LEVEL", "Specify log level (defaults to `warn`)") do |level|
@@ -433,8 +436,9 @@ EOU
       stdout.puts "  accessibility: #{method.accessibility}"
       stdout.puts "  types:"
       separator = " "
-      for type in method.method_types
-        stdout.puts "    #{separator} #{type}"
+      length_max = method.method_types.map { |type| type.to_s.length }.max or raise
+      method.method_types.each do |type|
+        stdout.puts format("    %s %-#{length_max}s   at %s", separator, type, type.location)
         separator = "|"
       end
     end
@@ -462,6 +466,30 @@ EOU
       builder = DefinitionBuilder.new(env: env)
       validator = Validator.new(env: env, resolver: Resolver::TypeNameResolver.new(env))
 
+      no_self_type_validator = ->(type) {
+        # @type var type: Types::t | MethodType
+        if type.has_self_type?
+          raise "#{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?
+          raise "#{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?
+          raise "#{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|
@@ -471,6 +499,29 @@ EOU
           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(
@@ -479,11 +530,36 @@ EOU
           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
@@ -510,6 +586,10 @@ EOU
           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
@@ -518,11 +598,17 @@ EOU
         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|
@@ -531,6 +617,9 @@ EOU
           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
     end
 
@@ -644,8 +733,10 @@ EOU
         require_libs = []
         relative_libs = []
         merge = false
+        todo = false
         owners_included = []
         outline = false
+        autoload = false
 
         OptionParser.new do |opts|
           opts.banner = <<EOU
@@ -671,26 +762,62 @@ EOU
           opts.on("--merge", "Merge generated prototype RBS with existing RBS") do
             merge = true
           end
+          opts.on("--todo", "Generates only undefined methods compared to objects") do
+            Warning.warn("Geneating prototypes with `--todo` option is experimental\n", category: :experimental)
+            todo = true
+          end
           opts.on("--method-owner CLASS", "Generate method prototypes if the owner of the method is [CLASS]") do |klass|
             owners_included << klass
           end
           opts.on("--outline", "Generates only module/class/constant declaration (no method definition)") do
             outline = true
           end
+          opts.on("--autoload", "Load all autoload path") do
+            autoload = true
+          end
         end.parse!(args)
 
         loader = options.loader()
         env = Environment.from_loader(loader).resolve_type_names
 
-        require_libs.each do |lib|
-          require(lib)
-        end
-
-        relative_libs.each do |lib|
-          eval("require_relative(lib)", binding, "rbs")
+        # @type var autoloader: ^() { () -> void } -> void
+        autoloader = ->(&block) {
+          if autoload
+            hook = Module.new do
+              def autoload(name, path)
+                super
+              end
+            end
+            ::Module.prepend(hook)
+            ::Kernel.prepend(hook)
+
+            arguments = []
+            TracePoint.new(:call) do |tp|
+              base = tp.self.kind_of?(Module) ? tp.self : Kernel
+              name = (tp.binding or raise).local_variable_get(:name)
+              arguments << [base, name]
+            end.enable(target: hook.instance_method(:autoload), &block)
+
+            arguments.each do |(base, name)|
+              begin
+                base.const_get(name)
+              rescue LoadError, StandardError
+              end
+            end
+          else
+            block.call
+          end
+        }
+        autoloader.call do
+          require_libs.each do |lib|
+            require(lib)
+          end
+          relative_libs.each do |lib|
+            eval("require_relative(lib)", binding, "rbs")
+          end
         end
 
-        runtime = Prototype::Runtime.new(patterns: args, env: env, merge: merge, owners_included: owners_included)
+        runtime = Prototype::Runtime.new(patterns: args, env: env, merge: merge, todo: todo, owners_included: owners_included)
         runtime.outline = outline
 
         decls = runtime.decls
@@ -827,7 +954,12 @@ EOU
             output_path = (output_dir + relative_path).sub_ext(".rbs")
 
             parser = new_parser[]
-            parser.parse file_path.read()
+            begin
+              parser.parse file_path.read()
+            rescue SyntaxError
+              stdout.puts "  ⚠️  Unable to parse due to SyntaxError: `#{file_path}`"
+              next
+            end
 
             if output_path.file?
               if force
@@ -1136,11 +1268,10 @@ EOB
           # A directory to install the downloaded RBSs
           path: .gem_rbs_collection
 
-          gems:
-            # Skip loading rbs gem's RBS.
-            # It's unnecessary if you don't use rbs as a library.
-            - name: rbs
-              ignore: true
+          # gems:
+          #   # If you want to avoid installing rbs files for gems, you can specify them here.
+          #   - name: GEM_NAME
+          #     ignore: true
         YAML
         stdout.puts "created: #{config_path}"
       when 'clean'
@@ -1259,5 +1390,9 @@ EOB
         end
       end
     end
+
+    def run_diff(argv, library_options)
+      Diff.new(argv: argv, library_options: library_options, stdout: stdout, stderr: stderr).run
+    end
   end
 end

data/lib/rbs/collection/config/lockfile.rb

@@ -12,7 +12,6 @@ module RBS
           @path = path
           @gemfile_lock_path = gemfile_lock_path
 
-          @sources = {}
           @gems = {}
         end
 
@@ -26,27 +25,15 @@ module RBS
           end
         end
 
-        def each_source(&block)
-          if block
-            sources.each_value(&block)
-            yield Sources::Rubygems.instance
-            yield Sources::Stdlib.instance
-          else
-            enum_for :each_source
-          end
-        end
-
         def to_lockfile
           # @type var data: lockfile_data
 
           data = {
-            "sources" => sources.each_value.sort_by {|s| s.name }.map {|source| source.to_lockfile },
             "path" => path.to_s,
             "gems" => gems.each_value.sort_by {|g| g[:name] }.map {|hash| library_data(hash) },
             "gemfile_lock_path" => gemfile_lock_path.to_s
           }
 
-          data.delete("sources") if sources.empty?
           data.delete("gems") if gems.empty?
 
           data
@@ -60,18 +47,6 @@ module RBS
 
           lockfile = Lockfile.new(lockfile_path: lockfile_path, path: path, gemfile_lock_path: gemfile_lock_path)
 
-          if sources = data["sources"]
-            sources.each do |src|
-              git = Sources::Git.new(
-                name: src["name"],
-                revision: src["revision"],
-                remote: src["remote"],
-                repo_dir: src["repo_dir"]
-              )
-              lockfile.sources[git.name] = git
-            end
-          end
-
           if gems = data["gems"]
             gems.each do |gem|
               src = gem["source"]

data/lib/rbs/collection/config/lockfile_generator.rb

@@ -44,12 +44,6 @@ module RBS
             path: config.repo_path_data,
             gemfile_lock_path: definition.lockfile.relative_path_from(lockfile_dir)
           )
-          config.sources.each do |source|
-            case source
-            when Sources::Git
-              lockfile.sources[source.name] = source
-            end
-          end
 
           if with_lockfile && lockfile_path.file?
             @existing_lockfile = Lockfile.from_lockfile(lockfile_path: lockfile_path, data: YAML.load_file(lockfile_path.to_s))

data/lib/rbs/collection/installer.rb

@@ -25,7 +25,7 @@ module RBS
             stdout: stdout
           )
         end
-        stdout.puts "It's done! #{selected.size} gems' RBSs now installed."
+        CLI::ColoredIO.new(stdout: stdout).puts_green("It's done! #{selected.size} gems' RBSs now installed.")
       end
     end
   end

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

@@ -45,23 +45,25 @@ module RBS
 
           gem_dir = dest.join(name, version)
 
+          colored_io = CLI::ColoredIO.new(stdout: stdout)
+
           case
           when gem_dir.symlink?
-            stdout.puts "Updating to #{format_config_entry(name, version)} from a local source"
+            colored_io.puts_green("Updating to #{format_config_entry(name, version)} from a local source")
             gem_dir.unlink
             _install(dest: dest, name: name, version: version)
           when gem_dir.directory?
             prev = load_metadata(dir: gem_dir)
 
             if prev == metadata_content(name: name, version: version)
-              stdout.puts "Using #{format_config_entry(name, version)}"
+              colored_io.puts "Using #{format_config_entry(name, version)}"
             else
-              stdout.puts "Updating to #{format_config_entry(name, version)} from #{format_config_entry(prev["name"], prev["version"])}"
+              colored_io.puts_green("Updating to #{format_config_entry(name, version)} from #{format_config_entry(prev["name"], prev["version"])}")
               FileUtils.remove_entry_secure(gem_dir.to_s)
               _install(dest: dest, name: name, version: version)
             end
           when !gem_dir.exist?
-            stdout.puts "Installing #{format_config_entry(name, version)}"
+            colored_io.puts_green("Installing #{format_config_entry(name, version)}")
             _install(dest: dest, name: name, version: version)
           else
             raise

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

@@ -7,7 +7,7 @@ module RBS
         include Base
 
         attr_reader :path, :full_path
-  
+
         def initialize(path:, base_directory:)
           # TODO: resolve relative path from dir of rbs_collection.yaml
           @path = Pathname(path)
@@ -33,22 +33,24 @@ module RBS
           from = @full_path.join(name, version)
           gem_dir = dest.join(name, version)
 
+          colored_io = CLI::ColoredIO.new(stdout: stdout)
+
           case
           when gem_dir.symlink? && gem_dir.readlink == from
-            stdout.puts "Using #{name}:#{version} (#{from})"
+            colored_io.puts "Using #{name}:#{version} (#{from})"
           when gem_dir.symlink?
             prev = gem_dir.readlink
             gem_dir.unlink
             _install(from, dest.join(name, version))
-            stdout.puts "Updating #{name}:#{version} to #{from} from #{prev}"
+            colored_io.puts_green("Updating #{name}:#{version} to #{from} from #{prev}")
           when gem_dir.directory?
             # TODO: Show version of git source
             FileUtils.remove_entry_secure(gem_dir.to_s)
             _install(from, dest.join(name, version))
-            stdout.puts "Updating #{name}:#{version} from git source"
+            colored_io.puts_green("Updating #{name}:#{version} from git source")
           when !gem_dir.exist?
             _install(from, dest.join(name, version))
-            stdout.puts "Installing #{name}:#{version} (#{from})"
+            colored_io.puts_green("Installing #{name}:#{version} (#{from})")
           else
             raise
           end