puppet 8.2.0-universal-darwin → 8.4.0-universal-darwin

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

@@ -1,54 +1,55 @@
 # frozen_string_literal: true
+
 Puppet::Parser::Functions::newfunction(
   :type,
   :type => :rvalue,
   :arity => -1,
-  :doc => <<-DOC
-Returns the data type of a given value with a given degree of generality.
-
-```puppet
-type InferenceFidelity = Enum[generalized, reduced, detailed]
-
-function type(Any $value, InferenceFidelity $fidelity = 'detailed') # returns Type
-```
-
- **Example:** Using `type`
-
- ``` puppet
- notice type(42) =~ Type[Integer]
- ```
-
- Would notice `true`.
-
- By default, the best possible inference is made where all details are retained.
- This is good when the type is used for further type calculations but is overwhelmingly
- rich in information if it is used in a error message.
-
- The optional argument `$fidelity` may be given as (from lowest to highest fidelity):
-
- * `generalized` - reduces to common type and drops size constraints
- * `reduced` - reduces to common type in collections
- * `detailed` - (default) all details about inferred types is retained
-
- **Example:** Using `type()` with different inference fidelity:
-
- ``` puppet
- notice type([3.14, 42], 'generalized')
- notice type([3.14, 42], 'reduced'')
- notice type([3.14, 42], 'detailed')
- notice type([3.14, 42])
- ```
-
- Would notice the four values:
-
- 1. 'Array[Numeric]'
- 2. 'Array[Numeric, 2, 2]'
- 3. 'Tuple[Float[3.14], Integer[42,42]]]'
- 4. 'Tuple[Float[3.14], Integer[42,42]]]'
-
- * Since 4.4.0
-
-DOC
-) do |args|
+  :doc => <<~DOC
+    Returns the data type of a given value with a given degree of generality.
+    
+    ```puppet
+    type InferenceFidelity = Enum[generalized, reduced, detailed]
+    
+    function type(Any $value, InferenceFidelity $fidelity = 'detailed') # returns Type
+    ```
+    
+     **Example:** Using `type`
+    
+     ``` puppet
+     notice type(42) =~ Type[Integer]
+     ```
+    
+     Would notice `true`.
+    
+     By default, the best possible inference is made where all details are retained.
+     This is good when the type is used for further type calculations but is overwhelmingly
+     rich in information if it is used in a error message.
+    
+     The optional argument `$fidelity` may be given as (from lowest to highest fidelity):
+    
+     * `generalized` - reduces to common type and drops size constraints
+     * `reduced` - reduces to common type in collections
+     * `detailed` - (default) all details about inferred types is retained
+    
+     **Example:** Using `type()` with different inference fidelity:
+    
+     ``` puppet
+     notice type([3.14, 42], 'generalized')
+     notice type([3.14, 42], 'reduced'')
+     notice type([3.14, 42], 'detailed')
+     notice type([3.14, 42])
+     ```
+    
+     Would notice the four values:
+    
+     1. 'Array[Numeric]'
+     2. 'Array[Numeric, 2, 2]'
+     3. 'Tuple[Float[3.14], Integer[42,42]]]'
+     4. 'Tuple[Float[3.14], Integer[42,42]]]'
+    
+     * Since 4.4.0
+    
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('type')
 end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/util/package'
 
 Puppet::Parser::Functions::newfunction( :versioncmp, :type => :rvalue, :arity => 2, :doc =>
@@ -26,6 +27,5 @@ This function uses the same version comparison algorithm used by Puppet's
 `package` type.
 
 ") do |args|
-
   return Puppet::Util::Package.versioncmp(args[0], args[1])
 end

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

@@ -1,29 +1,30 @@
 # frozen_string_literal: true
+
 Puppet::Parser::Functions::newfunction(
   :with,
   :type => :rvalue,
   :arity => -1,
-  :doc => <<-DOC
-Call a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
-with the given arguments and return the result. Since a lambda's scope is
-local to the lambda, you can use the `with` function to create private blocks
-of code within a class using variables whose values cannot be accessed outside
-of the lambda.
-
-**Example**: Using `with`
-
-~~~ puppet
-# Concatenate three strings into a single string formatted as a list.
-$fruit = with("apples", "oranges", "bananas") |$x, $y, $z| {
-  "${x}, ${y}, and ${z}"
-}
-$check_var = $x
-# $fruit contains "apples, oranges, and bananas"
-# $check_var is undefined, as the value of $x is local to the lambda.
-~~~
-
-- Since 4.0.0
-DOC
-) do |args|
+  :doc => <<~DOC
+    Call a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
+    with the given arguments and return the result. Since a lambda's scope is
+    local to the lambda, you can use the `with` function to create private blocks
+    of code within a class using variables whose values cannot be accessed outside
+    of the lambda.
+    
+    **Example**: Using `with`
+    
+    ~~~ puppet
+    # Concatenate three strings into a single string formatted as a list.
+    $fruit = with("apples", "oranges", "bananas") |$x, $y, $z| {
+      "${x}, ${y}, and ${z}"
+    }
+    $check_var = $x
+    # $fruit contains "apples, oranges, and bananas"
+    # $check_var is undefined, as the value of $x is local to the lambda.
+    ~~~
+    
+    - Since 4.0.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('with')
 end

data/lib/puppet/parser/functions.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/util/autoload'
 require_relative '../../puppet/parser/scope'
 require_relative '../../puppet/pops/adaptable'
@@ -213,6 +214,7 @@ module Puppet::Parser::Functions
           elsif arity < 0 and args[0].size < (arity+1).abs
             raise ArgumentError, _("%{name}(): Wrong number of arguments given (%{arg_count} for minimum %{min_arg_count})") % { name: name, arg_count: args[0].size, min_arg_count: (arity+1).abs }
           end
+
           r = Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.convert_return(self.send(real_fname, args[0]))
           # avoid leaking aribtrary value if not being an rvalue function
           options[:type] == :rvalue ? r : nil
@@ -258,7 +260,7 @@ module Puppet::Parser::Functions
   def self.functiondocs(environment = Puppet.lookup(:current_environment))
     autoloader.delegatee.loadall(environment)
 
-    ret = String.new
+    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"

data/lib/puppet/parser/parser_factory.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet; end
 
 module Puppet::Parser

data/lib/puppet/parser/relationship.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 class Puppet::Parser::Relationship
   attr_accessor :source, :target, :type
 
@@ -44,6 +45,7 @@ class Puppet::Parser::Relationship
     unless catalog.resource(*target_ref)
       raise ArgumentError, _("Could not find resource '%{target}' for relationship from '%{source}'") % { target: target.to_s, source: source.to_s }
     end
+
     Puppet.debug {"Adding relationship from #{source} to #{target} with '#{param_name}'"}
     if source_resource[rel_param].class != Array
       source_resource[rel_param] = [source_resource[rel_param]].compact
@@ -60,6 +62,7 @@ class Puppet::Parser::Relationship
     if x.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
       collected = x.collected
       return collected.values unless collected.empty?
+
       adapter = Puppet::Pops::Adapters::EmptyAlternativeAdapter.get(x)
       adapter.nil? ? [] : leftmost_alternative(adapter.empty_alternative)
     elsif x.is_a?(Array) && x.size == 1 && x[0].is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # The parameters we stick in Resources.
 class Puppet::Parser::Resource::Param
   include Puppet::Util

data/lib/puppet/parser/resource.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/resource'
 
 # The primary difference between this class and its
@@ -34,6 +35,7 @@ class Puppet::Parser::Resource < Puppet::Resource
     if param == :title
       return self.title
     end
+
     if @parameters.has_key?(param)
       @parameters[param].value
     else
@@ -42,7 +44,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   end
 
   def eachparam
-    @parameters.each do |name, param|
+    @parameters.each do |_name, param|
       yield param
     end
   end
@@ -69,6 +71,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   # Retrieve the associated definition and evaluate it.
   def evaluate
     return if evaluated?
+
     Puppet::Util::Profiler.profile(_("Evaluated resource %{res}") % { res: self }, [:compiler, :evaluate_resource, self]) do
       @evaluated = true
       if builtin_type?
@@ -98,6 +101,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   #
   def finish_evaluation
     return if @evaluation_finished
+
     add_scope_tags
     @evaluation_finished = true
   end
@@ -111,6 +115,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   # @api private
   def finish(do_validate = true)
     return if finished?
+
     @finished = true
     finish_evaluation
     replace_sensitive_data
@@ -125,6 +130,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   def initialize(type, title, attributes, with_defaults = true)
     raise ArgumentError, _('Resources require a hash as last argument') unless attributes.is_a? Hash
     raise ArgumentError, _('Resources require a scope') unless attributes[:scope]
+
     super(type, title, attributes)
 
     @source ||= scope.source
@@ -156,7 +162,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.object_id == resource.source.object_id || resource.source.child_of?(self.source)
+    unless self.source.equal?(resource.source) || resource.source.child_of?(self.source)
       raise Puppet::ParseError.new(_("Only subclasses can override parameters"), resource.file, resource.line)
     end
 
@@ -179,7 +185,7 @@ class Puppet::Parser::Resource < Puppet::Resource
     end
 
     # Some of these might fail, but they'll fail in the way we want.
-    resource.parameters.each do |name, param|
+    resource.parameters.each do |_name, param|
       override_parameter(param)
     end
   end
@@ -332,7 +338,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   def validate
     if builtin_type?
       begin
-        @parameters.each { |name, value| validate_parameter(name) }
+        @parameters.each { |name, _value| validate_parameter(name) }
       rescue => detail
         self.fail Puppet::ParseError, detail.to_s + " on #{self}", detail
       end

data/lib/puppet/parser/scope.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # The scope class, which handles storing and retrieving variables and types and
 # such.
 require 'forwardable'
@@ -42,7 +43,6 @@ class Puppet::Parser::Scope
   # Abstract base class for LocalScope and MatchScope
   #
   class Ephemeral
-
     attr_reader :parent
 
     def initialize(parent = nil)
@@ -75,7 +75,6 @@ class Puppet::Parser::Scope
   end
 
   class LocalScope < Ephemeral
-
     def initialize(parent=nil)
       super parent
       @symbols = {}
@@ -120,7 +119,6 @@ class Puppet::Parser::Scope
   end
 
   class MatchScope < Ephemeral
-
     attr_accessor :match_data
 
     def initialize(parent = nil, match_data = nil)
@@ -165,7 +163,6 @@ class Puppet::Parser::Scope
       # do not include match data ($0-$n)
       super
     end
-
   end
 
   # @api private
@@ -213,6 +210,7 @@ class Puppet::Parser::Scope
       # Parameters are evaluated in the order they have in the @params hash.
       keys = @params.keys
       raise Puppet::Error, _("%{callee}: expects a value for parameter $%{to}") % { callee: @callee_name, to: to } if keys.index(to) < keys.index(from)
+
       raise Puppet::Error, _("%{callee}: default expression for $%{from} tries to illegally access not yet evaluated $%{to}") % { callee: @callee_name, from: from, to: to }
     end
     private :parameter_reference_failure
@@ -227,12 +225,14 @@ class Puppet::Parser::Scope
     def [](name)
       access = @params[name]
       return super if access.nil?
+
       throw(:unevaluated_parameter, name) unless access.assigned?
       access.value
     end
 
     def []=(name, value)
       raise Puppet::Error, _("Attempt to assign variable %{name} when evaluating parameters") % { name: name } if @read_only
+
       @params[name] ||= Access.new
       @params[name].value = value
     end
@@ -264,7 +264,6 @@ class Puppet::Parser::Scope
     end
   end
 
-
   # Returns true if the variable of the given name has a non nil value.
   # TODO: This has vague semantics - does the variable exist or not?
   #       use ['name'] to get nil or value, and if nil check with exist?('name')
@@ -284,24 +283,24 @@ class Puppet::Parser::Scope
   def exist?(name)
     # Note !! ensure the answer is boolean
     !! if name =~ /^(.*)::(.+)$/
-      class_name = $1
-      variable_name = $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
-      # in it not existing anyway. (Tests may run with just scopes and no evaluated classes which
-      # will result in class_scope for "" not returning topscope).
-      klass = find_hostclass(class_name)
-      other_scope = klass.nil? ? nil : class_scope(klass)
-      if other_scope.nil?
-        class_name == '' ? compiler.topscope.exist?(variable_name) : false
-      else
-        other_scope.exist?(variable_name)
-      end
-    else
+         class_name = $1
+         variable_name = $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
+         # in it not existing anyway. (Tests may run with just scopes and no evaluated classes which
+         # will result in class_scope for "" not returning topscope).
+         klass = find_hostclass(class_name)
+         other_scope = klass.nil? ? nil : class_scope(klass)
+         if other_scope.nil?
+           class_name == '' ? compiler.topscope.exist?(variable_name) : false
+         else
+           other_scope.exist?(variable_name)
+         end
+    else # rubocop:disable Layout/ElseAlignment
       next_scope = inherited_scope || enclosing_scope
       effective_symtable(true).include?(name) || next_scope && next_scope.exist?(name) || BUILT_IN_VARS.include?(name)
-    end
+    end # rubocop:disable Layout/EndAlignment
   end
 
   # Returns true if the given name is bound in the current (most nested) scope for assignments.
@@ -525,19 +524,20 @@ class Puppet::Parser::Scope
     if BUILT_IN_VARS.include?(name) || name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
       return nil
     end
+
     begin
       throw(:undefined_variable, reason)
-    rescue  UNCAUGHT_THROW_EXCEPTION
+    rescue UNCAUGHT_THROW_EXCEPTION
       case Puppet[:strict]
       when :off
         # do nothing
       when :warning
         Puppet.warn_once(UNDEFINED_VARIABLES_KIND, _("Variable: %{name}") % { name: name },
-        _("Undefined variable '%{name}'; %{reason}") % { name: name, reason: reason } )
+                         _("Undefined variable '%{name}'; %{reason}") % { name: name, reason: reason } )
       when :error
         if Puppet.lookup(:avoid_hiera_interpolation_errors){false}
           Puppet.warn_once(UNDEFINED_VARIABLES_KIND, _("Variable: %{name}") % { name: name },
-          _("Interpolation failed with '%{name}', but compilation continuing; %{reason}") % { name: name, reason: reason } )
+                           _("Interpolation failed with '%{name}', but compilation continuing; %{reason}") % { name: name, reason: reason } )
         else
           raise ArgumentError, _("Undefined variable '%{name}'; %{reason}") % { name: name, reason: reason }
         end
