Generally we should test for the type of the nod and not emitter class. The ruby AST as a datastructure is well defined. The relationship from node-types to emitters is just an implementation detail that can change at any time.

`if key.type == :symbol` would be a far better choice than to test for instance of `Primitive::Inspect::Symbol`.

That `save_without_quotes?` is now a public API of `Printer::Inspect::Symbol` this violates the LSP.

These two reasons scream for representing the conditional inside the inheritance tree.

Why do not introduce `Emitter.build` called from the main dispatcher. Default implementation will just call `Emitter.new`. But the `HashPair.build` could just do an additional dispatch either instantiating `HashPair::Colon` (for the 1.9 symbol case) and `HashPair::Hashrocked` for all others.

```
class HashPair
  include AbstractType

  register :pair

  def self.build(node, parent)
    klass = if node.type == :symbol && node.children.first.inspect[0] == DBL_QUOTE
      Colon
    else
      Hashrocket
    end
    klass.new(node, parent)
  end

  class Colon
    children :key, :value
    def dispatch
      write(COLON, key.to_s, WS, COLON)
      visit(value)
    end
  end

  class Hashrocked
     # as current HashPair
  end   
end
```

Two different `#dispatch` implementations of these two classes would allow to remove the `Literal::Inspect::Symbol` class altogether. The AST is a top down tree and referring to `parent` or `parent_type` should be avoided altogether. Over the longterm I suspect we could squeeze out these backrefs altogether.