puppet 3.6.2 → 3.7.0

data/lib/puppet/pops/evaluator/callable_signature.rb

@@ -41,7 +41,7 @@ class Puppet::Pops::Evaluator::CallableSignature
   # or Optional[Variant[Callable, ...]]. The Variant type is used when multiple signatures are acceptable.
   # The Optional type is used when the block is optional.
   #
-  # @return [Puppet::Pops::Types::PAbstractType, nil] the expected type of a block given as the last parameter in a call.
+  # @return [Puppet::Pops::Types::PAnyType, nil] the expected type of a block given as the last parameter in a call.
   #
   # @api public
   #
@@ -97,5 +97,4 @@ class Puppet::Pops::Evaluator::CallableSignature
   def infinity?(x)
     x == Puppet::Pops::Types::INFINITY
   end
-
 end

data/lib/puppet/pops/evaluator/closure.rb

@@ -30,46 +30,88 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
   # compatible with 3x AST::Lambda
   # @api public
   def call(scope, *args)
-    @evaluator.call(self, args, @enclosing_scope)
+    variable_bindings = combine_values_with_parameters(args)
+
+    tc = Puppet::Pops::Types::TypeCalculator
+    final_args = tc.infer_set(parameters.inject([]) do |final_args, param|
+      if param.captures_rest
+        final_args.concat(variable_bindings[param.name])
+      else
+        final_args << variable_bindings[param.name]
+      end
+    end)
+
+    if tc.callable?(type, final_args)
+      @evaluator.evaluate_block_with_bindings(@enclosing_scope, variable_bindings, @model.body)
+    else
+      raise ArgumentError, "lambda called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string('lambda', final_args, [self])}"
+    end
   end
 
   # Call closure with argument assignment by name
-  def call_by_name(scope, args_hash, spill_over = false)
-    @evaluator.call_by_name(self, args_hash, @enclosing_scope, spill_over)
+  def call_by_name(scope, args_hash, enforce_parameters)
+    if enforce_parameters
+      if args_hash.size > parameters.size
+        raise ArgumentError, "Too many arguments: #{args_hash.size} for #{parameters.size}"
+      end
+
+      # associate values with parameters
+      scope_hash = {}
+      parameters.each do |p|
+        name = p.name
+        if (arg_value = args_hash[name]).nil?
+          # only set result of default expr if it is defined (it is otherwise not possible to differentiate
+          # between explicit undef and no default expression
+          unless p.value.nil?
+            scope_hash[name] = @evaluator.evaluate(p.value, @enclosing_scope)
+          end
+        else
+          scope_hash[name] = arg_value
+        end
+      end
+
+      missing = parameters.select { |p| !scope_hash.include?(p.name) }
+      if missing.any?
+        raise ArgumentError, "Too few arguments; no value given for required parameters #{missing.collect(&:name).join(" ,")}"
+      end
+
+      tc = Puppet::Pops::Types::TypeCalculator
+      final_args = tc.infer_set(parameter_names.collect { |param| scope_hash[param] })
+      if !tc.callable?(type, final_args)
+        raise ArgumentError, "lambda called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string('lambda', final_args, [self])}"
+      end
+    else
+      scope_hash = args_hash
+    end
+
+    @evaluator.evaluate_block_with_bindings(@enclosing_scope, scope_hash, @model.body)
   end
 
-  # incompatible with 3x except that it is an array of the same size
-  def parameters()
-    @model.parameters || []
+  def parameters
+    @model.parameters
   end
 
   # Returns the number of parameters (required and optional)
   # @return [Integer] the total number of accepted parameters
   def parameter_count
     # yes, this is duplication of code, but it saves a method call
-    (@model.parameters || []).size
-  end
-
-  # Returns the number of optional parameters.
-  # @return [Integer] the number of optional accepted parameters
-  def optional_parameter_count
-    @model.parameters.count { |p| !p.value.nil? }
+    @model.parameters.size
   end
 
   # @api public
   def parameter_names
-    @model.parameters.collect {|p| p.name }
+    @model.parameters.collect(&:name)
   end
 
   # @api public
   def type
