rbs 0.4.0 → 0.9.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,13 +108,91 @@ 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
   end
 
+  class NoSuperclassFoundError < StandardError
+    attr_reader :type_name
+    attr_reader :location
+
+    def initialize(type_name:, location:)
+      @type_name = type_name
+      @location = location
+
+      super "#{Location.to_string location}: Could not find super class: #{type_name}"
+    end
+
+    def self.check!(type_name, env:, location:)
+      env.class_decls.key?(type_name) or raise new(type_name: type_name, location: location)
+    end
+  end
+
+  class NoSelfTypeFoundError < StandardError
+    attr_reader :type_name
+    attr_reader :location
+
+    def initialize(type_name:, location:)
+      @type_name = type_name
+      @location = location
+
+      super "#{Location.to_string location}: Could not find self type: #{type_name}"
+    end
+
+    def self.check!(self_type, env:)
+      type_name = self_type.name
+
+      dic = case
+            when type_name.class?
+              env.class_decls
+            when type_name.interface?
+              env.interface_decls
+            end
+
+      dic.key?(type_name) or raise new(type_name: type_name, location: self_type.location)
+    end
+  end
+
+  class NoMixinFoundError < StandardError
+    attr_reader :type_name
+    attr_reader :member
+
+    def initialize(type_name:, member:)
+      @type_name = type_name
+      @member = member
+
+      super "#{Location.to_string location}: Could not find mixin: #{type_name}"
+    end
+
+    def location
+      member.location
+    end
+
+    def self.check!(type_name, env:, member:)
+      dic = case
+            when type_name.class?
+              env.class_decls
+            when type_name.interface?
+              env.interface_decls
+            end
+
+      dic.key?(type_name) or raise new(type_name: type_name, member: member)
+    end
+  end
+
   class DuplicatedMethodDefinitionError < StandardError
     attr_reader :decl
     attr_reader :location
@@ -122,6 +215,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 +255,74 @@ module RBS
     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 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/factory.rb

@@ -0,0 +1,14 @@
+module RBS
+  class Factory
+    def type_name(string)
+      absolute = string.start_with?("::")
+
+      *path, name = string.delete_prefix("::").split("::").map(&:to_sym)
+
+      TypeName.new(
+        name: name,
+        namespace: Namespace.new(path: path, absolute: absolute)
+      )
+    end
+  end
+end

data/lib/rbs/location.rb

@@ -77,6 +77,21 @@ module RBS
       locations.inject {|l1, l2| l1 + l2 }
     end
 
+    def concat(*others)
+      others.each { |other| self << other }
+      self
+    end
+
+    def <<(other)
+      if other
+        raise "Invalid concat: buffer=#{buffer.name}, other.buffer=#{other.buffer.name}" unless other.buffer == buffer
+        @end_pos = other.end_pos
+        @source = nil
+        @end_loc = nil
+      end
+      self
+    end
+
     def pred?(loc)
       loc.is_a?(Location) &&
         loc.name == name &&

data/lib/rbs/parser.y

@@ -4,13 +4,13 @@ class RBS::Parser
         tANNOTATION
         tSTRING tSYMBOL tINTEGER tWRITE_ATTR
         kLPAREN kRPAREN kLBRACKET kRBRACKET kLBRACE kRBRACE
-        kVOID kNIL kTRUE kFALSE kANY kUNTYPED kTOP kBOT kSELF kSELFQ kINSTANCE kCLASS kBOOL kSINGLETON kTYPE kDEF kMODULE kSUPER
+        kVOID kNIL kTRUE kFALSE kANY kUNTYPED kTOP kBOT kSELF kSELFQ kINSTANCE kCLASS kBOOL kSINGLETON kTYPE kDEF kMODULE
         kPRIVATE kPUBLIC kALIAS
-        kCOLON kCOLON2 kCOMMA kBAR kAMP kHAT kARROW kQUESTION kEXCLAMATION kSTAR kSTAR2 kFATARROW kEQ kDOT kLT
+        kCOLON kCOLON2 kCOMMA kBAR kAMP kHAT kARROW kQUESTION kEXCLAMATION kSTAR kSTAR2 kFATARROW kEQ kDOT kDOT3 kLT
         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
