diff --git a/lib/puppet/pops/evaluator/evaluator_impl.rb b/lib/puppet/pops/evaluator/evaluator_impl.rb
index 7a9645c8a..275e93264 100644
--- a/lib/puppet/pops/evaluator/evaluator_impl.rb
+++ b/lib/puppet/pops/evaluator/evaluator_impl.rb
@@ -1,1214 +1,1214 @@
 require 'rgen/ecore/ecore'
 require 'puppet/pops/evaluator/compare_operator'
 require 'puppet/pops/evaluator/relationship_operator'
 require 'puppet/pops/evaluator/access_operator'
 require 'puppet/pops/evaluator/closure'
 require 'puppet/pops/evaluator/external_syntax_support'
 
 # This implementation of {Puppet::Pops::Evaluator} performs evaluation using the puppet 3.x runtime system
 # in a manner largely compatible with Puppet 3.x, but adds new features and introduces constraints.
 #
 # The evaluation uses _polymorphic dispatch_ which works by dispatching to the first found method named after
 # the class or one of its super-classes. The EvaluatorImpl itself mainly deals with evaluation (it currently
 # also handles assignment), and it uses a delegation pattern to more specialized handlers of some operators
 # that in turn use polymorphic dispatch; this to not clutter EvaluatorImpl with too much responsibility).
 #
 # Since a pattern is used, only the main entry points are fully documented. The parameters _o_ and _scope_ are
 # the same in all the polymorphic methods, (the type of the parameter _o_ is reflected in the method's name;
 # either the actual class, or one of its super classes). The _scope_ parameter is always the scope in which
 # the evaluation takes place. If nothing else is mentioned, the return is always the result of evaluation.
 #
 # See {Puppet::Pops::Visitable} and {Puppet::Pops::Visitor} for more information about
 # polymorphic calling.
 #
 class Puppet::Pops::Evaluator::EvaluatorImpl
   include Puppet::Pops::Utils
 
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
   include Puppet::Pops::Evaluator::Runtime3Support
   include Puppet::Pops::Evaluator::ExternalSyntaxSupport
 
   # This constant is not defined as Float::INFINITY in Ruby 1.8.7 (but is available in later version
   # Refactor when support is dropped for Ruby 1.8.7.
   #
   INFINITY = 1.0 / 0.0
   EMPTY_STRING = ''.freeze
   COMMA_SEPARATOR = ', '.freeze
 
   # Reference to Issues name space makes it easier to refer to issues
   # (Issues are shared with the validator).
   #
   Issues = Puppet::Pops::Issues
 
   def initialize
     @@eval_visitor     ||= Puppet::Pops::Visitor.new(self, "eval", 1, 1)
     @@lvalue_visitor   ||= Puppet::Pops::Visitor.new(self, "lvalue", 1, 1)
     @@assign_visitor   ||= Puppet::Pops::Visitor.new(self, "assign", 3, 3)
     @@string_visitor   ||= Puppet::Pops::Visitor.new(self, "string", 1, 1)
 
     @@type_calculator  ||= Puppet::Pops::Types::TypeCalculator.new()
     @@type_parser      ||= Puppet::Pops::Types::TypeParser.new()
 
     @@compare_operator     ||= Puppet::Pops::Evaluator::CompareOperator.new()
     @@relationship_operator ||= Puppet::Pops::Evaluator::RelationshipOperator.new()
 
     # Use null migration checker unless given in context
