rbs 3.2.2 → 3.3.0

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

data/lib/rbs/diff.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RBS
+  class Diff
+    def initialize(type_name:, library_options:, after_path: [], before_path: [])
+      @type_name = type_name
+      @library_options = library_options
+      @after_path = after_path
+      @before_path = before_path
+    end
+
+    def each_diff(&block)
+      return to_enum(:each_diff) unless block
+
+      before_instance_methods, before_singleton_methods, before_constant_children = build_methods(@before_path)
+      after_instance_methods, after_singleton_methods, after_constant_children = build_methods(@after_path)
+
+      each_diff_methods(:instance, before_instance_methods, after_instance_methods, &block)
+      each_diff_methods(:singleton, before_singleton_methods, after_singleton_methods, &block)
+
+      each_diff_constants(before_constant_children, after_constant_children, &block)
+    end
+
+    private
+
+    def each_diff_methods(kind, before_methods, after_methods)
+      all_keys = before_methods.keys.to_set + after_methods.keys.to_set
+      all_keys.each do |key|
+        before = definition_method_to_s(key, kind, before_methods[key]) or next
+        after = definition_method_to_s(key, kind, after_methods[key]) or next
+        next if before == after
+
+        yield before, after
+      end
+    end
+
+    def each_diff_constants(before_constant_children, after_constant_children)
+      all_keys = before_constant_children.keys.to_set + after_constant_children.keys.to_set
+      all_keys.each do |key|
+        before = constant_to_s(before_constant_children[key]) or next
+        after = constant_to_s(after_constant_children[key]) or next
+        next if before == after
+
+        yield before, after
+      end
+    end
+
+    def build_methods(path)
+      env = build_env(path)
+      builder = build_builder(env)
+
+      instance_methods = begin
+        builder.build_instance(@type_name).methods
+      rescue => e
+        RBS.logger.warn("#{path}: (#{e.class}) #{e.message}")
+        {}
+      end
+      singleton_methods = begin
+        builder.build_singleton(@type_name).methods
+      rescue => e
+        RBS.logger.warn("#{path}: (#{e.class}) #{e.message}")
+        {}
+      end
+
+      constant_children = begin
+        constant_resolver = RBS::Resolver::ConstantResolver.new(builder: builder)
+        constant_resolver.children(@type_name)
+      rescue => e
+        RBS.logger.warn("#{path}: (#{e.class}) #{e.message}")
+        {}
+      end
+
+      [ instance_methods, singleton_methods, constant_children ]
+    end
+
+    def build_env(path)
+      loader = @library_options.loader()
+      path&.each do |dir|
+        dir_pathname = Pathname(dir)
+        loader.add(path: dir_pathname)
+
+        manifest_pathname = dir_pathname / 'manifest.yaml'
+        if manifest_pathname.exist?
+          manifest = YAML.safe_load(manifest_pathname.read)
+          if manifest['dependencies']
+            manifest['dependencies'].each do |dependency|
+              loader.add(library: dependency['name'], version: nil)
+            end
+          end
+        end
+      end
+      Environment.from_loader(loader)
+    end
+
+    def build_builder(env)
+      DefinitionBuilder.new(env: env.resolve_type_names)
+    end
+
+    def definition_method_to_s(key, kind, definition_method)
+      if definition_method
+        prefix = kind == :instance ? "" : "self."
+
+        if definition_method.alias_of
+          "alias #{prefix}#{key} #{prefix}#{definition_method.alias_of.defs.first.member.name}"
+        else
+          "def #{prefix}#{key}: #{definition_method.method_types.join(" | ")}"
+        end
+      else
+        +"-"
+      end
+    end
+
+    def constant_to_s(constant)
+      if constant
+        "#{constant.name.name}: #{constant.type}"
+      else
+        +"-"
+      end
+    end
+  end
+end

data/lib/rbs/environment.rb

@@ -441,7 +441,7 @@ module RBS
 
       when AST::Declarations::Global
         if entry = global_decls[decl.name]
