diff --git a/lib/puppet/pops/binder/bindings_model_dumper.rb b/lib/puppet/pops/binder/bindings_model_dumper.rb
index f47436ea9..1abfd0675 100644
--- a/lib/puppet/pops/binder/bindings_model_dumper.rb
+++ b/lib/puppet/pops/binder/bindings_model_dumper.rb
@@ -1,187 +1,187 @@
 
 # Dumps a Pops::Binder::Bindings model in reverse polish notation; i.e. LISP style
 # The intention is to use this for debugging output
 # TODO: BAD NAME - A DUMP is a Ruby Serialization
 # NOTE: use :break, :indent, :dedent in lists to do just that
 #
 class Puppet::Pops::Binder::BindingsModelDumper < Puppet::Pops::Model::TreeDumper
   Bindings = Puppet::Pops::Binder::Bindings
 
   attr_reader :type_calculator
   attr_reader :expression_dumper
 
   def initialize
     super
     @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
     @expression_dumper = Puppet::Pops::Model::ModelTreeDumper.new()
   end
 
   def dump_BindingsFactory o
     do_dump(o.model)
   end
 
   def dump_BindingsBuilder o
     do_dump(o.model)
   end
 
   def dump_BindingsContainerBuilder o
     do_dump(o.model)
   end
 
   def dump_NamedLayer o
     result = ['named-layer', (o.name.nil? ? '<no-name>': o.name), :indent]
     if o.bindings
       o.bindings.each do |b|
         result << :break
         result << do_dump(b)
       end
     end
     result << :dedent
     result
   end
 
 
   def dump_Array o
     o.collect {|e| do_dump(e) }
   end
 
   def dump_ASTArray o
     ["[]"] + o.children.collect {|x| do_dump(x)}
   end
 
   def dump_ASTHash o
     ["{}"] + o.value.sort_by{|k,v| k.to_s}.collect {|x| [do_dump(x[0]), do_dump(x[1])]}
   end
 
   def dump_Integer o
     o.to_s
   end
 
   # Dump a Ruby String in single quotes unless it is a number.
   def dump_String o
     "'#{o}'"
   end
 
   def dump_NilClass o
     "()"
   end
 
   def dump_Object o
     ['dev-error-no-polymorph-dump-for:', o.class.to_s, o.to_s]
   end
 
   def is_nop? o
     o.nil? || o.is_a?(Model::Nop) || o.is_a?(AST::Nop)
   end
 
   def dump_ProducerDescriptor o
      result = [o.class.name]
      result << expression_dumper.dump(o.transformer) if o.transformer
      result
   end
 
   def dump_NonCachingProducerDescriptor o
     dump_ProducerDescriptor(o) + do_dump(o.producer)
   end
 
   def dump_ConstantProducerDescriptor o
     ['constant', do_dump(o.value)]
   end
 
   def dump_EvaluatingProducerDescriptor o
     result = dump_ProducerDescriptor(o)
     result << expression_dumper.dump(o.expression)
   end
 
-  def dump_InstanceProducerDescriptor
+  def dump_InstanceProducerDescriptor o
     # TODO: o.arguments, o. transformer
     ['instance', o.class_name]
   end
 
   def dump_ProducerProducerDescriptor o
     # skip the transformer lambda...
     result = ['producer-producer', do_dump(o.producer)]
     result << expression_dumper.dump(o.transformer) if o.transformer
     result
   end
 
   def dump_LookupProducerDescriptor o
     ['lookup', do_dump(o.type), o.name]
   end
 
   def dump_PObjectType o
     type_calculator.string(o)
   end
 
   def dump_HashLookupProducerDescriptor o
     # TODO: transformer lambda
     result = ['hash-lookup', do_dump(o.type), o.name, "[#{do_dump(o.key)}]"]
     result << expression_dumper.dump(o.transformer) if o.transformer
     result
   end
 
   def dump_FirstFoundProducerDescriptor o
     # TODO: transformer lambda
     ['first-found', do_dump(o.producers)]
   end
 
   def dump_ArrayMultibindProducerDescriptor o
     ['multibind-array']
   end
 
   def dump_HashMultibindProducerDescriptor o
     ['multibind-hash']
   end
 
   def dump_NamedArgument o
     "#{o.name} => #{do_dump(o.value)}"
   end
 
   def dump_Binding o
     result = ['bind']
     result << 'override' if o.override
     result << 'abstract' if o.abstract
     result.concat([do_dump(o.type), o.name])
     result << "(in #{o.multibind_id})" if o.multibind_id
     result << ['to', do_dump(o.producer)] + do_dump(o.producer_args)
     result
   end
 
   def dump_Multibinding o
     result = ['multibind', o.id]
     result << 'override' if o.override
     result << 'abstract' if o.abstract
     result.concat([do_dump(o.type), o.name])
     result << "(in #{o.multibind_id})" if o.multibind_id
     result << ['to', do_dump(o.producer)] + do_dump(o.producer_args)
     result
   end
 
   def dump_Bindings o
     do_dump(o.bindings)
   end
 
   def dump_NamedBindings o
     result = ['named-bindings', o.name, :indent]
     o.bindings.each do |b|
       result << :break
       result << do_dump(b)
     end
     result << :dedent
     result
   end
 
   def dump_LayeredBindings o
     result = ['layers', :indent]
       o.layers.each do |layer|
         result << :break
         result << do_dump(layer)
       end
     result << :dedent
     result
   end
 
   def dump_ContributedBindings o
     ['contributed', o.name, do_dump(o.bindings)]
   end
 end