diff --git a/lib/puppet/pops/model/ast_transformer.rb b/lib/puppet/pops/model/ast_transformer.rb
index acff56ff3..c52c1ffa0 100644
--- a/lib/puppet/pops/model/ast_transformer.rb
+++ b/lib/puppet/pops/model/ast_transformer.rb
@@ -1,655 +1,651 @@
 require 'puppet/parser/ast'
 
 # The receiver of `import(file)` calls; once per imported file, or nil if imports are ignored
 #
 # Transforms a Pops::Model to classic Puppet AST.
 # TODO: Documentation is currently skipped completely (it is only used for Rdoc)
 #
 class Puppet::Pops::Model::AstTransformer
   AST = Puppet::Parser::AST
   Model = Puppet::Pops::Model
 
   attr_reader :importer
   def initialize(source_file = "unknown-file", importer=nil)
     @@transform_visitor ||= Puppet::Pops::Visitor.new(nil,"transform",0,0)
     @@query_transform_visitor ||= Puppet::Pops::Visitor.new(nil,"query",0,0)
     @@hostname_transform_visitor ||= Puppet::Pops::Visitor.new(nil,"hostname",0,0)
     @importer = importer
     @source_file = source_file
   end
 
   # Initialize klass from o (location) and hash (options to created instance).
   # The object o is used to compute a source location. It may be nil. Source position is merged into
   # the given options (non surgically). If o is non-nil, the first found source position going up
   # the containment hierarchy is set. I.e. callers should pass nil if a source position is not wanted
   # or known to be unobtainable for the object.
   #
   # @param o [Object, nil] object from which source position / location is obtained, may be nil
   # @param klass [Class<Puppet::Parser::AST>] the ast class to create an instance of
   # @param hash [Hash] hash with options for the class to create
   #
   def ast(o, klass, hash={})
     # create and pass hash with file and line information
     klass.new(merge_location(hash, o))
   end
 
   # THIS IS AN EXPENSIVE OPERATION
   # The 3x AST requires line, pos etc. to be recorded directly in the AST nodes and this information
   # must be computed.
   # (Newer implementation only computes the information that is actually needed; typically when raising an
   # exception).
   #
   def merge_location(hash, o)
     if o
       pos = {}
       source_pos = Puppet::Pops::Utils.find_adapter(o, Puppet::Pops::Adapters::SourcePosAdapter)
       if source_pos
         pos[:line] = source_pos.line
         pos[:pos]  = source_pos.pos
       end
       pos[:file] = @source_file if @source_file
       hash = hash.merge(pos)
     end
     hash
   end
 
   # Transforms pops expressions into AST 3.1 statements/expressions
   def transform(o)
     @@transform_visitor.visit_this(self,o)
   end
 
   # Transforms pops expressions into AST 3.1 query expressions
   def query(o)
     @@query_transform_visitor.visit_this(self, o)
   end
 
   # Transforms pops expressions into AST 3.1 hostnames
   def hostname(o)
     @@hostname_transform_visitor.visit_this(self, o)
   end
 
   def transform_LiteralFloat(o)
     # Numbers are Names in the AST !! (Name a.k.a BareWord)
     ast o, AST::Name, :value => o.value.to_s
   end
 
   def transform_LiteralInteger(o)
     s = case o.radix
     when 10
       o.value.to_s
     when 8
       "0%o" % o.value
     when 16
       "0x%X" % o.value
     else
       "bad radix:" + o.value.to_s
     end
 
     # Numbers are Names in the AST !! (Name a.k.a BareWord)
     ast o, AST::Name, :value => s
   end
 
   # Transforms all literal values to string (override for those that should not be AST::String)
   #
   def transform_LiteralValue(o)
     ast o, AST::String, :value => o.value.to_s
   end
 
   def transform_LiteralBoolean(o)
     ast o, AST::Boolean, :value => o.value
   end
 
   def transform_Factory(o)
     transform(o.current)
   end
 
   def transform_ArithmeticExpression(o)
     ast o, AST::ArithmeticOperator2, :lval => transform(o.left_expr), :rval=>transform(o.right_expr),
     :operator => o.operator.to_s
   end
 
   def transform_Array(o)
     ast nil, AST::ASTArray, :children => o.collect {|x| transform(x) }
   end
 
   # Puppet AST only allows:
   # * variable[expression] => Hasharray Access
   # * NAME [expressions] => Resource Reference(s)
   # * type [epxressions] => Resource Reference(s)
   # * HashArrayAccesses[expression] => HasharrayAccesses
   #
   # i.e. it is not possible to do `func()[3]`, `[1,2,3][$x]`, `{foo=>10, bar=>20}[$x]` etc. since
   # LHS is not an expression
   #
   # Validation for 3.x semantics should validate the illegal cases. This transformation may fail,
   # or ignore excess information if the expressions are not correct.
   # This means that the transformation does not have to evaluate the lhs to detect the target expression.
   #
   # Hm, this seems to have changed, the LHS (variable) is evaluated if evaluateable, else it is used as is.
   #
   def transform_AccessExpression(o)
     case o.left_expr
     when Model::QualifiedName
       ast o, AST::ResourceReference, :type => o.left_expr.value, :title => transform(o.keys)
 
     when Model::QualifiedReference
       ast o, AST::ResourceReference, :type => o.left_expr.value, :title => transform(o.keys)
 
     when Model::VariableExpression
       ast o, AST::HashOrArrayAccess, :variable => transform(o.left_expr), :key => transform(o.keys()[0])
 
     else
       ast o, AST::HashOrArrayAccess, :variable => transform(o.left_expr), :key => transform(o.keys()[0])
     end
   end
 
   # Puppet AST has a complicated structure
   # LHS can not be an expression, it must be a type (which is downcased).
   # type = a downcased QualifiedName
   #
   def transform_CollectExpression(o)
     raise "LHS is not a type" unless o.type_expr.is_a? Model::QualifiedReference
     type = o.type_expr.value().downcase()
     args = { :type => type }
 
     # This somewhat peculiar encoding is used by the 3.1 AST.
     query = transform(o.query)
     if query.is_a? Symbol
       args[:form] =  query
     else
       args[:form] = query.form
       args[:query] = query
       query.type = type
     end
 
     if o.operations.size > 0
       args[:override] = transform(o.operations)
     end
     ast o, AST::Collection, args
   end
 
   def transform_ExportedQuery(o)
     if is_nop?(o.expr)
       result = :exported
     else
       result = query(o.expr)
       result.form = :exported
     end
     result
   end
 
   def transform_VirtualQuery(o)
     if is_nop?(o.expr)
       result = :virtual
     else
       result = query(o.expr)
       result.form = :virtual
     end
     result
   end
 
   # Ensures transformation fails if a 3.1 non supported object is encountered in a query expression
   #
   def query_Object(o)
     raise "Not a valid expression in a collection query: "+o.class.name
   end
 
   # Puppet AST only allows == and !=, and left expr is restricted, but right value is an expression
   #
   def query_ComparisonExpression(o)
     if [:'==', :'!='].include? o.operator
       ast o, AST::CollExpr, :test1 => query(o.left_expr), :oper => o.operator.to_s, :test2 => transform(o.right_expr)
     else
       raise "Not a valid comparison operator in a collection query: " + o.operator.to_s
     end
   end
 
   def query_AndExpression(o)
     ast o, AST::CollExpr, :test1 => query(o.left_expr), :oper => 'and', :test2 => query(o.right_expr)
   end
 
   def query_OrExpression(o)
     ast o, AST::CollExpr, :test1 => query(o.left_expr), :oper => 'or', :test2 => query(o.right_expr)
   end
 
   def query_ParenthesizedExpression(o)
     result = query(o.expr) # produces CollExpr
     result.parens = true
     result
   end
 
   def query_VariableExpression(o)
     transform(o)
   end
 
   def query_QualifiedName(o)
     transform(o)
   end
 
   def query_LiteralNumber(o)
     transform(o) # number to string in correct radix
   end
 
   def query_LiteralString(o)
     transform(o)
   end
 
   def query_LiteralBoolean(o)
     transform(o)
   end
 
   def transform_QualifiedName(o)
     ast o, AST::Name, :value => o.value
   end
 
   def transform_QualifiedReference(o)
     ast o, AST::Type, :value => o.value
   end
 
   def transform_ComparisonExpression(o)
     ast o, AST::ComparisonOperator, :operator => o.operator.to_s, :lval => transform(o.left_expr), :rval => transform(o.right_expr)
   end
 
   def transform_AndExpression(o)
     ast o, AST::BooleanOperator, :operator => 'and', :lval => transform(o.left_expr), :rval => transform(o.right_expr)
   end
 
   def transform_OrExpression(o)
     ast o, AST::BooleanOperator, :operator => 'or', :lval => transform(o.left_expr), :rval => transform(o.right_expr)
   end
 
   def transform_InExpression(o)
     ast o, AST::InOperator, :lval => transform(o.left_expr), :rval => transform(o.right_expr)
   end
 
   # This is a complex transformation from a modeled import to a Nop result (where the import took place),
   # and calls to perform import/parsing etc. during the transformation.
   # When testing syntax, the @importer does not have to be set, but it is not possible to check
   # the actual import without inventing a new AST::ImportExpression with nop effect when evaluating.
   def transform_ImportExpression(o)
     if importer
       o.files.each {|f|
         unless f.is_a? Model::LiteralString
           raise "Illegal import file expression. Must be a single quoted string"
         end
         importer.import(f.value)
       }
     end
     # Crazy stuff
     # Transformation of "import" needs to parse the other files at the time of transformation.
     # Then produce a :nop, since nothing should be evaluated.
     ast o, AST::Nop, {}
   end
 
