puppet 3.8.7 → 4.0.0

data/lib/puppet/pops/types/type_factory.rb

@@ -2,9 +2,9 @@
 # @api public
 #
 module Puppet::Pops::Types::TypeFactory
+  @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
+
   Types = Puppet::Pops::Types
-  @type_calculator = Types::TypeCalculator.singleton
-  @undef_t = Types::PUndefType.new
 
   # Produces the Integer type
   # @api public
@@ -17,9 +17,6 @@ module Puppet::Pops::Types::TypeFactory
   # @api public
   #
   def self.range(from, to)
-    # NOTE! Do not merge the following line to 4.x. It has the same check in the initialize method
-    raise ArgumentError, "'from' must be less or equal to 'to'. Got (#{from}, #{to}" if from.is_a?(Numeric) && to.is_a?(Numeric) && from > to
-
     t = Types::PIntegerType.new()
     # optimize eq with symbol (faster when it is left)
     t.from = from unless (:default == from || from == 'default')
@@ -31,9 +28,6 @@ module Puppet::Pops::Types::TypeFactory
   # @api public
   #
   def self.float_range(from, to)
-    # NOTE! Do not merge the following line to 4.x. It has the same check in the initialize method
-    raise ArgumentError, "'from' must be less or equal to 'to'. Got (#{from}, #{to}" if from.is_a?(Numeric) && to.is_a?(Numeric) && from > to
-
     t = Types::PFloatType.new()
     # optimize eq with symbol (faster when it is left)
     t.from = Float(from) unless :default == from || from.nil?
@@ -72,17 +66,9 @@ module Puppet::Pops::Types::TypeFactory
   end
 
   # Produces the Optional type, i.e. a short hand for Variant[T, Undef]
-  # If the given 'optional_type' argument is a String, then it will be
-  # converted into a String type that represents that string.
-  #
-  # @param optional_type [String,PAnyType,nil] the optional type
-  # @return [POptionalType] the created type
-  #
-  # @api public
-  #
   def self.optional(optional_type = nil)
     t = Types::POptionalType.new
-    t.optional_type = optional_type.is_a?(String) ? string(optional_type) : type_of(optional_type)
+    t.optional_type = type_of(optional_type)
     t
   end
 
@@ -100,53 +86,24 @@ module Puppet::Pops::Types::TypeFactory
   #
   def self.variant(*types)
     t = Types::PVariantType.new()
-    types.each {|v| t.addTypes(type_of(v)) }
+    t.types = types.map {|v| type_of(v) }
     t
   end
 
   # Produces the Struct type, either a non parameterized instance representing
-  # all structs (i.e. all hashes) or a hash with entries where the key is
-  # either a literal String, an Enum with one entry, or a String representing exactly one value.
-  # The key type may also be wrapped in a NotUndef or an Optional.
-  #
-  # The value can be a ruby class, a String (interpreted as the name of a ruby class) or
-  # a Type.
-  #
-  # @param hash [Hash<Object, Object>] key => value hash
-  # @return [PStructType] the created Struct type
+  # all structs (i.e. all hashes) or a hash with a given set of keys of String
+  # type (names), bound to a value of a given type. Type may be a Ruby Class, a
+  # Puppet Type, or an instance from which the type is inferred.
   #
-  def self.struct(hash = {})
-    tc = @type_calculator
+  def self.struct(name_type_hash = {})
     t = Types::PStructType.new