-    @callable || create_callable_type
+    @callable ||= create_callable_type
   end
 
   # @api public
   def last_captures_rest?
-    # TODO: No support for this yet
-    false
+    last = @model.parameters[-1]
+    last && last.captures_rest
   end
 
   # @api public
@@ -80,28 +122,99 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
 
   private
 
+  def combine_values_with_parameters(args)
+    variable_bindings = {}
+
+    parameters.each_with_index do |parameter, index|
+      param_captures     = parameter.captures_rest
+      default_expression = parameter.value
+
+      if index >= args.size
+        if default_expression
+          # not given, has default
+          value = @evaluator.evaluate(default_expression, @enclosing_scope)
+          if param_captures && !value.is_a?(Array)
+            # correct non array default value
+            value = [value]
+          end
+        else
+          # not given, does not have default
+          if param_captures
+            # default for captures rest is an empty array
+            value = []
+          else
+            @evaluator.fail(Puppet::Pops::Issues::MISSING_REQUIRED_PARAMETER, parameter, { :param_name => parameter.name })
+          end
+        end
+      else
+        given_argument = args[index]
+        if param_captures
+          # get excess arguments
+          value = args[(parameter_count-1)..-1]
+          # If the input was a single nil, or undef, and there is a default, use the default
+          # This supports :undef in case it was used in a 3x data structure and it is passed as an arg
+          #
+          if value.size == 1 && (given_argument.nil? || given_argument == :undef) && default_expression
+            value = @evaluator.evaluate(default_expression, scope)
+            # and ensure it is an array
+            value = [value] unless value.is_a?(Array)
+          end
+        else
+          value = given_argument
+        end
+      end
+
+      variable_bindings[parameter.name] = value
+    end
+
+    variable_bindings
+  end
+
   def create_callable_type()
-    t = Puppet::Pops::Types::PCallableType.new()
-    tuple_t = Puppet::Pops::Types::PTupleType.new()
-    # since closure lambdas are currently untyped, each parameter becomes Optional[Object]
-    parameter_names.each do |name|
-      # TODO: Change when Closure supports typed parameters
-      tuple_t.addTypes(Puppet::Pops::Types::TypeFactory.optional_object())
+    types = []
+    range = [0, 0]
+    in_optional_parameters = false
+    parameters.each do |param|
+      type = if param.type_expr
+               @evaluator.evaluate(param.type_expr, @enclosing_scope)
+             else
+               Puppet::Pops::Types::TypeFactory.any()
+             end
+
+      if param.captures_rest && type.is_a?(Puppet::Pops::Types::PArrayType)
+        # An array on a slurp parameter is how a size range is defined for a
+        # slurp (Array[Integer, 1, 3] *$param). However, the callable that is
+        # created can't have the array in that position or else type checking
+        # will require the parameters to be arrays, which isn't what is
+        # intended. The array type contains the intended information and needs
+        # to be unpacked.
+        param_range = type.size_range
+        type = type.element_type
+      elsif param.captures_rest && !type.is_a?(Puppet::Pops::Types::PArrayType)
+        param_range = ANY_NUMBER_RANGE
+      elsif param.value
+        param_range = OPTIONAL_SINGLE_RANGE
+      else
+        param_range = REQUIRED_SINGLE_RANGE
+      end
+
+      types << type
+
+      if param_range[0] == 0
+        in_optional_parameters = true
+      elsif param_range[0] != 0 && in_optional_parameters
+        @evaluator.fail(Puppet::Pops::Issues::REQUIRED_PARAMETER_AFTER_OPTIONAL, param, { :param_name => param.name })
+      end
+
+      range[0] += param_range[0]
+      range[1] += param_range[1]
     end
 
-    # TODO: A Lambda can not currently declare varargs
-    to = parameter_count
-    from = to - optional_parameter_count
-    if from != to
-      size_t = Puppet::Pops::Types::PIntegerType.new()
-      size_t.from = size
-      size_t.to = size
-      tuple_t.size_type = size_t
+    if range[1] == Puppet::Pops::Types::INFINITY
+      range[1] = :default
     end
