puppet 5.0.0 → 6.0.0

data/lib/puppet/node/environment.rb

@@ -85,7 +85,6 @@ class Puppet::Node::Environment
     @modulepath = modulepath
     @manifest = manifest
     @config_version = config_version
-    @modules_strict_semver = false
   end
 
   # Creates a new Puppet::Node::Environment instance, overriding any of the passed
@@ -240,22 +239,6 @@ class Puppet::Node::Environment
     Puppet.settings.value(param, self.name)
   end
 
-  # A SemanticPuppet::VersionRange version >= 1.0.0 will not include versions with pre-release
-  # identifiers unless that is explicitly declared. This may cause backward compatibility
-  # issues when resolving module dependencies and the flag is therefore set to `false` by default.
-  #
-  # @param flag [Boolean] set to true to resolve module dependencies using strict SemVer semantics
-  #
-  def modules_strict_semver=(flag)
-    @modules_strict_semver = flag
-  end
-
-  # @return [Boolean] the current value of the modules_strict_semver flag.
-  # @api public
-  def modules_strict_semver?
-    @modules_strict_semver
-  end
-
   # @api public
   # @return [Puppet::Resource::TypeCollection] The current global TypeCollection
   def known_resource_types
@@ -295,7 +278,7 @@ class Puppet::Node::Environment
   # @param forge_name [String] The module name
   # @return [Puppet::Module, nil] The module if found, else nil
   def module_by_forge_name(forge_name)
-    author, modname = forge_name.split('/')
+    _, modname = forge_name.split('/')
     found_mod = self.module(modname)
     found_mod and found_mod.forge_name == forge_name ?
       found_mod :
@@ -330,7 +313,7 @@ class Puppet::Node::Environment
 
       @modules = module_references.collect do |reference|
         begin
-          Puppet::Module.new(reference[:name], reference[:path], self, modules_strict_semver?)
+          Puppet::Module.new(reference[:name], reference[:path], self)
         rescue Puppet::Module::Error => e
           Puppet.log_exception(e)
           nil
@@ -372,7 +355,7 @@ class Puppet::Node::Environment
             Puppet::Module.is_module_directory?(name, path)
           end
           modules_by_path[path] = module_names.sort.map do |name|
-            Puppet::Module.new(name, File.join(path, name), self, modules_strict_semver?)
+            Puppet::Module.new(name, File.join(path, name), self)
           end
         end
       else
@@ -433,6 +416,26 @@ class Puppet::Node::Environment
     deps
   end
 
+  # Loads module translations for the current environment once for
+  # the lifetime of the environment. Execute a block in the context
+  # of that translation domain.
+  def with_text_domain
+    return yield if Puppet[:disable_i18n]
+
+    if @text_domain.nil?
+      @text_domain = @name
+      Puppet::GettextConfig.reset_text_domain(@text_domain)
+      Puppet::ModuleTranslations.load_from_modulepath(modules)
+    else
+      Puppet::GettextConfig.use_text_domain(@text_domain)
+    end
+
+    yield
+  ensure
+    # Is a noop if disable_i18n is true
+    Puppet::GettextConfig.clear_text_domain
+  end
+
   # Checks if a reparse is required (cache of files is stale).
   #
   def check_for_reparse

data/lib/puppet/node/facts.rb

@@ -59,6 +59,15 @@ class Puppet::Node::Facts
     end
   end
 
+  # Add extra values, such as facts given to lookup on the command line. The
+  # extra values will override existing values.
+  # @param extra_values [Hash{String=>Object}] the values to add
+  # @api private
+  def add_extra_values(extra_values)
+    @values.merge!(extra_values)
+    nil
+  end
+
   # Sanitize fact values by converting everything not a string, Boolean
   # numeric, array or hash into strings.
   def sanitize
@@ -122,7 +131,17 @@ class Puppet::Node::Facts
       or fact.is_a? String
       fact
     else
-      fact.to_s
+      result = fact.to_s
+      # The result may be ascii-8bit encoded without being a binary (low level object.inspect returns ascii-8bit string)
+      if result.encoding == Encoding::ASCII_8BIT
+        begin
+          result = result.encode(Encoding::UTF_8)
+        rescue
+          # return the ascii-8bit - it will be taken as a binary
+          result
+        end
+      end
+      result
     end
   end
 end

data/lib/puppet/node.rb

