puppet 6.0.5-x64-mingw32 → 8.8.1-x64-mingw32

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Evaluator
 # A module with bindings between the new evaluator and the 3x runtime.
@@ -6,8 +8,7 @@ module Evaluator
 #
 # @api private
 module Runtime3Support
-
-  NAME_SPACE_SEPARATOR = '::'.freeze
+  NAME_SPACE_SEPARATOR = '::'
 
   # Fails the evaluation of _semantic_ with a given issue.
   #
@@ -17,7 +18,7 @@ module Runtime3Support
   # @return [!] this method does not return
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
   #
-  def fail(issue, semantic, options={}, except=nil)
+  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")
@@ -32,11 +33,11 @@ module Runtime3Support
   # @return [!] this method does not return
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
   #
-  def optionally_fail(issue, semantic, options={}, except=nil)
-    if except.nil?
+  def optionally_fail(issue, semantic, options = {}, except = nil)
+    if except.nil? && diagnostic_producer.severity_producer[issue] == :error
       # Want a stacktrace, and it must be passed as an exception
       begin
-       raise EvaluationError.new()
+        raise EvaluationError
       rescue EvaluationError => e
         except = e
       end
@@ -53,13 +54,13 @@ module Runtime3Support
   # @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={})
+  def runtime_issue(issue, options = {})
     # Get position from puppet runtime stack
     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)
+    semantic = Puppet::Pops::SemanticError.new(issue, nil, options.merge({ :file => file, :line => line }))
+    optionally_fail(issue, semantic)
     nil
   end
 
@@ -79,14 +80,14 @@ module Runtime3Support
     # TODO: Improve the messy implementation in Scope.
     #
     if name == "server_facts"
-      fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
+      fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, { :name => name })
     end
 
     if scope.bound?(name)
       if Puppet::Parser::Scope::RESERVED_VARIABLE_NAMES.include?(name)
-        fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
+        fail(Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, { :name => name })
       else
-        fail(Issues::ILLEGAL_REASSIGNMENT, o, {:name => name} )
+        fail(Issues::ILLEGAL_REASSIGNMENT, o, { :name => name })
       end
     end
     scope.setvar(name, value)
@@ -109,7 +110,7 @@ module Runtime3Support
     # if not set by a match expression.
     #
     unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
-      optionally_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
@@ -146,6 +147,7 @@ module Runtime3Support
     # is in the source.
     #
     raise ArgumentError, _("Internal error - attempt to create a local scope without a hash") unless hash.is_a?(Hash)
+
     scope.ephemeral_from(hash)
   end
 
@@ -252,11 +254,14 @@ module Runtime3Support
     if v.is_a?(Numeric)
       return v
     end
-    unless n = Utils.to_n(v)
-      fail(Issues::NOT_NUMERIC, o, {:value => v})
+
+    n = Utils.to_n(v)
+    unless n
+      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})
+    optionally_fail(Issues::NUMERIC_COERCION, o, { :before => v, :after => n })
     n
   end
 
@@ -276,7 +281,8 @@ module Runtime3Support
     # 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)
+    func = loader.load(:function, name) if loader
+    if func
       Puppet::Util::Profiler.profile(name, [:functions, name]) do
         return func.call(scope, *args, &block)
       end
@@ -296,17 +302,15 @@ 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)
-    # '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)
+    func = loader.load(:function, name) if loader
+    if func
       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)'.freeze, Kernel.binding, file || '', line)
+        # Add stack frame when calling.
+        return Puppet::Pops::PuppetStack.stack(file || '', line, func, :call, [scope, *args], &block)
       end
     end
     # 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)
