puppet 5.0.0 → 6.0.0

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

@@ -4,7 +4,9 @@ class Puppet::Pops::Evaluator::EppEvaluator
 
   def self.inline_epp(scope, epp_source, template_args = nil)
     unless epp_source.is_a?(String)
-      raise ArgumentError, "inline_epp(): the first argument must be a String with the epp source text, got a #{epp_source.class}"
+      #TRANSLATORS 'inline_epp()' is a method name and 'epp' refers to 'Embedded Puppet (EPP) template' and should not be translated
+      raise ArgumentError, _("inline_epp(): the first argument must be a String with the epp source text, got a %{class_name}") %
+          { class_name: epp_source.class }
     end
 
     # Parse and validate the source
@@ -12,7 +14,8 @@ class Puppet::Pops::Evaluator::EppEvaluator
     begin
       result = parser.parse_string(epp_source, 'inlined-epp-text')
     rescue Puppet::ParseError => e
-      raise ArgumentError, "inline_epp(): Invalid EPP: #{e.message}"
+      #TRANSLATORS 'inline_epp()' is a method name and 'EPP' refers to 'Embedded Puppet (EPP) template' and should not be translated
+      raise ArgumentError, _("inline_epp(): Invalid EPP: %{detail}") % { detail: e.message }
     end
 
     # Evaluate (and check template_args)
@@ -21,7 +24,8 @@ class Puppet::Pops::Evaluator::EppEvaluator
 
   def self.epp(scope, file, env_name, template_args = nil)
     unless file.is_a?(String)
-      raise ArgumentError, "epp(): the first argument must be a String with the filename, got a #{file.class}"
+      #TRANSLATORS 'epp()' is a method name and should not be translated
+      raise ArgumentError, _("epp(): the first argument must be a String with the filename, got a %{class_name}") % { class_name: file.class }
     end
 
     unless Puppet::FileSystem.exist?(file)
@@ -41,27 +45,32 @@ class Puppet::Pops::Evaluator::EppEvaluator
     begin
       result = parser.parse_file(template_file)
     rescue Puppet::ParseError => e
-      raise ArgumentError, "epp(): Invalid EPP: #{e.message}"
+      #TRANSLATORS 'epp()' is a method name and 'EPP' refers to 'Embedded Puppet (EPP) template' and should not be translated
+      raise ArgumentError, _("epp(): Invalid EPP: %{detail}") % { detail: e.message }
     end
 
     # Evaluate (and check template_args)
     evaluate(parser, 'epp', scope, true, result, template_args)
   end
 
-  private
-
   def self.evaluate(parser, func_name, scope, use_global_scope_only, parse_result, template_args)
     template_args, template_args_set = handle_template_args(func_name, template_args)
 
     body = parse_result.body
     unless body.is_a?(Puppet::Pops::Model::LambdaExpression)
-      raise ArgumentError, "#{func_name}(): the parser did not produce a LambdaExpression, got '#{body.class}'"
+      #TRANSLATORS 'LambdaExpression' is a class name and should not be translated
+      raise ArgumentError, _("%{function_name}(): the parser did not produce a LambdaExpression, got '%{class_name}'") %
+          { function_name: func_name, class_name: body.class }
     end
     unless body.body.is_a?(Puppet::Pops::Model::EppExpression)
-      raise ArgumentError, "#{func_name}(): the parser did not produce an EppExpression, got '#{body.body.class}'"
+      #TRANSLATORS 'EppExpression' is a class name and should not be translated
+      raise ArgumentError, _("%{function_name}(): the parser did not produce an EppExpression, got '%{class_name}'") %
+          { function_name: func_name, class_name: body.body.class }
     end
     unless parse_result.definitions.empty?
-      raise ArgumentError, "#{func_name}(): The EPP template contains illegal expressions (definitions)"
+      #TRANSLATORS 'EPP' refers to 'Embedded Puppet (EPP) template'
+      raise ArgumentError, _("%{function_name}(): The EPP template contains illegal expressions (definitions)") %
+          { function_name: func_name }
     end
 
     parameters_specified = body.body.parameters_specified
@@ -71,6 +80,19 @@ class Puppet::Pops::Evaluator::EppEvaluator
       enforce_parameters = true
     end
 
