puppet 5.0.0 → 6.0.0

data/lib/puppet/parser/functions/sprintf.rb

@@ -29,8 +29,33 @@ Puppet::Parser::Functions::newfunction(
   :arity => -2,
   :doc => "Perform printf-style formatting of text.
 
-      The first parameter is format string describing how the rest of the parameters should be formatted.  See the documentation for the `Kernel::sprintf` function in Ruby for all the details."
+  The first parameter is format string describing how the rest of the parameters should be formatted.
+  See the documentation for the [`Kernel::sprintf` function](https://ruby-doc.org/core/Kernel.html)
+  in Ruby for details.
+  
+  To use [named format](https://idiosyncratic-ruby.com/49-what-the-format.html) arguments, provide a
+  hash containing the target string values as the argument to be formatted. For example:
+
+  ```puppet
+  notice sprintf(\"%<x>s : %<y>d\", { 'x' => 'value is', 'y' => 42 })
+  ```
+
+  This statement produces a notice of `value is : 42`."
+
 ) do |args|
-  fmt = args.shift
-  return sprintf(fmt, *args)
+  fmt = args[0]
+  args = args[1..-1]
+  begin
+    return sprintf(fmt, *args)
+  rescue KeyError => e
+    if args.size == 1 && args[0].is_a?(Hash)
+      # map the single hash argument such that all top level string keys are symbols
+      # as that allows named arguments to be used in the format string.
+      #
+      result = {}
+      args[0].each_pair { |k,v| result[k.is_a?(String) ? k.to_sym : k] = v }
+      return sprintf(fmt, result)
+    end
+    raise e
+  end
 end

data/lib/puppet/parser/functions/step.rb

@@ -4,7 +4,7 @@ Puppet::Parser::Functions::newfunction(
   :arity => -1,
   :doc => <<-DOC
 Provides stepping with given interval over elements in an iterable and optionally runs a
-[lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) for each
+[lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) for each
 element.
 
 This function takes two to three arguments:
@@ -80,5 +80,5 @@ $transformed_data contains [0,50,100,150,200]
 
 DOC
 ) do |args|
-  Error.is4x('step')
+  Puppet::Parser::Functions::Error.is4x('step')
 end

data/lib/puppet/parser/functions/strftime.rb

@@ -181,5 +181,5 @@ notice($duration.strftime('%M:%S')) # outputs '200:30'
 - Since 4.8.0
 DOC
 ) do |args|
-  Error.is4x('strftime')
+  Puppet::Parser::Functions::Error.is4x('strftime')
 end

data/lib/puppet/parser/functions/tag.rb

@@ -2,5 +2,11 @@
 Puppet::Parser::Functions::newfunction(:tag, :arity => -2, :doc => "Add the specified tags to the containing class
   or definition.  All contained objects will then acquire that tag, also.
   ") do |vals|
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'tag'})
+    end
+
     self.resource.tag(*vals)
 end

data/lib/puppet/parser/functions/tagged.rb

@@ -3,12 +3,15 @@ Puppet::Parser::Functions::newfunction(:tagged, :type => :rvalue, :arity => -2,
   tells you whether the current container is tagged with the specified tags.
   The tags are ANDed, so that all of the specified tags must be included for
   the function to return true.") do |vals|
-    configtags = compiler.catalog.tags
-    resourcetags = resource.tags
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'tagged'})
+    end
 
     retval = true
     vals.each do |val|
-      unless configtags.include?(val) or resourcetags.include?(val)
+      unless compiler.catalog.tagged?(val) or resource.tagged?(val)
         retval = false
         break
       end

data/lib/puppet/parser/functions/template.rb

@@ -12,6 +12,11 @@ Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :arity => -2
   * An absolute path, which can load a template file from anywhere on disk.
   * Multiple arguments, which will evaluate all of the specified templates and
   return their outputs concatenated into a single string.") do |vals|
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::FEATURE_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:feature => 'ERB template'})
+    end
     vals.collect do |file|
       # Use a wrapper, so the template can't get access to the full
       # Scope object.
@@ -23,8 +28,12 @@ Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :arity => -2
         wrapper.result
       rescue => detail
         info = detail.backtrace.first.split(':')