-    @migration_checker ||= (Puppet.lookup(:migration_checker) { Puppet::Pops::Migration::MigrationChecker.new() })
+    @migration_checker = (Puppet.lookup(:migration_checker) { Puppet::Pops::Migration::MigrationChecker.new() })
   end
 
   # @api private
   def type_calculator
     @@type_calculator
   end
 
   # Evaluates the given _target_ object in the given scope.
   #
   # @overload evaluate(target, scope)
   # @param target [Object] evaluation target - see methods on the pattern assign_TYPE for actual supported types.
   # @param scope [Object] the runtime specific scope class where evaluation should take place
   # @return [Object] the result of the evaluation
   #
   # @api public
   #
   def evaluate(target, scope)
     begin
       @@eval_visitor.visit_this_1(self, target, scope)
 
     rescue Puppet::Pops::SemanticError => e
       # A raised issue may not know the semantic target, use errors call stack, but fill in the 
       # rest from a supplied semantic object, or the target instruction if there is not semantic
       # object.
       #
       fail(e.issue, e.semantic || target, e.options, e)
 
     rescue Puppet::PreformattedError => e
       # Already formatted with location information, and with the wanted call stack.
       # Note this is currently a specialized ParseError, so rescue-order is important
       #
       raise e
 
     rescue Puppet::ParseError => e
       # ParseError may be raised in ruby code without knowing the location
       # in puppet code.
       # Accept a ParseError that has file or line information available
       # as an error that should be used verbatim. (Tests typically run without
       # setting a file name).
       # ParseError can supply an original - it is impossible to determine which
       # call stack that should be propagated, using the ParseError's backtrace.
       #
       if e.file || e.line
         raise e
       else
         # Since it had no location information, treat it as user intended a general purpose
         # error. Pass on its call stack.
         fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e)
       end
 
 
     rescue Puppet::Error => e
       # PuppetError has the ability to wrap an exception, if so, use the wrapped exception's
       # call stack instead
       fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e.original || e)
 
     rescue StandardError => e
       # All other errors, use its message and call stack
       fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e)
     end
   end
 
   # Assigns the given _value_ to the given _target_. The additional argument _o_ is the instruction that
   # produced the target/value tuple and it is used to set the origin of the result.
   #
   # @param target [Object] assignment target - see methods on the pattern assign_TYPE for actual supported types.
   # @param value [Object] the value to assign to `target`
   # @param o [Puppet::Pops::Model::PopsObject] originating instruction
   # @param scope [Object] the runtime specific scope where evaluation should take place
   #
   # @api private
   #
   def assign(target, value, o, scope)
     @@assign_visitor.visit_this_3(self, target, value, o, scope)
   end
 
   # Computes a value that can be used as the LHS in an assignment.
   # @param o [Object] the expression to evaluate as a left (assignable) entity
   # @param scope [Object] the runtime specific scope where evaluation should take place
   #
   # @api private
   #
   def lvalue(o, scope)
     @@lvalue_visitor.visit_this_1(self, o, scope)
   end
 
   # Produces a String representation of the given object _o_ as used in interpolation.
   # @param o [Object] the expression of which a string representation is wanted
   # @param scope [Object] the runtime specific scope where evaluation should take place
   #
   # @api public
   #
   def string(o, scope)
     @@string_visitor.visit_this_1(self, o, scope)
   end
 
   # Evaluate a BlockExpression in a new scope with variables bound to the
   # given values.
   #
   # @param scope [Puppet::Parser::Scope] the parent scope
   # @param variable_bindings [Hash{String => Object}] the variable names and values to bind (names are keys, bound values are values)
   # @param block [Puppet::Pops::Model::BlockExpression] the sequence of expressions to evaluate in the new scope
   #
   # @api private
   #
   def evaluate_block_with_bindings(scope, variable_bindings, block_expr)
     with_guarded_scope(scope) do
       # change to create local scope_from - cannot give it file and line -
       # that is the place of the call, not "here"
       create_local_scope_from(variable_bindings, scope)
       evaluate(block_expr, scope)
     end
   end
 
   protected
 
   def lvalue_VariableExpression(o, scope)
     # evaluate the name
     evaluate(o.expr, scope)
   end
 
   # Catches all illegal lvalues
   #
   def lvalue_Object(o, scope)
     fail(Issues::ILLEGAL_ASSIGNMENT, o)
   end
 
   # Assign value to named variable.
   # The '$' sign is never part of the name.
   # @example In Puppet DSL
   #   $name = value
   # @param name [String] name of variable without $
   # @param value [Object] value to assign to the variable
   # @param o [Puppet::Pops::Model::PopsObject] originating instruction
   # @param scope [Object] the runtime specific scope where evaluation should take place
   # @return [value<Object>]
   #
   def assign_String(name, value, o, scope)
     if name =~ /::/
       fail(Issues::CROSS_SCOPE_ASSIGNMENT, o.left_expr, {:name => name})
     end
     set_variable(name, value, o, scope)
     value
   end
 
   def assign_Numeric(n, value, o, scope)
     fail(Issues::ILLEGAL_NUMERIC_ASSIGNMENT, o.left_expr, {:varname => n.to_s})
   end
 
   # Catches all illegal assignment (e.g. 1 = 2, {'a'=>1} = 2, etc)
   #
   def assign_Object(name, value, o, scope)
     fail(Issues::ILLEGAL_ASSIGNMENT, o)
   end
 
   def eval_Factory(o, scope)
     evaluate(o.current, scope)
   end
 
   # Evaluates any object not evaluated to something else to itself.
   def eval_Object o, scope
     o
   end
 
   # Allows nil to be used as a Nop, Evaluates to nil
   def eval_NilClass(o, scope)
     nil
   end
 
   # Evaluates Nop to nil.
   def eval_Nop(o, scope)
     nil
   end
 
   # Captures all LiteralValues not handled elsewhere.
   #
   def eval_LiteralValue(o, scope)
     o.value
   end
 
   # Reserved Words fail to evaluate
   #
   def eval_ReservedWord(o, scope)
     fail(Puppet::Pops::Issues::RESERVED_WORD, o, {:word => o.word})
   end
 
   def eval_LiteralDefault(o, scope)
     :default
   end
 
   def eval_LiteralUndef(o, scope)
     nil
   end
 
   # A QualifiedReference (i.e. a  capitalized qualified name such as Foo, or Foo::Bar) evaluates to a PType
   #
   def eval_QualifiedReference(o, scope)
     @@type_parser.interpret(o)
   end
 
   def eval_NotExpression(o, scope)
     ! is_true?(evaluate(o.expr, scope), o.expr)
   end
 
   def eval_UnaryMinusExpression(o, scope)
     - coerce_numeric(evaluate(o.expr, scope), o, scope)
   end
 
   def eval_UnfoldExpression(o, scope)
     candidate = evaluate(o.expr, scope)
     case candidate
     when nil
       []
     when Array
       candidate
     when Hash
       candidate.to_a
     else
       # turns anything else into an array (so result can be unfolded)
       [candidate]
     end
   end
 
   # Abstract evaluation, returns array [left, right] with the evaluated result of left_expr and
   # right_expr
   # @return <Array<Object, Object>> array with result of evaluating left and right expressions
   #
   def eval_BinaryExpression o, scope
     [ evaluate(o.left_expr, scope), evaluate(o.right_expr, scope) ]
   end
 
   # Evaluates assignment with operators =, +=, -= and
   #
   # @example Puppet DSL
   #   $a = 1
   #   $a += 1
   #   $a -= 1
   #
   def eval_AssignmentExpression(o, scope)
     name = lvalue(o.left_expr, scope)
     value = evaluate(o.right_expr, scope)
 
     if o.operator == :'='
       assign(name, value, o, scope)
     else
       fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
     end
     value
   end
 
   ARITHMETIC_OPERATORS = [:'+', :'-', :'*', :'/', :'%', :'<<', :'>>']
   COLLECTION_OPERATORS = [:'+', :'-', :'<<']
 
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
   def eval_ArithmeticExpression(o, scope)
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
 
     begin
       result = calculate(left, right, o.operator, o.left_expr, o.right_expr, scope)
     rescue ArgumentError => e
       fail(Issues::RUNTIME_ERROR, o, {:detail => e.message}, e)
     end
     result
   end
 
 
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
   def calculate(left, right, operator, left_o, right_o, scope)
     unless ARITHMETIC_OPERATORS.include?(operator)
       fail(Issues::UNSUPPORTED_OPERATOR, left_o.eContainer, {:operator => o.operator})
     end
 
     if (left.is_a?(Array) || left.is_a?(Hash)) && COLLECTION_OPERATORS.include?(operator)
       # Handle operation on collections
       case operator
       when :'+'
         concatenate(left, right)
       when :'-'
         delete(left, right)
       when :'<<'
         unless left.is_a?(Array)
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
         end
         left + [right]
       end
     else
       # Handle operation on numeric
       left = coerce_numeric(left, left_o, scope)
       right = coerce_numeric(right, right_o, scope)
       begin
         if operator == :'%' && (left.is_a?(Float) || right.is_a?(Float))
           # Deny users the fun of seeing severe rounding errors and confusing results
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
         end
         result = left.send(operator, right)
       rescue NoMethodError => e
         fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
       rescue ZeroDivisionError => e
         fail(Issues::DIV_BY_ZERO, right_o)
       end
       if result == INFINITY || result == -INFINITY
         fail(Issues::RESULT_IS_INFINITY, left_o, {:operator => operator})
       end
       result
     end
   end
 
   def eval_EppExpression(o, scope)
     scope["@epp"] = []
     evaluate(o.body, scope)
     result = scope["@epp"].join
     result
   end
 
   def eval_RenderStringExpression(o, scope)
     scope["@epp"] << o.value.dup
     nil
   end
 
   def eval_RenderExpression(o, scope)
     scope["@epp"] << string(evaluate(o.expr, scope), scope)
     nil
   end
 
   # Evaluates Puppet DSL ->, ~>, <-, and <~
   def eval_RelationshipExpression(o, scope)
     # First level evaluation, reduction to basic data types or puppet types, the relationship operator then translates this
     # to the final set of references (turning strings into references, which can not naturally be done by the main evaluator since
     # all strings should not be turned into references.
     #
     real = eval_BinaryExpression(o, scope)
     @@relationship_operator.evaluate(real, o, scope)
   end
 
   # Evaluates x[key, key, ...]
   #
   def eval_AccessExpression(o, scope)
     left = evaluate(o.left_expr, scope)
     keys = o.keys.nil? ? [] : o.keys.collect {|key| evaluate(key, scope) }
     Puppet::Pops::Evaluator::AccessOperator.new(o).access(left, scope, *keys)
   end
 
   # Evaluates <, <=, >, >=, and ==
   #
   def eval_ComparisonExpression o, scope
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
 
     @migration_checker.report_uc_bareword_type(left, o.left_expr)
     @migration_checker.report_uc_bareword_type(right, o.right_expr)
 
     begin
     # Left is a type
     if left.is_a?(Puppet::Pops::Types::PAnyType)
       case o.operator
       when :'=='
         @migration_checker.report_equality_type_mismatch(left, right, o)
         @@type_calculator.equals(left,right)
 
       when :'!='
         @migration_checker.report_equality_type_mismatch(left, right, o)
         !@@type_calculator.equals(left,right)
 
       when :'<'
         # left can be assigned to right, but they are not equal
         @@type_calculator.assignable?(right, left) && ! @@type_calculator.equals(left,right)
       when :'<='
         # left can be assigned to right
         @@type_calculator.assignable?(right, left)
       when :'>'
         # right can be assigned to left, but they are not equal
         @@type_calculator.assignable?(left,right) && ! @@type_calculator.equals(left,right)
       when :'>='
         # right can be assigned to left
         @@type_calculator.assignable?(left, right)
       else
         fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
       end
     else
       case o.operator
       when :'=='
         @migration_checker.report_equality_type_mismatch(left, right, o)
         @@compare_operator.equals(left,right)
       when :'!='
         @migration_checker.report_equality_type_mismatch(left, right, o)
         ! @@compare_operator.equals(left,right)
       when :'<'
         @@compare_operator.compare(left,right) < 0
       when :'<='
         @@compare_operator.compare(left,right) <= 0
       when :'>'
         @@compare_operator.compare(left,right) > 0
       when :'>='
         @@compare_operator.compare(left,right) >= 0
       else
         fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
       end
     end
     rescue ArgumentError => e
       fail(Issues::COMPARISON_NOT_POSSIBLE, o, {
         :operator => o.operator,
         :left_value => left,
         :right_value => right,
         :detail => e.message}, e)
     end
   end
 
   # Evaluates matching expressions with type, string or regexp rhs expression.
   # If RHS is a type, the =~ matches compatible (instance? of) type.
   #
   # @example
   #   x =~ /abc.*/
   # @example
   #   x =~ "abc.*/"
   # @example
   #   y = "abc"
   #   x =~ "${y}.*"
   # @example
   #   [1,2,3] =~ Array[Integer[1,10]]
   #
   # Note that a string is not instance? of Regexp, only Regular expressions are.
   # The Pattern type should instead be used as it is specified as subtype of String.
   #
   # @return [Boolean] if a match was made or not. Also sets $0..$n to matchdata in current scope.
   #
   def eval_MatchExpression o, scope
     left = evaluate(o.left_expr, scope)
     pattern = evaluate(o.right_expr, scope)
 
     @migration_checker.report_uc_bareword_type(left, o.left_expr)
 
     # matches RHS types as instance of for all types except a parameterized Regexp[R]
     if pattern.is_a?(Puppet::Pops::Types::PAnyType)
       # evaluate as instance? of type check
       matched = @@type_calculator.instance?(pattern, left)
       # convert match result to Boolean true, or false
       return o.operator == :'=~' ? !!matched : !matched
     end
 
     begin
       pattern = Regexp.new(pattern) unless pattern.is_a?(Regexp)
     rescue StandardError => e
       fail(Issues::MATCH_NOT_REGEXP, o.right_expr, {:detail => e.message}, e)
     end
     unless left.is_a?(String)
       fail(Issues::MATCH_NOT_STRING, o.left_expr, {:left_value => left})
     end
 
     matched = pattern.match(left) # nil, or MatchData
     set_match_data(matched,scope) # creates ephemeral
 
     # convert match result to Boolean true, or false
     o.operator == :'=~' ? !!matched : !matched
   end
 
   # Evaluates Puppet DSL `in` expression
   #
   def eval_InExpression o, scope
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
     @migration_checker.report_uc_bareword_type(left, o.left_expr)
     @migration_checker.report_in_expression(o)
     @@compare_operator.include?(right, left, scope)
   end
 
   # @example
   #   $a and $b
   # b is only evaluated if a is true
   #
   def eval_AndExpression o, scope
     is_true?(evaluate(o.left_expr, scope), o.left_expr) ? is_true?(evaluate(o.right_expr, scope), o.right_expr) : false
   end
 
   # @example
   #   a or b
   # b is only evaluated if a is false
   #
   def eval_OrExpression o, scope
     is_true?(evaluate(o.left_expr, scope), o.left_expr) ? true : is_true?(evaluate(o.right_expr, scope), o.right_expr)
   end
 
   # Evaluates each entry of the literal list and creates a new Array
   # Supports unfolding of entries
   # @return [Array] with the evaluated content
   #
   def eval_LiteralList o, scope
     unfold([], o.values, scope)
   end
 
   # Evaluates each entry of the literal hash and creates a new Hash.
   # @return [Hash] with the evaluated content
   #
   def eval_LiteralHash o, scope
     # optimized
     o.entries.reduce({}) {|h,entry| h[evaluate(entry.key, scope)] = evaluate(entry.value, scope); h }
   end
 
   # Evaluates all statements and produces the last evaluated value
   #
   def eval_BlockExpression o, scope
     r = nil
     o.statements.each {|s| r = evaluate(s, scope)}
     r
   end
 
   # Performs optimized search over case option values, lazily evaluating each
   # until there is a match. If no match is found, the case expression's default expression
   # is evaluated (it may be nil or Nop if there is no default, thus producing nil).
   # If an option matches, the result of evaluating that option is returned.
   # @return [Object, nil] what a matched option returns, or nil if nothing matched.
   #
   def eval_CaseExpression(o, scope)
     # memo scope level before evaluating test - don't want a match in the case test to leak $n match vars
     # to expressions after the case expression.
     #
     with_guarded_scope(scope) do
       test = evaluate(o.test, scope)
       @migration_checker.report_uc_bareword_type(test, o.test)
 
       result = nil
       the_default = nil
       if o.options.find do |co|
         # the first case option that matches
         if co.values.find do |c|
           case c
           when Puppet::Pops::Model::LiteralDefault
             the_default = co.then_expr
             is_match?(test, evaluate(c, scope), c, co, scope)
           when Puppet::Pops::Model::UnfoldExpression
             # not ideal for error reporting, since it is not known which unfolded result
             # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
             evaluate(c, scope).any? {|v| is_match?(test, v, c, co, scope) }
           else
             is_match?(test, evaluate(c, scope), c, co, scope)
           end
         end
         result = evaluate(co.then_expr, scope)
         true # the option was picked
         end
       end
         result # an option was picked, and produced a result
       else
         evaluate(the_default, scope) # evaluate the default (should be a nop/nil) if there is no default).
       end
     end
   end
 
   # Evaluates a CollectExpression by creating a collector transformer. The transformer
   # will evaulate the collection, create the appropriate collector, and hand it off
   # to the compiler to collect the resources specified by the query.
   #
   def eval_CollectExpression o, scope
     Puppet::Pops::Evaluator::CollectorTransformer.new().transform(o,scope)
   end
 
   def eval_ParenthesizedExpression(o, scope)
     evaluate(o.expr, scope)
   end
 
   # This evaluates classes, nodes and resource type definitions to nil, since 3x:
   # instantiates them, and evaluates their parameters and body. This is achieved by
   # providing bridge AST classes in Puppet::Parser::AST::PopsBridge that bridges a
   # Pops Program and a Pops Expression.
   #
   # Since all Definitions are handled "out of band", they are treated as a no-op when
   # evaluated.
   #
   def eval_Definition(o, scope)
     nil
   end
 
   def eval_Program(o, scope)
     evaluate(o.body, scope)
   end
 
   # Produces Array[PAnyType], an array of resource references
   #
   def eval_ResourceExpression(o, scope)
     exported = o.exported
     virtual = o.virtual
 
     # Get the type name
     type_name =
     if (tmp_name = o.type_name).is_a?(Puppet::Pops::Model::QualifiedName)
       tmp_name.value # already validated as a name
     else
       type_name_acceptable =
       case o.type_name
       when Puppet::Pops::Model::QualifiedReference
         true
       when Puppet::Pops::Model::AccessExpression
         o.type_name.left_expr.is_a?(Puppet::Pops::Model::QualifiedReference)
       end
 
       evaluated_name = evaluate(tmp_name, scope)
       unless type_name_acceptable
         actual = type_calculator.generalize!(type_calculator.infer(evaluated_name)).to_s
         fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual => actual})
       end
 
       # must be a CatalogEntry subtype
       case evaluated_name
       when Puppet::Pops::Types::PHostClassType
         unless evaluated_name.class_name.nil?
           fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
         end
         'class'
 
       when Puppet::Pops::Types::PResourceType
         unless evaluated_name.title().nil?
           fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
         end
         evaluated_name.type_name # assume validated
 
       else
         actual = type_calculator.generalize!(type_calculator.infer(evaluated_name)).to_s
         fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=>actual})
       end
     end
 
     # This is a runtime check - the model is valid, but will have runtime issues when evaluated
     # and storeconfigs is not set.
     if(o.exported)
       optionally_fail(Puppet::Pops::Issues::RT_NO_STORECONFIGS_EXPORT, o);
     end
 
     titles_to_body = {}
     body_to_titles = {}
     body_to_params = {}
 
     # titles are evaluated before attribute operations
     o.bodies.map do | body |
       titles = evaluate(body.title, scope)
 
       # Title may not be nil
       # Titles may be given as an array, it is ok if it is empty, but not if it contains nil entries
       # Titles may not be an empty String
       # Titles must be unique in the same resource expression
       # There may be a :default entry, its entries apply with lower precedence
       #
       if titles.nil?
         fail(Puppet::Pops::Issues::MISSING_TITLE, body.title)
       end
       titles = [titles].flatten
 
       # Check types of evaluated titles and duplicate entries
       titles.each_with_index do |title, index|
         if title.nil?
           fail(Puppet::Pops::Issues::MISSING_TITLE_AT, body.title, {:index => index})
 
         elsif !title.is_a?(String) && title != :default
           actual = type_calculator.generalize!(type_calculator.infer(title)).to_s
           fail(Puppet::Pops::Issues::ILLEGAL_TITLE_TYPE_AT, body.title, {:index => index, :actual => actual})
 
         elsif title == EMPTY_STRING
          fail(Puppet::Pops::Issues::EMPTY_STRING_TITLE_AT, body.title, {:index => index})
 
         elsif titles_to_body[title]
           fail(Puppet::Pops::Issues::DUPLICATE_TITLE, o, {:title => title})
         end
         titles_to_body[title] = body
       end
 
       # Do not create a real instance from the :default case
       titles.delete(:default)
 
       body_to_titles[body] = titles
 
       # Store evaluated parameters in a hash associated with the body, but do not yet create resource
       # since the entry containing :defaults may appear later
       body_to_params[body] = body.operations.reduce({}) do |param_memo, op|
         params = evaluate(op, scope)
         params = [params] unless params.is_a?(Array)
         params.each do |p|
           if param_memo.include? p.name
             fail(Puppet::Pops::Issues::DUPLICATE_ATTRIBUTE, o, {:attribute => p.name})
           end
           param_memo[p.name] = p
         end
         param_memo
       end
     end
 
     # Titles and Operations have now been evaluated and resources can be created
     # Each production is a PResource, and an array of all is produced as the result of
     # evaluating the ResourceExpression.
     #
     defaults_hash = body_to_params[titles_to_body[:default]] || {}
     o.bodies.map do | body |
       titles = body_to_titles[body]
       params = defaults_hash.merge(body_to_params[body] || {})
       create_resources(o, scope, virtual, exported, type_name, titles, params.values)
     end.flatten.compact
   end
 
   def eval_ResourceOverrideExpression(o, scope)
     evaluated_resources = evaluate(o.resources, scope)
     evaluated_parameters = o.operations.map { |op| evaluate(op, scope) }
     create_resource_overrides(o, scope, [evaluated_resources].flatten, evaluated_parameters)
     evaluated_resources
   end
 
   # Produces 3x parameter
   def eval_AttributeOperation(o, scope)
     create_resource_parameter(o, scope, o.attribute_name, evaluate(o.value_expr, scope), o.operator)
   end
 
   def eval_AttributesOperation(o, scope)
     hashed_params = evaluate(o.expr, scope)
     unless hashed_params.is_a?(Hash)
       actual = type_calculator.generalize!(type_calculator.infer(hashed_params)).to_s
       fail(Puppet::Pops::Issues::TYPE_MISMATCH, o.expr, {:expected => 'Hash', :actual => actual})
     end
     hashed_params.map { |k,v| create_resource_parameter(o, scope, k, v, :'=>') }
   end
 
   # Sets default parameter values for a type, produces the type
   #
   def eval_ResourceDefaultsExpression(o, scope)
     type = evaluate(o.type_ref, scope)
     type_name =
     if type.is_a?(Puppet::Pops::Types::PResourceType) && !type.type_name.nil? && type.title.nil?
       type.type_name # assume it is a valid name
     else
       actual = type_calculator.generalize!(type_calculator.infer(type))
       fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_ref, {:actual => actual})
     end
     evaluated_parameters = o.operations.map {|op| evaluate(op, scope) }
     create_resource_defaults(o, scope, type_name, evaluated_parameters)
     # Produce the type
     type
   end
 
   # Evaluates function call by name.
   #
   def eval_CallNamedFunctionExpression(o, scope)
     # The functor expression is not evaluated, it is not possible to select the function to call
     # via an expression like $a()
     case o.functor_expr
     when Puppet::Pops::Model::QualifiedName
       # ok
     when Puppet::Pops::Model::RenderStringExpression
       # helpful to point out this easy to make Epp error
       fail(Issues::ILLEGAL_EPP_PARAMETERS, o)
     else
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end
     name = o.functor_expr.value
     call_function_with_block(name, unfold([], o.arguments, scope), o, scope)
   end
 
   # Evaluation of CallMethodExpression handles a NamedAccessExpression functor (receiver.function_name)
   #
   def eval_CallMethodExpression(o, scope)
     unless o.functor_expr.is_a? Puppet::Pops::Model::NamedAccessExpression
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function accessor', :container => o})
     end
     receiver = evaluate(o.functor_expr.left_expr, scope)
     name = o.functor_expr.right_expr
     unless name.is_a? Puppet::Pops::Model::QualifiedName
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end 
     name = name.value # the string function name
     call_function_with_block(name, unfold([receiver], o.arguments || [], scope), o, scope)
   end
 
   def call_function_with_block(name, evaluated_arguments, o, scope)
     if o.lambda.nil?
       call_function(name, evaluated_arguments, o, scope)
     else
       closure = Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope)
       call_function(name, evaluated_arguments, o, scope, &proc_from_closure(closure))
     end
   end
   private :call_function_with_block
 
   # Creates a Proc with an arity count that matches the parameters of the given closure. The arity will
   # be correct up to 10 parameters and then default to varargs (-1)
   #
   def proc_from_closure(closure)
     return Puppet::Pops::Evaluator::PuppetProc.new(closure) { |*args| closure.call(*args) } unless RUBY_VERSION[0,3] == '1.8'
 
     # This code is required since a Proc isn't propagated by reference in Ruby 1.8.x. It produces a standard
     # Proc that has correct arity as a replacement for the otherwise used PuppetProc
     # TODO: Remove when Ruby 1.8.x support is dropped
     arity = closure.parameters.reduce(0) do |memo, param|
       count = memo + 1
       break -count if param.captures_rest || !param.value.nil?
       count
     end
 
     case arity
     when 0
       proc { || closure.call }
     when 1
       proc { |a| closure.call(a) }
     when 2
       proc { |a, b| closure.call(a, b) }
     when 3
       proc { |a, b, c| closure.call(a, b, c) }
     when 4
       proc { |a, b, c, d| closure.call(a, b, c, d) }
     when 5
       proc { |a, b, c, d, e| closure.call(a, b, c, d, e) }
     when 6
       proc { |a, b, c, d, e, f| closure.call(a, b, c, d, e, f) }
     when 7
       proc { |a, b, c, d, e, f, g| closure.call(a, b, c, d, e, f, g) }
     when 8
       proc { |a, b, c, d, e, f, g, h| closure.call(a, b, c, d, e, f, g, h) }
     when 9
       proc { |a, b, c, d, e, f, g, h, i| closure.call(a, b, c, d, e, f, g, h, i) }
     when 10
       proc { |a, b, c, d, e, f, g, h, i, j| closure.call(a, b, c, d, e, f, g, h, i, j) }
     when -1
       proc { |*v| closure.call(*v) }
     when -2
       proc { |a, *v| closure.call(a, *v) }
     when -3
       proc { |a, b, *v| closure.call(a, b, *v) }
     when -4
       proc { |a, b, c, *v| closure.call(a, b, c, *v) }
     when -5
       proc { |a, b, c, d, *v| closure.call(a, b, c, d, *v) }
     when -6
       proc { |a, b, c, d, e, *v| closure.call(a, b, c, d, e, *v) }
     when -7
       proc { |a, b, c, d, e, f, *v| closure.call(a, b, c, d, e, f, *v) }
     when -8
       proc { |a, b, c, d, e, f, g, *v| closure.call(a, b, c, d, e, f, g, *v) }
     when -9
       proc { |a, b, c, d, e, f, g, h, *v| closure.call(a, b, c, d, e, f,g, h, *v) }
     when -10
       proc { |a, b, c, d, e, f, g, h, i, *v| closure.call(a, b, c, d, e, f,g, h, i, *v) }
     else
       proc { |*a| closure.call(*a) }
     end
   end
   private :proc_from_closure
 
   # @example
   #   $x ? { 10 => true, 20 => false, default => 0 }
   #
   def eval_SelectorExpression o, scope
     # memo scope level before evaluating test - don't want a match in the case test to leak $n match vars
     # to expressions after the selector expression.
     #
     with_guarded_scope(scope) do
       test = evaluate(o.left_expr, scope)
       @migration_checker.report_uc_bareword_type(test, o.left_expr)
 
       the_default = nil
       selected = o.selectors.find do |s|
         me = s.matching_expr
         case me
         when Puppet::Pops::Model::LiteralDefault
           the_default = s.value_expr
           false
         when Puppet::Pops::Model::UnfoldExpression
           # not ideal for error reporting, since it is not known which unfolded result
           # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
           evaluate(me, scope).any? {|v| is_match?(test, v, me, s, scope) }
         else
           is_match?(test, evaluate(me, scope), me, s, scope)
         end
       end
       if selected
         evaluate(selected.value_expr, scope)
       elsif the_default
         evaluate(the_default, scope)
       else
         fail(Issues::UNMATCHED_SELECTOR, o.left_expr, :param_value => test)
       end
     end
   end
 
   # SubLocatable is simply an expression that holds location information
   def eval_SubLocatedExpression o, scope
     evaluate(o.expr, scope)
   end
 
   # Evaluates Puppet DSL Heredoc
   def eval_HeredocExpression o, scope
     result = evaluate(o.text_expr, scope)
     assert_external_syntax(scope, result, o.syntax, o.text_expr)
     result
   end
 
   # Evaluates Puppet DSL `if`
   def eval_IfExpression o, scope
     with_guarded_scope(scope) do
       if is_true?(evaluate(o.test, scope), o.test)
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
       end
     end
   end
 
   # Evaluates Puppet DSL `unless`
   def eval_UnlessExpression o, scope
     with_guarded_scope(scope) do
       unless is_true?(evaluate(o.test, scope), o.test)
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
       end
     end
   end
 
   # Evaluates a variable (getting its value)
   # The evaluator is lenient; any expression producing a String is used as a name
   # of a variable.
   #
   def eval_VariableExpression o, scope
     # Evaluator is not too fussy about what constitutes a name as long as the result
     # is a String and a valid variable name
     #
     name = evaluate(o.expr, scope)
 
     # Should be caught by validation, but make this explicit here as well, or mysterious evaluation issues
     # may occur for some evaluation use cases.
     case name
     when String
     when Numeric
     else
       fail(Issues::ILLEGAL_VARIABLE_EXPRESSION, o.expr)
     end
     get_variable_value(name, o, scope)
   end
 
   # Evaluates double quoted strings that may contain interpolation
   #
   def eval_ConcatenatedString o, scope
     o.segments.collect {|expr| string(evaluate(expr, scope), scope)}.join
   end
 
 
   # If the wrapped expression is a QualifiedName, it is taken as the name of a variable in scope.
   # Note that this is different from the 3.x implementation, where an initial qualified name
   # is accepted. (e.g. `"---${var + 1}---"` is legal. This implementation requires such concrete
   # syntax to be expressed in a model as `(TextExpression (+ (Variable var) 1)` - i.e. moving the decision to
   # the parser.
   #
   # Semantics; the result of an expression is turned into a string, nil is silently transformed to empty
   # string.
   # @return [String] the interpolated result
   #
   def eval_TextExpression o, scope
     if o.expr.is_a?(Puppet::Pops::Model::QualifiedName)
       string(get_variable_value(o.expr.value, o, scope), scope)
     else
       string(evaluate(o.expr, scope), scope)
     end
   end
 
   def string_Object(o, scope)
     o.to_s
   end
 
   def string_Symbol(o, scope)
     if :undef == o  # optimized comparison 1.44 vs 1.95
       EMPTY_STRING
     else
       o.to_s
     end
   end
 
   def string_Array(o, scope)
     "[#{o.map {|e| string(e, scope)}.join(COMMA_SEPARATOR)}]"
   end
 
   def string_Hash(o, scope)
     "{#{o.map {|k,v| "#{string(k, scope)} => #{string(v, scope)}"}.join(COMMA_SEPARATOR)}}"
   end
 
   def string_Regexp(o, scope)
     "/#{o.source}/"
   end
 
   def string_PAnyType(o, scope)
     @@type_calculator.string(o)
   end
 
   # Produces concatenation / merge of x and y.
   #
   # When x is an Array, y of type produces:
   #
   # * Array => concatenation `[1,2], [3,4] => [1,2,3,4]`
   # * Hash => concatenation of hash as array `[key, value, key, value, ...]`
   # * any other => concatenation of single value
   #
   # When x is a Hash, y of type produces:
   #
   # * Array => merge of array interpreted as `[key, value, key, value,...]`
   # * Hash => a merge, where entries in `y` overrides
   # * any other => error
   #
   # When x is something else, wrap it in an array first.
   #
   # When x is nil, an empty array is used instead.
   #
   # @note to concatenate an Array, nest the array - i.e. `[1,2], [[2,3]]`
   #
   # @overload concatenate(obj_x, obj_y)
   #   @param obj_x [Object] object to wrap in an array and concatenate to; see other overloaded methods for return type
   #   @param ary_y [Object] array to concatenate at end of `ary_x`
   #   @return [Object] wraps obj_x in array before using other overloaded option based on type of obj_y
   # @overload concatenate(ary_x, ary_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param ary_y [Array] array to concatenate at end of `ary_x`
   #   @return [Array] new array with `ary_x` + `ary_y`
   # @overload concatenate(ary_x, hsh_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param hsh_y [Hash] converted to array form, and concatenated to array
   #   @return [Array] new array with `ary_x` + `hsh_y` converted to array
   # @overload concatenate (ary_x, obj_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param obj_y [Object] non array or hash object to add to array
   #   @return [Array] new array with `ary_x` + `obj_y` added as last entry
   # @overload concatenate(hsh_x, ary_y)
   #   @param hsh_x [Hash] the hash to merge with
   #   @param ary_y [Array] array interpreted as even numbered sequence of key, value merged with `hsh_x`
   #   @return [Hash] new hash with `hsh_x` merged with `ary_y` interpreted as hash in array form
   # @overload concatenate(hsh_x, hsh_y)
   #   @param hsh_x [Hash] the hash to merge to
   #   @param hsh_y [Hash] hash merged with `hsh_x`
   #   @return [Hash] new hash with `hsh_x` merged with `hsh_y`
   # @raise [ArgumentError] when `xxx_x` is neither an Array nor a Hash
   # @raise [ArgumentError] when `xxx_x` is a Hash, and `xxx_y` is neither Array nor Hash.
   #
   def concatenate(x, y)
     x = [x] unless x.is_a?(Array) || x.is_a?(Hash)
     case x
     when Array
       y = case y
       when Array then y
       when Hash  then y.to_a
       else
         [y]
       end
       x + y # new array with concatenation
     when Hash
       y = case y
       when Hash then y
       when Array
         # Hash[[a, 1, b, 2]] => {}
         # Hash[a,1,b,2] => {a => 1, b => 2}
         # Hash[[a,1], [b,2]] => {[a,1] => [b,2]}
         # Hash[[[a,1], [b,2]]] => {a => 1, b => 2}
         # Use type calcultor to determine if array is Array[Array[?]], and if so use second form
         # of call
         t = @@type_calculator.infer(y)
         if t.element_type.is_a? Puppet::Pops::Types::PArrayType
           Hash[y]
         else
           Hash[*y]
         end
       else
         raise ArgumentError.new("Can only append Array or Hash to a Hash")
       end
       x.merge y # new hash with overwrite
     else
       raise ArgumentError.new("Can only append to an Array or a Hash.")
     end
   end
 
   # Produces the result x \ y (set difference)
   # When `x` is an Array, `y` is transformed to an array and then all matching elements removed from x.
   # When `x` is a Hash, all contained keys are removed from x as listed in `y` if it is an Array, or all its keys if it is a Hash.
   # The difference is returned. The given `x` and `y` are not modified by this operation.
   # @raise [ArgumentError] when `x` is neither an Array nor a Hash
   #
   def delete(x, y)
     result = x.dup
     case x
     when Array
       y = case y
       when Array then y
       when Hash then y.to_a
       else
         [y]
       end
       y.each {|e| result.delete(e) }
     when Hash
       y = case y
       when Array then y
       when Hash then y.keys
       else
         [y]
       end
       y.each {|e| result.delete(e) }
     else
       raise ArgumentError.new("Can only delete from an Array or Hash.")
     end
     result
   end
 
   # Implementation of case option matching.
   #
   # This is the type of matching performed in a case option, using == for every type
   # of value except regular expression where a match is performed.
   #
   def is_match?(left, right, o, option_expr, scope)
     @migration_checker.report_option_type_mismatch(left, right, option_expr, o)
     if right.is_a?(Regexp)
       return false unless left.is_a? String
       matched = right.match(left)
       set_match_data(matched, scope) # creates or clears ephemeral
       !!matched # convert to boolean
     elsif right.is_a?(Puppet::Pops::Types::PAnyType)
       @migration_checker.report_uc_bareword_type(right, o)
 
       # right is a type and left is not - check if left is an instance of the given type
       # (The reverse is not terribly meaningful - computing which of the case options that first produces
       # an instance of a given type).
       #
       @@type_calculator.instance?(right, left)
     else
       # Handle equality the same way as the language '==' operator (case insensitive etc.)
       @@compare_operator.equals(left,right)
     end
   end
 
   def with_guarded_scope(scope)
     scope_memo = get_scope_nesting_level(scope)
     begin
       yield
     ensure
       set_scope_nesting_level(scope, scope_memo)
     end
   end
 
   # Maps the expression in the given array to their product except for UnfoldExpressions which are first unfolded.
   # The result is added to the given result Array.
   # @param result [Array] Where to add the result (may contain information to add to)
   # @param array [Array[Puppet::Pops::Model::Expression] the expressions to map
   # @param scope [Puppet::Parser::Scope] the scope to evaluate in
   # @return [Array] the given result array with content added from the operation
   #
   def unfold(result, array, scope)
     array.each do |x|
       if x.is_a?(Puppet::Pops::Model::UnfoldExpression)
         result.concat(evaluate(x, scope))
       else
         result << evaluate(x, scope)
       end
     end
     result
   end
   private :unfold
 
 end