+    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
@@ -319,10 +323,10 @@ module Runtime3Support
   def create_resource_parameter(o, scope, name, value, operator)
     file, line = extract_file_line(o)
     Puppet::Parser::Resource::Param.new(
-      :name   => name,
-      :value  => convert(value, scope, nil), # converted to 3x since 4x supports additional objects / types
+      :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
 
@@ -371,8 +375,9 @@ 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_OVERRIDDEN_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(
         t, r.title, {
@@ -415,7 +420,8 @@ module Runtime3Support
       # The defaults must be looked up in the scope where the resource was created (not in the given
       # scope where the lookup takes place.
       resource_scope = resource.scope
-      if val.nil? && resource_scope && defaults = resource_scope.lookupdefaults(resource.type)
+      defaults = resource_scope.lookupdefaults(resource.type) if val.nil? && resource_scope
+      if defaults
         # NOTE: 3x resource keeps defaults as hash using symbol for name as key to Parameter which (again) holds
         # name and value.
         # NOTE: meta parameters that are unset ends up here, and there are no defaults for those encoded
@@ -433,13 +439,8 @@ module Runtime3Support
   #
   def is_parameter_of_resource?(scope, resource, name)
     return false unless name.is_a?(String)
-    resource.valid_parameter?(name)
-  end
 
-  def resource_to_ptype(resource)
-    nil if resource.nil?
-    # inference returns the meta type since the 3x Resource is an alternate way to describe a type
-    type_calculator.infer(resource).type
+    resource.valid_parameter?(name)
   end
 
   # This is the same type of "truth" as used in the current Puppet DSL.
@@ -458,12 +459,6 @@ module Runtime3Support
     end
   end
 
-  # Utility method for TrueClass || FalseClass
-  # @param x [Object] the object to test if it is instance of TrueClass or FalseClass
-  def is_boolean? x
-    x.is_a?(TrueClass) || x.is_a?(FalseClass)
-  end
-
   def extract_file_line(o)
     o.is_a?(Model::Positioned) ? [o.file, o.line] : [nil, -1]
   end
@@ -471,15 +466,14 @@ module Runtime3Support
   # Creates a diagnostic producer
   def diagnostic_producer
     Validation::DiagnosticProducer.new(
-      ExceptionRaisingAcceptor.new(),                   # Raises exception on all issues
+      ExceptionRaisingAcceptor.new(), # Raises exception on all issues
       SeverityProducer.new(), # All issues are errors
-      Model::ModelLabelProvider.new())
+      Model::ModelLabelProvider.new()
+    )
   end
 
   # Configure the severity of failures
   class SeverityProducer < Validation::SeverityProducer
-    Issues = Issues
-
     def initialize
       super
       p = self
@@ -504,7 +498,7 @@ module Runtime3Support
       # 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::CLASS_NOT_VIRTUALIZABLE]      = :error
       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]
@@ -517,10 +511,10 @@ module Runtime3Support
     def accept(diagnostic)
       super
       IssueReporter.assert_and_report(self, {
-        :message => "Evaluation Error:",
-        :emit_warnings => true,  # log warnings
-        :exception_class => Puppet::PreformattedError
-      })
+                                        :message => "Evaluation Error:",
+                                        :emit_warnings => true, # log warnings
+                                        :exception_class => Puppet::PreformattedError
+                                      })
       if errors?
         raise ArgumentError, _("Internal Error: Configuration of runtime error handling wrong: should have raised exception")
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Functions
 # Defines a connection between a implementation method and the signature that
@@ -88,15 +90,13 @@ class Dispatch < Evaluator::CallableSignature
             else
               raise ArgumentError, _("Unknown injection %{injection_name}") % { injection_name: injection_name }
             end
-        else
+        elsif knit < 0
           # Careful so no new nil arguments are added since they would override default
           # parameter values in the received
-          if knit < 0
-            idx = -knit - 1
-            new_args += args[idx..-1] if idx < args.size
-          else
-            new_args << args[knit] if knit < args.size
-          end
+          idx = -knit - 1
+          new_args += args[idx..] if idx < args.size
+        elsif knit < args.size
+          new_args << args[knit]
         end
       end
       new_args

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Evaluate the dispatches defined as {Puppet::Pops::Functions::Dispatch}
 # instances to call the appropriate method on the
 # {Puppet::Pops::Functions::Function} instance.
@@ -7,8 +9,8 @@ class Puppet::Pops::Functions::Dispatcher
   attr_reader :dispatchers
 
   # @api private
-  def initialize()
-    @dispatchers = [ ]
+  def initialize
+    @dispatchers = []
   end
 
   # Answers if dispatching has been defined
@@ -19,6 +21,10 @@ class Puppet::Pops::Functions::Dispatcher
     @dispatchers.empty?
   end
 
