JezK

Edit File: analyzer.rb

module TypeProf
  class CRef
    include Utils::StructuralEquality

def initialize(outer, klass, singleton)
      @outer = outer
      @klass = klass
      @singleton = singleton
      # flags
      # scope_visi (= method_visi * module_func_flag)
      # refinements
    end

def extend(klass, singleton)
      CRef.new(self, klass, singleton)
    end

attr_reader :outer, :klass, :singleton

def pretty_print(q)
      q.text "CRef["
      q.pp @klass
      q.text "]"
    end
  end

class Context
    include Utils::StructuralEquality

def initialize(iseq, cref, mid)
      @iseq = iseq
      @cref = cref
      @mid = mid
    end

attr_reader :iseq, :cref, :mid

def source_location(pc)
      if @iseq
        @iseq.source_location(pc)
      else
        "<builtin>"
      end
    end

def detailed_source_location(pc)
      if @iseq
        @iseq.detailed_source_location(pc)
      else
        nil
      end
    end

def replace_cref(cref)
      Context.new(@iseq, cref, @mid)
    end
  end

class TypedContext
    include Utils::StructuralEquality

def initialize(caller_ep, mid)
      @caller_ep = caller_ep
      @mid = mid
    end

attr_reader :caller_ep, :mid

def source_location(_pc)
      if @caller_ep
        @caller_ep.source_location
      else
        "<typed-context:#{ @mid }>"
      end
    end

def detailed_source_location(_pc)
      if @caller_ep
        @caller_ep.source_location
      else
        nil
      end
    end

def replace_cref(cref)
      # What to do?
    end
  end

class ExecutionPoint
    include Utils::StructuralEquality

def initialize(ctx, pc, outer)
      @ctx = ctx
      @pc = pc
      @outer = outer
    end

def key
      [@ctx.iseq, @pc]
    end

attr_reader :ctx, :pc, :outer

def jump(pc)
      ExecutionPoint.new(@ctx, pc, @outer)
    end

def next
      ExecutionPoint.new(@ctx, @pc + 1, @outer)
    end

def replace_cref(cref)
      ExecutionPoint.new(@ctx.replace_cref(cref), @pc, @outer)
    end

def source_location
      @ctx.source_location(@pc)
    end

def detailed_source_location
      @ctx.detailed_source_location(@pc)
    end

def absolute_path
      @ctx.iseq.absolute_path
    end
  end

class StaticEnv
    include Utils::StructuralEquality

def initialize(recv_ty, blk_ty, mod_func, pub_meth)
      @recv_ty = recv_ty
      @blk_ty = blk_ty
      @mod_func = mod_func
      @pub_meth = pub_meth

return if recv_ty == :top #OK
      recv_ty.each_child_global do |ty|
        raise ty.inspect if !ty.is_a?(Type::Instance) && !ty.is_a?(Type::Class) && !ty.is_a?(Type::Symbol) && ty != Type.any
      end
    end

attr_reader :recv_ty, :blk_ty, :mod_func, :pub_meth

def merge(other)
      recv_ty = @recv_ty.union(other.recv_ty)
      blk_ty = @blk_ty.union(other.blk_ty)
      mod_func = @mod_func & other.mod_func # ??
      pub_meth = @pub_meth & other.pub_meth # ??
      StaticEnv.new(recv_ty, blk_ty, mod_func, pub_meth)
    end
  end

class Env
    include Utils::StructuralEquality

def initialize(static_env, locals, stack, type_params)
      @static_env = static_env
      @locals = locals
      @stack = stack
      @type_params = type_params
    end

attr_reader :static_env, :locals, :stack, :type_params

def merge(other)
      raise if @locals.size != other.locals.size
      raise if @stack.size != other.stack.size
      static_env = @static_env.merge(other.static_env)
      locals = []
      @locals.zip(other.locals) {|ty1, ty2| locals << ty1.union(ty2) }
      stack = []
      @stack.zip(other.stack) {|ty1, ty2| stack << ty1.union(ty2) }
      if @type_params
        raise if !other.type_params
        if @type_params == other.type_params
          type_params = @type_params
        else
          type_params = @type_params.internal_hash.dup
          other.type_params.internal_hash.each do |id, elems|
            elems2 = type_params[id]
            if elems2
              if elems != elems2
                type_params[id] = elems.union(elems2)
              end
            else
              type_params[id] = elems
            end
          end
          type_params = Utils::HashWrapper.new(type_params)
        end
      else
        raise if other.type_params
      end
      Env.new(static_env, locals, stack, type_params)
    end

def push(*tys)
      tys.each do |ty|
        raise "nil cannot be pushed to the stack" if ty.nil?
        ty.each_child do |ty|
          raise if ty.is_a?(Type::Var)
          #raise if ty.is_a?(Type::Instance) && ty.klass.type_params.size > 1
          raise "Array cannot be pushed to the stack" if ty.is_a?(Type::Array)
          raise "Hash cannot be pushed to the stack" if ty.is_a?(Type::Hash)
        end
      end
      Env.new(@static_env, @locals, @stack + tys, @type_params)
    end

def pop(n)
      stack = @stack.dup
      tys = stack.pop(n)
      nenv = Env.new(@static_env, @locals, stack, @type_params)
      return nenv, tys
    end

def setn(i, ty)
      stack = Utils.array_update(@stack, -i, ty)
      Env.new(@static_env, @locals, stack, @type_params)
    end

def topn(i)
      push(@stack[-i - 1])
    end

def get_local(idx)
      @locals[idx]
    end

def local_update(idx, ty)
      Env.new(@static_env, Utils.array_update(@locals, idx, ty), @stack, @type_params)
    end

def get_container_elem_types(id)
      @type_params.internal_hash[id]
    end

def deploy_type(id, elems)
      type_params = Utils::HashWrapper.new(@type_params.internal_hash.merge({ id => elems }))
      Env.new(@static_env, @locals, @stack, type_params)
    end

def enable_module_function
      senv = StaticEnv.new(@static_env.recv_ty, @static_env.blk_ty, true, @static_env.pub_meth)
      Env.new(senv, @locals, @stack, @type_params)
    end

def method_public_set(flag)
      senv = StaticEnv.new(@static_env.recv_ty, @static_env.blk_ty, @static_env.mod_func, flag)
      Env.new(senv, @locals, @stack, @type_params)
    end

def replace_recv_ty(ty)
      senv = StaticEnv.new(ty, @static_env.blk_ty, @static_env.mod_func, @static_env.pub_meth)
      Env.new(senv, @locals, @stack, @type_params)
    end

def replace_blk_ty(ty)
      senv = StaticEnv.new(@static_env.recv_ty, ty, @static_env.mod_func, @static_env.pub_meth)
      Env.new(senv, @locals, @stack, @type_params)
    end

def inspect
      "Env[#{ @static_env.inspect }, locals:#{ @locals.inspect }, stack:#{ @stack.inspect }, type_params:#{ (@type_params&.internal_hash).inspect }]"
    end
  end

class Scratch
    def inspect
      "#<Scratch>"
    end

def initialize
      @entrypoints = []

@worklist = Utils::WorkList.new

@ep2env = {}

@class_defs = {}
      @struct_defs = {}

@iseq_method_to_ctxs = {}

@alloc_site_to_global_id = {}

@callsites, @return_envs = {}, {}
      @block_to_ctx = {}
      @method_signatures = {}
      @block_signatures = {}
      @return_values = {}
      @gvar_table = VarTable.new