-        raise Puppet::ParseError,
-          "Failed to parse template #{file}:\n  Filepath: #{info[0]}\n  Line: #{info[1]}\n  Detail: #{detail}\n"
+        message = []
+        message << _("Failed to parse template %{file}:") % { file: file }
+        message << _("  Filepath: %{file_path}") % { file_path: info[0] }
+        message << _("  Line: %{line}") % { line: info[1] }
+        message << _("  Detail: %{detail}") % { detail: detail }
+        raise Puppet::ParseError, message.join("\n") + "\n"
       end
     end.join("")
 end

data/lib/puppet/parser/functions/then.rb

@@ -3,7 +3,7 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -2,
   :doc => <<-DOC
-Call a [lambda](https://docs.puppet.com/puppet/latest/reference/lang_lambdas.html)
+Call a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 with the given argument unless the argument is undef. Return `undef` if argument is
 `undef`, and otherwise the result of giving the argument to the lambda.
 
@@ -69,5 +69,5 @@ was not a String.
 
 DOC
 ) do |args|
-  Error.is4x('then')
+  Puppet::Parser::Functions::Error.is4x('then')
 end

data/lib/puppet/parser/functions/type.rb

@@ -49,5 +49,5 @@ function type(Any $value, InferenceFidelity $fidelity = 'detailed') # returns Ty
 
 DOC
 ) do |args|
-  Error.is4x('type')
+  Puppet::Parser::Functions::Error.is4x('type')
 end

data/lib/puppet/parser/functions/with.rb

@@ -3,11 +3,11 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -1,
   :doc => <<-DOC
-Call a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+Call a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 with the given arguments and return the result. Since a lambda's scope is
-[local](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html#lambda-scope)
-to the lambda, you can use the `with` function to create private blocks of code within a
-class using variables whose values cannot be accessed outside of the lambda.
+local to the lambda, you can use the `with` function to create private blocks
+of code within a class using variables whose values cannot be accessed outside
+of the lambda.
 
 **Example**: Using `with`
 
@@ -24,5 +24,5 @@ $check_var = $x
 - Since 4.0.0
 DOC
 ) do |args|
-  Error.is4x('with')
+  Puppet::Parser::Functions::Error.is4x('with')
 end

data/lib/puppet/parser/functions.rb

@@ -30,11 +30,43 @@ module Puppet::Parser::Functions
     end
   end
 
+  class AutoloaderDelegate
+    attr_reader :delegatee
+
+    def initialize
+      @delegatee = Puppet::Util::Autoload.new(self, "puppet/parser/functions")
+    end
+
+    def loadall(env = Puppet.lookup(:current_environment))
+      if Puppet[:strict] != :off
+        Puppet.warn_once('deprecations', 'Puppet::Parser::Functions#loadall', _("The method 'Puppet::Parser::Functions.autoloader#loadall' is deprecated in favor of using 'Scope#call_function'."))
+      end
+
+      @delegatee.loadall(env)
+    end
+
+    def load(name, env = Puppet.lookup(:current_environment))
+      if Puppet[:strict] != :off
+        Puppet.warn_once('deprecations', "Puppet::Parser::Functions#load('#{name}')", _("The method 'Puppet::Parser::Functions.autoloader#load(\"%{name}\")' is deprecated in favor of using 'Scope#call_function'.") % {name: name})
+      end
+
+      @delegatee.load(name, env)
+    end
+
+    def loaded?(name)
+      if Puppet[:strict] != :off
+        Puppet.warn_once('deprecations', "Puppet::Parser::Functions.loaded?('#{name}')", _("The method 'Puppet::Parser::Functions.autoloader#loaded?(\"%{name}\")' is deprecated in favor of using 'Scope#call_function'.") % {name: name})
+      end
+
+      @delegatee.loaded?(name)
+    end
+  end
+
   # Accessor for singleton autoloader
   #
   # @api private
   def self.autoloader
-    @autoloader ||= Puppet::Util::Autoload.new(self, "puppet/parser/functions")
+    @autoloader ||= AutoloaderDelegate.new
   end
 
   # An adapter that ties the anonymous module that acts as the container for all 3x functions to the environment
@@ -82,7 +114,7 @@ module Puppet::Parser::Functions
   # extend the behavior and functionality of Puppet.
   #
   # See also [Docs: Custom