@@ -27,10 +27,11 @@ class Puppet::Node
     @name       = data['name']       || (raise ArgumentError, _("No name provided in serialized data"))
     @classes    = data['classes']    || []
     @parameters = data['parameters'] || {}
-    env_name = data['environment']
-    env_name = env_name.intern unless env_name.nil?
-    @environment_name = env_name
-    environment = env_name
+    env_name = data['environment'] || @parameters[ENVIRONMENT]
+    unless env_name.nil?
+      @parameters[ENVIRONMENT] = env_name
+      @environment_name = env_name.intern
+    end
   end
 
   def self.from_data_hash(data)
@@ -45,10 +46,17 @@ class Puppet::Node
       'environment' => environment.name.to_s,
     }
     result['classes'] = classes unless classes.empty?
-    result['parameters'] = parameters unless parameters.empty?
+    serialized_params = self.serializable_parameters
+    result['parameters'] = serialized_params unless serialized_params.empty?
     result
   end
 
+  def serializable_parameters
+    new_params = parameters.dup
+    new_params.delete(ENVIRONMENT)
+    new_params
+  end
+
   def environment
     if @environment
       @environment
@@ -60,7 +68,7 @@ class Puppet::Node
       else
         # This should not be :current_environment, this is the default
         # for a node when it has not specified its environment
-        # Tt will be used to establish what the current environment is.
+        # it will be used to establish what the current environment is.
         #
         self.environment = Puppet.lookup(:environments).get!(Puppet[:environment])
       end
@@ -78,7 +86,8 @@ class Puppet::Node
 
     # Keep environment_name attribute and parameter in sync if they have been set
     unless @environment.nil?
-      @parameters[ENVIRONMENT] = @environment.name.to_s if @parameters.include?(ENVIRONMENT)
+      # always set the environment parameter. It becomes top scope $environment for a manifest during catalog compilation.
+      @parameters[ENVIRONMENT] = @environment.name.to_s
       self.environment_name = @environment.name if instance_variable_defined?(:@environment_name)
     end
     @environment
@@ -132,7 +141,10 @@ class Puppet::Node
 
     if !@facts.nil?
       @facts.sanitize
+      # facts should never modify the environment parameter
+      orig_param_env = @parameters[ENVIRONMENT]
       merge(@facts.values)
+      @parameters[ENVIRONMENT] = orig_param_env
     end
   end
 
@@ -145,8 +157,16 @@ class Puppet::Node
         @parameters[name] = value
       end
     end
+  end
 
-    @parameters[ENVIRONMENT] ||= self.environment.name.to_s
+  # Add extra facts, such as facts given to lookup on the command line The
+  # extra facts will override existing ones.
+  # @param extra_facts [Hash{String=>Object}] the facts to tadd
+  # @api private
+  def add_extra_facts(extra_facts)
+    @facts.add_extra_values(extra_facts)
+    @parameters.merge!(extra_facts)
+    nil
   end
 
   def add_server_facts(facts)
@@ -206,4 +226,56 @@ class Puppet::Node
     Puppet.warning(_("Trusted node data modified for node %{name}") % { name: name }) unless @trusted_data.nil?
     @trusted_data = data.freeze
   end
+
+  # Resurrects and sanitizes trusted information in the node by modifying it and setting
+  # the trusted_data in the node from parameters.
+  # This modifies the node
+  #
+  def sanitize
+    # Resurrect "trusted information" that comes from node/fact terminus.
+    # The current way this is done in puppet db (currently the only one)
+    # is to store the node parameter 'trusted' as a hash of the trusted information.
+    #
+    # Thus here there are two main cases:
+    # 1. This terminus was used in a real agent call (only meaningful if someone curls the request as it would
+    #  fail since the result is a hash of two catalogs).
+    # 2  It is a command line call with a given node that use a terminus that:
+    # 2.1 does not include a 'trusted' fact - use local from node trusted information
+    # 2.2 has a 'trusted' fact - this in turn could be
+    # 2.2.1 puppet db having stored trusted node data as a fact (not a great design)
+    # 2.2.2 some other terminus having stored a fact called "trusted" (most likely that would have failed earlier, but could
+    #       be spoofed).
+    #
+    # For the reasons above, the resurrection of trusted node data with authenticated => true is only performed
+    # if user is running as root, else it is resurrected as unauthenticated.
+    #
+    trusted_param = @parameters['trusted']
+    if trusted_param
+      # Blows up if it is a parameter as it will be set as $trusted by the compiler as if it was a variable
+      @parameters.delete('trusted')
+      unless trusted_param.is_a?(Hash) && %w{authenticated certname extensions}.all? {|key| trusted_param.has_key?(key) }
+        # trusted is some kind of garbage, do not resurrect
+        trusted_param = nil
+      end
+    else
+      # trusted may be Boolean false if set as a fact by someone
+      trusted_param = nil
+    end
+
+    # The options for node.trusted_data in priority order are:
+    # 1) node came with trusted_data so use that
+    # 2) else if there is :trusted_information in the puppet context
+    # 3) else if the node provided a 'trusted' parameter (parsed out above)
+    # 4) last, fallback to local node trusted information
+    #
+    # Note that trusted_data should be a hash, but (2) and (4) are not
+    # hashes, so we to_h at the end
+    if !trusted_data
+      trusted = Puppet.lookup(:trusted_information) do
+        trusted_param || Puppet::Context::TrustedInformation.local(self)
+      end
+
+      self.trusted_data = trusted.to_h
+    end
+  end
 end

