puppet 4.0.0 → 4.5.0

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

@@ -0,0 +1,85 @@
+require 'rgen/ecore/ecore'
+
+# Literal values for
+#
+#   * String
+#   * Numbers
+#   * Booleans
+#   * Undef (produces nil)
+#   * Array
+#   * Hash where keys must be Strings
+#   * QualifiedName
+#
+# Not considered literal:
+#
+#   * QualifiedReference  # i.e. File, FooBar
+#   * Default is not accepted as being literal
+#   * Regular Expression is not accepted as being literal
+#   * Hash with non String keys
+#   * String with interpolatin
+#
+class Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator
+  #include Puppet::Pops::Utils
+
+  EMPTY_STRING = ''.freeze
+  COMMA_SEPARATOR = ', '.freeze
+
+  def initialize
+    @@literal_visitor ||= Puppet::Pops::Visitor.new(self, "literal", 0, 0)
+  end
+
+  def literal(ast)
+    @@literal_visitor.visit_this_0(self, ast)
+  end
+
+  def literal_Object(o)
+    throw :not_literal
+  end
+
+  def literal_Factory(o)
+    literal(o.model)
+  end
+
+  def literal_Program(o)
+    literal(o.body)
+  end
+
+  def literal_LiteralString(o)
+    o.value
+  end
+
+  def literal_QualifiedName(o)
+    o.value
+  end
+
+  def literal_LiteralNumber(o)
+    o.value
+  end
+
+  def literal_LiteralBoolean(o)
+    o.value
+  end
+
+  def literal_LiteralUndef(o)
+    nil
+  end
+
+  def literal_ConcatenatedString(o)
+    # use double quoted string value if there is no interpolation
+    throw :not_literal unless o.segments.size == 1 && o.segments[0].is_a?(Puppet::Pops::Model::LiteralString)
+    o.segments[0].value
+  end
+
+  def literal_LiteralList(o)
+    o.values.map {|v| literal(v) }
+  end
+
+  def literal_LiteralHash(o)
+    o.entries.reduce({}) do |result, entry|
+      key = literal(entry.key)
+      throw :not_literal unless key.is_a?(String)
+      result[key] = literal(entry.value)
+      result
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+module Puppet::Pops
+module Evaluator
+# Literal values for
+# String (not containing interpolation)
+# Numbers
+# Booleans
+# Undef (produces nil)
+# Array
+# Hash
+# QualifiedName
+# Default (produced :default)
+# Regular Expression (produces ruby reqular expression)
+#
+# Not considered literal
+# QualifiedReference  # i.e. File, FooBar
+#
+class LiteralEvaluator
+
+  EMPTY_STRING = ''.freeze
+  COMMA_SEPARATOR = ', '.freeze
+
+  def initialize
+    @@literal_visitor ||= Visitor.new(self, "literal", 0, 0)
+  end
+
+  def literal(ast)
+    @@literal_visitor.visit_this_0(self, ast)
+  end
+
+  def literal_Object(o)
+    throw :not_literal
+  end
+
+  def literal_Factory(o)
+    literal(o.model)
+  end
+
+  def literal_Program(o)
+    literal(o.body)
+  end
+
+  def literal_LiteralString(o)
+    o.value
+  end
+
+  def literal_QualifiedName(o)
+    o.value
+  end
+
+  def literal_LiteralNumber(o)
+    o.value
+  end
+
+  def literal_LiteralBoolean(o)
+    o.value
+  end
+
+  def literal_LiteralUndef(o)
+    nil
+  end
+
+  def literal_LiteralDefault(o)
+    :default
+  end
+
+  def literal_LiteralRegularExpression(o)
+    o.value
+  end
+
+  def literal_ConcatenatedString(o)
+    # use double quoted string value if there is no interpolation
+    throw :not_literal unless o.segments.size == 1 && o.segments[0].is_a?(Model::LiteralString)
+    o.segments[0].value
+  end
+
+  def literal_LiteralList(o)
+    o.values.map {|v| literal(v) }
+  end
+
+  def literal_LiteralHash(o)
+    o.entries.reduce({}) do |result, entry|
+      result[literal(entry.key)] = literal(entry.value)
+      result
+    end
+  end
+end
+end
+end

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

@@ -1,3 +1,5 @@
+module Puppet::Pops
+module Evaluator
 # The RelationshipOperator implements the semantics of the -> <- ~> <~ operators creating relationships or notification
 # relationships between the left and right hand side's references to resources.
 #