-  # Functions](https://docs.puppetlabs.com/guides/custom_functions.html)
+  # Functions](https://puppet.com/docs/puppet/5.5/lang_write_functions_in_puppet.html)
   #
   # @example Define a new Puppet DSL Function
   #     >> Puppet::Parser::Functions.newfunction(:double, :arity => 1,
@@ -152,7 +184,7 @@ module Puppet::Parser::Functions
     ftype = options[:type] || :statement
 
     unless ftype == :statement or ftype == :rvalue
-      raise Puppet::DevError, "Invalid statement type #{ftype.inspect}"
+      raise Puppet::DevError, _("Invalid statement type %{type}") % { type: ftype.inspect }
     end
 
     # the block must be installed as a method because it may use "return",
@@ -171,7 +203,9 @@ module Puppet::Parser::Functions
           elsif arity < 0 and args[0].size < (arity+1).abs
             raise ArgumentError, _("%{name}(): Wrong number of arguments given (%{arg_count} for minimum %{min_arg_count})") % { name: name, arg_count: args[0].size, min_arg_count: (arity+1).abs }
           end
-          self.send(real_fname, args[0])
+          r = Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.convert_return(self.send(real_fname, args[0]))
+          # avoid leaking aribtrary value if not being an rvalue function
+          options[:type] == :rvalue ? r : nil
         else
           raise ArgumentError, _("custom functions must be called with a single array that contains the arguments. For example, function_example([1]) instead of function_example(1)")
         end
@@ -198,9 +232,8 @@ module Puppet::Parser::Functions
   def self.function(name, environment = Puppet.lookup(:current_environment))
     name = name.intern
 
-    func = nil
     unless func = get_function(name, environment)
-      autoloader.load(name, environment)
+      autoloader.delegatee.load(name, environment)
       func = get_function(name, environment)
     end
 
@@ -212,7 +245,7 @@ module Puppet::Parser::Functions
   end
 
   def self.functiondocs(environment = Puppet.lookup(:current_environment))
-    autoloader.loadall
+    autoloader.delegatee.loadall(environment)
 
     ret = ""
 

data/lib/puppet/parser/parser_factory.rb

@@ -16,7 +16,7 @@ module Puppet::Parser
     # EvaluatingParser to the 3x way of parsing.
     #
     def self.evaluating_parser
-      unless defined?(Puppet::Pops::Parser::E4ParserAdapter)
+      unless defined?(Puppet::Parser::E4ParserAdapter)
         require 'puppet/parser/e4_parser_adapter'
         require 'puppet/pops/parser/code_merger'
       end

data/lib/puppet/parser/relationship.rb

@@ -67,14 +67,14 @@ class Puppet::Parser::Relationship
     end
   end
 
-  # Turns a PResourceType or PHostClassType into an array [type, title] and all other references to [ref, nil]
+  # Turns a PResourceType or PClassType into an array [type, title] and all other references to [ref, nil]
   # This is needed since it is not possible to find resources in the catalog based on the type system types :-(
   # (note, the catalog is also used on the agent side)
   def canonical_ref(ref)
     case ref
     when Puppet::Pops::Types::PResourceType
       [ref.type_name, ref.title]
-    when Puppet::Pops::Types::PHostClassType
+    when Puppet::Pops::Types::PClassType
       ['class', ref.class_name]
     else
       [ref.to_s, nil]

data/lib/puppet/parser/resource/param.rb

@@ -2,14 +2,21 @@
 class Puppet::Parser::Resource::Param
   include Puppet::Util
   include Puppet::Util::Errors
-  include Puppet::Util::MethodHelper
 
   attr_accessor :name, :value, :source, :add, :file, :line
 
-  def initialize(hash)
-    set_options(hash)
-    requiredopts(:name)
-    @name = @name.intern
+  def initialize(name: nil, value: nil, source: nil, line: nil, file: nil, add: nil)
+    @value = value
+    @source = source
+    @line = line
+    @file = file
+    @add = add
+
+    unless name
+      # This must happen after file and line are set to have them reported in the error
+      self.fail(Puppet::ResourceError, "'name' is a required option for #{self.class}")
+    end
+    @name = name.intern
   end
 
   def line_to_i