-  def transform_InstanceReferences(o)
-    ast o, AST::ResourceReference, :type => o.type_name.value, :title => transform(o.names)
-  end
-
   # Assignment in AST 3.1 is to variable or hasharray accesses !!! See Bug #16116
   def transform_AssignmentExpression(o)
     args = {:value => transform(o.right_expr) }
     case o.operator
     when :'+='
       args[:append] = true
     when :'='
     else
       raise "The operator #{o.operator} is not supported by Puppet 3."
     end
 
     args[:name] = case o.left_expr
     when Model::VariableExpression
       ast o, AST::Name, {:value => o.left_expr.expr.value }
     when Model::AccessExpression
       transform(o.left_expr)
     else
       raise "LHS is not an expression that can be assigned to"
     end
     ast o, AST::VarDef, args
   end
 
   # Produces (name => expr) or (name +> expr)
   def transform_AttributeOperation(o)
     args = { :value => transform(o.value_expr) }
     args[:add] = true if o.operator == :'+>'
     args[:param] = o.attribute_name
     ast o, AST::ResourceParam, args
   end
 
   def transform_LiteralList(o)
     # Uses default transform of Ruby Array to ASTArray
     transform(o.values)
   end
 
   # Literal hash has strange behavior in Puppet 3.1. See Bug #19426, and this implementation is bug
   # compatible
   def transform_LiteralHash(o)
     if o.entries.size == 0
       ast o, AST::ASTHash, {:value=> {}}
     else
       value = {}
       o.entries.each {|x| value.merge! transform(x) }
       ast o, AST::ASTHash, {:value=> value}
     end
   end
 
   # Transforms entry into a hash (they are later merged with strange effects: Bug #19426).
   # Puppet 3.x only allows:
   # * NAME
   # * quotedtext
   # As keys (quoted text can be an interpolated string which is compared as a key in a less than satisfactory way).
   #
   def transform_KeyedEntry(o)
     value = transform(o.value)
     key = case o.key
     when Model::QualifiedName
       o.key.value
     when Model::LiteralString
       transform o.key
     when Model::LiteralNumber
       transform o.key
     when Model::ConcatenatedString
       transform o.key
     else
       raise "Illegal hash key expression of type (#{o.key.class})"
     end
     {key => value}
   end
 
   def transform_MatchExpression(o)
     ast o, AST::MatchOperator, :operator => o.operator.to_s, :lval => transform(o.left_expr), :rval => transform(o.right_expr)
   end
 
   def transform_LiteralString(o)
     ast o, AST::String, :value => o.value
   end
 
   def transform_LambdaExpression(o)
     astargs = { :parameters => o.parameters.collect {|p| transform(p) } }
     astargs.merge!({ :children => transform(o.body) }) if o.body         # do not want children if it is nil/nop
     ast o, AST::Lambda, astargs
   end
 
   def transform_LiteralDefault(o)
     ast o, AST::Default, :value => :default
   end
 
   def transform_LiteralUndef(o)
     ast o, AST::Undef, :value => :undef
   end
 
   def transform_LiteralRegularExpression(o)
     ast o, AST::Regex, :value => o.value
   end
 
   def transform_Nop(o)
     ast o, AST::Nop
   end
 
   # In the 3.1. grammar this is a hash that is merged with other elements to form a method call
   # Also in 3.1. grammar there are restrictions on the LHS (that are only there for grammar issues).
   #
   def transform_NamedAccessExpression(o)
     receiver = transform(o.left_expr)
     name = o.right_expr
     raise "Unacceptable function/method name" unless name.is_a? Model::QualifiedName
     {:receiver => receiver, :name => name.value}
   end
 
   def transform_NilClass(o)
     ast o, AST::Nop, {}
   end
 
   def transform_NotExpression(o)
     ast o, AST::Not, :value => transform(o.expr)
   end
 
   def transform_VariableExpression(o)
     # assumes the expression is a QualifiedName
     ast o, AST::Variable, :value => o.expr.value
   end
 
   # In Puppet 3.1, the ConcatenatedString is responsible for the evaluation and stringification of
   # expression segments. Expressions and Strings are kept in an array.
   def transform_TextExpression(o)
     transform(o.expr)
   end
 
   def transform_UnaryMinusExpression(o)
     ast o, AST::Minus, :value => transform(o.expr)
   end
 
   # Puppet 3.1 representation of a BlockExpression is an AST::Array - this makes it impossible to differentiate
   # between a LiteralArray and a Sequence. (Should it return the collected array, or the last expression?)
   # (A BlockExpression has now been introduced in the AST to solve this).
   #
   def transform_BlockExpression(o)
     children = []
     # remove nops resulting from import
     o.statements.each {|s| r = transform(s); children << r unless is_nop?(r) }
     ast o, AST::BlockExpression, :children => children  # o.statements.collect {|s| transform(s) }
   end
 
   # Interpolated strings are kept in an array of AST (string or other expression).
   def transform_ConcatenatedString(o)
     ast o, AST::Concat, :value => o.segments.collect {|x| transform(x)}
   end
 
   def transform_HostClassDefinition(o)
     parameters = o.parameters.collect {|p| transform(p) }
     args = {
       :arguments => parameters,
       :parent => o.parent_class,
     }
     args[:code] = transform(o.body) unless is_nop?(o.body)
     Puppet::Parser::AST::Hostclass.new(o.name, merge_location(args, o))
   end
 
   def transform_NodeDefinition(o)
     # o.host_matches are expressions, and 3.1 AST requires special object AST::HostName
     # where a HostName is one of NAME, STRING, DEFAULT or Regexp - all of these are strings except regexp
     #
     args = {
       :code => transform(o.body)
     }
     args[:parent] = hostname(o.parent) unless is_nop?(o.parent)
     if(args[:parent].is_a?(Array))
       raise "Illegal expression - unacceptable as a node parent"
     end
     Puppet::Parser::AST::Node.new(hostname(o.host_matches), merge_location(args, o))
   end
 
   # Transforms Array of host matching expressions into a (Ruby) array of AST::HostName
   def hostname_Array(o)
     o.collect {|x| ast x, AST::HostName, :value => hostname(x) }
   end
 
   def hostname_LiteralValue(o)
     return o.value
   end
 
   def hostname_QualifiedName(o)
     return o.value
   end
 
   def hostname_LiteralNumber(o)
     transform(o) # Number to string with correct radix
   end
 
   def hostname_LiteralDefault(o)
     return 'default'
   end
 
   def hostname_LiteralRegularExpression(o)
     ast o, AST::Regex, :value => o.value
   end
 
   def hostname_Object(o)
     raise "Illegal expression - unacceptable as a node name"
   end
 
   def transform_RelationshipExpression(o)
     Puppet::Parser::AST::Relationship.new(transform(o.left_expr), transform(o.right_expr), o.operator.to_s, merge_location({}, o))
   end
 
   def transform_ResourceTypeDefinition(o)
     parameters = o.parameters.collect {|p| transform(p) }
     args = { :arguments => parameters }
     args[:code] = transform(o.body) unless is_nop?(o.body)
 
     Puppet::Parser::AST::Definition.new(o.name, merge_location(args, o))
   end
 
   # Transformation of ResourceOverrideExpression is slightly more involved than a straight forward
   # transformation.
   # A ResourceOverrideExppression has "resources" which should be an AccessExpression
   # on the form QualifiedName[expressions], or QualifiedReference[expressions] to be valid.
   # It also has a set of attribute operations.
   #
   # The AST equivalence is an AST::ResourceOverride with a ResourceReference as its LHS, and
   # a set of Parameters.
   # ResourceReference has type as a string, and the expressions representing
   # the "titles" to be an ASTArray.
   #
   def transform_ResourceOverrideExpression(o)
     resource_ref = o.resources
     raise "Unacceptable expression for resource override" unless resource_ref.is_a? Model::AccessExpression
 
     type = case resource_ref.left_expr
     when Model::QualifiedName
       # This is deprecated "Resource references should now be capitalized" - this is caught elsewhere
       resource_ref.left_expr.value
     when Model::QualifiedReference
       resource_ref.left_expr.value
     else
       raise "Unacceptable expression for resource override; need NAME or CLASSREF"
     end
 
     result_ref = ast o, AST::ResourceReference, :type => type, :title => transform(resource_ref.keys)
 
     # title is one or more expressions, if more than one it should be an ASTArray
     ast o, AST::ResourceOverride, :object => result_ref, :parameters => transform(o.operations)
   end
 
   # Parameter is a parameter in a definition of some kind.
   # It is transformed to an array on the form `[name]´, or `[name, value]´.
   def transform_Parameter(o)
     if o.value
       [o.name, transform(o.value)]
     else
       [o.name]
     end
   end
 
   # For non query expressions, parentheses can be dropped in the resulting AST.
   def transform_ParenthesizedExpression(o)
     transform(o.expr)
   end
 
   def transform_Program(o)
     transform(o.body)
   end
 
   def transform_IfExpression(o)
     args = { :test => transform(o.test), :statements => transform(o.then_expr) }
     args[:else] = transform(o.else_expr) # Tests say Nop should be there (unless is_nop? o.else_expr), probably not needed
     ast o, AST::IfStatement, args
   end
 
   # Unless is not an AST object, instead an AST::IfStatement is used with an AST::Not around the test
   #
   def transform_UnlessExpression(o)
     args = { :test => ast(o, AST::Not, :value => transform(o.test)),
       :statements => transform(o.then_expr) }
     # AST 3.1 does not allow else on unless in the grammar, but it is ok since unless is encoded as an if !x
     args.merge!({:else => transform(o.else_expr)}) unless is_nop?(o.else_expr)
     ast o, AST::IfStatement, args
   end
 
   # Puppet 3.1 AST only supports calling a function by name (it is not possible to produce a function
   # that is then called).
   # rval_required (for an expression)
   # functor_expr (lhs - the "name" expression)
   # arguments - list of arguments
   #
   def transform_CallNamedFunctionExpression(o)
     name = o.functor_expr
     raise "Unacceptable expression for name of function" unless name.is_a? Model::QualifiedName
     args = {
       :name => name.value,
       :arguments => transform(o.arguments),
       :ftype => o.rval_required ? :rvalue : :statement
     }
     args[:pblock] = transform(o.lambda) if o.lambda
     ast o, AST::Function, args
   end
 
   # Transformation of CallMethodExpression handles a NamedAccessExpression functor and
   # turns this into a 3.1 AST::MethodCall.
   #
   def transform_CallMethodExpression(o)
     name = o.functor_expr
     raise "Unacceptable expression for name of function" unless name.is_a? Model::NamedAccessExpression
     # transform of NamedAccess produces a hash, add arguments to it
     astargs = transform(name).merge(:arguments => transform(o.arguments))
     astargs.merge!(:lambda => transform(o.lambda)) if o.lambda # do not want a Nop as the lambda
     ast o, AST::MethodCall, astargs
 
   end
 
   def transform_CaseExpression(o)
     # Expects expression, AST::ASTArray of AST
     ast o, AST::CaseStatement, :test => transform(o.test), :options => transform(o.options)
   end
 
   def transform_CaseOption(o)
     ast o, AST::CaseOpt, :value => transform(o.values), :statements => transform(o.then_expr)
   end
 
   def transform_ResourceBody(o)
     # expects AST, AST::ASTArray of AST
     ast o, AST::ResourceInstance, :title => transform(o.title), :parameters => transform(o.operations)
   end
 
   def transform_ResourceDefaultsExpression(o)
     ast o, AST::ResourceDefaults, :type => o.type_ref.value, :parameters => transform(o.operations)
   end
 
   # Transformation of ResourceExpression requires calling a method on the resulting
   # AST::Resource if it is virtual or exported
   #
   def transform_ResourceExpression(o)
     raise "Unacceptable type name expression" unless o.type_name.is_a? Model::QualifiedName
     resource = ast o, AST::Resource, :type => o.type_name.value, :instances => transform(o.bodies)
     resource.send("#{o.form}=", true) unless o.form == :regular
     resource
   end
 
   # Transformation of SelectorExpression is limited to certain types of expressions.
   # This is probably due to constraints in the old grammar rather than any real concerns.
   def transform_SelectorExpression(o)
     case o.left_expr
     when Model::CallNamedFunctionExpression
     when Model::AccessExpression
     when Model::VariableExpression
     when Model::ConcatenatedString
     else
       raise "Unacceptable select expression" unless o.left_expr.kind_of? Model::Literal
     end
     ast o, AST::Selector, :param => transform(o.left_expr), :values => transform(o.selectors)
   end
 
   def transform_SelectorEntry(o)
     ast o, AST::ResourceParam, :param => transform(o.matching_expr), :value => transform(o.value_expr)
   end
 
   def transform_Object(o)
     raise "Unacceptable transform - found an Object without a rule: #{o.class}"
   end
 
   # Nil, nop
   # Bee bopp a luh-lah, a bop bop boom.
   #
   def is_nop?(o)
     o.nil? || o.is_a?(Model::Nop)
   end
 end
