puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

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

@@ -68,7 +68,7 @@ class Puppet::Pops::Evaluator::CallableSignature
   end
 
   # Returns the range of required/optional argument values as an array of [min, max], where an infinite
-  # end is given as INFINITY. To test against infinity, use the infinity? method.
+  # end is given as Float::INFINITY. To test against infinity, use the infinity? method.
   #
   # @return [Array[Integer, Numeric]] - an Array with [min, max]
   #
@@ -95,6 +95,6 @@ class Puppet::Pops::Evaluator::CallableSignature
   # @api public
   #
   def infinity?(x)
-    x == Puppet::Pops::Types::INFINITY
+    x == Float::INFINITY
   end
 end

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

@@ -1,13 +1,15 @@
-
 # A Closure represents logic bound to a particular scope.
-# As long as the runtime (basically the scope implementation) has the behaviour of Puppet 3x it is not
-# safe to use this closure when the scope given to it when initialized goes "out of scope".
+# As long as the runtime (basically the scope implementation) has the behavior of Puppet 3x it is not
+# safe to return and later use this closure.
 #
-# Note that the implementation is backwards compatible in that the call method accepts a scope, but this
-# scope is not used.
+# The 3x scope is essentially a named scope with an additional internal local/ephemeral nested scope state.
+# In 3x there is no way to directly refer to the nested scopes, instead, the named scope must be in a particular
+# state. Specifically, closures that require a local/ephemeral scope to exist at a later point will fail.
+# It is safe to call a closure (even with 3x scope) from the very same place it was defined, but not
+# returning it and expecting the closure to reference the scope's state at the point it was created.
 #
 # Note that this class is a CallableSignature, and the methods defined there should be used
-# as the API for obtaining information in a callable implementation agnostic way.
+# as the API for obtaining information in a callable-implementation agnostic way.
 #
 class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignature
   attr_reader :evaluator
@@ -20,24 +22,17 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
     @enclosing_scope = scope
   end
 
-  # marker method checked with respond_to :puppet_lambda
-  # @api private
-  # @deprecated Use the type system to query if an object is of Callable type, then use its signatures method for info
-  def puppet_lambda()
-    true
-  end
-
-  # compatible with 3x AST::Lambda
+  # Evaluates a closure in its enclosing scope after having matched given arguments with parameters (from left to right)
   # @api public
   def call(*args)
     variable_bindings = combine_values_with_parameters(args)
 
     tc = Puppet::Pops::Types::TypeCalculator