@errors = []
      @reveal_types = {}
      @backward_edges = {}

@pending_execution = {}
      @executed_iseqs = Utils::MutableSet.new

@loaded_files = {}

@rbs_reader = RBSReader.new

@terminated = false

@anonymous_struct_gen_id = 0

@types_being_shown = []
      @namespace = nil

@lsp_completion = nil
      @lsp_signature_help = CodeRangeTable.new
    end

def add_entrypoint(iseq)
      @entrypoints << iseq
    end

attr_reader :return_envs, :loaded_files, :rbs_reader

def get_env(ep)
      @ep2env[ep]
    end

def merge_env(ep, env)
      # TODO: this is wrong; it include not only proceeds but also indirect propagation like out-of-block variable modification
      #add_edge(ep, @ep)
      env2 = @ep2env[ep]
      if env2
        nenv = env2.merge(env)
        if nenv != env2 && !@worklist.member?(ep)
          @worklist.insert(ep.key, ep)
        end
        @ep2env[ep] = nenv
      else
        @worklist.insert(ep.key, ep)
        @ep2env[ep] = env
      end
    end

attr_reader :class_defs

class ClassDef # or ModuleDef
      def initialize(kind, name, absolute_path, superclass)
        raise unless name.is_a?(Array)
        @kind = kind
        @modules = {
          :before => { true => [], false => [] }, # before = include/extend
          :after  => { true => [], false => [] }, # after = prepend
        }
        @name = name
        @consts = {}
        @methods = {}
        @ivars = VarTable.new
        @cvars = VarTable.new
        @absolute_path = absolute_path
        @namespace = nil
        @superclass = superclass
        @subclasses = []
      end

attr_reader :kind, :modules, :methods, :ivars, :cvars, :absolute_path, :superclass, :subclasses
      attr_accessor :name, :klass_obj

def mix_module(kind, mod, type_args, singleton, absolute_path)
        mod_, module_type_args, absolute_paths = @modules[kind][singleton].find {|m,| m == mod }
        if mod_
          raise "inconsistent #{ kind == :after ? "include/extend" : "prepend" } type args in RBS?" if module_type_args != type_args && type_args != [] && type_args != nil
        else
          absolute_paths = Utils::MutableSet.new
          @modules[kind][singleton].unshift([mod, type_args, absolute_paths])
        end
        absolute_paths << absolute_path
      end

def get_constant(name)
        ty, locs = @consts[name]
        ty = ty || Type.any # XXX: warn?
        return ty, locs
      end

def add_constant(name, ty, def_ep)
        if @consts[name]
          # XXX: warn!
          _, eps = @consts[name]
          @consts[name] = [ty, eps + [def_ep&.detailed_source_location]]
          return
        end
        @consts[name] = [ty, [def_ep&.detailed_source_location]]
      end

def consts
        @consts.lazy.flat_map do |name, (ty, eps)|
          eps.map do |ep|
            [name, [ty, ep]]
          end
        end
      end

def add_class_open(name, open_ep)
        ty, eps = @consts[name]
        raise "call this only if the class is opened more than once" if ty.nil?
        @consts[name] = [ty, eps + [open_ep&.detailed_source_location]]
      end

def adjust_substitution_for_module(mods, mid, mthd, subst, &blk)
        mods.each do |mod_def, type_args,|
          if mod_def.klass_obj.type_params && type_args
            subst2 = {}
            mod_def.klass_obj.type_params.zip(type_args) do |(tyvar, *), tyarg|
              tyvar = Type::Var.new(tyvar)
              subst2[tyvar] = tyarg.substitute(subst, Config.current.options[:type_depth_limit])
            end
            mod_def.adjust_substitution(false, mid, mthd, subst2, false, &blk)
          end
        end
      end

def adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
        adjust_substitution_for_module(@modules[:before][singleton], mid, mthd, subst, &blk)

mthds = @methods[[singleton, mid]]
        yield subst, direct if mthds&.include?(mthd)

adjust_substitution_for_module(@modules[:after][singleton], mid, mthd, subst, &blk)
      end

def search_method(singleton, mid, visited, &blk)
        # Currently, circular inclusion of modules is allowed
        return if visited[self]
        visited[self] = true

@modules[:before][singleton].each do |mod_def,|
          mod_def.search_method(false, mid, visited, &blk)
        end

mthds = @methods[[singleton, mid]]
        yield mthds, @klass_obj, singleton if mthds

@modules[:after][singleton].each do |mod_def,|
          mod_def.search_method(false, mid, visited, &blk)
        end
      end

def check_typed(mid, singleton, klass)
        set = @methods[[singleton, mid]]
        return nil unless set
        set = set.select {|mdef| mdef.is_a?(klass) }
        return nil if set.empty?
        return set
      end

def check_typed_method(mid, singleton)
        check_typed(mid, singleton, TypedMethodDef)
      end

def check_typed_attr(mid, singleton)
        check_typed(mid, singleton, TypedAttrMethodDef)
      end

def add_method(mid, singleton, mdef)
        @methods[[singleton, mid]] ||= Utils::MutableSet.new
        @methods[[singleton, mid]] << mdef
        # Need to restart...?
      end

def set_method(mid, singleton, mdef)
        if mdef
          @methods[[singleton, mid]] = Utils::MutableSet.new
          @methods[[singleton, mid]] << mdef
        else
          @methods.delete([singleton, mid])
        end
      end
    end

def mix_module(kind, mixing_mod, mixed_mod, type_args, singleton, caller_ep)
      return if mixed_mod == Type.any

mixing_mod = @class_defs[mixing_mod.idx]
      mixed_mod.each_child do |mixed_mod|
        if mixed_mod.is_a?(Type::Class)
          mixed_mod = @class_defs[mixed_mod.idx]
          if mixed_mod && mixed_mod.kind == :module
            mixing_mod.mix_module(kind, mixed_mod, type_args, singleton, caller_ep ? caller_ep.ctx.iseq.absolute_path : nil)
          else
            warn(caller_ep, "attempted to #{ kind == :after ? "include/extend" : "prepend" } non-module; ignored")
          end
        end
      end
    end

def cbase_path(cbase)
      cbase && cbase.idx != 1 ? @class_defs[cbase.idx].name : []
    end

def new_class(cbase, name, type_params, superclass, def_ep)
      show_name = cbase_path(cbase) + [name]
      idx = @class_defs.size
      if superclass
        superclass_def = @class_defs[superclass.idx] unless superclass == :__root__
        @class_defs[idx] = ClassDef.new(:class, show_name, def_ep&.absolute_path, superclass_def)
        superclass_def.subclasses << idx if superclass_def
        klass = Type::Class.new(:class, idx, type_params, superclass, show_name)
        @class_defs[idx].klass_obj = klass
        cbase ||= klass # for bootstrap
        add_constant(cbase, name, klass, def_ep)
        return klass
      else
        # module
        @class_defs[idx] = ClassDef.new(:module, show_name, def_ep&.absolute_path, nil)
        mod = Type::Class.new(:module, idx, type_params, nil, show_name)
        @class_defs[idx].klass_obj = mod
        add_constant(cbase, name, mod, def_ep)
        return mod
      end
    end

def add_superclass_type_args!(klass, tyargs)
      klass.superclass_type_args = tyargs
    end

def new_struct(ep)
      return @struct_defs[ep] if @struct_defs[ep]