diff --git a/lib/puppet/pops/migration/migration_checker.rb b/lib/puppet/pops/migration/migration_checker.rb
index 3db857435..efd756cec 100644
--- a/lib/puppet/pops/migration/migration_checker.rb
+++ b/lib/puppet/pops/migration/migration_checker.rb
@@ -1,31 +1,32 @@
-# This class defines the API of the MigrationChecker support.
+# This class defines the private API of the MigrationChecker support.
+# @api private
 #
 class Puppet::Pops::Migration::MigrationChecker
 
   def initialize()
   end
 
   def report_ambiguous_integer(o)
   end
 
   def report_ambiguous_float(o)
   end
 
   def report_empty_string_true(value, o)
   end
 
   def report_uc_bareword_type(value, o)
   end
 
   def report_equality_type_mismatch(left, right, o)
   end
 
   def report_option_type_mismatch(test_value, option_value, option_expr, matching_expr)
   end
 
   def report_in_expression(o)
   end
 
   def report_array_last_in_block(o)
   end
 end
diff --git a/lib/puppet/pops/parser/evaluating_parser.rb b/lib/puppet/pops/parser/evaluating_parser.rb
index bf464e84f..4e84b153e 100644
--- a/lib/puppet/pops/parser/evaluating_parser.rb
+++ b/lib/puppet/pops/parser/evaluating_parser.rb
@@ -1,148 +1,148 @@
 
 # Does not support "import" and parsing ruby files
 #
 class Puppet::Pops::Parser::EvaluatingParser
 
   attr_reader :parser
 
   def initialize()
     @parser = Puppet::Pops::Parser::Parser.new()
   end
 
   def parse_string(s, file_source = 'unknown')
     @file_source = file_source
     clear()
     # Handling of syntax error can be much improved (in general), now it bails out of the parser
     # and does not have as rich information (when parsing a string), need to update it with the file source
     # (ideally, a syntax error should be entered as an issue, and not just thrown - but that is a general problem
     # and an improvement that can be made in the eparser (rather than here).
     # Also a possible improvement (if the YAML parser returns positions) is to provide correct output of position.
     #
     begin
       assert_and_report(parser.parse_string(s))
     rescue Puppet::ParseError => e
       # TODO: This is not quite right, why does not the exception have the correct file?
       e.file = @file_source unless e.file.is_a?(String) && !e.file.empty?
       raise e
     end
   end
 
   def parse_file(file)
     @file_source = file
     clear()
     assert_and_report(parser.parse_file(file))
   end
 
   def evaluate_string(scope, s, file_source='unknown')
     evaluate(scope, parse_string(s, file_source))
   end
 
   def evaluate_file(file)
     evaluate(parse_file(file))
   end
 
   def clear()
     @acceptor = nil
   end
 
   # Create a closure that can be called in the given scope
   def closure(model, scope)
     Puppet::Pops::Evaluator::Closure.new(evaluator, model, scope)
   end
 
   def evaluate(scope, model)
     return nil unless model
     evaluator.evaluate(model, scope)
   end
 
   def evaluator
     # Do not use the cached evaluator if this is a migration run
     if (Puppet.lookup(:migration_checker) { nil })
       return Puppet::Pops::Evaluator::EvaluatorImpl.new()
     end
     @@evaluator ||= Puppet::Pops::Evaluator::EvaluatorImpl.new()
     @@evaluator
   end
 
   def convert_to_3x(object, scope)
