rbs 0.4.0 → 0.5.0

data/lib/rbs/environment_walker.rb

@@ -23,13 +23,9 @@ module RBS
     include TSort
 
     def tsort_each_node(&block)
-      env.each_decl do |name|
-        yield name.absolute!
-      end
-
-      env.each_alias do |name, _|
-        yield name.absolute!
-      end
+      env.class_decls.each_key(&block)
+      env.interface_decls.each_key(&block)
+      env.alias_decls.each_key(&block)
     end
 
     def tsort_each_child(name, &block)
@@ -46,31 +42,26 @@ module RBS
           definitions << builder.build_instance(name)
           definitions << builder.build_singleton(name)
         when name.interface?
-          definitions << builder.build_interface(name, env.find_class(name))
+          definitions << builder.build_interface(name)
         end
 
         definitions.each do |definition|
-          definition.ancestors.each do |ancestor|
-            yield ancestor.name
+          if ancestors = definition.ancestors
+            ancestors.ancestors.each do |ancestor|
+              yield ancestor.name
 
-            case ancestor
-            when Definition::Ancestor::Instance, Definition::Ancestor::ExtensionInstance
-              ancestor.args.each do |type|
-                each_type_name type, &block
+              case ancestor
+              when Definition::Ancestor::Instance
+                ancestor.args.each do |type|
+                  each_type_name type, &block
+                end
               end
             end
           end
 
           unless only_ancestors?
-            definition.methods.each do |_, method|
-              method.method_types.each do |method_type|
-                method_type.type.each_type do |type|
-                  each_type_name type, &block
-                end
-                method_type.block&.type&.each_type do |type|
-                  each_type_name type, &block
-                end
-              end
+            definition.each_type do |type|
+              each_type_name type, &block
             end
           end
         end

data/lib/rbs/errors.rb

@@ -1,4 +1,19 @@
 module RBS
+  module MethodNameHelper
+    def method_name_string()
+      separator = case kind
+                  when :instance
+                    "#"
+                  when :singleton
+                    "."
+                  else
+                    raise
+                  end
+
+      "#{type_name}#{separator}#{method_name}"
+    end
+  end
+
   class InvalidTypeApplicationError < StandardError
     attr_reader :type_name
     attr_reader :args
@@ -10,7 +25,7 @@ module RBS
       @args = args
       @params = params
       @location = location
-      super "#{Location.to_string location}: #{type_name} expects parameters [#{params.each.map(&:name).join(", ")}], but given args [#{args.join(", ")}]"
+      super "#{Location.to_string location}: #{type_name} expects parameters [#{params.join(", ")}], but given args [#{args.join(", ")}]"
     end
 
     def self.check!(type_name:, args:, params:, location:)
@@ -93,8 +108,18 @@ module RBS
     end
 
     def self.check!(type_name, env:, location:)
-      env.find_type_decl(type_name) or
-        raise new(type_name: type_name, location: location)
+      dic = case
+            when type_name.class?
+              env.class_decls
+            when type_name.alias?
+              env.alias_decls
+            when type_name.interface?
+              env.interface_decls
+            else
+              raise
+            end
+
+      dic.key?(type_name) or raise new(type_name: type_name, location: location)
 
       type_name
     end
@@ -122,6 +147,26 @@ module RBS
     end
   end
 
+  class MethodDefinitionConflictWithInterfaceMixinError < StandardError
+    include MethodNameHelper
+
+    attr_reader :type_name
+    attr_reader :method_name
+    attr_reader :kind
+    attr_reader :mixin_member
+    attr_reader :entries
+
+    def initialize(type_name:, method_name:, kind:, mixin_member:, entries:)
+      @type_name = type_name
+      @method_name = method_name
+      @kind = kind
+      @mixin_member = mixin_member
+      @entries = entries
+
+      super "#{entries[0].decl.location}: Duplicated method with interface mixin: #{method_name_string}"
+    end
+  end
+
   class UnknownMethodAliasError < StandardError
     attr_reader :original_name
     attr_reader :aliased_name
@@ -142,6 +187,99 @@ module RBS
     end
   end
 
