class TypeProf::Core::MethodDeclBox

# File bundled-src/typeprof-0.31.1/lib/typeprof/core/graph/box.rb, line 103
def initialize(node, genv, cpath, singleton, mid, method_types, overloading)
  super(node)
  @cpath = cpath
  @singleton = singleton
  @mid = mid
  @method_types = method_types
  @overloading = overloading
  @ret = Source.new

  me = genv.resolve_method(@cpath, @singleton, @mid)
  me.add_decl(self)
  me.add_run_all_method_call_boxes(genv)
  me.add_run_all_mdefs(genv)
end

# File bundled-src/typeprof-0.31.1/lib/typeprof/core/graph/box.rb, line 122
def destroy(genv)
  me = genv.resolve_method(@cpath, @singleton, @mid)
  me.remove_decl(self)
  me.add_run_all_method_call_boxes(genv)
end

# File bundled-src/typeprof-0.31.1/lib/typeprof/core/graph/box.rb, line 128
def match_arguments?(genv, changes, param_map, a_args, method_type)
  # TODO: handle a tuple as a splat argument?
  if a_args.splat_flags.any?
    return false unless method_type.rest_positionals
    method_type.req_positionals.size.times do |i|
      return false if a_args.splat_flags[i]
    end
    method_type.post_positionals.size.times do |i|
      return false if a_args.splat_flags[-i - 1]
    end
  else
    actual = a_args.positionals.size
    required_formal = method_type.req_positionals.size + method_type.post_positionals.size
    if actual < required_formal
      # too few actual arguments
      return false
    end
    if !method_type.rest_positionals && actual > required_formal + method_type.opt_positionals.size
      # too many actual arguments
      return false
    end
  end

  method_type.req_positionals.each_with_index do |ty, i|
    return false unless ty.typecheck(genv, changes, a_args.positionals[i], param_map)
  end
  method_type.post_positionals.each_with_index do |ty, i|
    i -= method_type.post_positionals.size
    return false unless ty.typecheck(genv, changes, a_args.positionals[i], param_map)
  end

  start_rest = method_type.req_positionals.size
  end_rest = a_args.positionals.size - method_type.post_positionals.size

  i = 0
  while i < method_type.opt_positionals.size && start_rest < end_rest
    break if a_args.splat_flags[start_rest]
    return false unless method_type.opt_positionals[i].typecheck(genv, changes, a_args.positionals[start_rest], param_map)
    i += 1
    start_rest += 1
  end

  if start_rest < end_rest
    vtxs = a_args.get_rest_args(genv, changes, start_rest, end_rest)
    while i < method_type.opt_positionals.size
      ty = method_type.opt_positionals[i]
      return false if vtxs.any? {|vtx| !ty.typecheck(genv, changes, vtx, param_map) }
      i += 1
    end
    if method_type.rest_positionals
      return false if vtxs.any? {|vtx| !method_type.rest_positionals.typecheck(genv, changes, vtx, param_map) }
    end
  end

  return true
end

# File bundled-src/typeprof-0.31.1/lib/typeprof/core/graph/box.rb, line 185
def resolve_overload(changes, genv, method_type, node, param_map, a_args, ret, force)
  param_map0 = param_map.dup
  if method_type.type_params
    method_type.type_params.zip(yield(method_type)) do |var, vtx|
      param_map0[var] = vtx
    end
  end

  unless match_arguments?(genv, changes, param_map0, a_args, method_type)
    if force
      meth = node.mid_code_range ? :mid_code_range : :code_range
      changes.add_diagnostic(meth, "wrong type of arguments") # XXX: more friendly and fine-grained error message
    end
    return false
  end

  rbs_blk = method_type.block
  if method_type.block_required && !a_args.block
    if force
      meth = node.mid_code_range ? :mid_code_range : :code_range
      changes.add_diagnostic(meth, "block is expected") # XXX: more friendly error message
    end
    return false
  end
  if !rbs_blk && a_args.block
    if force
      meth = node.mid_code_range ? :mid_code_range : :code_range
      changes.add_diagnostic(meth, "block is not expected") # XXX: more friendly error message
    end
    return false
  end
  if rbs_blk && a_args.block
    # rbs_blk_func.optional_keywords, ...
    blk_a_args = rbs_blk.req_positionals.map do |blk_a_arg|
      blk_a_arg.covariant_vertex(genv, changes, param_map0)
    end
    a_args.block.each_type do |ty|
      case ty
      when Type::Proc
        ty.block.accept_args(genv, changes, blk_a_args)

        if ty.block.is_a?(Block)
          ty.block.next_boxes.each do |next_box|
            unless rbs_blk.return_type.typecheck(genv, changes, next_box.a_ret, param_map0)
              next_box.wrong_return_type(rbs_blk.return_type.show, changes)
            end
          end
        end
      end
    end
  end

  force = true
  return true

ensure
  if force
    ret_vtx = method_type.return_type.covariant_vertex(genv, changes, param_map0)
    changes.add_edge(genv, ret_vtx, ret)
  end
end

# File bundled-src/typeprof-0.31.1/lib/typeprof/core/graph/box.rb, line 247
def resolve_overloads(changes, genv, node, param_map, a_args, ret, &blk)
  if @method_types.size == 1
    method_type = @method_types.first
    resolve_overload(changes, genv, method_type, node, param_map, a_args, ret, true, &blk)
    return
  end

  match_any_overload = false
  @method_types.each do |method_type|
    if resolve_overload(changes, genv, method_type, node, param_map, a_args, ret, false, &blk)
      match_any_overload = true
    end
  end
  unless match_any_overload
    meth = node.mid_code_range ? :mid_code_range : :code_range
    changes.add_diagnostic(meth, "failed to resolve overloads")
  end
end

# File bundled-src/typeprof-0.31.1/lib/typeprof/core/graph/box.rb, line 266
def show
  @method_types.map do |method_type|
    args = []
    method_type.req_positionals.each do |arg|
      args << arg.show
    end
    method_type.opt_positionals.each do |arg|
      args << "?#{arg.show}"
    end
    if method_type.rest_positionals
      args << "*#{method_type.rest_positionals.show}"
    end
    method_type.post_positionals.each do |arg|
      args << arg.show
    end

    method_type.req_keywords.each do |key, arg|
      args << "#{ key }: #{arg.show}"
    end
    method_type.opt_keywords.each do |key, arg|
      args << "?#{ key }: #{arg.show}"
    end
    if method_type.rest_keywords
      args << "**#{method_type.rest_keywords.show}"
    end

    s = args.empty? ? "-> " : "(#{ args.join(", ") }) -> "
    s += method_type.return_type.show
  end.join(" | ")
end