+  def find_matching_dispatcher(args, &block)
+    @dispatchers.find { |d| d.type.callable_with?(args, block) }
+  end
+
   # Dispatches the call to the first found signature (entry with matching type).
   #
   # @param instance [Puppet::Functions::Function] - the function to call
@@ -28,19 +34,18 @@ class Puppet::Pops::Functions::Dispatcher
   #
   # @api private
   def dispatch(instance, calling_scope, args, &block)
-    found = @dispatchers.find { |d| d.type.callable_with?(args, block) }
-    unless found
+    dispatcher = find_matching_dispatcher(args, &block)
+    unless dispatcher
       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
-
-    if found.argument_mismatch_handler?
-      msg = found.invoke(instance, calling_scope, args)
+    if dispatcher.argument_mismatch_handler?
+      msg = dispatcher.invoke(instance, calling_scope, args)
       raise ArgumentError, "'#{instance.class.name}' #{msg}"
     end
 
     catch(:next) do
-      found.invoke(instance, calling_scope, args, &block)
+      dispatcher.invoke(instance, calling_scope, args, &block)
     end
   end
 
@@ -53,19 +58,19 @@ class Puppet::Pops::Functions::Dispatcher
   # Produces a CallableType for a single signature, and a Variant[<callables>] otherwise
   #
   # @api private
-  def to_type()
+  def to_type
     # 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 }
+    callables = dispatchers.map(&:type)
 
     # multiple signatures, produce a Variant type of Callable1-n (must copy them)
     # single signature, produce single Callable
-    callables.size > 1 ?  Puppet::Pops::Types::TypeFactory.variant(*callables) : callables.pop
+    callables.size > 1 ? Puppet::Pops::Types::TypeFactory.variant(*callables) : callables.pop
   end
 
   # @api private
   def signatures
-    @dispatchers.reject { |dispatcher| dispatcher.argument_mismatch_handler? }
+    @dispatchers.reject(&:argument_mismatch_handler?)
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # @note WARNING: This new function API is still under development and may change at
 #   any time
 #
@@ -11,9 +13,6 @@
 #
 # @api public
 class Puppet::Pops::Functions::Function
-  # The scope where the function was defined
-  attr_reader :closure_scope
-
   # The loader that loaded this function.
   # Should be used if function wants to load other things.
   #
@@ -41,23 +40,21 @@ class Puppet::Pops::Functions::Function
   #
   # @api public
   def call(scope, *args, &block)
+    result = catch(:return) do
+      return self.class.dispatcher.dispatch(self, scope, args, &block)
+    end
+    result.value
+  rescue Puppet::Pops::Evaluator::Next => jumper
     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
-        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
-        raise Puppet::ParseError.new("return() from context where this is illegal", jumper.file, jumper.line)
-      end
+      throw :next, jumper.value
+    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
+      raise Puppet::ParseError.new("return() from context where this is illegal", jumper.file, jumper.line)
     end
   end
 
@@ -74,6 +71,7 @@ class Puppet::Pops::Functions::Function
     internal_call_function(closure_scope, function_name, args, &block)
   end
 
+  # The scope where the function was defined
   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) { {} }
@@ -106,11 +104,10 @@ class Puppet::Pops::Functions::Function
   #
   # @api public
   def internal_call_function(scope, function_name, args, &block)
-
     the_loader = 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 }
+                           { class_name: self.class.name, function_name: function_name }
     end
 
     func = the_loader.load(:function, function_name)
@@ -126,7 +123,7 @@ class Puppet::Pops::Functions::Function
     func_3x = Puppet::Parser::Functions.function(function_name, loader_scope.environment) if loader_scope.is_a?(Puppet::Parser::Scope)
     unless func_3x
       raise ArgumentError, _("Function %{class_name}(): Unknown function: '%{function_name}'") %
-          { class_name: self.class.name, function_name: function_name }
+                           { class_name: self.class.name, function_name: function_name }
     end
 
     # Call via 3x API
@@ -137,5 +134,4 @@ class Puppet::Pops::Functions::Function
     # 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
   end
-
 end

data/lib/puppet/pops/issue_reporter.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 class IssueReporter
-
   # @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
