rbs 0.17.0 → 0.20.1

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

@@ -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)
@@ -102,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

@@ -27,26 +27,28 @@ module RBS
         :>> => "rshift",
         :~ => "tilda"
       }
-      def self.alias_names(target)
+      def self.alias_names(target, random)
+        suffix = "#{RBS::Test.suffix}_#{random}"
+
         case target
         when *OPERATORS.keys
           name = OPERATORS[target]
           [
-            "#{name}____with__#{Test.suffix}",
-            "#{name}____without__#{Test.suffix}"
+            "#{name}____with__#{suffix}",
+            "#{name}____without__#{suffix}"
           ]
         else
           aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
 
           [
-            "#{aliased_target}__with__#{Test.suffix}#{punctuation}",
-            "#{aliased_target}__without__#{Test.suffix}#{punctuation}"
+            "#{aliased_target}__with__#{suffix}#{punctuation}",
+            "#{aliased_target}__without__#{suffix}#{punctuation}"
           ]
         end
       end
 
-      def self.setup_alias_method_chain(klass, target)
-        with_method, without_method = alias_names(target)
+      def self.setup_alias_method_chain(klass, target, random:)
+        with_method, without_method = alias_names(target, random)
 
         RBS.logger.debug "alias name: #{target}, #{with_method}, #{without_method}"
 
@@ -65,12 +67,12 @@ module RBS
         end
       end
 
-      def self.hook_method_source(prefix, method_name, key)
-        with_name, without_name = alias_names(method_name)
+      def self.hook_method_source(prefix, method_name, key, random:)
+        with_name, without_name = alias_names(method_name, random)
         full_method_name = "#{prefix}#{method_name}"
 
         [__LINE__ + 1, <<RUBY]
-def #{with_name}(*args)
+def #{with_name}(*args, &block)
   ::RBS.logger.debug { "#{full_method_name} with arguments: [" + args.map(&:inspect).join(", ") + "]" }
 
   begin
@@ -78,11 +80,18 @@ def #{with_name}(*args)
     block_calls = []
 
     if block_given?
-      result = __send__(:"#{without_name}", *args) do |*block_args|
+      receiver = self
+
+      wrapped_block = proc do |*block_args|
         return_from_block = false
 
         begin
-          block_result = yield(*block_args)
+          block_result = if receiver.equal?(self)
+                           yield(*block_args)
+                         else
+                           instance_exec(*block_args, &block)
+                         end
+
           return_from_block = true
         ensure
           exn = $!
@@ -109,7 +118,9 @@ def #{with_name}(*args)
         end
 
         block_result
-      end
+      end.ruby2_keywords
+
+      result = __send__(:"#{without_name}", *args, &wrapped_block)
     else
       result = __send__(:"#{without_name}", *args)
     end
@@ -154,17 +165,19 @@ RUBY
       end
 
       def self.hook_instance_method(klass, method, key:)
-        line, source = hook_method_source("#{klass}#", method, key)
+        random = SecureRandom.hex(4)
+        line, source = hook_method_source("#{klass}#", method, key, random: random)
 
         klass.module_eval(source, __FILE__, line)
-        setup_alias_method_chain klass, method
+        setup_alias_method_chain klass, method, random: random
       end
 
       def self.hook_singleton_method(klass, method, key:)
-        line, source = hook_method_source("#{klass}.",method, key)
+        random = SecureRandom.hex(4)
+        line, source = hook_method_source("#{klass}.",method, key, random: random)
 
         klass.singleton_class.module_eval(source, __FILE__, line)
-        setup_alias_method_chain klass.singleton_class, method
+        setup_alias_method_chain klass.singleton_class, method, random: random
       end
     end
   end

data/lib/rbs/test/type_check.rb

@@ -288,7 +288,12 @@ module RBS
           end
         when Types::ClassSingleton
           klass = get_class(type.name) or return false
-          val == klass
+          singleton_class = begin
+                              klass.singleton_class
+                            rescue TypeError
+                              return false
+                            end
+          val.is_a?(singleton_class)
         when Types::Interface
           methods = Set.new(Test.call(val, METHODS))
           if (definition = builder.build_interface(type.name))

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

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "0.17.0"
+  VERSION = "0.20.1"
 end

data/lib/rbs/writer.rb