idx = @class_defs.size
      superclass = Type::Builtin[:struct]
      name = "AnonymousStruct_generated_#{ @anonymous_struct_gen_id += 1 }"
      # Should we pass a superclass here?
      @class_defs[idx] = ClassDef.new(:class, [name], ep.ctx.iseq.absolute_path, nil)
      #@class_defs[superclass.idx].subclasses << idx # needed?
      klass = Type::Class.new(:class, idx, [], superclass, name)
      add_superclass_type_args!(klass, [Type.any])
      @class_defs[idx].klass_obj = klass

@struct_defs[ep] = klass

klass
    end

attr_accessor :namespace

def get_class_name(klass)
      if klass == Type.any
        "???"
      else
        path = @class_defs[klass.idx].name
        if @namespace
          i = 0
          i += 1 while @namespace[i] && @namespace[i] == path[i]
          if path[i]
            path[i..].join("::")
          else
            path.last.to_s
          end
        else
          #"::" + path.join("::")
          path.join("::")
        end
      end
    end

def adjust_substitution(klass, singleton, mid, mthd, subst, &blk)
      direct = true
      if klass.kind == :class
        while klass != :__root__
          class_def = @class_defs[klass.idx]
          class_def.adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
          direct = false
          if klass.superclass && klass.superclass_type_args
            subst2 = {}
            klass.superclass.type_params.zip(klass.superclass_type_args) do |(tyvar, *), tyarg|
              tyvar = Type::Var.new(tyvar)
              subst2[tyvar] = tyarg.substitute(subst, Config.current.options[:type_depth_limit])
            end
            subst = subst2
          end
          klass = klass.superclass
        end
      else
        # module
        class_def = @class_defs[klass.idx]
        class_def.adjust_substitution(singleton, mid, mthd, subst, direct, &blk)
      end
    end

def traverse_subclasses(klass, &blk)
      @class_defs[klass.idx].subclasses.each do |subclass|
        yield @class_defs[subclass]
        traverse_subclasses(@class_defs[subclass].klass_obj, &blk)
      end
    end

def search_method(klass, singleton, mid, &blk)
      # XXX: support method alias correctly
      klass_orig = klass
      if klass.kind == :class
        while klass != :__root__
          class_def = @class_defs[klass.idx]
          class_def.search_method(singleton, mid, {}, &blk)
          klass = klass.superclass
        end
      else
        # module
        class_def = @class_defs[klass.idx]
        class_def.search_method(singleton, mid, {}, &blk)
      end
      if singleton
        search_method(Type::Builtin[klass_orig.kind], false, mid, &blk)
      end
    end

def get_method(klass, singleton, include_subclasses, mid)
      if include_subclasses
        subclasses_mthds = []
        traverse_subclasses(klass) do |subclass|
          subclass.search_method(singleton, mid, {}) do |mthds,|
            subclasses_mthds.concat(mthds.to_a)
          end
        end
        search_method(klass, singleton, mid) {|mthds,| return subclasses_mthds + mthds.to_a }
        return subclasses_mthds
      end

search_method(klass, singleton, mid) {|mthds,| return mthds }
    end

def get_all_super_methods(klass, singleton, current_klass, mid)
      hit = false
      search_method(klass, singleton, mid) do |mthds, klass0, singleton0|
        yield mthds, klass0, singleton0 if hit
        hit = klass0 == current_klass
      end
    end

def get_super_method(ctx, singleton)
      klass = ctx.cref.klass
      mid = ctx.mid
      if klass.kind == :class
        klass = klass.superclass
        while klass != :__root__
          class_def = @class_defs[klass.idx]
          mthd = class_def.get_method(mid, singleton)
          return mthd if mthd
          klass = klass.superclass
        end
      else
        # module
        class_def = @class_defs[klass.idx]
        mthd = class_def.get_method(mid, singleton)
        return mthd if mthd
      end
      nil
    end

def get_all_methods(klass, singleton, _include_subclasses)
      names = {}

if klass.kind == :class
        while klass != :__root__
          # TODO: module
          @class_defs[klass.idx].methods.each_key do |singleton0, name|
            if singleton == singleton0
              names[name] = true
            end
          end
          klass = klass.superclass
        end
      else
        @class_defs[klass.idx].methods.each_key do |singleton0, name|
          if singleton == singleton0
            names[name] = true
          end
        end
      end

names
    end

def get_constant(klass, name)
      if klass == Type.any
        [Type.any, nil]
      elsif klass.is_a?(Type::Class)
        @class_defs[klass.idx].get_constant(name)
      else
        [Type.any, nil]
      end
    end

def search_constant(cref, name)
      while cref != :bottom
        ty, locs = get_constant(cref.klass, name)
        return ty, locs if ty != Type.any
        cref = cref.outer
      end

return Type.any, nil
    end

def add_constant(klass, name, value, def_ep)
      if klass.is_a?(Type::Class)
        @class_defs[klass.idx].add_constant(name, value, def_ep)
      end
    end

def check_typed_method(klass, mid, singleton)
      @class_defs[klass.idx].check_typed_method(mid, singleton)
    end

def check_typed_attr(klass, mid, singleton)
      @class_defs[klass.idx].check_typed_attr(mid, singleton)
    end

def add_method(klass, mid, singleton, mdef)
      @class_defs[klass.idx].add_method(mid, singleton, mdef)
      mdef
    end

def set_method(klass, mid, singleton, mdef)
      @class_defs[klass.idx].set_method(mid, singleton, mdef)
      mdef
    end

def add_attr_method(klass, mid, ivar, kind, pub_meth, ep)
      if kind == :reader || kind == :accessor
        typed_mdef = check_typed_attr(klass, mid, ep.ctx.cref.singleton)
        unless typed_mdef
          add_method(klass, mid, false, ExecutedAttrMethodDef.new(ivar, :reader, pub_meth, ep))
        end
      end
      if kind == :writer || kind == :accessor
        mid = :"#{ mid }="
        typed_mdef = check_typed_attr(klass, mid, ep.ctx.cref.singleton)
        unless typed_mdef
          add_method(klass, mid, false, ExecutedAttrMethodDef.new(ivar, :writer, pub_meth, ep))
        end
      end
    end

def add_typed_attr_method(klass, mdef)
      name = mdef.ivar[1..-1]
      name = mdef.kind == :writer ? :"#{ name }=" : name.to_sym
      add_method(klass, name, false, mdef)
    end

def add_iseq_method(klass, mid, iseq, cref, outer_ep, pub_meth)
      add_method(klass, mid, false, ISeqMethodDef.new(iseq, cref, outer_ep, pub_meth))
    end

def add_singleton_iseq_method(klass, mid, iseq, cref, outer_ep, pub_meth)
      add_method(klass, mid, true, ISeqMethodDef.new(iseq, cref, outer_ep, pub_meth))
    end

def set_custom_method(klass, mid, impl, pub_meth = true)
      set_method(klass, mid, false, CustomMethodDef.new(impl, pub_meth))
    end

def set_singleton_custom_method(klass, mid, impl, pub_meth = true)
      set_method(klass, mid, true, CustomMethodDef.new(impl, pub_meth))
    end

def alias_method(klass, singleton, alias_mid, orig_mid, ep)
      if klass == Type.any
        self
      else
        mdefs = get_method(klass, singleton, false, orig_mid) # XXX: include_subclass == false??
        if mdefs
          # dup is needed for `alias foo foo` (otherwise, "can't add a new key into hash during iteration" error occurs)
          mdefs.dup.each do |mdef|
            @class_defs[klass.idx].add_method(alias_mid, singleton, AliasMethodDef.new(orig_mid, mdef, ep))
          end
        end
      end
    end

