puppet 3.8.7 → 4.0.0

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

@@ -30,10 +30,6 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   include Puppet::Pops::Evaluator::Runtime3Support
   include Puppet::Pops::Evaluator::ExternalSyntaxSupport
 
-  # This constant is not defined as Float::INFINITY in Ruby 1.8.7 (but is available in later version
-  # Refactor when support is dropped for Ruby 1.8.7.
-  #
-  INFINITY = 1.0 / 0.0
   EMPTY_STRING = ''.freeze
   COMMA_SEPARATOR = ', '.freeze
 
@@ -53,9 +49,6 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
 
     @@compare_operator     ||= Puppet::Pops::Evaluator::CompareOperator.new()
     @@relationship_operator ||= Puppet::Pops::Evaluator::RelationshipOperator.new()
-
-    # Use null migration checker unless given in context
-    @migration_checker = (Puppet.lookup(:migration_checker) { Puppet::Pops::Migration::MigrationChecker.new() })
   end
 
   # @api private
@@ -239,11 +232,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # Reserved Words fail to evaluate
   #
   def eval_ReservedWord(o, scope)
-    if !o.future
-      fail(Puppet::Pops::Issues::RESERVED_WORD, o, {:word => o.word})
-    else
-      o.word
-    end
+    fail(Puppet::Pops::Issues::RESERVED_WORD, o, {:word => o.word})
   end
 
   def eval_LiteralDefault(o, scope)
@@ -261,7 +250,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   end
 
   def eval_NotExpression(o, scope)
-    ! is_true?(evaluate(o.expr, scope), o.expr)
+    ! is_true?(evaluate(o.expr, scope))
   end
 
   def eval_UnaryMinusExpression(o, scope)
@@ -363,7 +352,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       rescue ZeroDivisionError => e
         fail(Issues::DIV_BY_ZERO, right_o)
       end
-      if result == INFINITY || result == -INFINITY
+      if result == Float::INFINITY || result == -Float::INFINITY
         fail(Issues::RESULT_IS_INFINITY, left_o, {:operator => operator})
       end
       result
@@ -411,19 +400,14 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
 
-    @migration_checker.report_uc_bareword_type(left, o.left_expr)
-    @migration_checker.report_uc_bareword_type(right, o.right_expr)
-
     begin
     # Left is a type
     if left.is_a?(Puppet::Pops::Types::PAnyType)
       case o.operator
       when :'=='
-        @migration_checker.report_equality_type_mismatch(left, right, o)
         @@type_calculator.equals(left,right)
 
       when :'!='
-        @migration_checker.report_equality_type_mismatch(left, right, o)
         !@@type_calculator.equals(left,right)
 
       when :'<'
@@ -444,10 +428,8 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     else
       case o.operator
       when :'=='
-        @migration_checker.report_equality_type_mismatch(left, right, o)
         @@compare_operator.equals(left,right)
       when :'!='
-        @migration_checker.report_equality_type_mismatch(left, right, o)
         ! @@compare_operator.equals(left,right)
       when :'<'
         @@compare_operator.compare(left,right) < 0
@@ -492,8 +474,6 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     left = evaluate(o.left_expr, scope)
     pattern = evaluate(o.right_expr, scope)
 
-    @migration_checker.report_uc_bareword_type(left, o.left_expr)
-
     # matches RHS types as instance of for all types except a parameterized Regexp[R]
     if pattern.is_a?(Puppet::Pops::Types::PAnyType)
       # evaluate as instance? of type check
@@ -523,8 +503,6 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   def eval_InExpression o, scope
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
-    @migration_checker.report_uc_bareword_type(left, o.left_expr)
-    @migration_checker.report_in_expression(o)
     @@compare_operator.include?(right, left, scope)
   end
 
@@ -533,7 +511,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # b is only evaluated if a is true
   #
   def eval_AndExpression o, scope
-    is_true?(evaluate(o.left_expr, scope), o.left_expr) ? is_true?(evaluate(o.right_expr, scope), o.right_expr) : false
+    is_true?(evaluate(o.left_expr, scope)) ? is_true?(evaluate(o.right_expr, scope)) : false
   end
 
   # @example
@@ -541,7 +519,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # b is only evaluated if a is false
   #
   def eval_OrExpression o, scope