@@ -285,7 +285,15 @@ module RBS
             else
               "(#{attr.ivar_name})"
             end
-      "attr_#{kind} #{attr.name}#{var}: #{attr.type}"
+
+      receiver = case attr.kind
+                 when :singleton
+                   "self."
+                 when :instance
+                   ""
+                 end
+
+      "attr_#{kind} #{receiver}#{attr.name}#{var}: #{attr.type}"
     end
 
     def preserve_empty_line(prev, decl)

data/schema/members.json

@@ -165,6 +165,10 @@
         "name": {
           "type": "string"
         },
+        "kind": {
+          "type": "string",
+          "enum": ["instance", "singleton"]
+        },
         "type": {
           "$ref": "types.json"
         },
@@ -194,7 +198,7 @@
           "$ref": "location.json"
         }
       },
-      "required": ["member", "name", "ivar_name", "type", "annotations", "comment", "location"]
+      "required": ["member", "name", "ivar_name", "type", "annotations", "kind", "comment", "location"]
     },
     "visibility": {
       "title": "Visibility specifier",

data/sig/definition_builder.rbs

@@ -93,5 +93,8 @@ module RBS
     def validate_parameter_variance: (decl: AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface, methods: Hash[Symbol, Definition::Method]) -> void
 
     def expand_alias: (TypeName) -> Types::t
+
+    type attributes = AST::Members::AttrReader | AST::Members::AttrWriter | AST::Members::AttrAccessor
+    def build_attribute: (type_name: TypeName, definition: Definition, member: attributes, accessibility: Definition::accessibility) -> void
   end
 end

data/sig/members.rbs

@@ -91,14 +91,17 @@ module RBS
       end
 
       module Attribute
+        type kind = :instance | :singleton
+
         attr_reader name: Symbol
         attr_reader type: Types::t
+        attr_reader kind: kind
         attr_reader ivar_name: Symbol | false | nil
         attr_reader annotations: Array[Annotation]
         attr_reader location: Location?
         attr_reader comment: Comment?
 
-        def initialize: (name: Symbol, type: Types::t, ivar_name: Symbol | false | nil, annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
+        def initialize: (name: Symbol, type: Types::t, ivar_name: Symbol | false | nil, kind: kind, annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
 
         include _HashEqual
       end

data/sig/method_types.rbs

@@ -1,24 +1,11 @@
 module RBS
   class MethodType
-    class Block
-      attr_reader type: Types::Function
-      attr_reader required: bool
-
-      def initialize: (type: Types::Function, required: boolish) -> void
-
-      def ==: (untyped other) -> bool
-
-      def to_json: (*untyped) -> String
-
-      def sub: (Substitution) -> Block
-    end
-
     attr_reader type_params: Array[Symbol]
     attr_reader type: Types::Function
-    attr_reader block: Block?
+    attr_reader block: Types::Block?
     attr_reader location: Location?
 
-    def initialize: (type_params: Array[Symbol], type: Types::Function, block: Block?, location: Location?) -> void
+    def initialize: (type_params: Array[Symbol], type: Types::Function, block: Types::Block?, location: Location?) -> void
 
     def ==: (untyped other) -> bool
 
@@ -26,7 +13,7 @@ module RBS
 
     def sub: (Substitution) -> MethodType
 
-    def update: (?type_params: Array[Symbol], ?type: Types::Function, ?block: Block?, ?location: Location?) -> MethodType
+    def update: (?type_params: Array[Symbol], ?type: Types::Function, ?block: Types::Block?, ?location: Location?) -> MethodType
 
     def free_variables: (?Set[Symbol] set) -> Set[Symbol]
 

data/sig/types.rbs

@@ -334,11 +334,27 @@ module RBS
       def has_keyword?: () -> bool
     end
 
+    class Block
+      attr_reader type: Types::Function
+      attr_reader required: boolish
+
+      def initialize: (type: Types::Function, required: boolish) -> void
+
+      def ==: (untyped other) -> bool
+
+      def to_json: (*untyped) -> String
+
+      def sub: (Substitution) -> Block
+
+      def map_type: () { (Types::t) -> Types::t } -> Block
+    end
+
     class Proc
       attr_reader type: Function
+      attr_reader block: Block?
       attr_reader location: Location?
 
-      def initialize: (location: Location?, type: Function) -> void
+      def initialize: (location: Location?, type: Function, block: Block?) -> void
 
       include _TypeBase
     end

data/stdlib/dbm/0/dbm.rbs

@@ -138,8 +138,6 @@ class DBM
   #
   def include?: (String) -> bool
 
-  def index: (untyped) -> (String | NilClass)
-
   # Returns a Hash (not a DBM database) created by using each value in the
   # database as a key, with the corresponding key as its value.
   #

data/stdlib/monitor/0/monitor.rbs

@@ -0,0 +1,119 @@
+# Use the Monitor class when you want to have a lock object for blocks with
+# mutual exclusion.
+#
+#     require 'monitor'
+#
+#     lock = Monitor.new
+#     lock.synchronize do
+#       # exclusive access
+#     end
+class Monitor
+  public
+
+  def enter: () -> nil
+
+  def exit: () -> nil
+
+  def mon_check_owner: () -> nil
+
+  alias mon_enter enter
+
+  alias mon_exit exit
+
+  def mon_locked?: () -> bool
+
+  def mon_owned?: () -> bool
+
+  alias mon_synchronize synchronize
+
+  alias mon_try_enter try_enter
+
+  def new_cond: () -> ::MonitorMixin::ConditionVariable
+
+  def synchronize: [T] () { () -> T } -> T
+
+  def try_enter: () -> bool
+
+  # for compatibility
+  alias try_mon_enter try_enter
+
+  def wait_for_cond: (::MonitorMixin::ConditionVariable, Numeric? timeout) -> untyped
+end
+
+module MonitorMixin
+  def self.extend_object: (untyped obj) -> untyped
+
+  public
+
+  # Enters exclusive section.
+  def mon_enter: () -> nil
+
+  # Leaves exclusive section.
+  def mon_exit: () -> nil
+
+  # Returns true if this monitor is locked by any thread
+  def mon_locked?: () -> bool
+
+  # Returns true if this monitor is locked by current thread.
+  def mon_owned?: () -> bool
+
+  # Enters exclusive section and executes the block.  Leaves the exclusive section
+  # automatically when the block exits.  See example under `MonitorMixin`.
+  def mon_synchronize: [T] () { () -> T } -> T
+
+  # Attempts to enter exclusive section.  Returns `false` if lock fails.
+  def mon_try_enter: () -> bool
+
+  # Creates a new MonitorMixin::ConditionVariable associated with the Monitor
+  # object.
+  def new_cond: () -> ::MonitorMixin::ConditionVariable
+
+  alias synchronize mon_synchronize
+
+  # For backward compatibility
+  alias try_mon_enter mon_try_enter
+
+  private
+
+  # Use `extend MonitorMixin` or `include MonitorMixin` instead of this
+  # constructor.  Have look at the examples above to understand how to use this
+  # module.
+  def initialize: (*untyped) { (*untyped) -> untyped } -> void
+
+  def mon_check_owner: () -> nil
+
+  # Initializes the MonitorMixin after being included in a class or when an object
+  # has been extended with the MonitorMixin
+  def mon_initialize: () -> untyped
+end
+
+# FIXME: This isn't documented in Nutshell.
+#
+# Since MonitorMixin.new_cond returns a ConditionVariable, and the example above
+# calls while_wait and signal, this class should be documented.
+class MonitorMixin::ConditionVariable
+  public
+
+  # Wakes up all threads waiting for this lock.
+  def broadcast: () -> Thread::ConditionVariable
+
+  # Wakes up the first thread in line waiting for this lock.
+  def signal: () -> Thread::ConditionVariable
+
+  # Releases the lock held in the associated monitor and waits; reacquires the
+  # lock on wakeup.
+  #
+  # If `timeout` is given, this method returns after `timeout` seconds passed,
+  # even if no other thread doesn't signal.
+  def wait: (?Numeric? timeout) -> untyped
+
+  # Calls wait repeatedly until the given block yields a truthy value.
+  def wait_until: () { () -> boolish } -> untyped
+
+  # Calls wait repeatedly while the given block yields a truthy value.
+  def wait_while: () { () -> boolish } -> untyped
+
+  private
+
+  def initialize: (Monitor monitor) -> void
+end