class TypeProf::Scratch::ClassDef

# File typeprof-0.21.9/lib/typeprof/analyzer.rb, line 348
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

# File typeprof-0.21.9/lib/typeprof/analyzer.rb, line 404
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

# File typeprof-0.21.9/lib/typeprof/analyzer.rb, line 386
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

# File typeprof-0.21.9/lib/typeprof/analyzer.rb, line 466
def add_method(mid, singleton, mdef)
  @methods[[singleton, mid]] ||= Utils::MutableSet.new
  @methods[[singleton, mid]] << mdef
  # Need to restart...?
end

# File typeprof-0.21.9/lib/typeprof/analyzer.rb, line 424
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

# File typeprof-0.21.9/lib/typeprof/analyzer.rb, line 411
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

# File typeprof-0.21.9/lib/typeprof/analyzer.rb, line 450
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

# File typeprof-0.21.9/lib/typeprof/analyzer.rb, line 462
def check_typed_attr(mid, singleton)
  check_typed(mid, singleton, TypedAttrMethodDef)
end

# File typeprof-0.21.9/lib/typeprof/analyzer.rb, line 458
def check_typed_method(mid, singleton)
  check_typed(mid, singleton, TypedMethodDef)
end

# File typeprof-0.21.9/lib/typeprof/analyzer.rb, line 396
def consts
  @consts.lazy.flat_map do |name, (ty, eps)|
    eps.map do |ep|
      [name, [ty, ep]]
    end
  end
end

# File typeprof-0.21.9/lib/typeprof/analyzer.rb, line 380
def get_constant(name)
  ty, locs = @consts[name]
  ty = ty || Type.any # XXX: warn?
  return ty, locs
end

# File typeprof-0.21.9/lib/typeprof/analyzer.rb, line 369
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

# File typeprof-0.21.9/lib/typeprof/analyzer.rb, line 433
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

# File typeprof-0.21.9/lib/typeprof/analyzer.rb, line 472
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