-    is_true?(evaluate(o.left_expr, scope), o.left_expr) ? true : is_true?(evaluate(o.right_expr, scope), o.right_expr)
+    is_true?(evaluate(o.left_expr, scope)) ? true : is_true?(evaluate(o.right_expr, scope))
   end
 
   # Evaluates each entry of the literal list and creates a new Array
@@ -580,24 +558,21 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     #
     with_guarded_scope(scope) do
       test = evaluate(o.test, scope)
-      @migration_checker.report_uc_bareword_type(test, o.test)
-
       result = nil
       the_default = nil
       if o.options.find do |co|
         # the first case option that matches
         if co.values.find do |c|
-          c = unwind_parentheses(c)
           case c
           when Puppet::Pops::Model::LiteralDefault
             the_default = co.then_expr
-            next false
+            is_match?(test, evaluate(c, scope), c, scope)
           when Puppet::Pops::Model::UnfoldExpression
             # not ideal for error reporting, since it is not known which unfolded result
             # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
-            evaluate(c, scope).any? {|v| is_match?(test, v, c, co, scope) }
+            evaluate(c, scope).any? {|v| is_match?(test, v, c, scope) }
           else
-            is_match?(test, evaluate(c, scope), c, co, scope)
+            is_match?(test, evaluate(c, scope), c, scope)
           end
         end
         result = evaluate(co.then_expr, scope)
@@ -821,13 +796,13 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     unless o.functor_expr.is_a? Puppet::Pops::Model::NamedAccessExpression
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function accessor', :container => o})
     end
-    receiver = unfold([], [o.functor_expr.left_expr], scope)
+    receiver = evaluate(o.functor_expr.left_expr, scope)
     name = o.functor_expr.right_expr
     unless name.is_a? Puppet::Pops::Model::QualifiedName
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
-    end 
+    end
     name = name.value # the string function name
-    call_function_with_block(name, unfold(receiver, o.arguments || [], scope), o, scope)
+    call_function_with_block(name, unfold([receiver], o.arguments || [], scope), o, scope)
   end
 
   def call_function_with_block(name, evaluated_arguments, o, scope)
@@ -835,75 +810,11 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       call_function(name, evaluated_arguments, o, scope)
     else
       closure = Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope)
-      call_function(name, evaluated_arguments, o, scope, &proc_from_closure(closure))
+      call_function(name, evaluated_arguments, o, scope, &Puppet::Pops::Evaluator::PuppetProc.new(closure) { |*args| closure.call(*args) })
     end
   end
   private :call_function_with_block
 
-  # Creates a Proc with an arity count that matches the parameters of the given closure. The arity will
-  # be correct up to 10 parameters and then default to varargs (-1)
-  #
-  def proc_from_closure(closure)
-    return Puppet::Pops::Evaluator::PuppetProc.new(closure) { |*args| closure.call(*args) } unless RUBY_VERSION[0,3] == '1.8'
-
-    # This code is required since a Proc isn't propagated by reference in Ruby 1.8.x. It produces a standard
-    # Proc that has correct arity as a replacement for the otherwise used PuppetProc
-    # TODO: Remove when Ruby 1.8.x support is dropped
-    arity = closure.parameters.reduce(0) do |memo, param|
-      count = memo + 1
-      break -count if param.captures_rest || !param.value.nil?
-      count
-    end
-
-    case arity
-    when 0
-      proc { || closure.call }
-    when 1
-      proc { |a| closure.call(a) }
-    when 2
-      proc { |a, b| closure.call(a, b) }
-    when 3
-      proc { |a, b, c| closure.call(a, b, c) }
-    when 4
-      proc { |a, b, c, d| closure.call(a, b, c, d) }
-    when 5
-      proc { |a, b, c, d, e| closure.call(a, b, c, d, e) }
-    when 6
-      proc { |a, b, c, d, e, f| closure.call(a, b, c, d, e, f) }
-    when 7
-      proc { |a, b, c, d, e, f, g| closure.call(a, b, c, d, e, f, g) }
-    when 8
-      proc { |a, b, c, d, e, f, g, h| closure.call(a, b, c, d, e, f, g, h) }
-    when 9
-      proc { |a, b, c, d, e, f, g, h, i| closure.call(a, b, c, d, e, f, g, h, i) }
-    when 10
-      proc { |a, b, c, d, e, f, g, h, i, j| closure.call(a, b, c, d, e, f, g, h, i, j) }
-    when -1
-      proc { |*v| closure.call(*v) }
-    when -2
-      proc { |a, *v| closure.call(a, *v) }
-    when -3
-      proc { |a, b, *v| closure.call(a, b, *v) }
-    when -4
-      proc { |a, b, c, *v| closure.call(a, b, c, *v) }
-    when -5
-      proc { |a, b, c, d, *v| closure.call(a, b, c, d, *v) }
-    when -6
-      proc { |a, b, c, d, e, *v| closure.call(a, b, c, d, e, *v) }
-    when -7
-      proc { |a, b, c, d, e, f, *v| closure.call(a, b, c, d, e, f, *v) }
-    when -8
-      proc { |a, b, c, d, e, f, g, *v| closure.call(a, b, c, d, e, f, g, *v) }
-    when -9
-      proc { |a, b, c, d, e, f, g, h, *v| closure.call(a, b, c, d, e, f,g, h, *v) }
-    when -10
-      proc { |a, b, c, d, e, f, g, h, i, *v| closure.call(a, b, c, d, e, f,g, h, i, *v) }
-    else
-      proc { |*a| closure.call(*a) }
-    end
-  end
-  private :proc_from_closure
-
   # @example
   #   $x ? { 10 => true, 20 => false, default => 0 }
   #