@@ -106,28 +106,28 @@ rule
       }
 
   module_decl:
-      annotations kMODULE start_new_scope class_name module_type_params module_self_type class_members kEND {
+      annotations kMODULE start_new_scope class_name module_type_params colon_module_self_types class_members kEND {
         reset_variable_scope
 
         location = val[1].location + val[7].location
         result = Declarations::Module.new(
           name: val[3].value,
           type_params: val[4]&.value || Declarations::ModuleTypeParams.empty,
-          self_type: val[5],
+          self_types: val[5],
           members: val[6],
           annotations: val[0],
           location: location,
           comment: leading_comment(val[0].first&.location || location)
         )
       }
-    | annotations kMODULE start_new_scope tUKEYWORD type class_members kEND {
+    | annotations kMODULE start_new_scope tUKEYWORD module_self_types class_members kEND {
         reset_variable_scope
 
         location = val[1].location + val[6].location
         result = Declarations::Module.new(
           name: val[3].value,
           type_params: Declarations::ModuleTypeParams.empty,
-          self_type: val[4],
+          self_types: val[4],
           members: val[5],
           annotations: val[0],
           location: location,
@@ -135,12 +135,50 @@ rule
         )
       }
 
-  module_self_type:
-      { result = nil }
-    | kCOLON type {
+  colon_module_self_types:
+      { result = [] }
+    | kCOLON module_self_types {
         result = val[1]
       }
 
+  module_self_types:
+      module_self_type {
+        result = [val[0]]
+      }
+    | module_self_types kCOMMA module_self_type {
+        result = val[0].push(val[2])
+      }
+
+  module_self_type:
+      qualified_name kLBRACKET type_list kRBRACKET {
+        name = val[0].value
+        args = val[2]
+        location = val[0].location + val[3].location
+
+        case
+        when name.class?
+          result = Declarations::Module::Self.new(name: name, args: args, location: location)
+        when name.interface?
+          result = Declarations::Module::Self.new(name: name, args: args, location: location)
+        else
+          raise SemanticsError.new("Module self type should be instance or interface", subject: val[0], location: val[0].location)
+        end
+      }
+    | qualified_name {
+        name = val[0].value
+        args = []
+        location = val[0].location
+
+        case
+        when name.class?
+          result = Declarations::Module::Self.new(name: name, args: args, location: location)
+        when name.interface?
+          result = Declarations::Module::Self.new(name: name, args: args, location: location)
+        else
+          raise SemanticsError.new("Module self type should be instance or interface", subject: val[0], location: val[0].location)
+        end
+      }
+
   class_members:
       { result = [] }
     | class_members class_member {
@@ -161,6 +199,7 @@ rule
         result = Members::Private.new(location: val[0].location)
       }
     | alias_member
+    | signature
 
   attribute_member:
       annotations kATTRREADER keyword type {
@@ -386,10 +425,17 @@ rule
                                       comment: leading_comment(val[0].first&.location || location))
       }
 
+  overload:
+        { result = nil }
+    | kOVERLOAD {
+        RBS.logger.warn "`overload def` syntax is deprecated. Use `...` syntax instead."
+        result = val[0]
+      }
+
   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
@@ -397,14 +443,24 @@ rule
             type
           end
         end
+
+        last_type = val[6].last
+        if last_type.is_a?(LocatedValue) && last_type.value == :dot3
+          overload = true
+          val[6].pop
+        else
+          overload = false
+        end
+
         result = Members::MethodDefinition.new(
-          name: val[4].value,
-          kind: val[3],
-          types: types,
+          name: val[5].value,
+          kind: val[4],
+          types: val[6],
           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: overload || !!val[2]
         )
       }
 
@@ -421,7 +477,7 @@ rule
 
   method_types:
       method_type { result = [val[0]] }
-    | kSUPER { result = [LocatedValue.new(value: :super, location: val[0].location)] }
+    | kDOT3 { result = [LocatedValue.new(value: :dot3, location: val[0].location)] }
     | method_type kBAR method_types {
         result = val[2].unshift(val[0])
       }
@@ -478,7 +534,7 @@ rule
 
   method_name:
       tOPERATOR
-    | kAMP | kHAT | kSTAR | kLT | kEXCLAMATION | kSTAR2 | kBAR | kOUT | kIN
+    | kAMP | kHAT | kSTAR | kLT | kEXCLAMATION | kSTAR2 | kBAR
     | method_name0
     | method_name0 kQUESTION {
         unless val[0].location.pred?(val[1].location)
@@ -506,7 +562,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 | kALIAS | kOUT | kIN | kOVERLOAD
 
   module_type_params:
       { result = nil }
@@ -1026,6 +1082,7 @@ def initialize(type, buffer:, eof_re:)
   @eof = false
   @bound_variables_stack = []
   @comments = {}
+  @ascii_only = buffer.content.ascii_only?
 end
 
 def start_merged_variables_scope
@@ -1107,20 +1164,19 @@ def leading_comment(location)
 end
 
 def push_comment(string, location)
-  new_comment = AST::Comment.new(string: string+"\n", location: location)
-
-  if (prev_comment = leading_comment(location)) && prev_comment.location.start_column == location.start_column
-    @comments.delete prev_comment.location.end_line
-    new_comment = AST::Comment.new(string: prev_comment.string + new_comment.string,
-                                   location: prev_comment.location + new_comment.location)
+  if (comment = leading_comment(location)) && comment.location.start_column == location.start_column
+    comment.concat(string: "#{string}\n", location: location)
+    @comments[comment.location.end_line] = comment
+  else
+    new_comment = AST::Comment.new(string: "#{string}\n", location: location)
+    @comments[new_comment.location.end_line] = new_comment
   end
-
-  @comments[new_comment.location.end_line] = new_comment
 end
 
 def new_token(type, value = input.matched)
-  start_index = input.charpos - input.matched.size
-  end_index = input.charpos
+  charpos = charpos(input)
+  start_index = charpos - input.matched.size
+  end_index = charpos
 
   location = RBS::Location.new(buffer: buffer,
                                            start_pos: start_index,
@@ -1129,6 +1185,14 @@ def new_token(type, value = input.matched)
   [type, LocatedValue.new(location: location, value: value)]
 end
 
+def charpos(scanner)
+  if @ascii_only
+    scanner.pos
+  else
+    scanner.charpos
+  end
+end
+
 def empty_params_result
   [
     [],
@@ -1166,13 +1230,13 @@ KEYWORDS = {
   "attr_reader" => :kATTRREADER,
   "attr_writer" => :kATTRWRITER,
   "attr_accessor" => :kATTRACCESSOR,
-  "super" => :kSUPER,
   "public" => :kPUBLIC,
   "private" => :kPRIVATE,
   "alias" => :kALIAS,
   "extension" => :kEXTENSION,
   "incompatible" => :kINCOMPATIBLE,
   "unchecked" => :kUNCHECKED,
+  "overload" => :kOVERLOAD,
   "out" => :kOUT,
   "in" => :kIN,
 }
@@ -1214,6 +1278,7 @@ PUNCTS = {
   "!" => :kEXCLAMATION,
   "**" => :kSTAR2,
   "*" => :kSTAR,
+  "..." => :kDOT3,
   "." => :kDOT,
   "<" => :kLT,
   "-@" => :tOPERATOR,
@@ -1245,8 +1310,9 @@ def next_token
     when input.scan(/\s+/)
       # skip
     when input.scan(/#(( *)|( ?(?<string>.*)))\n/)
-      start_index = input.charpos - input.matched.size
-      end_index = input.charpos-1
+      charpos = charpos(input)
+      start_index = charpos - input.matched.size
+      end_index = charpos-1
 
       location = RBS::Location.new(buffer: buffer,
                                                start_pos: start_index,