typeprof 0.4.2 → 0.5.4

data/lib/typeprof/export.rb

@@ -174,7 +174,7 @@ module TypeProf
       cvars = cvars.map do |var, entry|
         next if entry.absolute_paths.all? {|path| Config.check_dir_filter(path) == :exclude }
         [var, entry.type.screen_name(@scratch), entry.rbs_declared]
-      end
+      end.compact
 
       if !class_def.absolute_path || Config.check_dir_filter(class_def.absolute_path) == :exclude
         return nil if consts.empty? && included_mods.empty? && extended_mods.empty? && ivars.empty? && cvars.empty? && iseq_methods.empty? && attr_methods.empty? && inner_classes.empty?

data/lib/typeprof/import.rb

@@ -10,7 +10,10 @@ module TypeProf
     def self.get_builtin_env
       unless @builtin_env
         @builtin_env = RBS::Environment.new
-        @builtin_env_json = load_rbs(@builtin_env, builtin: true)
+
+        loader = RBS::EnvironmentLoader.new
+        new_decls = loader.load(env: @builtin_env).map {|decl,| decl }
+        @builtin_env_json = load_rbs(@builtin_env, new_decls)
       end
 
       return @builtin_env.dup, @builtin_env_json
@@ -21,27 +24,34 @@ module TypeProf
     end
 
     def load_library(lib)
-      RBSReader.load_rbs(@env, library: lib)
+      loader = RBS::EnvironmentLoader.new(core_root: nil)
+      loader.add(library: lib)
+      new_decls = loader.load(env: @env).map {|decl,| decl }
+      RBSReader.load_rbs(@env, new_decls)
     end
 
     def load_path(path)
-      RBSReader.load_rbs(@env, path: path)
+      loader = RBS::EnvironmentLoader.new(core_root: nil)
+      loader.add(path: path)
+      new_decls = loader.load(env: @env).map {|decl,| decl }
+      RBSReader.load_rbs(@env, new_decls)
     end
 
-    def self.load_rbs(env, builtin: false, **opt)
-      if builtin
-        loader = RBS::EnvironmentLoader.new
-      else
-        loader = RBS::EnvironmentLoader.new(core_root: nil)
-        loader.add(**opt)
+    def load_rbs_string(name, content)
+      buffer = RBS::Buffer.new(name: name, content: content)
+      new_decls = []
+      RBS::Parser.parse_signature(buffer).each do |decl|
+        @env << decl
+        new_decls << decl
       end
-      new_decls = loader.load(env: env)
+      RBSReader.load_rbs(@env, new_decls)
+    end
 
+    def self.load_rbs(env, new_decls)
       all_env = env.resolve_type_names
-
       resolver = RBS::TypeNameResolver.from_env(all_env)
       cur_env = RBS::Environment.new
-      new_decls.each do |decl,|
+      new_decls.each do |decl|
         cur_env << env.resolve_declaration(resolver, decl, outer: [], prefix: RBS::Namespace.root)
       end
 
@@ -210,7 +220,7 @@ module TypeProf
       #   * superclasses and modules appear earlier than their subclasses (Object is earlier than String)
       #   * namespace module appers earlier than its children (Process is earlier than Process::Status)
       visited = {}
-      queue = @cur_env.class_decls.keys.map {|name| [:visit, name] }
+      queue = @cur_env.class_decls.keys.map {|name| [:visit, name] }.reverse
       until queue.empty?
         event, name = queue.pop
         case event
@@ -365,10 +375,15 @@ module TypeProf
           raise if ty.args.size != 2
           [:array, [:Enumerator], [], conv_type(ty.args.first)]
         else
-          [:instance, klass]
+          if ty.args.empty?
+            [:instance, klass]
+          else
+            [:cell, [:instance, klass], ty.args.map {|ty| conv_type(ty) }]
+          end
         end
       when RBS::Types::Bases::Bool   then [:bool]
       when RBS::Types::Bases::Any    then [:any]
+      when RBS::Types::Bases::Top    then [:any]
       when RBS::Types::Bases::Void   then [:void]
       when RBS::Types::Bases::Self   then [:self]
       when RBS::Types::Bases::Nil    then [:nil]