-    val = @@evaluator.convert(object, scope, nil)
+    val = evaluator.convert(object, scope, nil)
   end
 
   def validate(parse_result)
     resulting_acceptor = acceptor()
     validator(resulting_acceptor).validate(parse_result)
     resulting_acceptor
   end
 
   def acceptor()
     Puppet::Pops::Validation::Acceptor.new
   end
 
   def validator(acceptor)
     Puppet::Pops::Validation::ValidatorFactory_4_0.new().validator(acceptor)
   end
 
   def assert_and_report(parse_result)
     return nil unless parse_result
     if parse_result.source_ref.nil? or parse_result.source_ref == ''
       parse_result.source_ref = @file_source
     end
     validation_result = validate(parse_result)
 
     Puppet::Pops::IssueReporter.assert_and_report(validation_result,
                                           :emit_warnings => true)
     parse_result
   end
 
   def quote(x)
     self.class.quote(x)
   end
 
   # Translates an already parsed string that contains control characters, quotes
   # and backslashes into a quoted string where all such constructs have been escaped.
   # Parsing the return value of this method using the puppet parser should yield
   # exactly the same string as the argument passed to this method
   #
   # The method makes an exception for the two character sequences \$ and \s. They
   # will not be escaped since they have a special meaning in puppet syntax.
   #
   # TODO: Handle \uXXXX characters ??
   #
   # @param x [String] The string to quote and "unparse"
   # @return [String] The quoted string
   #
   def self.quote(x)
     escaped = '"'
     p = nil
     x.each_char do |c|
       case p
       when nil
         # do nothing
       when "\t"
         escaped << '\\t'
       when "\n"
         escaped << '\\n'
       when "\f"
         escaped << '\\f'
       # TODO: \cx is a range of characters - skip for now
       #      when "\c"
       #        escaped << '\\c'
       when '"'
         escaped << '\\"'
       when '\\'
         escaped << if c == '$' || c == 's'; p; else '\\\\'; end # don't escape \ when followed by s or $
       else
         escaped << p
       end
       p = c
     end
     escaped << p unless p.nil?
     escaped << '"'
   end
 
   class EvaluatingEppParser < Puppet::Pops::Parser::EvaluatingParser
     def initialize()
       @parser = Puppet::Pops::Parser::EppParser.new()
     end
   end
 end
