rbs 0.18.0 → 1.0.0.pre

data/lib/rbs/definition_builder/method_builder.rb

@@ -0,0 +1,217 @@
+module RBS
+  class DefinitionBuilder
+    class MethodBuilder
+      class Methods
+        Definition = Struct.new(:name, :type, :originals, :overloads, :accessibilities, keyword_init: true) do
+          def original
+            originals[0]
+          end
+
+          def accessibility
+            accessibilities[0]
+          end
+
+          def self.empty(name:, type:)
+            new(type: type, name: name, originals: [], overloads: [], accessibilities: [])
+          end
+        end
+
+        attr_reader :type
+        attr_reader :methods
+
+        def initialize(type:)
+          @type = type
+          @methods = {}
+        end
+
+        def validate!
+          methods.each_value do |defn|
+            if defn.originals.size > 1
+              raise DuplicatedMethodDefinitionError.new(
+                type: type,
+                method_name: defn.name,
+                members: defn.originals
+              )
+            end
+          end
+
+          self
+        end
+
+        def each
+          if block_given?
+            Sorter.new(methods).each_strongly_connected_component do |scc|
+              if scc.size > 1
+                raise RecursiveAliasDefinitionError.new(type: type, defs: scc)
+              end
+
+              yield scc[0]
+            end
+          else
+            enum_for :each
+          end
+        end
+
+        class Sorter
+          include TSort
+
+          attr_reader :methods
+
+          def initialize(methods)
+            @methods = methods
+          end
+
+          def tsort_each_node(&block)
+            methods.each_value(&block)
+          end
+
+          def tsort_each_child(defn)
+            if (member = defn.original).is_a?(AST::Members::Alias)
+              if old = methods[member.old_name]
+                yield old
+              end
+            end
+          end
+        end
+      end
+
+      attr_reader :env
+      attr_reader :instance_methods
+      attr_reader :singleton_methods
+      attr_reader :interface_methods
+
+      def initialize(env:)
+        @env = env
+
+        @instance_methods = {}
+        @singleton_methods = {}
+        @interface_methods = {}
+      end
+
+      def build_instance(type_name)
+        instance_methods[type_name] ||=
+          begin
+            entry = env.class_decls[type_name]
+            args = Types::Variable.build(entry.type_params.each.map(&:name))
+            type = Types::ClassInstance.new(name: type_name, args: args, location: nil)
+            Methods.new(type: type).tap do |methods|
+              entry.decls.each do |d|
+                each_member_with_accessibility(d.decl.members) do |member, accessibility|
+                  case member
+                  when AST::Members::MethodDefinition
+                    if member.instance?
+                      build_method(methods, type, member: member, accessibility: accessibility)
+                    end
+                  when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
+                    if member.kind == :instance
+                      build_attribute(methods, type, member: member, accessibility: accessibility)
+                    end
+                  when AST::Members::Alias
+                    if member.kind == :instance
+                      build_alias(methods, type, member: member, accessibility: accessibility)
+                    end
+                  end
+                end
+              end
+            end.validate!
+          end
+      end
+
+      def build_singleton(type_name)
+        singleton_methods[type_name] ||=
+          begin
+            entry = env.class_decls[type_name]
+            type = Types::ClassSingleton.new(name: type_name, location: nil)
+
+            Methods.new(type: type).tap do |methods|
+              entry.decls.each do |d|
+                each_member_with_accessibility(d.decl.members) do |member, accessibility|
+                  case member
+                  when AST::Members::MethodDefinition
+                    if member.singleton?
+                      build_method(methods, type, member: member, accessibility: accessibility)
+                    end
+                  when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
+                    if member.kind == :singleton
+                      build_attribute(methods, type, member: member, accessibility: accessibility)
+                    end
+                  when AST::Members::Alias
+                    if member.kind == :singleton
+                      build_alias(methods, type, member: member, accessibility: accessibility)
+                    end
+                  end
+                end
+              end
+            end.validate!
+          end
+      end
+
+      def build_interface(type_name)
+        interface_methods[type_name] ||=
+          begin
+            entry = env.interface_decls[type_name]
+            args = Types::Variable.build(entry.decl.type_params.each.map(&:name))
+            type = Types::Interface.new(name: type_name, args: args, location: nil)
+
+            Methods.new(type: type).tap do |methods|
+              entry.decl.members.each do |member|
+                case member
+                when AST::Members::MethodDefinition
+                  build_method(methods, type, member: member, accessibility: :public)
+                when AST::Members::Alias
+                  build_alias(methods, type, member: member, accessibility: :public)
+                end
+              end
+            end.validate!
+          end
+      end
+
+      def build_alias(methods, type, member:, accessibility:)
+        defn = methods.methods[member.new_name] ||= Methods::Definition.empty(type: type, name: member.new_name)
+
+        defn.originals << member
+        defn.accessibilities << accessibility
+      end
+
+      def build_attribute(methods, type, member:, accessibility:)
+        if member.is_a?(AST::Members::AttrReader) || member.is_a?(AST::Members::AttrAccessor)
+          defn = methods.methods[member.name] ||= Methods::Definition.empty(type: type, name: member.name)
+
+          defn.accessibilities << accessibility
+          defn.originals << member
+        end
+
+        if member.is_a?(AST::Members::AttrWriter) || member.is_a?(AST::Members::AttrAccessor)
+          defn = methods.methods[:"#{member.name}="] ||= Methods::Definition.empty(type: type, name: :"#{member.name}=")
+
+          defn.accessibilities << accessibility
+          defn.originals << member
+        end
+      end
+
+      def build_method(methods, type, member:, accessibility:)
+        defn = methods.methods[member.name] ||= Methods::Definition.empty(type: type, name: member.name)
+
+        if member.overload?
+          defn.overloads << member
+        else
+          defn.accessibilities << accessibility
+          defn.originals << member
+        end
+      end
+
+      def each_member_with_accessibility(members, accessibility: :public)
+        members.each do |member|
+          case member
+          when AST::Members::Public
+            accessibility = :public
+          when AST::Members::Private
+            accessibility = :private
+          else
+            yield member, accessibility
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/environment.rb