@@ -440,6 +455,10 @@ module TypeProf
       Import.new(scratch, scratch.rbs_reader.load_path(rbs_path)).import(true)
     end
 
+    def self.import_rbs_code(scratch, rbs_name, rbs_code)
+      Import.new(scratch, scratch.rbs_reader.load_rbs_string(rbs_name, rbs_code)).import(true)
+    end
+
     def initialize(scratch, json)
       @scratch = scratch
       @json = json
@@ -485,11 +504,11 @@ module TypeProf
         rbs_sources = members[:rbs_sources]
 
         included_modules.each do |mod|
-          @scratch.include_module(klass, path_to_klass(mod), nil)
+          @scratch.include_module(klass, path_to_klass(mod), false, nil)
         end
 
         extended_modules.each do |mod|
-          @scratch.extend_module(klass, path_to_klass(mod), nil)
+          @scratch.include_module(klass, path_to_klass(mod), true, nil)
         end
 
         methods.each do |(singleton, method_name), mdef|
@@ -499,24 +518,25 @@ module TypeProf
         end
 
         ivars.each do |ivar_name, ty|
-          ty = conv_type(ty)
+          ty = conv_type(ty).remove_type_vars
           @scratch.add_ivar_write!(Type::Instance.new(klass), ivar_name, ty, nil)
         end
 
         cvars.each do |ivar_name, ty|
-          ty = conv_type(ty)
+          ty = conv_type(ty).remove_type_vars
           @scratch.add_cvar_write!(klass, ivar_name, ty, nil)
         end
       end
 
       @json[:constants].each do |classpath, value|
         base_klass = path_to_klass(classpath[0..-2])
-        value = conv_type(value)
+        value = conv_type(value).remove_type_vars
         @scratch.add_constant(base_klass, classpath[-1], value, nil)
       end
 
-      @json[:globals].each do |name, value|
-        @scratch.add_gvar_write!(name, conv_type(value), nil)
+      @json[:globals].each do |name, ty|
+        ty = conv_type(ty).remove_type_vars
+        @scratch.add_gvar_write!(name, ty, nil)
       end
 
       true
@@ -574,6 +594,8 @@ module TypeProf
       case ty.first
       when :class then path_to_klass(ty[1])
       when :instance then Type::Instance.new(path_to_klass(ty[1]))
+      when :cell
+        Type::Cell.new(Type::Cell::Elements.new(ty[2].map {|ty| conv_type(ty) }), conv_type(ty[1]))
       when :any then Type.any
       when :void then Type::Void.new
       when :nil then Type.nil
@@ -609,7 +631,7 @@ module TypeProf
         end
       when :union
         tys = ty[1]
-        Type::Union.new(Utils::Set[*tys.map {|ty2| conv_type(ty2) }], nil) # XXX: Array and Hash support
+        Type::Union.new(Utils::Set[*tys.map {|ty2| conv_type(ty2) }], nil).normalize # XXX: Array and Hash support
       when :var
         Type::Var.new(ty[1])
       when :proc

data/lib/typeprof/method.rb

@@ -11,6 +11,7 @@ module TypeProf
     end
 
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
+      recv = recv.base_type while recv.respond_to?(:base_type)
       recv = scratch.globalize_type(recv, caller_env, caller_ep)
       aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
 
@@ -175,8 +176,10 @@ module TypeProf
         ncaller_env = caller_env
         #pp [mid, aargs, msig]
         # XXX: support self type in msig
-        subst = { Type::Var.new(:self) => recv }
-        next unless aargs.consistent_with_method_signature?(msig, subst)
+        subst = aargs.consistent_with_method_signature?(msig)
+        next unless subst
+        # need to check self tyvar?
+        subst[Type::Var.new(:self)] = recv
         case
         when recv.is_a?(Type::Cell) && recv_orig.is_a?(Type::LocalCell)
           tyvars = recv.base_type.klass.type_params.map {|name,| Type::Var.new(name) }