-          raise DuplicatedDeclarationError.new(name, decl, entry.decl)
+          raise DuplicatedDeclarationError.new(decl.name, decl, entry.decl)
         end
 
         global_decls[decl.name] = GlobalEntry.new(name: decl.name, decl: decl, outer: outer)

data/lib/rbs/method_type.rb

@@ -86,6 +86,9 @@ module RBS
         type.each_type(&block)
         self.block&.yield_self do |b|
           b.type.each_type(&block)
+          if b.self_type
+            yield b.self_type
+          end
         end
       else
         enum_for :each_type
@@ -114,5 +117,25 @@ module RBS
     def type_param_names
       type_params.map(&:name)
     end
+
+    def has_self_type?
+      each_type.any? {|type| type.has_self_type? }
+    end
+
+    def has_classish_type?
+      each_type.any? {|type| type.has_classish_type? }
+    end
+
+    def with_nonreturn_void?
+      if type.with_nonreturn_void?
+        true
+      else
+        if block = block()
+          block.type.with_nonreturn_void? || block.self_type&.with_nonreturn_void? || false
+        else
+          false
+        end
+      end
+    end
   end
 end

data/lib/rbs/prototype/rb.rb

@@ -89,8 +89,7 @@ module RBS
               body = "\n" if body.empty?
 
               comment = AST::Comment.new(string: body, location: nil)
-              if (prev_comment = hash[line - 1])
-                hash[line - 1] = nil
+              if prev_comment = hash.delete(line - 1)
                 hash[line] = AST::Comment.new(string: prev_comment.string + comment.string,
                                               location: nil)
               else
@@ -362,13 +361,7 @@ module RBS
           end
 
         when :ITER
-          method_name = node.children.first.children.first
-          case method_name
-          when :refine
-            # ignore
-          else
-            process_children(node, decls: decls, comments: comments, context: context)
-          end
+          # ignore
 
         when :CDECL
           const_name = case

data/lib/rbs/prototype/rbi.rb

@@ -246,7 +246,7 @@ module RBS
               end
             end
             value_node = node.children.last
-            type = if value_node.type == :CALL && value_node.children[1] == :let
+            type = if value_node && value_node.type == :CALL && value_node.children[1] == :let
                      type_node = each_arg(value_node.children[2]).to_a[1]
                      type_of type_node, variables: current_module&.type_params || []
                    else

data/lib/rbs/prototype/runtime/helpers.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RBS
+  module Prototype
+    class Runtime
+      module Helpers
+        private
+
+        # Returns the exact name & not compactly declared name
+        def only_name(mod)
+          # No nil check because this method is invoked after checking if the module exists
+          const_name!(mod).split(/::/).last or raise # (A::B::C) => C
+        end
+
+        def const_name!(const)
+          const_name(const) or raise
+        end
+
+        def const_name(const)
+          @module_name_method ||= Module.instance_method(:name)
+          name = @module_name_method.bind(const).call
+          return nil unless name
+
+          begin
+            deprecated, Warning[:deprecated] = Warning[:deprecated], false
+            Object.const_get(name)
+          rescue NameError
+            # Should generate const name if anonymous or internal module (e.g. NameError::message)
+            nil
+          else
+            name
+          ensure
+            Warning[:deprecated] = deprecated
+          end
+        end
+
+        def to_type_name(name, full_name: false)
+          *prefix, last = name.split(/::/)
+
+          last or raise
+
+          if full_name
+            if prefix.empty?
+              TypeName.new(name: last.to_sym, namespace: Namespace.empty)
+            else
+              TypeName.new(name: last.to_sym, namespace: Namespace.parse(prefix.join("::")))
+            end
+          else
+            TypeName.new(name: last.to_sym, namespace: Namespace.empty)
+          end
+        end
+
+        def untyped
+          @untyped ||= Types::Bases::Any.new(location: nil)
+        end
+      end
+    end
+  end
+end

