rbs 0.15.0 → 0.19.0

data/lib/rbs/parser.y

@@ -1168,14 +1168,21 @@ end
 
 def new_token(type, value = input.matched)
   charpos = charpos(input)
-  start_index = charpos - input.matched.size
-  end_index = charpos
+  matched = input.matched
 
-  location = RBS::Location.new(buffer: buffer,
-                                           start_pos: start_index,
-                                           end_pos: end_index)
+  if matched
+    start_index = charpos - matched.size
+    end_index = charpos
 
-  [type, LocatedValue.new(location: location, value: value)]
+    location = RBS::Location.new(buffer: buffer,
+                                 start_pos: start_index,
+                                 end_pos: end_index)
+
+    [type, LocatedValue.new(location: location, value: value)]
+  else
+    # scanner hasn't matched yet
+    [false, nil]
+  end
 end
 
 def charpos(scanner)
@@ -1294,10 +1301,10 @@ def next_token
     return [:"type_#{type}", nil]
   end
 
-  return if @eof
+  return new_token(false, '') if @eof
 
   while true
-    return if input.eos?
+    return new_token(false, '') if input.eos?
 
     case
     when input.scan(/\s+/)

data/lib/rbs/prototype/rb.rb

@@ -1,6 +1,22 @@
 module RBS
   module Prototype
     class RB
+      Context = Struct.new(:module_function, :singleton, :namespace, keyword_init: true) do
+        def self.initial(namespace: Namespace.root)
+          self.new(module_function: false, singleton: false, namespace: namespace)
+        end
+
+        def method_kind
+          if singleton
+            :singleton
+          elsif module_function
+            :singleton_instance
+          else
+            :instance
+          end
+        end
+      end
+
       attr_reader :source_decls
       attr_reader :toplevel_members
 
@@ -52,10 +68,10 @@ module RBS
           end
         end
 
-        process RubyVM::AbstractSyntaxTree.parse(string), decls: source_decls, comments: comments, singleton: false
+        process RubyVM::AbstractSyntaxTree.parse(string), decls: source_decls, comments: comments, context: Context.initial
       end
 
-      def process(node, decls:, comments:, singleton:)
+      def process(node, decls:, comments:, context:)
         case node.type
         when :CLASS
           class_name, super_class, *class_body = node.children
@@ -71,9 +87,11 @@ module RBS
 
           decls.push kls
 
+          new_ctx = Context.initial(namespace: context.namespace + kls.name.to_namespace)
           each_node class_body do |child|
-            process child, decls: kls.members, comments: comments, singleton: false
+            process child, decls: kls.members, comments: comments, context: new_ctx
           end
+          remove_unnecessary_accessibility_methods! kls.members
 
         when :MODULE
           module_name, *module_body = node.children
@@ -90,9 +108,11 @@ module RBS
 
           decls.push mod
 
+          new_ctx = Context.initial(namespace: context.namespace + mod.name.to_namespace)
           each_node module_body do |child|
-            process child, decls: mod.members, comments: comments, singleton: false
+            process child, decls: mod.members, comments: comments, context: new_ctx
           end
+          remove_unnecessary_accessibility_methods! mod.members
 
         when :SCLASS
           this, body = node.children
@@ -101,14 +121,13 @@ module RBS
             RBS.logger.warn "`class <<` syntax with not-self may be compiled to incorrect code: #{this}"
           end
 
-          each_child(body) do |child|
-            process child, decls: decls, comments: comments, singleton: true
-          end
+          ctx = Context.initial.tap { |ctx| ctx.singleton = true }
+          process_children(body, decls: decls, comments: comments, context: ctx)
 
         when :DEFN, :DEFS
             if node.type == :DEFN
               def_name, def_body = node.children
-              kind = singleton ? :singleton : :instance
+              kind = context.method_kind
             else
               _, def_name, def_body = node.children
               kind = :singleton
@@ -140,14 +159,14 @@ module RBS
           member = AST::Members::Alias.new(
             new_name: new_name,
             old_name: old_name,
-            kind: singleton ? :singleton : :instance,
+            kind: context.singleton ? :singleton : :instance,
             annotations: [],
             location: nil,
             comment: comments[node.first_lineno - 1],
           )
           decls.push member unless decls.include?(member)
 
-        when :FCALL
+        when :FCALL, :VCALL
           # Inside method definition cannot reach here.
           args = node.children[1]&.children || []
 
