rbs 0.14.0 → 0.18.1

data/lib/rbs/parser.y

@@ -475,6 +475,8 @@ rule
 
   method_type:
       start_merged_scope type_params params_opt block_opt kARROW simple_type {
+        reset_variable_scope
+
         location = (val[1] || val[2] || val[3] || val[4]).location + val[5].location
         type_params = val[1]&.value || []
 
@@ -875,7 +877,7 @@ rule
           required_keywords: {},
           optional_keywords: {},
           rest_keywords: nil,
-          return_type: val[2]
+          return_type: val[1]
         )
 
         result = LocatedValue.new(value: type, location: location)
@@ -1166,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
+
+  if matched
+    start_index = charpos - matched.size
+    end_index = charpos
 
-  location = RBS::Location.new(buffer: buffer,
-                                           start_pos: start_index,
-                                           end_pos: end_index)
+    location = RBS::Location.new(buffer: buffer,
+                                 start_pos: start_index,
+                                 end_pos: end_index)
 
-  [type, LocatedValue.new(location: location, value: value)]
+    [type, LocatedValue.new(location: location, value: value)]
+  else
+    # scanner hasn't matched yet
+    [false, nil]
+  end
 end
 
 def charpos(scanner)
@@ -1292,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
@@ -135,7 +154,19 @@ module RBS
 
             decls.push member unless decls.include?(member)
 
-        when :FCALL
+        when :ALIAS
+          new_name, old_name = node.children.map { |c| literal_to_symbol(c) }
+          member = AST::Members::Alias.new(
+            new_name: new_name,
+            old_name: old_name,
+            kind: context.singleton ? :singleton : :instance,
+            annotations: [],
+            location: nil,
+            comment: comments[node.first_lineno - 1],
+          )
+          decls.push member unless decls.include?(member)
+
+        when :FCALL, :VCALL
           # Inside method definition cannot reach here.
           args = node.children[1]&.children || []
 
@@ -154,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: [],
@@ -166,9 +197,9 @@ module RBS
             end
           when :attr_reader
             args.each do |arg|
-              if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+              if arg && (name = literal_to_symbol(arg))
                 decls << AST::Members::AttrReader.new(
-                  name: arg.children[0],
+                  name: name,
                   ivar_name: nil,
                   type: Types::Bases::Any.new(location: nil),
                   location: nil,
@@ -179,9 +210,9 @@ module RBS
             end
           when :attr_accessor
             args.each do |arg|
-              if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+              if arg && (name = literal_to_symbol(arg))
                 decls << AST::Members::AttrAccessor.new(
-                  name: arg.children[0],
+                  name: name,
                   ivar_name: nil,
                   type: Types::Bases::Any.new(location: nil),
                   location: nil,
@@ -192,9 +223,9 @@ module RBS
             end
           when :attr_writer
             args.each do |arg|
-              if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+              if arg && (name = literal_to_symbol(arg))
                 decls << AST::Members::AttrWriter.new(
-                  name: arg.children[0],
+                  name: name,
                   ivar_name: nil,
                   type: Types::Bases::Any.new(location: nil),
                   location: nil,
@@ -203,10 +234,66 @@ module RBS
                 )
               end
             end
+          when :alias_method
+            if args[0] && args[1] && (new_name = literal_to_symbol(args[0])) && (old_name = literal_to_symbol(args[1]))
+              decls << AST::Members::Alias.new(
+                new_name: new_name,
+                old_name: old_name,
+                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
@@ -225,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 const_to_name(node)
+      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, context: nil)
         case node&.type
         when :CONST
           TypeName.new(name: node.children[0], namespace: Namespace.empty)
@@ -245,6 +336,17 @@ 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
+
+      def literal_to_symbol(node)
+        case node.type
+        when :LIT
+          node.children[0] if node.children[0].is_a?(Symbol)
+        when :STR
+          node.children[0].to_sym
         end
       end
 
@@ -379,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
@@ -387,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) }
@@ -548,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

@@ -17,11 +17,13 @@ module RBS
       end
 
       def target?(const)
+        name = const_name(const)
+
         patterns.any? do |pattern|
           if pattern.end_with?("*")
-            (const.name || "").start_with?(pattern.chop)
+            (name || "").start_with?(pattern.chop)
           else
-            const.name == pattern
+            name == pattern
           end
         end
       end
@@ -37,7 +39,7 @@ module RBS
       def decls
         unless @decls
           @decls = []
-          ObjectSpace.each_object(Module).select {|mod| target?(mod) }.sort_by(&:name).each do |mod|
+          ObjectSpace.each_object(Module).select {|mod| target?(mod) }.sort_by{|mod| const_name(mod) }.each do |mod|
             case mod
             when Class
               generate_class mod
@@ -92,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)
@@ -356,12 +359,14 @@ module RBS
       end
 
       def generate_module(mod)
-        unless mod.name
+        name = const_name(mod)
+
+        unless name
           RBS.logger.warn("Skipping anonymous module #{mod}")
           return
         end
 
-        type_name = to_type_name(mod.name)
+        type_name = to_type_name(name)
 
         decl = AST::Declarations::Module.new(
           name: type_name,
@@ -374,12 +379,13 @@ module RBS
         )
 
         each_mixin(mod.included_modules, *mod.included_modules.flat_map(&:included_modules), namespace: type_name.namespace) do |included_module|
-          unless included_module.name
+          included_module_name = const_name(included_module)
+          unless included_module_name
             RBS.logger.warn("Skipping anonymous module #{included_module} included in #{mod}")
             next
           end
 
-          module_name = to_type_name(included_module.name)
+          module_name = to_type_name(included_module_name)
           if module_name.namespace == type_name.namespace
             module_name = TypeName.new(name: module_name.name, namespace: Namespace.empty)
           end
@@ -399,6 +405,11 @@ module RBS
 
         generate_constants mod
       end
+
+      def const_name(const)
+        @module_name_method ||= Module.instance_method(:name)
+        @module_name_method.bind(const).call
+      end
     end
   end
 end