@@ -579,13 +579,13 @@ class Puppet::Parser::Scope
   #
   # @return [Puppet::Parser::Scope] The scope or nil if there is no enclosing scope
   def enclosing_scope
-     if has_enclosing_scope?
+    if has_enclosing_scope?
       if parent.is_topscope? || parent.is_nodescope?
         parent
       else
         parent.enclosing_scope
       end
-     end
+    end
   end
 
   def is_classscope?
@@ -615,6 +615,7 @@ class Puppet::Parser::Scope
         qs = qualified_scope(class_name)
         unless qs.nil?
           return qs.get_local_variable(leaf_name) if qs.has_local_variable?(leaf_name)
+
           iscope = qs.inherited_scope
           return lookup_qualified_variable("#{iscope.source.name}::#{leaf_name}", options) unless iscope.nil?
         end
@@ -658,9 +659,11 @@ class Puppet::Parser::Scope
 
   def qualified_scope(classname)
     klass = find_hostclass(classname)
-    raise _("class %{classname} could not be found") % { classname: classname }     unless klass
+    raise _("class %{classname} could not be found") % { classname: classname } unless klass
+
     kscope = class_scope(klass)
     raise _("class %{classname} has not been evaluated") % { classname: classname } unless kscope
+
     kscope
   end
   private :qualified_scope