-    t.param_types = tuple_t
-    # TODO: A Lambda can not currently declare that it accepts a lambda, except as an explicit parameter
-    # being a Callable
-    t
+
+    Puppet::Pops::Types::TypeFactory.callable(*(types + range))
   end
 
   # Produces information about parameters compatible with a 4x Function (which can have multiple signatures)
@@ -109,4 +222,7 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
     [ self ]
   end
 
+  ANY_NUMBER_RANGE = [0, Puppet::Pops::Types::INFINITY]
+  OPTIONAL_SINGLE_RANGE = [0, 1]
+  REQUIRED_SINGLE_RANGE = [1, 1]
 end

data/lib/puppet/pops/evaluator/compare_operator.rb

@@ -9,10 +9,15 @@
 class Puppet::Pops::Evaluator::CompareOperator
   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
+
   def initialize
     @@equals_visitor  ||= Puppet::Pops::Visitor.new(self, "equals", 1, 1)
     @@compare_visitor ||= Puppet::Pops::Visitor.new(self, "cmp", 1, 1)
-    @@include_visitor ||= Puppet::Pops::Visitor.new(self, "include", 1, 1)
+    @@include_visitor ||= Puppet::Pops::Visitor.new(self, "include", 2, 2)
     @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
   end
 
@@ -27,8 +32,8 @@ class Puppet::Pops::Evaluator::CompareOperator
   end
 
   # Answers is b included in a
-  def include?(a, b)
-    @@include_visitor.visit_this_1(self, a, b)
+  def include?(a, b, scope)
+    @@include_visitor.visit_this_2(self, a, b, scope)
   end
 
   protected
@@ -110,50 +115,49 @@ class Puppet::Pops::Evaluator::CompareOperator
   end
 
   def equals_NilClass(a, b)
+    # :undef supported in case it is passed from a 3x data structure
     b.nil? || b == :undef
   end
 
   def equals_Symbol(a, b)
+    # :undef supported in case it is passed from a 3x data structure
     a == b || a == :undef && b.nil?
   end
 
-  def include_Object(a, b)
+  def include_Object(a, b, scope)
     false
   end
 
-  def include_String(a, b)
+  def include_String(a, b, scope)
     case b
     when String
       # subsstring search downcased
       a.downcase.include?(b.downcase)
     when Regexp
-      # match (convert to boolean)
-      !!(a =~ b)
+      matched = a.match(b)           # nil, or MatchData
+      set_match_data(matched, scope) # creates ephemeral
+      !!matched                      # match (convert to boolean)
     when Numeric
       # convert string to number, true if ==
       equals(a, b)
-    when Puppet::Pops::Types::PStringType
-      # is there a string in a string? (yes, each char is a string, and an empty string contains an empty string)
-      true
     else
-      if b == Puppet::Pops::Types::PDataType || b == Puppet::Pops::Types::PObjectType
-        # A String is Data and Object (but not of all subtypes of those types).
-        true
-      else
-        false
-      end
+      false
     end
   end
 
-  def include_Array(a, b)
+  def include_Array(a, b, scope)
     case b
     when Regexp
+      matched = nil
       a.each do |element|
         next unless element.is_a? String
-        return true if element =~ b
+        matched = element.match(b) # nil, or MatchData
+        break if matched
       end
-      return false
-    when Puppet::Pops::Types::PAbstractType
+      # Always set match data, a "not found" should not keep old match data visible
+      set_match_data(matched, scope) # creates ephemeral
+      return !!matched
+    when Puppet::Pops::Types::PAnyType
       a.each {|element| return true if @type_calculator.instance?(b, element) }
       return false
     else
@@ -162,7 +166,7 @@ class Puppet::Pops::Evaluator::CompareOperator
     end
   end
 
-  def include_Hash(a, b)
-    include?(a.keys, b)
+  def include_Hash(a, b, scope)
+    include?(a.keys, b, scope)
   end
 end

data/lib/puppet/pops/evaluator/epp_evaluator.rb

@@ -3,14 +3,14 @@
 class Puppet::Pops::Evaluator::EppEvaluator
 
   def self.inline_epp(scope, epp_source, template_args = nil)