-    t.elements = hash.map do |key_type, value_type|
-      value_type = type_of(value_type)
-      raise ArgumentError, 'Struct element value_type must be a Type' unless value_type.is_a?(Types::PAnyType)
-
-      # TODO: Should have stricter name rule
-      if key_type.is_a?(String)
-        raise ArgumentError, 'Struct element key cannot be an empty String' if key_type.empty?
-        key_type = string(key_type)
-        # Must make key optional if the value can be Undef
-        key_type = optional(key_type) if tc.assignable?(value_type, @undef_t)
-      else
-        # assert that the key type is one of String[1], NotUndef[String[1]] and Optional[String[1]]
-        case key_type
-        when Types::PNotUndefType
-          # We can loose the NotUndef wrapper here since String[1] isn't optional anyway
-          key_type = key_type.type
-          s = key_type
-        when Types::POptionalType
-          s = key_type.optional_type
-        else
-          s = key_type
-        end
-        unless (s.is_a?(Puppet::Pops::Types::PStringType) || s.is_a?(Puppet::Pops::Types::PEnumType)) && s.values.size == 1 && !s.values[0].empty?
-          raise ArgumentError, 'Unable to extract a non-empty literal string from Struct member key type' if key_type.empty?
-        end
-      end
+    t.elements = name_type_hash.map do |name, type|
       elem = Types::PStructElement.new
-      elem.key_type = key_type
-      elem.value_type = value_type
+      if name.is_a?(String) && name.empty?
+        raise ArgumentError, "An empty String can not be used where a String[1, default] is expected"
+      end
+      elem.name = name
+      elem.type = type_of(type)
       elem
     end
     t
@@ -154,7 +111,7 @@ module Puppet::Pops::Types::TypeFactory
 
   def self.tuple(*types)
     t = Types::PTupleType.new
-    types.each {|elem| t.addTypes(type_of(elem)) }
+    t.types = types.map {|elem| type_of(elem) }
     t
   end
 
@@ -394,22 +351,6 @@ module Puppet::Pops::Types::TypeFactory
     type
   end
 
-  # Produces a type for NotUndef[T]
-  # The given 'inst_type' can be a string in which case it will be converted into
-  # the type String[inst_type].
-  #
-  # @param inst_type [Type,String] the type to qualify
-  # @return [Puppet::Pops::Types::PNotUndefType] the NotUndef type
-  #
-  # @api public
-  #
-  def self.not_undef(inst_type = nil)
-    type = Types::PNotUndefType.new()
-    inst_type = string(inst_type) if inst_type.is_a?(String)
-    type.type = inst_type
-    type
-  end
-
   # Produces a type for Type[T]
   # @api public
   #

data/lib/puppet/pops/types/type_parser.rb

@@ -13,7 +13,6 @@ class Puppet::Pops::Types::TypeParser
   def initialize
     @parser = Puppet::Pops::Parser::Parser.new()
     @type_transformer = Puppet::Pops::Visitor.new(nil, "interpret", 0, 0)
-    @undef_t = TYPES.undef
   end
 
   # Produces a *puppet type* based on the given string.
@@ -164,9 +163,6 @@ class Puppet::Pops::Types::TypeParser
     when "undef"
       TYPES.undef()
 
-    when "notundef"
-      TYPES.not_undef()
-
     when "default"
       TYPES.default()
 
@@ -348,15 +344,14 @@ class Puppet::Pops::Types::TypeParser
     when "struct"
       # 1..m parameters being types (last two optionally integer or literal default
       raise_invalid_parameters_error("Struct", "1", parameters.size) unless parameters.size == 1
-      h = parameters[0]
-      raise_invalid_type_specification_error unless h.is_a?(Hash)
-      TYPES.struct(h)
+      assert_struct_parameter(parameters[0])
+      TYPES.struct(parameters[0])
 
     when "integer"
       if parameters.size == 1
         case parameters[0]
         when Integer
-          TYPES.range(parameters[0], :default)
+          TYPES.range(parameters[0], parameters[0])
         when :default
           TYPES.integer # unbound
         end
@@ -370,7 +365,7 @@ class Puppet::Pops::Types::TypeParser
       if parameters.size == 1
         case parameters[0]
         when Integer, Float
-          TYPES.float_range(parameters[0], :default)
+          TYPES.float_range(parameters[0], parameters[0])
         when :default
           TYPES.float # unbound
         end