diff --git a/lib/puppet/pops/model/factory.rb b/lib/puppet/pops/model/factory.rb
index 9319a7b45..0b9b82d22 100644
--- a/lib/puppet/pops/model/factory.rb
+++ b/lib/puppet/pops/model/factory.rb
@@ -1,935 +1,929 @@
 # Factory is a helper class that makes construction of a Pops Model
 # much more convenient. It can be viewed as a small internal DSL for model
 # constructions.
 # For usage see tests using the factory.
 #
 # @todo All those uppercase methods ... they look bad in one way, but stand out nicely in the grammar...
 #   decide if they should change into lower case names (some of the are lower case)...
 #
 class Puppet::Pops::Model::Factory
   Model = Puppet::Pops::Model
 
   attr_accessor :current
 
   alias_method :model, :current
 
   # Shared build_visitor, since there are many instances of Factory being used
   @@build_visitor = Puppet::Pops::Visitor.new(self, "build")
   @@interpolation_visitor = Puppet::Pops::Visitor.new(self, "interpolate")
   # Initialize a factory with a single object, or a class with arguments applied to build of
   # created instance
   #
   def initialize o, *args
     @current = case o
     when Model::PopsObject
       o
     when Puppet::Pops::Model::Factory
       o.current
     else
       build(o, *args)
     end
   end
 
   # Polymorphic build
   def build(o, *args)
     begin
       @@build_visitor.visit_this(self, o, *args)
     rescue =>e
       # require 'debugger'; debugger # enable this when in trouble...
       raise e
     end
   end
 
   # Polymorphic interpolate
   def interpolate()
     begin
       @@interpolation_visitor.visit_this(self, current)
     rescue =>e
       # require 'debugger'; debugger # enable this when in trouble...
       raise e
     end
   end
 
   # Building of Model classes
 
   def build_ArithmeticExpression(o, op, a, b)
     o.operator = op
     build_BinaryExpression(o, a, b)
   end
 
   def build_AssignmentExpression(o, op, a, b)
     o.operator = op
     build_BinaryExpression(o, a, b)
   end
 
   def build_AttributeOperation(o, name, op, value)
     o.operator = op
     o.attribute_name = name.to_s # BOOLEAN is allowed in the grammar
     o.value_expr = build(value)
     o
   end
 
   def build_AccessExpression(o, left, *keys)
     o.left_expr = to_ops(left)
     keys.each {|expr| o.addKeys(to_ops(expr)) }
     o
   end
 
   def build_BinaryExpression(o, left, right)
     o.left_expr = to_ops(left)
     o.right_expr = to_ops(right)
     o
   end
 
   def build_BlockExpression(o, *args)
     args.each {|expr| o.addStatements(to_ops(expr)) }
     o
   end
 
   def build_CollectExpression(o, type_expr, query_expr, attribute_operations)
     o.type_expr = to_ops(type_expr)
     o.query = build(query_expr)
     attribute_operations.each {|op| o.addOperations(build(op)) }
     o
   end
 
   def build_ComparisonExpression(o, op, a, b)
     o.operator = op
     build_BinaryExpression(o, a, b)
   end
 
   def build_ConcatenatedString(o, *args)
     args.each {|expr| o.addSegments(build(expr)) }
     o
   end
 
   def build_CreateTypeExpression(o, name, super_name = nil)
     o.name = name
     o.super_name = super_name
     o
   end
 
   def build_CreateEnumExpression(o, *args)
     o.name = args.slice(0) if args.size == 2
     o.values = build(args.last)
     o
   end
 
   def build_CreateAttributeExpression(o, name, datatype_expr)
     o.name = name
     o.type = to_ops(datatype_expr)
     o
   end
 
   # @param name [String] a valid classname
   # @param parameters [Array<Model::Parameter>] may be empty
   # @param parent_class_name [String, nil] a valid classname referencing a parent class, optional.
   # @param body [Array<Expression>, Expression, nil] expression that constitute the body
   # @return [Model::HostClassDefinition] configured from the parameters
   #
   def build_HostClassDefinition(o, name, parameters, parent_class_name, body)
     build_NamedDefinition(o, name, parameters, body)
     o.parent_class = parent_class_name if parent_class_name
     o
   end
 
   #  # @param name [String] a valid classname
   #  # @param parameters [Array<Model::Parameter>] may be empty
   #  # @param body [Array<Expression>, Expression, nil] expression that constitute the body
   #  # @return [Model::HostClassDefinition] configured from the parameters
   #  #
   #  def build_ResourceTypeDefinition(o, name, parameters, body)
   #    build_NamedDefinition(o, name, parameters, body)
   #    o.name = name
   #    parameters.each {|p| o.addParameters(build(p)) }
   #    b = f_build_body(body)
   #    o.body = b.current if b
   #    o
   #  end
 
   def build_ResourceOverrideExpression(o, resources, attribute_operations)
     o.resources = build(resources)
     attribute_operations.each {|ao| o.addOperations(build(ao)) }
     o
   end
 
   def build_KeyedEntry(o, k, v)
     o.key = build(k)
     o.value = build(v)
     o
   end
 
   def build_LiteralHash(o, *keyed_entries)
     keyed_entries.each {|entry| o.addEntries build(entry) }
     o
   end
 
   def build_LiteralList(o, *values)
     values.each {|v| o.addValues build(v) }
     o
   end
 
   def build_LiteralFloat(o, val)
     o.value = val
     o
   end
 
   def build_LiteralInteger(o, val, radix)
     o.value = val
     o.radix = radix
     o
   end
 