@@ -6,14 +8,12 @@
 # This is done to separate the concerns of the new evaluator from the 3x runtime; messy logic goes into the runtime support
 # module. Later when more is cleaned up this can be simplified further.
 #
-class Puppet::Pops::Evaluator::RelationshipOperator
+class RelationshipOperator
 
   # 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
-
-  Issues = Puppet::Pops::Issues
+  include Runtime3Support
 
   class IllegalRelationshipOperandError < RuntimeError
     attr_reader :operand
@@ -30,11 +30,11 @@ class Puppet::Pops::Evaluator::RelationshipOperator
   end
 
   def initialize
-    @type_transformer_visitor = Puppet::Pops::Visitor.new(self, "transform", 1, 1)
-    @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
-    @type_parser = Puppet::Pops::Types::TypeParser.new()
+    @type_transformer_visitor = Visitor.new(self, "transform", 1, 1)
+    @type_calculator = Types::TypeCalculator.new()
+    @type_parser = Types::TypeParser.new()
 
-    tf = Puppet::Pops::Types::TypeFactory
+    tf = Types::TypeFactory
     @catalog_type = tf.variant(tf.catalog_entry, tf.type_type(tf.catalog_entry))
   end
 
@@ -48,16 +48,22 @@ class Puppet::Pops::Evaluator::RelationshipOperator
     raise IllegalRelationshipOperandError.new(o)
   end
 
+  # A Resource is by definition a Catalog type, but of 3.x type
+  # @api private
+  def transform_Resource(o, scope)
+    Types::TypeFactory.resource(o.type, o.title)
+  end
+
   # A string must be a type reference in string format
   # @api private
   def transform_String(o, scope)
-    assert_catalog_type(@type_parser.parse(o), scope)
+    assert_catalog_type(@type_parser.parse(o, scope), scope)
   end
 
   # A qualified name is short hand for a class with this name
   # @api private
   def transform_QualifiedName(o, scope)
-    Puppet::Pops::Types::TypeFactory.host_class(o.value)
+    Types::TypeFactory.host_class(o.value)
   end
 
   # Types are what they are, just check the type
@@ -149,7 +155,7 @@ class Puppet::Pops::Evaluator::RelationshipOperator
       # Produce the transformed source RHS (if this is a chain, this does not need to be done again)
       real.slice(1)
     rescue NotCatalogTypeError => e
-      fail(Issues::ILLEGAL_RELATIONSHIP_OPERAND_TYPE, relationship_expression, {:type => @type_calculator.string(e.type)})
+      fail(Issues::NOT_CATALOG_TYPE, relationship_expression, {:type => @type_calculator.string(e.type)})
     rescue IllegalRelationshipOperandError => e
       fail(Issues::ILLEGAL_RELATIONSHIP_OPERAND_TYPE, relationship_expression, {:operand => e.operand})
     end
@@ -159,3 +165,5 @@ class Puppet::Pops::Evaluator::RelationshipOperator
     REVERSE_OPERATORS.include?(o.operator)
   end
 end
+end
+end

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

@@ -88,6 +88,11 @@ class Runtime3Converter
   end
   alias :convert2_Hash :convert_Hash
 
+  def convert_Iterator(o, scope, undef_value)
+    raise Puppet::Error, 'Use of an Iterator is not supported here'
+  end
+  alias :convert2_Iterator :convert_Iterator
+
   def convert_Regexp(o, scope, undef_value)
     # Puppet 3x cannot handle parameter values that are reqular expressions. Turn into regexp string in
     # source form
@@ -95,6 +100,18 @@ class Runtime3Converter
   end
   alias :convert2_Regexp :convert_Regexp
 
+  def convert_SemVer(o, scope, undef_value)
+    # Puppet 3x cannot handle SemVers. Use the string form
+    o.to_s
+  end
+  alias :convert2_SemVer :convert_SemVer
+
+  def convert_SemVerRange(o, scope, undef_value)
+    # Puppet 3x cannot handle SemVerRanges. Use the string form
+    o.to_s
+  end
+  alias :convert2_SemVerRange :convert_SemVerRange
+
   def convert_Symbol(o, scope, undef_value)
     case o
       # Support :undef since it may come from a 3x structure
@@ -140,12 +157,12 @@ class Runtime3Converter
       when Puppet::Pops::Types::PResourceType
         type_name = split_type.type_name
         title = split_type.title