+    # filter out all qualified names and set them in qualified_variables
+    # only pass unqualified (filtered) variable names to the the template
+    filtered_args = {}
+    template_args.each_pair do |k, v|
+      if k =~ /::/
+        k = k[2..-1] if k.start_with?('::')
+        scope[k] = v
+      else
+        filtered_args[k] = v
+      end
+    end
+    template_args = filtered_args
+
     # inline_epp() logic sees all local variables, epp() all global
     if use_global_scope_only
       scope.with_global_scope do |global_scope|
@@ -80,15 +102,19 @@ class Puppet::Pops::Evaluator::EppEvaluator
       parser.closure(body, scope).call_by_name(template_args, enforce_parameters)
     end
   end
+  private_class_method :evaluate
 
   def self.handle_template_args(func_name, template_args)
     if template_args.nil?
       [{}, false]
     else
       unless template_args.is_a?(Hash)
-        raise ArgumentError, "#{func_name}(): the template_args must be a Hash, got a #{template_args.class}"
+        #TRANSLATORS 'template_args' is a variable name and should not be translated
+        raise ArgumentError, _("%{function_name}(): the template_args must be a Hash, got a %{class_name}") %
+            { function_name: func_name, class_name: template_args.class }
       end
       [template_args, true]
     end
   end
+  private_class_method :handle_template_args
 end

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

@@ -178,6 +178,15 @@ class EvaluatorImpl
     end
   end
 
+  # Implementation of case option matching.
+  #
+  # 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 match?(left, right)
+    @@compare_operator.match(left, right, nil)
+  end
+
   protected
 
   def lvalue_VariableExpression(o, scope)
@@ -231,7 +240,10 @@ class EvaluatorImpl
           values.fetch(lval) {|k| fail(Issues::MISSING_MULTI_ASSIGNMENT_KEY, o, :key =>k)},
           o, scope)
       end
-    elsif values.is_a?(Puppet::Pops::Types::PHostClassType)
+    elsif values.is_a?(Puppet::Pops::Types::PClassType)
+      if Puppet[:tasks]
+        fail(Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING, o, {:operation => _('multi var assignment from class')})
+      end
       # assign variables from class variables
       # lookup class resource and return one or more parameter values
       # TODO: behavior when class_name is nil
@@ -305,7 +317,7 @@ class EvaluatorImpl
     nil
   end
 
-  # A QualifiedReference (i.e. a  capitalized qualified name such as Foo, or Foo::Bar) evaluates to a PType
+  # A QualifiedReference (i.e. a  capitalized qualified name such as Foo, or Foo::Bar) evaluates to a PTypeType
   #
   def eval_QualifiedReference(o, scope)
     type = Types::TypeParser.singleton.interpret(o)
@@ -330,7 +342,7 @@ class EvaluatorImpl
       candidate
     when Hash
       candidate.to_a
-    when Puppet::Pops::Types::Iterator
+    when Puppet::Pops::Types::Iterable
       candidate.to_a
     else
       # turns anything else into an array (so result can be unfolded)
@@ -392,7 +404,9 @@ class EvaluatorImpl
     end
 
     left_o = bin_expr.left_expr
-    if (left.is_a?(Array) || left.is_a?(Hash)) && COLLECTION_OPERATORS.include?(operator)
+    if (left.is_a?(URI) || left.is_a?(Types::PBinaryType::Binary)) && operator == '+'
+      concatenate(left, right)
+    elsif (left.is_a?(Array) || left.is_a?(Hash)) && COLLECTION_OPERATORS.include?(operator)
       # Handle operation on collections
       case operator
       when '+'
@@ -428,9 +442,9 @@ class EvaluatorImpl
           end
         end
         result = left.send(operator, right)
-      rescue NoMethodError => e
+      rescue NoMethodError
         fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
-      rescue ZeroDivisionError => e
+      rescue ZeroDivisionError
         fail(Issues::DIV_BY_ZERO, bin_expr.right_expr)
       end
       case result
@@ -479,7 +493,7 @@ class EvaluatorImpl
   def eval_AccessExpression(o, scope)
     left = evaluate(o.left_expr, scope)
     keys = o.keys || []
-    if left.is_a?(Types::PHostClassType)
+    if left.is_a?(Types::PClassType)
       # Evaluate qualified references without errors no undefined types
       keys = keys.map {|key| key.is_a?(Model::QualifiedReference) ? Types::TypeParser.singleton.interpret(key) : evaluate(key, scope) }
     else
@@ -689,7 +703,7 @@ class EvaluatorImpl
   end
 
   # Evaluates a CollectExpression by creating a collector transformer. The transformer