-  def build_InstanceReferences(o, type_name, name_expressions)
-    o.type_name = build(type_name)
-    name_expressions.each {|n| o.addNames(build(n)) }
-    o
-  end
-
   def build_ImportExpression(o, files)
     # The argument files has already been built
     files.each {|f| o.addFiles(to_ops(f)) }
     o
   end
 
   def build_IfExpression(o, t, ift, els)
     o.test = build(t)
     o.then_expr = build(ift)
     o.else_expr= build(els)
     o
   end
 
   def build_MatchExpression(o, op, a, b)
     o.operator = op
     build_BinaryExpression(o, a, b)
   end
 
   # Builds body :) from different kinds of input
   # @overload f_build_body(nothing)
   #   @param nothing [nil] unchanged, produces nil
   # @overload f_build_body(array)
   #   @param array [Array<Expression>] turns into a BlockExpression
   # @overload f_build_body(expr)
   #   @param expr [Expression] produces the given expression
   # @overload f_build_body(obj)
   #   @param obj [Object] produces the result of calling #build with body as argument
   def f_build_body(body)
     case body
     when NilClass
       nil
     when Array
       Puppet::Pops::Model::Factory.new(Model::BlockExpression, *body)
     else
       build(body)
     end
   end
 
   def build_LambdaExpression(o, parameters, body)
     parameters.each {|p| o.addParameters(build(p)) }
     b = f_build_body(body)
     o.body = b.current if b
     o
   end
 
   def build_NamedDefinition(o, name, parameters, body)
     parameters.each {|p| o.addParameters(build(p)) }
     b = f_build_body(body)
     o.body = b.current if b
     o.name = name
     o
   end
 
   # @param o [Model::NodeDefinition]
   # @param hosts [Array<Expression>] host matches
   # @param parent [Expression] parent node matcher
   # @param body [Object] see {#f_build_body}
   def build_NodeDefinition(o, hosts, parent, body)
     hosts.each {|h| o.addHost_matches(build(h)) }
     o.parent = build(parent) if parent # no nop here
     b = f_build_body(body)
     o.body = b.current if b
     o
   end
 
   def build_Parameter(o, name, expr)
     o.name = name
     o.value = build(expr) if expr # don't build a nil/nop
     o
   end
 
   def build_QualifiedReference(o, name)
     o.value = name.to_s.downcase
     o
   end
 
   def build_RelationshipExpression(o, op, a, b)
     o.operator = op
     build_BinaryExpression(o, a, b)
   end
 
   def build_ResourceExpression(o, type_name, bodies)
     o.type_name = build(type_name)
     bodies.each {|b| o.addBodies(build(b)) }
     o
   end
 
   def build_ResourceBody(o, title_expression, attribute_operations)
     o.title = build(title_expression)
     attribute_operations.each {|ao| o.addOperations(build(ao)) }
     o
   end
 
   def build_ResourceDefaultsExpression(o, type_ref, attribute_operations)
     o.type_ref = build(type_ref)
     attribute_operations.each {|ao| o.addOperations(build(ao)) }
     o
   end
 
   def build_SelectorExpression(o, left, *selectors)
     o.left_expr = to_ops(left)
     selectors.each {|s| o.addSelectors(build(s)) }
     o
   end
 
   def build_SelectorEntry(o, matching, value)
     o.matching_expr = build(matching)
     o.value_expr = build(value)
     o
   end
 
   def build_QueryExpression(o, expr)
     ops = to_ops(expr)
     o.expr = ops unless Puppet::Pops::Model::Factory.nop? ops
     o
   end
 
   def build_UnaryExpression(o, expr)
     ops = to_ops(expr)
     o.expr = ops unless Puppet::Pops::Model::Factory.nop? ops
     o
   end
 
   def build_Program(o, body, definitions)
     o.body = to_ops(body)
     # non containment
     definitions.each { |d| o.addDefinitions(d) }
     o
   end
 
   def build_QualifiedName(o, name)
     o.value = name.to_s
     o
   end
 
   # Puppet::Pops::Model::Factory helpers
   def f_build_unary(klazz, expr)
     Puppet::Pops::Model::Factory.new(build(klazz.new, expr))
   end
 
   def f_build_binary_op(klazz, op, left, right)
     Puppet::Pops::Model::Factory.new(build(klazz.new, op, left, right))
   end
 
   def f_build_binary(klazz, left, right)
     Puppet::Pops::Model::Factory.new(build(klazz.new, left, right))
   end
 
   def f_build_vararg(klazz, left, *arg)
     Puppet::Pops::Model::Factory.new(build(klazz.new, left, *arg))
   end
 
   def f_arithmetic(op, r)
     f_build_binary_op(Model::ArithmeticExpression, op, current, r)
   end
 
   def f_comparison(op, r)
     f_build_binary_op(Model::ComparisonExpression, op, current, r)
   end
 
   def f_match(op, r)
     f_build_binary_op(Model::MatchExpression, op, current, r)
   end
 
   # Operator helpers
   def in(r)     f_build_binary(Model::InExpression, current, r);          end
 
   def or(r)     f_build_binary(Model::OrExpression, current, r);          end
 
   def and(r)    f_build_binary(Model::AndExpression, current, r);         end
 
   def not();    f_build_unary(Model::NotExpression, self);                end
 
   def minus();  f_build_unary(Model::UnaryMinusExpression, self);         end
 
   def text();   f_build_unary(Model::TextExpression, self);               end
 
   def var();    f_build_unary(Model::VariableExpression, self);           end
 
   def [](*r);   f_build_vararg(Model::AccessExpression, current, *r);     end
 
   def dot r;    f_build_binary(Model::NamedAccessExpression, current, r); end
 
   def + r;      f_arithmetic(:+, r);                                      end
 
   def - r;      f_arithmetic(:-, r);                                      end
 
   def / r;      f_arithmetic(:/, r);                                      end
 
   def * r;      f_arithmetic(:*, r);                                      end
 
   def % r;      f_arithmetic(:%, r);                                      end
 
   def << r;     f_arithmetic(:<<, r);                                     end
 
   def >> r;     f_arithmetic(:>>, r);                                     end
 
   def < r;      f_comparison(:<, r);                                      end
 
   def <= r;     f_comparison(:<=, r);                                     end
 
   def > r;      f_comparison(:>, r);                                      end
 
   def >= r;     f_comparison(:>=, r);                                     end
 
   def == r;     f_comparison(:==, r);                                     end
 
   def ne r;     f_comparison(:'!=', r);                                   end
 
   def =~ r;     f_match(:'=~', r);                                        end
 
   def mne r;    f_match(:'!~', r);                                        end
 
   def paren();  f_build_unary(Model::ParenthesizedExpression, current);   end
 
   def relop op, r
     f_build_binary_op(Model::RelationshipExpression, op.to_sym, current, r)
   end
 
   def select *args
     Puppet::Pops::Model::Factory.new(build(Model::SelectorExpression, current, *args))
   end
 
   # For CaseExpression, setting the default for an already build CaseExpression
   def default r
     current.addOptions(Puppet::Pops::Model::Factory.WHEN(:default, r).current)
     self
   end
 
   def lambda=(lambda)
     current.lambda = lambda.current
     self
   end
 
   # Assignment =
   def set(r)
     f_build_binary_op(Model::AssignmentExpression, :'=', current, r)
   end
 
   # Assignment +=
   def plus_set(r)
     f_build_binary_op(Model::AssignmentExpression, :'+=', current, r)
   end
 
   # Assignment -=
   def minus_set(r)
     f_build_binary_op(Model::AssignmentExpression, :'-=', current, r)
   end
 
   def attributes(*args)
     args.each {|a| current.addAttributes(build(a)) }
     self
   end
 
   # Catch all delegation to current
   def method_missing(meth, *args, &block)
     if current.respond_to?(meth)
       current.send(meth, *args, &block)
     else
       super
     end
   end
 
   def respond_to?(meth, include_all=false)
     current.respond_to?(meth, include_all) || super
   end
 
   # Records the position (start -> end) and computes the resulting length.
   #
   def record_position(start_locatable, end_locatable)
     Puppet::Pops::Adapters::SourcePosAdapter.adapt(current) do |a|
       if start_locatable && end_locatable
         a.locatable = Puppet::Pops::Parser::Locatable::Range.new(start_locatable, end_locatable)
       else
         a.locatable = Puppet::Pops::Parser::Locatable::Lazy.new(start_locatable)
       end
 
 #      a.line   = start_pos.line
 #      a.offset = start_pos.offset
 #      a.pos    = start_pos.pos
 #      a.length = start_pos.length
 #      if(end_pos.offset && end_pos.length)
 #        a.length = end_pos.offset + end_pos.length - start_pos.offset
 #      end
     end
     self
   end
 
   # Records the origin file of an element
   # Does nothing if file is nil.
   #
   # @param file [String,nil] the file/path to the origin, may contain URI scheme of file: or some other URI scheme
   # @return [Factory] returns self
   #
   def record_origin(file)
     return self unless file
     Puppet::Pops::Adapters::OriginAdapter.adapt(current) do |a|
        a.origin = file
     end
     self
   end
 
   # @return [Puppet::Pops::Adapters::SourcePosAdapter] with location information
   def loc()
     Puppet::Pops::Adapters::SourcePosAdapter.adapt(current)
   end
 
   # Returns symbolic information about an expected share of a resource expression given the LHS of a resource expr.
   #
   # * `name { }` => `:resource`,  create a resource of the given type
   # * `Name { }` => ':defaults`, set defaults for the referenced type
   # * `Name[] { }` => `:override`, overrides instances referenced by LHS
   # * _any other_ => ':error', all other are considered illegal
   #
   def self.resource_shape(expr)
     expr = expr.current if expr.is_a?(Puppet::Pops::Model::Factory)
     case expr
     when Model::QualifiedName
       :resource
     when Model::QualifiedReference
       :defaults
     when Model::AccessExpression
       :override
     when 'class'
       :class
     else
       :error
     end
   end
   # Factory starting points
 
   def self.literal(o);                   new(o);                                                 end
 
   def self.minus(o);                     new(o).minus;                                           end
 
   def self.var(o);                       new(o).var;                                             end
 
   def self.block(*args);                 new(Model::BlockExpression, *args);                     end
 
   def self.string(*args);                new(Model::ConcatenatedString, *args);                  end
 
   def self.text(o);                      new(o).text;                                            end
 
   def self.IF(test_e,then_e,else_e);     new(Model::IfExpression, test_e, then_e, else_e);       end
 
   def self.UNLESS(test_e,then_e,else_e); new(Model::UnlessExpression, test_e, then_e, else_e);   end
 
   def self.CASE(test_e,*options);        new(Model::CaseExpression, test_e, *options);           end
 
   def self.WHEN(values_list, block);     new(Model::CaseOption, values_list, block);             end
 
   def self.MAP(match, value);            new(Model::SelectorEntry, match, value);                end
 
   def self.TYPE(name, super_name=nil);   new(Model::CreateTypeExpression, name, super_name);     end
 
   def self.ATTR(name, type_expr=nil);    new(Model::CreateAttributeExpression, name, type_expr); end
 
   def self.ENUM(*args);                  new(Model::CreateEnumExpression, *args);                end
 
   def self.KEY_ENTRY(key, val);          new(Model::KeyedEntry, key, val);                       end
 
   def self.HASH(entries);                new(Model::LiteralHash, *entries);                      end
 
   def self.LIST(entries);                new(Model::LiteralList, *entries);                      end
 
   def self.PARAM(name, expr=nil);        new(Model::Parameter, name, expr);                      end
 
   def self.NODE(hosts, parent, body);    new(Model::NodeDefinition, hosts, parent, body);        end
 
   # Creates a QualifiedName representation of o, unless o already represents a QualifiedName in which
   # case it is returned.
   #
   def self.fqn(o)
     o = o.current if o.is_a?(Puppet::Pops::Model::Factory)
     o = new(Model::QualifiedName, o) unless o.is_a? Model::QualifiedName
     o
   end
 
   # Creates a QualifiedName representation of o, unless o already represents a QualifiedName in which
   # case it is returned.
   #
   def self.fqr(o)
     o = o.current if o.is_a?(Puppet::Pops::Model::Factory)
     o = new(Model::QualifiedReference, o) unless o.is_a? Model::QualifiedReference
     o
   end
 
   def self.TEXT(expr)
     new(Model::TextExpression, new(expr).interpolate)
   end
 
   # TODO: This is the same a fqn factory method, don't know if callers to fqn and QNAME can live with the
   # same result or not yet - refactor into one method when decided.
   #
   def self.QNAME(name)
     new(Model::QualifiedName, name)
   end
 
   def self.NUMBER(name_or_numeric)
     if n_radix = Puppet::Pops::Utils.to_n_with_radix(name_or_numeric)
       val, radix = n_radix
       if val.is_a?(Float)
         new(Model::LiteralFloat, val)
       else
         new(Model::LiteralInteger, val, radix)
       end
     else
       # Bad number should already have been caught by lexer - this should never happen
       raise ArgumentError, "Internal Error, NUMBER token does not contain a valid number, #{name_or_numeric}"
     end
   end
 
   # Convert input string to either a qualified name, a LiteralInteger with radix, or a LiteralFloat
   #
   def self.QNAME_OR_NUMBER(name)
     if n_radix = Puppet::Pops::Utils.to_n_with_radix(name)
       val, radix = n_radix
       if val.is_a?(Float)
         new(Model::LiteralFloat, val)
       else
         new(Model::LiteralInteger, val, radix)
       end
     else
       new(Model::QualifiedName, name)
     end
   end
 
   def self.QREF(name)
     new(Model::QualifiedReference, name)
   end
 
   def self.VIRTUAL_QUERY(query_expr)
     new(Model::VirtualQuery, query_expr)
   end
 
   def self.EXPORTED_QUERY(query_expr)
     new(Model::ExportedQuery, query_expr)
   end
 
   def self.ATTRIBUTE_OP(name, op, expr)
     new(Model::AttributeOperation, name, op, expr)
   end
 
   def self.CALL_NAMED(name, rval_required, argument_list)
     unless name.kind_of?(Model::PopsObject)
       name = Puppet::Pops::Model::Factory.fqn(name) unless name.is_a?(Puppet::Pops::Model::Factory)
     end
     new(Model::CallNamedFunctionExpression, name, rval_required, *argument_list)
   end
 
   def self.CALL_METHOD(functor, argument_list)
     new(Model::CallMethodExpression, functor, true, nil, *argument_list)
   end
 
   def self.COLLECT(type_expr, query_expr, attribute_operations)
     new(Model::CollectExpression, Puppet::Pops::Model::Factory.fqr(type_expr), query_expr, attribute_operations)
   end
 
   def self.IMPORT(files)
     new(Model::ImportExpression, files)
   end
 
   def self.NAMED_ACCESS(type_name, bodies)
     new(Model::NamedAccessExpression, type_name, bodies)
   end
 
   def self.RESOURCE(type_name, bodies)
     new(Model::ResourceExpression, type_name, bodies)
   end
 
   def self.RESOURCE_DEFAULTS(type_name, attribute_operations)
     new(Model::ResourceDefaultsExpression, type_name, attribute_operations)
   end
 
   def self.RESOURCE_OVERRIDE(resource_ref, attribute_operations)
     new(Model::ResourceOverrideExpression, resource_ref, attribute_operations)
   end
 
   def self.RESOURCE_BODY(resource_title, attribute_operations)
     new(Model::ResourceBody, resource_title, attribute_operations)
   end
 
   def self.PROGRAM(body, definitions)
     new(Model::Program, body, definitions)
   end
 
   # Builds a BlockExpression if args size > 1, else the single expression/value in args
   def self.block_or_expression(*args)
     if args.size > 1
       new(Model::BlockExpression, *args)
     else
       new(args[0])
     end
   end
 
   def self.HOSTCLASS(name, parameters, parent, body)
     new(Model::HostClassDefinition, name, parameters, parent, body)
   end
 
   def self.DEFINITION(name, parameters, body)
     new(Model::ResourceTypeDefinition, name, parameters, body)
   end
 
   def self.LAMBDA(parameters, body)
     new(Model::LambdaExpression, parameters, body)
   end
 
   def self.nop? o
     o.nil? || o.is_a?(Puppet::Pops::Model::Nop)
   end
 
   # Transforms an array of expressions containing literal name expressions to calls if followed by an
   # expression, or expression list. Also transforms a "call" to `import` into an ImportExpression.
   #
   def self.transform_calls(expressions)
     expressions.reduce([]) do |memo, expr|
       expr = expr.current if expr.is_a?(Puppet::Pops::Model::Factory)
       name = memo[-1]
       if name.is_a? Model::QualifiedName
         if name.value() == 'import'
           memo[-1] = Puppet::Pops::Model::Factory.IMPORT(expr.is_a?(Array) ? expr : [expr])
         else
           memo[-1] = Puppet::Pops::Model::Factory.CALL_NAMED(name, false, expr.is_a?(Array) ? expr : [expr])
           if expr.is_a?(Model::CallNamedFunctionExpression)
             # Patch statement function call to expression style
             # This is needed because it is first parsed as a "statement" and the requirement changes as it becomes
             # an argument to the name to call transform above.
             expr.rval_required = true
           end
         end
       else
         memo << expr
         if expr.is_a?(Model::CallNamedFunctionExpression)
           # Patch rvalue expression function call to statement style.
           # This is not really required but done to be AST model compliant
           expr.rval_required = false
         end
       end
       memo
     end
 
   end
 
   # Building model equivalences of Ruby objects
   # Allows passing regular ruby objects to the factory to produce instructions
   # that when evaluated produce the same thing.
 
   def build_String(o)
     x = Model::LiteralString.new
     x.value = o;
     x
   end
 
   def build_NilClass(o)
     x = Model::Nop.new
     x
   end
 
   def build_TrueClass(o)
     x = Model::LiteralBoolean.new
     x.value = o
     x
   end
 
   def build_FalseClass(o)
     x = Model::LiteralBoolean.new
     x.value = o
     x
   end
 
   def build_Fixnum(o)
     x = Model::LiteralInteger.new
     x.value = o;
     x
   end
 
   def build_Float(o)
     x = Model::LiteralFloat.new
     x.value = o;
     x
   end
 
   def build_Regexp(o)
     x = Model::LiteralRegularExpression.new
     x.value = o;
     x
   end
 
   # If building a factory, simply unwrap the model oject contained in the factory.
   def build_Factory(o)
     o.current
   end
 
   # Creates a String literal, unless the symbol is one of the special :undef, or :default
   # which instead creates a LiterlUndef, or a LiteralDefault.
   def build_Symbol(o)
     case o
     when :undef
       Model::LiteralUndef.new
     when :default
       Model::LiteralDefault.new
     else
       build_String(o.to_s)
     end
   end
 
   # Creates a LiteralList instruction from an Array, where the entries are built.
   def build_Array(o)
     x = Model::LiteralList.new
     o.each { |v| x.addValues(build(v)) }
     x
   end
 
   # Create a LiteralHash instruction from a hash, where keys and values are built
   # The hash entries are added in sorted order based on key.to_s
   #
   def build_Hash(o)
     x = Model::LiteralHash.new
     (o.sort_by {|k,v| k.to_s}).each {|k,v| x.addEntries(build(Model::KeyedEntry.new, k, v)) }
     x
   end
 
   # @param rval_required [Boolean] if the call must produce a value
   def build_CallExpression(o, functor, rval_required, *args)
     o.functor_expr = to_ops(functor)
     o.rval_required = rval_required
     args.each {|x| o.addArguments(to_ops(x)) }
     o
   end
 
   #  # @param rval_required [Boolean] if the call must produce a value
   #  def build_CallNamedFunctionExpression(o, name, rval_required, *args)
   #    build_CallExpression(o, name, rval_required, *args)
   ##    o.functor_expr = build(name)
   ##    o.rval_required = rval_required
   ##    args.each {|x| o.addArguments(build(x)) }
   #    o
   #  end
 
   def build_CallMethodExpression(o, functor, rval_required, lambda, *args)
     build_CallExpression(o, functor, rval_required, *args)
     o.lambda = lambda
     o
   end
 
   def build_CaseExpression(o, test, *args)
     o.test = build(test)
     args.each {|opt| o.addOptions(build(opt)) }
     o
   end
 
   def build_CaseOption(o, value_list, then_expr)
     value_list = [value_list] unless value_list.is_a? Array
     value_list.each { |v| o.addValues(build(v)) }
     b = f_build_body(then_expr)
     o.then_expr = to_ops(b) if b
     o
   end
 
   # Build a Class by creating an instance of it, and then calling build on the created instance
   # with the given arguments
   def build_Class(o, *args)
     build(o.new(), *args)
   end
 
   def interpolate_Factory(o)
     interpolate(o.current)
   end
 
   def interpolate_LiteralInteger(o)
     # convert number to a variable
     self.class.new(o).var
   end
 
   def interpolate_Object(o)
     o
   end
 
   def interpolate_QualifiedName(o)
     self.class.new(o).var
   end
 
   # rewrite left expression to variable if it is name, number, and recurse if it is an access expression
   # this is for interpolation support in new lexer (${NAME}, ${NAME[}}, ${NUMBER}, ${NUMBER[]} - all
   # other expressions requires variables to be preceded with $
   #
   def interpolate_AccessExpression(o)
     if is_interop_rewriteable?(o.left_expr)
       o.left_expr = to_ops(self.class.new(o.left_expr).interpolate)
     end
     o
   end
 
   def interpolate_NamedAccessExpression(o)
     if is_interop_rewriteable?(o.left_expr)
         o.left_expr = to_ops(self.class.new(o.left_expr).interpolate)
     end
     o
   end
 
   # Rewrite method calls on the form ${x.each ...} to ${$x.each}
   def interpolate_CallMethodExpression(o)
     if is_interop_rewriteable?(o.functor_expr)
       o.functor_expr = to_ops(self.class.new(o.functor_expr).interpolate)
     end
     o
   end
 
   def is_interop_rewriteable?(o)
     case o
     when Model::AccessExpression, Model::QualifiedName,
       Model::NamedAccessExpression, Model::CallMethodExpression
       true
     when Model::LiteralInteger
       # Only decimal integers can represent variables, else it is a number
       o.radix == 10
     else
       false
     end
   end
 
   # Checks if the object is already a model object, or build it
   def to_ops(o, *args)
     case o
     when Model::PopsObject
       o
     when Puppet::Pops::Model::Factory
       o.current
     else
       build(o, *args)
     end
   end
 
   def self.concat(*args)
     new(args.map do |e|
       e = e.current if e.is_a?(self)
       case e
       when Model::LiteralString
         e.value
       when String
         e
       else
         raise ArgumentError, "can only concatenate strings, got #{e.class}"
       end
     end.join(''))
   end
 end