@@ -205,22 +208,34 @@ module TypeProf
               elems.update(nil, ty)
             end
           end
-          subst.merge!({ tyvar_elem => recv.elems.squash_or_any })
+          subst.merge!({ tyvar_elem => recv.elems.squash })
         when recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
           tyvar_k = Type::Var.new(:K)
           tyvar_v = Type::Var.new(:V)
-          # XXX: need to support destructive operation
-          k_ty, v_ty = recv.elems.squash
+          k_ty0, v_ty0 = recv.elems.squash
+          if subst[tyvar_k] && subst[tyvar_v]
+            k_ty = subst[tyvar_k]
+            v_ty = subst[tyvar_v]
+            k_ty0 = k_ty0.union(k_ty)
+            v_ty0 = v_ty0.union(v_ty)
+            alloc_site = AllocationSite.new(caller_ep)
+            ncaller_env, k_ty = scratch.localize_type(k_ty, ncaller_env, caller_ep, alloc_site.add_id(:k))
+            ncaller_env, v_ty = scratch.localize_type(v_ty, ncaller_env, caller_ep, alloc_site.add_id(:v))
+            ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
+              elems.update(k_ty, v_ty)
+            end
+          end
           # XXX: need to heuristically replace ret type Hash[K, V] with self, instead of conversative type?
-          subst.merge!({ tyvar_k => k_ty, tyvar_v => v_ty })
+          subst.merge!({ tyvar_k => k_ty0, tyvar_v => v_ty0 })
         end
-        ret_ty = ret_ty.substitute(subst, Config.options[:type_depth_limit])
         found = true
         if aargs.blk_ty.is_a?(Type::Proc)
           #raise NotImplementedError unless aargs.blk_ty.block_body.is_a?(ISeqBlock) # XXX
           dummy_ctx = TypedContext.new(caller_ep, mid)
           dummy_ep = ExecutionPoint.new(dummy_ctx, -1, caller_ep)
-          dummy_env = Env.new(StaticEnv.new(recv, msig.blk_ty, false), [], [], Utils::HashWrapper.new({}))
+          s_recv = recv
+          s_recv = s_recv.base_type while s_recv.respond_to?(:base_type)
+          dummy_env = Env.new(StaticEnv.new(s_recv, msig.blk_ty, false), [], [], Utils::HashWrapper.new({}))
           if msig.blk_ty.is_a?(Type::Proc)
             scratch.add_callsite!(dummy_ctx, caller_ep, ncaller_env, &ctn)
             nfargs = msig.blk_ty.block_body.msig
@@ -240,13 +255,55 @@ module TypeProf
             0.upto(nfargs.opt_tys.size) do |n|
               naargs = ActualArguments.new(nlead_tys[0, nfargs.lead_tys.size + n], nil, {}, Type.nil) # XXX: support block to block?
               scratch.do_invoke_block(aargs.blk_ty, naargs, dummy_ep, dummy_env) do |blk_ret_ty, _ep, _env|
-                subst2 = {}
-                if blk_ret_ty.consistent?(msig.blk_ty.block_body.ret_ty, subst2)
-                  if recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
+                subst2 = Type.match?(blk_ret_ty, msig.blk_ty.block_body.ret_ty)
+                if subst2
+                  subst2 = Type.merge_substitution(subst, subst2)
+                  case
+                  when recv.is_a?(Type::Cell) && recv_orig.is_a?(Type::LocalCell)
+                    tyvars = recv.base_type.klass.type_params.map {|name,| Type::Var.new(name) }
+                    tyvars.each_with_index do |tyvar, idx|
+                      ty = subst2[tyvar]
+                      if ty
+                        ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
+                        ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
+                          elems.update(idx, ty)
+                        end
+                        scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
+                      end
+                    end
+                    tyvars.zip(recv.elems.elems) do |tyvar, elem|
+                      if subst2[tyvar]
+                        subst2[tyvar] = subst2[tyvar].union(elem)
+                      else
+                        subst2[tyvar] = elem
+                      end
+                    end
+                    ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
+                  when recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
                     tyvar_elem = Type::Var.new(:Elem)
                     if subst2[tyvar_elem]
