rbs 0.17.0 → 0.20.1

data/lib/rbs/parser.y

@@ -20,7 +20,7 @@ class RBS::Parser
   nonassoc kARROW
   preclow
 
-  expect 2
+  expect 5
 
 rule
 
@@ -202,57 +202,67 @@ rule
     | alias_member
     | signature
 
+  attribute_kind:
+      { result = :instance }
+    | kSELF kDOT { result = :singleton }
+
   attribute_member:
-      annotations kATTRREADER keyword type {
-        location = val[1].location + val[3].location
-        result = Members::AttrReader.new(name: val[2].value,
+      annotations kATTRREADER attribute_kind keyword type {
+        location = val[1].location + val[4].location
+        result = Members::AttrReader.new(name: val[3].value,
                                          ivar_name: nil,
-                                         type: val[3],
+                                         type: val[4],
+                                         kind: val[2],
                                          annotations: val[0],
                                          location: location,
                                          comment: leading_comment(val[0].first&.location || location))
       }
-    | annotations kATTRREADER method_name attr_var_opt kCOLON type {
-        location = val[1].location + val[5].location
-        result = Members::AttrReader.new(name: val[2].value.to_sym,
-                                         ivar_name: val[3],
-                                         type: val[5],
+    | annotations kATTRREADER attribute_kind method_name attr_var_opt kCOLON type {
+        location = val[1].location + val[6].location
+        result = Members::AttrReader.new(name: val[3].value.to_sym,
+                                         ivar_name: val[4],
+                                         type: val[6],
+                                         kind: val[2],
                                          annotations: val[0],
                                          location: location,
                                          comment: leading_comment(val[0].first&.location || location))
       }
-    | annotations kATTRWRITER keyword type {
-        location = val[1].location + val[3].location
-        result = Members::AttrWriter.new(name: val[2].value,
+    | annotations kATTRWRITER attribute_kind keyword type {
+        location = val[1].location + val[4].location
+        result = Members::AttrWriter.new(name: val[3].value,
                                          ivar_name: nil,
-                                         type: val[3],
+                                         kind: val[2],
+                                         type: val[4],
                                          annotations: val[0],
                                          location: location,
                                          comment: leading_comment(val[0].first&.location || location))
       }
-    | annotations kATTRWRITER method_name attr_var_opt kCOLON type {
-        location = val[1].location + val[5].location
-        result = Members::AttrWriter.new(name: val[2].value.to_sym,
-                                         ivar_name: val[3],
-                                         type: val[5],
+    | annotations kATTRWRITER attribute_kind method_name attr_var_opt kCOLON type {
+        location = val[1].location + val[6].location
+        result = Members::AttrWriter.new(name: val[3].value.to_sym,
+                                         ivar_name: val[4],
+                                         kind: val[2],
+                                         type: val[6],
                                          annotations: val[0],
                                          location: location,
                                          comment: leading_comment(val[0].first&.location || location))
       }
-    | annotations kATTRACCESSOR keyword type {
-        location = val[1].location + val[3].location
-        result = Members::AttrAccessor.new(name: val[2].value,
+    | annotations kATTRACCESSOR attribute_kind keyword type {
+        location = val[1].location + val[4].location
+        result = Members::AttrAccessor.new(name: val[3].value,
                                            ivar_name: nil,
-                                           type: val[3],
+                                           kind: val[2],
+                                           type: val[4],
                                            annotations: val[0],
                                            location: location,
                                            comment: leading_comment(val[0].first&.location || location))
       }
-    | annotations kATTRACCESSOR method_name attr_var_opt kCOLON type {
-        location = val[1].location + val[5].location
-        result = Members::AttrAccessor.new(name: val[2].value.to_sym,
-                                           ivar_name: val[3],
-                                           type: val[5],
+    | annotations kATTRACCESSOR attribute_kind method_name attr_var_opt kCOLON type {
+        location = val[1].location + val[6].location
+        result = Members::AttrAccessor.new(name: val[3].value.to_sym,
+                                           ivar_name: val[4],
+                                           kind: val[2],
+                                           type: val[6],
                                            annotations: val[0],
                                            location: location,
                                            comment: leading_comment(val[0].first&.location || location))
@@ -474,26 +484,13 @@ rule
       }
 
   method_type:
-      start_merged_scope type_params params_opt block_opt kARROW simple_type {
+      start_merged_scope type_params proc_type {
         reset_variable_scope
 
-        location = (val[1] || val[2] || val[3] || val[4]).location + val[5].location
+        location = (val[1] || val[2]).location + val[2].location
         type_params = val[1]&.value || []
 
-        params = val[2]&.value || empty_params_result
-
-        type = Types::Function.new(
-          required_positionals: params[0],
-          optional_positionals: params[1],
-          rest_positionals: params[2],
-          trailing_positionals: params[3],
-          required_keywords: params[4],
-          optional_keywords: params[5],
-          rest_keywords: params[6],
-          return_type: val[5]
-        )
-
-        block = val[3]&.value
+        type, block = val[2].value
 
         result = MethodType.new(type_params: type_params,
                                 type: type,
@@ -507,14 +504,13 @@ rule
         result = LocatedValue.new(value: val[1], location: val[0].location + val[2].location)
       }
 
-  block_opt:
-      { result = nil }
-    | kLBRACE function_type kRBRACE {
-        block = MethodType::Block.new(type: val[1].value, required: true)
+  block:
+      kLBRACE simple_function_type kRBRACE {
+        block = Types::Block.new(type: val[1].value, required: true)
         result = LocatedValue.new(value: block, location: val[0].location + val[2].location)
       }
-    | kQUESTION kLBRACE function_type kRBRACE {
-        block = MethodType::Block.new(type: val[2].value, required: false)
+    | kQUESTION kLBRACE simple_function_type kRBRACE {
+        block = Types::Block.new(type: val[2].value, required: false)
         result = LocatedValue.new(value: block, location: val[0].location + val[3].location)
       }
 
@@ -797,8 +793,9 @@ rule
         result = Types::ClassSingleton.new(name: val[2].value,
                                            location: val[0].location + val[3].location)
       }
-    | kHAT function_type {
-        result = Types::Proc.new(type: val[1].value, location: val[0].location + val[1].location)
+    | kHAT proc_type {
+        type, block = val[1].value
+        result = Types::Proc.new(type: type, block: block, location: val[0].location + val[1].location)
       }
     | simple_type kQUESTION {
         result = Types::Optional.new(type: val[0], location: val[0].location + val[1].location)
@@ -851,7 +848,32 @@ rule
 
   keyword: tLKEYWORD | tUKEYWORD | tLKEYWORD_Q_E | tUKEYWORD_Q_E
 
-  function_type:
+  proc_type:
+      params_opt block kARROW simple_type {
+        location = (val[0] || val[1] || val[2]).location + val[3].location
+
+        params = val[0]&.value || [[], [], nil, [], {}, {}, nil]
+
+        type = Types::Function.new(
+          required_positionals: params[0],
+          optional_positionals: params[1],
+          rest_positionals: params[2],
+          trailing_positionals: params[3],
+          required_keywords: params[4],
+          optional_keywords: params[5],
+          rest_keywords: params[6],
+          return_type: val[3]
+        )
+
+        block = val[1].value
+
+        result = LocatedValue.new(value: [type, block], location: location)
+      }
+    | simple_function_type {
+        result = LocatedValue.new(value: [val[0].value, nil], location: val[0].location)
+      }
+
+  simple_function_type:
       kLPAREN params kRPAREN kARROW simple_type {
         location = val[0].location + val[4].location
         type = Types::Function.new(
@@ -883,7 +905,7 @@ rule
         result = LocatedValue.new(value: type, location: location)
       }
 
-    params:
+  params:
       required_positional kCOMMA params {
         result = val[2]
         result[0].unshift(val[0])
@@ -1294,6 +1316,10 @@ ANNOTATION_RE = Regexp.union(/%a\{.*?\}/,
                              /%a\(.*?\)/,
                              /%a\<.*?\>/,
                              /%a\|.*?\|/)
+
+escape_sequences = %w[a b e f n r s t v "].map { |l| "\\\\#{l}" }
+DBL_QUOTE_STR_ESCAPE_SEQUENCES_RE = /(#{escape_sequences.join("|")})/
+
 def next_token
   if @type
     type = @type
@@ -1373,7 +1399,21 @@ def next_token
   when input.scan(/[a-z_]\w*\b/)
     new_token(:tLIDENT)
   when input.scan(/"(\\"|[^"])*"/)
-    s = input.matched.yield_self {|s| s[1, s.length - 2] }.gsub(/\\"/, '"')
+    s = input.matched.yield_self {|s| s[1, s.length - 2] }
+                     .gsub(DBL_QUOTE_STR_ESCAPE_SEQUENCES_RE) do |match|
+                       case match
+                       when '\\a' then "\a"
+                       when '\\b' then "\b"
+                       when '\\e' then "\e"
+                       when '\\f' then "\f"
+                       when '\\n' then "\n"
+                       when '\\r' then "\r"
+                       when '\\s' then "\s"
+                       when '\\t' then "\t"
+                       when '\\v' then "\v"
+                       when '\\"' then '"'
+                       end
+                     end
     new_token(:tSTRING, s)
   when input.scan(/'(\\'|[^'])*'/)
     s = input.matched.yield_self {|s| s[1, s.length - 2] }.gsub(/\\'/, "'")

data/lib/rbs/prototype/rb.rb

@@ -1,6 +1,30 @@
 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
+
+        def attribute_kind
+          if singleton
+            :singleton
+          else
+            :instance
+          end
+        end
+      end
+
       attr_reader :source_decls
       attr_reader :toplevel_members
 
@@ -52,10 +76,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 +95,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 +116,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 +129,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 +167,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 +193,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: [],
@@ -183,6 +210,7 @@ module RBS
                   name: name,
                   ivar_name: nil,
                   type: Types::Bases::Any.new(location: nil),
+                  kind: context.attribute_kind,
                   location: nil,
                   comment: comments[node.first_lineno - 1],
                   annotations: []
@@ -196,6 +224,7 @@ module RBS
                   name: name,
                   ivar_name: nil,
                   type: Types::Bases::Any.new(location: nil),
+                  kind: context.attribute_kind,
                   location: nil,
                   comment: comments[node.first_lineno - 1],
                   annotations: []
@@ -209,6 +238,7 @@ module RBS
                   name: name,
                   ivar_name: nil,
                   type: Types::Bases::Any.new(location: nil),
+                  kind: context.attribute_kind,
                   location: nil,
                   comment: comments[node.first_lineno - 1],
                   annotations: []
@@ -220,16 +250,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 +323,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)
@@ -268,6 +347,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
 
@@ -479,7 +560,7 @@ module RBS
         method_block = nil
 
         if block
-          method_block = MethodType::Block.new(
+          method_block = Types::Block.new(
             required: true,
             type: Types::Function.empty(untyped)
           )
@@ -487,7 +568,7 @@ module RBS
 
         if body_node
           if (yields = any_node?(body_node) {|n| n.type == :YIELD })
-            method_block = MethodType::Block.new(
+            method_block = Types::Block.new(
               required: true,
               type: Types::Function.empty(untyped)
             )
@@ -586,6 +667,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