puppet 4.1.0 → 5.0.0

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?)
@@ -42,6 +44,30 @@ module Puppet::Pops::Evaluator::Runtime3Support
     diagnostic_producer.accept(issue, semantic, options, except)
   end
 
+  # Optionally (based on severity) Fails the evaluation with a given issue
+  # If the given issue is configured to be of severity < :error it is only reported, and the function returns.
+  # The location the issue is reported against is found is based on the top file/line in the puppet call stack
+  #
+  # @param issue [Issue] the issue to report
+  # @param options [Hash] hash of optional named data elements for the given issue
+  # @return [!] this method may not return, nil if it does
+  # @raise [Puppet::ParseError] an evaluation error initialized from the arguments
+  #
+  def runtime_issue(issue, options={})
+    # Get position from puppet runtime stack
+    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
+    if stacktrace.size > 0
+      file, line = stacktrace[0]
+    else
+      file = nil
+      line = nil
+    end
+    # Use a SemanticError as the sourcepos
+    semantic = Puppet::Pops::SemanticError.new(issue, nil, options.merge({:file => file, :line => line}))
+    optionally_fail(issue,  semantic)
+    nil
+  end
+
   # Binds the given variable name to the given value in the given scope.
   # The reference object `o` is intended to be used for origin information - the 3x scope implementation
   # only makes use of location when there is an error. This is now handled by other mechanisms; first a check
@@ -57,13 +83,15 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # The error is not specific enough to allow catching it - need to check the actual message text.
     # TODO: Improve the messy implementation in Scope.
     #
+    if name == "server_facts"
+      fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
+    end
+
     if scope.bound?(name)
       if Puppet::Parser::Scope::RESERVED_VARIABLE_NAMES.include?(name)