@@ -166,7 +185,7 @@ module RBS
             end
           when :extend
             args.each do |arg|
-              if (name = const_to_name(arg))
+              if (name = const_to_name(arg, context: context))
                 decls << AST::Members::Extend.new(
                   name: name,
                   args: [],
@@ -220,16 +239,61 @@ module RBS
               decls << AST::Members::Alias.new(
                 new_name: new_name,
                 old_name: old_name,
-                kind: singleton ? :singleton : :instance,
+                kind: context.singleton ? :singleton : :instance,
                 annotations: [],
                 location: nil,
                 comment: comments[node.first_lineno - 1],
               )
             end
+          when :module_function
+            if args.empty?
+              context.module_function = true
+            else
+              module_func_context = context.dup.tap { |ctx| ctx.module_function = true }
+              args.each do |arg|
+                if arg && (name = literal_to_symbol(arg))
+                  if i = find_def_index_by_name(decls, name)
+                    decls[i] = decls[i].update(kind: :singleton_instance)
+                  end
+                elsif arg
+                  process arg, decls: decls, comments: comments, context: module_func_context
+                end
+              end
+            end
+          when :public, :private
+            accessibility = __send__(node.children[0])
+            if args.empty?
+              decls << accessibility
+            else
+              args.each do |arg|
+                if arg && (name = literal_to_symbol(arg))
+                  if i = find_def_index_by_name(decls, name)
+                    current = current_accessibility(decls, i)
+                    if current != accessibility
+                      decls.insert(i + 1, current)
+                      decls.insert(i, accessibility)
+                    end
+                  end
+                end
+              end
+
+              # For `private def foo` syntax
+              current = current_accessibility(decls)
+              decls << accessibility
+              process_children(node, decls: decls, comments: comments, context: context)
+              decls << current
+            end
+          else
+            process_children(node, decls: decls, comments: comments, context: context)
           end
 
-          each_child node do |child|
-            process child, decls: decls, comments: comments, singleton: singleton
+        when :ITER
+          method_name = node.children.first.children.first
+          case method_name
+          when :refine
+            # ignore
+          else
+            process_children(node, decls: decls, comments: comments, context: context)
           end
 
         when :CDECL
@@ -248,13 +312,17 @@ module RBS
           )
 
         else
-          each_child node do |child|
-            process child, decls: decls, comments: comments, singleton: singleton
-          end
+          process_children(node, decls: decls, comments: comments, context: context)
+        end
+      end
+
+      def process_children(node, decls:, comments:, context:)
+        each_child node do |child|
+          process child, decls: decls, comments: comments, context: context
         end
       end
 
-      def const_to_name(node)
+      def const_to_name(node, context: nil)
         case node&.type
         when :CONST
           TypeName.new(name: node.children[0], namespace: Namespace.empty)
@@ -268,6 +336,8 @@ module RBS
           TypeName.new(name: node.children[1], namespace: namespace)
         when :COLON3
           TypeName.new(name: node.children[0], namespace: Namespace.root)
+        when :SELF
+          context&.then { |c| c.namespace.to_type_name }
         end
       end
 
@@ -411,7 +481,8 @@ module RBS
         when :HASH
           list = node.children[0]
           if list
-            children = list.children.compact
+            children = list.children
+            children.pop
           else
             children = []
           end
@@ -419,8 +490,13 @@ module RBS
           key_types = []
           value_types = []
           children.each_slice(2) do |k, v|
-            key_types << literal_to_type(k)
-            value_types << literal_to_type(v)
+            if k
+              key_types << literal_to_type(k)
+              value_types << literal_to_type(v)
+            else
+              key_types << untyped
+              value_types << untyped
+            end
           end
 
           if !key_types.empty? && key_types.all? { |t| t.is_a?(Types::Literal) }
@@ -580,6 +656,59 @@ module RBS
       def untyped
         @untyped ||= Types::Bases::Any.new(location: nil)
       end