@@ -405,25 +400,12 @@ class Puppet::Pops::Types::TypeParser
       if parameters.size != 1
         raise_invalid_parameters_error("Optional", 1, parameters.size)
       end
-      param = parameters[0]
-      assert_type(param) unless param.is_a?(String)
-      TYPES.optional(param)
+      assert_type(parameters[0])
+      TYPES.optional(parameters[0])
 
     when "any", "data", "catalogentry", "boolean", "scalar", "undef", "numeric", "default"
       raise_unparameterized_type_error(parameterized_ast.left_expr)
 
-    when "notundef"
-      case parameters.size
-      when 0
-        TYPES.not_undef
-      when 1
-        param = parameters[0]
-        assert_type(param) unless param.is_a?(String)
-        TYPES.not_undef(param)
-      else
-        raise_invalid_parameters_error("NotUndef", "0 to 1", parameters.size)
-      end
-
     when "type"
       if parameters.size != 1
         raise_invalid_parameters_error("Type", 1, parameters.size)
@@ -456,6 +438,15 @@ class Puppet::Pops::Types::TypeParser
     raise_invalid_type_specification_error unless TYPES.is_range_parameter?(t)
   end
 
+  def assert_struct_parameter(h)
+    raise_invalid_type_specification_error unless h.is_a?(Hash)
+    h.each do |k,v|
+      # TODO: Should have stricter name rule
+      raise_invalid_type_specification_error unless k.is_a?(String) && !k.empty?
+      assert_type(v)
+    end
+  end
+
   def raise_invalid_type_specification_error
     raise Puppet::ParseError,
       "The expression <#{@string}> is not a valid type specification."

data/lib/puppet/pops/types/types.rb

@@ -13,10 +13,6 @@ module Puppet::Pops
 
   # Mix in implementation part of the Bindings Module
   module Types
-    # Used as end in a range
-    INFINITY = 1.0 / 0.0
-    NEGATIVE_INFINITY = -INFINITY
-
     class TypeModelObject < RGen::MetamodelBuilder::MMBase
       include Puppet::Pops::Visitable
       include Puppet::Pops::Adaptable
@@ -46,18 +42,6 @@ module Puppet::Pops
       end
     end
 
-    class PNotUndefType < PAnyType
-      module ClassModule
-        def hash
-          [self.class, type].hash
-        end
-
-        def ==(o)
-          self.class == o.class && type == o.type
-        end
-      end
-    end
-
     class PType < PAnyType
       module ClassModule
         def hash
@@ -112,16 +96,20 @@ module Puppet::Pops
 
         # Returns Float.Infinity if one end of the range is unbound
         def size
-          return INFINITY if from.nil? || to.nil?
+          return Float::INFINITY if from.nil? || to.nil?
           1+(to-from).abs
         end
 
         # Returns the range as an array ordered so the smaller number is always first.
         # The number may be Infinity or -Infinity.
         def range
-          f = from || NEGATIVE_INFINITY
-          t = to || INFINITY
-          [f, t]
+          f = from || -Float::INFINITY
+          t = to || Float::INFINITY
+          if f < t
+            [f, t]
+          else
+            [t,f]
+          end
         end
 
         # Returns Enumerator if no block is given
@@ -129,7 +117,11 @@ module Puppet::Pops
         def each
           return self.to_enum unless block_given?
           return nil if from.nil? || to.nil?
-          from.upto(to) {|x| yield x }
+          if to < from
+            from.downto(to) {|x| yield x }
+          else
+            from.upto(to) {|x| yield x }
+          end
         end
 
         def hash
@@ -201,10 +193,14 @@ module Puppet::Pops
       module ClassModule
         # Returns an array with from (min) size to (max) size
         def size_range
-          return [0, INFINITY] if size_type.nil?
+          return [0, Float::INFINITY] if size_type.nil?
           f = size_type.from || 0