data/lib/puppet/parameter/boolean.rb

@@ -1,7 +1,7 @@
 require 'puppet/coercion'
 
 # This specialized {Puppet::Parameter} handles Boolean options, accepting lots
-# of strings and symbols for both truthiness and falsehood.
+# of strings and symbols for both truth and falsehood.
 #
 class Puppet::Parameter::Boolean < Puppet::Parameter
   def unsafe_munge(value)

data/lib/puppet/parameter/value_collection.rb

@@ -19,7 +19,7 @@ class Puppet::Parameter::ValueCollection
   def aliasvalue(name, other)
     other = other.to_sym
     unless value = match?(other)
-      raise Puppet::DevError, "Cannot alias nonexistent value #{other}"
+      raise Puppet::DevError, _("Cannot alias nonexistent value %{value}") % { value: other }
     end
 
     value.alias(name)
@@ -133,7 +133,10 @@ class Puppet::Parameter::ValueCollection
     call_opt = options[:call]
     unless call_opt.nil?
       devfail "Cannot use obsolete :call value '#{call_opt}' for property '#{self.class.name}'" unless call_opt == :none || call_opt == :instead
-      Puppet.deprecation_warning(_("Property option :call is deprecated and no longer used. Please remove it."))
+      #TRANSLATORS ':call' is a property and should not be translated
+      message = _("Property option :call is deprecated and no longer used.")
+      message += ' ' + _("Please remove it.")
+      Puppet.deprecation_warning(message)
       options = options.reject { |k,v| k == :call }
     end
 
@@ -180,13 +183,10 @@ class Puppet::Parameter::ValueCollection
   def validate(value)
     return if empty?
 
-    unless @values.detect { |name, v| v.match?(value) }
-      str = _("Invalid value %{value}. ") % { value: value.inspect }
-
-      str += _("Valid values are %{value_list}. ") % { value_list: values.join(", ") } unless values.empty?
-
-      str += _("Valid values match %{pattern}.") % { pattern: regexes.join(", ") } unless regexes.empty?
-
+    unless @values.detect {|name, v| v.match?(value)}
+      str = _("Invalid value %{value}.") % { value: value.inspect }
+      str += " " + _("Valid values are %{value_list}.") % { value_list: values.join(", ") } unless values.empty?
+      str += " " + _("Valid values match %{pattern}.") % { pattern: regexes.join(", ") } unless regexes.empty?
       raise ArgumentError, str
     end
   end

data/lib/puppet/parameter.rb

@@ -1,4 +1,3 @@
-require 'puppet/util/methodhelper'
 require 'puppet/util/logging'
 require 'puppet/util/docs'
 
@@ -22,7 +21,6 @@ class Puppet::Parameter
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Util::Logging
-  include Puppet::Util::MethodHelper
 
   require 'puppet/parameter/value_collection'
 
@@ -93,6 +91,14 @@ class Puppet::Parameter
       end
     end
 
+    def sensitive(value = nil, &block)
+      if block
+        define_method(:is_sensitive, &block)
+      else
+        define_method(:is_sensitive) do value end
+      end
+    end
+
     # Produces a documentation string.
     # If an enumeration of _valid values_ has been defined, it is appended to the documentation
     # for this parameter specified with the {desc} method.