def add_edge(ep, next_ep)
      (@backward_edges[next_ep] ||= {})[ep] = true
    end

def add_iseq_method_call!(iseq_mdef, ctx)
      @iseq_method_to_ctxs[iseq_mdef] ||= Utils::MutableSet.new
      @iseq_method_to_ctxs[iseq_mdef] << ctx
    end

def add_executed_iseq(iseq)
      @executed_iseqs << iseq
    end

def add_callsite!(callee_ctx, caller_ep, caller_env, &ctn)
      if callee_ctx.is_a?(Context)
        @executed_iseqs << callee_ctx.iseq
        callee_type = callee_ctx.iseq.type
        if caller_ep.ctx.is_a?(Context) && (callee_type == :method || callee_type == :block)
          caller_ep.ctx.iseq&.add_called_iseq(caller_ep.pc, callee_ctx.iseq)
        end
      end

@callsites[callee_ctx] ||= {}
      @callsites[callee_ctx][caller_ep] = ctn
      merge_return_env(caller_ep) {|env| env ? env.merge(caller_env) : caller_env }

ret_ty = @return_values[callee_ctx] ||= Type.bot
      if ret_ty != Type.bot
        ctn[ret_ty, caller_ep, @return_envs[caller_ep]]
      end
    end

def add_method_signature!(callee_ctx, msig)
      if @method_signatures[callee_ctx]
        @method_signatures[callee_ctx] = @method_signatures[callee_ctx].merge(msig)
      else
        @method_signatures[callee_ctx] = msig
      end
    end

def merge_return_env(caller_ep)
      @return_envs[caller_ep] = yield @return_envs[caller_ep]
    end

def add_return_value!(callee_ctx, ret_ty)
      @return_values[callee_ctx] ||= Type.bot
      @return_values[callee_ctx] = @return_values[callee_ctx].union(ret_ty)

@callsites[callee_ctx] ||= {}
      @callsites[callee_ctx].each do |caller_ep, ctn|
        ctn[ret_ty, caller_ep, @return_envs[caller_ep]]
      end
    end

def add_block_to_ctx!(block_body, ctx)
      raise if !block_body.is_a?(Block)
      @block_to_ctx[block_body] ||= Utils::MutableSet.new
      @block_to_ctx[block_body] << ctx
    end

def add_block_signature!(block_body, bsig)
      if @block_signatures[block_body]
        @block_signatures[block_body] = @block_signatures[block_body].merge(bsig)
      else
        @block_signatures[block_body] = bsig
      end
    end

class VarTable
      Entry = Struct.new(:rbs_declared, :read_continuations, :type, :absolute_paths, :write_eps)

def initialize
        @tbl = {}
      end

def add_read!(site, ep, &ctn)
        entry = @tbl[site] ||= Entry.new(false, {}, Type.bot, Utils::MutableSet.new, Utils::MutableSet.new)
        entry.read_continuations[ep] = ctn
        entry.absolute_paths << ep.ctx.iseq.absolute_path if ep.ctx.is_a?(Context)
        ty = entry.type
        ty = Type.nil if ty == Type.bot
        ctn[ty, ep, entry.write_eps]
      end

def add_write!(site, ty, ep, scratch)
        entry = @tbl[site] ||= Entry.new(!ep, {}, Type.bot, Utils::MutableSet.new, Utils::MutableSet.new)
        if ep
          if entry.rbs_declared
            unless Type.match?(ty, entry.type)
              scratch.warn(ep, "inconsistent assignment to RBS-declared variable")
              return
            end
          end
          entry.absolute_paths << ep.ctx.iseq.absolute_path
          entry.write_eps << ep
        end
        entry.type = entry.type.union(ty)
        entry.read_continuations.each do |read_ep, ctn|
          ctn[ty, read_ep, ep ? [ep] : []]
        end
      end

def dump
        @tbl
      end
    end

def identify_class_for_ivar(recv, var)
      klass, singleton = recv.method_dispatch_info
      return nil unless klass
      search_method(klass, singleton, var) do |mthds, klass0, singleton0|
        if mthds.any? {|mthd| mthd.is_a?(AttrMethodDef) }
          return klass0, singleton
        end
      end
      return klass, singleton
    end

def get_ivar(recv, var)
      recv = recv.base_type while recv.respond_to?(:base_type)

klass, singleton = identify_class_for_ivar(recv, var.to_s[1..].to_sym) # search attr_reader

if klass
        return @class_defs[klass.idx], singleton
      else
        return nil
      end
    end

def add_ivar_read!(recv, var, ep, &ctn)
      recv.each_child do |recv|
        class_def, singleton = get_ivar(recv, var)
        next unless class_def
        class_def.ivars.add_read!([singleton, var], ep, &ctn)
      end
    end

def add_ivar_write!(recv, var, ty, ep)
      recv.each_child do |recv|
        class_def, singleton = get_ivar(recv, var)
        next unless class_def
        site = [singleton, var]
        class_def.ivars.add_write!(site, ty, ep, self)
      end
    end

def add_cvar_read!(klass, var, ep, &ctn)
      klass.each_child do |klass|
        next unless klass.is_a?(Type::Class)
        class_def = @class_defs[klass.idx]
        next unless class_def
        class_def.cvars.add_read!(var, ep, &ctn)
      end
    end

def add_cvar_write!(klass, var, ty, ep)
      klass.each_child do |klass|
        next unless klass.is_a?(Type::Class)
        class_def = @class_defs[klass.idx]
        next unless class_def
        class_def.cvars.add_write!(var, ty, ep, self)
      end
    end

def add_gvar_read!(var, ep, &ctn)
      @gvar_table.add_read!(var, ep, &ctn)
    end

def add_gvar_write!(var, ty, ep)
      @gvar_table.add_write!(var, ty, ep, self)
    end

def error(ep, msg)
      p [ep.source_location, "[error] " + msg] if Config.current.verbose >= 2
      @errors << [ep, "[error] " + msg]
    end

def warn(ep, msg)
      p [ep.source_location, "[warning] " + msg] if Config.current.verbose >= 2
      @errors << [ep, "[warning] " + msg]
    end

def reveal_type(ep, ty)
      key = ep.source_location
      puts "reveal:#{ ep.source_location }:#{ ty.screen_name(self) }" if Config.current.verbose >= 2
      if @reveal_types[key]
        @reveal_types[key] = @reveal_types[key].union(ty)
      else
        @reveal_types[key] = ty
      end
    end

def get_container_elem_types(env, ep, id)
      if ep.outer
        tmp_ep = ep
        tmp_ep = tmp_ep.outer while tmp_ep.outer
        env = @return_envs[tmp_ep]
      end
      env.get_container_elem_types(id)
    end

def update_container_elem_types(env, ep, id, base_type)
      if ep.outer
        tmp_ep = ep
        tmp_ep = tmp_ep.outer while tmp_ep.outer
        merge_return_env(tmp_ep) do |menv|
          elems = menv.get_container_elem_types(id)
          elems = yield elems
          menv = menv.deploy_type(id, elems)
          gid = @alloc_site_to_global_id[id]
          if gid
            ty = globalize_type(elems.to_local_type(id, base_type), env, ep)
            add_ivar_write!(*gid, ty, ep)
          end
          menv
        end
        env
      else
        elems = env.get_container_elem_types(id)
        elems = yield elems
        env = env.deploy_type(id, elems)
        gid = @alloc_site_to_global_id[id]
        if gid
          ty = globalize_type(elems.to_local_type(id, base_type), env, ep)
          add_ivar_write!(*gid, ty, ep)
        end
        env
      end
    end