@@ -692,6 +695,7 @@ class Puppet::Parser::Scope
 
   def parent_module_name
     return nil unless @parent && @parent.source
+
     @parent.source.module_name
   end
 
@@ -708,6 +712,7 @@ class Puppet::Parser::Scope
       if table.include?(param.name)
         raise Puppet::ParseError.new(_("Default already defined for %{type} { %{param} }; cannot redefine") % { type: type, param: param.name }, param.file, param.line)
       end
+
       table[param.name] = param
     }
   end
@@ -722,6 +727,7 @@ class Puppet::Parser::Scope
     all_local = {}
     settings.each_key do |name|
       next if :name == name
+
       key = name.to_s
       value = transform_setting(settings.value_sym(name, env_name))
       if set_in_this_scope
@@ -1016,6 +1022,7 @@ class Puppet::Parser::Scope
       new_ephemeral(false)
     else
       raise(ArgumentError,_("Invalid regex match data. Got a %{klass}") % { klass: match.class }) unless match.is_a?(MatchData)
+
       # Create a match ephemeral and set values from match data
       new_match_scope(match)
     end
@@ -1036,7 +1043,6 @@ class Puppet::Parser::Scope
     raise Puppet::DevError, _("Scope#find_defined_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead")
   end
 
-
   def method_missing(method, *args, &block)
     method.to_s =~ /^function_(.*)$/
     name = $1