@@ -913,11 +824,9 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     #
     with_guarded_scope(scope) do
       test = evaluate(o.left_expr, scope)
-      @migration_checker.report_uc_bareword_type(test, o.left_expr)
-
       the_default = nil
       selected = o.selectors.find do |s|
-        me = unwind_parentheses(s.matching_expr)
+        me = s.matching_expr
         case me
         when Puppet::Pops::Model::LiteralDefault
           the_default = s.value_expr
@@ -925,9 +834,9 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
         when Puppet::Pops::Model::UnfoldExpression
           # not ideal for error reporting, since it is not known which unfolded result
           # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
-          evaluate(me, scope).any? {|v| is_match?(test, v, me, s, scope) }
+          evaluate(me, scope).any? {|v| is_match?(test, v, me, scope) }
         else
-          is_match?(test, evaluate(me, scope), me, s, scope)
+          is_match?(test, evaluate(me, scope), me, scope)
         end
       end
       if selected
@@ -955,7 +864,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # Evaluates Puppet DSL `if`
   def eval_IfExpression o, scope
     with_guarded_scope(scope) do
-      if is_true?(evaluate(o.test, scope), o.test)
+      if is_true?(evaluate(o.test, scope))
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
@@ -966,7 +875,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # Evaluates Puppet DSL `unless`
   def eval_UnlessExpression o, scope
     with_guarded_scope(scope) do
-      unless is_true?(evaluate(o.test, scope), o.test)
+      unless is_true?(evaluate(o.test, scope))
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
@@ -1167,12 +1076,22 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # 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 is_match?(left, right, o, option_expr, scope)
-    @migration_checker.report_option_type_mismatch(left, right, option_expr, o)
-    if right.is_a?(Puppet::Pops::Types::PAnyType)
-      @migration_checker.report_uc_bareword_type(right, o)
+  def is_match? left, right, o, scope
+    if right.is_a?(Regexp)
+      return false unless left.is_a? String
+      matched = right.match(left)
+      set_match_data(matched, scope) # creates or clears ephemeral
+      !!matched # convert to boolean
+    elsif right.is_a?(Puppet::Pops::Types::PAnyType)
+      # right is a type and left is not - check if left is an instance of the given type
+      # (The reverse is not terribly meaningful - computing which of the case options that first produces
+      # an instance of a given type).
+      #
+      @@type_calculator.instance?(right, left)
+    else
+      # Handle equality the same way as the language '==' operator (case insensitive etc.)
+      @@compare_operator.equals(left,right)
     end
-    @@compare_operator.match(left, right, scope)
   end
 
   def with_guarded_scope(scope)
@@ -1193,7 +1112,6 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   #
   def unfold(result, array, scope)
     array.each do |x|