+                      ty = subst2[tyvar_elem]
+                      ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
+                      ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
+                        elems.update(nil, ty)
+                      end
+                      scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
+                    end
+                    ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
+                  when recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
+                    tyvar_k = Type::Var.new(:K)
+                    tyvar_v = Type::Var.new(:V)
+                    k_ty0, v_ty0 = recv.elems.squash
+                    if subst2[tyvar_k] && subst2[tyvar_v]
+                      k_ty = subst2[tyvar_k]
+                      v_ty = subst2[tyvar_v]
+                      k_ty0 = k_ty0.union(k_ty)
+                      v_ty0 = v_ty0.union(v_ty)
+                      alloc_site = AllocationSite.new(caller_ep)
+                      ncaller_env, k_ty = scratch.localize_type(k_ty, ncaller_env, caller_ep, alloc_site.add_id(:k))
+                      ncaller_env, v_ty = scratch.localize_type(v_ty, ncaller_env, caller_ep, alloc_site.add_id(:v))
                       ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
-                        elems.update(nil, subst2[tyvar_elem])
+                        elems.update(k_ty, v_ty)
                       end
                       scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
                     end
@@ -274,6 +331,7 @@ module TypeProf
             ctn[ret_ty, caller_ep, ncaller_env]
           end
         else
+          ret_ty = ret_ty.substitute(subst, Config.options[:type_depth_limit])
           ret_ty = ret_ty.remove_type_vars
           ctn[ret_ty, caller_ep, ncaller_env]
         end

data/lib/typeprof/type.rb

@@ -20,16 +20,69 @@ module TypeProf
       self
     end
 
-    def consistent?(other, subst)
-      case other
-      when Type::Any then true
-      when Type::Var then other.add_subst!(self, subst)
+    def self.match?(ty1, ty2)
+      # both ty1 and ty2 should be global
+      # ty1 is always concrete; it should not have type variables
+      # ty2 might be abstract; it may have type variables
+      case ty2
+      when Type::Var
+        { ty2 => ty1 }
+      when Type::Any
+        {}
       when Type::Union
-        other.types.each do |ty2|
-          return true if consistent?(ty2, subst)
+        subst = nil
+        ty2.each_child_global do |ty2|
+          # this is very conservative to create subst:
+          # Type.match?( int | str, int | X) creates { X => int | str } but should be { X => str }???
+          subst2 = Type.match?(ty1, ty2)
+          next unless subst2
+          subst = Type.merge_substitution(subst, subst2)
         end
+        subst
       else
-        self == other
+        case ty1
+        when Type::Var then raise "should not occur"
+        when Type::Any
+          subst = {}
+          ty2.each_free_type_variable do |tyvar|
+            subst[tyvar] = Type.any
+          end
+          subst
+        when Type::Union
+          subst = nil
+          ty1.each_child_global do |ty1|
+            subst2 = Type.match?(ty1, ty2)
+            next unless subst2
+            subst = Type.merge_substitution(subst, subst2)
+          end
+          subst
+        else
+          if ty2.is_a?(Type::ContainerType)
+            # ty2 may have type variables
+            return nil if ty1.class != ty2.class
+            ty1.match?(ty2)
+          elsif ty1.is_a?(Type::ContainerType)
+            nil
+          else
+            ty1.consistent?(ty2) ? {} : nil
+          end
+        end
+      end
+    end
+
+    def self.merge_substitution(subst1, subst2)
+      if subst1
+        subst1 = subst1.dup
+        subst2.each do |tyvar, ty|
+          if subst1[tyvar]
+            subst1[tyvar] = subst1[tyvar].union(ty)
+          else
+            subst1[tyvar] = ty
+          end
+        end
+        subst1
+      else
+        subst2
       end
     end
 
@@ -41,6 +94,9 @@ module TypeProf
       yield self
     end
 
+    def each_free_type_variable
+    end
+
     def union(other)
       return self if self == other # fastpath
 
@@ -118,10 +174,8 @@ module TypeProf
         nil
       end
 