@@ -47,8 +48,9 @@ class IssueReporter
     errors = acceptor.errors
     if errors.size > 0
       unless emit_errors
-        raise emit_exception.new(emit_message)
+        raise emit_exception, emit_message
       end
+
       formatter = Validation::DiagnosticFormatterPuppetStyle.new
       if errors.size == 1 || max_errors <= 1
         # raise immediately
@@ -68,12 +70,12 @@ class IssueReporter
         emitted += 1
         break if emitted >= max_errors
       end
-      giving_up_message = if (emit_warnings && warnings.size > 0)
+      giving_up_message = if emit_warnings && warnings.size > 0
                             _("Language validation logged %{error_count} errors, and %{warning_count} warnings. Giving up") %
-                                { error_count: errors.size, warning_count: warnings.size }
+                              { error_count: errors.size, warning_count: warnings.size }
                           else
                             _("Language validation logged %{error_count} errors. Giving up") %
-                                { error_count: errors.size }
+                              { error_count: errors.size }
                           end
       exception = emit_exception.new(giving_up_message)
       exception.file = errors[0].file
@@ -83,19 +85,20 @@ class IssueReporter
 
   def self.format_with_prefix(prefix, message)
     return message unless prefix
+
     [prefix, message].join(' ')
   end
 
   def self.warning(semantic, issue, args)
     Puppet::Util::Log.create({
-      :level => :warning,
-      :message => issue.format(args),
-      :arguments => args,
-      :issue_code => issue.issue_code,
-      :file => semantic.file,
-      :line => semantic.line,
-      :pos => semantic.pos,
-    })
+                               :level => :warning,
+                               :message => issue.format(args),
+                               :arguments => args,
+                               :issue_code => issue.issue_code,
+                               :file => semantic.file,
+                               :line => semantic.line,
+                               :pos => semantic.pos,
+                             })
   end
 
   def self.error(exception_class, semantic, issue, args)
@@ -123,15 +126,15 @@ class IssueReporter
       pos = diagnostic.source_pos.pos
     end
     Puppet::Util::Log.create({
-        :level => severity,
-        :message => formatter.format_message(diagnostic),
-        :arguments => diagnostic.arguments,
-        :issue_code => diagnostic.issue.issue_code,
-        :file => file,
-        :line => line,
-        :pos => pos,
-      })
+                               :level => severity,
+                               :message => formatter.format_message(diagnostic),
+                               :arguments => diagnostic.arguments,
+                               :issue_code => diagnostic.issue.issue_code,
+                               :file => file,
+                               :line => line,
+                               :pos => pos,
+                             })
   end
   private_class_method :log_message
 end
-end
+end

data/lib/puppet/pops/issues.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Defines classes to deal with issues, and message formatting and defines constants with Issues.
 # @api public
 #
@@ -22,6 +24,7 @@ module Issues
 
     # If this issue can have its severity lowered to :warning, :deprecation, or :ignored
     attr_writer :demotable
+
     # Configures the Issue with required arguments (bound by occurrence), and a block producing a message.
     def initialize issue_code, *args, &block
       @issue_code = issue_code
@@ -41,7 +44,7 @@ module Issues
     # in the given `hash`.
     # @api public
     #
-    def format(hash ={})
+    def format(hash = {})
       # Create a Message Data where all hash keys become methods for convenient interpolation
       # in issue text.
       msgdata = MessageData.new(*arg_names)
@@ -89,16 +92,18 @@ module Issues
     # @raise [Puppet::Error] if no label provider is found
     def label_provider
       label_provider = @data[:label]
-      #TRANSLATORS ":label" is a keyword and should not be translated
+      # TRANSLATORS ":label" is a keyword and should not be translated
       raise Puppet::Error, _('Label provider key :label must be set to produce the text of the message!') unless label_provider
+
       label_provider
     end
 
     # Returns the label provider given as a key in the hash passed to #format.
     #
     def semantic
-      #TRANSLATORS ":semantic" is a keyword and should not be translated
+      # TRANSLATORS ":semantic" is a keyword and should not be translated
       raise Puppet::Error, _('Label provider key :semantic must be set to produce the text of the message!') unless @data[:semantic]
+
       @data[:semantic]
     end
   end