-    unless epp_source.is_a? String
+    unless epp_source.is_a?(String)
       raise ArgumentError, "inline_epp(): the first argument must be a String with the epp source text, got a #{epp_source.class}"
     end
 
     # Parse and validate the source
     parser = Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.new
     begin
-    result = parser.parse_string(epp_source, 'inlined-epp-text')
+      result = parser.parse_string(epp_source, 'inlined-epp-text')
     rescue Puppet::ParseError => e
       raise ArgumentError, "inline_epp(): Invalid EPP: #{e.message}"
     end
@@ -20,7 +20,7 @@ class Puppet::Pops::Evaluator::EppEvaluator
   end
 
   def self.epp(scope, file, env_name, template_args = nil)
-    unless file.is_a? String
+    unless file.is_a?(String)
       raise ArgumentError, "epp(): the first argument must be a String with the filename, got a #{file.class}"
     end
 
@@ -34,7 +34,7 @@ class Puppet::Pops::Evaluator::EppEvaluator
     # Parse and validate the source
     parser = Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.new
     begin
-    result = parser.parse_file(template_file)
+      result = parser.parse_file(template_file)
     rescue Puppet::ParseError => e
       raise ArgumentError, "epp(): Invalid EPP: #{e.message}"
     end
@@ -59,18 +59,19 @@ class Puppet::Pops::Evaluator::EppEvaluator
       raise ArgumentError, "#{func_name}(): The EPP template contains illegal expressions (definitions)"
     end
 
-    see_scope = body.body.see_scope
-    if see_scope && !template_args_set
-      # no epp params and no arguments were given => inline_epp logic sees all local variables, epp all global
-      closure_scope =  use_global_scope_only ? scope.find_global_scope : scope
-      spill_over = false
-    else
-      # no epp params or user provided arguments in a hash, epp logic only sees global + what was given
+    parameters_specified = body.body.parameters_specified
+    if parameters_specified || template_args_set
+      # no epp params or user provided arguments in a hash, epp() logic
+      # only sees global + what was given
       closure_scope = scope.find_global_scope
-      # given spill over if there are no params (e.g. replace closure scope by a new scope with the given args)
-      spill_over = see_scope
+      enforce_parameters = parameters_specified
+    else
+      # no epp params and no arguments were given => inline_epp() logic
+      # sees all local variables, epp() all global
+      closure_scope =  use_global_scope_only ? scope.find_global_scope : scope
+      enforce_parameters = true
     end
-    evaluated_result = parser.closure(body, closure_scope).call_by_name(scope, template_args, spill_over)
+    evaluated_result = parser.closure(body, closure_scope).call_by_name(scope, template_args, enforce_parameters)
     evaluated_result
   end
 
@@ -84,4 +85,4 @@ class Puppet::Pops::Evaluator::EppEvaluator
       [template_args, true]
     end
   end
-end
+end

data/lib/puppet/pops/evaluator/evaluator_impl.rb

@@ -34,6 +34,8 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # 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).
@@ -41,7 +43,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   Issues = Puppet::Pops::Issues
 
   def initialize
-    @@eval_visitor   ||= Puppet::Pops::Visitor.new(self, "eval", 1, 1)
+    @@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)
@@ -61,23 +63,14 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     @@type_calculator
   end
 
-  # Polymorphic evaluate - calls eval_TYPE
+  # Evaluates the given _target_ object in the given scope.
   #
-  # ## Polymorphic evaluate
-  # Polymorphic evaluate calls a method on the format eval_TYPE where classname is the last
-  # part of the class of the given _target_. A search is performed starting with the actual class, continuing
-  # with each of the _target_ class's super classes until a matching method is found.
-  #
-  # # Description
-  # Evaluates the given _target_ object in the given scope, optionally passing a block which will be
-  # called with the result of the evaluation.
-  #
-  # @overload evaluate(target, scope, {|result| block})
+  # @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
+  # @api public
   #
   def evaluate(target, scope)
     begin
@@ -96,152 +89,56 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     end
   end
 