@@ -1077,6 +1083,7 @@ class Puppet::Parser::Scope
         raise ArgumentError, _("Cannot use undef as a class name")
       when String
         raise ArgumentError, _("Cannot use empty string as a class name") if name.empty?
+
         name.sub(/^([^:]{1,2})/, '::\1')
 
       when Puppet::Resource
@@ -1084,8 +1091,9 @@ class Puppet::Parser::Scope
         name.title.sub(/^([^:]{1,2})/, '::\1')
 
       when Puppet::Pops::Types::PClassType
-        #TRANSLATORS "Class" and "Type" are Puppet keywords and should not be translated
+        # TRANSLATORS "Class" and "Type" are Puppet keywords and should not be translated
         raise ArgumentError, _("Cannot use an unspecific Class[] Type") unless name.class_name
+
         name.class_name.sub(/^([^:]{1,2})/, '::\1')
 
       when Puppet::Pops::Types::PResourceType
@@ -1111,15 +1119,15 @@ class Puppet::Parser::Scope
 
   def assert_class_and_title(type_name, title)
     if type_name.nil? || type_name == ''
-      #TRANSLATORS "Resource" is a class name and should not be translated
+      # TRANSLATORS "Resource" is a class name and should not be translated
       raise ArgumentError, _("Cannot use an unspecific Resource[] where a Resource['class', name] is expected")
     end
     unless type_name =~ /^[Cc]lass$/
