rbs 1.1.0 → 1.3.0

data/lib/rbs/definition_builder.rb

@@ -746,6 +746,20 @@ module RBS
                               end
             )
           end
+
+          defs = method.defs.map do |defn|
+            defn.update(
+              type: sub.empty? ? defn.type : defn.type.sub(sub),
+              implemented_in: case implemented_in
+                              when :keep
+                                defn.implemented_in
+                              when nil
+                                nil
+                              else
+                                implemented_in
+                              end
+            )
+          end
         end
 
         super_method = methods[name]
@@ -760,26 +774,10 @@ module RBS
     end
 
     def try_cache(type_name, cache:, key: type_name)
-      # @type var cc: Hash[untyped, Definition | false | nil]
+      # @type var cc: Hash[untyped, Definition | nil]
       cc = _ = cache
-      cached = cc[key]
 
-      case cached
-      when Definition
-        cached
-      when false
-        raise
-      when nil
-        cc[key] = false
-        begin
-          cc[key] = yield
-        rescue => ex
-          cc.delete(key)
-          raise ex
-        end
-      else
-        raise
-      end
+      cc[key] ||= yield
     end
 
     def expand_alias(type_name)

data/lib/rbs/definition_builder/ancestor_builder.rb

@@ -237,6 +237,7 @@ module RBS
         end
 
         mixin_ancestors(entry,
+                        type_name,
                         included_modules: ancestors.included_modules,
                         included_interfaces: ancestors.included_interfaces,
                         prepended_modules: ancestors.prepended_modules,
@@ -284,6 +285,7 @@ module RBS
         end
 
         mixin_ancestors(entry,
+                        type_name,
                         included_modules: nil,
                         included_interfaces: nil,
                         prepended_modules: nil,
@@ -301,6 +303,7 @@ module RBS
 
             OneAncestors.interface(type_name: type_name, params: params).tap do |ancestors|
               mixin_ancestors0(entry.decl,
+                               type_name,
                                align_params: nil,
                                included_modules: nil,
                                included_interfaces: ancestors.included_interfaces,
@@ -311,7 +314,7 @@ module RBS
           end
       end
 
-      def mixin_ancestors0(decl, align_params:, included_modules:, included_interfaces:, extended_modules:, prepended_modules:, extended_interfaces:)
+      def mixin_ancestors0(decl, type_name, align_params:, included_modules:, included_interfaces:, extended_modules:, prepended_modules:, extended_interfaces:)
         decl.each_mixin do |member|
           case member
           when AST::Members::Include
@@ -321,6 +324,7 @@ module RBS
 
             case
             when member.name.class? && included_modules
+              MixinClassError.check!(type_name: type_name, env: env, member: member)
               NoMixinFoundError.check!(member.name, env: env, member: member)
               included_modules << ancestor
             when member.name.interface? && included_interfaces
@@ -330,6 +334,7 @@ module RBS
 
           when AST::Members::Prepend
             if prepended_modules
+              MixinClassError.check!(type_name: type_name, env: env, member: member)
               NoMixinFoundError.check!(member.name, env: env, member: member)
 
               module_name = member.name
@@ -345,6 +350,7 @@ module RBS
 
             case
             when member.name.class? && extended_modules
+              MixinClassError.check!(type_name: type_name, env: env, member: member)
               NoMixinFoundError.check!(member.name, env: env, member: member)
               extended_modules << ancestor
             when member.name.interface? && extended_interfaces
@@ -355,7 +361,7 @@ module RBS
         end
       end
 
-      def mixin_ancestors(entry, included_modules:, included_interfaces:, extended_modules:, prepended_modules:, extended_interfaces:)
+      def mixin_ancestors(entry, type_name, included_modules:, included_interfaces:, extended_modules:, prepended_modules:, extended_interfaces:)
         entry.decls.each do |d|
           decl = d.decl
 
@@ -365,6 +371,7 @@ module RBS
           )
 
           mixin_ancestors0(decl,
+                           type_name,
                            align_params: align_params,
                            included_modules: included_modules,
                            included_interfaces: included_interfaces,
@@ -508,6 +515,7 @@ module RBS
         included_interfaces = one_ancestors.included_interfaces or raise
         included_interfaces.each do |a|
           included_ancestors = interface_ancestors(a.name, building_ancestors: building_ancestors)
+
           ancestors.unshift(*included_ancestors.apply(a.args, location: entry.decl.location))
         end
 

data/lib/rbs/definition_builder/method_builder.rb

@@ -2,9 +2,11 @@ module RBS
   class DefinitionBuilder
     class MethodBuilder
       class Methods
-        Definition = Struct.new(:name, :type, :originals, :overloads, :accessibilities, keyword_init: true) do
+        Definition = _ = Struct.new(:name, :type, :originals, :overloads, :accessibilities, keyword_init: true) do
+          # @implements Definition
+
           def original
-            originals[0]
+            originals.first
           end
 
           def accessibility

data/lib/rbs/errors.rb

@@ -350,4 +350,40 @@ module RBS
       original.location
     end
   end
+
+  class MixinClassError < DefinitionError
+    attr_reader :type_name
+    attr_reader :member
+
+    def initialize(type_name:, member:)
+      @type_name = type_name
+      @member = member
+
+      super "#{Location.to_string member.location}: Cannot #{mixin_name} a class `#{member.name}` in the definition of `#{type_name}`"
+    end
+
+    def location
+      member.location
+    end
+
+    def self.check!(type_name:, env:, member:)
+      case env.class_decls[member.name]
+      when Environment::ClassEntry
+        raise new(type_name: type_name, member: member)
+      end
+    end
+
+    private
+
+    def mixin_name
+      case member
+      when AST::Members::Prepend
+        "prepend"
+      when AST::Members::Include
+        "include"
+      when AST::Members::Extend
+        "extend"
+      end
+    end
+  end
 end

data/lib/rbs/location.rb

@@ -42,6 +42,10 @@ module RBS
       @end_loc ||= buffer.pos_to_loc(end_pos)
     end
 
+    def range
+      start_pos...end_pos
+    end
+
     def source
       @source ||= buffer.content[start_pos...end_pos] or raise
     end
@@ -94,7 +98,7 @@ module RBS
         loc.start_pos == end_pos
     end
 
-    def to_json(*args)
+    def to_json(state = _ = nil)
       {
         start: {
           line: start_line,
@@ -107,7 +111,107 @@ module RBS
         buffer: {
           name: name&.to_s
         }
-      }.to_json(*args)
+      }.to_json(state)
+    end
+
+    def with_children(required: {}, optional: {})
+      # @type var required: Hash[Symbol, Range[Integer] | Location]
+      # @type var optional: Hash[Symbol, Range[Integer] | Location | nil]
+
+      this = WithChildren.new(buffer: buffer, start_pos: start_pos, end_pos: end_pos)
+
+      req = required.transform_values do |value|
+        case value
+        when Location
+          value.range
+        else
+          value
+        end
+      end
+
+      opt = optional.transform_values do |value|
+        case value
+        when Location
+          value.range
+        else
+          value
+        end
+      end
+
+      this.required_children.merge!(req)
+      this.optional_children.merge!(opt)
+
+      this
+    end
+
+    class WithChildren < Location
+      attr_reader :required_children, :optional_children
+
+      def initialize(buffer:, start_pos:, end_pos:)
+        super(buffer: buffer, start_pos: start_pos, end_pos: end_pos)
+
+        @optional_children = {}
+        @required_children = {}
+      end
+
+      def initialize_copy(from)
+        required_children.merge!(from.required_children)
+        optional_children.merge!(from.optional_children)
+        self
+      end
+
+      def [](key)
+        case
+        when required_children.key?(_ = key)
+          range = required_children[_ = key]
+          Location.new(buffer: buffer, start_pos: range.begin, end_pos: range.end)
+        when optional_children.key?(_ = key)
+          range = required_children[_ = key] || optional_children[_ = key]
+          if range
+            Location.new(buffer: buffer, start_pos: range.begin, end_pos: range.end)
+          end
+        else
+          raise "Unknown key given: `#{key}`"
+        end
+      end
+
+      def merge_required(hash)
+        this = dup
+
+        h = hash.transform_values do |value|
+          case value
+          when Range
+            value
+          when Location
+            value.range
+          else
+            raise
+          end
+        end
+
+        this.required_children.merge!(h)
+
+        this
+      end
+
+      def merge_optional(hash)
+        this = dup
+
+        h = hash.transform_values do |value|
+          case value
+          when Range
+            value
+          when Location
+            value.range
+          else
+            nil
+          end
+        end
+
+        this.optional_children.merge!(h)
+
+        this
+      end
     end
   end
 end

data/lib/rbs/locator.rb

@@ -0,0 +1,205 @@
+module RBS
+  class Locator
+    attr_reader :decls
+
+    def initialize(decls:)
+      @decls = decls
+    end
+
+    def buffer
+      decls[0].location&.buffer or raise
+    end
+
+    def find(line:, column:)
+      pos = buffer.loc_to_pos([line, column])
+
+      decls.each do |decl|
+        array = []
+        find_in_decl(pos, decl: decl, array: array) and return array
+      end
+
+      []
+    end
+
+    def find2(line:, column:)
+      path = find(line: line, column: column)
+
+      return if path.empty?
+
+      hd, *tl = path
+      if hd.is_a?(Symbol)
+        [hd, tl]
+      else
+        [nil, path]
+      end
+    end
+
+    def find_in_decl(pos, decl:, array:)
+      if test_loc(pos, location: decl.location)
+        array.unshift(decl)
+
+        case decl
+        when AST::Declarations::Class
+          decl.type_params.each do |param|
+            if test_loc(pos, location: param.location)
+              array.unshift(param)
+              find_in_loc(pos, array: array, location: param.location)
+              return true
+            end
+          end
+
+          if super_class = decl.super_class
+            if test_loc(pos, location: super_class.location)
+              array.unshift(super_class)
+              find_in_loc(pos, array: array, location: super_class.location)
+              return true
+            end
+          end
+
+          decl.each_decl do |decl_|
+            find_in_decl(pos, decl: decl_, array: array) and return true
+          end
+
+          decl.each_member do |member|
+            find_in_member(pos, array: array, member: member) and return true
+          end
+
+        when AST::Declarations::Module
+          decl.type_params.each do |param|
+            if test_loc(pos, location: param.location)
+              array.unshift(param)
+              find_in_loc(pos, array: array, location: param.location)
+              return true
+            end
+          end
+
+          decl.self_types.each do |self_type|
+            if test_loc(pos, location: self_type.location)
+              array.unshift(self_type)
+              find_in_loc(pos, array: array, location: self_type.location)
+              return true
+            end
+          end
+
+          decl.each_decl do |decl_|
+            find_in_decl(pos, decl: decl_, array: array) and return true
+          end
+
+          decl.each_member do |member|
+            find_in_member(pos, array: array, member: member) and return true
+          end
+
+        when AST::Declarations::Interface
+          decl.type_params.each do |param|
+            if test_loc(pos, location: param.location)
+              array.unshift(param)
+              find_in_loc(pos, array: array, location: param.location)
+              return true
+            end
+          end
+
+          decl.members.each do |member|
+            find_in_member(pos, array: array, member: member) and return true
+          end
+
+        when AST::Declarations::Constant, AST::Declarations::Global
+          find_in_type(pos, array: array, type: decl.type) and return true
+
+        when AST::Declarations::Alias
+          find_in_type(pos, array: array, type: decl.type) and return true
+        end
+
+        find_in_loc(pos, location: decl.location, array: array)
+
+        true
+      else
+        false
+      end
+    end
+
+    def find_in_member(pos, member:, array:)
+      if test_loc(pos, location: member.location)
+        array.unshift(member)
+
+        case member
+        when AST::Members::MethodDefinition
+          member.types.each do |method_type|
+            find_in_method_type(pos, array: array, method_type: method_type) and return true
+          end
+        when AST::Members::InstanceVariable, AST::Members::ClassInstanceVariable, AST::Members::ClassVariable
+          find_in_type(pos, array: array, type: member.type) and return true
+        when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
+          find_in_type(pos, array: array, type: member.type) and return true
+        end
+
+        find_in_loc(pos, location: member.location, array: array)
+
+        true
+      else
+        false
+      end
+    end
+
+    def find_in_method_type(pos, method_type:, array:)
+      if test_loc(pos, location: method_type.location)
+        array.unshift(method_type)
+
+        method_type.each_type do |type|
+          find_in_type(pos, array: array, type: type) and break
+        end
+
+        true
+      else
+        false
+      end
+    end
+
+    def find_in_type(pos, type:, array:)
+      if test_loc(pos, location: type.location)
+        array.unshift(type)
+
+        type.each_type do |type_|
+          find_in_type(pos, array: array, type: type_) and return true
+        end
+
+        find_in_loc(pos, array: array, location: type.location)
+
+        true
+      else
+        false
+      end
+    end
+
+    def find_in_loc(pos, location:, array:)
+      if test_loc(pos, location: location)
+        if location.is_a?(Location::WithChildren)
+          location.optional_children.each do |key, range|
+            if range === pos
+              array.unshift(key)
+              return true
+            end
+          end
+
+          location.required_children.each do |key, range|
+            if range === pos
+              array.unshift(key)
+              return true
+            end
+          end
+        end
+
+        true
+      else
+        false
+      end
+    end
+
+    def test_loc(pos, location:)
+      if location
+        location.range === pos
+      else
+        false
+      end
+    end
+  end
+end