@@ -332,16 +338,15 @@ class Puppet::Parameter
   # @api public
   # @note A parameter should be created via the DSL method {Puppet::Type::newparam}
   #
-  def initialize(options = {})
-    options = symbolize_options(options)
-    if resource = options[:resource]
+  def initialize(resource: nil, value: nil, should: nil)
+    if resource
       self.resource = resource
-      options.delete(:resource)
     else
-      raise Puppet::DevError, "No resource set for #{self.class.name}"
+      raise Puppet::DevError, _("No resource set for %{name}") % { name: self.class.name }
     end
 
-    set_options(options)
+    self.value = value if value
+    self.should = should if should
   end
 
   # Writes the given `msg` to the log with the loglevel indicated by the associated resource's
@@ -425,7 +430,7 @@ class Puppet::Parameter
       Puppet.debug "Reraising #{detail}"
       raise
     rescue => detail
-      raise Puppet::DevError, "Munging failed for value #{value.inspect} in class #{self.name}: #{detail}", detail.backtrace
+      raise Puppet::DevError, _("Munging failed for value %{value} in class %{class_name}: %{detail}") % { value: value.inspect, class_name: self.name, detail: detail }, detail.backtrace
     end
     ret
   end
@@ -459,7 +464,7 @@ class Puppet::Parameter
     rescue Puppet::Error, TypeError
       raise
     rescue => detail
-      raise Puppet::DevError, "Validate method failed for class #{self.name}: #{detail}", detail.backtrace
+      raise Puppet::DevError, _("Validate method failed for class %{class_name}: %{detail}") % { class_name: self.name, detail: detail }, detail.backtrace
     end
   end
 

data/lib/puppet/parser/abstract_compiler.rb

@@ -0,0 +1,36 @@
+
+module Puppet::Parser::AbstractCompiler
+
+  # Returns the catalog for a compilation. Must return a Puppet::Resource::Catalog or fail with an 
+  # error if the specific compiler does not support catalog operations.
+  #
+  def catalog
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'catalog'")
+  end
+
+  # Returns the environment for the compilation
+  #
+  def environment
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'environment'")
+  end
+
+  # Produces a new scope
+  # This method is here if there are functions/logic that will call this for some other purpose than to create
+  # a named scope for a class. It may not have to be here. (TODO)
+  #
+  def newscope(scope, options)
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'newscope'")
+  end
+
+  # Returns a hash of all externally referenceable qualified variables
+  #
+  def qualified_variables
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'qualified_variables'")
+  end
+
+  # Returns the top scope instance
+  def topscope
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'topscope'")
+  end
+
+end

data/lib/puppet/parser/ast/branch.rb

@@ -1,7 +1,7 @@
 # The parent class of all AST objects that contain other AST objects.
 # Everything but the really simple objects descend from this.  It is
 # important to note that Branch objects contain other AST objects only --
-# if you want to contain values, use a descendent of the AST::Leaf class.
+# if you want to contain values, use a descendant of the AST::Leaf class.
 #
 # @api private
 class Puppet::Parser::AST::Branch < Puppet::Parser::AST
@@ -12,8 +12,8 @@ class Puppet::Parser::AST::Branch < Puppet::Parser::AST
     @children.each { |child| yield child }
   end
 
-  def initialize(arghash)
-    super(arghash)
-    @children ||= []
+  def initialize(children: [], **args)
+    @children = children
+    super(**args)
   end
 end

data/lib/puppet/parser/ast/leaf.rb

@@ -16,6 +16,11 @@ class Puppet::Parser::AST::Leaf < Puppet::Parser::AST
   def to_s
     @value.to_s unless @value.nil?
   end
+
+  def initialize(value: nil, **options)
+    @value = value
+    super(**options)
+  end
 end
 
 # Host names, either fully qualified or just the short name, or even a regex
@@ -28,7 +33,7 @@ class Puppet::Parser::AST::HostName < Puppet::Parser::AST::Leaf
     unless @value.is_a?(Regex)
       @value = @value.to_s.downcase
       if @value =~ /[^-\w.]/
-        raise Puppet::DevError, "'#{@value}' is not a valid hostname"
+        raise Puppet::DevError, _("'%{value}' is not a valid hostname") % { value: @value }
       end
     end
   end