-  # will evaulate the collection, create the appropriate collector, and hand it off
+  # will evaluate the collection, create the appropriate collector, and hand it off
   # to the compiler to collect the resources specified by the query.
   #
   def eval_CollectExpression o, scope
@@ -724,7 +738,8 @@ class EvaluatorImpl
       #evaluate(o.body, scope)
     rescue Puppet::Pops::Evaluator::PuppetStopIteration => ex
       # breaking out of a file level program is not allowed
-      raise Puppet::ParseError.new("break() from context where this is illegal", ex.file, ex.line)
+      #TRANSLATOR break() is a method that should not be translated
+      raise Puppet::ParseError.new(_("break() from context where this is illegal"), ex.file, ex.line)
     end
   end
 
@@ -755,7 +770,7 @@ class EvaluatorImpl
 
       # must be a CatalogEntry subtype
       case evaluated_name
-      when Types::PHostClassType
+      when Types::PClassType
         unless evaluated_name.class_name.nil?
           fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
         end
@@ -858,6 +873,18 @@ class EvaluatorImpl
     evaluated_resources
   end
 
+  def eval_ApplyExpression(o, scope)
+    # All expressions are wrapped in an ApplyBlockExpression so we can identify the contents of
+    # that block. However we don't want to serialize the block expression, so unwrap here.
+    body = if o.body.statements.count > 1
+      Model::BlockExpression.from_asserted_hash(o.body._pcore_init_hash)
+    else
+      o.body.statements[0]
+    end
+
+    Puppet.lookup(:apply_executor).apply(unfold([], o.arguments, scope), body, scope)
+  end
+
   # Produces 3x parameter
   def eval_AttributeOperation(o, scope)
     create_resource_parameter(o, scope, o.attribute_name, evaluate(o.value_expr, scope), o.operator)
@@ -933,7 +960,7 @@ class EvaluatorImpl
 
     obj = receiver[0]
     receiver_type = Types::TypeCalculator.infer(obj)
-    if receiver_type.is_a?(Types::PObjectType)
+    if receiver_type.is_a?(Types::TypeWithMembers)
       member = receiver_type[name]
       unless member.nil?
         args = unfold([], o.arguments || [], scope)
@@ -1095,7 +1122,7 @@ class EvaluatorImpl
   end
 
   def string_Regexp(o, scope)
-    "/#{o.source}/"
+    Types::PRegexpType.regexp_to_s_with_delimiters(o)
   end
 
   def string_PAnyType(o, scope)
@@ -1116,7 +1143,11 @@ class EvaluatorImpl
   # * Hash => a merge, where entries in `y` overrides
   # * any other => error
   #
-  # When x is something else, wrap it in an array first.
+  # When x is a URI, y of type produces:
+  #
+  # * String => merge of URI interpreted x + URI(y) using URI merge semantics
+  # * URI => merge of URI interpreted x + y using URI merge semantics
+  # * any other => error
   #
   # When x is nil, an empty array is used instead.
   #
@@ -1146,11 +1177,18 @@ class EvaluatorImpl
   #   @param hsh_x [Hash] the hash to merge to
   #   @param hsh_y [Hash] hash merged with `hsh_x`
   #   @return [Hash] new hash with `hsh_x` merged with `hsh_y`
+  # @overload concatenate(uri_x, uri_y)
+  #   @param uri_x [URI] the uri to merge to
+  #   @param uri_y [URI] uri to merged with `uri_x`
+  #   @return [URI] new uri with `uri_x` merged with `uri_y`
+  # @overload concatenate(uri_x, string_y)
+  #   @param uri_x [URI] the uri to merge to
+  #   @param string_y [String] string to merge with `uri_x`
+  #   @return [URI] new uri with `uri_x` merged with `string_y`
   # @raise [ArgumentError] when `xxx_x` is neither an Array nor a Hash
   # @raise [ArgumentError] when `xxx_x` is a Hash, and `xxx_y` is neither Array nor Hash.
   #
   def concatenate(x, y)
-    x = [x] unless x.is_a?(Array) || x.is_a?(Hash)
     case x
     when Array
       y = case y
@@ -1168,7 +1206,7 @@ class EvaluatorImpl
         # Hash[a,1,b,2] => {a => 1, b => 2}
         # Hash[[a,1], [b,2]] => {[a,1] => [b,2]}
         # Hash[[[a,1], [b,2]]] => {a => 1, b => 2}
-        # Use type calcultor to determine if array is Array[Array[?]], and if so use second form
+        # Use type calculator to determine if array is Array[Array[?]], and if so use second form
         # of call
         t = @@type_calculator.infer(y)
         if t.element_type.is_a? Types::PArrayType