-    final_args = tc.infer_set(parameters.inject([]) do |final_args, param|
+    final_args = tc.infer_set(parameters.inject([]) do |tmp_args, param|
       if param.captures_rest
-        final_args.concat(variable_bindings[param.name])
+        tmp_args.concat(variable_bindings[param.name])
       else
-        final_args << variable_bindings[param.name]
+        tmp_args << variable_bindings[param.name]
       end
     end)
 
@@ -49,7 +44,7 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
   end
 
   # Call closure with argument assignment by name
-  def call_by_name(scope, args_hash, enforce_parameters)
+  def call_by_name(args_hash, enforce_parameters)
     if enforce_parameters
       if args_hash.size > parameters.size
         raise ArgumentError, "Too many arguments: #{args_hash.size} for #{parameters.size}"
@@ -155,7 +150,7 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
           # 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)
+            value = @evaluator.evaluate(default_expression, @enclosing_scope)
             # and ensure it is an array
             value = [value] unless value.is_a?(Array)
           end
@@ -210,7 +205,7 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
       range[1] += param_range[1]
     end
 
-    if range[1] == Puppet::Pops::Types::INFINITY
+    if range[1] == Float::INFINITY
       range[1] = :default
     end
 
@@ -222,7 +217,7 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
     [ self ]
   end
 
-  ANY_NUMBER_RANGE = [0, Puppet::Pops::Types::INFINITY]
+  ANY_NUMBER_RANGE = [0, Float::INFINITY]
   OPTIONAL_SINGLE_RANGE = [0, 1]
   REQUIRED_SINGLE_RANGE = [1, 1]
 end

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

@@ -27,7 +27,7 @@ class Puppet::Pops::Evaluator::CollectorTransformer
 
     if !o.operations.empty?
       overrides = {
-        :parameters => o.operations.map{ |x| @@evaluator.evaluate(x, scope)}.flatten,
+        :parameters => o.operations.map{ |x| to_3x_param(x).evaluate(scope)},
         :file       => file_path,
         :line       => [line_num, position],
         :source     => scope.source,
@@ -206,4 +206,14 @@ protected
   def match_Object(o, scope)
     raise ArgumentError, "Cannot transform object of class #{o.class}"
   end
+
+  # Produces (name => expr) or (name +> expr)
+  def to_3x_param(o)
+    bridge = Puppet::Parser::AST::PopsBridge::Expression.new(:value => o.value_expr)
+    args = { :value => bridge }
+    args[:add] = true if o.operator == :'+>'
+    args[:param] = o.attribute_name
+    args= Puppet::Pops::Model::AstTransformer.new().merge_location(args, o)
+    Puppet::Parser::AST::ResourceParam.new(args)
+  end
 end

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

@@ -17,7 +17,6 @@ class Puppet::Pops::Evaluator::CompareOperator
   def initialize
     @@equals_visitor  ||= Puppet::Pops::Visitor.new(self, "equals", 1, 1)
     @@compare_visitor ||= Puppet::Pops::Visitor.new(self, "cmp", 1, 1)
-    @@match_visitor ||= Puppet::Pops::Visitor.new(self, "match", 2, 2)
     @@include_visitor ||= Puppet::Pops::Visitor.new(self, "include", 2, 2)
     @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
   end
@@ -32,11 +31,6 @@ class Puppet::Pops::Evaluator::CompareOperator
     @@compare_visitor.visit_this_1(self, a, b)
   end
 
-  # Performs a match of a and b, and returns true if b matches a
-  def match(a, b, scope)
-    @@match_visitor.visit_this_2(self, b, a, scope)
-  end
-
   # Answers is b included in a
   def include?(a, b, scope)
     @@include_visitor.visit_this_2(self, a, b, scope)
@@ -155,41 +149,4 @@ class Puppet::Pops::Evaluator::CompareOperator
   def include_Hash(a, b, scope)
     include?(a.keys, b, scope)
   end
-
-  # Matches in general by using == operator
-  def match_Object(pattern, a, scope)
-    equals(a, pattern)
-  end
-
-  # Matches only against strings
-  def match_Regexp(regexp, left, scope)
-    return false unless left.is_a? String
-    matched = regexp.match(left)
-    set_match_data(matched, scope) # creates or clears ephemeral
-    !!matched # convert to boolean
-  end
-
-  def match_PAnyType(any_type, left, scope)
-    # 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?(any_type, left)
-  end
-
-  def match_Array(array, left, scope)
-    return false unless left.is_a?(Array)
-    return false unless left.length == array.length
-    array.each_with_index.all? { | pattern, index| match(left[index], pattern, scope) }
-  end
-
-  def match_Hash(hash, left, scope)
-    return false unless left.is_a?(Hash)
-    hash.all? {|x,y| match(left[x], y, scope) }
-  end
-
-  def match_Symbol(symbol, left, scope)
-    return true if symbol == :default
-    equals(left, default, scope)
-  end
 end

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

@@ -71,7 +71,7 @@ class Puppet::Pops::Evaluator::EppEvaluator
       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, enforce_parameters)
+    evaluated_result = parser.closure(body, closure_scope).call_by_name(template_args, enforce_parameters)
     evaluated_result
   end
 

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

@@ -30,10 +30,6 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   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
 
@@ -53,9 +49,6 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
 
     @@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() })
   end
 
   # @api private
@@ -77,43 +70,14 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       @@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.
-      #
+      # a raised issue may not know the semantic target
       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
+    rescue StandardError => e
+      if e.is_a? Puppet::ParseError
+        # ParseError's are supposed to be fully configured with location information
         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
@@ -239,11 +203,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # Reserved Words fail to evaluate
   #
   def eval_ReservedWord(o, scope)
-    if !o.future
-      fail(Puppet::Pops::Issues::RESERVED_WORD, o, {:word => o.word})
-    else
-      o.word
-    end
+    fail(Puppet::Pops::Issues::RESERVED_WORD, o, {:word => o.word})
   end
 
   def eval_LiteralDefault(o, scope)
@@ -261,7 +221,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   end
 
   def eval_NotExpression(o, scope)
-    ! is_true?(evaluate(o.expr, scope), o.expr)
+    ! is_true?(evaluate(o.expr, scope))
   end
 
   def eval_UnaryMinusExpression(o, scope)