diff --git a/lib/puppet/pops/model/model_label_provider.rb b/lib/puppet/pops/model/model_label_provider.rb
index a55e69aaa..863a1f977 100644
--- a/lib/puppet/pops/model/model_label_provider.rb
+++ b/lib/puppet/pops/model/model_label_provider.rb
@@ -1,78 +1,77 @@
 # A provider of labels for model object, producing a human name for the model object.
 # As an example, if object is an ArithmeticExpression with operator +, `#a_an(o)` produces "a '+' Expression",
 # #the(o) produces "the + Expression", and #label produces "+ Expression".
 #
 class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
   def initialize
     @@label_visitor ||= Puppet::Pops::Visitor.new(self,"label",0,0)
   end
 
   # Produces a label for the given objects type/operator without article.
   def label o
    @@label_visitor.visit(o)
   end
 
   def label_Factory o                     ; label(o.current)                    end
   def label_Array o                       ; "Array Object"                      end
   def label_LiteralInteger o              ; "Literal Integer"                   end
   def label_LiteralFloat o                ; "Literal Float"                     end
   def label_ArithmeticExpression o        ; "'#{o.operator}' expression"        end
   def label_AccessExpression o            ; "'[]' expression"                   end
   def label_MatchExpression o             ; "'#{o.operator}' expression"        end
   def label_CollectExpression o           ; label(o.query)                      end
   def label_ExportedQuery o               ; "Exported Query"                    end
   def label_VirtualQuery o                ; "Virtual Query"                     end
   def label_QueryExpression o             ; "Collect Query"                     end
   def label_ComparisonExpression o        ; "'#{o.operator}' expression"        end
   def label_AndExpression o               ; "'and' expression"                  end
   def label_OrExpression o                ; "'or' expression"                   end
   def label_InExpression o                ; "'in' expression"                   end
   def label_ImportExpression o            ; "'import' expression"               end