def get_array_elem_type(env, ep, id, idx = nil)
      elems = get_container_elem_types(env, ep, id)

if elems
        return elems[idx] || Type.nil if idx
        return elems.squash_or_any
      else
        Type.any
      end
    end

def get_hash_elem_type(env, ep, id, key_ty = nil)
      elems = get_container_elem_types(env, ep, id)

if elems
        elems[globalize_type(key_ty, env, ep) || Type.any]
      else
        Type.any
      end
    end

def type_profile(cancel_token = nil)
      cancel_token ||= Utils::TimerCancelToken.new(Config.current.max_sec)
      tick = Time.now
      iter_counter = 0
      stat_eps = Utils::MutableSet.new

prologue_ctx = Context.new(nil, nil, nil)
      prologue_ep = ExecutionPoint.new(prologue_ctx, -1, nil)
      prologue_env = Env.new(StaticEnv.new(Type.bot, Type.nil, false, true), [], [], Utils::HashWrapper.new({}))

until @entrypoints.empty?
        entrypoint = @entrypoints.shift
        if entrypoint.is_a?(String)
          file = entrypoint
          next if @loaded_files[File.expand_path(file)]
          iseq, = ISeq.compile(file)
        else
          iseq = entrypoint
        end

@loaded_files[iseq.absolute_path] = true
        ep, env = TypeProf.starting_state(iseq)
        merge_env(ep, env)
        add_callsite!(ep.ctx, prologue_ep, prologue_env) {|ty, ep| }

while true
          until @worklist.empty?
            ep = @worklist.deletemin

iter_counter += 1
            if Config.current.options[:show_indicator]
              tick2 = Time.now
              if tick2 - tick >= 1
                tick = tick2
                $stderr << "\rType Profiling... (%d instructions @ %s)\e[K" % [iter_counter, ep.source_location]
                $stderr.flush
              end
            end

if (Config.current.max_iter && Config.current.max_iter <= iter_counter) || cancel_token.cancelled?
              @terminated = true
              break
            end

stat_eps << ep
            step(ep)
          end

break if @terminated

break unless Config.current.options[:stub_execution]

begin
            iseq, (kind, dummy_continuation) = @pending_execution.first
            break if !iseq
            @pending_execution.delete(iseq)
          end while @executed_iseqs.include?(iseq)

puts "DEBUG: trigger stub execution (#{ iseq&.name || "(nil)" }): rest #{ @pending_execution.size }" if Config.current.verbose >= 2

break if !iseq
          case kind
          when :method
            meth, ep, env = dummy_continuation
            merge_env(ep, env)
            add_iseq_method_call!(meth, ep.ctx)

when :block
            blk, epenvs = dummy_continuation
            epenvs.each do |ep, env|
              merge_env(ep, env)
              add_block_to_ctx!(blk.block_body, ep.ctx)
            end
          end
        end
      end

$stderr.print "\r\e[K" if Config.current.options[:show_indicator]

stat_eps
    end

def report(stat_eps, output)
      Reporters.show_message(@terminated, output)

Reporters.show_error(@errors, @backward_edges, output)

Reporters.show_reveal_types(self, @reveal_types, output)

Reporters.show_gvars(self, @gvar_table, output)

RubySignatureExporter.new(self, @class_defs, @iseq_method_to_ctxs).show(stat_eps, output)
    end

def report_lsp
      errs = @errors.map do |ep, msg|
        [ep&.detailed_source_location, msg]
      end

res = RubySignatureExporter.new(self, @class_defs, @iseq_method_to_ctxs).show_lsp

path, loc = Config.current.options[:signature_help_loc]
      if path
        sig_help_res = []
        sig_help = @lsp_signature_help[loc]
        if sig_help
          recv = sig_help[:recv]
          mid = sig_help[:mid]
          singleton = sig_help[:singleton]
          mdefs = sig_help[:mdefs]
          node_id = sig_help[:node_id]
          mdefs.each do |mdef|
            case mdef
            when ISeqMethodDef
              ctxs = @iseq_method_to_ctxs[mdef]
              next unless ctxs

ctx = ctxs.find {|ctx| ctx.mid == mid } || ctxs.first

method_name = mid
              method_name = "self.#{ method_name }" if singleton

str = recv.screen_name(self)
              str += singleton ? "." : "#"
              str += method_name.to_s
              str += ": "
              sig, _, sig_help = show_method_signature(ctx)
              offset = str.size
              sig_help = sig_help.transform_values {|r| (r.begin + offset ... r.end + offset) }
              str += sig
              sig_help_res << [str, sig_help, node_id]
            when AliasMethodDef
              # TODO
            when TypedMethodDef
              mdef.rbs_source&.[](1)&.each do |rbs|
                # TODO: sig_help
                sig_help_res << [rbs, {}, node_id]
              end
            end
          end
        end
      end

{
        sigs: res,
        errors: errs,
        completion: @lsp_completion,
        signature_help: sig_help_res,
      }
    end

def globalize_type(ty, env, ep)
      if ep.outer
        tmp_ep = ep
        tmp_ep = tmp_ep.outer while tmp_ep.outer
        env = @return_envs[tmp_ep]
      end
      ty.globalize(env, {}, Config.current.options[:type_depth_limit])
    end

def localize_type(ty, env, ep, alloc_site = AllocationSite.new(ep))
      if ep.outer
        tmp_ep = ep
        tmp_ep = tmp_ep.outer while tmp_ep.outer
        target_env = @return_envs[tmp_ep]
        target_env, ty = ty.localize(target_env, alloc_site, Config.current.options[:type_depth_limit])
        merge_return_env(tmp_ep) do |env|
          env ? env.merge(target_env) : target_env
        end
        return env, ty
      else
        return ty.localize(env, alloc_site, Config.current.options[:type_depth_limit])
      end
    end

def pend_method_execution(iseq, meth, recv, mid, cref, ep)
      ctx = Context.new(iseq, cref, mid)
      ep = ExecutionPoint.new(ctx, 0, ep)
      locals = [Type.nil] * iseq.locals.size

fargs_format = iseq.fargs_format
      lead_num = fargs_format[:lead_num] || 0
      post_num = fargs_format[:post_num] || 0
      post_index = fargs_format[:post_start]
      rest_index = fargs_format[:rest_start]
      keyword = fargs_format[:keyword]
      kw_index = fargs_format[:kwbits] - keyword.size if keyword
      kwrest_index = fargs_format[:kwrest]
      block_index = fargs_format[:block_start]
      opt = fargs_format[:opt] || [0]

(lead_num + opt.size - 1).times {|i| locals[i] = Type.any }
      post_num.times {|i| locals[i + post_index] = Type.any } if post_index
      locals[rest_index] = Type.any if rest_index
      if keyword
        keyword.each_with_index do |kw, i|
          case
          when kw.is_a?(Symbol) # required keyword
            locals[kw_index + i] = Type.any
          when kw.size == 2 # optional keyword (default value is a literal)
            _key, default_ty = *kw
            default_ty = Type.guess_literal_type(default_ty)
            default_ty = default_ty.base_type if default_ty.is_a?(Type::Literal)
            locals[kw_index + i] = default_ty.union(Type.any)
          else # optional keyword (default value is an expression)
            locals[kw_index + i] = Type.any
          end
        end
      end
      locals[kwrest_index] = Type.any if kwrest_index
      locals[block_index] = Type.nil if block_index