-          t = size_type.to || INFINITY
-          [f, t]
+          t = size_type.to || Float::INFINITY
+          if f < t
+            [f, t]
+          else
+            [t,f]
+          end
         end
 
         def hash
@@ -220,17 +216,11 @@ module Puppet::Pops
     class PStructElement < TypeModelObject
       module ClassModule
         def hash
-          [self.class, value_type, key_type].hash
-        end
-
-        def name
-          k = key_type
-          k = k.optional_type if k.is_a?(POptionalType)
-          k.values[0]
+          [self.class, type, name].hash
         end
 
         def ==(o)
-          self.class == o.class && value_type == o.value_type && key_type == o.key_type
+          self.class == o.class && type == o.type && name == o.name
         end
       end
     end
@@ -239,7 +229,7 @@ module Puppet::Pops
     class PStructType < PAnyType
       module ClassModule
         def hashed_elements_derived
-          @_hashed ||= elements.reduce({}) {|memo, e| memo[e.name] = e; memo }
+          @_hashed ||= elements.reduce({}) {|memo, e| memo[e.name] = e.type; memo }
           @_hashed
         end
 
@@ -321,7 +311,7 @@ module Puppet::Pops
         end
 
         def ==(o)
-          self.class == o.class && args_type == o.args_type && block_type == o.block_type
+          self.class == o.class && param_types == o.param_types && block_type == o.block_type
         end
       end
     end
@@ -364,7 +354,7 @@ module Puppet::Pops
         end
 
         def ==(o)
-          self.class == o.class && runtime == o.runtime && runtime_type_name == o.runtime_type_name 
+          self.class == o.class && runtime == o.runtime && runtime_type_name == o.runtime_type_name
         end
       end
     end

data/lib/puppet/pops/types/types_meta.rb

@@ -27,15 +27,6 @@ module Puppet::Pops::Types
   class PAnyType < TypeModelObject
   end
 
-  # A type that is assignable from the same types as its contained `type` except the
-  # types assignable from {Puppet::Pops::Types::PUndefType}
-  #
-  # @api public
-  #
-  class PNotUndefType < PAnyType
-    contains_one_uni 'type', PAnyType
-  end
-
   # The type of types.
   # @api public
   #
@@ -144,10 +135,8 @@ module Puppet::Pops::Types
   # @api public
   #
   class PStructElement < TypeModelObject
-    # key_type must be either String[1] or Optional[String[1]] and the String[1] must
-    # have a values collection with exactly one element
-    contains_one_uni 'key_type', PAnyType, :lowerBound => 1
-    contains_one_uni 'value_type', PAnyType
+    has_attr 'name', String, :lowerBound => 1
+    contains_one_uni 'type', PAnyType
   end
 
   # @api public

data/lib/puppet/pops/utils.rb

@@ -25,7 +25,7 @@ module Puppet::Pops::Utils
         nil
       else
         fp_value = Float(match[2])
-        if fp_value != Puppet::Pops::Types::TypeCalculator::TheInfinity
+        if fp_value != Float::INFINITY
           match[1] == '-' ? -fp_value : fp_value
         else
           nil

data/lib/puppet/pops/validation/checker4_0.rb

@@ -14,8 +14,6 @@ class Puppet::Pops::Validation::Checker4_0
   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`.
   #
@@ -30,9 +28,6 @@ class Puppet::Pops::Validation::Checker4_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`.
@@ -187,18 +182,12 @@ class Puppet::Pops::Validation::Checker4_0
 
   def check_AttributesOperation(o)
     # Append operator use is constrained
-    parent1 = o.eContainer
-    case parent1
-    when Model::AbstractResource
-    when Model::CollectExpression
-    else
-      # protect against just testing a snippet that has no parent, error message will be a bit strange
-      # but it is not for a real program.
-      parent2 = parent1.nil? ? o : parent1.eContainer
-      unless parent2.is_a?(Model::AbstractResource)
-        acceptor.accept(Issues::UNSUPPORTED_OPERATOR_IN_CONTEXT, parent2, :operator=>'* =>')
-      end
+    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
 