-  def label_InstanceReferences o          ; "Resource Reference"                end
   def label_AssignmentExpression o        ; "'#{o.operator}' expression"        end
   def label_AttributeOperation o          ; "'#{o.operator}' expression"        end
   def label_LiteralList o                 ; "Array Expression"                  end
   def label_LiteralHash o                 ; "Hash Expression"                   end
   def label_KeyedEntry o                  ; "Hash Entry"                        end
   def label_LiteralBoolean o              ; "Boolean"                           end
   def label_LiteralString o               ; "String"                            end
   def label_LambdaExpression o            ; "Lambda"                            end
   def label_LiteralDefault o              ; "'default' expression"              end
   def label_LiteralUndef o                ; "'undef' expression"                end
   def label_LiteralRegularExpression o    ; "Regular Expression"                end
   def label_Nop o                         ; "Nop Expression"                    end
   def label_NamedAccessExpression o       ; "'.' expression"                    end
   def label_NilClass o                    ; "Nil Object"                        end
   def label_NotExpression o               ; "'not' expression"                  end
   def label_VariableExpression o          ; "Variable"                          end
   def label_TextExpression o              ; "Expression in Interpolated String" end
   def label_UnaryMinusExpression o        ; "Unary Minus"                       end
   def label_BlockExpression o             ; "Block Expression"                  end
   def label_ConcatenatedString o          ; "Double Quoted String"              end
   def label_HostClassDefinition o         ; "Host Class Definition"             end
   def label_NodeDefinition o              ; "Node Definition"                   end
   def label_ResourceTypeDefinition o      ; "'define' expression"               end
   def label_ResourceOverrideExpression o  ; "Resource Override"                 end
   def label_Parameter o                   ; "Parameter Definition"              end
   def label_ParenthesizedExpression o     ; "Parenthesized Expression"          end
   def label_IfExpression o                ; "'if' statement"                    end
   def label_UnlessExpression o            ; "'unless' Statement"                end
   def label_CallNamedFunctionExpression o ; "Function Call"                     end
   def label_CallMethodExpression o        ; "Method call"                       end
   def label_CaseExpression o              ; "'case' statement"                  end
   def label_CaseOption o                  ; "Case Option"                       end
   def label_RelationshipExpression o      ; "'#{o.operator}' expression"        end
   def label_ResourceBody o                ; "Resource Instance Definition"      end
   def label_ResourceDefaultsExpression o  ; "Resource Defaults Expression"      end
   def label_ResourceExpression o          ; "Resource Statement"                end
   def label_SelectorExpression o          ; "Selector Expression"               end
   def label_SelectorEntry o               ; "Selector Option"                   end
   def label_String o                      ; "String"                            end
   def label_Object o                      ; "Object"                            end
   def label_Hash o                        ; "Hash"                              end
   def label_QualifiedName o               ; "Name"                              end
   def label_QualifiedReference o          ; "Type Name"                         end
 
   # TODO: Could use the TypeFactory to infer and output more detailed type information instead of
   # just printing Object, Hash, Array, etc.
 end
