rbs 0.5.0 → 0.9.1

data/lib/rbs/environment.rb

@@ -34,56 +34,49 @@ module RBS
 
       def insert(decl:, outer:)
         decls << D.new(decl: decl, outer: outer)
+        @primary = nil
       end
 
-      def type_params
-        primary.decl.type_params
-      end
-    end
+      def validate_type_params
+        unless decls.empty?
+          hd_decl, *tl_decls = decls
+          hd_params = hd_decl.decl.type_params
+          hd_names = hd_params.params.map(&:name)
 
-    class ModuleEntry < MultiEntry
-      def insert(decl:, outer:)
-        unless decl.is_a?(AST::Declarations::Module)
-          raise MixedClassModuleDeclarationError.new(name: name, decl: decl)
-        end
+          tl_decls.each do |tl_decl|
+            tl_params = tl_decl.decl.type_params
 
-        unless decls.empty?
-          names = decls[0].decl.type_params.each.map(&:name)
-          unless names.size == decl.type_params.each.size && decls[0].decl.type_params == decl.type_params.rename_to(names)
-            raise GenericParameterMismatchError.new(name: name, decl: decl)
+            unless hd_params.size == tl_params.size && hd_params == tl_params.rename_to(hd_names)
+              raise GenericParameterMismatchError.new(name: name, decl: tl_decl.decl)
+            end
           end
         end
+      end
 
-        super(decl: decl, outer: outer)
+      def type_params
+        primary.decl.type_params
       end
+    end
 
-      def primary
-        @primary ||= decls.find {|d| d.decl.self_type } || decls.first
+    class ModuleEntry < MultiEntry
+      def self_types
+        decls.flat_map do |d|
+          d.decl.self_types
+        end.uniq
       end
 
-      def self_type
-        primary.decl.self_type
+      def primary
+        @primary ||= begin
+                       validate_type_params
+                       decls.first
+                     end
       end
     end
 
     class ClassEntry < MultiEntry
-      def insert(decl:, outer:)
-        unless decl.is_a?(AST::Declarations::Class)
-          raise MixedClassModuleDeclarationError.new(name: name, decl: decl)
-        end
-
-        unless decls.empty?
-          names = decls[0].decl.type_params.each.map(&:name)
-          unless names.size == decl.type_params.each.size && decls[0].decl.type_params == decl.type_params.rename_to(names)
-            raise GenericParameterMismatchError.new(name: name, decl: decl)
-          end
-        end
-
-        super(decl: decl, outer: outer)
-      end
-
       def primary
         @primary ||= begin
+                       validate_type_params
                        decls.find {|d| d.decl.super_class } || decls.first
                      end
       end
@@ -133,7 +126,7 @@ module RBS
 
     def cache_name(cache, name:, decl:, outer:)
       if cache.key?(name)
-        raise DuplicatedDeclarationError.new(name, decl, cache[name])
+        raise DuplicatedDeclarationError.new(name, decl, cache[name].decl)
       end
 
       cache[name] = SingleEntry.new(name: name, decl: decl, outer: outer)
@@ -157,7 +150,18 @@ module RBS
           end
         end
 
-        class_decls[name].insert(decl: decl, outer: outer)
+        existing_entry = class_decls[name]
+
+        case
+        when decl.is_a?(AST::Declarations::Module) && existing_entry.is_a?(ModuleEntry)
+          # OK
+        when decl.is_a?(AST::Declarations::Class) && existing_entry.is_a?(ClassEntry)
+          # OK
+        else
+          raise DuplicatedDeclarationError.new(name, decl, existing_entry.primary.decl)
+        end
+
+        existing_entry.insert(decl: decl, outer: outer)
 
         prefix = outer + [decl]
         ns = name.to_namespace
@@ -255,8 +259,12 @@ module RBS
         AST::Declarations::Module.new(
           name: decl.name.with_prefix(prefix),
           type_params: decl.type_params,
-          self_type: decl.self_type&.yield_self do |self_type|
-            absolute_type(resolver, self_type, context: context)
+          self_types: decl.self_types.map do |module_self|
+            AST::Declarations::Module::Self.new(
+              name: absolute_type_name(resolver, module_self.name, context: context),
+              args: module_self.args.map {|type| absolute_type(resolver, type, context: context) },
+              location: module_self.location
+            )
           end,
           members: decl.members.map do |member|
             case member
@@ -406,5 +414,10 @@ module RBS
         absolute_type_name(resolver, name, context: context)
       end
     end
+
+    def inspect
+      ivars = %i[@buffers @declarations @class_decls @interface_decls @alias_decls @constant_decls @global_decls]
+      "\#<RBS::Environment #{ivars.map { |iv| "#{iv}=(#{instance_variable_get(iv).size} items)"}.join(' ')}>"
+    end
   end
 end

data/lib/rbs/errors.rb

@@ -125,6 +125,74 @@ module RBS
     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
@@ -187,17 +255,6 @@ 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
@@ -209,20 +266,6 @@ module RBS
     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

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,9 +4,9 @@ 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
@@ -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 {
@@ -387,7 +425,12 @@ rule
                                       comment: leading_comment(val[0].first&.location || location))
       }
 
-  overload: { result = nil } | kOVERLOAD
+  overload:
+        { result = nil }
+    | kOVERLOAD {
+        RBS.logger.warn "`overload def` syntax is deprecated. Use `...` syntax instead."
+        result = val[0]
+      }
 
   method_member:
       annotations attributes overload kDEF method_kind def_name method_types {
@@ -400,15 +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[5].value,
           kind: val[4],
-          types: types,
+          types: val[6],
           annotations: val[0],
           location: location,
           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]
+          overload: overload || !!val[2]
         )
       }
 
@@ -425,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])
       }
@@ -482,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)
@@ -510,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 | kOVERLOAD
+    | kUNCHECKED | kINTERFACE | kALIAS | kOUT | kIN | kOVERLOAD
 
   module_type_params:
       { result = nil }
@@ -1030,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
@@ -1111,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,
@@ -1133,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
   [
     [],
@@ -1170,7 +1230,6 @@ KEYWORDS = {
   "attr_reader" => :kATTRREADER,
   "attr_writer" => :kATTRWRITER,
   "attr_accessor" => :kATTRACCESSOR,
-  "super" => :kSUPER,
   "public" => :kPUBLIC,
   "private" => :kPRIVATE,
   "alias" => :kALIAS,
@@ -1219,6 +1278,7 @@ PUNCTS = {
   "!" => :kEXCLAMATION,
   "**" => :kSTAR2,
   "*" => :kSTAR,
+  "..." => :kDOT3,
   "." => :kDOT,
   "<" => :kLT,
   "-@" => :tOPERATOR,
@@ -1250,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,