@@ -363,7 +323,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       rescue ZeroDivisionError => e
         fail(Issues::DIV_BY_ZERO, right_o)
       end
-      if result == INFINITY || result == -INFINITY
+      if result == Float::INFINITY || result == -Float::INFINITY
         fail(Issues::RESULT_IS_INFINITY, left_o, {:operator => operator})
       end
       result
@@ -411,19 +371,14 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     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 :'<'
@@ -444,10 +399,8 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     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
@@ -492,8 +445,6 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     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
@@ -523,8 +474,6 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   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
 
@@ -533,7 +482,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # 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
+    is_true?(evaluate(o.left_expr, scope)) ? is_true?(evaluate(o.right_expr, scope)) : false
   end
 
   # @example
@@ -541,7 +490,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # 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)
+    is_true?(evaluate(o.left_expr, scope)) ? true : is_true?(evaluate(o.right_expr, scope))
   end
 
   # Evaluates each entry of the literal list and creates a new Array
@@ -580,24 +529,21 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     #
     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|
-          c = unwind_parentheses(c)
           case c
           when Puppet::Pops::Model::LiteralDefault
             the_default = co.then_expr
-            next false
+            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, co, scope) }
+            evaluate(c, scope).any? {|v| is_match?(test, v, c, scope) }
           else
-            is_match?(test, evaluate(c, scope), c, co, scope)
+            is_match?(test, evaluate(c, scope), c, scope)
           end
         end
         result = evaluate(co.then_expr, scope)
@@ -821,13 +767,13 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     unless o.functor_expr.is_a? Puppet::Pops::Model::NamedAccessExpression
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function accessor', :container => o})
     end
-    receiver = unfold([], [o.functor_expr.left_expr], scope)
+    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 
+    end
     name = name.value # the string function name
-    call_function_with_block(name, unfold(receiver, o.arguments || [], scope), o, scope)
+    call_function_with_block(name, unfold([receiver], o.arguments || [], scope), o, scope)
   end
 
   def call_function_with_block(name, evaluated_arguments, o, scope)
@@ -835,75 +781,11 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       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))
+      call_function(name, evaluated_arguments, o, scope, &Puppet::Pops::Evaluator::PuppetProc.new(closure) { |*args| closure.call(*args) })
     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 }
   #
@@ -913,11 +795,9 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     #
     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 = unwind_parentheses(s.matching_expr)
+        me = s.matching_expr
         case me
         when Puppet::Pops::Model::LiteralDefault
           the_default = s.value_expr
@@ -925,9 +805,9 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
         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) }
+          evaluate(me, scope).any? {|v| is_match?(test, v, me, scope) }
         else
-          is_match?(test, evaluate(me, scope), me, s, scope)
+          is_match?(test, evaluate(me, scope), me, scope)
         end
       end
       if selected
@@ -955,7 +835,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # Evaluates Puppet DSL `if`
   def eval_IfExpression o, scope
     with_guarded_scope(scope) do
-      if is_true?(evaluate(o.test, scope), o.test)
+      if is_true?(evaluate(o.test, scope))
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
@@ -966,7 +846,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # Evaluates Puppet DSL `unless`
   def eval_UnlessExpression o, scope
     with_guarded_scope(scope) do
-      unless is_true?(evaluate(o.test, scope), o.test)
+      unless is_true?(evaluate(o.test, scope))
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
@@ -1167,12 +1047,22 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # 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?(Puppet::Pops::Types::PAnyType)
-      @migration_checker.report_uc_bareword_type(right, o)
+  def is_match? left, right, o, scope
+    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)
+      # 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
-    @@compare_operator.match(left, right, scope)
   end
 
   def with_guarded_scope(scope)
@@ -1193,7 +1083,6 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   #
   def unfold(result, array, scope)
     array.each do |x|
-      x = unwind_parentheses(x)
       if x.is_a?(Puppet::Pops::Model::UnfoldExpression)
         result.concat(evaluate(x, scope))
       else
@@ -1204,9 +1093,4 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   end
   private :unfold
 
-  def unwind_parentheses(o)
-    return o unless o.is_a?(Puppet::Pops::Model::ParenthesizedExpression)
-    unwind_parentheses(o.expr)
-  end
-  private :unwind_parentheses
 end