-      #TRANSLATORS "Resource" is a class name and should not be translated
+      # TRANSLATORS "Resource" is a class name and should not be translated
       raise ArgumentError, _("Cannot use a Resource[%{type_name}] where a Resource['class', name] is expected") % { type_name: type_name }
     end
     if title.nil?
-      #TRANSLATORS "Resource" is a class name and should not be translated
+      # TRANSLATORS "Resource" is a class name and should not be translated
       raise ArgumentError, _("Cannot use an unspecific Resource['class'] where a Resource['class', name] is expected")
     end
   end

data/lib/puppet/parser/script_compiler.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/loaders'
 require_relative '../../puppet/pops'
 
@@ -41,8 +42,7 @@ class Puppet::Parser::ScriptCompiler
 
     # TRANSLATORS, "For running script" is not user facing
     Puppet.override( @context_overrides , "For running script") do
-
-      #TRANSLATORS "main" is a function name and should not be translated
+      # TRANSLATORS "main" is a function name and should not be translated
       result = Puppet::Util::Profiler.profile(_("Script: Evaluated main"), [:script, :evaluate_main]) { evaluate_main }
       if block_given?
         yield self
@@ -50,7 +50,6 @@ class Puppet::Parser::ScriptCompiler
         result
       end
     end
-
   rescue Puppet::ParseErrorWithIssue => detail
     detail.node = node_name
     Puppet.log_exception(detail)