-  # Polymorphic assign - calls assign_TYPE
-  #
-  # ## Polymorphic assign
-  # Polymorphic assign calls a method on the format assign_TYPE where TYPE is the last
-  # part of the class of the given _target_. A search is performed starting with the actual class, continuing
-  # with each of the _target_ class's super classes until a matching method is found.
-  #
-  # # Description
   # 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
+  # @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
 
-  # Call a closure matching arguments by name - Can only be called with a Closure (for now), may be refactored later
-  # to also handle other types of calls (function calls are also handled by CallNamedFunction and CallMethod, they
-  # could create similar objects to Closure, wait until other types of defines are instantiated - they may behave
-  # as special cases of calls - i.e. 'new').
+  # Evaluate a BlockExpression in a new scope with variables bound to the
+  # given values.
   #
-  # Call by name supports a "spill_over" mode where extra arguments in the given args_hash are introduced
-  # as variables in the resulting scope.
+  # @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
   #
-  # @raise ArgumentError, if there are to many or too few arguments
-  # @raise ArgumentError, if given closure is not a Puppet::Pops::Evaluator::Closure
-  #
-  def call_by_name(closure, args_hash, scope, spill_over = false)
-    raise ArgumentError, "Can only call a Lambda" unless closure.is_a?(Puppet::Pops::Evaluator::Closure)
-    pblock = closure.model
-    parameters = pblock.parameters || []
-
-    if !spill_over && args_hash.size > parameters.size
-      raise ArgumentError, "Too many arguments: #{args_hash.size} for #{parameters.size}" 
-    end
-
-    # associate values with parameters
-    scope_hash = {}
-    parameters.each do |p|
-      scope_hash[p.name] = args_hash[p.name] || evaluate(p.value, scope)
-    end
-    missing = scope_hash.reduce([]) {|memo, entry| memo << entry[0] if entry[1].nil?; memo }
-    unless missing.empty?
-      optional = parameters.count { |p| !p.value.nil? }
-      raise ArgumentError, "Too few arguments; no value given for required parameters #{missing.join(" ,")}"
-    end
-    if spill_over
-      # all args from given hash should be used, nil entries replaced by default values should win
-      scope_hash = args_hash.merge(scope_hash)
-    end
-
-    # Store the evaluated name => value associations in a new inner/local/ephemeral scope
-    # (This is made complicated due to the fact that the implementation of scope is overloaded with
-    # functionality and an inner ephemeral scope must be used (as opposed to just pushing a local scope
-    # on a scope "stack").
-
-    # Ensure variable exists with nil value if error occurs.
-    # Some ruby implementations does not like creating variable on return
-    result = nil
-    begin
-      scope_memo = get_scope_nesting_level(scope)
-      # 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(scope_hash, scope)
-      result = evaluate(pblock.body, scope)
-    ensure
-      set_scope_nesting_level(scope, scope_memo)
-    end
-    result
-  end
-
-  # Call a closure - Can only be called with a Closure (for now), may be refactored later
-  # to also handle other types of calls (function calls are also handled by CallNamedFunction and CallMethod, they
-  # could create similar objects to Closure, wait until other types of defines are instantiated - they may behave
-  # as special cases of calls - i.e. 'new')
-  #
-  # @raise ArgumentError, if there are to many or too few arguments
-  # @raise ArgumentError, if given closure is not a Puppet::Pops::Evaluator::Closure
+  # @api private
   #
