class YARD::Parser::Ruby::AstNode

def self.node_class_for(type)
  case type
  when :params
    ParameterNode
  when :call, :fcall, :vcall, :command, :command_call
    MethodCallNode
  when :if, :elsif, :if_mod, :unless, :unless_mod
    ConditionalNode
  when :for, :while, :while_mod, :until, :until_mod
    LoopNode
  when :def, :defs
    MethodDefinitionNode
  when :class, :sclass
    ClassNode
  when :module
    ModuleNode
  else
    if type.to_s =~ /_ref\Z/
      ReferenceNode
    elsif type.to_s =~ /_literal\Z/
      LiteralNode
    elsif KEYWORDS.key?(type)
      KeywordNode
    else
      AstNode
    end
  end
end

def ==(other)
  super && type == other.type
end

def block?
  respond_to?(:block) || condition?
end

def call?
  false
end

def children
  @children ||= select {|e| AstNode === e }
end

def condition?
  false
end

def def?
  false
end

def file
  return parent.file if parent
  @file
end

def first_line
  full_source.split(/\r?\n/)[line - 1].strip
end

def full_source
  return parent.full_source if parent
  return @full_source if @full_source
  return IO.read(@file) if file && File.exist?(file)
end

def has_line?
  @line_range ? true : false
end

def initialize(type, arr, opts = {})
  super(arr)
  self.type = type
  self.line_range = opts[:line]
  self.source_range = opts[:char]
  @fallback_line = opts[:listline]
  @fallback_source = opts[:listchar]
  @token = true if opts[:token]
  @docstring = nil
end

def inspect
  typeinfo = type && type != :list ? ':' + type.to_s + ', ' : ''
  's(' + typeinfo + map(&:inspect).join(", ") + ')'
end

def jump(*node_types)
  traverse {|child| return(child) if node_types.include?(child.type) }
  self
end

def kw?
  false
end

def line
  line_range && line_range.first
end

def line_range
  reset_line_info unless @line_range
  @line_range
end

def literal?
  false
end

def loop?
  false
end

def pretty_print(q)
  objs = dup + [:__last__]
  objs.unshift(type) if type && type != :list
  options = []
  options << ['docstring', docstring] if @docstring
  if @source_range || @line_range
    options << ['line', line_range]
    options << ['source', source_range]
  end
  objs.pop if options.empty?
  q.group(3, 's(', ')') do
    q.seplist(objs, nil, :each) do |v|
      if v == :__last__
        q.seplist(options, nil, :each) do |arr|
          k, v2 = *arr
          q.group(3) do
            q.text k
            q.group(3) do
              q.text ': '
              q.pp v2
            end
          end
        end
      else
        q.pp v
      end
    end
  end
end

def ref?
  false
end

def reset_line_info
  if size == 0
    self.line_range = @fallback_line
    self.source_range = @fallback_source
  elsif !children.empty?
    f = children.first
    l = children.last
    self.line_range = Range.new(f.line_range.first, l.line_range.last)
    self.source_range = Range.new(f.source_range.first, l.source_range.last)
  elsif @fallback_line || @fallback_source
    self.line_range = @fallback_line
    self.source_range = @fallback_source
  else
    self.line_range = 0...0
    self.source_range = 0...0
  end
end

def show
  "\t#{line}: #{first_line}"
end

def source
  return parent.full_source[source_range] if parent
  full_source
end

def source_range
  reset_line_info unless @source_range
  @source_range
end

def token?
  @token
end

def traverse
  nodes = [self]
  until nodes.empty?
    node = nodes.pop
    yield node
    nodes += node.children.reverse unless node.children.empty?
  end
end

def unfreeze
  @children = nil
end