diff --git a/lib/puppet/pops/validation.rb b/lib/puppet/pops/validation.rb
index c9a841418..570d42fe7 100644
--- a/lib/puppet/pops/validation.rb
+++ b/lib/puppet/pops/validation.rb
@@ -1,454 +1,455 @@
 # A module with base functionality for validation of a model.
 #
 # * **Factory** - an abstract factory implementation that makes it easier to create a new validation factory.
 # * **SeverityProducer** - produces a severity (:error, :warning, :ignore) for a given Issue
 # * **DiagnosticProducer** - produces a Diagnostic which binds an Issue to an occurrence of that issue
 # * **Acceptor** - the receiver/sink/collector of computed diagnostics
 # * **DiagnosticFormatter** - produces human readable output for a Diagnostic
 #
 module Puppet::Pops::Validation
 
   # This class is an abstract base implementation of a _model validation factory_ that creates a validator instance
   # and associates it with a fully configured DiagnosticProducer.
   #
   # A _validator_ is responsible for validating a model. There may be different versions of validation available
   # for one and the same model; e.g. different semantics for different puppet versions, or different types of
   # validation configuration depending on the context/type of validation that should be performed (static, vs. runtime, etc.).
   #
   # This class is abstract and must be subclassed. The subclass must implement the methods
   # {#label_provider} and {#checker}. It is also expected that the sublcass will override
   # the severity_producer and configure the issues that should be reported as errors (i.e. if they should be ignored, produce
   # a warning, or a deprecation warning).
   #
   # @abstract Subclass must implement {#checker}, and {#label_provider}
   # @api public
   #
   class Factory
 
     # Produces a validator with the given acceptor as the recipient of produced diagnostics.
     # The acceptor is where detected issues are received (and typically collected).
     #
     # @param acceptor [Acceptor] the acceptor is the receiver of all detected issues
     # @return [#validate] a validator responding to `validate(model)`
     #
     # @api public
     #
     def validator(acceptor)
       checker(diagnostic_producer(acceptor))
     end
 
     # Produces the diagnostics producer to use given an acceptor of issues.
     #
     # @param acceptor [Acceptor] the acceptor is the receiver of all detected issues
     # @return [DiagnosticProducer] a detector of issues
     #
     # @api public
     #
     def diagnostic_producer(acceptor)
       Puppet::Pops::Validation::DiagnosticProducer.new(acceptor, severity_producer(), label_provider())
     end
 
     # Produces the SeverityProducer to use
     # Subclasses should implement and add specific overrides
     #
     # @return [SeverityProducer] a severity producer producing error, warning or ignore per issue
     #
     # @api public
     #
     def severity_producer
       Puppet::Pops::Validation::SeverityProducer.new
     end
 
     # Produces the checker to use.
     #
     # @abstract
     #
     # @api public
     #
     def checker(diagnostic_producer)
       raise NoMethodError, "checker"
     end
 
     # Produces the label provider to use.
     #
     # @abstract
     #
     # @api public
     #
     def label_provider
       raise NoMethodError, "label_provider"
     end
   end
 
   # Decides on the severity of a given issue.
   # The produced severity is one of `:error`, `:warning`, or `:ignore`.
   # By default, a severity of `:error` is produced for all issues. To configure the severity
   # of an issue call `#severity=(issue, level)`.
   #
   # @return [Symbol] a symbol representing the severity `:error`, `:warning`, or `:ignore`
   #
   # @api public
   #
   class SeverityProducer
     @@severity_hash = {:ignore => true, :warning => true, :error => true, :deprecation => true }
 
     # Creates a new instance where all issues are diagnosed as :error unless overridden.