env = Env.new(StaticEnv.new(recv, Type.nil, false, true), locals, [], Utils::HashWrapper.new({}))

if !@pending_execution[iseq] || @pending_execution[iseq][0] == :block
        @pending_execution[iseq] = [:method, [meth, ep, env]]
      end
    end

def pend_block_dummy_execution(blk, iseq, nep, nenv)
      @pending_execution[iseq] ||= [:block, [blk, {}]]
      if @pending_execution[iseq][0] == :block
        if @pending_execution[iseq][1][1][nep]
          @pending_execution[iseq][1][1][nep] = @pending_execution[iseq][1][1][nep].merge(nenv)
        else
          @pending_execution[iseq][1][1][nep] = nenv
        end
      else
        # XXX: what to do?
      end
    end

def get_instance_variable(recv, var, ep, env)
      add_ivar_read!(recv, var, ep) do |ty, ep, write_eps|
        alloc_site = AllocationSite.new(ep)
        nenv, ty = localize_type(ty, env, ep, alloc_site)
        case ty
        when Type::Local
          @alloc_site_to_global_id[ty.id] = [recv, var] # need overwrite check??
        end
        write_eps.each do |write_ep|
          ep.ctx.iseq.add_def_loc(ep.pc, write_ep.detailed_source_location)
        end
        yield ty, nenv
      end
    end

def set_instance_variable(recv, var, ty, ep, env)
      ty = globalize_type(ty, env, ep)
      add_ivar_write!(recv, var, ty, ep)
    end

def step(ep)
      env = @ep2env[ep]
      raise "nil env" unless env

insn = ep.ctx.iseq.insns[ep.pc]
      operands = insn.operands

if Config.current.verbose >= 2
        # XXX: more dedicated output
        puts "DEBUG: stack=%p" % [env.stack]
        puts "DEBUG: %s (%s) PC=%d insn=%s sp=%d" % [ep.source_location, ep.ctx.iseq.name, ep.pc, insn.insn, env.stack.size]
      end

case insn.insn
      when :_iseq_body_start
        # XXX: reconstruct and record the method signature
        iseq = ep.ctx.iseq
        lead_num = iseq.fargs_format[:lead_num] || 0
        opt = iseq.fargs_format[:opt] || [0]
        rest_start = iseq.fargs_format[:rest_start]
        post_start = iseq.fargs_format[:post_start]
        post_num = iseq.fargs_format[:post_num] || 0
        kw_start = iseq.fargs_format[:kwbits]
        keyword = iseq.fargs_format[:keyword]
        kw_start -= keyword.size if kw_start
        kw_rest = iseq.fargs_format[:kwrest]
        block_start = iseq.fargs_format[:block_start]

lead_tys = env.locals[0, lead_num].map {|ty| globalize_type(ty, env, ep) }
        opt_tys = opt.size > 1 ? env.locals[lead_num, opt.size - 1].map {|ty| globalize_type(ty, env, ep) } : []
        if rest_start # XXX:squash
          ty = globalize_type(env.locals[rest_start], env, ep)
          rest_ty = Type.bot
          ty.each_child_global do |ty|
            if ty.is_a?(Type::Array)
              rest_ty = rest_ty.union(ty.elems.squash)
            else
              # XXX: to_ary?
              rest_ty = rest_ty.union(ty)
            end
          end
        end
        post_tys = (post_start ? env.locals[post_start, post_num] : []).map {|ty| globalize_type(ty, env, ep) }
        if keyword
          kw_tys = []
          keyword.each_with_index do |kw, i|
            case
            when kw.is_a?(Symbol) # required keyword
              key = kw
              req = true
            when kw.size == 2 # optional keyword (default value is a literal)
              key, default_ty = *kw
              default_ty = Type.guess_literal_type(default_ty)
              default_ty = default_ty.base_type if default_ty.is_a?(Type::Literal)
              req = false
            else # optional keyword (default value is an expression)
              key, = kw
              req = false
            end
            ty = env.locals[kw_start + i]
            ty = ty.union(default_ty) if default_ty
            ty = globalize_type(ty, env, ep)
            kw_tys << [req, key, ty]
          end
        end
        kw_rest_ty = globalize_type(env.locals[kw_rest], env, ep) if kw_rest
        kw_rest_ty = nil if kw_rest_ty == Type.nil
        if block_start
          blk_ty = globalize_type(env.locals[block_start], env, ep)
        elsif iseq.type == :method
          blk_ty = env.static_env.blk_ty
        else
          blk_ty = Type.nil
        end
        msig = MethodSignature.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
        add_method_signature!(ep.ctx, msig)
      when :putspecialobject
        kind, = operands
        ty = case kind
        when 1 then Type::Instance.new(Type::Builtin[:vmcore])
        when 2, 3 # CBASE / CONSTBASE
          ep.ctx.cref.klass
        else
          raise NotImplementedError, "unknown special object: #{ type }"
        end
        env = env.push(ty)
      when :putnil
        env = env.push(Type.nil)
      when :putobject, :duparray
        obj, = operands
        env, ty = localize_type(Type.guess_literal_type(obj), env, ep)
        env = env.push(ty)
      when :putstring
        str, = operands
        ty = Type::Literal.new(str, Type::Instance.new(Type::Builtin[:str]))
        env = env.push(ty)
      when :putself
        ty = env.static_env.recv_ty
        if ty.is_a?(Type::Instance)
          klass = ty.klass
          if klass.type_params.size >= 1
            ty = Type::ContainerType.create_empty_instance(klass)
            env, ty = localize_type(ty, env, ep, AllocationSite.new(ep))
          else
            ty = Type::Instance.new(klass)
          end
          env, ty = localize_type(ty, env, ep)
        end
        env = env.push(ty)
      when :newarray, :newarraykwsplat
        len, = operands
        env, elems = env.pop(len)
        ty = Type::Array.new(Type::Array::Elements.new(elems), Type::Instance.new(Type::Builtin[:ary]))
        env, ty = localize_type(ty, env, ep)
        env = env.push(ty)
      when :newhash
        num, = operands
        env, tys = env.pop(num)

ty = Type.gen_hash do |h|
          tys.each_slice(2) do |k_ty, v_ty|
            k_ty = globalize_type(k_ty, env, ep)
            h[k_ty] = v_ty
          end
        end

env, ty = localize_type(ty, env, ep)
        env = env.push(ty)
      when :newhashfromarray
        raise NotImplementedError, "newhashfromarray"
      when :newrange
        env, tys = env.pop(2)
        # XXX: need generics
        env = env.push(Type::Instance.new(Type::Builtin[:range]))

when :concatstrings
        num, = operands
        env, = env.pop(num)
        env = env.push(Type::Instance.new(Type::Builtin[:str]))
      when :tostring, :anytostring
        env, (_ty1, _ty2,) = env.pop(2)
        env = env.push(Type::Instance.new(Type::Builtin[:str]))
      when :objtostring
        env, (_ty1,) = env.pop(1)
        env = env.push(Type::Instance.new(Type::Builtin[:str]))
      when :freezestring
        # do nothing
      when :toregexp
        _regexp_opt, str_count = operands
        env, tys = env.pop(str_count)
        # TODO: check if tys are all strings?
        env = env.push(Type::Instance.new(Type::Builtin[:regexp]))
      when :intern
        env, (ty,) = env.pop(1)
        # XXX check if ty is String
        env = env.push(Type::Instance.new(Type::Builtin[:sym]))