+
+      def private
+        @private ||= AST::Members::Private.new(location: nil)
+      end
+
+      def public
+        @public ||= AST::Members::Public.new(location: nil)
+      end
+
+      def current_accessibility(decls, index = decls.size)
+        idx = decls.slice(0, index).rindex { |decl| decl == private || decl == public }
+        (idx && decls[idx]) || public
+      end
+
+      def remove_unnecessary_accessibility_methods!(decls)
+        current = public
+        idx = 0
+
+        loop do
+          decl = decls[idx] or break
+          if current == decl
+            decls.delete_at(idx)
+            next
+          end
+
+          if 0 < idx && is_accessibility?(decls[idx - 1]) && is_accessibility?(decl)
+            decls.delete_at(idx - 1)
+            idx -= 1
+            current = current_accessibility(decls, idx)
+            next
+          end
+
+          current = decl if is_accessibility?(decl)
+          idx += 1
+        end
+
+        decls.pop while decls.last && is_accessibility?(decls.last)
+      end
+
+      def is_accessibility?(decl)
+        decl == public || decl == private
+      end
+
+      def find_def_index_by_name(decls, name)
+        decls.find_index do |decl|
+          case decl
+          when AST::Members::MethodDefinition, AST::Members::AttrReader
+            decl.name == name
+          when AST::Members::AttrWriter
+            decl.name == :"#{name}="
+          end
+        end
+      end
     end
   end
 end

data/lib/rbs/prototype/runtime.rb

@@ -94,6 +94,7 @@ module RBS
             optional_positionals << Types::Function::Param.new(name: name, type: untyped)
           when :rest
             requireds = trailing_positionals
+            name = nil if name == :* # For `def f(...) end` syntax
             rest = Types::Function::Param.new(name: name, type: untyped)
           when :keyreq
             required_keywords[name] = Types::Function::Param.new(name: nil, type: untyped)

data/lib/rbs/repository.rb

@@ -0,0 +1,121 @@
+module RBS
+  class Repository
+    DEFAULT_STDLIB_ROOT = Pathname(_ = __dir__) + "../../stdlib"
+
+    class GemRBS
+      attr_reader :name
+      attr_reader :paths
+
+      def initialize(name:)
+        @name = name
+        @paths = []
+        @versions = nil
+      end
+
+      def versions
+        load! unless @versions
+        @versions or raise
+      end
+
+      def load!
+        @versions = {}
+        versions = @versions or raise
+
+        paths.each do |gem_path|
+          gem_path.each_child(false) do |child|
+            next unless Gem::Version.correct?(child.to_s)
+
+            if version = Gem::Version.create(child.to_s)
+              unless version.prerelease?
+                path = gem_path + child
+
+                if prev = versions[version]
+                  RBS.logger.info { "Overwriting gem RBS in repository: gem=#{name}, prev_path=#{prev.path}, new_path=#{path}" }
+                end
+
+                versions[version] = VersionPath.new(gem: self, version: version, path: path)
+              end
+            end
+          end
+        end
+      end
+
+      def version_names
+        versions.keys.sort_by(&:version)
+      end
+
+      def oldest_version
+        oldest = version_names.first or raise
+        versions[oldest] or raise
+      end
+
+      def latest_version
+        latest = version_names.last or raise
+        versions[latest] or raise
+      end
+
+      def find_best_version(version)
+        return latest_version unless version
+
+        if v = version_names.reverse.bsearch {|v| v <= version ? true : false }
+          versions[v]
+        else
+          oldest_version
+        end
+      end
+
+      def empty?
+        versions.empty?
+      end
+    end
+
+    VersionPath = _ = Struct.new(:gem, :version, :path, keyword_init: true)
+
+    attr_reader :dirs
+    attr_reader :gems
+
+    def initialize(no_stdlib: false)
+      @dirs = []
+      @gems = {}
+
+      unless no_stdlib
+        add(DEFAULT_STDLIB_ROOT)
+      end
+    end
+
+    def self.default
+      new().tap do |repo|
+        repo.add(DEFAULT_STDLIB_ROOT)
+      end
+    end
+
+    def add(dir)
+      dirs << dir
+
+      dir.each_child(false) do |child|
+        gem_name = child.to_s
+        gem_rbs = (gems[gem_name] ||= GemRBS.new(name: gem_name))
+        gem_rbs.paths << dir + child
+      end
+    end
+
+    def lookup(gem, version)
+      _, set = lookup_path(gem, version)
+      set&.path
+    end
+
+    def lookup_path(gem, version)
+      if gem_rbs = gems[gem]
+        unless gem_rbs.empty?
+          set = if v = Gem::Version.create(version)&.release
+            gem_rbs.find_best_version(v)
+          else
+            gem_rbs.latest_version
+          end
+
+          [gem_rbs, set]
+        end
+      end
+    end
+  end
+end