@@ -1177,11 +1215,17 @@ class EvaluatorImpl
           Hash[*y]
         end
       else
-        raise ArgumentError.new(_("Can only append Array or Hash to a Hash"))
+        raise ArgumentError.new(_('Can only append Array or Hash to a Hash'))
       end
       x.merge y # new hash with overwrite
+    when URI
+      raise ArgumentError.new(_('An URI can only be merged with an URI or String')) unless y.is_a?(String) || y.is_a?(URI)
+      x + y
+    when Types::PBinaryType::Binary
+      raise ArgumentError.new(_('Can only append Binary to a Binary')) unless y.is_a?(Types::PBinaryType::Binary)
+      Types::PBinaryType::Binary.from_binary_string(x.binary_buffer + y.binary_buffer)
     else
-      raise ArgumentError.new(_("Can only append to an Array or a Hash."))
+      concatenate([x], y)
     end
   end
 

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

@@ -19,7 +19,7 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
     if acceptor.error_count > 0
       checker_message = "Invalid produced text having syntax: '#{syntax}'."
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, :message => checker_message)
-      raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
+      raise ArgumentError, _("Internal Error: Configuration of runtime error handling wrong: should have raised exception")
     end
   end
 

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

@@ -9,7 +9,7 @@ module Evaluator
 # Hash
 # QualifiedName
 # Default (produced :default)
-# Regular Expression (produces ruby reqular expression)
+# Regular Expression (produces ruby regular expression)
 #
 # Not considered literal
 # QualifiedReference  # i.e. File, FooBar

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

@@ -91,7 +91,7 @@ class RelationshipOperator
   end
 
   # Asserts (and returns) the type if it is a PCatalogEntryType
-  # (A PCatalogEntryType is the base class of PHostClassType, and PResourceType).
+  # (A PCatalogEntryType is the base class of PClassType, and PResourceType).
   #
   def assert_catalog_type(o, scope)
     unless @type_calculator.assignable?(@catalog_type, o)

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

@@ -61,7 +61,7 @@ class Runtime3Converter
   end
 
   def convert_NilClass(o, scope, undef_value)
-    @inner ? :undef : undef_value
+    @inner ? nil : undef_value
   end
 
   def convert_Integer(o, scope, undef_value)
@@ -78,8 +78,10 @@ class Runtime3Converter
   end
 
   def convert_String(o, scope, undef_value)
-    # although wasteful, needed because user code may mutate these strings in Resources
-    o.frozen? ? o.dup : o
+    # Although wasteful, a dup is needed because user code may mutate these strings when applying
+    # Resources. This does not happen when in master mode since it only uses Resources that are
+    # in puppet core and those are all safe.
+    o.frozen? && !Puppet.run_mode.master? ? o.dup : o
   end
 
   def convert_Object(o, scope, undef_value)
@@ -103,7 +105,8 @@ class Runtime3Converter
   end
 
   def convert_Symbol(o, scope, undef_value)
-    o == :undef && !@inner ? undef_value : o
+    o == :undef ? undef_value : o
+    #o == :undef && !@inner ? undef_value : o
   end
 
   def convert_PAnyType(o, scope, undef_value)
@@ -127,9 +130,9 @@ class Runtime3Converter
   # Ensures that resources are *not* absolute.
   #
   def catalog_type_to_split_type_title(catalog_type)
-    split_type = catalog_type.is_a?(Puppet::Pops::Types::PType) ? catalog_type.type : catalog_type
+    split_type = catalog_type.is_a?(Puppet::Pops::Types::PTypeType) ? catalog_type.type : catalog_type
     case split_type
-      when Puppet::Pops::Types::PHostClassType
+      when Puppet::Pops::Types::PClassType
         class_name = split_type.class_name
         ['class', class_name.nil? ? nil : class_name.sub(/^::/, '')]
       when Puppet::Pops::Types::PResourceType