@@ -70,6 +75,6 @@ class Puppet::Parser::AST::Regex < Puppet::Parser::AST::Leaf
   end
 
   def to_s
-    "/#{@value.source}/"
+    Puppet::Pops::Types::PRegexpType.regexp_to_s_with_delimiters(@value)
   end
 end

data/lib/puppet/parser/ast/node.rb

@@ -2,9 +2,9 @@ class Puppet::Parser::AST::Node < Puppet::Parser::AST::TopLevelConstruct
   attr_accessor :names, :context
 
   def initialize(names, context = {})
-    raise ArgumentError, "names should be an array" unless names.is_a? Array
+    raise ArgumentError, _("names should be an array") unless names.is_a? Array
     if context[:parent]
-      raise Puppet::DevError, "Node inheritance is removed in Puppet 4.0.0. See http://links.puppet.com/puppet-node-inheritance-deprecation"
+      raise Puppet::DevError, _("Node inheritance is removed in Puppet 4.0.0. See http://links.puppet.com/puppet-node-inheritance-deprecation")
     end
 
     @names = names

data/lib/puppet/parser/ast/pops_bridge.rb

@@ -95,7 +95,8 @@ class Puppet::Parser::AST::PopsBridge
     # efficient as it avoids one full scan of all logic via recursive enumeration/yield)
     #
     def instantiate(modname)
-      @program_model.definitions.collect do |d|
+
+      @program_model.definitions.map do |d|
         case d
         when Puppet::Pops::Model::HostClassDefinition
           instantiate_HostClassDefinition(d, modname)
@@ -107,25 +108,17 @@ class Puppet::Parser::AST::PopsBridge
           instantiate_NodeDefinition(d, modname)
         when Puppet::Pops::Model::SiteDefinition
             instantiate_SiteDefinition(d, modname)
-        when Puppet::Pops::Model::FunctionDefinition
-          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
-          instantiate_FunctionDefinition(d, modname)
-          next
-        when Puppet::Pops::Model::TypeAlias
-          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
-          instantiate_TypeAlias(d, modname)
-          next
-        when Puppet::Pops::Model::TypeMapping
-          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
-          instantiate_TypeMapping(d, modname)
-          next
         when Puppet::Pops::Model::Application
           instantiate_ApplicationDefinition(d, modname)
         else
-          raise Puppet::ParseError, "Internal Error: Unknown type of definition - got '#{d.class}'"
+          loaders = Puppet::Pops::Loaders.loaders
+          loaders.instantiate_definition(d, loaders.find_loader(modname))
+
+          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
+          nil
         end
       end.flatten().compact() # flatten since node definition may have returned an array
-                              # Compact since functions are not understood by compiler
+                              # Compact since 4x definitions are not understood by compiler
     end
 
     def evaluate(scope)
@@ -139,8 +132,26 @@ class Puppet::Parser::AST::PopsBridge
       yield self
     end
 
+    # Returns true if this Program only contains definitions
+    def is_definitions_only?
+      is_definition?(program_model)
+    end
+
     private
 
+    def is_definition?(o)
+      case o
+      when Puppet::Pops::Model::Program
+        is_definition?(o.body)
+      when Puppet::Pops::Model::BlockExpression
+        o.statements.all {|s| is_definition?(s) }
+      when Puppet::Pops::Model::Definition
+        true
+      else
+        false
+      end
+    end
+
     def instantiate_Parameter(o)
       # 3x needs parameters as an array of `[name]` or `[name, value_expr]`
       if o.value
@@ -261,43 +272,6 @@ class Puppet::Parser::AST::PopsBridge
       Puppet::Resource::Type.new(:site, 'site', @context.merge(args))
     end
 
