rbs 0.19.0 → 0.20.0

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

@@ -15,6 +15,14 @@ module RBS
             :instance
           end
         end
+
+        def attribute_kind
+          if singleton
+            :singleton
+          else
+            :instance
+          end
+        end
       end
 
       attr_reader :source_decls
@@ -202,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: []
@@ -215,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: []
@@ -228,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: []
@@ -549,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)
           )
@@ -557,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)
             )

data/lib/rbs/prototype/rbi.rb

@@ -387,19 +387,19 @@ module RBS
         if block
           if (type = vars[block])
             if type.is_a?(Types::Proc)
-              method_block = MethodType::Block.new(required: true, type: type.type)
+              method_block = Types::Block.new(required: true, type: type.type)
             elsif type.is_a?(Types::Bases::Any)
-              method_block = MethodType::Block.new(
+              method_block = Types::Block.new(
                 required: true,
                 type: Types::Function.empty(Types::Bases::Any.new(location: nil))
               )
             # Handle an optional block like `T.nilable(T.proc.void)`.
             elsif type.is_a?(Types::Optional) && type.type.is_a?(Types::Proc)
-              method_block = MethodType::Block.new(required: false, type: type.type.type)
+              method_block = Types::Block.new(required: false, type: type.type.type)
             else
               STDERR.puts "Unexpected block type: #{type}"
               PP.pp args_node, STDERR
-              method_block = MethodType::Block.new(
+              method_block = Types::Block.new(
                 required: true,
                 type: Types::Function.empty(Types::Bases::Any.new(location: nil))
               )
@@ -485,7 +485,7 @@ module RBS
           Types::Tuple.new(types: types, location: nil)
         else
           if proc_type?(type_node)
-            Types::Proc.new(type: method_type(nil, type_node, variables: variables).type, location: nil)
+            Types::Proc.new(type: method_type(nil, type_node, variables: variables).type, block: nil, location: nil)
           else
             STDERR.puts "Unexpected type_node:"
             PP.pp type_node, STDERR

data/lib/rbs/prototype/runtime.rb

@@ -103,7 +103,7 @@ module RBS
           when :keyrest
             rest_keywords = Types::Function::Param.new(name: nil, type: untyped)
           when :block
-            block = MethodType::Block.new(
+            block = Types::Block.new(
               type: Types::Function.empty(untyped).update(rest_positionals: Types::Function::Param.new(name: nil, type: untyped)),
               required: true
             )

data/lib/rbs/test/hook.rb

@@ -81,7 +81,8 @@ def #{with_name}(*args, &block)
 
     if block_given?
       receiver = self
-      result = __send__(:"#{without_name}", *args) do |*block_args|
+
+      wrapped_block = proc do |*block_args|
         return_from_block = false
 
         begin
@@ -117,7 +118,9 @@ def #{with_name}(*args, &block)
         end
 
         block_result
-      end
+      end.ruby2_keywords
+
+      result = __send__(:"#{without_name}", *args, &wrapped_block)
     else
       result = __send__(:"#{without_name}", *args)
     end

data/lib/rbs/types.rb

@@ -947,44 +947,100 @@ module RBS
       end
     end
 
+    class Block
+      attr_reader :type
+      attr_reader :required
+
+      def initialize(type:, required:)
+        @type = type
+        @required = required
+      end
+
+      def ==(other)
+        other.is_a?(Block) &&
+          other.type == type &&
+          other.required == required
+      end
+
+      def to_json(*a)
+        {
+          type: type,
+          required: required
+        }.to_json(*a)
+      end
+
+      def sub(s)
+        self.class.new(
+          type: type.sub(s),
+          required: required
+        )
+      end
+
+      def map_type(&block)
+        Block.new(
+          required: required,
+          type: type.map_type(&block)
+        )
+      end
+    end
+
     class Proc
       attr_reader :type
+      attr_reader :block
       attr_reader :location
 
-      def initialize(location:, type:)
+      def initialize(location:, type:, block:)
         @type = type
+        @block = block
         @location = location
       end
 
       def ==(other)
-        other.is_a?(Proc) && other.type == type
+        other.is_a?(Proc) && other.type == type && other.block == block
       end
 
       alias eql? ==
 
       def hash
-        self.class.hash ^ type.hash
+        self.class.hash ^ type.hash ^ block.hash
       end
 
       def free_variables(set = Set[])
         type.free_variables(set)
+        block&.type&.free_variables(set)
+        set
       end
 
       def to_json(*a)
-        { class: :proc, type: type, location: location }.to_json(*a)
+        {
+          class: :proc,
+          type: type,
+          block: block,
+          location: location
+        }.to_json(*a)
       end
 
       def sub(s)
-        self.class.new(type: type.sub(s), location: location)
+        self.class.new(type: type.sub(s), block: block&.sub(s), location: location)
       end
 
       def to_s(level = 0)
-        "^(#{type.param_to_s}) -> #{type.return_to_s}".lstrip
+        case
+        when b = block
+          if b.required
+            "^(#{type.param_to_s}) { (#{b.type.param_to_s}) -> #{b.type.return_to_s} } -> #{type.return_to_s}"
+          else
+            "^(#{type.param_to_s}) ?{ (#{b.type.param_to_s}) -> #{b.type.return_to_s} } -> #{type.return_to_s}"
+          end
+        else
+          "^(#{type.param_to_s}) -> #{type.return_to_s}"
+        end
       end
 
       def each_type(&block)
         if block
           type.each_type(&block)
+          self.block&.type&.each_type(&block)
         else
           enum_for :each_type
         end
@@ -993,6 +1049,7 @@ module RBS
       def map_type_name(&block)
         Proc.new(
           type: type.map_type_name(&block),
+          block: self.block&.map_type {|type| type.map_type_name(&block) },
           location: location
         )
       end