rbs 3.2.2 → 3.3.0.pre.1

data/lib/rbs/diff.rb

@@ -0,0 +1,104 @@
+# 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_decls = build_methods(@before_path)
+      after_instance_methods, after_singleton_methods, after_constant_decls = 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_decls, after_constant_decls, &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_decls, after_constant_decls)
+      all_keys = before_constant_decls.keys.to_set + after_constant_decls.keys.to_set
+      all_keys.each do |key|
+        before = constant_to_s(key, before_constant_decls[key]) or next
+        after = constant_to_s(key, after_constant_decls[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.message}")
+        {}
+      end
+      singleton_methods = begin
+        builder.build_singleton(@type_name).methods
+      rescue => e
+        RBS.logger.warn("#{path}: #{e.message}")
+        {}
+      end
+      type_name_to_s = @type_name.to_s
+      constant_decls = env.constant_decls.select { |key| key.to_s.start_with?(type_name_to_s) }
+
+      [ instance_methods, singleton_methods, constant_decls ]
+    end
+
+    def build_env(path)
+      loader = @library_options.loader()
+      path&.each do |dir|
+        loader.add(path: Pathname(dir))
+      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(key, constant)
+      if constant
+        "#{key}: #{constant.decl.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/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/value_object_generator.rb

@@ -0,0 +1,236 @@
+# 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
+        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 ? (@target_class.keyword_init? == false || @target_class.keyword_init? == nil) : true
+              new_overloads << 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
+            if CAN_CALL_KEYWORD_INIT_P ? (@target_class.keyword_init? == true || @target_class.keyword_init? == nil) : true
+              new_overloads << 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
+
+            AST::Members::MethodDefinition.new(
+              name: name,
+              overloads: new_overloads,
+              kind: :singleton,
+              location: nil,
+              comment: nil,
+              annotations: [],
+              overloading: false,
+              visibility: nil
+            )
+          end
+        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 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