rbs 0.18.1 → 1.0.0.pre2

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

@@ -133,7 +133,7 @@ module RBS
 
     def cache_name(cache, name:, decl:, outer:)
       if cache.key?(name)
-        raise DuplicatedDeclarationError.new(name, decl, cache[name].decl)
+        raise DuplicatedDeclarationError.new(_ = name, _ = decl, _ = cache[name].decl)
       end
 
       cache[name] = SingleEntry.new(name: name, decl: decl, outer: outer)
@@ -195,9 +195,6 @@ module RBS
 
       when AST::Declarations::Global
         cache_name global_decls, name: decl.name, decl: decl, outer: outer
-
-      when AST::Declarations::Extension
-        RBS.logger.warn "#{Location.to_string decl.location} Extension construct is deprecated: use class/module syntax instead"
       end
     end
 
@@ -244,7 +241,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|
@@ -325,9 +323,6 @@ module RBS
           location: decl.location,
           comment: decl.comment
         )
-
-      else
-        raise
       end
     end
 
@@ -349,6 +344,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 +354,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 +364,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

@@ -48,7 +48,11 @@ module RBS
     end
 
     def has_library?(library:, version:)
-      self.class.gem_sig_path(library, version) || repository.lookup(library, version)
+      if self.class.gem_sig_path(library, version) || repository.lookup(library, version)
+        true
+      else
+        false
+      end
     end
 
     def load(env:)
@@ -70,7 +74,7 @@ module RBS
 
       libs.each do |lib|
         unless has_library?(version: lib.version, library: lib.name)
-          raise UnknownLibraryError.new(lib: lib) 
+          raise UnknownLibraryError.new(lib: lib)
         end
 
         case
@@ -97,12 +101,12 @@ module RBS
         if path.basename.to_s.start_with?("_")
           if skip_hidden
             unless immediate
-              return 
+              return
             end
           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/errors.rb

@@ -35,51 +35,25 @@ module RBS
     end
   end
 
-  class InvalidExtensionParameterError < StandardError
-    attr_reader :type_name
-    attr_reader :extension_name
-    attr_reader :location
-    attr_reader :extension_params
-    attr_reader :class_params
-
-    def initialize(type_name:, extension_name:, extension_params:, class_params:, location:)
-      @type_name = type_name
-      @extension_name = extension_name
-      @extension_params = extension_params
-      @class_params = class_params
-      @location = location
-
-      super "#{Location.to_string location}: Expected #{class_params.size} parameters to #{type_name} (#{extension_name}) but has #{extension_params.size} parameters"
-    end
-
-    def self.check!(type_name:, extension_name:, extension_params:, class_params:, location:)
-      unless extension_params.size == class_params.size
-        raise new(type_name: type_name,
-                  extension_name: extension_name,
-                  extension_params: extension_params,
-                  class_params: class_params,
-                  location: location)
-      end
-    end
-  end
-
   class RecursiveAncestorError < StandardError
     attr_reader :ancestors
     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:)
@@ -160,6 +134,8 @@ module RBS
               env.class_decls
             when type_name.interface?
               env.interface_decls
+            else
+              raise
             end
 
       dic.key?(type_name) or raise new(type_name: type_name, location: self_type.location)
@@ -187,6 +163,8 @@ module RBS
               env.class_decls
             when type_name.interface?
               env.interface_decls
+            else
+              raise
             end
 
       dic.key?(type_name) or raise new(type_name: type_name, member: member)
@@ -194,44 +172,60 @@ 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}"
+      message = "#{Location.to_string location}: #{qualified_method_name} has duplicated definitions"
+      if members.size > 1
+        message << " in #{other_locations.map { |loc| Location.to_string loc }.join(', ')}"
+      end
+      super message
     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
-  end
 
-  class MethodDefinitionConflictWithInterfaceMixinError < StandardError
-    include MethodNameHelper
+    def location
+      members[0].location
+    end
 
-    attr_reader :type_name
+    def other_locations
+      members.drop(1).map(&:location)
+    end
+  end
+
+  class DuplicatedInterfaceMethodDefinitionError < StandardError
+    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,48 +241,19 @@ 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
     attr_reader :name
     attr_reader :entry
 
-    def initialize(name:, super_classes:, entry:)
+    def initialize(name:, entry:)
       @name = name
       @entry = entry
       super "#{Location.to_string entry.primary.decl.location}: Superclass mismatch: #{name}"
     end
   end
 
-  class InconsistentMethodVisibilityError < StandardError
-    attr_reader :type_name
-    attr_reader :method_name
-    attr_reader :kind
-    attr_reader :member_pairs
-
-    def initialize(type_name:, method_name:, kind:, member_pairs:)
-      @type_name = type_name
-      @method_name = method_name
-      @kind = kind
-      @member_pairs = member_pairs
-
-      delimiter = case kind
-                  when :instance
-                    "#"
-                  when :singleton
-                    "."
-                  end
-
-      super "#{Location.to_string member_pairs[0][0].location}: Inconsistent method visibility: #{type_name}#{delimiter}#{method_name}"
-    end
-  end
-
   class InvalidOverloadMethodError < StandardError
     attr_reader :type_name
     attr_reader :method_name
@@ -331,38 +296,40 @@ module RBS
       @name = name
       @decls = decls
 
-      super "#{Location.to_string decls.last.location}: Duplicated declaration: #{name}"
+      last_decl = decls.last or raise
+      super "#{Location.to_string last_decl.location}: Duplicated declaration: #{name}"
     end
   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
+      first_def = defs.first or raise
+      original = first_def.original or raise
+      original.location
     end
   end
 end