when :definemethod
        mid, iseq = operands
        do_define_iseq_method(ep, env, mid, iseq, nil)

when :definesmethod
        mid, iseq = operands
        env, (recv,) = env.pop(1)
        cref = ep.ctx.cref
        recv.each_child do |recv|
          if recv.is_a?(Type::Class)
            typed_mdef = check_typed_method(recv, mid, true)
            if typed_mdef
              mdef = ISeqMethodDef.new(iseq, cref, nil, env.static_env.pub_meth)
              typed_mdef.each do |typed_mdef|
                typed_mdef.do_match_iseq_mdef(mdef, recv, mid, env, ep, self)
              end
            else
              meth = add_singleton_iseq_method(recv, mid, iseq, cref, nil, env.static_env.pub_meth)
            end

pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref, nil)
          else
            recv = Type.any # XXX: what to do?
          end
        end
      when :defineclass
        id, iseq, flags = operands
        env, (cbase, superclass) = env.pop(2)
        case flags & 7
        when 0, 2 # CLASS / MODULE
          type = (flags & 7) == 2 ? :module : :class
          existing_klass, = get_constant(cbase, id) # TODO: multiple return values
          if existing_klass.is_a?(Type::Class)
            # record re-opening location
            @class_defs[cbase.idx].add_class_open(id, ep)
            klass = existing_klass
          else
            if existing_klass != Type.any
              error(ep, "the class \"#{ id }\" is #{ existing_klass.screen_name(self) }")
            end
            if type == :class
              if superclass.is_a?(Type::Class)
                # okay
              elsif superclass == Type.any
                warn(ep, "superclass is any; Object is used instead")
                superclass = Type::Builtin[:obj]
              elsif superclass == Type.nil
                superclass = Type::Builtin[:obj]
              elsif superclass.is_a?(Type::Instance)
                warn(ep, "superclass is an instance; Object is used instead")
                superclass = Type::Builtin[:obj]
              else
                warn(ep, "superclass is not a class; Object is used instead")
                superclass = Type::Builtin[:obj]
              end
            else # module
              superclass = nil
            end
            if cbase.is_a?(Type::Class)
              klass = new_class(cbase, id, [], superclass, ep)
              if superclass
                add_superclass_type_args!(klass, superclass.type_params.map { Type.any })

# inherited hook
                aargs = ActualArguments.new([klass], nil, {}, Type.nil)
                do_send(superclass, :inherited, aargs, ep, env) {|_ret_ty, _ep| }
              end
            else
              klass = Type.any
            end
          end
          singleton = false
        when 1 # SINGLETON_CLASS
          singleton = true
          klass = cbase
          if klass.is_a?(Type::Class)
          elsif klass.is_a?(Type::Any)
          else
            warn(ep, "A singleton class is open for #{ klass.screen_name(self) }; handled as any")
            klass = Type.any
          end
        else
          raise NotImplementedError, "unknown defineclass flag: #{ flags }"
        end
        ncref = ep.ctx.cref.extend(klass, singleton)
        recv = singleton ? Type.any : klass
        blk = env.static_env.blk_ty
        nctx = Context.new(iseq, ncref, nil)
        nep = ExecutionPoint.new(nctx, 0, nil)
        locals = [Type.nil] * iseq.locals.size
        nenv = Env.new(StaticEnv.new(recv, blk, false, true), locals, [], Utils::HashWrapper.new({}))
        merge_env(nep, nenv)
        add_callsite!(nep.ctx, ep, env) do |ret_ty, ep, env|
          nenv, ret_ty = localize_type(ret_ty, env, ep)
          nenv = nenv.push(ret_ty)
          merge_env(ep.next, nenv)
        end
        return
      when :send
        env, recvs, mid, aargs = setup_actual_arguments(:method, operands, ep, env)
        recvs = Type.any if recvs == Type.bot
        do_send(recvs, mid, aargs, ep, env) do |ret_ty, ep, env|
          nenv, ret_ty, = localize_type(ret_ty, env, ep)
          nenv = nenv.push(ret_ty)
          merge_env(ep.next, nenv)
        end
        return
      when :recv_getlocal_send_branch
        getlocal_operands, send_operands, branch_operands = operands
        env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
        recvs = Type.any if recvs == Type.bot
        recvs.each_child do |recv|
          do_send(recv, mid, aargs, ep, env) do |ret_ty, ep, env|
            env, ret_ty, = localize_type(ret_ty, env, ep)

branchtype, target, = branch_operands
            # branchtype: :if or :unless or :nil
            ep_then = ep.next
            ep_else = ep.jump(target)

var_idx, _scope_idx, _escaped = getlocal_operands
            flow_env = env.local_update(-var_idx+2, recv)

case ret_ty
            when Type::Instance.new(Type::Builtin[:true])
              merge_env(branchtype == :if ? ep_else : ep_then, flow_env)
            when Type::Instance.new(Type::Builtin[:false])
              merge_env(branchtype == :if ? ep_then : ep_else, flow_env)
            else
              merge_env(ep_then, env)
              merge_env(ep_else, env)
            end
          end
        end
        return
      when :arg_getlocal_send_branch
        getlocal_operands, send_operands, branch_operands = operands
        env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
        raise if aargs.lead_tys.size != 1
        aarg = aargs.lead_tys[0]
        aarg = Type.any if aarg == Type.bot
        recvs.each_child do |recv|
          aarg.each_child do |aarg|
            aargs_tmp = ActualArguments.new([aarg], nil, {}, aargs.blk_ty)
            do_send(recv, mid, aargs_tmp, ep, env) do |ret_ty, ep, env|
              env, ret_ty, = localize_type(ret_ty, env, ep)

branchtype, target, = branch_operands
              # branchtype: :if or :unless or :nil
              ep_then = ep.next
              ep_else = ep.jump(target)

var_idx, _scope_idx, _escaped = getlocal_operands
              flow_env = env.local_update(-var_idx+2, aarg)

case ret_ty
              when Type::Instance.new(Type::Builtin[:true])
                merge_env(branchtype == :if ? ep_else : ep_then, flow_env)
              when Type::Instance.new(Type::Builtin[:false])
                merge_env(branchtype == :if ? ep_then : ep_else, flow_env)
              else
                merge_env(ep_then, env)
                merge_env(ep_else, env)
              end
            end
          end
        end
        return
      when :send_branch
        send_operands, branch_operands = operands
        env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
        recvs = Type.any if recvs == Type.bot
        do_send(recvs, mid, aargs, ep, env) do |ret_ty, ep, env|
          env, ret_ty, = localize_type(ret_ty, env, ep)

branchtype, target, = branch_operands
          # branchtype: :if or :unless or :nil
          ep_then = ep.next
          ep_else = ep.jump(target)

