rbs 0.2.0 → 0.6.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,66 @@ 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 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 +190,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 +230,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/namespace.rb

@@ -87,5 +87,23 @@ module RBS
         new(path: string.split("::").map(&:to_sym), absolute: false)
       end
     end
+
+
+    def ascend
+      if block_given?
+        current = self
+
+        until current.empty?
+          yield current
+          current = current.parent
+        end
+
+        yield current
+
+        self
+      else
+        enum_for(:ascend)
+      end
+    end
   end
 end

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
@@ -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,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 +439,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]
         )
       }
 
@@ -500,13 +542,13 @@ rule
     | tQUOTEDIDENT
     | tWRITE_ATTR
 
-  method_name0: tUIDENT | tLIDENT | identifier_keywords
+  method_name0: tUIDENT | tLIDENT | tINTERFACEIDENT | identifier_keywords
 
   identifier_keywords:
       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
+    | kUNCHECKED | kINTERFACE | kSUPER | kALIAS | kOUT | kIN | kOVERLOAD
 
   module_type_params:
       { result = nil }
@@ -1026,6 +1068,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
@@ -1119,8 +1162,9 @@ def push_comment(string, location)
 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 +1173,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
   [
     [],
@@ -1173,6 +1225,7 @@ KEYWORDS = {
   "extension" => :kEXTENSION,
   "incompatible" => :kINCOMPATIBLE,
   "unchecked" => :kUNCHECKED,
+  "overload" => :kOVERLOAD,
   "out" => :kOUT,
   "in" => :kIN,
 }
@@ -1245,8 +1298,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,