@@ -143,7 +146,9 @@ class Runtime3Converter
           [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."
+        #TRANSLATORS 'PClassType' and 'PResourceType' are Puppet types and should not be translated
+        raise ArgumentError, _("Cannot split the type %{class_name}, it represents neither a PClassType, nor a PResourceType.") %
+            { class_name: catalog_type.class }
     end
   end
 
@@ -164,7 +169,7 @@ end
 class Runtime3FunctionArgumentConverter < Runtime3Converter
 
   def convert_Regexp(o, scope, undef_value)
-    # Puppet 3x cannot handle parameter values that are reqular expressions. Turn into regexp string in
+    # Puppet 3x cannot handle parameter values that are regular expressions. Turn into regexp string in
     # source form
     o.inspect
   end
@@ -194,6 +199,22 @@ class Runtime3FunctionArgumentConverter < Runtime3Converter
     o.to_s
   end
 
+  # Converts result back to 4.x by replacing :undef with nil in Array and Hash objects
+  #
+  def self.convert_return(val3x)
+    if val3x == :undef
+      nil
+    elsif val3x.is_a?(Array)
+      val3x.map {|v| convert_return(v) }
+    elsif val3x.is_a?(Hash)
+      hsh = {}
+      val3x.each_pair {|k,v| hsh[convert_return(k)] = convert_return(v)}
+      hsh
+    else
+      val3x
+    end
+  end
+
   @instance = self.new
 end
 

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

@@ -28,7 +28,7 @@ module Runtime3ResourceSupport
     # from the raised exception. (It may be good enough).
     unless resolved_type
       # TODO: do this the right way
-      raise ArgumentError, "Unknown resource type: '#{type_name}'"
+      raise ArgumentError, _("Unknown resource type: '%{type}'") % { type: type_name }
     end
 
     # Build a resource for each title - use the resolved *type* as opposed to a reference
@@ -60,7 +60,7 @@ module Runtime3ResourceSupport
         # Classes are evaluated immediately
         scope.compiler.evaluate_classes([resource_title], scope, false) if resolved_type == CLASS_STRING
 
-        # Turn the resource into a PType (a reference to a resource type)
+        # Turn the resource into a PTypeType (a reference to a resource type)
         # weed out nil's
         resource_to_ptype(resource)
     end
@@ -89,8 +89,6 @@ module Runtime3ResourceSupport
     scope.environment.known_resource_types.find_hostclass(class_name)
   end
 
-  private
-
   def self.find_builtin_resource_type(scope, type_name)
     if type_name.include?(':')
       # Skip the search for built in types as they are always in global namespace
@@ -106,11 +104,13 @@ module Runtime3ResourceSupport
     # horrible - should be loaded by a "last loader" in 4.x loaders instead.
     Puppet::Type.type(type_name)
   end
+  private_class_method :find_builtin_resource_type
 
   def self.find_defined_resource_type(scope, type_name)
     krt = scope.environment.known_resource_types
     krt.find_definition(type_name) || krt.application(type_name)
   end
+  private_class_method :find_defined_resource_type
 
 end
 end

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

@@ -20,7 +20,7 @@ module Runtime3Support
   def fail(issue, semantic, options={}, except=nil)
     optionally_fail(issue, semantic, options, except)
     # an error should have been raised since fail always fails
-    raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
+    raise ArgumentError, _("Internal Error: Configuration of runtime error handling wrong: should have raised exception")
   end
 
   # Optionally (based on severity) Fails the evaluation of _semantic_ with a given issue
@@ -55,13 +55,8 @@ module Runtime3Support
   #
   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
+    file, line = Puppet::Pops::PuppetStack.top_of_stack
+
     # Use a SemanticError as the sourcepos
     semantic = Puppet::Pops::SemanticError.new(issue, nil, options.merge({:file => file, :line => line}))
     optionally_fail(issue,  semantic)
@@ -150,7 +145,7 @@ module Runtime3Support
     # case - it is just wrong, the error should be reported by the caller who knows in more detail where it
     # is in the source.
     #
-    raise ArgumentError, "Internal error - attempt to create a local scope without a hash" unless hash.is_a?(Hash)
+    raise ArgumentError, _("Internal error - attempt to create a local scope without a hash") unless hash.is_a?(Hash)
     scope.ephemeral_from(hash)
   end
 
@@ -288,7 +283,7 @@ module Runtime3Support
     end
 
     # Call via 3x API if function exists there
-    raise ArgumentError, "Unknown function '#{name}'" unless Puppet::Parser::Functions.function(name)
+    raise ArgumentError, _("Unknown function '%{name}'") % { 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
@@ -301,21 +296,23 @@ module Runtime3Support
   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)
+    # 'ruby -wc' thinks that _func is unused, because the only reference to it
+    # is inside of the Kernel.eval string below. By prefixing it with the
+    # underscore, we let Ruby know to not worry about whether it's unused or not.
+    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)
+        return Kernel.eval('_func.call(scope, *args, &block)'.freeze, Kernel.binding, file || '', line)
       end
     end