-  def call(closure, args, scope)
-    raise ArgumentError, "Can only call a Lambda" unless closure.is_a?(Puppet::Pops::Evaluator::Closure)
-    pblock = closure.model
-    parameters = pblock.parameters || []
-
-    raise ArgumentError, "Too many arguments: #{args.size} for #{parameters.size}" unless args.size <= parameters.size
-
-    # associate values with parameters
-    merged = parameters.zip(args)
-    # calculate missing arguments
-    missing = parameters.slice(args.size, parameters.size - args.size).select {|p| p.value.nil? }
-    unless missing.empty?
-      optional = parameters.count { |p| !p.value.nil? }
-      raise ArgumentError, "Too few arguments; #{args.size} for #{optional > 0 ? ' min ' : ''}#{parameters.size - optional}"
-    end
-
-    evaluated = merged.collect do |m|
-      # m can be one of
-      # m = [Parameter{name => "name", value => nil], "given"]
-      #   | [Parameter{name => "name", value => Expression}, "given"]
-      #
-      # "given" is always an optional entry. If a parameter was provided then
-      # the entry will be in the array, otherwise the m array will be a
-      # single element.
-      given_argument = m[1]
-      argument_name = m[0].name
-      default_expression = m[0].value
-
-      value = if default_expression
-        evaluate(default_expression, scope)
-      else
-        given_argument
-      end
-      [argument_name, value]
-    end
-
-    # Store the evaluated name => value associations in a new inner/local/ephemeral scope
-    # (This is made complicated due to the fact that the implementation of scope is overloaded with
-    # functionality and an inner ephemeral scope must be used (as opposed to just pushing a local scope
-    # on a scope "stack").
-
-    # Ensure variable exists with nil value if error occurs. 
-    # Some ruby implementations does not like creating variable on return
-    result = nil
-    begin
-      scope_memo = get_scope_nesting_level(scope)
-      # 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(Hash[evaluated], scope)
-      result = evaluate(pblock.body, scope)
-    ensure
-      set_scope_nesting_level(scope, scope_memo)
+  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
-    result
   end
 
   protected
@@ -294,17 +191,12 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     o
   end
 
-  # Allows nil to be used as a Nop.
-  # Evaluates to nil
-  # TODO: What is the difference between literal undef, nil, and nop?
-  #
+  # Allows nil to be used as a Nop, Evaluates to nil
   def eval_NilClass(o, scope)
     nil
   end
 
   # Evaluates Nop to nil.
-  # TODO: or is this the same as :undef
-  # TODO: is this even needed as a separate instruction when there is a literal undef?
   def eval_Nop(o, scope)
     nil
   end
@@ -315,12 +207,18 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     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)
-    :undef # TODO: or just use nil for this?
+    nil
   end
 
   # A QualifiedReference (i.e. a  capitalized qualified name such as Foo, or Foo::Bar) evaluates to a PType
@@ -337,6 +235,19 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     - coerce_numeric(evaluate(o.expr, scope), o, scope)
   end
 
+  def eval_UnfoldExpression(o, scope)
+    candidate = evaluate(o.expr, scope)
+    case candidate
+    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
@@ -356,41 +267,8 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     name = lvalue(o.left_expr, scope)
     value = evaluate(o.right_expr, scope)
 
-    case o.operator
-    when :'=' # regular assignment
+    if o.operator == :'='
       assign(name, value, o, scope)
-
-    when :'+='
-      # if value does not exist and strict is on, looking it up fails, else it is nil or :undef
-      existing_value = get_variable_value(name, o, scope)
-      begin
-        if existing_value.nil? || existing_value == :undef
-          assign(name, value, o, scope)
-        else
-          # Delegate to calculate function to deal with check of LHS, and perform ´+´ as arithmetic or concatenation the
-          # same way as ArithmeticExpression performs `+`.
-          assign(name, calculate(existing_value, value, :'+', o.left_expr, o.right_expr, scope), o, scope)
-        end
-      rescue ArgumentError => e
-        fail(Issues::APPEND_FAILED, o, {:message => e.message})
-      end
-
-    when :'-='
-      # If an attempt is made to delete values from something that does not exists, the value is :undef (it is guaranteed to not
-      # include any values the user wants deleted anyway :-)
-      #
-      # if value does not exist and strict is on, looking it up fails, else it is nil or :undef
-      existing_value = get_variable_value(name, o, scope)
-      begin
-      if existing_value.nil? || existing_value == :undef
-        assign(name, :undef, o, scope)
-      else
-        # Delegate to delete function to deal with check of LHS, and perform deletion
-        assign(name, delete(get_variable_value(name, o, scope), value), o, scope)
-      end
-      rescue ArgumentError => e
-        fail(Issues::APPEND_FAILED, o, {:message => e.message}, e)
-      end
     else
       fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
     end
