puppet 8.5.1-universal-darwin → 8.6.0-universal-darwin

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

@@ -17,13 +17,13 @@ class Puppet::Parser::AST::ResourceParam < Puppet::Parser::AST::Branch
   # Return the parameter and the value.
   def evaluate(scope)
     value = @value.safeevaluate(scope)
-    return Puppet::Parser::Resource::Param.new(
+    Puppet::Parser::Resource::Param.new(
       :name => @param,
       :value => value.nil? ? :undef : value,
       :source => scope.source,
-      :line => self.line,
-      :file => self.file,
-      :add => self.add
+      :line => line,
+      :file => file,
+      :add => add
     )
   end
 

data/lib/puppet/parser/ast.rb

@@ -28,21 +28,20 @@ class Puppet::Parser::AST
   def safeevaluate(scope)
     # We duplicate code here, rather than using exceptwrap, because this
     # is called so many times during parsing.
-    begin
-      return self.evaluate(scope)
-    rescue Puppet::Pops::Evaluator::PuppetStopIteration => detail
-      raise detail
-    #      # Only deals with StopIteration from the break() function as a general
-    #      # StopIteration is a general runtime problem
-    #      raise Puppet::ParseError.new(detail.message, detail.file, detail.line, detail)
-    rescue Puppet::Error => detail
-      raise adderrorcontext(detail)
-    rescue => detail
-      error = Puppet::ParseError.new(detail.to_s, nil, nil, detail)
-      # We can't use self.fail here because it always expects strings,
-      # not exceptions.
-      raise adderrorcontext(error, detail)
-    end
+
+    evaluate(scope)
+  rescue Puppet::Pops::Evaluator::PuppetStopIteration => detail
+    raise detail
+  #      # Only deals with StopIteration from the break() function as a general
+  #      # StopIteration is a general runtime problem
+  #      raise Puppet::ParseError.new(detail.message, detail.file, detail.line, detail)
+  rescue Puppet::Error => detail
+    raise adderrorcontext(detail)
+  rescue => detail
+    error = Puppet::ParseError.new(detail.to_s, nil, nil, detail)
+    # We can't use self.fail here because it always expects strings,
+    # not exceptions.
+    raise adderrorcontext(error, detail)
   end
 
   def initialize(file: nil, line: nil, pos: nil)

data/lib/puppet/parser/compiler.rb

@@ -24,16 +24,16 @@ class Puppet::Parser::Compiler
     node.environment.check_for_reparse
 
     errors = node.environment.validation_errors
-    if !errors.empty?
+    unless errors.empty?
       errors.each { |e| Puppet.err(e) } if errors.size > 1
       errmsg = [
         _("Compilation has been halted because: %{error}") % { error: errors.first },
-        _("For more information, see https://puppet.com/docs/puppet/latest/environments_about.html"),
+        _("For more information, see https://puppet.com/docs/puppet/latest/environments_about.html")
       ]
       raise(Puppet::Error, errmsg.join(' '))
     end
 
-    new(node, :code_id => code_id).compile { |resulting_catalog| resulting_catalog.to_resource }
+    new(node, :code_id => code_id).compile(&:to_resource)
   rescue Puppet::ParseErrorWithIssue => detail
     detail.node = node.name
     Puppet.log_exception(detail)
@@ -79,7 +79,7 @@ class Puppet::Parser::Compiler
     # Note that this will fail if the resource is not unique.
     @catalog.add_resource(resource)
 
-    if not resource.class? and resource[:stage]
+    if !resource.class? and resource[:stage]
       # TRANSLATORS "stage" is a keyword in Puppet and should not be translated
       raise ArgumentError, _("Only classes can set 'stage'; normal resources like %{resource} cannot change run stage") % { resource: resource }
     end
@@ -216,7 +216,7 @@ class Puppet::Parser::Compiler
       break if astnode
     end
 
-    unless (astnode ||= krt.node("default"))
+    unless astnode ||= krt.node("default")
       raise Puppet::ParseError, _("Could not find node statement with name 'default' or '%{names}'") % { names: node.names.join(", ") }
     end
 
@@ -251,14 +251,14 @@ class Puppet::Parser::Compiler
 
     if class_parameters
       resources = ensure_classes_with_parameters(scope, hostclasses, class_parameters)
-      if !lazy_evaluate
+      unless lazy_evaluate
         resources.each(&:evaluate)
       end
 
       resources
     else
       already_included, newly_included = ensure_classes_without_parameters(scope, hostclasses)
-      if !lazy_evaluate
+      unless lazy_evaluate
         newly_included.each(&:evaluate)
       end
 
@@ -345,17 +345,15 @@ class Puppet::Parser::Compiler
     exceptwrap do
       Puppet::Util::Profiler.profile(_("Evaluated definitions"), [:compiler, :evaluate_definitions]) do
         urs = unevaluated_resources.each do |resource|
-          begin
-            resource.evaluate
-          rescue Puppet::Pops::Evaluator::PuppetStopIteration => detail
-            # needs to be handled specifically as the error has the file/line/position where this
-            # occurred rather than the resource
-            fail(Puppet::Pops::Issues::RUNTIME_ERROR, detail, { :detail => detail.message }, detail)
-          rescue Puppet::Error => e
-            # PuppetError has the ability to wrap an exception, if so, use the wrapped exception's
-            # call stack instead
-            fail(Puppet::Pops::Issues::RUNTIME_ERROR, resource, { :detail => e.message }, e.original || e)
-          end
+          resource.evaluate
+        rescue Puppet::Pops::Evaluator::PuppetStopIteration => detail
+          # needs to be handled specifically as the error has the file/line/position where this
+          # occurred rather than the resource
+          fail(Puppet::Pops::Issues::RUNTIME_ERROR, detail, { :detail => detail.message }, detail)
+        rescue Puppet::Error => e
+          # PuppetError has the ability to wrap an exception, if so, use the wrapped exception's
+          # call stack instead
+          fail(Puppet::Pops::Issues::RUNTIME_ERROR, resource, { :detail => e.message }, e.original || e)
         end
         !urs.empty?
       end
@@ -413,7 +411,7 @@ class Puppet::Parser::Compiler
   def fail_on_unevaluated_overrides
     remaining = @resource_overrides.values.flatten.collect(&:ref)
 
-    if !remaining.empty?
+    unless remaining.empty?
       raise Puppet::ParseError, _("Could not find resource(s) %{resources} for overriding") % { resources: remaining.join(', ') }
     end
   end
@@ -424,7 +422,7 @@ class Puppet::Parser::Compiler
   #
   def fail_on_unevaluated_resource_collections
     remaining = @collections.collect(&:unresolved_resources).flatten.compact
-    if !remaining.empty?
+    unless remaining.empty?
       raise Puppet::ParseError, _("Failed to realize virtual resources %{resources}") % { resources: remaining.join(', ') }
     end
   end
@@ -484,14 +482,14 @@ class Puppet::Parser::Compiler
   def metaparams_as_data(resource, params)
     data = nil
     params.each do |param|
-      unless resource[param].nil?
-        # Because we could be creating a hash for every resource,
-        # and we actually probably don't often have any data here at all,
-        # we're optimizing a bit by only creating a hash if there's
-        # any data to put in it.
-        data ||= {}
-        data[param] = resource[param]
-      end
+      next if resource[param].nil?
+
+      # Because we could be creating a hash for every resource,
+      # and we actually probably don't often have any data here at all,
+      # we're optimizing a bit by only creating a hash if there's
+      # any data to put in it.
+      data ||= {}
+      data[param] = resource[param]
     end
     data
   end

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

@@ -61,10 +61,10 @@ ENDHEREDOC
   end
 
   raise ArgumentError, (_("create_resources(): wrong number of arguments (%{count}; must be 2 or 3)") % { count: args.length }) if args.length > 3
-  raise ArgumentError, (_('create_resources(): second argument must be a hash')) unless args[1].is_a?(Hash)
+  raise ArgumentError, _('create_resources(): second argument must be a hash') unless args[1].is_a?(Hash)
 
   if args.length == 3
-    raise ArgumentError, (_('create_resources(): third argument, if provided, must be a hash')) unless args[2].is_a?(Hash)
+    raise ArgumentError, _('create_resources(): third argument, if provided, must be a hash') unless args[2].is_a?(Hash)
   end
 
   type, instances, defaults = args
@@ -105,7 +105,7 @@ ENDHEREDOC
         Puppet::Parser::Resource::Param.new(
           :name => name,
           :value => value, # wide open to various data types, must be correct
-          :source => self.source, # TODO: support :line => line, :file => file,
+          :source => source, # TODO: support :line => line, :file => file,
           :add => false
         )
       end

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

@@ -8,6 +8,6 @@ Puppet::Parser::Functions.newfunction(
     concatenated, and passed to the exception-handler.
   DOC
 ) do |vals|
-  vals = vals.collect { |s| s.to_s }.join(" ") if vals.is_a? Array
+  vals = vals.collect(&:to_s).join(" ") if vals.is_a? Array
   raise Puppet::ParseError, vals.to_s
 end

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

@@ -17,9 +17,9 @@ Puppet::Parser::Functions.newfunction(:generate, :arity => -2, :type => :rvalue,
   raise Puppet::ParseError, _("Generators must be fully qualified") unless Puppet::Util.absolute_path?(args[0])
 
   if Puppet::Util::Platform.windows?
-    valid = args[0] =~ /^[a-z]:(?:[\/\\][-.~\w]+)+$/i
+    valid = args[0] =~ %r{^[a-z]:(?:[/\\][-.~\w]+)+$}i
   else
-    valid = args[0] =~ /^[-\/\w.+]+$/
+    valid = args[0] =~ %r{^[-/\w.+]+$}
   end
 
   unless valid

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

@@ -11,5 +11,5 @@ Puppet::Parser::Functions.newfunction(:tag, :arity => -2, :doc => "Add the speci
     )
   end
 
-  self.resource.tag(*vals)
+  resource.tag(*vals)
 end

data/lib/puppet/parser/functions.rb

@@ -215,7 +215,7 @@ module Puppet::Parser::Functions
             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
 
-          r = Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.convert_return(self.send(real_fname, args[0]))
+          r = Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.convert_return(send(real_fname, args[0]))
           # avoid leaking aribtrary value if not being an rvalue function
           options[:type] == :rvalue ? r : nil
         else
@@ -263,7 +263,7 @@ module Puppet::Parser::Functions
     ret = ''.dup
 
     merged_functions(environment).sort { |a, b| a[0].to_s <=> b[0].to_s }.each do |name, hash|
-      ret << "#{name}\n#{"-" * name.to_s.length}\n"
+      ret << "#{name}\n#{'-' * name.to_s.length}\n"
       if hash[:doc]
         ret << Puppet::Util::Docs.scrub(hash[:doc])
       else

data/lib/puppet/parser/relationship.rb

@@ -26,7 +26,9 @@ class Puppet::Parser::Relationship
   end
 
   def initialize(source, target, type)
-    @source, @target, @type = source, target, type
+    @source = source
+    @target = target
+    @type = type
   end
 
   def param_name

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

@@ -26,12 +26,12 @@ class Puppet::Parser::Resource::Param
   end
 
   def to_s
-    "#{self.name} => #{self.value}"
+    "#{name} => #{value}"
   end
 
   def self.from_param(param, value)
     new_param = param.dup
     new_param.value = value
-    return new_param
+    new_param
   end
 end

data/lib/puppet/parser/resource.rb

@@ -21,7 +21,7 @@ class Puppet::Parser::Resource < Puppet::Resource
 
   # Determine whether the provided parameter name is a relationship parameter.
   def self.relationship_parameter?(name)
-    @relationship_names ||= Puppet::Type.relationship_params.collect { |p| p.name }
+    @relationship_names ||= Puppet::Type.relationship_params.collect(&:name)
     @relationship_names.include?(name)
   end
 
@@ -33,7 +33,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   def [](param)
     param = param.intern
     if param == :title
-      return self.title
+      return title
     end
 
     if @parameters.has_key?(param)
@@ -57,7 +57,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   # is drawn from  the class to the stage.   The stage for containment
   # defaults to main, if none is specified.
   def add_edge_to_stage
-    return unless self.class?
+    return unless class?
 
     stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
     unless stage
@@ -136,13 +136,13 @@ class Puppet::Parser::Resource < Puppet::Resource
 
     if with_defaults
       scope.lookupdefaults(self.type).each_pair do |name, param|
-        unless @parameters.include?(name)
-          self.debug "Adding default for #{name}"
+        next if @parameters.include?(name)
 
-          param = param.dup
-          @parameters[name] = param
-          tag(*param.value) if param.name == :tag
-        end
+        debug "Adding default for #{name}"
+
+        param = param.dup
+        @parameters[name] = param
+        tag(*param.value) if param.name == :tag
       end
     end
   end
@@ -150,9 +150,9 @@ class Puppet::Parser::Resource < Puppet::Resource
   # Is this resource modeling an isomorphic resource type?
   def isomorphic?
     if builtin_type?
-      return resource_type.isomorphic?
+      resource_type.isomorphic?
     else
-      return true
+      true
     end
   end
 
@@ -161,7 +161,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   def merge(resource)
     # Test the resource scope, to make sure the resource is even allowed
     # to override.
-    unless self.source.equal?(resource.source) || resource.source.child_of?(self.source)
+    unless source.equal?(resource.source) || resource.source.child_of?(source)
       raise Puppet::ParseError.new(_("Only subclasses can override parameters"), resource.file, resource.line)
     end
 
@@ -190,7 +190,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   end
 
   def name
-    self[:name] || self.title
+    self[:name] || title
   end
 
   # A temporary occasion, until I get paths in the scopes figured out.
@@ -200,10 +200,10 @@ class Puppet::Parser::Resource < Puppet::Resource
   # if we ever receive a parameter named 'tag', set
   # the resource tags with its value.
   def set_parameter(param, value = nil)
-    if !param.is_a?(Puppet::Parser::Resource::Param)
+    unless param.is_a?(Puppet::Parser::Resource::Param)
       param = param.name if param.is_a?(Puppet::Pops::Resource::Param)
       param = Puppet::Parser::Resource::Param.new(
-        :name => param, :value => value, :source => self.source
+        :name => param, :value => value, :source => source
       )
     end
 
@@ -219,16 +219,16 @@ class Puppet::Parser::Resource < Puppet::Resource
       value = param.value
       value = (:undef == value) ? nil : value
 
-      unless value.nil?
-        case param.name
-        when :before, :subscribe, :notify, :require
-          if value.is_a?(Array)
-            value = value.flatten.reject { |v| v.nil? || :undef == v }
-          end
-        else
+      next if value.nil?
+
+      case param.name
+      when :before, :subscribe, :notify, :require
+        if value.is_a?(Array)
+          value = value.flatten.reject { |v| v.nil? || :undef == v }
         end
-        result[param.name] = value
+      else
       end
+      result[param.name] = value
     end)
   end
 

data/lib/puppet/parser/scope.rb

@@ -17,7 +17,7 @@ class Puppet::Parser::Scope
   extend Forwardable
 
   # Variables that always exist with nil value even if not set
-  BUILT_IN_VARS = ['module_name', 'caller_module_name'].freeze
+  BUILT_IN_VARS = %w[module_name caller_module_name].freeze
   EMPTY_HASH = {}.freeze
 
   Puppet::Util.logmethods(self)
@@ -260,7 +260,7 @@ class Puppet::Parser::Scope
     end
 
     def to_hash
-      @params.select { |_, access| access.assigned? }.transform_values { |access| access.value }
+      @params.select { |_, access| access.assigned? }.transform_values(&:value)
     end
   end
 
@@ -283,8 +283,8 @@ class Puppet::Parser::Scope
   def exist?(name)
     # Note !! ensure the answer is boolean
     !!if name =~ /^(.*)::(.+)$/
-        class_name = $1
-        variable_name = $2
+        class_name = ::Regexp.last_match(1)
+        variable_name = ::Regexp.last_match(2)
         return true if class_name == '' && BUILT_IN_VARS.include?(variable_name)
 
         # lookup class, but do not care if it is not evaluated since that will result
@@ -425,7 +425,7 @@ class Puppet::Parser::Scope
   # additive -- it collects all of the defaults, with defaults
   # in closer scopes overriding those in later scopes.
   #
-  # The lookupdefaults searches in the the order:
+  # The lookupdefaults searches in the order:
   #
   #   * inherited
   #   * contained (recursive)
@@ -625,7 +625,7 @@ class Puppet::Parser::Scope
       end
     end
     # report with leading '::' by using empty class_name
-    return handle_not_found('', fqn, options)
+    handle_not_found('', fqn, options)
   end
 
   # @api private
@@ -676,7 +676,7 @@ class Puppet::Parser::Scope
   def to_hash(recursive = true, include_undef = false)
     if recursive and has_enclosing_scope?
       target = enclosing_scope.to_hash(recursive)
-      if !(inherited = inherited_scope).nil?
+      unless (inherited = inherited_scope).nil?
         target.merge!(inherited.to_hash(recursive))
       end
     else
@@ -773,7 +773,7 @@ class Puppet::Parser::Scope
   # when you need to set options.
   def setvar(name, value, options = EMPTY_HASH)
     if name =~ /^[0-9]+$/
-      raise Puppet::ParseError.new(_("Cannot assign to a numeric match result variable '$%{name}'") % { name: name }) # unless options[:ephemeral]
+      raise Puppet::ParseError, _("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 %{name} is a %{class_type}, not a string") % { name: name.inspect, class_type: name.class }
@@ -894,7 +894,7 @@ class Puppet::Parser::Scope
     # shorten the path if possible
     path = detail[0]
     env_path = nil
-    env_path = environment.configuration.path_to_env unless (environment.nil? || environment.configuration.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)
     module_path = environment.full_modulepath.detect { |m_path| path.start_with?(m_path) }
     if module_path
@@ -1046,7 +1046,7 @@ class Puppet::Parser::Scope
 
   def method_missing(method, *args, &block)
     method.to_s =~ /^function_(.*)$/
-    name = $1
+    name = ::Regexp.last_match(1)
     super unless name
     super unless Puppet::Parser::Functions.function(name)
     # In odd circumstances, this might not end up defined by the previous

data/lib/puppet/parser/script_compiler.rb

@@ -118,6 +118,6 @@ class Puppet::Parser::ScriptCompiler
   def evaluate_main
     @loaders.pre_load
     program = @loaders.load_main_manifest
-    return program.nil? ? nil : Puppet::Pops::Parser::EvaluatingParser.singleton.evaluator.evaluate(program, @topscope)
+    program.nil? ? nil : Puppet::Pops::Parser::EvaluatingParser.singleton.evaluator.evaluate(program, @topscope)
   end
 end

data/lib/puppet/parser/templatewrapper.rb

@@ -100,6 +100,6 @@ class Puppet::Parser::TemplateWrapper
   end
 
   def to_s
-    "template[#{(@__file__ ? @__file__ : "inline")}]"
+    "template[#{@__file__ || 'inline'}]"
   end
 end

data/lib/puppet/parser/type_loader.rb

@@ -67,27 +67,25 @@ class Puppet::Parser::TypeLoader
     return nil if fqname == "" # special-case main.
 
     files_to_try_for(fqname).each do |filename|
-      begin
-        imported_types = import_from_modules(filename)
-        result = imported_types.find { |t| t.type == type and t.name == fqname }
-        if result
-          Puppet.debug { "Automatically imported #{fqname} from #{filename} into #{environment}" }
-          return result
-        end
-      rescue TypeLoaderError
-        # I'm not convinced we should just drop these errors, but this
-        # preserves existing behaviours.
+      imported_types = import_from_modules(filename)
+      result = imported_types.find { |t| t.type == type and t.name == fqname }
+      if result
+        Puppet.debug { "Automatically imported #{fqname} from #{filename} into #{environment}" }
+        return result
       end
+    rescue TypeLoaderError
+      # I'm not convinced we should just drop these errors, but this
+      # preserves existing behaviours.
     end
     # Nothing found.
-    return nil
+    nil
   end
 
   def parse_file(file)
     Puppet.debug { "importing '#{file}' in environment #{environment}" }
     parser = Puppet::Parser::ParserFactory.parser
     parser.file = file
-    return parser.parse
+    parser.parse
   end
 
   private

data/lib/puppet/parser.rb

@@ -16,7 +16,7 @@ require_relative 'parser/relationship'
 require_relative '../puppet/resource/type'
 require 'monitor'
 
-require_relative 'parser/compiler/catalog_validator/relationship_validator.rb'
+require_relative 'parser/compiler/catalog_validator/relationship_validator'
 
 # PUP-3274 This should probably go someplace else
 class Puppet::LexError < RuntimeError; end

data/lib/puppet/pops/adaptable.rb

@@ -182,7 +182,7 @@ module Adaptable
     # Returns the name of the class, or the name of the type if the class represents an Object type
     # @return [String] the name of the class or type
     def self.type_name
-      self.name
+      name
     end
 
     # Returns a suitable instance variable name for the _name_ of this instance. The name is created by calling

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

@@ -67,7 +67,7 @@ class AccessOperator
                k2 = k2 < 0 ? o.length - k1 + k2 + 1 : k2  # abs length (negative k2 is length from pos to end count)
                # if k1 is outside, adjust to first position, and adjust length
                if k1 < 0
-                 k2 = k2 + k1
+                 k2 += k1
                  k1 = 0
                end
                o[k1, k2]
@@ -116,7 +116,7 @@ class AccessOperator
       k2 = k2 < 0 ? o.length - k1 + k2 + 1 : k2  # abs length (negative k2 is length from pos to end count)
       # if k1 is outside, adjust to first position, and adjust length
       if k1 < 0
-        k2 = k2 + k1
+        k2 += k1
         k1 = 0
       end
       # Help ruby always return empty array when asking for a sub array
@@ -448,7 +448,7 @@ class AccessOperator
 
     keys.each_with_index do |x, index|
       fail(Issues::BAD_INTEGER_SLICE_TYPE, @semantic.keys[index],
-           { :actual => x.class }) unless (x.is_a?(Integer) || x == :default)
+           { :actual => x.class }) unless x.is_a?(Integer) || x == :default
     end
     Types::PIntegerType.new(*keys)
   end