-        if type_name =~ /^(::)?[Cc]lass/
+        if type_name =~ /^(::)?[Cc]lass$/
           ['class', title.nil? ? nil : title.sub(/^::/, '')]
         else
           # Ensure that title is '' if nil
           # Resources with absolute name always results in error because tagging does not support leading ::
-          [type_name.nil? ? nil : type_name.sub(/^::/, ''), title.nil? ? '' : title]
+          [type_name.nil? ? nil : type_name.sub(/^::/, '').downcase, title.nil? ? '' : title]
         end
       else
         raise ArgumentError, "Cannot split the type #{catalog_type.class}, it represents neither a PHostClassType, nor a PResourceType."

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

@@ -1,16 +1,18 @@
+module Puppet::Pops
+module Evaluator
 # A module with bindings between the new evaluator and the 3x runtime.
 # The intention is to separate all calls into scope, compiler, resource, etc. in this module
 # to make it easier to later refactor the evaluator for better implementations of the 3x classes.
 #
 # @api private
-module Puppet::Pops::Evaluator::Runtime3Support
+module Runtime3Support
 
   NAME_SPACE_SEPARATOR = '::'.freeze
 
   # Fails the evaluation of _semantic_ with a given issue.
   #
-  # @param issue [Puppet::Pops::Issue] the issue to report
-  # @param semantic [Puppet::Pops::ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
+  # @param issue [Issue] the issue to report
+  # @param semantic [ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
   # @param options [Hash] hash of optional named data elements for the given issue
   # @return [!] this method does not return
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
@@ -24,8 +26,8 @@ module Puppet::Pops::Evaluator::Runtime3Support
   # Optionally (based on severity) Fails the evaluation of _semantic_ with a given issue
   # If the given issue is configured to be of severity < :error it is only reported, and the function returns.
   #
-  # @param issue [Puppet::Pops::Issue] the issue to report
-  # @param semantic [Puppet::Pops::ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
+  # @param issue [Issue] the issue to report
+  # @param semantic [ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
   # @param options [Hash] hash of optional named data elements for the given issue
   # @return [!] this method does not return
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
@@ -59,9 +61,11 @@ module Puppet::Pops::Evaluator::Runtime3Support
     #
     if scope.bound?(name)
       if Puppet::Parser::Scope::RESERVED_VARIABLE_NAMES.include?(name)
-        fail(Puppet::Pops::Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
+        fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
+      elsif name == "server_facts" && Puppet[:trusted_server_facts]
+        fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
       else
-        fail(Puppet::Pops::Issues::ILLEGAL_REASSIGNMENT, o, {:name => name} )
+        fail(Issues::ILLEGAL_REASSIGNMENT, o, {:name => name} )
       end
     end
     scope.setvar(name, value)
@@ -78,14 +82,15 @@ module Puppet::Pops::Evaluator::Runtime3Support
       # Must convert :undef back to nil - this can happen when an undefined variable is used in a
       # parameter's default value expression - there nil must be :undef to work with the rest of 3x.
       # Now that the value comes back to 4x it is changed to nil.
-      return (x == :undef) ? nil : x
+      return :undef == x ? nil : x
     }
     # It is always ok to reference numeric variables even if they are not assigned. They are always undef
     # if not set by a match expression.
     #
     unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
-      fail(Puppet::Pops::Issues::UNKNOWN_VARIABLE, o, {:name => name})
+      optionally_fail(Puppet::Pops::Issues::UNKNOWN_VARIABLE, o, {:name => name})
     end
+    nil # in case unknown variable is configured as a warning or ignore
   end
 
   # Returns true if the variable of the given name is set in the given most nested scope. True is returned even if
@@ -134,10 +139,8 @@ module Puppet::Pops::Evaluator::Runtime3Support
   end
 
   def set_scope_nesting_level(scope, level)
-    # Yup, 3x uses this method to reset the level, it also supports passing :all to destroy all 
-    # ephemeral/local scopes - which is a sure way to create havoc.
-    #
-    scope.unset_ephemeral_var(level)
+    # 3x uses this method to reset the level,
+    scope.pop_ephemerals(level)
   end
 
   # Adds a relationship between the given `source` and `target` of the given `relationship_type`
@@ -194,20 +197,20 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # And if that is not enough, a source/target may be a Collector (a baked query that will be evaluated by the
     # compiler - it is simply passed through here for processing by the compiler at the right time).
     #
-    if source.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
+    if source.is_a?(Collectors::AbstractCollector)
       # use verbatim - behavior defined by 3x
       source_resource = source
     else
       # transform into the wonderful String representation in 3x