-    # Propagates a found Function to the appropriate loader.
-    # This is for 4x evaluator/loader
-    #
-    def instantiate_FunctionDefinition(function_definition, modname)
-      loader = Puppet::Pops::Loaders.find_loader(modname)
-
-      # Instantiate Function, and store it in the loader
-      typed_name, f = Puppet::Pops::Loader::PuppetFunctionInstantiator.create_from_model(function_definition, loader)
-      loader.set_entry(typed_name, f, function_definition.locator.to_uri(function_definition))
-
-      nil # do not want the function to inadvertently leak into 3x
-    end
-
-    # Propagates a found TypeAlias to the appropriate loader.
-    # This is for 4x evaluator/loader
-    #
-    def instantiate_TypeAlias(type_alias, modname)
-      loader = Puppet::Pops::Loaders.find_loader(modname)
-
-      # Bind the type alias to the loader using the alias
-      Puppet::Pops::Loader::TypeDefinitionInstantiator.create_from_model(type_alias, loader)
-
-      nil # do not want the type alias to inadvertently leak into 3x
-    end
-
-    # Adds the TypeMapping to the ImplementationRegistry
-    # This is for 4x evaluator/loader
-    #
-    def instantiate_TypeMapping(type_mapping, modname)
-      loader = Puppet::Pops::Loaders.find_loader(modname)
-      tf = Puppet::Pops::Types::TypeParser.singleton
-      lhs = tf.interpret(type_mapping.type_expr, loader)
-      rhs = tf.interpret_any(type_mapping.mapping_expr, loader)
-      Puppet::Pops::Loaders.implementation_registry.register_type_mapping(lhs, rhs, loader)
-      nil
-    end
-
     def code()
       Expression.new(:value => @value)
     end

data/lib/puppet/parser/ast.rb

@@ -7,7 +7,6 @@ class Puppet::Parser::AST
   AST = Puppet::Parser::AST
 
   include Puppet::Util::Errors
-  include Puppet::Util::MethodHelper
 
   attr_accessor :parent, :scope, :file, :line, :pos
 
@@ -44,14 +43,11 @@ class Puppet::Parser::AST
     end
   end
 
-  # Initialize the object.  Requires a hash as the argument, and
-  # takes each of the parameters of the hash and calls the setter
-  # method for them.  This is probably pretty inefficient and should
-  # likely be changed at some point.
-  def initialize(args)
-    set_options(args)
+  def initialize(file: nil, line: nil, pos: nil)
+    @file = file
+    @line = line
+    @pos = pos
   end
-
 end
 
 # And include all of the AST subclasses.

data/lib/puppet/parser/catalog_compiler.rb

@@ -0,0 +1,32 @@
+require 'puppet/loaders'
+require 'puppet/pops'
+
+# A Catalog "compiler" that is like the regular compiler but with an API
+# that is harmonized with the ScriptCompiler
+#
+# The Script compiler is "one shot" - it does not support rechecking if underlying source has changed or
+# deal with possible errors in a cached environment.
+#
+class Puppet::Parser::CatalogCompiler < Puppet::Parser::Compiler
+
+  # Evaluates the configured setup for a script + code in an environment with modules
+  #
+  def compile
+    Puppet[:strict_variables] = true
+    Puppet[:strict] = :error
+
+    Puppet.override(rich_data: true) do
+      super
+    end
+
+  rescue Puppet::ParseErrorWithIssue => detail
+    detail.node = node.name
+    Puppet.log_exception(detail)
+    raise
+  rescue => detail
+    message = "#{detail} on node #{node.name}"
+    Puppet.log_exception(detail, message)
+    raise Puppet::Error, message, detail.backtrace
+  end
+
+end

data/lib/puppet/parser/compiler/catalog_validator/env_relationship_validator.rb

@@ -1,7 +1,7 @@
 class Puppet::Parser::Compiler
   # Validator that asserts that all capability resources that are referenced by 'consume' or 'require' has
   # been exported by some other resource in the environment
- class CatalogValidator::EnvironmentRelationshipValidator < CatalogValidator
+  class CatalogValidator::EnvironmentRelationshipValidator < CatalogValidator
 
     def validate
       assumed_exports = {}

data/lib/puppet/parser/compiler/catalog_validator/relationship_validator.rb

@@ -32,8 +32,15 @@ class Puppet::Parser::Compiler
         refs = param.value.is_a?(Array) ? param.value.flatten : [param.value]
         refs.each do |r|
           next if r.nil? || r == :undef
-          unless catalog.resource(r.to_s)
-            msg = _("Could not find resource '%{res}' in parameter '%{param}'") % { res: r.to_s, param: param.name.to_s }
+          res = r.to_s
+          begin
+            found = catalog.resource(res)
+          rescue ArgumentError => e
+            # Raise again but with file and line information
+            raise CatalogValidationError.new(e.message, param.file, param.line)
+          end
+          unless found
+            msg = _("Could not find resource '%{res}' in parameter '%{param}'") % { res: res, param: param.name.to_s }
             raise CatalogValidationError.new(msg, param.file, param.line)
           end
         end