rbs 0.16.0 → 0.20.0

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.16.0"
+  VERSION = "0.20.0"
 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.rbs

@@ -21,13 +21,13 @@ module RBS
         attr_reader defined_in: TypeName
         attr_reader implemented_in: TypeName?
 
-        def initialize: (type: MethodType, member: method_member, defined_in: TypeName?, implemented_in: TypeName?) -> void
+        def initialize: (type: MethodType, member: method_member, defined_in: TypeName, implemented_in: TypeName?) -> void
 
         def comment: () -> AST::Comment?
 
         def annotations: () -> Array[AST::Annotation]
 
-        def update: (?type: MethodType, ?member: method_member, ?defined_in: TypeName?, ?implemented_in: TypeName?) -> TypeDef
+        def update: (?type: MethodType, ?member: method_member, ?defined_in: TypeName, ?implemented_in: TypeName?) -> TypeDef
 
         def overload?: () -> bool
       end
@@ -42,8 +42,13 @@ module RBS
       attr_reader comments: Array[AST::Comment]
       attr_reader annotations: Array[AST::Annotation]
       attr_reader members: Array[method_member]
+      attr_reader alias_of: Method?
 
-      def initialize: (super_method: Method?, defs: Array[TypeDef], accessibility: accessibility, ?annotations: Array[AST::Annotation]) -> void
+      def initialize: (super_method: Method?,
+                       defs: Array[TypeDef],
+                       accessibility: accessibility,
+                       alias_of: Method?,
+                       ?annotations: Array[AST::Annotation]) -> void
 
       def public?: () -> bool
 

data/sig/definition_builder.rbs

@@ -62,7 +62,7 @@ module RBS
     def ensure_namespace!: (Namespace, location: Location?) -> void
 
     def build_singleton: (TypeName) -> Definition
-                       
+
     def build_instance: (TypeName) -> Definition
 
     def build_interface: (TypeName) -> Definition
@@ -71,11 +71,12 @@ module RBS
 
     def build_one_singleton: (TypeName) -> Definition
 
+    type ancestors = Definition::InstanceAncestors | Definition::SingletonAncestors | nil
     def merge_definitions: (TypeName,
                             Array[[Definition::Ancestor::t, Definition]],
                             entry: Environment::ModuleEntry | Environment::ClassEntry,
                             self_type: Definition::self_type,
-                            ancestors: Array[Definition::Ancestor::t]) -> Definition
+                            ancestors: ancestors) -> Definition
 
     type method_kind = :instance | :singleton
     def merge_method: (TypeName, Hash[Symbol, Definition::Method], Symbol, Definition::Method, Substitution, kind: method_kind) -> void
@@ -92,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]