-      type, title = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(source)
+      type, title = Runtime3Converter.instance.catalog_type_to_split_type_title(source)
       source_resource = Puppet::Resource.new(type, title)
     end
-    if target.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
+    if target.is_a?(Collectors::AbstractCollector)
       # use verbatim - behavior defined by 3x
       target_resource = target
     else
       # transform into the wonderful String representation in 3x
-      type, title = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(target)
+      type, title = Runtime3Converter.instance.catalog_type_to_split_type_title(target)
       target_resource = Puppet::Resource.new(type, title)
     end
     # Add the relationship to the compiler for later evaluation.
@@ -223,28 +226,58 @@ module Puppet::Pops::Evaluator::Runtime3Support
   # @return [Numeric] value `v` converted to Numeric.
   #
   def coerce_numeric(v, o, scope)
-    unless n = Puppet::Pops::Utils.to_n(v)
-      fail(Puppet::Pops::Issues::NOT_NUMERIC, o, {:value => v})
+    unless n = Utils.to_n(v)
+      fail(Issues::NOT_NUMERIC, o, {:value => v})
     end
     n
   end
 
-  def call_function(name, args, o, scope, &block)
+  # Provides the ability to call a 3.x or 4.x function from the perspective of a 3.x function or ERB template.
+  # The arguments to the function must be an Array containing values compliant with the 4.x calling convention.
+  # If the targeted function is a 3.x function, the values will be transformed.
+  # @param name [String] the name of the function (without the 'function_' prefix used by scope)
+  # @param args [Array] arguments, may be empty
+  # @param scope [Object] the (runtime specific) scope where evaluation takes place
+  # @raise ArgumentError 'unknown function' if the function does not exist
+  #
+  def external_call_function(name, args, scope, &block)
     # Call via 4x API if the function exists there
     loaders = scope.compiler.loaders
-    # find the loader that loaded the code, or use the private_environment_loader (sees env + all modules)
-    adapter = Puppet::Pops::Utils.find_adapter(o, Puppet::Pops::Adapters::LoaderAdapter)
-    loader = adapter.nil? ? loaders.private_environment_loader : adapter.loader
+    # Since this is a call from non puppet code, it is not possible to relate it to a module loader
+    # It is known where the call originates by using the scope associated module - but this is the calling scope
+    # and it does not defined the visibility of functions from a ruby function's perspective. Instead,
+    # this is done from the perspective of the environment.
+    loader = loaders.private_environment_loader
     if loader && func = loader.load(:function, name)
-      return func.call(scope, *args, &block)
+      Puppet::Util::Profiler.profile(name, [:functions, name]) do
+        return func.call(scope, *args, &block)
+      end
     end
 
     # Call via 3x API if function exists there
-    fail(Puppet::Pops::Issues::UNKNOWN_FUNCTION, o, {:name => name}) unless Puppet::Parser::Functions.function(name)
+    raise ArgumentError, "Unknown function '#{name}'" unless Puppet::Parser::Functions.function(name)
+
+    # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
+    # NOTE: Passing an empty string last converts nil/:undef to empty string
+    mapped_args = Runtime3Converter.map_args(args, scope, '')
+    result = scope.send("function_#{name}", mapped_args, &block)
+    # Prevent non r-value functions from leaking their result (they are not written to care about this)
+    Puppet::Parser::Functions.rvalue?(name) ? result : nil
+  end
+
+  def call_function(name, args, o, scope, &block)
+    loader = Adapters::LoaderAdapter.loader_for_model_object(o, scope)
+    if loader && func = loader.load(:function, name)
+      Puppet::Util::Profiler.profile(name, [:functions, name]) do
+        return func.call(scope, *args, &block)
+      end
+    end
+    # Call via 3x API if function exists there
+    fail(Issues::UNKNOWN_FUNCTION, o, {:name => name}) unless Puppet::Parser::Functions.function(name)
 
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
     # NOTE: Passing an empty string last converts nil/:undef to empty string
-    mapped_args = Puppet::Pops::Evaluator::Runtime3Converter.map_args(args, scope, '')
+    mapped_args = Runtime3Converter.map_args(args, scope, '')
     result = scope.send("function_#{name}", mapped_args, &block)
     # Prevent non r-value functions from leaking their result (they are not written to care about this)
     Puppet::Parser::Functions.rvalue?(name) ? result : nil