-    # Call via 3x API if function exists there
+    # Call via 3x API if function exists there without having been autoloaded
     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
+    # The 3x function performs return value mapping and returns nil if it is not of rvalue type
+    Puppet::Pops::PuppetStack.stack(file, line, scope, "function_#{name}", [mapped_args], &block)
   end
 
   # The o is used for source reference
@@ -330,8 +327,7 @@ module Runtime3Support
   end
 
   def convert(value, scope, undef_value)
-    converter = scope.environment.rich_data? ? Runtime3Converter.instance : Runtime3FunctionArgumentConverter.instance
-    converter.convert(value, scope, undef_value)
+    Runtime3Converter.instance.convert(value, scope, undef_value)
   end
 
   def create_resources(o, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
@@ -375,7 +371,7 @@ module Runtime3Support
     evaluated_parameters = evaluated_parameters.flatten
     evaluated_resources.each do |r|
       unless r.is_a?(Types::PResourceType) && r.type_name != 'class'
-        fail(Issues::ILLEGAL_OVERRIDEN_TYPE, o, {:actual => r} )
+        fail(Issues::ILLEGAL_OVERRIDDEN_TYPE, o, {:actual => r} )
       end
       t = Runtime3ResourceSupport.find_resource_type(scope, r.type_name)
       resource = Puppet::Parser::Resource.new(
@@ -510,6 +506,7 @@ module Runtime3Support
       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_DEFAULT_CONVERTED_TO_STRING] = Puppet[:strict] == :off ? :warning : 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
@@ -525,7 +522,7 @@ module Runtime3Support
         :exception_class => Puppet::PreformattedError
       })
       if errors?
-        raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
+        raise ArgumentError, _("Internal Error: Configuration of runtime error handling wrong: should have raised exception")
       end
     end
   end

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

@@ -1,5 +1,5 @@
 module Puppet::Pops
-  module Functions
+module Functions
 # Defines a connection between a implementation method and the signature that
 # the method will handle.
 #
@@ -72,14 +72,21 @@ class Dispatch < Evaluator::CallableSignature
       new_args = []
       @weaving.each do |knit|
         if knit.is_a?(Array)
-          injection_data = @injections[knit[0]]
+          injection_name = @injections[knit[0]]
           new_args <<
-            case injection_data[3]
-            when :dispatcher_internal
-              # currently only supports :scope injection
+            case injection_name
+            when :scope
               scope
+            when :pal_script_compiler
+              Puppet.lookup(:pal_script_compiler)
+            when :cache
+              Puppet::Pops::Adapters::ObjectIdCacheAdapter.adapt(scope.compiler)
+            when :pal_catalog_compiler
+              Puppet.lookup(:pal_catalog_compiler)
+            when :pal_compiler
+              Puppet.lookup(:pal_compiler)
             else
-              raise_error ArgumentError, "Unknown injection #{injection_data[3]}"
+              raise ArgumentError, _("Unknown injection %{injection_name}") % { injection_name: injection_name }
             end
         else
           # Careful so no new nil arguments are added since they would override default

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

@@ -49,13 +49,13 @@ class Puppet::Pops::Functions::Function
     rescue Puppet::Pops::Evaluator::Next => jumper
       begin
         throw :next, jumper.value
-      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION => uncaught
+      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
         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
+      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
         raise Puppet::ParseError.new("return() from context where this is illegal", jumper.file, jumper.line)
       end
     end
@@ -108,7 +108,10 @@ class Puppet::Pops::Functions::Function
   def internal_call_function(scope, function_name, args, &block)
 
     the_loader = loader
-    raise ArgumentError, "Function #{self.class.name}(): cannot call function '#{function_name}' - no loader specified" unless the_loader
+    unless the_loader
+      raise ArgumentError, _("Function %{class_name}(): cannot call function '%{function_name}' - no loader specified") %
+          { class_name: self.class.name, function_name: function_name }
+    end
 
     func = the_loader.load(:function, function_name)
     if func
@@ -121,7 +124,10 @@ class Puppet::Pops::Functions::Function
     # 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}(): Unknown function: '#{function_name}'" unless func_3x
+    unless func_3x
+      raise ArgumentError, _("Function %{class_name}(): Unknown function: '%{function_name}'") %
+          { class_name: self.class.name, function_name: function_name }
+    end
 
     # Call via 3x API
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.