+  class MixedClassModuleDeclarationError < StandardError
+    attr_reader :name
+    attr_reader :decl
+
+    def initialize(name:, decl:)
+      @name = name
+      @decl = decl
+      super "#{Location.to_string decl.location}: Both class and module declarations: #{name}"
+    end
+  end
+
+  class SuperclassMismatchError < StandardError
+    attr_reader :name
+    attr_reader :entry
+
+    def initialize(name:, super_classes:, entry:)
+      @name = name
+      @entry = entry
+      super "#{Location.to_string entry.primary.decl.location}: Superclass mismatch: #{name}"
+    end
+  end
+
+  class ModuleSelfTypeMismatchError < StandardError
+    attr_reader :name
+    attr_reader :entry
+    attr_reader :location
+
+    def initialize(name:, entry:, location:)
+      @name = name
+      @entry = entry
+      @location = location
+
+      super "#{Location.to_string location}: Module self type 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
+    attr_reader :kind
+    attr_reader :members
+
+    def initialize(type_name:, method_name:, kind:, members:)
+      @type_name = type_name
+      @method_name = method_name
+      @kind = kind
+      @members = members
+
+      delimiter = case kind
+                  when :instance
+                    "#"
+                  when :singleton
+                    "."
+                  end
+
+      super "#{Location.to_string members[0].location}: Invalid method overloading: #{type_name}#{delimiter}#{method_name}"
+    end
+  end
+
+  class GenericParameterMismatchError < StandardError
+    attr_reader :name
+    attr_reader :decl
+
+    def initialize(name:, decl:)
+      @name = name
+      @decl = decl
+      super "#{Location.to_string decl.location}: Generic parameters mismatch: #{name}"
+    end
+  end
+
   class DuplicatedDeclarationError < StandardError
     attr_reader :name
     attr_reader :decls

data/lib/rbs/parser.y

@@ -10,7 +10,7 @@ class RBS::Parser
         kINTERFACE kEND kINCLUDE kEXTEND kATTRREADER kATTRWRITER kATTRACCESSOR tOPERATOR tQUOTEDMETHOD tQUOTEDIDENT
         kPREPEND kEXTENSION kINCOMPATIBLE
         type_TYPE type_SIGNATURE type_METHODTYPE tEOF
-        kOUT kIN kUNCHECKED
+        kOUT kIN kUNCHECKED kOVERLOAD
 
   prechigh
   nonassoc kQUESTION
@@ -161,6 +161,7 @@ rule
         result = Members::Private.new(location: val[0].location)
       }
     | alias_member
+    | signature
 
   attribute_member:
       annotations kATTRREADER keyword type {
@@ -386,10 +387,12 @@ rule
                                       comment: leading_comment(val[0].first&.location || location))
       }
 
+  overload: { result = nil } | kOVERLOAD
+
   method_member:
-      annotations attributes kDEF method_kind def_name method_types {
-        location = val[2].location + val[5].last.location
-        types = val[5].map do |type|
+      annotations attributes overload kDEF method_kind def_name method_types {
+        location = val[3].location + val[6].last.location
+        types = val[6].map do |type|
           case type
           when LocatedValue
             type.value
@@ -398,13 +401,14 @@ rule
           end
         end
         result = Members::MethodDefinition.new(
-          name: val[4].value,
-          kind: val[3],
+          name: val[5].value,
+          kind: val[4],
           types: types,
           annotations: val[0],
           location: location,
-          comment: leading_comment(val[0].first&.location || val[1].first&.location || val[2].location),
-          attributes: val[1].map(&:value)
+          comment: leading_comment(val[0].first&.location || val[1].first&.location || val[2]&.location || val[3].location),
+          attributes: val[1].map(&:value),
+          overload: !!val[2]
         )
       }
 
@@ -506,7 +510,7 @@ rule
       kCLASS | kVOID | kNIL | kTRUE | kFALSE | kANY | kUNTYPED | kTOP | kBOT | kINSTANCE | kBOOL | kSINGLETON
     | kTYPE | kMODULE | kPRIVATE | kPUBLIC | kEND | kINCLUDE | kEXTEND | kPREPEND
     | kATTRREADER | kATTRACCESSOR | kATTRWRITER | kDEF | kEXTENSION | kSELF | kINCOMPATIBLE
-    | kUNCHECKED | kINTERFACE | kSUPER | kALIAS | kOUT | kIN
+    | kUNCHECKED | kINTERFACE | kSUPER | kALIAS | kOUT | kIN | kOVERLOAD
 
   module_type_params:
       { result = nil }
@@ -1173,6 +1177,7 @@ KEYWORDS = {
   "extension" => :kEXTENSION,
   "incompatible" => :kINCOMPATIBLE,
   "unchecked" => :kUNCHECKED,
+  "overload" => :kOVERLOAD,
   "out" => :kOUT,
   "in" => :kIN,
 }

data/lib/rbs/prototype/rb.rb

@@ -6,19 +6,20 @@ module RBS
 
       def initialize
         @source_decls = []
-        @toplevel_members = []
       end
 
       def decls
         decls = []
 
-        decls.push(*source_decls)
+        top_decls, top_members = source_decls.partition {|decl| decl.is_a?(AST::Declarations::Base) }
 
-        unless toplevel_members.empty?
-          top = AST::Declarations::Extension.new(
+        decls.push(*top_decls)
+
+        unless top_members.empty?
+          top = AST::Declarations::Class.new(
             name: TypeName.new(name: :Object, namespace: Namespace.empty),
-            extension_name: :Toplevel,
-            members: toplevel_members,
+            super_class: nil,
+            members: top_members,
             annotations: [],
             comment: nil,
             location: nil,
@@ -27,7 +28,7 @@ module RBS
           decls << top
         end
 
-        decls.uniq
+        decls
       end
 
       def parse(string)
@@ -51,19 +52,15 @@ module RBS
           end
         end
 
-        process RubyVM::AbstractSyntaxTree.parse(string), namespace: Namespace.empty, current_module: nil, comments: comments, singleton: false
-      end
-
-      def nested_name(name)
-        (current_namespace + const_to_name(name).to_namespace).to_type_name.relative!
+        process RubyVM::AbstractSyntaxTree.parse(string), decls: source_decls, comments: comments, singleton: false
       end
 
-      def process(node, namespace:, current_module:, comments:, singleton:)
+      def process(node, decls:, comments:, singleton:)
         case node.type
         when :CLASS
           class_name, super_class, *class_body = node.children
           kls = AST::Declarations::Class.new(
-            name: const_to_name(class_name).with_prefix(namespace).relative!,
+            name: const_to_name(class_name),
             super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: []),
             type_params: AST::Declarations::ModuleTypeParams.empty,
             members: [],
@@ -72,16 +69,17 @@ module RBS
             comment: comments[node.first_lineno - 1]
           )
 
-          source_decls.push kls
+          decls.push kls
 
           each_node class_body do |child|
-            process child, namespace: kls.name.to_namespace, current_module: kls, comments: comments, singleton: false
+            process child, decls: kls.members, comments: comments, singleton: false
           end
+
         when :MODULE
           module_name, *module_body = node.children
 
           mod = AST::Declarations::Module.new(
-            name: const_to_name(module_name).with_prefix(namespace).relative!,
+            name: const_to_name(module_name),
             type_params: AST::Declarations::ModuleTypeParams.empty,
             self_type: nil,
             members: [],
@@ -90,21 +88,23 @@ module RBS
             comment: comments[node.first_lineno - 1]
           )
 
-          source_decls.push mod
+          decls.push mod
 
           each_node module_body do |child|
-            process child, namespace: mod.name.to_namespace, current_module: mod, comments: comments, singleton: false
+            process child, decls: mod.members, comments: comments, singleton: false
           end
+
         when :SCLASS
-          this = node.children[0]
+          this, body = node.children
+
           if this.type != :SELF
             RBS.logger.warn "`class <<` syntax with not-self may be compiled to incorrect code: #{this}"
           end
 
-          body = node.children[1]
           each_child(body) do |child|
-            process child, namespace: namespace, current_module: current_module, comments: comments, singleton: true
+            process child, decls: decls, comments: comments, singleton: true
           end
+
         when :DEFN, :DEFS
             if node.type == :DEFN
               def_name, def_body = node.children
@@ -130,116 +130,104 @@ module RBS
               types: types,
               kind: kind,
               comment: comments[node.first_lineno - 1],
-              attributes: []
+              attributes: [],
+              overload: false
             )
 
-            if current_module
-              current_module.members.push member
-            else
-              toplevel_members.push member
-            end
+            decls.push member
+
         when :FCALL
-          if current_module
-            # Inside method definition cannot reach here.
-            args = node.children[1]&.children || []
-
-            case node.children[0]
-            when :include
-              args.each do |arg|
-                if (name = const_to_name(arg))
-                  current_module.members << AST::Members::Include.new(
-                    name: name,
-                    args: [],
-                    annotations: [],
-                    location: nil,
-                    comment: comments[node.first_lineno - 1]
-                  )
-                end
+          # Inside method definition cannot reach here.
+          args = node.children[1]&.children || []
+
+          case node.children[0]
+          when :include
+            args.each do |arg|
+              if (name = const_to_name(arg))
+                decls << AST::Members::Include.new(
+                  name: name,
+                  args: [],
+                  annotations: [],
+                  location: nil,
+                  comment: comments[node.first_lineno - 1]
+                )
               end
-            when :extend
-              args.each do |arg|
-                if (name = const_to_name(arg))
-                  current_module.members << AST::Members::Extend.new(
-                    name: name,
-                    args: [],
-                    annotations: [],
-                    location: nil,
-                    comment: comments[node.first_lineno - 1]
-                  )
-                end
+            end
+          when :extend
+            args.each do |arg|
+              if (name = const_to_name(arg))
+                decls << AST::Members::Extend.new(
+                  name: name,
+                  args: [],
+                  annotations: [],
+                  location: nil,
+                  comment: comments[node.first_lineno - 1]
+                )
               end
-            when :attr_reader
-              args.each do |arg|
-                if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
-                  current_module.members << AST::Members::AttrReader.new(
-                    name: arg.children[0],
-                    ivar_name: nil,
-                    type: Types::Bases::Any.new(location: nil),
-                    location: nil,
-                    comment: comments[node.first_lineno - 1],
-                    annotations: []
-                  )
-                end
+            end
+          when :attr_reader
+            args.each do |arg|
+              if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+                decls << AST::Members::AttrReader.new(
+                  name: arg.children[0],
+                  ivar_name: nil,
+                  type: Types::Bases::Any.new(location: nil),
+                  location: nil,
+                  comment: comments[node.first_lineno - 1],
+                  annotations: []
+                )
               end
-            when :attr_accessor
-              args.each do |arg|
-                if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
-                  current_module.members << AST::Members::AttrAccessor.new(
-                    name: arg.children[0],
-                    ivar_name: nil,
-                    type: Types::Bases::Any.new(location: nil),
-                    location: nil,
-                    comment: comments[node.first_lineno - 1],
-                    annotations: []
-                  )
-                end
+            end
+          when :attr_accessor
+            args.each do |arg|
+              if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+                decls << AST::Members::AttrAccessor.new(
+                  name: arg.children[0],
+                  ivar_name: nil,
+                  type: Types::Bases::Any.new(location: nil),
+                  location: nil,
+                  comment: comments[node.first_lineno - 1],
+                  annotations: []
+                )
               end
-            when :attr_writer
-              args.each do |arg|
-                if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
-                  current_module.members << AST::Members::AttrWriter.new(
-                    name: arg.children[0],
-                    ivar_name: nil,
-                    type: Types::Bases::Any.new(location: nil),
-                    location: nil,
-                    comment: comments[node.first_lineno - 1],
-                    annotations: []
-                  )
-                end
+            end
+          when :attr_writer
+            args.each do |arg|
+              if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+                decls << AST::Members::AttrWriter.new(
+                  name: arg.children[0],
+                  ivar_name: nil,
+                  type: Types::Bases::Any.new(location: nil),
+                  location: nil,
+                  comment: comments[node.first_lineno - 1],
+                  annotations: []
+                )
               end
             end
           end
+
           each_child node do |child|
-            process child, namespace: namespace, current_module: current_module, comments: comments, singleton: singleton
+            process child, decls: decls, comments: comments, singleton: singleton
           end
 
         when :CDECL
-          type_name = case
-                      when node.children[0].is_a?(Symbol)
-                        ns = if current_module
-                               current_module.name.to_namespace
-                             else
-                               Namespace.empty
-                             end
-                        TypeName.new(name: node.children[0], namespace: ns)
-                      else
-                        name = const_to_name(node.children[0])
-                        if current_module
-                          name.with_prefix current_module.name.to_namespace
-                        else
-                          name
-                        end.relative!
-                      end
-
-          source_decls << AST::Declarations::Constant.new(
-            name: type_name,
+          const_name = case
+                       when node.children[0].is_a?(Symbol)
+                         TypeName.new(name: node.children[0], namespace: Namespace.empty)
+                       else
+                         const_to_name(node.children[0])
+                       end
+
+          decls << AST::Declarations::Constant.new(
+            name: const_name,
             type: node_type(node.children.last),
             location: nil,
             comment: comments[node.first_lineno - 1]
           )
+
         else
           each_child node do |child|
-            process child, namespace: namespace, current_module: current_module, comments: comments, singleton: singleton
+            process child, decls: decls, comments: comments, singleton: singleton
           end
         end
       end