data/lib/rbs/prototype/runtime/reflection.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RBS
+  module Prototype
+    class Runtime
+      module Reflection
+        def self.object_class(value)
+          @object_class ||= Object.instance_method(:class)
+          @object_class.bind_call(value)
+        end
+
+        def self.constants_of(mod, inherit = true)
+          @constants_of ||= Module.instance_method(:constants)
+          @constants_of.bind_call(mod, inherit)
+        end
+      end
+    end
+  end
+end

data/lib/rbs/prototype/runtime/value_object_generator.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require_relative 'helpers'
+
+module RBS
+  module Prototype
+    class Runtime
+      class ValueObjectBase
+        include Helpers
+
+        def initialize(target_class)
+          @target_class = target_class
+        end
+
+        def build_decl
+          decl = AST::Declarations::Class.new(
+            name: to_type_name(only_name(@target_class)),
+            type_params: [],
+            super_class: build_super_class,
+            members: [],
+            annotations: [],
+            location: nil,
+            comment: nil
+          )
+
+          add_decl_members(decl)
+
+          decl
+        end
+
+        private
+
+        # def self.members: () -> [ :foo, :bar ]
+        # def members: () -> [ :foo, :bar ]
+        def build_s_members
+          [:singleton, :instance].map do |kind|
+            AST::Members::MethodDefinition.new(
+              name: :members,
+              overloads: [
+                AST::Members::MethodDefinition::Overload.new(
+                  annotations: [],
+                  method_type: MethodType.new(
+                    type: Types::Function.empty(
+                      Types::Tuple.new(
+                        types: @target_class.members.map do |member|
+                          if member.to_s.ascii_only?
+                            Types::Literal.new(literal: member, location: nil)
+                          else
+                            BuiltinNames::Symbol.instance_type
+                          end
+                        end,
+                        location: nil
+                      )
+                    ),
+                    type_params: [],
+                    block: nil,
+                    location: nil,
+                  )
+                )
+              ],
+              kind: kind,
+              location: nil,
+              comment: nil,
+              annotations: [],
+              overloading: false,
+              visibility: nil
+            )
+          end
+        end
+
+        # attr_accessor foo: untyped
+        def build_member_accessors(ast_members_class)
+          @target_class.members.map do |member|
+            ast_members_class.new(
+              name: member,
+              ivar_name: nil,
+              type: untyped,
+              kind: :instance,
+              location: nil,
+              comment: nil,
+              annotations: []
+            )
+          end
+        end
+      end
+
+      class StructGenerator < ValueObjectBase
+        def self.generatable?(target)
+          return false unless target < Struct
+          # Avoid direct inherited class like `class Option < Struct`
+          return false unless target.respond_to?(:members)
+
+          true
+        end
+
+        private
+
+        CAN_CALL_KEYWORD_INIT_P = Struct.new(:tmp).respond_to?(:keyword_init?)
+
+        def build_super_class
+          AST::Declarations::Class::Super.new(name: TypeName("::Struct"), args: [untyped], location: nil)
+        end
+
+        def add_decl_members(decl)
+          decl.members.concat build_s_new
+          decl.members.concat build_s_keyword_init_p
+          decl.members.concat build_s_members
+          decl.members.concat build_member_accessors(AST::Members::AttrAccessor)
+        end
+
+        # def self.new: (?untyped foo, ?untyped bar) -> instance
+        #             | (?foo: untyped, ?bar: untyped) -> instance
+        def build_s_new
+          [:new, :[]].map do |name|
+            new_overloads = []
+
+            if CAN_CALL_KEYWORD_INIT_P
+              case @target_class.keyword_init?
+              when false
+                new_overloads << build_overload_for_positional_arguments
+              when true
+                new_overloads << build_overload_for_keyword_arguments
+              when nil
+                new_overloads << build_overload_for_positional_arguments
+                new_overloads << build_overload_for_keyword_arguments
+              else
+                raise
+              end
+            else
+              new_overloads << build_overload_for_positional_arguments
+              new_overloads << build_overload_for_keyword_arguments
+            end
+
+            AST::Members::MethodDefinition.new(
+              name: name,
+              overloads: new_overloads,
+              kind: :singleton,
+              location: nil,
+              comment: nil,
+              annotations: [],
+              overloading: false,
+              visibility: nil
+            )
+          end
+        end
+
+        def build_overload_for_positional_arguments
+          AST::Members::MethodDefinition::Overload.new(
+            annotations: [],
+            method_type: MethodType.new(
+              type: Types::Function.empty(Types::Bases::Instance.new(location: nil)).update(
+                optional_positionals: @target_class.members.map { |m| Types::Function::Param.new(name: m, type: untyped) },
+              ),
+              type_params: [],
+              block: nil,
+              location: nil,
+            )
+          )
+        end
+
+        def build_overload_for_keyword_arguments
+          AST::Members::MethodDefinition::Overload.new(
+            annotations: [],
+            method_type: MethodType.new(
+              type: Types::Function.empty(Types::Bases::Instance.new(location: nil)).update(
+                optional_keywords: @target_class.members.to_h { |m| [m, Types::Function::Param.new(name: nil, type: untyped)] },
+              ),
+              type_params: [],
+              block: nil,
+              location: nil,
+            )
+          )
+        end
+
+        # def self.keyword_init?: () -> bool?
+        def build_s_keyword_init_p
+          return [] unless CAN_CALL_KEYWORD_INIT_P
+
+          return_type = @target_class.keyword_init?.nil? \
+                      ? Types::Bases::Nil.new(location: nil)
+                      : Types::Literal.new(literal: @target_class.keyword_init?, location: nil)
+          type = Types::Function.empty(return_type)
+
+          [
+            AST::Members::MethodDefinition.new(
+              name: :keyword_init?,
+              overloads: [
+                AST::Members::MethodDefinition::Overload.new(
+                  annotations: [],
+                  method_type: MethodType.new(
+                    type: type,
+                    type_params: [],
+                    block: nil,
+                    location: nil,
+                  )
+                )
+              ],
+              kind: :singleton,
+              location: nil,
+              comment: nil,
+              annotations: [],
+              overloading: false,
+              visibility: nil
+            )
+          ]
+        end
+      end
+
+      class DataGenerator < ValueObjectBase
+        def self.generatable?(target)
+          return false unless RUBY_VERSION >= '3.2'
+          return false unless target < Data
+          # Avoid direct inherited class like `class Option < Data`
+          return false unless target.respond_to?(:members)
+
+          true
+        end
+
+        private
+
+        def build_super_class
+          AST::Declarations::Class::Super.new(name: TypeName("::Data"), args: [], location: nil)
+        end
+
+        def add_decl_members(decl)
+          decl.members.concat build_s_new
+          decl.members.concat build_s_members
+          decl.members.concat build_member_accessors(AST::Members::AttrReader)
+        end
+
+        # def self.new: (untyped foo, untyped bar) -> instance
+        #             | (foo: untyped, bar: untyped) -> instance
+        def build_s_new
+          [:new, :[]].map do |name|
+            new_overloads = []
+
+            new_overloads << AST::Members::MethodDefinition::Overload.new(
+              annotations: [],
+              method_type: MethodType.new(
+                type: Types::Function.empty(Types::Bases::Instance.new(location: nil)).update(
+                  required_positionals: @target_class.members.map { |m| Types::Function::Param.new(name: m, type: untyped) },
+                ),
+                type_params: [],
+                block: nil,
+                location: nil,
+              )
+            )
+            new_overloads << AST::Members::MethodDefinition::Overload.new(
+              annotations: [],
+              method_type: MethodType.new(
+                type: Types::Function.empty(Types::Bases::Instance.new(location: nil)).update(
+                  required_keywords: @target_class.members.to_h { |m| [m, Types::Function::Param.new(name: nil, type: untyped)] },
+                ),
+                type_params: [],
+                block: nil,
+                location: nil,
+              )
+            )
+
+            AST::Members::MethodDefinition.new(
+              name: name,
+              overloads: new_overloads,
+              kind: :singleton,
+              location: nil,
+              comment: nil,
+              annotations: [],
+              overloading: false,
+              visibility: nil
+            )
+          end
+        end
+      end
+    end
+  end
+end