data/lib/puppet/parser/resource.rb

@@ -8,7 +8,6 @@ class Puppet::Parser::Resource < Puppet::Resource
   require 'puppet/util/tagging'
 
   include Puppet::Util
-  include Puppet::Util::MethodHelper
   include Puppet::Util::Errors
   include Puppet::Util::Logging
 
@@ -167,6 +166,25 @@ class Puppet::Parser::Resource < Puppet::Resource
     unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
       raise Puppet::ParseError.new(_("Only subclasses can override parameters"), resource.file, resource.line)
     end
+
+    if evaluated?
+      error_location_str = Puppet::Util::Errors.error_location(file, line)
+      msg = if error_location_str.empty?
+              _('Attempt to override an already evaluated resource with new values')
+            else
+              _('Attempt to override an already evaluated resource, defined at %{error_location}, with new values') % { error_location: error_location_str }
+            end
+      strict = Puppet[:strict]
+      unless strict == :off
+        if strict == :error
+          raise Puppet::ParseError.new(msg, resource.file, resource.line)
+        else
+          msg += Puppet::Util::Errors.error_location_with_space(resource.file, resource.line)
+          Puppet.warning(msg)
+        end
+      end
+    end
+
     # Some of these might fail, but they'll fail in the way we want.
     resource.parameters.each do |name, param|
       override_parameter(param)
@@ -258,7 +276,7 @@ class Puppet::Parser::Resource < Puppet::Resource
       t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
       cap = catalog.resource(t, ref.title)
       if cap.nil?
-        raise _("Resource %{ref} could not be found; it might not have been produced yet") % { ref: ref }
+        raise Puppet::Error, _("Resource %{ref} could not be found; it might not have been produced yet") % { ref: ref }
       end
 
       # Ensure that the found resource is a capability resource
@@ -313,7 +331,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   def add_scope_tags
     scope_resource = scope.resource
     unless scope_resource.nil? || scope_resource.equal?(self)
-      merge_tags(scope_resource)
+      merge_tags_from(scope_resource)
     end
   end
 
@@ -337,15 +355,24 @@ class Puppet::Parser::Resource < Puppet::Resource
 
     # The parameter is already set.  Fail if they're not allowed to override it.
     unless param.source.child_of?(current.source) || param.source.equal?(current.source) && scope.is_default?(type, param.name, current.value)
-      msg = "Parameter '#{param.name}' is already set on #{self}"
-      msg += " by #{current.source}" if current.source.to_s != ""
-      if current.file or current.line
-        fields = []
-        fields << current.file if current.file
-        fields << current.line.to_s if current.line
-        msg += " at #{fields.join(":")}"
-      end
-      msg += "; cannot redefine"
+      error_location_str = Puppet::Util::Errors.error_location(current.file, current.line)
+      msg = if current.source.to_s == ''
+              if error_location_str.empty?
+                _("Parameter '%{name}' is already set on %{resource}; cannot redefine") %
+                    { name: param.name, resource: ref }
+              else
+                _("Parameter '%{name}' is already set on %{resource} at %{error_location}; cannot redefine") %
+                    { name: param.name, resource: ref, error_location: error_location_str }
+              end
+            else
+              if error_location_str.empty?
+                _("Parameter '%{name}' is already set on %{resource} by %{source}; cannot redefine") %
+                    { name: param.name, resource: ref, source: current.source.to_s }
+              else
+                _("Parameter '%{name}' is already set on %{resource} by %{source} at %{error_location}; cannot redefine") %
+                    { name: param.name, resource: ref, source: current.source.to_s, error_location: error_location_str }
+              end
+            end
       raise Puppet::ParseError.new(msg, param.file, param.line)
     end
 

data/lib/puppet/parser/scope.rb

@@ -7,8 +7,6 @@ require 'puppet/parser'
 require 'puppet/parser/templatewrapper'
 require 'puppet/parser/resource'
 
-require 'puppet/util/methodhelper'
-
 # This class is part of the internal parser/evaluator/compiler functionality of Puppet.
 # It is passed between the various classes that participate in evaluation.
 # None of its methods are API except those that are clearly marked as such.