@@ -403,7 +281,9 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
   def eval_ArithmeticExpression(o, scope)
-    left, right = eval_BinaryExpression(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
@@ -458,7 +338,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   def eval_EppExpression(o, scope)
     scope["@epp"] = []
     evaluate(o.body, scope)
-    result = scope["@epp"].join('')
+    result = scope["@epp"].join
     result
   end
 
@@ -493,11 +373,12 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # Evaluates <, <=, >, >=, and ==
   #
   def eval_ComparisonExpression o, scope
-    left, right = eval_BinaryExpression o, scope
+    left = evaluate(o.left_expr, scope)
+    right = evaluate(o.right_expr, scope)
 
     begin
     # Left is a type
-    if left.is_a?(Puppet::Pops::Types::PAbstractType)
+    if left.is_a?(Puppet::Pops::Types::PAnyType)
       case o.operator
       when :'=='
         @@type_calculator.equals(left,right)
@@ -548,7 +429,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   end
 
   # Evaluates matching expressions with type, string or regexp rhs expression.
-  # If RHS is a type, the =~ matches compatible (assignable?) type.
+  # If RHS is a type, the =~ matches compatible (instance? of) type.
   #
   # @example
   #   x =~ /abc.*/
@@ -559,21 +440,22 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   #   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, pattern = eval_BinaryExpression o, scope
+    left = evaluate(o.left_expr, scope)
+    pattern = evaluate(o.right_expr, scope)
+
     # matches RHS types as instance of for all types except a parameterized Regexp[R]
-    if pattern.is_a?(Puppet::Pops::Types::PAbstractType)
-      if pattern.is_a?(Puppet::Pops::Types::PRegexpType) && pattern.pattern
-        # A qualified PRegexpType, get its ruby regexp
-        pattern = pattern.regexp
-      else
-        # evaluate as instance?
-        matched = @@type_calculator.instance?(pattern, left)
-        # convert match result to Boolean true, or false
-        return o.operator == :'=~' ? !!matched : !matched
-      end
+    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
@@ -586,7 +468,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     end
 
     matched = pattern.match(left) # nil, or MatchData
-    set_match_data(matched, o, scope) # creates ephemeral
+    set_match_data(matched,scope) # creates ephemeral
 
     # convert match result to Boolean true, or false
     o.operator == :'=~' ? !!matched : !matched
@@ -595,8 +477,9 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # Evaluates Puppet DSL `in` expression
   #
   def eval_InExpression o, scope
-    left, right = eval_BinaryExpression o, scope
-    @@compare_operator.include?(right, left)
+    left = evaluate(o.left_expr, scope)
+    right = evaluate(o.right_expr, scope)
+    @@compare_operator.include?(right, left, scope)
   end
 
   # @example
@@ -616,19 +499,19 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   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
-    o.values.collect {|expr| evaluate(expr, 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
-    h = Hash.new
-    o.entries.each {|entry| h[ evaluate(entry.key, scope)]= evaluate(entry.value, scope)}
-    h
+    # 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
@@ -656,8 +539,17 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       if o.options.find do |co|
         # the first case option that matches
         if co.values.find do |c|
-          the_default = co.then_expr if c.is_a? Puppet::Pops::Model::LiteralDefault
-          is_match?(test, evaluate(c, scope), c, scope)
+          case c
+          when Puppet::Pops::Model::LiteralDefault
+            the_default = co.then_expr
+            is_match?(test, evaluate(c, scope), c, 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, scope) }
+          else
+            is_match?(test, evaluate(c, scope), c, scope)
+          end
         end
         result = evaluate(co.then_expr, scope)
         true # the option was picked
@@ -712,16 +604,123 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     evaluate(o.body, scope)
   end
 
-  # Produces Array[PObjectType], an array of resource references
+  # Produces Array[PAnyType], an array of resource references
   #
   def eval_ResourceExpression(o, scope)
     exported = o.exported
     virtual = o.virtual
-    type_name = evaluate(o.type_name, scope)
-    o.bodies.map do |body|
-      titles = [evaluate(body.title, scope)].flatten
-      evaluated_parameters = body.operations.map {|op| evaluate(op, scope) }
-      create_resources(o, scope, virtual, exported, type_name, titles, evaluated_parameters)
+
+    # 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
 
@@ -732,19 +731,35 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     evaluated_resources
   end
 
-  # Produces 3x array of parameters
+  # 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_name = o.type_ref.value # a QualifiedName's string value
+    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
-    evaluate(o.type_ref, scope)
+    type
   end
 
   # Evaluates function call by name.
@@ -762,7 +777,9 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end
     name = o.functor_expr.value
-    evaluated_arguments = o.arguments.collect {|arg| evaluate(arg, scope) }
+
+    evaluated_arguments = unfold([], o.arguments, scope)
+
     # wrap lambda in a callable block if it is present
     evaluated_arguments << Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope) if o.lambda
     call_function(name, evaluated_arguments, o, scope)
@@ -780,7 +797,10 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end 
     name = name.value # the string function name
-    evaluated_arguments = [receiver] + (o.arguments || []).collect {|arg| evaluate(arg, scope) }
+
+    evaluated_arguments = unfold([receiver], o.arguments || [], scope)
+
+    # wrap lambda in a callable block if it is present
     evaluated_arguments << Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope) if o.lambda
     call_function(name, evaluated_arguments, o, scope)
   end