case ret_ty
          when Type::Instance.new(Type::Builtin[:true])
            merge_env(branchtype == :if ? ep_else : ep_then, env)
          when Type::Instance.new(Type::Builtin[:false])
            merge_env(branchtype == :if ? ep_then : ep_else, env)
          else
            merge_env(ep_then, env)
            merge_env(ep_else, env)
          end
        end
        return
      when :invokeblock
        env, recvs, mid, aargs = setup_actual_arguments(:block, operands, ep, env)
        blk = env.static_env.blk_ty
        case
        when blk == Type.nil
          env = env.push(Type.any)
        when blk == Type.any
          #warn(ep, "block is any")
          env = env.push(Type.any)
        else # Proc
          do_invoke_block(blk, aargs, ep, env) do |ret_ty, ep, env|
            nenv, ret_ty, = localize_type(ret_ty, env, ep)
            nenv = nenv.push(ret_ty)
            merge_env(ep.next, nenv)
          end
          return
        end
      when :invokesuper
        env, recv, _, aargs = setup_actual_arguments(:method, operands, ep, env)
        mid = ep.ctx.mid
        found = false
        recv.each_child_global do |recv|
          klass, singleton = recv.method_dispatch_info
          next unless klass
          get_all_super_methods(klass, singleton, ep.ctx.cref.klass, ep.ctx.mid) do |meths, klass|
            found = true
            meths.each do |meth|
              # XXX: this decomposition is really needed??
              # It calls `Object.new` with union receiver which causes an error, but
              # it may be a fault of builtin Object.new implementation.
              meth.do_send(recv, mid, aargs, ep, env, self) do |ret_ty, ep, env|
                nenv, ret_ty, = localize_type(ret_ty, env, ep)
                nenv = nenv.push(ret_ty)
                merge_env(ep.next, nenv)
              end
            end
          end
        end
        return if found
        error(ep, "no superclass method: #{ env.static_env.recv_ty.screen_name(self) }##{ mid }")
        env = env.push(Type.any)
      when :invokebuiltin
        raise NotImplementedError
      when :leave
        if env.stack.size != 1
          raise "stack inconsistency error: #{ env.stack.inspect }"
        end
        env, (ty,) = env.pop(1)
        ty = globalize_type(ty, env, ep)
        add_return_value!(ep.ctx, ty)
        return
      when :throw
        throwtype, = operands
        env, (ty,) = env.pop(1)
        _no_escape = !!(throwtype & 0x8000)
        throwtype = [:none, :return, :break, :next, :retry, :redo][throwtype & 0xff]
        case throwtype
        when :none

when :return
          ty = globalize_type(ty, env, ep)
          tmp_ep = ep
          tmp_ep = tmp_ep.outer while tmp_ep.outer
          add_return_value!(tmp_ep.ctx, ty)
          return
        when :break
          tmp_ep = ep
          while true
            if tmp_ep.ctx.iseq.type == :block
              tmp_ep = tmp_ep.outer
              nenv = @return_envs[tmp_ep].push(ty)
              merge_env(tmp_ep.next, nenv)
              break
            end
            _type, _iseq, cont, stack_depth = tmp_ep.ctx.iseq.catch_table[tmp_ep.pc]&.find {|type,| type == :break }
            if cont
              nenv = @return_envs[tmp_ep] || env
              nenv, = nenv.pop(nenv.stack.size - stack_depth)
              nenv = nenv.push(ty)
              tmp_ep = tmp_ep.jump(cont)
              merge_env(tmp_ep, nenv)
              break
            end
            tmp_ep = tmp_ep.outer
          end
        when :next, :redo
          # begin; rescue; next; end
          tmp_ep = ep.outer
          _type, _iseq, cont, stack_depth = tmp_ep.ctx.iseq.catch_table[tmp_ep.pc].find {|type,| type == throwtype }
          nenv = @return_envs[tmp_ep]
          nenv, = nenv.pop(nenv.stack.size - stack_depth)
          nenv = nenv.push(ty) if throwtype == :next
          tmp_ep = tmp_ep.jump(cont)
          merge_env(tmp_ep, nenv)
        when :retry
          tmp_ep = ep.outer
          _type, _iseq, cont, stack_depth = tmp_ep.ctx.iseq.catch_table[tmp_ep.pc].find {|type,| type == :retry }
          nenv = @return_envs[tmp_ep]
          nenv, = nenv.pop(nenv.stack.size - stack_depth)
          tmp_ep = tmp_ep.jump(cont)
          merge_env(tmp_ep, nenv)
        else
          p throwtype
          raise NotImplementedError
        end
        return
      when :once
        iseq, = operands

nctx = Context.new(iseq, ep.ctx.cref, ep.ctx.mid)
        nep = ExecutionPoint.new(nctx, 0, ep)
        raise if iseq.locals != []
        nenv = Env.new(env.static_env, [], [], nil)
        merge_env(nep, nenv)
        add_callsite!(nep.ctx, ep, env) do |ret_ty, ep, env|
          nenv, ret_ty = localize_type(ret_ty, env, ep)
          nenv = nenv.push(ret_ty)
          merge_env(ep.next, nenv)
        end
        return

when :branch # TODO: check how branchnil is used
        branchtype, target, = operands
        # branchtype: :if or :unless or :nil
        env, (ty,) = env.pop(1)
        ep_then = ep.next
        ep_else = ep.jump(target)

# TODO: it works for only simple cases: `x = nil; x || 1`
        # It would be good to merge "dup; branchif" to make it context-sensitive-like
        falsy = ty == Type.nil

merge_env(ep_then, env)
        merge_env(ep_else, env) unless branchtype == :if && falsy
        return
      when :jump
        target, = operands
        merge_env(ep.jump(target), env)
        return

when :setinstancevariable
        var, = operands
        env, (ty,) = env.pop(1)
        recv = env.static_env.recv_ty
        set_instance_variable(recv, var, ty, ep, env)

when :getinstancevariable
        var, = operands
        recv = env.static_env.recv_ty
        get_instance_variable(recv, var, ep, env) do |ty, nenv|
          merge_env(ep.next, nenv.push(ty))
        end
        return

when :setclassvariable
        var, = operands
        env, (ty,) = env.pop(1)
        cbase = ep.ctx.cref.klass
        ty = globalize_type(ty, env, ep)
        # TODO: if superclass has the variable, it should be updated
        add_cvar_write!(cbase, var, ty, ep)

when :getclassvariable
        var, = operands
        cbase = ep.ctx.cref.klass
        # TODO: if superclass has the variable, it should be read
        add_cvar_read!(cbase, var, ep) do |ty, ep|
          nenv, ty = localize_type(ty, env, ep)
          merge_env(ep.next, nenv.push(ty))
        end
        return

when :setglobal
        var, = operands
        env, (ty,) = env.pop(1)
        ty = globalize_type(ty, env, ep)
        add_gvar_write!(var, ty, ep)

when :getglobal
        var, = operands
        ty = Type.builtin_global_variable_type(var)
        if ty
          ty, locs = get_constant(Type::Builtin[:obj], ty) if ty.is_a?(Symbol)
          env, ty = localize_type(ty, env, ep)
          env = env.push(ty)
        else
          add_gvar_read!(var, ep) do |ty, ep|
            nenv, ty = localize_type(ty, env, ep)
            merge_env(ep.next, nenv.push(ty))
          end
          # need to return default nil of global variables
          return
        end

when :getlocal
        var_idx, scope_idx, _escaped = operands
        if scope_idx == 0
          ty = env.get_local(-var_idx+2)
        else
          tmp_ep = ep
          scope_idx.times do
            tmp_ep = tmp_ep.outer
          end
          ty = @return_envs[tmp_ep].get_local(-var_idx+2)
        end
        env = env.push(ty)
      when :getlocal_branch
        getlocal_operands, branch_operands = operands
        var_idx, _scope_idx, _escaped = getlocal_operands
        ret_ty = env.get_local(-var_idx+2)