-      x = unwind_parentheses(x)
       if x.is_a?(Puppet::Pops::Model::UnfoldExpression)
         result.concat(evaluate(x, scope))
       else
@@ -1204,9 +1122,4 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   end
   private :unfold
 
-  def unwind_parentheses(o)
-    return o unless o.is_a?(Puppet::Pops::Model::ParenthesizedExpression)
-    unwind_parentheses(o.expr)
-  end
-  private :unwind_parentheses
 end

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

@@ -1,12 +1,15 @@
 # This module is an integral part of the evaluator. It deals with the concern of validating
 # external syntax in text produced by heredoc and templates.
 #
+require 'puppet/plugins/syntax_checkers'
 module Puppet::Pops::Evaluator::ExternalSyntaxSupport
-  # TODO: This can be simplified if the Factory directly supporteded hash_of/type_of
+  # TODO: This can be simplified if the Factory directly supported hash_of/type_of
   TYPES = Puppet::Pops::Types::TypeFactory
+  SERVICE_TYPE = Puppet::Plugins::SyntaxCheckers::SYNTAX_CHECKERS_TYPE
+  SERVICE_NAME = Puppet::Plugins::SyntaxCheckers::SYNTAX_CHECKERS_KEY
 
   def assert_external_syntax(scope, result, syntax, reference_expr)
-    @@HASH_OF_SYNTAX_CHECKERS ||= TYPES.hash_of(TYPES.type_of(::Puppetx::SYNTAX_CHECKERS_TYPE))
+    @@HASH_OF_SYNTAX_CHECKERS ||= TYPES.hash_of(TYPES.type_of(SERVICE_TYPE))
     # ignore 'unspecified syntax'
     return if syntax.nil? || syntax == ''
 
@@ -31,7 +34,7 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
   # Returns nil if there is no registered checker.
   #
   def checker_for_syntax(scope, syntax)
-    checkers_hash = scope.compiler.injector.lookup(scope, @@HASH_OF_SYNTAX_CHECKERS, ::Puppetx::SYNTAX_CHECKERS) || {}
+    checkers_hash = scope.compiler.injector.lookup(scope, @@HASH_OF_SYNTAX_CHECKERS, SERVICE_NAME) || {}
     checkers_hash[lookup_keys_for_syntax(syntax).find {|x| checkers_hash[x] }]
   end
 

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

@@ -134,7 +134,7 @@ class Puppet::Pops::Evaluator::RelationshipOperator
       # into an array, and thus the resulting left and right must be flattened individually
       # Once flattened, the operands should be sets (to remove duplicate entries)
       #
-      real = left_right_evaluated.collect {|x| [x].flatten.collect {|x| transform(x, scope) }}
+      real = left_right_evaluated.collect {|x| [x].flatten.collect {|y| transform(y, scope) }}
       real[0].flatten!
       real[1].flatten!
       real[0].uniq!

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

@@ -140,7 +140,7 @@ class Runtime3Converter
       when Puppet::Pops::Types::PResourceType
         type_name = split_type.type_name
         title = split_type.title
-        if type_name =~ /^(::)?[Cc]lass$/
+        if type_name =~ /^(::)?[Cc]lass/
           ['class', title.nil? ? nil : title.sub(/^::/, '')]
         else
           # Ensure that title is '' if nil

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

@@ -194,7 +194,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # And if that is not enough, a source/target may be a Collector (a baked query that will be evaluated by the
     # compiler - it is simply passed through here for processing by the compiler at the right time).
     #
-    if source.is_a?(Puppet::Parser::Collector) || source.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
+    if source.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
       # use verbatim - behavior defined by 3x
       source_resource = source
     else
@@ -202,7 +202,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
       type, title = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(source)
       source_resource = Puppet::Resource.new(type, title)
     end
-    if target.is_a?(Puppet::Parser::Collector) || target.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
+    if target.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
       # use verbatim - behavior defined by 3x
       target_resource = target
     else
@@ -229,37 +229,6 @@ module Puppet::Pops::Evaluator::Runtime3Support
     n
   end
 