-      def consistent?(other, subst)
-        # need to create a type assignment if other is Var
-        other.add_subst!(self, subst) if other.is_a?(Type::Var)
-        true
+      def consistent?(_other)
+        raise "should not be called"
       end
 
       def substitute(_subst, _depth)
@@ -156,6 +210,12 @@ module TypeProf
         @elems = elems
       end
 
+      def each_free_type_variable(&blk)
+        each_child_global do |ty|
+          ty.each_free_type_variable(&blk)
+        end
+      end
+
       def limit_size(limit)
         return Type.any if limit <= 0
         tys = Utils::Set[]
@@ -271,48 +331,20 @@ module TypeProf
       def localize(env, alloc_site, depth)
         return env, Type.any if depth <= 0
         tys = @types.map do |ty|
-          alloc_site2 = alloc_site.add_id(ty)
-          env, ty2 = ty.localize(env, alloc_site2, depth - 1)
+          env, ty2 = ty.localize(env, alloc_site, depth - 1)
           ty2
         end
         @elems&.each do |(container_kind, base_type), elems|
           ty = container_kind.new(elems, base_type)
-          alloc_site2 = alloc_site.add_id(container_kind.name.to_sym).add_id(base_type)
-          env, ty = ty.localize(env, alloc_site2, depth - 1)
+          env, ty = ty.localize(env, alloc_site, depth - 1)
           tys = tys.add(ty)
         end
         ty = Union.new(tys, nil).normalize
         return env, ty
       end
 
-      def consistent?(other, subst)
-        case other
-        when Type::Any then true
-        when Type::Var then other.add_subst!(self, subst)
-        when Type::Union
-          # this is very conservative to create subst:
-          # consistent?( int | str, int | X) creates { X => int | str } but should be { X => str }???
-          @types.each do |ty1|
-            other.types.each do |ty2|
-              subst2 = subst.dup
-              if ty1.consistent?(ty2, subst2)
-                subst.replace(subst2)
-                # XXX: need to check other pairs to create conservative substitution??
-                # consistent?( X | :foo, str | int ) may return { X => str } or { X => int } but should be { X => str | int }?
-                return true
-              end
-            end
-          end
-          return true if @types.size == 0 && other.types.size == 0 # XXX: is this okay?
-          # TODO: array argument?
-          return false
-        else
-          @types.each do |ty1|
-            return true if ty1.consistent?(other, subst)
-          end
-          # TODO: array argument?
-          return false
-        end
+      def consistent?(_other)
+        raise "should not be called"
       end
 
       def substitute(subst, depth)
@@ -331,7 +363,7 @@ module TypeProf
         elems = @elems&.to_h do |(container_kind, base_type), elems|
           [[container_kind, base_type], elems.substitute(subst, depth - 1)]
         end
-        ty = Union.new(tys, elems)
+        ty = Union.new(tys, elems).normalize
         unions.each do |ty0|
           ty = ty.union(ty0)
         end
@@ -371,6 +403,10 @@ module TypeProf
         "Var[#{ @name }]"
       end
 
+      def each_free_type_variable
+        yield self
+      end
+
       def substitute(subst, depth)
         if subst[self]
           subst[self].limit_size(depth)
@@ -379,7 +415,7 @@ module TypeProf
         end
       end
 
-      def consistent?(other, subst)
+      def consistent?(_other)
         raise "should not be called: #{ self }"
       end
 
@@ -413,22 +449,15 @@ module TypeProf
       end
 
       def screen_name(scratch)
-        "#{ scratch.get_class_name(self) }.class"
+        "singleton(#{ scratch.get_class_name(self) })"
       end
 
       def get_method(mid, scratch)
         scratch.get_method(self, true, mid)
       end
 
-      def consistent?(other, subst)
+      def consistent?(other)
         case other
-        when Type::Any then true
-        when Type::Var then other.add_subst!(self, subst)
-        when Type::Union
-          other.types.each do |ty|
-            return true if consistent?(ty, subst)
-          end
-          return false
         when Type::Class
           ty = self
           loop do