@@ -794,14 +814,27 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     #
     with_guarded_scope(scope) do
       test = evaluate(o.left_expr, scope)
+      the_default = nil
       selected = o.selectors.find do |s|
-        candidate = evaluate(s.matching_expr, scope)
-        candidate == :default || is_match?(test, candidate, s.matching_expr, scope)
+        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, scope) }
+        else
+          is_match?(test, evaluate(me, scope), me, scope)
+        end
       end
       if selected
         evaluate(selected.value_expr, scope)
+      elsif the_default
+        evaluate(the_default, scope)
       else
-        nil
+        fail(Issues::UNMATCHED_SELECTOR, o.left_expr, :param_value => test)
       end
     end
   end
@@ -851,15 +884,13 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     name = evaluate(o.expr, scope)
 
     # Should be caught by validation, but make this explicit here as well, or mysterious evaluation issues
-    # may occur.
+    # may occur for some evaluation use cases.
     case name
     when String
     when Numeric
     else
       fail(Issues::ILLEGAL_VARIABLE_EXPRESSION, o.expr)
     end
-    # TODO: Check for valid variable name (Task for validator)
-    # TODO: semantics of undefined variable in scope, this just returns what scope does == value or nil
     get_variable_value(name, o, scope)
   end
 
@@ -882,7 +913,6 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   #
   def eval_TextExpression o, scope
     if o.expr.is_a?(Puppet::Pops::Model::QualifiedName)
-      # TODO: formalize, when scope returns nil, vs error
       string(get_variable_value(o.expr.value, o, scope), scope)
     else
       string(evaluate(o.expr, scope), scope)
@@ -894,27 +924,26 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   end
 
   def string_Symbol(o, scope)
-    case o
-    when :undef
-      ''
+    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(', '), ']'].join()
+  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(', '), '}'].join()
+    "{#{o.map {|k,v| "#{string(k, scope)} => #{string(v, scope)}"}.join(COMMA_SEPARATOR)}}"
   end
 
   def string_Regexp(o, scope)
-    ['/', o.source, '/'].join()
+    "/#{o.source}/"
   end
 
-  def string_PAbstractType(o, scope)
+  def string_PAnyType(o, scope)
     @@type_calculator.string(o)
   end
 
@@ -1041,9 +1070,9 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     if right.is_a?(Regexp)
       return false unless left.is_a? String
       matched = right.match(left)
-      set_match_data(matched, o, scope) # creates or clears ephemeral
+      set_match_data(matched, scope) # creates or clears ephemeral
       !!matched # convert to boolean
-    elsif right.is_a?(Puppet::Pops::Types::PAbstractType)
+    elsif right.is_a?(Puppet::Pops::Types::PAnyType)
       # 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).
@@ -1064,4 +1093,23 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     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