@@ -214,7 +203,6 @@ class Puppet::Pops::Validation::Checker4_0
         break # only flag the first
       end
     end
-    migration_checker.report_array_last_in_block(o.statements[-1])
   end
 
   def check_CallNamedFunctionExpression(o)
@@ -233,7 +221,6 @@ class Puppet::Pops::Validation::Checker4_0
   def check_EppExpression(o)
     if o.eContainer.is_a?(Puppet::Pops::Model::LambdaExpression)
       internal_check_no_capture(o.eContainer, o)
-      internal_check_parameter_name_uniqueness(o.eContainer)
     end
   end
 
@@ -297,12 +284,6 @@ class Puppet::Pops::Validation::Checker4_0
     'runtime' => true,
   }
 
-  FUTURE_RESERVED_WORDS = {
-    'application' => true,
-    'produces' => true,
-    'consumes' => true
-  }
-
   # for 'class', 'define', and function
   def check_NamedDefinition(o)
     top(o.eContainer, o)
@@ -314,12 +295,6 @@ class Puppet::Pops::Validation::Checker4_0
       acceptor.accept(Issues::RESERVED_TYPE_NAME, o, {:name => o.name})
     end
 
-    # This is perhaps not ideal but it's very difficult to pass a ReservedWord through
-    # the mechanism that creates qualified names (namestack, namepop etc.)
-    if FUTURE_RESERVED_WORDS[o.name]
-      acceptor.accept(Issues::FUTURE_RESERVED_WORD, o, {:word => o.name})
-    end
-
     if violator = ends_with_idem(o.body)
       acceptor.accept(Issues::IDEM_NOT_ALLOWED_LAST, violator, {:container => o})
     end
@@ -328,14 +303,12 @@ class Puppet::Pops::Validation::Checker4_0
   def check_HostClassDefinition(o)
     check_NamedDefinition(o)
     internal_check_no_capture(o)
-    internal_check_parameter_name_uniqueness(o)
     internal_check_reserved_params(o)
   end
 
   def check_ResourceTypeDefinition(o)
     check_NamedDefinition(o)
     internal_check_no_capture(o)
-    internal_check_parameter_name_uniqueness(o)
     internal_check_reserved_params(o)
   end
 
@@ -369,13 +342,6 @@ class Puppet::Pops::Validation::Checker4_0
     end
   end
 
-  def internal_check_parameter_name_uniqueness(o)
-    unique = Set.new
-    o.parameters.each do |p|
-      acceptor.accept(Issues::DUPLICATE_PARAMETER, p, {:param_name => p.name}) unless unique.add?(p.name)
-    end
-  end
-
   def check_IfExpression(o)
     rvalue(o.test)
   end
@@ -395,14 +361,6 @@ class Puppet::Pops::Validation::Checker4_0
     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)
@@ -449,10 +407,6 @@ class Puppet::Pops::Validation::Checker4_0
     if o.name =~ /^(?:0x)?[0-9]+$/
       acceptor.accept(Issues::ILLEGAL_NUMERIC_PARAMETER, o, :name => o.name)
     end
-
-    unless o.name =~ Puppet::Pops::Patterns::PARAM_NAME
-      acceptor.accept(Issues::ILLEGAL_PARAM_NAME, o, :name => o.name)
-    end
   end
 
   #relationship_side: resource
@@ -502,11 +456,7 @@ class Puppet::Pops::Validation::Checker4_0
   end
 
   def check_ReservedWord(o)
-    if o.future
-      acceptor.accept(Issues::FUTURE_RESERVED_WORD, o, :word => o.word)
-    else
-      acceptor.accept(Issues::RESERVED_WORD, o, :word => o.word)
-    end
+    acceptor.accept(Issues::RESERVED_WORD, o, :word => o.word)
   end
 
   def check_SelectorExpression(o)