+    # @param [Symbol] specifies default severity if :error is not wanted as the default
     # @api public
     #
     def initialize(default_severity = :error)
       # If diagnose is not set, the default is returned by the block
       @severities = Hash.new default_severity
     end
 
     # Returns the severity of the given issue.
     # @return [Symbol] severity level :error, :warning, or :ignore
     # @api public
     #
     def severity(issue)
       assert_issue(issue)
       @severities[issue]
     end
 
     # @see {#severity}
     # @api public
     #
     def [] issue
       severity issue
     end
 
     # Override a default severity with the given severity level.
     #
     # @param issue [Puppet::Pops::Issues::Issue] the issue for which to set severity
     # @param level [Symbol] the severity level (:error, :warning, or :ignore).
     # @api public
     #
     def []=(issue, level)
       raise Puppet::DevError.new("Attempt to set validation severity for something that is not an Issue. (Got #{issue.class})") unless issue.is_a? Puppet::Pops::Issues::Issue
       raise Puppet::DevError.new("Illegal severity level: #{option}") unless @@severity_hash[level]
       raise Puppet::DevError.new("Attempt to demote the hard issue '#{issue.issue_code}' to #{level}") unless issue.demotable? || level == :error
       @severities[issue] = level
     end
 
     # Returns `true` if the issue should be reported or not.
     # @return [Boolean] this implementation returns true for errors and warnings
     #
     # @api public
     #
     def should_report? issue
       diagnose = @severities[issue]
       diagnose == :error || diagnose == :warning || diagnose == :deprecation
     end
 
     # Checks if the given issue is valid.
     # @api private
     #
     def assert_issue issue
       raise Puppet::DevError.new("Attempt to get validation severity for something that is not an Issue. (Got #{issue.class})") unless issue.is_a? Puppet::Pops::Issues::Issue
     end
 
     # Checks if the given severity level is valid.
     # @api private
     #
     def assert_severity level
       raise Puppet::DevError.new("Illegal severity level: #{option}") unless @@severity_hash[level]
     end
   end
 
   # A producer of diagnostics.
   # An producer of diagnostics is given each issue occurrence as they are found by a diagnostician/validator. It then produces
   # a Diagnostic, which it passes on to a configured Acceptor.
   #
   # This class exists to aid a diagnostician/validator which will typically first check if a particular issue
   # will be accepted at all (before checking for an occurrence of the issue; i.e. to perform check avoidance for expensive checks).
   # A validator passes an instance of Issue, the semantic object (the "culprit"), a hash with arguments, and an optional
   # exception. The semantic object is used to determine the location of the occurrence of the issue (file/line), and it
   # sets keys in the given argument hash that may be used in the formatting of the issue message.
   #
   class DiagnosticProducer
 
     # A producer of severity for a given issue
     # @return [SeverityProducer]
     #
     attr_reader :severity_producer
 
     # A producer of labels for objects involved in the issue
     # @return [LabelProvider]
     #
     attr_reader :label_provider
     # Initializes this producer.
     #
     # @param acceptor [Acceptor] a sink/collector of diagnostic results
     # @param severity_producer [SeverityProducer] the severity producer to use to determine severity of a given issue
     # @param label_provider [LabelProvider] a provider of model element type to human readable label
     #
     def initialize(acceptor, severity_producer, label_provider)
       @acceptor           = acceptor
       @severity_producer  = severity_producer
       @label_provider     = label_provider
     end
 
     def accept(issue, semantic, arguments={}, except=nil)
       return unless will_accept? issue
 
       # Set label provider unless caller provided a special label provider
       arguments[:label]    ||= @label_provider
       arguments[:semantic] ||= semantic
 
       # A detail message is always provided, but is blank by default.
       # TODO: this support is questionable, it requires knowledge that :detail is special
       arguments[:detail] ||= ''
 
       source_pos = Puppet::Pops::Utils.find_closest_positioned(semantic)
       file = source_pos ? source_pos.locator.file : nil
 
       severity = @severity_producer.severity(issue)
       @acceptor.accept(Diagnostic.new(severity, issue, file, source_pos, arguments, except))
     end
 
     def will_accept? issue
       @severity_producer.should_report? issue
     end
   end
 
   class Diagnostic
     attr_reader :severity
     attr_reader :issue
     attr_reader :arguments
     attr_reader :exception
     attr_reader :file
     attr_reader :source_pos
     def initialize severity, issue, file, source_pos, arguments={}, exception=nil
       @severity = severity
       @issue = issue
       @file = file
       @source_pos = source_pos
       @arguments = arguments
       # TODO: Currently unused, the intention is to provide more information (stack backtrace, etc.) when
       # debugging or similar - this to catch internal problems reported as higher level issues.
       @exception = exception
     end
 
     # Two diagnostics are considered equal if the have the same issue, location and severity
     # (arguments and exception are ignored)
     #
     def ==(o)
       self.class            == o.class             &&
         same_position?(o)                          &&
         issue.issue_code    == o.issue.issue_code  &&
         file                == o.file              &&
         severity            == o.severity
     end
     alias eql? ==
 
     # Position is equal if the diagnostic is not located or if referring to the same offset
     def same_position?(o)
       source_pos.nil? && o.source_pos.nil? || source_pos.offset == o.source_pos.offset
     end
     private :same_position?
 
     def hash
       @hash ||= [file, source_pos.offset, issue.issue_code, severity].hash
     end
   end
 
   # Formats a diagnostic for output.
   # Produces a diagnostic output typical for a compiler (suitable for interpretation by tools)
   # The format is:
   # `file:line:pos: Message`, where pos, line and file are included if available.
   #
   class DiagnosticFormatter
     def format diagnostic
       "#{loc(diagnostic)} #{format_severity(diagnostic)}#{format_message(diagnostic)}"
     end
 
     def format_message diagnostic
       diagnostic.issue.format(diagnostic.arguments)
     end
 
     # This produces "Deprecation notice: " prefix if the diagnostic has :deprecation severity, otherwise "".
     # The idea is that all other diagnostics are emitted with the methods Puppet.err (or an exception), and
     # Puppet.warning.
     # @note Note that it is not a good idea to use Puppet.deprecation_warning as it is for internal deprecation.
     #
     def format_severity diagnostic
       diagnostic.severity == :deprecation ? "Deprecation notice: " : ""
     end
 
     def format_location diagnostic
       file = diagnostic.file
       file = (file.is_a?(String) && file.empty?) ? nil : file
       line = pos = nil
       if diagnostic.source_pos
         line = diagnostic.source_pos.line
         pos = diagnostic.source_pos.pos
       end
       if file && line && pos
         "#{file}:#{line}:#{pos}:"
       elsif file && line
         "#{file}:#{line}:"
       elsif file
         "#{file}:"
       else
         ""
       end
     end
   end
 
   # Produces a diagnostic output in the "puppet style", where the location is appended with an "at ..." if the
   # location is known.
   #
   class DiagnosticFormatterPuppetStyle < DiagnosticFormatter
     def format diagnostic
       if (location = format_location diagnostic) != ""
         "#{format_severity(diagnostic)}#{format_message(diagnostic)}#{location}"
       else
         format_message(diagnostic)
       end
     end
 
     # The somewhat (machine) unusable format in current use by puppet.
     # have to be used here for backwards compatibility.
     def format_location diagnostic
       file = diagnostic.file
       file = (file.is_a?(String) && file.empty?) ? nil : file
       line = pos = nil
       if diagnostic.source_pos
         line = diagnostic.source_pos.line
         pos = diagnostic.source_pos.pos
       end
 
       if file && line && pos
         " at #{file}:#{line}:#{pos}"
       elsif file and line
         " at #{file}:#{line}"
       elsif line && pos
         " at line #{line}:#{pos}"
       elsif line
         " at line #{line}"
       elsif file
         " in #{file}"
       else
         ""
       end
     end
   end
 
   # An acceptor of diagnostics.
   # An acceptor of diagnostics is given each issue as they are found by a diagnostician/validator. An
   # acceptor can collect all found issues, or decide to collect a few and then report, or give up as the first issue
   # if found.
   # This default implementation collects all diagnostics in the order they are produced, and can then
   # answer questions about what was diagnosed.
   #
   class Acceptor
 
     # All diagnostic in the order they were issued
     attr_reader :diagnostics
 
     # The number of :warning severity issues + number of :deprecation severity issues
     attr_reader :warning_count
 
     # The number of :error severity issues
     attr_reader :error_count
     # Initializes this diagnostics acceptor.
     # By default, the acceptor is configured with a default severity producer.
     # @param severity_producer [SeverityProducer] the severity producer to use to determine severity of an issue
     #
     # TODO add semantic_label_provider
     #
     def initialize()
       @diagnostics = []
       @error_count = 0
       @warning_count = 0
     end
 
     # Returns true when errors have been diagnosed.
     def errors?
       @error_count > 0
     end
 
     # Returns true when warnings have been diagnosed.
     def warnings?
       @warning_count > 0
     end
 
     # Returns true when errors and/or warnings have been diagnosed.
     def errors_or_warnings?
       errors? || warnings?
     end
 
     # Returns the diagnosed errors in the order thwy were reported.
     def errors
       @diagnostics.select {|d| d.severity == :error }
     end
 
     # Returns the diagnosed warnings in the order thwy were reported.
     # (This includes :warning and :deprecation severity)
     def warnings
       @diagnostics.select {|d| d.severity == :warning || d.severity == :deprecation }
     end
 
     def errors_and_warnings
       @diagnostics.select {|d| d.severity != :ignore }
     end
 
     # Returns the ignored diagnostics in the order thwy were reported (if reported at all)
     def ignored
       @diagnostics.select {|d| d.severity == :ignore }
     end
 
     # Add a diagnostic, or all diagnostics from another acceptor to the set of diagnostics
     # @param diagnostic [Puppet::Pops::Validation::Diagnostic, Puppet::Pops::Validation::Acceptor] diagnostic(s) that should be accepted
     def accept(diagnostic)
       if diagnostic.is_a?(Acceptor)
         diagnostic.diagnostics.each {|d| self.send(d.severity, d)}
       else
         self.send(diagnostic.severity, diagnostic)
       end
     end
 
     # Prunes the contain diagnostics by removing those for which the given block returns true.
     # The internal statistics is updated as a consequence of removing.
     # @return [Array<Puppet::Pops::Validation::Diagnostic, nil] the removed set of diagnostics or nil if nothing was removed
     #
     def prune(&block)
       removed = []
       @diagnostics.delete_if do |d|
         if should_remove = yield(d)
           removed << d
         end
         should_remove
       end
       removed.each do |d|
         case d.severity
         when :error
           @error_count -= 1
         when :warning
           @warning_count -= 1
         # there is not ignore_count
         end
       end
       removed.empty? ? nil : removed
     end
 
     private
 
     def ignore diagnostic
       @diagnostics << diagnostic
     end
 
     def error diagnostic
       @diagnostics << diagnostic
       @error_count += 1
     end
 
     def warning diagnostic
       @diagnostics << diagnostic
       @warning_count += 1
     end
 
     def deprecation diagnostic
       warning diagnostic
     end
   end
 end