-        fail(Puppet::Pops::Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
-      elsif name == "server_facts" && Puppet[:trusted_server_facts]
-        fail(Puppet::Pops::Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
+        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)
@@ -80,14 +108,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.equal?(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
@@ -136,10 +165,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`
@@ -196,20 +223,22 @@ 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)
+      type = Runtime3ResourceSupport.find_resource_type(scope, type) unless type == 'class' || type == 'node'
       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)
+      type = Runtime3ResourceSupport.find_resource_type(scope, type) unless type == 'class' || type == 'node'
       target_resource = Puppet::Resource.new(type, title)
     end
     # Add the relationship to the compiler for later evaluation.
@@ -225,33 +254,70 @@ 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})
+    if v.is_a?(Numeric)
+      return v
+    end
+    unless n = Utils.to_n(v)
+      fail(Issues::NOT_NUMERIC, o, {:value => v})
     end
+    # this point is reached if there was a conversion
+    optionally_fail(Issues::NUMERIC_COERCION, o, {:before => v, :after => n})
     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 = Puppet::Pops::Evaluator::Runtime3Converter.map_args(args, scope, '')
+    mapped_args = Runtime3FunctionArgumentConverter.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)
+    file, line = extract_file_line(o)
+    loader = Adapters::LoaderAdapter.loader_for_model_object(o, file)
+    if loader && func = loader.load(:function, name)
+      Puppet::Util::Profiler.profile(name, [:functions, name]) do
+        # Add stack frame when calling. See Puppet::Pops::PuppetStack
+        return Kernel.eval('func.call(scope, *args, &block)', Kernel.binding, file || '', line)
+      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 = Runtime3FunctionArgumentConverter.map_args(args, scope, '')
+    result = Puppet::Pops::PuppetStack.stack(file, line, scope, "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
+
   # The o is used for source reference
   def create_resource_parameter(o, scope, name, value, operator)
     file, line = extract_file_line(o)
@@ -259,55 +325,23 @@ module Puppet::Pops::Evaluator::Runtime3Support
       :name   => name,
       :value  => convert(value, scope, nil), # converted to 3x since 4x supports additional objects / types
       :source => scope.source, :line => line, :file => file,
-      :add    => operator == :'+>'
+      :add    => operator == '+>'
     )
   end
 
   def convert(value, scope, undef_value)
-    Puppet::Pops::Evaluator::Runtime3Converter.convert(value, scope, undef_value)
+    converter = scope.environment.rich_data? ? Runtime3Converter.instance : Runtime3FunctionArgumentConverter.instance
+    converter.convert(value, scope, undef_value)
   end
 
-  CLASS_STRING = 'class'.freeze
-
   def create_resources(o, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
-
-    # TODO: Unknown resource causes creation of Resource to fail with ArgumentError, should give
-    # 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)
-
     # Not 100% accurate as this is the resource expression location and each title is processed separately
     # The titles are however the result of evaluation and they have no location at this point (an array
     # of positions for the source expressions are required for this to work).
     # TODO: Revisit and possible improve the accuracy.
     #
     file, line = extract_file_line(o)
-    # Build a resource for each title
-    resource_titles.map do |resource_title|
-        resource = Puppet::Parser::Resource.new(
-          fully_qualified_type, resource_title,
-          :parameters => evaluated_parameters,
-          :file => file,
-          :line => line,
-          :exported => exported,
-          :virtual => virtual,
-          # WTF is this? Which source is this? The file? The name of the context ?
-          :source => scope.source,
-          :scope => scope,
-          :strict => true
-        )
-
-        if resource.resource_type.is_a? Puppet::Resource::Type
-          resource.resource_type.instantiate_resource(scope, resource)
-        end
-        scope.compiler.add_resource(scope, resource)
-        scope.compiler.evaluate_classes([resource_title], scope, false) if fully_qualified_type == CLASS_STRING
-        # Turn the resource into a PType (a reference to a resource type)
-        # weed out nil's
-        resource_to_ptype(resource)
-    end
+    Runtime3ResourceSupport.create_resources(file, line, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
   end
 
   # Defines default parameters for a type with the given name.
@@ -340,17 +374,19 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # 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
+      t = Runtime3ResourceSupport.find_resource_type(scope, r.type_name)
       resource = Puppet::Parser::Resource.new(
-      r.type_name, r.title,
-        :parameters => evaluated_parameters,
-        :file => file,
-        :line => line,
-        # WTF is this? Which source is this? The file? The name of the context ?
-        :source => scope.source,
-        :scope => scope
+        t, r.title, {
+          :parameters => evaluated_parameters,
+          :file => file,
+          :line => line,
+          # WTF is this? Which source is this? The file? The name of the context ?
+          :source => scope.source,
+          :scope => scope
+        }, false # defaults should not override
       )
 
       scope.compiler.add_override(resource)
@@ -433,27 +469,20 @@ module Puppet::Pops::Evaluator::Runtime3Support
   end
 
   def extract_file_line(o)
-    source_pos = Puppet::Pops::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)
+    o.is_a?(Model::Positioned) ? [o.file, o.line] : [nil, -1]
   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
@@ -465,18 +494,33 @@ 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
+        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
+      p[Issues::CLASS_NOT_VIRTUALIZABLE]      = Puppet[:strict] == :off ? :warning : Puppet[:strict]
+      p[Issues::NUMERIC_COERCION]             = Puppet[:strict] == :off ? :ignore : Puppet[:strict]
+      p[Issues::SERIALIZATION_UNKNOWN_CONVERTED_TO_STRING] = Puppet[:strict] == :off ? :warning : Puppet[:strict]
+      p[Issues::SERIALIZATION_UNKNOWN_KEY_CONVERTED_TO_STRING] = Puppet[:strict] == :off ? :warning : Puppet[:strict]
     end
   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
       })
@@ -489,3 +533,5 @@ module Puppet::Pops::Evaluator::Runtime3Support
   class EvaluationError < StandardError
   end
 end
+end
+end

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

@@ -1,3 +1,5 @@
+module Puppet::Pops
+  module Functions
 # Defines a connection between a implementation method and the signature that
 # the method will handle.
 #
@@ -5,7 +7,7 @@
 # constructed using the DSL defined in {Puppet::Functions}.
 #
 # @api private
-class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSignature
+class Dispatch < Evaluator::CallableSignature
   # @api public
   attr_reader :type
   # TODO: refactor to parameter_names since that makes it API
@@ -19,15 +21,24 @@ class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSigna
   # @api public
   attr_reader :block_name
 
+  # @param type [Puppet::Pops::Types::PArrayType, Puppet::Pops::Types::PTupleType] - type describing signature
+  # @param method_name [String] the name of the method that will be called when type matches given arguments
+  # @param param_names [Array<String>] names matching the number of parameters specified by type (or empty array)
+  # @param block_name [String,nil] name of block parameter, no nil
+  # @param injections [Array<Array>] injection data for weaved parameters
+  # @param weaving [Array<Integer,Array>] weaving knits
+  # @param last_captures [Boolean] true if last parameter is captures rest
+  # @param argument_mismatch_handler [Boolean] true if this is a dispatch for an argument mismatch
   # @api private
-  def initialize(type, method_name, param_names, block_name, injections, weaving, last_captures)
+  def initialize(type, method_name, param_names, last_captures = false, block_name = nil, injections = EMPTY_ARRAY, weaving = EMPTY_ARRAY, argument_mismatch_handler = false)
     @type = type
     @method_name = method_name
-    @param_names = param_names || []
+    @param_names = param_names
+    @last_captures = last_captures
     @block_name = block_name
-    @injections = injections || []
+    @injections = injections
     @weaving = weaving
-    @last_captures = last_captures
+    @argument_mismatch_handler = argument_mismatch_handler
   end
 
   # @api private
@@ -37,12 +48,19 @@ class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSigna
 
   # @api private
   def last_captures_rest?
-    !! @last_captures
+    @last_captures
+  end
+
+  def argument_mismatch_handler?
+    @argument_mismatch_handler
   end
 
   # @api private
   def invoke(instance, calling_scope, args, &block)
-    instance.send(@method_name, *weave(calling_scope, args), &block)
+    result = instance.send(@method_name, *weave(calling_scope, args), &block)
+    return_type = @type.return_type
+    Types::TypeAsserter.assert_instance_of(nil, return_type, result) { "value returned from function '#{@method_name}'" } unless return_type.nil?
+    result
   end
 
   # @api private
@@ -51,7 +69,6 @@ class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSigna
     if @injections.empty?
       args
     else
-      injector = nil # lazy lookup of injector Puppet.lookup(:injector)
       new_args = []
       @weaving.each do |knit|
         if knit.is_a?(Array)
@@ -61,12 +78,8 @@ class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSigna
             when :dispatcher_internal
               # currently only supports :scope injection
               scope
-            when :producer
-              injector ||= Puppet.lookup(:injector)
-              injector.lookup_producer(scope, injection_data[0], injection_data[2])
             else
-              injector ||= Puppet.lookup(:injector)
-              injector.lookup(scope, injection_data[0], injection_data[2])
+              raise_error ArgumentError, "Unknown injection #{injection_data[3]}"
             end
         else
           # Careful so no new nil arguments are added since they would override default
@@ -83,3 +96,5 @@ class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSigna
     end
   end
 end
+end
+end

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

@@ -28,28 +28,23 @@ class Puppet::Pops::Functions::Dispatcher
   #
   # @api private
   def dispatch(instance, calling_scope, args, &block)
-    tc = Puppet::Pops::Types::TypeCalculator
-    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)}"
+    found = @dispatchers.find { |d| d.type.callable_with?(args, block) }
+    unless found
+      args_type = Puppet::Pops::Types::TypeCalculator.singleton.infer_set(block_given? ? args + [block] : args)
+      raise ArgumentError, Puppet::Pops::Types::TypeMismatchDescriber.describe_signatures(instance.class.name, signatures, args_type)
     end
-  end
 
-  # Adds a regular dispatch for one method name
-  #
-  # @param type [Puppet::Pops::Types::PArrayType, Puppet::Pops::Types::PTupleType] - type describing signature
-  # @param method_name [String] - the name of the method that will be called when type matches given arguments
-  # @param names [Array<String>] - array with names matching the number of parameters specified by type (or empty array)
-  #
-  # @api private
-  def add_dispatch(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))
+    if found.argument_mismatch_handler?
+      msg = found.invoke(instance, calling_scope, args)
+      raise ArgumentError, "'#{instance.class.name}' #{msg}"
+    end
+
+    catch(:next) do
+      found.invoke(instance, calling_scope, args, &block)
+    end
   end
 
-  # Adds a dispatch directly to the set of dispathers.
+  # Adds a dispatch directly to the set of dispatchers.
   # @api private
   def add(a_dispatch)
     @dispatchers << a_dispatch
@@ -62,7 +57,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
@@ -71,6 +66,6 @@ class Puppet::Pops::Functions::Dispatcher
 
   # @api private
   def signatures
-    @dispatchers
+    @dispatchers.reject { |dispatcher| dispatcher.argument_mismatch_handler? }
   end
 end

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

@@ -41,7 +41,24 @@ class Puppet::Pops::Functions::Function
   #
   # @api public
   def call(scope, *args, &block)
-    self.class.dispatcher.dispatch(self, scope, args, &block)
+    begin
+      result = catch(:return) do
+        return self.class.dispatcher.dispatch(self, scope, args, &block)
+      end
+      return result.value
+    rescue Puppet::Pops::Evaluator::Next => jumper
+      begin
+        throw :next, jumper.value
+      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION => uncaught
+        raise Puppet::ParseError.new("next() from context where this is illegal", jumper.file, jumper.line)
+      end
+    rescue Puppet::Pops::Evaluator::Return => jumper
+      begin
+        throw :return, jumper
+      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION => uncaught
+        raise Puppet::ParseError.new("return() from context where this is illegal", jumper.file, jumper.line)
+      end
+    end
   end
 
   # Allows the implementation of a function to call other functions by name. The callable functions
@@ -57,6 +74,11 @@ class Puppet::Pops::Functions::Function
     internal_call_function(closure_scope, function_name, args, &block)
   end
 
+  def closure_scope
+    # If closure scope is explicitly set to not nil, if there is a global scope, otherwise an empty hash
+    @closure_scope || Puppet.lookup(:global_scope) { {} }
+  end
+
   # The dispatcher for the function
   #
   # @api private
@@ -89,18 +111,22 @@ 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.
     # NOTE: Passing an empty string last converts nil/:undef to empty string
-    result = scope.send(func_3x, Puppet::Pops::Evaluator::Runtime3Converter.map_args(args, loader_scope, ''), &block)
+    result = scope.send(func_3x, Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.map_args(args, loader_scope, ''), &block)
 
     # Prevent non r-value functions from leaking their result (they are not written to care about this)
     Puppet::Parser::Functions.rvalue?(function_name) ? result : nil

data/lib/puppet/pops/issue_reporter.rb

@@ -1,6 +1,7 @@
-class Puppet::Pops::IssueReporter
+module Puppet::Pops
+class IssueReporter
 
-  # @param acceptor [Puppet::Pops::Validation::Acceptor] the acceptor containing reported issues
+  # @param acceptor [Validation::Acceptor] the acceptor containing reported issues
   # @option options [String] :message (nil) A message text to use as prefix in
   #   a single Error message
   # @option options [Boolean] :emit_warnings (false) whether warnings should be emitted
@@ -23,7 +24,7 @@ class Puppet::Pops::IssueReporter
     # If there are warnings output them
     warnings = acceptor.warnings
     if emit_warnings && warnings.size > 0
-      formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
+      formatter = Validation::DiagnosticFormatterPuppetStyle.new
       emitted_w = 0
       emitted_dw = 0
       acceptor.warnings.each do |w|
@@ -48,7 +49,7 @@ class Puppet::Pops::IssueReporter
       unless emit_errors
         raise emit_exception.new(emit_message)
       end
-      formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
+      formatter = Validation::DiagnosticFormatterPuppetStyle.new
       if errors.size == 1 || max_errors <= 1
         # raise immediately
         exception = create_exception(emit_exception, emit_message, formatter, errors[0])
@@ -68,7 +69,7 @@ class Puppet::Pops::IssueReporter
         break if emitted >= max_errors
       end
       warnings_message = (emit_warnings && warnings.size > 0) ? ", and #{warnings.size} warnings" : ""
-      giving_up_message = "Found #{errors.size} errors#{warnings_message}. Giving up"
+      giving_up_message = "Language validation logged #{errors.size} errors#{warnings_message}. Giving up"
       exception = emit_exception.new(giving_up_message)
       exception.file = errors[0].file
       raise exception
@@ -111,3 +112,4 @@ class Puppet::Pops::IssueReporter
   end
   private_class_method :log_message
 end
+end