@@ -16,7 +14,6 @@ require 'puppet/util/methodhelper'
 # @api public
 class Puppet::Parser::Scope
   extend Forwardable
-  include Puppet::Util::MethodHelper
 
   # Variables that always exist with nil value even if not set
   BUILT_IN_VARS = ['module_name'.freeze, 'caller_module_name'.freeze].freeze
@@ -374,14 +371,15 @@ class Puppet::Parser::Scope
   end
 
   # Initialize our new scope.  Defaults to having no parent.
-  def initialize(compiler, options = EMPTY_HASH)
-    if compiler.is_a? Puppet::Parser::Compiler
+  def initialize(compiler, source: nil, resource: nil)
+    if compiler.is_a? Puppet::Parser::AbstractCompiler
       @compiler = compiler
     else
-      raise Puppet::DevError, "you must pass a compiler instance to a new scope object"
+      raise Puppet::DevError, _("you must pass a compiler instance to a new scope object")
     end
 
-    set_options(options)
+    @source = source
+    @resource = resource
 
     extend_with_functions_module
 
@@ -611,6 +609,7 @@ class Puppet::Parser::Scope
       begin
         qs = qualified_scope(class_name)
         unless qs.nil?
+          return qs.get_local_variable(leaf_name) if qs.has_local_variable?(leaf_name)
           iscope = qs.inherited_scope
           return lookup_qualified_variable("#{iscope.source.name}::#{leaf_name}", options) unless iscope.nil?
         end
@@ -623,15 +622,23 @@ class Puppet::Parser::Scope
     return handle_not_found('', fqn, options)
   end
 
+  # @api private
+  def has_local_variable?(name)
+    @ephemeral.last.include?(name)
+  end
+
+  # @api private
+  def get_local_variable(name)
+    @ephemeral.last[name]
+  end
+
   def handle_not_found(class_name, variable_name, position, reason = nil)
     unless Puppet[:strict_variables]
       # Do not issue warning if strict variables are on, as an error will be raised by variable_not_found
       location = if position[:lineproc]
-                   " at #{position[:lineproc].call}"
-                 elsif position[:file] && position[:line]
-                   " at #{position[:file]}:#{position[:line]}"
+                   Puppet::Util::Errors.error_location_with_space(nil, position[:lineproc].call)
                  else
-                   ""
+                   Puppet::Util::Errors.error_location_with_space(position[:file], position[:line])
                  end
       variable_not_found("#{class_name}::#{variable_name}", "#{reason}#{location}")
       return nil
@@ -699,7 +706,8 @@ class Puppet::Parser::Scope
 
   # Merge all settings for the given _env_name_ into this scope
   # @param env_name [Symbol] the name of the environment
-  def merge_settings(env_name)
+  # @param set_in_this_scope [Boolean] if the settings variables should also be set in this instance of scope
+  def merge_settings(env_name, set_in_this_scope=true)
     settings = Puppet.settings
     table = effective_symtable(false)
     global_table = compiler.qualified_variables
@@ -708,7 +716,9 @@ class Puppet::Parser::Scope
       next if :name == name
       key = name.to_s
       value = transform_setting(settings.value_sym(name, env_name))
-      table[key] = value
+      if set_in_this_scope
+        table[key] = value
+      end
       all_local[key] = value
       # also write the fqn into global table for direct lookup
       global_table["settings::#{key}"] = value
@@ -751,7 +761,7 @@ class Puppet::Parser::Scope
       raise Puppet::ParseError.new(_("Cannot assign to a numeric match result variable '$%{name}'") % { name: name }) # unless options[:ephemeral]
     end
     unless name.is_a? String
-      raise Puppet::ParseError, _("Scope variable name %{value0} is a %{value1}, not a string") % { value0: name.inspect, value1: name.class }
+      raise Puppet::ParseError, _("Scope variable name %{name} is a %{class_type}, not a string") % { name: name.inspect, class_type: name.class }
     end
 
     # Check for reserved variable names
@@ -759,8 +769,8 @@ class Puppet::Parser::Scope
       raise Puppet::ParseError, _("Attempt to assign to a reserved variable name: '%{name}'") % { name: name }
     end
 