diff --git a/lib/puppet/pops/model/model_tree_dumper.rb b/lib/puppet/pops/model/model_tree_dumper.rb
index 553021271..14ad52caf 100644
--- a/lib/puppet/pops/model/model_tree_dumper.rb
+++ b/lib/puppet/pops/model/model_tree_dumper.rb
@@ -1,358 +1,354 @@
 # Dumps a Pops::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
 #
 class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
   def dump_Array o
     o.collect {|e| do_dump(e) }
   end
 
   def dump_LiteralFloat o
     o.value.to_s
   end
 
   def dump_LiteralInteger o
     case o.radix
     when 10
       o.value.to_s
     when 8
       "0%o" % o.value
     when 16
       "0x%X" % o.value
     else
       "bad radix:" + o.value.to_s
     end
   end
 
   def dump_LiteralValue o
     o.value.to_s
   end
 
   def dump_Factory o
     do_dump(o.current)
   end
 
   def dump_ArithmeticExpression o
     [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
   end
 
   # x[y] prints as (slice x y)
   def dump_AccessExpression o
     if o.keys.size <= 1
       ["slice", do_dump(o.left_expr), do_dump(o.keys[0])]
     else
       ["slice", do_dump(o.left_expr), do_dump(o.keys)]
     end
   end
 
   def dump_MatchesExpression o
     [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
   end
 
   def dump_CollectExpression o
     result = ["collect", do_dump(o.type_expr), :indent, :break, do_dump(o.query), :indent]
     o.operations do |ao|
       result << :break << do_dump(ao)
     end
     result += [:dedent, :dedent ]
     result
   end
 
   def dump_ExportedQuery o
     result = ["<<| |>>"]
     result += dump_QueryExpression(o) unless is_nop?(o.expr)
     result
   end
 
   def dump_VirtualQuery o
     result = ["<| |>"]
     result += dump_QueryExpression(o) unless is_nop?(o.expr)
     result
   end
 
   def dump_QueryExpression o
     [do_dump(o.expr)]
   end
 
   def dump_ComparisonExpression o
     [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
   end
 
   def dump_AndExpression o
     ["&&", do_dump(o.left_expr), do_dump(o.right_expr)]
   end
 
   def dump_OrExpression o
     ["||", do_dump(o.left_expr), do_dump(o.right_expr)]
   end
 
   def dump_InExpression o
     ["in", do_dump(o.left_expr), do_dump(o.right_expr)]
   end
 
   def dump_ImportExpression o
     ["import"] + o.files.collect {|f| do_dump(f) }
   end
 
-  def dump_InstanceReferences o
-    ["instances", do_dump(o.type_name)] + o.names.collect {|n| do_dump(n) }
-  end
-
   def dump_AssignmentExpression o
     [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
   end
 
   # Produces (name => expr) or (name +> expr)
   def dump_AttributeOperation o
     [o.attribute_name, o.operator, do_dump(o.value_expr)]
   end
 
   def dump_LiteralList o
     ["[]"] + o.values.collect {|x| do_dump(x)}
   end
 
   def dump_LiteralHash o
     ["{}"] + o.entries.collect {|x| do_dump(x)}
   end
 
   def dump_KeyedEntry o
     [do_dump(o.key), do_dump(o.value)]
   end
 
   def dump_MatchExpression o
     [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
   end
 
   def dump_LiteralString o
     "'#{o.value}'"
   end
 
   def dump_LambdaExpression o
     result = ["lambda"]
     result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
     if o.body
       result << do_dump(o.body)
     else
       result << []
     end
     result
   end
 
   def dump_LiteralDefault o
     ":default"
   end
 
   def dump_LiteralUndef o
     ":undef"
   end
 
   def dump_LiteralRegularExpression o
     "/#{o.value.source}/"
   end
 
   def dump_Nop o
     ":nop"
   end
 
   def dump_NamedAccessExpression o
     [".", do_dump(o.left_expr), do_dump(o.right_expr)]
   end
 
   def dump_NilClass o
     "()"
   end
 
   def dump_NotExpression o
     ['!', dump(o.expr)]
   end
 
   def dump_VariableExpression o
     "$#{dump(o.expr)}"
   end
 
   # Interpolation (to string) shown as (str expr)
   def dump_TextExpression o
     ["str", do_dump(o.expr)]
   end
 
   def dump_UnaryMinusExpression o
     ['-', do_dump(o.expr)]
   end
 
   def dump_BlockExpression o
     ["block"] + o.statements.collect {|x| do_dump(x) }
   end
 
   # Interpolated strings are shown as (cat seg0 seg1 ... segN)
   def dump_ConcatenatedString o
     ["cat"] + o.segments.collect {|x| do_dump(x)}
   end
 
   def dump_HostClassDefinition o
     result = ["class", o.name]
     result << ["inherits", o.parent_class] if o.parent_class
     result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
     if o.body
       result << do_dump(o.body)
     else
       result << []
     end
     result
   end
 
   def dump_NodeDefinition o
     result = ["node"]
     result << ["matches"] + o.host_matches.collect {|m| do_dump(m) }
     result << ["parent", do_dump(o.parent)] if o.parent
     if o.body
       result << do_dump(o.body)
     else
       result << []
     end
     result
   end
 
   def dump_ResourceTypeDefinition o
     result = ["define", o.name]
     result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
     if o.body
       result << do_dump(o.body)
     else
       result << []
     end
     result
   end
 
   def dump_ResourceOverrideExpression o
     result = ["override", do_dump(o.resources), :indent]
     o.operations.each do |p|
       result << :break << do_dump(p)
     end
     result << :dedent
     result
   end
 
   # Produces parameters as name, or (= name value)
   def dump_Parameter o
     if o.value
       ["=", o.name, do_dump(o.value)]
     else
       o.name
     end
   end
 
   def dump_ParenthesizedExpression o
     do_dump(o.expr)
   end
 
   # Hides that Program exists in the output (only its body is shown), the definitions are just
   # references to contained classes, resource types, and nodes
   def dump_Program(o)
     dump(o.body)
   end
 
   def dump_IfExpression o
     result = ["if", do_dump(o.test), :indent, :break,
       ["then", :indent, do_dump(o.then_expr), :dedent]]
     result +=
     [:break,
       ["else", :indent, do_dump(o.else_expr), :dedent],
       :dedent] unless is_nop? o.else_expr
     result
   end
 
   def dump_UnlessExpression o
     result = ["unless", do_dump(o.test), :indent, :break,
       ["then", :indent, do_dump(o.then_expr), :dedent]]
     result +=
     [:break,
       ["else", :indent, do_dump(o.else_expr), :dedent],
       :dedent] unless is_nop? o.else_expr
     result
   end
 
   # Produces (invoke name args...) when not required to produce an rvalue, and
   # (call name args ... ) otherwise.
   #
   def dump_CallNamedFunctionExpression o
     result = [o.rval_required ? "call" : "invoke", do_dump(o.functor_expr)]
     o.arguments.collect {|a| result << do_dump(a) }
     result
   end
 
   #    def dump_CallNamedFunctionExpression o
   #      result = [o.rval_required ? "call" : "invoke", do_dump(o.functor_expr)]
   #      o.arguments.collect {|a| result << do_dump(a) }
   #      result
   #    end
 
   def dump_CallMethodExpression o
     result = [o.rval_required ? "call-method" : "invoke-method", do_dump(o.functor_expr)]
     o.arguments.collect {|a| result << do_dump(a) }
     result << do_dump(o.lambda) if o.lambda
     result
   end
 
   def dump_CaseExpression o
     result = ["case", do_dump(o.test), :indent]
     o.options.each do |s|
       result << :break << do_dump(s)
     end
     result << :dedent
   end
 
   def dump_CaseOption o
     result = ["when"]
     result << o.values.collect {|x| do_dump(x) }
     result << ["then", do_dump(o.then_expr) ]
     result
   end
 
   def dump_RelationshipExpression o
     [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
   end
 
   def dump_ResourceBody o
     result = [do_dump(o.title), :indent]
     o.operations.each do |p|
       result << :break << do_dump(p)
     end
     result << :dedent
     result
   end
 
   def dump_ResourceDefaultsExpression o
     result = ["resource-defaults", do_dump(o.type_ref), :indent]
     o.operations.each do |p|
       result << :break << do_dump(p)
     end
     result << :dedent
     result
   end
 
   def dump_ResourceExpression o
     form = o.form == :regular ? '' : o.form.to_s + "-"
     result = [form+"resource", do_dump(o.type_name), :indent]
     o.bodies.each do |b|
       result << :break << do_dump(b)
     end
     result << :dedent
     result
   end
 
   def dump_SelectorExpression o
     ["?", do_dump(o.left_expr)] + o.selectors.collect {|x| do_dump(x) }
   end
 
   def dump_SelectorEntry o
     [do_dump(o.matching_expr), "=>", do_dump(o.value_expr)]
   end
 
   def dump_Object o
     [o.class.to_s, o.to_s]
   end
 
   def is_nop? o
     o.nil? || o.is_a?(Puppet::Pops::Model::Nop)
   end
 end
diff --git a/lib/puppet/pops/validation/checker4_0.rb b/lib/puppet/pops/validation/checker4_0.rb
index f4f7833e9..8ea140f1f 100644
--- a/lib/puppet/pops/validation/checker4_0.rb
+++ b/lib/puppet/pops/validation/checker4_0.rb
@@ -1,566 +1,555 @@
 # A Validator validates a model.
 #
 # Validation is performed on each model element in isolation. Each method should validate the model element's state
 # but not validate its referenced/contained elements except to check their validity in their respective role.
 # The intent is to drive the validation with a tree iterator that visits all elements in a model.
 #
 #
 # TODO: Add validation of multiplicities - this is a general validation that can be checked for all
 #       Model objects via their metamodel. (I.e an extra call to multiplicity check in polymorph check).
 #       This is however mostly valuable when validating model to model transformations, and is therefore T.B.D
 #
 class Puppet::Pops::Validation::Checker4_0
   Issues = Puppet::Pops::Issues
   Model = Puppet::Pops::Model
 
   attr_reader :acceptor
   # Initializes the validator with a diagnostics producer. This object must respond to
   # `:will_accept?` and `:accept`.
   #
   def initialize(diagnostics_producer)
     @@check_visitor       ||= Puppet::Pops::Visitor.new(nil, "check", 0, 0)
     @@rvalue_visitor      ||= Puppet::Pops::Visitor.new(nil, "rvalue", 0, 0)
     @@hostname_visitor    ||= Puppet::Pops::Visitor.new(nil, "hostname", 1, 2)
     @@assignment_visitor  ||= Puppet::Pops::Visitor.new(nil, "assign", 0, 1)
     @@query_visitor       ||= Puppet::Pops::Visitor.new(nil, "query", 0, 0)
     @@top_visitor         ||= Puppet::Pops::Visitor.new(nil, "top", 1, 1)
     @@relation_visitor    ||= Puppet::Pops::Visitor.new(nil, "relation", 1, 1)
 
     @acceptor = diagnostics_producer
   end
 
   # Validates the entire model by visiting each model element and calling `check`.
   # The result is collected (or acted on immediately) by the configured diagnostic provider/acceptor
   # given when creating this Checker.
   #
   def validate(model)
     # tree iterate the model, and call check for each element
     check(model)
     model.eAllContents.each {|m| check(m) }
   end
 
   # Performs regular validity check
   def check(o)
     @@check_visitor.visit_this_0(self, o)
   end
 
   # Performs check if this is a vaid hostname expression
   # @param single_feature_name [String, nil] the name of a single valued hostname feature of the value's container. e.g. 'parent'
   def hostname(o, semantic, single_feature_name = nil)
     @@hostname_visitor.visit_this_2(self, o, semantic, single_feature_name)
   end
 
   # Performs check if this is valid as a query
   def query(o)
     @@query_visitor.visit_this_0(self, o)
   end
 
   # Performs check if this is valid as a relationship side
   def relation(o, container)
     @@relation_visitor.visit_this_1(self, o, container)
   end
 
   # Performs check if this is valid as a rvalue
   def rvalue(o)
     @@rvalue_visitor.visit_this_0(self, o)
   end
 
   # Performs check if this is valid as a container of a definition (class, define, node)
   def top(o, definition)
     @@top_visitor.visit_this_1(self, o, definition)
   end
 
   # Checks the LHS of an assignment (is it assignable?).
   # If args[0] is true, assignment via index is checked.
   #
   def assign(o, via_index = false)
     @@assignment_visitor.visit_this_1(self, o, via_index)
   end
 
   #---ASSIGNMENT CHECKS
 
   def assign_VariableExpression(o, via_index)
     varname_string = varname_to_s(o.expr)
     if varname_string =~ /^[0-9]+$/
       acceptor.accept(Issues::ILLEGAL_NUMERIC_ASSIGNMENT, o, :varname => varname_string)
     end
     # Can not assign to something in another namespace (i.e. a '::' in the name is not legal)
     if acceptor.will_accept? Issues::CROSS_SCOPE_ASSIGNMENT
       if varname_string =~ /::/
         acceptor.accept(Issues::CROSS_SCOPE_ASSIGNMENT, o, :name => varname_string)
       end
     end
     # TODO: Could scan for reassignment of the same variable if done earlier in the same container
     #       Or if assigning to a parameter (more work).
     # TODO: Investigate if there are invalid cases for += assignment
   end
 
   def assign_AccessExpression(o, via_index)
     # Are indexed assignments allowed at all ? $x[x] = '...'
     if acceptor.will_accept? Issues::ILLEGAL_INDEXED_ASSIGNMENT
       acceptor.accept(Issues::ILLEGAL_INDEXED_ASSIGNMENT, o)
     else
       # Then the left expression must be assignable-via-index
       assign(o.left_expr, true)
     end
   end
 
   def assign_Object(o, via_index)
     # Can not assign to anything else (differentiate if this is via index or not)
     # i.e. 10 = 'hello' vs. 10['x'] = 'hello' (the root is reported as being in error in both cases)
     #
     acceptor.accept(via_index ? Issues::ILLEGAL_ASSIGNMENT_VIA_INDEX : Issues::ILLEGAL_ASSIGNMENT, o)
   end
 
   #---CHECKS
 
   def check_Object(o)
   end
 
   def check_Factory(o)
     check(o.current)
   end
 
   def check_AccessExpression(o)
     # Check multiplicity of keys
     case o.left_expr
     when Model::QualifiedName
       # allows many keys, but the name should really be a QualifiedReference
       # acceptor.accept(Issues::DEPRECATED_NAME_AS_TYPE, o, :name => o.value)
       # OK in 4.x since a name evaluates to a String, and String[] is supported
       # Also allows many
     when Model::QualifiedReference
       # ok, allows many - this is a type / resource reference
 
     else
       # i.e. for any other expression that may produce an array or hash
 #      if o.keys.size > 1
 #        acceptor.accept(Issues::UNSUPPORTED_RANGE, o, :count => o.keys.size)
 #      end
       # Range is ok, multiple keys supported by many LHS types (checked at runtime)
       # TODO: can statically check key size for some types Name & String 1-2, Array 1,2, Hash 1-many, etc
       # (but is captured as RT error)
       if o.keys.size < 1
         acceptor.accept(Issues::MISSING_INDEX, o)
       end
     end
   end
 
   def check_AssignmentExpression(o)
     acceptor.accept(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator}) unless [:'=', :'+=', :'-='].include? o.operator
     assign(o.left_expr)
     rvalue(o.right_expr)
   end
 
   # Checks that operation with :+> is contained in a ResourceOverride or Collector.
   #
   # Parent of an AttributeOperation can be one of:
   # * CollectExpression
   # * ResourceOverride
   # * ResourceBody (ILLEGAL this is a regular resource expression)
   # * ResourceDefaults (ILLEGAL)
   #
   def check_AttributeOperation(o)
     if o.operator == :'+>'
       # Append operator use is constrained
       parent = o.eContainer
       unless parent.is_a?(Model::CollectExpression) || parent.is_a?(Model::ResourceOverrideExpression)
         acceptor.accept(Issues::ILLEGAL_ATTRIBUTE_APPEND, o, {:name=>o.attribute_name, :parent=>parent})
       end
     end
     rvalue(o.value_expr)
   end
 
   def check_BinaryExpression(o)
     rvalue(o.left_expr)
     rvalue(o.right_expr)
   end
 
   def check_CallNamedFunctionExpression(o)
     unless o.functor_expr.is_a? Model::QualifiedName
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.functor_expr, :feature => 'function name', :container => o)
     end
   end
 
   def check_MethodCallExpression(o)
     unless o.functor_expr.is_a? Model::QualifiedName
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.functor_expr, :feature => 'function name', :container => o)
     end
   end
 
   def check_CaseExpression(o)
+    rvalue(o.test)
     # There should only be one LiteralDefault case option value
     # TODO: Implement this check
   end
 
+  def check_CaseOption(o)
+    o.values.each { |v| rvalue(v) }
+  end
+
   def check_CollectExpression(o)
     unless o.type_expr.is_a? Model::QualifiedReference
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.type_expr, :feature=> 'type name', :container => o)
     end
 
     # If a collect expression tries to collect exported resources and storeconfigs is not on
     # then it will not work... This was checked in the parser previously. This is a runtime checking
     # thing as opposed to a language thing.
     if acceptor.will_accept?(Issues::RT_NO_STORECONFIGS) && o.query.is_a?(Model::ExportedQuery)
       acceptor.accept(Issues::RT_NO_STORECONFIGS, o)
     end
   end
 
   # Only used for function names, grammar should not be able to produce something faulty, but
   # check anyway if model is created programatically (it will fail in transformation to AST for sure).
   def check_NamedAccessExpression(o)
     name = o.right_expr
     unless name.is_a? Model::QualifiedName
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, name, :feature=> 'function name', :container => o.eContainer)
     end
   end
 
   # for 'class' and 'define'
   def check_NamedDefinition(o)
     top(o.eContainer, o)
     if (acceptor.will_accept? Issues::NAME_WITH_HYPHEN) && o.name.include?('-')
       acceptor.accept(Issues::NAME_WITH_HYPHEN, o, {:name => o.name})
     end
   end
 
   def check_ImportExpression(o)
     o.files.each do |f|
       unless f.is_a? Model::LiteralString
         acceptor.accept(Issues::ILLEGAL_EXPRESSION, f, :feature => 'file name', :container => o)
       end
     end
   end
 
-  def check_InstanceReference(o)
-    # TODO: Original warning is :
-    #       Puppet.warning addcontext("Deprecation notice:  Resource references should now be capitalized")
-    #       This model element is not used in the egrammar.
-    #       Either implement checks or deprecate the use of InstanceReference (the same is acheived by
-    #       transformation of AccessExpression when used where an Instance/Resource reference is allowed.
-    #
-  end
-
-  # Restrictions on hash key are because of the strange key comparisons/and merge rules in the AST evaluation
-  # (Even the allowed ones are handled in a strange way).
-  #
-  def transform_KeyedEntry(o)
-    case o.key
-    when Model::QualifiedName
-    when Model::LiteralString
-    when Model::LiteralNumber
-    when Model::ConcatenatedString
-    else
-      acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.key, :feature => 'hash key', :container => o.eContainer)
-    end
+  def check_KeyedEntry(o)
+    rvalue(o.key)
+    rvalue(o.value)
+    # In case there are additional things to forbid than non-rvalues
+    # acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.key, :feature => 'hash key', :container => o.eContainer)
   end
 
   # A Lambda is a Definition, but it may appear in other scopes that top scope (Which check_Definition asserts).
   #
   def check_LambdaExpression(o)
   end
 
   def check_NodeDefinition(o)
     # Check that hostnames are valid hostnames (or regular expressons)
     hostname(o.host_matches, o)
     hostname(o.parent, o, 'parent') unless o.parent.nil?
     top(o.eContainer, o)
   end
 
   # Asserts that value is a valid QualifiedName. No additional checking is made, objects that use
   # a QualifiedName as a name should check the validity - this since a QualifiedName is used as a BARE WORD
   # and then additional chars may be valid (like a hyphen).
   #
   def check_QualifiedName(o)
     # Is this a valid qualified name?
     if o.value !~ Puppet::Pops::Patterns::NAME
       acceptor.accept(Issues::ILLEGAL_NAME, o, {:name=>o.value})
     end
   end
 
   # Checks that the value is a valid UpperCaseWord (a CLASSREF), and optionally if it contains a hypen.
   # DOH: QualifiedReferences are created with LOWER CASE NAMES at parse time
   def check_QualifiedReference(o)
     # Is this a valid qualified name?
     if o.value !~ Puppet::Pops::Patterns::CLASSREF
       acceptor.accept(Issues::ILLEGAL_CLASSREF, o, {:name=>o.value})
     elsif (acceptor.will_accept? Issues::NAME_WITH_HYPHEN) && o.value.include?('-')
       acceptor.accept(Issues::NAME_WITH_HYPHEN, o, {:name => o.value})
     end
   end
 
   def check_QueryExpression(o)
     query(o.expr) if o.expr  # is optional
   end
 
   def relation_Object(o, rel_expr)
     acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature => o.eContainingFeature, :container => rel_expr})
   end
 
   def relation_AccessExpression(o, rel_expr); end
 
   def relation_CollectExpression(o, rel_expr); end
 
   def relation_VariableExpression(o, rel_expr); end
 
   def relation_LiteralString(o, rel_expr); end
 
   def relation_ConcatenatedStringExpression(o, rel_expr); end
 
   def relation_SelectorExpression(o, rel_expr); end
 
   def relation_CaseExpression(o, rel_expr); end
 
   def relation_ResourceExpression(o, rel_expr); end
 
   def relation_RelationshipExpression(o, rel_expr); end
 
   def check_Parameter(o)
     if o.name =~ /^[0-9]+$/
       acceptor.accept(Issues::ILLEGAL_NUMERIC_PARAMETER, o, :name => o.name)
     end
   end
 
   #relationship_side: resource
   #  | resourceref
   #  | collection
   #  | variable
   #  | quotedtext
   #  | selector
   #  | casestatement
   #  | hasharrayaccesses
 
   def check_RelationshipExpression(o)
     relation(o.left_expr, o)
     relation(o.right_expr, o)
   end
 
   def check_ResourceExpression(o)
     # A resource expression must have a lower case NAME as its type e.g. 'file { ... }'
     unless o.type_name.is_a? Model::QualifiedName
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.type_name, :feature => 'resource type', :container => o)
     end
 
     # This is a runtime check - the model is valid, but will have runtime issues when evaluated
     # and storeconfigs is not set.
     if acceptor.will_accept?(Issues::RT_NO_STORECONFIGS) && o.exported
       acceptor.accept(Issues::RT_NO_STORECONFIGS_EXPORT, o)
     end
   end
 
   def check_ResourceDefaultsExpression(o)
     if o.form && o.form != :regular
       acceptor.accept(Issues::NOT_VIRTUALIZEABLE, o)
     end
   end
 
   # Transformation of SelectorExpression is limited to certain types of expressions.
   # This is probably due to constraints in the old grammar rather than any real concerns.
   def select_SelectorExpression(o)
     case o.left_expr
     when Model::CallNamedFunctionExpression
     when Model::AccessExpression
     when Model::VariableExpression
     when Model::ConcatenatedString
     else
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.left_expr, :feature => 'left operand', :container => o)
     end
   end
 
   def check_UnaryExpression(o)
     rvalue(o.expr)
   end
 
   def check_UnlessExpression(o)
     # TODO: Unless may not have an elsif
     # TODO: 3.x unless may not have an else
   end
 
   def check_VariableExpression(o)
     # The expression must be a qualified name
     if !o.expr.is_a? Model::QualifiedName
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, :feature => 'name', :container => o)
     else
       # Note, that if it later becomes illegal with hyphen in any name, this special check
       # can be skipped in favor of the check in QualifiedName, which is now not done if contained in
       # a VariableExpression
       name = o.expr.value
       if (acceptor.will_accept? Issues::VAR_WITH_HYPHEN) && name.include?('-')
         acceptor.accept(Issues::VAR_WITH_HYPHEN, o, {:name => name})
       end
     end
   end
 
   #--- HOSTNAME CHECKS
 
   # Transforms Array of host matching expressions into a (Ruby) array of AST::HostName
   def hostname_Array(o, semantic, single_feature_name)
     if single_feature_name
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature=>single_feature_name, :container=>semantic})
     end
     o.each {|x| hostname(x, semantic, false) }
   end
 
   def hostname_String(o, semantic, single_feature_name)
     # The 3.x checker only checks for illegal characters - if matching /[^-\w.]/ the name is invalid,
     # but this allows pathological names like "a..b......c", "----"
     # TODO: Investigate if more illegal hostnames should be flagged.
     #
     if o =~ Puppet::Pops::Patterns::ILLEGAL_HOSTNAME_CHARS
       acceptor.accept(Issues::ILLEGAL_HOSTNAME_CHARS, semantic, :hostname => o)
     end
   end
 
   def hostname_LiteralValue(o, semantic, single_feature_name)
     hostname_String(o.value.to_s, o, single_feature_name)
   end
 
   def hostname_ConcatenatedString(o, semantic, single_feature_name)
     # Puppet 3.1. only accepts a concatenated string without interpolated expressions
     if the_expr = o.segments.index {|s| s.is_a?(Model::TextExpression) }
       acceptor.accept(Issues::ILLEGAL_HOSTNAME_INTERPOLATION, o.segments[the_expr].expr)
     elsif o.segments.size() != 1
       # corner case, bad model, concatenation of several plain strings
       acceptor.accept(Issues::ILLEGAL_HOSTNAME_INTERPOLATION, o)
     else
       # corner case, may be ok, but lexer may have replaced with plain string, this is
       # here if it does not
       hostname_String(o.segments[0], o.segments[0], false)
     end
   end
 
   def hostname_QualifiedName(o, semantic, single_feature_name)
     hostname_String(o.value.to_s, o, single_feature_name)
   end
 
   def hostname_QualifiedReference(o, semantic, single_feature_name)
     hostname_String(o.value.to_s, o, single_feature_name)
   end
 
   def hostname_LiteralNumber(o, semantic, single_feature_name)
     # always ok
   end
 
   def hostname_LiteralDefault(o, semantic, single_feature_name)
     # always ok
   end
 
   def hostname_LiteralRegularExpression(o, semantic, single_feature_name)
     # always ok
   end
 
   def hostname_Object(o, semantic, single_feature_name)
     acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature=> single_feature_name || 'hostname', :container=>semantic})
   end
 
   #---QUERY CHECKS
 
   # Anything not explicitly allowed is flagged as error.
   def query_Object(o)
     acceptor.accept(Issues::ILLEGAL_QUERY_EXPRESSION, o)
   end
 
   # Puppet AST only allows == and !=
   #
   def query_ComparisonExpression(o)
     acceptor.accept(Issues::ILLEGAL_QUERY_EXPRESSION, o) unless [:'==', :'!='].include? o.operator
   end
 
   # Allows AND, OR, and checks if left/right are allowed in query.
   def query_BooleanExpression(o)
     query o.left_expr
     query o.right_expr
   end
 
   def query_ParenthesizedExpression(o)
     query(o.expr)
   end
 
   def query_VariableExpression(o); end
 
   def query_QualifiedName(o); end
 
   def query_LiteralNumber(o); end
 
   def query_LiteralString(o); end
 
   def query_LiteralBoolean(o); end
 
   #---RVALUE CHECKS
 
   # By default, all expressions are reported as being rvalues
   # Implement specific rvalue checks for those that are not.
   #
   def rvalue_Expression(o); end
 
   def rvalue_ImportExpression(o)          ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_BlockExpression(o)           ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
 #  def rvalue_CaseExpression(o)            ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
 #  def rvalue_IfExpression(o)              ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
 #  def rvalue_UnlessExpression(o)          ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_ResourceExpression(o)        ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_ResourceDefaultsExpression(o); acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_ResourceOverrideExpression(o); acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_CollectExpression(o)         ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_Definition(o)                ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_NodeDefinition(o)            ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_UnaryExpression(o)           ; rvalue o.expr                 ; end
 
   #---TOP CHECK
 
   def top_NilClass(o, definition)
     # ok, reached the top, no more parents
   end
 
   def top_Object(o, definition)
     # fail, reached a container that is not top level
     acceptor.accept(Issues::NOT_TOP_LEVEL, definition)
   end
 
   def top_BlockExpression(o, definition)
     # ok, if this is a block representing the body of a class, or is top level
     top o.eContainer, definition
   end
 
   def top_HostClassDefinition(o, definition)
     # ok, stop scanning parents
   end
 
   def top_Program(o, definition)
     # ok
   end
 
   # A LambdaExpression is a BlockExpression, and this method is needed to prevent the polymorph method for BlockExpression
   # to accept a lambda.
   # A lambda can not iteratively create classes, nodes or defines as the lambda does not have a closure.
   #
   def top_LambdaExpression(o, definition)
     # fail, stop scanning parents
     acceptor.accept(Issues::NOT_TOP_LEVEL, definition)
   end
 
   #--- NON POLYMORPH, NON CHECKING CODE
 
   # Produces string part of something named, or nil if not a QualifiedName or QualifiedReference
   #
   def varname_to_s(o)
     case o
     when Model::QualifiedName
       o.value
     when Model::QualifiedReference
       o.value
     else
       nil
     end
   end
 end