diff --git a/lib/puppet/pops/validation/checker4_0.rb b/lib/puppet/pops/validation/checker4_0.rb
index 18f271528..618ac5a0e 100644
--- a/lib/puppet/pops/validation/checker4_0.rb
+++ b/lib/puppet/pops/validation/checker4_0.rb
@@ -1,776 +1,776 @@
 # 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
   attr_reader :migration_checker
 
   # 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", 0, 0)
     @@idem_visitor        ||= Puppet::Pops::Visitor.new(self, "idem", 0, 0)
 
     @acceptor = diagnostics_producer
 
     # Use null migration checker unless given in context
     @migration_checker ||= (Puppet.lookup(:migration_checker) { Puppet::Pops::Migration::MigrationChecker.new() })
   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)
     @@relation_visitor.visit_this_0(self, o)
   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
 
   # Checks if the expression has side effect ('idem' is latin for 'the same', here meaning that the evaluation state
   # is known to be unchanged after the expression has been evaluated). The result is not 100% authoritative for
   # negative answers since analysis of function behavior is not possible.
   # @return [Boolean] true if expression is known to have no effect on evaluation state
   #
   def idem(o)
     @@idem_visitor.visit_this_0(self, o)
   end
 
   # Returns the last expression in a block, or the expression, if that expression is idem
   def ends_with_idem(o)
     if o.is_a?(Puppet::Pops::Model::BlockExpression)
       last = o.statements[-1]
       idem(last) ? last : nil
     else
       idem(o) ? o : nil
     end
   end
 
   #---ASSIGNMENT CHECKS
 
   def assign_VariableExpression(o, via_index)
     varname_string = varname_to_s(o.expr)
     if varname_string =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
       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)
     # Only min range is checked, all other checks are RT checks as they depend on the resulting type
     # of the LHS.
     if o.keys.size < 1
       acceptor.accept(Issues::MISSING_INDEX, o)
     end
   end
 
   def check_AssignmentExpression(o)
     case o.operator
     when :'='
       assign(o.left_expr)
       rvalue(o.right_expr)
     when :'+=', :'-='
       acceptor.accept(Issues::APPENDS_DELETES_NO_LONGER_SUPPORTED, o, {:operator => o.operator})
     else
       acceptor.accept(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
     end
   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_AttributesOperation(o)
     # Append operator use is constrained
     parent = o.eContainer
     parent = parent.eContainer unless parent.nil?
     unless parent.is_a?(Model::ResourceExpression)
       acceptor.accept(Issues::UNSUPPORTED_OPERATOR_IN_CONTEXT, o, :operator=>'* =>')
     end
 
     rvalue(o.expr)
   end
 
   def check_BinaryExpression(o)
     rvalue(o.left_expr)
     rvalue(o.right_expr)
   end
 
   def check_BlockExpression(o)
     o.statements[0..-2].each do |statement|
       if idem(statement)
         acceptor.accept(Issues::IDEM_EXPRESSION_NOT_LAST, statement)
         break # only flag the first
       end
     end
-    @migration_checker.report_array_last_in_block(o.statements[-1])
+    migration_checker.report_array_last_in_block(o.statements[-1])
   end
 
   def check_CallNamedFunctionExpression(o)
     case o.functor_expr
     when Puppet::Pops::Model::QualifiedName
       # ok
       nil
     when Puppet::Pops::Model::RenderStringExpression
       # helpful to point out this easy to make Epp error
       acceptor.accept(Issues::ILLEGAL_EPP_PARAMETERS, o)
     else
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end
   end
 
   def check_EppExpression(o)
     if o.eContainer.is_a?(Puppet::Pops::Model::LambdaExpression)
       internal_check_no_capture(o.eContainer, 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
 
   RESERVED_TYPE_NAMES = {
     'type' => true,
     'any' => true,
     'unit' => true,
     'scalar' => true,
     'boolean' => true,
     'numeric' => true,
     'integer' => true,
     'float' => true,
     'collection' => true,
     'array' => true,
     'hash' => true,
     'tuple' => true,
     'struct' => true,
     'variant' => true,
     'optional' => true,
     'enum' => true,
     'regexp' => true,
     'pattern' => true,
     'runtime' => true,
   }
 
   # for 'class', 'define', and function
   def check_NamedDefinition(o)
     top(o.eContainer, o)
     if o.name !~ Puppet::Pops::Patterns::CLASSREF
       acceptor.accept(Issues::ILLEGAL_DEFINITION_NAME, o, {:name=>o.name})
     end
 
     if RESERVED_TYPE_NAMES[o.name()]
       acceptor.accept(Issues::RESERVED_TYPE_NAME, o, {:name => o.name})
     end
 
     if violator = ends_with_idem(o.body)
       acceptor.accept(Issues::IDEM_NOT_ALLOWED_LAST, violator, {:container => o})
     end
   end
 
   def check_HostClassDefinition(o)
     check_NamedDefinition(o)
     internal_check_no_capture(o)
     internal_check_reserved_params(o)
   end
 
   def check_ResourceTypeDefinition(o)
     check_NamedDefinition(o)
     internal_check_no_capture(o)
     internal_check_reserved_params(o)
   end
 
   def internal_check_capture_last(o)
     accepted_index = o.parameters.size() -1
     o.parameters.each_with_index do |p, index|
       if p.captures_rest && index != accepted_index
         acceptor.accept(Issues::CAPTURES_REST_NOT_LAST, p, {:param_name => p.name})
       end
     end
   end
 
   def internal_check_no_capture(o, container = o)
     o.parameters.each do |p|
       if p.captures_rest
         acceptor.accept(Issues::CAPTURES_REST_NOT_SUPPORTED, p, {:container => container, :param_name => p.name})
       end
     end
   end
 
   RESERVED_PARAMETERS = {
     'name' => true,
     'title' => true,
   }
 
   def internal_check_reserved_params(o)
     o.parameters.each do |p|
       if RESERVED_PARAMETERS[p.name]
         acceptor.accept(Issues::RESERVED_PARAMETER, p, {:container => o, :param_name => p.name})
       end
     end
   end
 
   def check_IfExpression(o)
     rvalue(o.test)
   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
 
   def check_LambdaExpression(o)
     internal_check_capture_last(o)
   end
 
   def check_LiteralList(o)
     o.values.each {|v| rvalue(v) }
   end
 
   def check_LiteralFloat(o)
     migration_checker.report_ambiguous_float(o)
   end
 
   def check_LiteralInteger(o)
     migration_checker.report_ambiguous_integer(o)
   end
 
   def check_NodeDefinition(o)
     # Check that hostnames are valid hostnames (or regular expressions)
     hostname(o.host_matches, o)
     hostname(o.parent, o, 'parent') unless o.parent.nil?
     top(o.eContainer, o)
     if violator = ends_with_idem(o.body)
       acceptor.accept(Issues::IDEM_NOT_ALLOWED_LAST, violator, {:container => o})
     end
     unless o.parent.nil?
       acceptor.accept(Issues::ILLEGAL_NODE_INHERITANCE, o.parent)
     end
   end
 
   # No checking takes place - all expressions using a QualifiedName need to check. This because the
   # rules are slightly different depending on the container (A variable allows a numeric start, but not
   # other names). This means that (if the lexer/parser so chooses) a QualifiedName
   # can be anything when it represents a Bare Word and evaluates to a String.
   #
   def check_QualifiedName(o)
   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})
     end
   end
 
   def check_QueryExpression(o)
     query(o.expr) if o.expr  # is optional
   end
 
   def relation_Object(o)
     rvalue(o)
   end
 
   def relation_CollectExpression(o); end
 
   def relation_RelationshipExpression(o); end
 
   def check_Parameter(o)
     if o.name =~ /^(?:0x)?[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)
     relation(o.right_expr)
   end
 
   def check_ResourceExpression(o)
     # The expression for type name cannot be statically checked - this is instead done at runtime
     # to enable better error message of the result of the expression rather than the static instruction.
     # (This can be revised as there are static constructs that are illegal, but require updating many
     # tests that expect the detailed reporting).
   end
 
   def check_ResourceBody(o)
     seenUnfolding = false
     o.operations.each do |ao|
       if ao.is_a?(Puppet::Pops::Model::AttributesOperation)
         if seenUnfolding
           acceptor.accept(Issues::MULTIPLE_ATTRIBUTES_UNFOLD, ao)
         else
           seenUnfolding = true
         end
       end
     end
   end
 
   def check_ResourceDefaultsExpression(o)
     if o.form && o.form != :regular
       acceptor.accept(Issues::NOT_VIRTUALIZEABLE, o)
     end
   end
 
   def check_ResourceOverrideExpression(o)
     if o.form && o.form != :regular
       acceptor.accept(Issues::NOT_VIRTUALIZEABLE, o)
     end
   end
 
   def check_ReservedWord(o)
     acceptor.accept(Issues::RESERVED_WORD, o, :word => o.word)
   end
 
   def check_SelectorExpression(o)
     rvalue(o.left_expr)
   end
 
   def check_SelectorEntry(o)
     rvalue(o.matching_expr)
   end
 
   def check_UnaryExpression(o)
     rvalue(o.expr)
   end
 
   def check_UnlessExpression(o)
     rvalue(o.test)
     # TODO: Unless may not have an else part that is an IfExpression (grammar denies this though)
   end
 
   # Checks that variable is either strictly 0, or a non 0 starting decimal number, or a valid VAR_NAME
   def check_VariableExpression(o)
     # The expression must be a qualified name or an integer
     name_expr = o.expr
     return if name_expr.is_a?(Model::LiteralInteger)
     if !name_expr.is_a?(Model::QualifiedName)
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, :feature => 'name', :container => o)
     else
       # name must be either a decimal string value, or a valid NAME
       name = o.expr.value
       if name[0,1] =~ /[0-9]/
         unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
           acceptor.accept(Issues::ILLEGAL_NUMERIC_VAR_NAME, o, :name => name)
         end
       else
         unless name =~ Puppet::Pops::Patterns::VAR_NAME
           acceptor.accept(Issues::ILLEGAL_VAR_NAME, o, :name => name)
         end
       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_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
 
   #--IDEM CHECK
   def idem_Object(o)
     false
   end
 
   def idem_Nop(o)
     true
   end
 
   def idem_NilClass(o)
     true
   end
 
   def idem_Literal(o)
     true
   end
 
   def idem_LiteralList(o)
     true
   end
 
   def idem_LiteralHash(o)
     true
   end
 
   def idem_Factory(o)
     idem(o.current)
   end
 
   def idem_AccessExpression(o)
     true
   end
 
   def idem_BinaryExpression(o)
     true
   end
 
   def idem_RelationshipExpression(o)
     # Always side effect
     false
   end
 
   def idem_AssignmentExpression(o)
     # Always side effect
     false
   end
 
   # Handles UnaryMinusExpression, NotExpression, VariableExpression
   def idem_UnaryExpression(o)
     true
   end
 
   # Allow (no-effect parentheses) to be used around a productive expression
   def idem_ParenthesizedExpression(o)
     idem(o.expr)
   end
 
   def idem_RenderExpression(o)
     false
   end
 
   def idem_RenderStringExpression(o)
     false
   end
 
   def idem_BlockExpression(o)
     # productive if there is at least one productive expression
     ! o.statements.any? {|expr| !idem(expr) }
   end
 
   # Returns true even though there may be interpolated expressions that have side effect.
   # Report as idem anyway, as it is very bad design to evaluate an interpolated string for its
   # side effect only.
   def idem_ConcatenatedString(o)
     true
   end
 
   # Heredoc is just a string, but may contain interpolated string (which may have side effects).
   # This is still bad design and should be reported as idem.
   def idem_HeredocExpression(o)
     true
   end
 
   # May technically have side effects inside the Selector, but this is bad design - treat as idem
   def idem_SelectorExpression(o)
     true
   end
 
   def idem_IfExpression(o)
     [o.test, o.then_expr, o.else_expr].all? {|e| idem(e) }
   end
 
   # Case expression is idem, if test, and all options are idem
   def idem_CaseExpression(o)
     return false if !idem(o.test)
     ! o.options.any? {|opt| !idem(opt) }
   end
 
   # An option is idem if values and the then_expression are idem
   def idem_CaseOption(o)
     return false if o.values.any? { |value| !idem(value) }
     idem(o.then_expr)
   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