@@ -262,7 +295,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
   end
 
   def convert(value, scope, undef_value)
-    Puppet::Pops::Evaluator::Runtime3Converter.convert(value, scope, undef_value)
+    Runtime3Converter.convert(value, scope, undef_value)
   end
 
   CLASS_STRING = 'class'.freeze
@@ -273,6 +306,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # a proper Issue. Now the result is "Error while evaluating a Resource Statement" with the message
     # from the raised exception. (It may be good enough).
 
+
     # resolve in scope.
     fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type_name, resource_titles)
 
@@ -316,7 +350,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # for the type of the name.
     # Note, locations are available per parameter.
     #
-    scope.define_settings(capitalize_qualified_name(type_name), evaluated_parameters)
+    scope.define_settings(capitalize_qualified_name(type_name), evaluated_parameters.flatten)
   end
 
   # Capitalizes each segment of a qualified name
@@ -335,10 +369,11 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # TODO: Revisit and possible improve the accuracy.
     #
     file, line = extract_file_line(o)
-
+    # A *=> results in an array of arrays
+    evaluated_parameters = evaluated_parameters.flatten
     evaluated_resources.each do |r|
-      unless r.is_a?(Puppet::Pops::Types::PResourceType) && r.type_name != 'class'
-        fail(Puppet::Pops::Issues::ILLEGAL_OVERRIDEN_TYPE, o, {:actual => r} )
+      unless r.is_a?(Types::PResourceType) && r.type_name != 'class'
+        fail(Issues::ILLEGAL_OVERRIDEN_TYPE, o, {:actual => r} )
       end
       resource = Puppet::Parser::Resource.new(
       r.type_name, r.title,
@@ -409,15 +444,17 @@ module Puppet::Pops::Evaluator::Runtime3Support
 
   # This is the same type of "truth" as used in the current Puppet DSL.
   #
-  def is_true? o
+  def is_true?(value, o)
     # Is the value true?  This allows us to control the definition of truth
     # in one place.
-    case o
+    case value
     # Support :undef since it may come from a 3x structure
     when :undef
       false
+    when String
+      true
     else
-      !!o
+      !!value
     end
   end
 
@@ -428,27 +465,27 @@ module Puppet::Pops::Evaluator::Runtime3Support
   end
 
   def extract_file_line(o)
-    source_pos = Puppet::Pops::Utils.find_closest_positioned(o)
+    source_pos = Utils.find_closest_positioned(o)
     return [nil, -1] unless source_pos
     [source_pos.locator.file, source_pos.line]
   end
 
   def find_closest_positioned(o)
-    return nil if o.nil? || o.is_a?(Puppet::Pops::Model::Program)
-    o.offset.nil? ? find_closest_positioned(o.eContainer) : Puppet::Pops::Adapters::SourcePosAdapter.adapt(o)
+    return nil if o.nil? || o.is_a?(Model::Program)
+    o.offset.nil? ? find_closest_positioned(o.eContainer) : Adapters::SourcePosAdapter.adapt(o)
   end
 
   # Creates a diagnostic producer
   def diagnostic_producer
-    Puppet::Pops::Validation::DiagnosticProducer.new(
+    Validation::DiagnosticProducer.new(
       ExceptionRaisingAcceptor.new(),                   # Raises exception on all issues
       SeverityProducer.new(), # All issues are errors
-      Puppet::Pops::Model::ModelLabelProvider.new())
+      Model::ModelLabelProvider.new())
   end
 
   # Configure the severity of failures
-  class SeverityProducer < Puppet::Pops::Validation::SeverityProducer
-    Issues = Puppet::Pops::Issues
+  class SeverityProducer < Validation::SeverityProducer
+    Issues = Issues
 
     def initialize
       super
@@ -460,6 +497,18 @@ module Puppet::Pops::Evaluator::Runtime3Support
         p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
       end
 
+      # if strict variables are on, an error is raised
+      # if strict variables are off, the Puppet[strict] defines what is done
+      #
+      if Puppet[:strict_variables]
+        p[Issues::UNKNOWN_VARIABLE] = :error
+      elsif Puppet[:strict] == :off
+        p[Issues::UNKNOWN_VARIABLE] = :ignore
+      else
+        Puppet[:strict_variables]
+        p[Issues::UNKNOWN_VARIABLE] = Puppet[:strict]
+      end
+
       # Store config issues, ignore or warning
       p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
       p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
@@ -467,11 +516,11 @@ module Puppet::Pops::Evaluator::Runtime3Support
   end
 
   # An acceptor of diagnostics that immediately raises an exception.
-  class ExceptionRaisingAcceptor < Puppet::Pops::Validation::Acceptor
+  class ExceptionRaisingAcceptor < Validation::Acceptor
     def accept(diagnostic)
       super
-      Puppet::Pops::IssueReporter.assert_and_report(self, {
-        :message => "Evaluation Error:", 
+      IssueReporter.assert_and_report(self, {
+        :message => "Evaluation Error:",
         :emit_warnings => true,  # log warnings
         :exception_class => Puppet::PreformattedError
       })
@@ -484,3 +533,5 @@ module Puppet::Pops::Evaluator::Runtime3Support
   class EvaluationError < StandardError
   end
 end
+end
+end

data/lib/puppet/pops/functions/dispatch.rb

@@ -71,7 +71,12 @@ class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSigna
         else
           # Careful so no new nil arguments are added since they would override default
           # parameter values in the received
-          new_args << args[knit] if knit < args.size
+          if knit < 0
+            idx = -knit - 1
+            new_args += args[idx..-1] if idx < args.size
+          else
+            new_args << args[knit] if knit < args.size
+          end
         end
       end
       new_args

data/lib/puppet/pops/functions/dispatcher.rb

@@ -28,13 +28,13 @@ class Puppet::Pops::Functions::Dispatcher
   #
   # @api private
   def dispatch(instance, calling_scope, args, &block)
-    tc = Puppet::Pops::Types::TypeCalculator
+    tc = Puppet::Pops::Types::TypeCalculator.singleton
     actual = tc.infer_set(block_given? ? args + [block] : args)
     found = @dispatchers.find { |d| tc.callable?(d.type, actual) }
     if found
       found.invoke(instance, calling_scope, args, &block)
     else
-      raise ArgumentError, "function '#{instance.class.name}' called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string(instance.class.name, actual, @dispatchers)}"
+      raise ArgumentError, Puppet::Pops::Types::TypeMismatchDescriber.describe_signatures(instance.class.name, @dispatchers, actual)
     end
   end
 
@@ -46,7 +46,13 @@ class Puppet::Pops::Functions::Dispatcher
   #
   # @api private
   def add_dispatch(type, method_name, param_names, block_name, injections, weaving, last_captures)
-    @dispatchers << Puppet::Pops::Functions::Dispatch.new(type, method_name, param_names, block_name, injections, weaving, last_captures)
+    add(Puppet::Pops::Functions::Dispatch.new(type, method_name, param_names, block_name, injections, weaving, last_captures))
+  end
+
+  # Adds a dispatch directly to the set of dispatchers.
+  # @api private
+  def add(a_dispatch)
+    @dispatchers << a_dispatch
   end
 
   # Produces a CallableType for a single signature, and a Variant[<callables>] otherwise
@@ -56,7 +62,7 @@ class Puppet::Pops::Functions::Dispatcher
     # make a copy to make sure it can be contained by someone else (even if it is not contained here, it
     # should be treated as immutable).
     #
-    callables = dispatchers.map { | dispatch | dispatch.type.copy }
+    callables = dispatchers.map { | dispatch | dispatch.type }
 
     # multiple signatures, produce a Variant type of Callable1-n (must copy them)
     # single signature, produce single Callable

data/lib/puppet/pops/functions/function.rb

@@ -89,13 +89,17 @@ class Puppet::Pops::Functions::Function
     raise ArgumentError, "Function #{self.class.name}(): cannot call function '#{function_name}' - no loader specified" unless the_loader
 
     func = the_loader.load(:function, function_name)
-    return func.call(scope, *args, &block) if func
+    if func
+      Puppet::Util::Profiler.profile(function_name, [:functions, function_name]) do
+        return func.call(scope, *args, &block)
+      end
+    end
 
     # Check if a 3x function is present. Raise a generic error if it's not to allow upper layers to fill in the details
     # about where in a puppet manifest this error originates. (Such information is not available here).
     loader_scope = closure_scope
     func_3x = Puppet::Parser::Functions.function(function_name, loader_scope.environment) if loader_scope.is_a?(Puppet::Parser::Scope)
-    raise ArgumentError, "Function #{self.class.name}(): cannot call function '#{function_name}' - not found" unless func_3x
+    raise ArgumentError, "Function #{self.class.name}(): Unknown function: '#{function_name}'" unless func_3x
 
     # Call via 3x API
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.