@@ -206,6 +211,10 @@ module Issues
     _("The numeric parameter name '$%{name}' cannot be used (clashes with numeric match result variables)") % { name: name }
   end
 
+  ILLEGAL_NONLITERAL_PARAMETER_TYPE = issue :ILLEGAL_NONLITERAL_PARAMETER_TYPE, :name, :type_class do
+    _("The parameter '$%{name}' must be a literal type, not %{type_class}") % { name: name, type_class: label.a_an(type_class) }
+  end
+
   # In certain versions of Puppet it may be allowed to assign to a not already assigned key
   # in an array or a hash. This is an optional validation that may be turned on to prevent accidental
   # mutation.
@@ -431,12 +440,11 @@ module Issues
   end
 
   BAD_SLICE_KEY_TYPE = issue :BAD_SLICE_KEY_TYPE, :left_value, :expected_classes, :actual do
-    expected_text = if expected_classes.size > 1
-      _("one of %{expected} are") % { expected: expected_classes.join(', ') }
+    if expected_classes.size > 1
+      _("%{expression}[] cannot use %{actual} where one of the following is expected: %{expected}") % { expression: label.a_an_uc(left_value), actual: actual, expected: expected_classes.join(', ') }
     else
-      _("%{expected} is") % { expected: expected_classes[0] }
+      _("%{expression}[] cannot use %{actual} where %{expected} is expected") % { expression: label.a_an_uc(left_value), actual: actual, expected: expected_classes[0] }
     end
-    _("%{expression}[] cannot use %{actual} where %{expected_text} expected") % { expression: label.a_an_uc(left_value), actual: actual, expected_text: expected_text }
   end
 
   BAD_STRING_SLICE_KEY_TYPE = issue :BAD_STRING_SLICE_KEY_TYPE, :left_value, :actual_type do
@@ -542,7 +550,7 @@ module Issues
     _("Illegal Resource Type expression, expected result to be a type name, or untitled Resource, got %{actual}") % { actual: actual }
   end
 
-  DUPLICATE_TITLE = issue :DUPLICATE_TITLE, :title  do
+  DUPLICATE_TITLE = issue :DUPLICATE_TITLE, :title do
     _("The title '%{title}' has already been used in this resource expression") % { title: title }
   end
 
@@ -592,7 +600,7 @@ module Issues
   end
 
   DISCONTINUED_IMPORT = hard_issue :DISCONTINUED_IMPORT do
-    #TRANSLATORS "import" is a function name and should not be translated
+    # TRANSLATORS "import" is a function name and should not be translated
     _("Use of 'import' has been discontinued in favor of a manifest directory. See http://links.puppet.com/puppet-import-deprecation")
   end
 
@@ -760,6 +768,10 @@ module Issues
     _("An escape char for @() may only appear once. Got '%{escapes}'") % { escapes: escapes.join(', ') }
   end
 
+  HEREDOC_DIRTY_MARGIN = hard_issue :HEREDOC_DIRTY_MARGIN, :heredoc_line do
+    _("Heredoc with text in the margin is not allowed (line %{heredoc_line} in this heredoc)") % { heredoc_line: heredoc_line }
+  end
+
   ILLEGAL_BOM = hard_issue :ILLEGAL_BOM, :format_name, :bytes do
     _("Illegal %{format} Byte Order mark at beginning of input: %{bom} - remove these from the puppet source") % { format: format_name, bom: bytes }
   end

data/lib/puppet/pops/label_provider.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 # Provides a label for an object.
 # This simple implementation calls #to_s on the given object, and handles articles 'a/an/the'.
 #
 module Puppet::Pops::LabelProvider
-  VOWELS = %w{a e i o u y}
-  SKIPPED_CHARACTERS = %w{" '}
+  VOWELS = %w[a e i o u y]
+  SKIPPED_CHARACTERS = %w[" ']
   A = "a"
   AN = "an"
 
@@ -67,9 +69,9 @@ module Puppet::Pops::LabelProvider
   private
 
   def first_letter_of(string)
-    char = string[0,1]
+    char = string[0, 1]
     if SKIPPED_CHARACTERS.include? char
-      char = string[1,1]
+      char = string[1, 1]
     end
 
     if char == ""