-  # Provides the ability to call a 3.x or 4.x function from the perspective of a 3.x function or ERB template.
-  # The arguments to the function must be an Array containing values compliant with the 4.x calling convention.
-  # If the targeted function is a 3.x function, the values will be transformed.
-  # @param name [String] the name of the function (without the 'function_' prefix used by scope)
-  # @param args [Array] arguments, may be empty
-  # @param scope [Object] the (runtime specific) scope where evaluation takes place
-  # @raise ArgumentError 'unknown function' if the function does not exist
-  #
-  def external_call_function(name, args, scope, &block)
-    # Call via 4x API if the function exists there
-    loaders = scope.compiler.loaders
-    # Since this is a call from non puppet code, it is not possible to relate it to a module loader
-    # It is known where the call originates by using the scope associated module - but this is the calling scope
-    # and it does not defined the visibility of functions from a ruby function's perspective. Instead,
-    # this is done from the perspective of the environment.
-    loader = loaders.private_environment_loader
-    if loader && func = loader.load(:function, name)
-      return func.call(scope, *args, &block)
-    end
-
-    # Call via 3x API if function exists there
-    raise ArgumentError, "Unknown function '#{name}'" unless Puppet::Parser::Functions.function(name)
-
-    # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
-    # NOTE: Passing an empty string last converts nil/:undef to empty string
-    mapped_args = Puppet::Pops::Evaluator::Runtime3Converter.map_args(args, scope, '')
-    result = scope.send("function_#{name}", mapped_args, &block)
-    # Prevent non r-value functions from leaking their result (they are not written to care about this)
-    Puppet::Parser::Functions.rvalue?(name) ? result : nil
-  end
-
   def call_function(name, args, o, scope, &block)
     # Call via 4x API if the function exists there
     loaders = scope.compiler.loaders
@@ -304,15 +273,6 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # a proper Issue. Now the result is "Error while evaluating a Resource Statement" with the message
     # from the raised exception. (It may be good enough).
 
-
-    # In 3.x scope does not resolve classes as absolute names.
-    # In 4.x it does. This comment, and the conditional logic in the if below
-    # should be removed when merged to 4.x
-    #
-    if type_name == CLASS_STRING
-      resource_titles = resource_titles.map {|s| s.index('::') != 0 ? "::#{s}" : s }
-    end
-
     # resolve in scope.
     fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type_name, resource_titles)
 
@@ -341,7 +301,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
           resource.resource_type.instantiate_resource(scope, resource)
         end
         scope.compiler.add_resource(scope, resource)
-        scope.compiler.evaluate_classes([resource_title], scope, false, true) if fully_qualified_type == CLASS_STRING
+        scope.compiler.evaluate_classes([resource_title], scope, false) if fully_qualified_type == CLASS_STRING
         # Turn the resource into a PType (a reference to a resource type)
         # weed out nil's
         resource_to_ptype(resource)
@@ -356,7 +316,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # for the type of the name.
     # Note, locations are available per parameter.
     #
-    scope.define_settings(capitalize_qualified_name(type_name), evaluated_parameters.flatten)
+    scope.define_settings(capitalize_qualified_name(type_name), evaluated_parameters)
   end
 
   # Capitalizes each segment of a qualified name
@@ -375,8 +335,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # TODO: Revisit and possible improve the accuracy.
     #
     file, line = extract_file_line(o)
-    # A *=> results in an array of arrays
-    evaluated_parameters = evaluated_parameters.flatten
+
     evaluated_resources.each do |r|
       unless r.is_a?(Puppet::Pops::Types::PResourceType) && r.type_name != 'class'
         fail(Puppet::Pops::Issues::ILLEGAL_OVERRIDEN_TYPE, o, {:actual => r} )
@@ -450,18 +409,15 @@ module Puppet::Pops::Evaluator::Runtime3Support
 
   # This is the same type of "truth" as used in the current Puppet DSL.
   #
-  def is_true?(value, o)
+  def is_true? o
     # Is the value true?  This allows us to control the definition of truth
     # in one place.
-    case value
+    case o
     # Support :undef since it may come from a 3x structure
     when :undef
       false
-    when String
-      @migration_checker.report_empty_string_true(value, o)
-      true
     else
-      !!value
+      !!o
     end
   end
 

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

@@ -71,12 +71,7 @@ class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSigna
         else
           # 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
