class IDL::AST::Node

def children
  @children
end

def copy_from(_template, instantiation_context)
  super
  _template.__send__(:walk_members_for_copy) do |child|
    _child_copy = child.instantiate(instantiation_context, self)
    @children << _child_copy
    # introduce unless already introduced (happens with module chains)
    @introduced[_child_copy.intern] = _child_copy unless @introduced.has_key?(_child_copy.intern)
  end
  self
end

def define(_type, _name, params = {})
  unless is_definable?(_type)
    raise "#{_type.to_s} is not definable in #{self.typename}."
  end
  node = search_self(_name)
  if node.nil?
    node = _type.new(_name, self, params)
    node.annotations.concat(params[:annotations])
    node.prefix = @prefix
    introduce(node)
    @children << node
  else
    if _type != node.class
      raise "#{_name} is already defined as a type of #{node.typename}"
    end
    node = redefine(node, params)
  end
  node
end

def initialize(name, enclosure)
  super
  @introduced = {}
  @children = []
  introduce(self)
end

def introduce(node)
  n = (@introduced[node.intern] ||= node)
  raise "#{node.name} is already introduced as a #{n.scoped_name} of #{n.typename}." if n != node
end

def is_definable?(_type)
  self.class::DEFINABLE.any? do |target|
    _type.ancestors.include? target
  end
end

def marshal_dump
  super() << @children << @introduced
end

def marshal_load(vars)
  @introduced = vars.pop
  @children = vars.pop
  super(vars)
end

def match_members(&block)
  !(@children.find(&block)).nil?
end

def redefine(node, _params)
  raise "\"#{node.name}\" is already defined."
end

def replace_prefix(pfx)
  super
  walk_members { |m| m.replace_prefix(pfx) }
end

def resolve(_name)
  node = search_enclosure(_name)
  @introduced[node.intern] = node unless node.nil?
  node
end

def search_enclosure(_name)
  node = search_self(_name)
  if node.nil? and not @enclosure.nil?
    node = @enclosure.search_enclosure(_name)
  end
  node
end

def search_self(_name)
  key = _name.downcase.intern
  node = @introduced[key]
  if not node.nil? and node.name != _name
    raise "\"#{_name}\" clashed with \"#{node.name}\"."
  end
  node
end

def select_members(&block)
  @children.select(&block)
end

def undo_introduction(node)
  @introduced.delete(node.intern)
end

def walk_members(&block)
  @children.each(&block)
end

def walk_members_for_copy(&block)
  self.walk_members(&block)
end