@@ -461,7 +461,7 @@ class AccessOperator
 
     keys.each_with_index do |x, index|
       fail(Issues::BAD_FLOAT_SLICE_TYPE, @semantic.keys[index],
-           { :actual => x.class }) unless (x.is_a?(Float) || x.is_a?(Integer) || x == :default)
+           { :actual => x.class }) unless x.is_a?(Float) || x.is_a?(Integer) || x == :default
     end
     from, to = keys
     from = from == :default || from.nil? ? nil : Float(from)
@@ -556,7 +556,7 @@ class AccessOperator
     else
       keys.each_with_index do |x, index|
         fail(Issues::BAD_COLLECTION_SLICE_TYPE, @semantic.keys[start_index + index],
-             { :actual => x.class }) unless (x.is_a?(Integer) || x == :default)
+             { :actual => x.class }) unless x.is_a?(Integer) || x == :default
       end
       Types::PIntegerType.new(*keys)
     end
@@ -635,7 +635,7 @@ class AccessOperator
       return result_type_array ? [] : nil
     end
 
-    if !o.title.nil?
+    unless o.title.nil?
       # lookup resource and return one or more parameter values
       resource = find_resource(scope, o.type_name, o.title)
       unless resource
@@ -665,7 +665,7 @@ class AccessOperator
       Types::PResourceType.new(type_name, t == :no_title ? nil : t)
     end
     # returns single type if request was for a single entity, else an array of types (possibly empty)