data/lib/puppet/pops/validation/validator_factory_4_0.rb

@@ -23,9 +23,7 @@ class Puppet::Pops::Validation::ValidatorFactory_4_0 < Puppet::Pops::Validation:
     p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
     p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
 
-    p[Issues::FUTURE_RESERVED_WORD]          = :deprecation
-
-    p[Issues::NAME_WITH_HYPHEN]              = :error
+    p[Issues::NAME_WITH_HYPHEN]             = :error
     p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
     p
   end

data/lib/puppet/pops/validation.rb

@@ -93,12 +93,11 @@ module Puppet::Pops::Validation
     @@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)
+    def initialize
       # If diagnose is not set, the default is returned by the block
-      @severities = Hash.new default_severity
+      @severities = Hash.new :error
     end
 
     # Returns the severity of the given issue.
@@ -228,28 +227,6 @@ module Puppet::Pops::Validation
       # 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.
@@ -320,7 +297,7 @@ module Puppet::Pops::Validation
 
       if file && line && pos
         " at #{file}:#{line}:#{pos}"
-      elsif file and line
+      elsif file && line
         " at #{file}:#{line}"
       elsif line && pos
         " at line #{line}:#{pos}"

data/lib/puppet/pops/visitor.rb

@@ -24,11 +24,14 @@ class Puppet::Pops::Visitor
 
   # Visit the configured receiver
   def visit(thing, *args)
-    visit_this(@receiver, thing, *args)
+    visit_this(@receiver, thing, args)
   end
 
+  DOUBLE_COLON = '::'
+  NO_ARGS = [].freeze
+
   # Visit an explicit receiver
-  def visit_this(receiver, thing, *args)
+  def visit_this(receiver, thing, args)
     raise "Visitor Error: Too few arguments passed. min = #{@min_args}" unless args.length >= @min_args
     if @max_args
       raise "Visitor Error: Too many arguments passed. max = #{@max_args}" unless args.length <= @max_args
@@ -37,7 +40,7 @@ class Puppet::Pops::Visitor
       return receiver.send(method_name, thing, *args)
     else
       thing.class.ancestors().each do |ancestor|
-        method_name = :"#{@message}_#{ancestor.name.split(/::/).last}"
+        method_name = :"#{@message}_#{ancestor.name.split(DOUBLE_COLON).last}"
         next unless receiver.respond_to?(method_name, true)
         @cache[thing.class] = method_name
         return receiver.send(method_name, thing, *args)
@@ -53,7 +56,7 @@ class Puppet::Pops::Visitor
     if method_name = @cache[thing.class]
       return receiver.send(method_name, thing)
     end
-    visit_this(receiver, thing)
+    visit_this(receiver, thing, NO_ARGS)
   end
 
   # Visit an explicit receiver with 1 args
@@ -63,7 +66,7 @@ class Puppet::Pops::Visitor
     if method_name = @cache[thing.class]
       return receiver.send(method_name, thing, arg)
     end
-    visit_this(receiver, thing, arg)
+    visit_this(receiver, thing, [arg])
   end
 
   # Visit an explicit receiver with 2 args
@@ -73,7 +76,7 @@ class Puppet::Pops::Visitor
     if method_name = @cache[thing.class]
       return receiver.send(method_name, thing, arg1, arg2)
     end
-    visit_this(receiver, thing, arg1, arg2)
+    visit_this(receiver, thing, [arg1, arg2])
   end
 
   # Visit an explicit receiver with 3 args
@@ -83,7 +86,7 @@ class Puppet::Pops::Visitor
     if method_name = @cache[thing.class]
       return receiver.send(method_name, thing, arg1, arg2, arg3)
     end
-    visit_this(receiver, thing, arg1, arg2, arg3)
+    visit_this(receiver, thing, [arg1, arg2, arg3])
   end
 
 end