@@ -244,7 +244,8 @@ module RBS
           super_class: decl.super_class&.yield_self do |super_class|
             AST::Declarations::Class::Super.new(
               name: absolute_type_name(resolver, super_class.name, context: context),
-              args: super_class.args.map {|type| absolute_type(resolver, type, context: context) }
+              args: super_class.args.map {|type| absolute_type(resolver, type, context: context) },
+              location: super_class.location
             )
           end,
           members: decl.members.map do |member|
@@ -349,6 +350,7 @@ module RBS
         AST::Members::AttrAccessor.new(
           name: member.name,
           type: absolute_type(resolver, member.type, context: context),
+          kind: member.kind,
           annotations: member.annotations,
           comment: member.comment,
           location: member.location,
@@ -358,6 +360,7 @@ module RBS
         AST::Members::AttrReader.new(
           name: member.name,
           type: absolute_type(resolver, member.type, context: context),
+          kind: member.kind,
           annotations: member.annotations,
           comment: member.comment,
           location: member.location,
@@ -367,6 +370,7 @@ module RBS
         AST::Members::AttrWriter.new(
           name: member.name,
           type: absolute_type(resolver, member.type, context: context),
+          kind: member.kind,
           annotations: member.annotations,
           comment: member.comment,
           location: member.location,

data/lib/rbs/environment_loader.rb

@@ -102,7 +102,7 @@ module RBS
           end
         end
 
-        path.each_child do |child|
+        path.children.sort.each do |child|
           each_file(child, immediate: false, skip_hidden: skip_hidden, &block)
         end
       end

data/lib/rbs/environment_walker.rb

@@ -53,11 +53,11 @@ module RBS
           definition = builder.build_interface(name)
           unless only_ancestors?
             definition.each_type do |type|
-              each_type_name type, &block
+              each_type_node type, &block
             end
           end
         when name.alias?
-          each_type_name builder.expand_alias(name), &block
+          each_type_node builder.expand_alias(name), &block
         else
           raise "Unexpected TypeNameNode with type_name=#{name}"
         end
@@ -77,7 +77,7 @@ module RBS
 
               unless only_ancestors?
                 ancestor.args.each do |type|
-                  each_type_name type, &block
+                  each_type_node type, &block
                 end
               end
             when Definition::Ancestor::Singleton
@@ -88,13 +88,19 @@ module RBS
 
         unless only_ancestors?
           definition.each_type do |type|
-            each_type_name type, &block
+            each_type_node type, &block
           end
         end
       end
     end
 
     def each_type_name(type, &block)
+      each_type_node(type) do |node|
+        yield node.type_name
+      end
+    end
+
+    def each_type_node(type, &block)
       case type
       when RBS::Types::Bases::Any
       when RBS::Types::Bases::Class
@@ -111,30 +117,30 @@ module RBS
       when RBS::Types::ClassInstance
         yield InstanceNode.new(type_name: type.name)
         type.args.each do |ty|
-          each_type_name(ty, &block)
+          each_type_node(ty, &block)
         end
       when RBS::Types::Interface
         yield TypeNameNode.new(type_name: type.name)
         type.args.each do |ty|
-          each_type_name(ty, &block)
+          each_type_node(ty, &block)
         end
       when RBS::Types::Alias
         yield TypeNameNode.new(type_name: type.name)
       when RBS::Types::Union, RBS::Types::Intersection, RBS::Types::Tuple
         type.types.each do |ty|
-          each_type_name ty, &block
+          each_type_node ty, &block
         end
       when RBS::Types::Optional
-        each_type_name type.type, &block
+        each_type_node type.type, &block
       when RBS::Types::Literal
         # nop
       when RBS::Types::Record
         type.fields.each_value do |ty|
-          each_type_name ty, &block
+          each_type_node ty, &block
         end
       when RBS::Types::Proc
         type.each_type do |ty|
-          each_type_name ty, &block
+          each_type_node ty, &block
         end
       else
         raise "Unexpected type given: #{type}"

data/lib/rbs/errors.rb

@@ -68,18 +68,20 @@ module RBS
     attr_reader :location
 
     def initialize(ancestors:, location:)
-      last = case last = ancestors.last
-             when Definition::Ancestor::Singleton
-               "singleton(#{last.name})"
-             when Definition::Ancestor::Instance
-               if last.args.empty?
-                 last.name.to_s
-               else
-                 "#{last.name}[#{last.args.join(", ")}]"
-               end
-             end
-
-      super "#{Location.to_string location}: Detected recursive ancestors: #{last}"
+      names = ancestors.map do |ancestor|
+        case ancestor
+        when Definition::Ancestor::Singleton
+          "singleton(#{ancestor.name})"
+        when Definition::Ancestor::Instance
+          if ancestor.args.empty?
+            ancestor.name.to_s
+          else
+            "#{ancestor.name}[#{ancestor.args.join(", ")}]"
+          end
+        end
+      end
+
+      super "#{Location.to_string location}: Detected recursive ancestors: #{names.join(" < ")}"
     end
 
     def self.check!(self_ancestor, ancestors:, location:)
@@ -194,44 +196,54 @@ module RBS
   end
 
   class DuplicatedMethodDefinitionError < StandardError
-    attr_reader :decl
-    attr_reader :location
+    attr_reader :type
+    attr_reader :method_name
+    attr_reader :members
 
-    def initialize(decl:, name:, location:)
-      decl_str = case decl
-                 when AST::Declarations::Interface, AST::Declarations::Class, AST::Declarations::Module
-                   decl.name.to_s
-                 when AST::Declarations::Extension
-                   "#{decl.name} (#{decl.extension_name})"
-                 end
+    def initialize(type:, method_name:, members:)
+      @type = type
+      @method_name = method_name
+      @members = members
 
-      super "#{Location.to_string location}: #{decl_str} has duplicated method definition: #{name}"
+      super "#{Location.to_string location}: #{qualified_method_name} has duplicated definitions"
     end
 
-    def self.check!(decl:, methods:, name:, location:)
-      if methods.key?(name)
-        raise new(decl: decl, name: name, location: location)
+    def qualified_method_name
+      case type
+      when Types::ClassSingleton
+        "#{type.name}.#{method_name}"
+      else
+        "#{type.name}##{method_name}"
       end
     end
+
+    def location
+      members[0].location
+    end
   end
 
-  class MethodDefinitionConflictWithInterfaceMixinError < StandardError
+  class DuplicatedInterfaceMethodDefinitionError < StandardError
     include MethodNameHelper
 
-    attr_reader :type_name
+    attr_reader :type
     attr_reader :method_name
-    attr_reader :kind
-    attr_reader :mixin_member
-    attr_reader :entries
+    attr_reader :member
 
-    def initialize(type_name:, method_name:, kind:, mixin_member:, entries:)
-      @type_name = type_name
+    def initialize(type:, method_name:, member:)
+      @type = type
       @method_name = method_name
-      @kind = kind
-      @mixin_member = mixin_member
-      @entries = entries
+      @member = member
 
-      super "#{entries[0].decl.location}: Duplicated method with interface mixin: #{method_name_string}"
+      super "#{member.location}: Duplicated method definition: #{qualified_method_name}"
+    end
+
+    def qualified_method_name
+      case type
+      when Types::ClassSingleton
+        "#{type.name}.#{method_name}"
+      else
+        "#{type.name}##{method_name}"
+      end
     end
   end
 
@@ -247,12 +259,6 @@ module RBS
 
       super "#{Location.to_string location}: Unknown method alias name: #{original_name} => #{aliased_name}"
     end
-
-    def self.check!(methods:, original_name:, aliased_name:, location:)
-      unless methods.key?(original_name)
-        raise new(original_name: original_name, aliased_name: aliased_name, location: location)
-      end
-    end
   end
 
   class SuperclassMismatchError < StandardError
@@ -336,33 +342,32 @@ module RBS
   end
 
   class InvalidVarianceAnnotationError < StandardError
-    MethodTypeError = Struct.new(:method_name, :method_type, :param, keyword_init: true)
-    InheritanceError = Struct.new(:super_class, :param, keyword_init: true)
-    MixinError = Struct.new(:include_member, :param, keyword_init: true)
+    attr_reader :type_name
+    attr_reader :param
+    attr_reader :location
 
-    attr_reader :decl
-    attr_reader :errors
+    def initialize(type_name:, param:, location:)
+      @type_name = type_name
+      @param = param
+      @location = location
 
-    def initialize(decl:, errors:)
-      @decl = decl
-      @errors = errors
-
-      message = [
-        "#{Location.to_string decl.location}: Invalid variance annotation: #{decl.name}"
-      ]
-
-      errors.each do |error|
-        case error
-        when MethodTypeError
-          message << "  MethodTypeError (#{error.param.name}): on `#{error.method_name}` #{error.method_type.to_s} (#{error.method_type.location&.start_line})"
-        when InheritanceError
-          message << "  InheritanceError: #{error.super_class}"
-        when MixinError
-          message << "  MixinError: #{error.include_member.name} (#{error.include_member.location&.start_line})"
-        end
-      end
+      super "#{Location.to_string location}: Type parameter variance error: #{param.name} is #{param.variance} but used as incompatible variance"
+    end
+  end
+
+  class RecursiveAliasDefinitionError < StandardError
+    attr_reader :type
+    attr_reader :defs
 
-      super message.join("\n")
+    def initialize(type:, defs:)
+      @type = type
+      @defs = defs
+
+      super "#{Location.to_string location}: Recursive aliases in #{type}: #{defs.map(&:name).join(", ")}"
+    end
+
+    def location
+      defs[0].original.location
     end
   end
 end