-    # Check for server_facts reserved variable name if the trusted_sever_facts setting is true
-    if name == VARNAME_SERVER_FACTS && !options[:privileged] && Puppet[:trusted_server_facts]
+    # Check for server_facts reserved variable name
+    if name == VARNAME_SERVER_FACTS && !options[:privileged]
       raise Puppet::ParseError, _("Attempt to assign to a reserved variable name: '%{name}'") % { name: name }
     end
 
@@ -804,7 +814,7 @@ class Puppet::Parser::Scope
   end
 
   # Deeply freezes the given object. The object and its content must be of the types:
-  # Array, Hash, Numeric, Boolean, Symbol, Regexp, NilClass, or String. All other types raises an Error.
+  # Array, Hash, Numeric, Boolean, Regexp, NilClass, or String. All other types raises an Error.
   # (i.e. if they are assignable to Puppet::Pops::Types::Data type).
   #
   def deep_freeze(object)
@@ -859,7 +869,25 @@ class Puppet::Parser::Scope
 
   # Used mainly for logging
   def to_s
-    "Scope(#{@resource})"
+    # As this is used for logging, this should really not be done in this class at all...
+    return "Scope(#{@resource})" unless @resource.nil?
+
+    # For logging of function-scope - it is now showing the file and line.
+    detail = Puppet::Pops::PuppetStack.top_of_stack
+    return "Scope()" if detail.empty?
+
+    # shorten the path if possible
+    path = detail[0]
+    env_path = nil
+    env_path = environment.configuration.path_to_env unless (environment.nil? || environment.configuration.nil?)
+    # check module paths first since they may be in the environment (i.e. they are longer)
+    if module_path = environment.full_modulepath.detect {|m_path| path.start_with?(m_path) }
+      path = "<module>" + path[module_path.length..-1]
+    elsif env_path && path && path.start_with?(env_path)
+      path = "<env>" + path[env_path.length..-1]
+    end
+    # Make the output appear as "Scope(path, line)"
+    "Scope(#{[path, detail[1]].join(', ')})" 
   end
 
   alias_method :inspect, :to_s
@@ -986,17 +1014,17 @@ class Puppet::Parser::Scope
 
   # @api private
   def find_resource_type(type)
-    raise Puppet::DevError, "Scope#find_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
+    raise Puppet::DevError, _("Scope#find_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead")
   end
 
   # @api private
   def find_builtin_resource_type(type)
-    raise Puppet::DevError, "Scope#find_builtin_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
+    raise Puppet::DevError, _("Scope#find_builtin_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead")
   end
 
   # @api private
   def find_defined_resource_type(type)
-    raise Puppet::DevError, "Scope#find_defined_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
+    raise Puppet::DevError, _("Scope#find_defined_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead")
   end
 
 
@@ -1010,14 +1038,14 @@ class Puppet::Parser::Scope
     if respond_to? method
       send(method, *args)
     else
-      raise Puppet::DevError, "Function #{name} not defined despite being loaded!"
+      raise Puppet::DevError, _("Function %{name} not defined despite being loaded!") % { name: name }
     end
   end
 
   # To be removed when enough time has passed after puppet 5.0.0
   # @api private
   def resolve_type_and_titles(type, titles)
-    raise Puppet::DevError, "Scope#resolve_type_and_title() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
+    raise Puppet::DevError, _("Scope#resolve_type_and_title() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead")
   end
 
   # Transforms references to classes to the form suitable for
@@ -1036,14 +1064,17 @@ class Puppet::Parser::Scope
   def transform_and_assert_classnames(names)
     names.map do |name|
       case name
+      when NilClass
+        raise ArgumentError, _("Cannot use undef as a class name")
       when String
+        raise ArgumentError, _("Cannot use empty string as a class name") if name.empty?
         name.sub(/^([^:]{1,2})/, '::\1')
 
       when Puppet::Resource
         assert_class_and_title(name.type, name.title)
         name.title.sub(/^([^:]{1,2})/, '::\1')
 
-      when Puppet::Pops::Types::PHostClassType
+      when Puppet::Pops::Types::PClassType
         #TRANSLATORS "Class" and "Type" are Puppet keywords and should not be translated
         raise ArgumentError, _("Cannot use an unspecific Class[] Type") unless name.class_name
         name.class_name.sub(/^([^:]{1,2})/, '::\1')