-    return result_type_array ? result : result.pop
+    result_type_array ? result : result.pop
   end
 
   NS = '::'
@@ -725,7 +725,7 @@ class AccessOperator
     end
 
     # returns single type as type, else an array of types
-    return result_type_array ? result : result.pop
+    result_type_array ? result : result.pop
   end
 end
 end

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

@@ -22,7 +22,7 @@ class Puppet::Pops::Evaluator::CallableSignature
   # @api public
   #
   def parameter_names
-    raise NotImplementedError.new
+    raise NotImplementedError
   end
 
   # Returns a PCallableType with the type information, required and optional count, and type information about
@@ -34,7 +34,7 @@ class Puppet::Pops::Evaluator::CallableSignature
   # @api public
   #
   def type
-    raise NotImplementedError.new
+    raise NotImplementedError
   end
 
   # Returns the expected type for an optional block. The type may be nil, which means that the callable does
@@ -56,7 +56,7 @@ class Puppet::Pops::Evaluator::CallableSignature
   # @api public
   #
   def block_name
-    raise NotImplementedError.new
+    raise NotImplementedError
   end
 
   # Returns a range indicating the optionality of a block. One of [0,0] (does not accept block), [0,1] (optional
@@ -87,7 +87,7 @@ class Puppet::Pops::Evaluator::CallableSignature
   # @api public
   #
   def last_captures_rest?
-    raise NotImplementedError.new
+    raise NotImplementedError
   end
 
   # Returns true if the given x is infinity