+          new_args << args[knit] if knit < args.size
         end
       end
       new_args

data/lib/puppet/pops/issue_reporter.rb

@@ -11,14 +11,19 @@ class Puppet::Pops::IssueReporter
   def self.assert_and_report(acceptor, options)
     return unless acceptor
 
-    max_errors       = options[:max_errors]   || Puppet[:max_errors]
-    max_warnings     = options[:max_warnings] || Puppet[:max_warnings]
-    max_deprecations = options[:max_deprecations] || (Puppet[:disable_warnings].include?('deprecations') ? 0 : Puppet[:max_deprecations])
+    max_errors = Puppet[:max_errors]
+    max_warnings = Puppet[:max_warnings]
+    max_deprecations =
+    if Puppet[:disable_warnings].include?('deprecations')
+      0
+    else
+      Puppet[:max_deprecations]
+    end
 
-    emit_warnings    = options[:emit_warnings] || false
-    emit_errors      = options[:emit_errors].nil? ? true : !!options[:emit_errors]
-    emit_message     = options[:message]
-    emit_exception   = options[:exception_class] || Puppet::ParseErrorWithIssue
+    emit_warnings = options[:emit_warnings] || false
+    emit_errors = options[:emit_errors].nil? ? true : !!options[:emit_errors]
+    emit_message = options[:message]
+    emit_exception = options[:exception_class] || Puppet::ParseError
 
     # If there are warnings output them
     warnings = acceptor.warnings
@@ -32,10 +37,10 @@ class Puppet::Pops::IssueReporter
           # deprecation of constructs in manifests! (It is not designed for that purpose even if
           # used throughout the code base).
           #
-          log_message(:warning, formatter, w) if emitted_dw < max_deprecations
+          Puppet.warning(formatter.format(w)) if emitted_dw < max_deprecations
           emitted_dw += 1
         else
-          log_message(:warning, formatter, w) if emitted_w < max_warnings
+          Puppet.warning(formatter.format(w)) if emitted_w < max_warnings
           emitted_w += 1
         end
         break if emitted_w >= max_warnings && emitted_dw >= max_deprecations # but only then
@@ -51,7 +56,7 @@ class Puppet::Pops::IssueReporter
       formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
       if errors.size == 1 || max_errors <= 1
         # raise immediately
-        exception = create_exception(emit_exception, emit_message, formatter, errors[0])
+        exception = emit_exception.new(format_with_prefix(emit_message, formatter.format(errors[0])))
         # if an exception was given as cause, use it's backtrace instead of the one indicating "here"
         if errors[0].exception
           exception.set_backtrace(errors[0].exception.backtrace)
@@ -63,7 +68,7 @@ class Puppet::Pops::IssueReporter
         Puppet.err(emit_message)
       end
       errors.each do |e|
-        log_message(:err, formatter, e)
+        Puppet.err(formatter.format(e))
         emitted += 1
         break if emitted >= max_errors
       end
@@ -79,35 +84,4 @@ class Puppet::Pops::IssueReporter
     return message unless prefix
     [prefix, message].join(' ')
   end
-
-  def self.create_exception(exception_class, emit_message, formatter, diagnostic)
-    file = diagnostic.file
-    file = (file.is_a?(String) && file.empty?) ? nil : file
-    line = pos = nil
-    if diagnostic.source_pos
-      line = diagnostic.source_pos.line
-      pos = diagnostic.source_pos.pos
-    end
-    exception_class.new(format_with_prefix(emit_message, formatter.format_message(diagnostic)), file, line, pos, nil, diagnostic.issue.issue_code)
-  end
-  private_class_method :create_exception
-
-  def self.log_message(severity, formatter, diagnostic)
-    file = diagnostic.file
-    file = (file.is_a?(String) && file.empty?) ? nil : file
-    line = pos = nil
-    if diagnostic.source_pos
-      line = diagnostic.source_pos.line
-      pos = diagnostic.source_pos.pos
-    end
-    Puppet::Util::Log.create({
-        :level => severity,
-        :message => formatter.format_message(diagnostic),
-        :issue_code => diagnostic.issue.issue_code,
-        :file => file,
-        :line => line,
-        :pos => pos,
-      })
-  end
-  private_class_method :log_message
 end