@@ -65,8 +64,8 @@ class Puppet::Parser::ScriptCompiler
   def context_overrides()
     {
       :current_environment => environment,
-      :global_scope => @topscope,             # 4x placeholder for new global scope
-      :loaders  => @loaders,                  # 4x loaders
+      :global_scope => @topscope, # 4x placeholder for new global scope
+      :loaders => @loaders, # 4x loaders
       :rich_data => true,
     }
   end
@@ -110,7 +109,7 @@ class Puppet::Parser::ScriptCompiler
   # have to (TODO).
   #
   def newscope(parent, options = {})
-     raise _('having multiple named scopes is not supported when scripting')
+    raise _('having multiple named scopes is not supported when scripting')
   end
 
   private

data/lib/puppet/parser/templatewrapper.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/parser/files'
 require 'erb'
 require_relative '../../puppet/file_system'

data/lib/puppet/parser/type_loader.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
+
 require 'find'
 require 'forwardable'
 require_relative '../../puppet/parser/parser_factory'
 
 class Puppet::Parser::TypeLoader
-  extend  Forwardable
+  extend Forwardable
 
   class TypeLoaderError < StandardError; end
 
@@ -64,6 +65,7 @@ class Puppet::Parser::TypeLoader
   # Try to load the object with the given fully qualified name.
   def try_load_fqname(type, fqname)
     return nil if fqname == "" # special-case main.
+
     files_to_try_for(fqname).each do |filename|
       begin
         imported_types = import_from_modules(filename)
@@ -107,25 +109,25 @@ class Puppet::Parser::TypeLoader
     @loaded ||= {}
     loaded_asts = []
     files.reject { |file| @loaded[file] }.each do |file|
-    # The squelch_parse_errors use case is for parsing for the purpose of searching
-    # for information and it should not abort.
-    # There is currently one user in indirector/resourcetype/parser
-    #
-    if Puppet.lookup(:squelch_parse_errors) {|| false }
-      begin
+      # The squelch_parse_errors use case is for parsing for the purpose of searching
+      # for information and it should not abort.
+      # There is currently one user in indirector/resourcetype/parser
+      #
+      if Puppet.lookup(:squelch_parse_errors) {|| false }
+        begin
+          loaded_asts << parse_file(file)
+        rescue => e
+          # Resume from errors so that all parseable files may
+          # still be parsed. Mark this file as loaded so that
+          # it would not be parsed next time (handle it as if
+          # it was successfully parsed).
+          Puppet.debug { "Unable to parse '#{file}': #{e.message}" }
+        end
+      else
         loaded_asts << parse_file(file)
-      rescue => e
-        # Resume from errors so that all parseable files may
-        # still be parsed. Mark this file as loaded so that
-        # it would not be parsed next time (handle it as if
-        # it was successfully parsed).
-        Puppet.debug { "Unable to parse '#{file}': #{e.message}" }
       end
-    else
-      loaded_asts << parse_file(file)
-    end
 
-    @loaded[file] = true
+      @loaded[file] = true
     end
 
     loaded_asts.collect do |ast|

data/lib/puppet/parser.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # is only needed to create the name space
 module Puppet::Parser; end