@@ -479,17 +508,10 @@ module TypeProf
         scratch.get_method(@klass, false, mid)
       end
 
-      def consistent?(other, subst)
+      def consistent?(other)
         case other
-        when Type::Any then true
-        when Type::Var then other.add_subst!(self, subst)
-        when Type::Union
-          other.types.each do |ty|
-            return true if consistent?(ty, subst)
-          end
-          return false
         when Type::Instance
-          @klass.consistent?(other.klass, subst)
+          @klass.consistent?(other.klass)
         when Type::Class
           return true if @klass == Type::Builtin[:obj] || @klass == Type::Builtin[:class] || @klass == Type::Builtin[:module]
           return false
@@ -503,6 +525,7 @@ module TypeProf
       end
     end
 
+    # This is an internal object in MRI, so a user program cannot create this object explicitly
     class ISeq < Type
       def initialize(iseq)
         @iseq = iseq
@@ -520,20 +543,14 @@ module TypeProf
     end
 
     class Proc < Type
-      def initialize(block_body, type)
-        @block_body, @type = block_body, type
+      def initialize(block_body, base_type)
+        @block_body, @base_type = block_body, base_type
       end
 
-      attr_reader :block_body, :type
+      attr_reader :block_body, :base_type
 
-      def consistent?(other, subst)
+      def consistent?(other)
         case other
-        when Type::Any then true
-        when Type::Var then other.add_subst!(self, subst)
-        when Type::Union
-          other.types.each do |ty2|
-            return true if consistent?(ty2, subst)
-          end
         when Type::Proc
           @block_body.consistent?(other.block_body)
         else
@@ -542,11 +559,11 @@ module TypeProf
       end
 
       def get_method(mid, scratch)
-        @type.get_method(mid, scratch)
+        @base_type.get_method(mid, scratch)
       end
 
       def substitute(subst, depth)
-        Proc.new(@block_body.substitute(subst, depth), @type)
+        Proc.new(@block_body.substitute(subst, depth), @base_type)
       end
 
       def screen_name(scratch)
@@ -566,14 +583,12 @@ module TypeProf
         "Type::Symbol[#{ @sym ? @sym.inspect : "(dynamic symbol)" }, #{ @base_type.inspect }]"
       end
 
-      def consistent?(other, subst)
+      def consistent?(other)
         case other
-        when Var
-          other.add_subst!(self, subst)
         when Symbol
           @sym == other.sym
         else
-          @base_type.consistent?(other, subst)
+          @base_type.consistent?(other)
         end
       end
 
@@ -594,33 +609,33 @@ module TypeProf
       end
     end
 
-    # local info
+    # A local type
     class Literal < Type
-      def initialize(lit, type)
+      def initialize(lit, base_type)
         @lit = lit
-        @type = type
+        @base_type = base_type
       end
 
-      attr_reader :lit, :type
+      attr_reader :lit, :base_type
 
       def inspect
-        "Type::Literal[#{ @lit.inspect }, #{ @type.inspect }]"
+        "Type::Literal[#{ @lit.inspect }, #{ @base_type.inspect }]"
       end
 
       def screen_name(scratch)
-        @type.screen_name(scratch) + "<#{ @lit.inspect }>"
+        @base_type.screen_name(scratch) + "<#{ @lit.inspect }>"
       end
 
       def globalize(_env, _visited, _depth)
-        @type
+        @base_type
       end
 
       def get_method(mid, scratch)
-        @type.get_method(mid, scratch)
+        @base_type.get_method(mid, scratch)
       end
 
-      def consistent?(other, subst)
-        @type.consistent?(other, subst)
+      def consistent?(_other)
+        raise "should not called"
       end
     end
 
@@ -770,6 +785,10 @@ module TypeProf
       end
       str = str.empty? ? "" : "(#{ str.join(", ") })"
 
+      # Dirty Hack: Stop the iteration at most once!
+      # I'll remove this hack if RBS removes the limitation of nesting blocks
+      return str if caller_locations.any? {|frame| frame.label == "show_block_signature" }
+
       optional = false
       blks = []
       @blk_ty.each_child_global do |ty|