puppet 5.3.4 → 6.29.0

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

@@ -3,11 +3,11 @@ Puppet::Parser::Functions::newfunction(
   :type => :rvalue,
   :arity => -1,
   :doc => <<-DOC
-Call a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+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](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html#lambda-scope)
-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.
+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`
 

data/lib/puppet/parser/functions.rb

@@ -1,6 +1,7 @@
 require 'puppet/util/autoload'
 require 'puppet/parser/scope'
 require 'puppet/pops/adaptable'
+require 'puppet/concurrent/lock'
 
 # A module for managing parser functions.  Each specified function
 # is added to a central module that then gets included into the Scope
@@ -24,17 +25,49 @@ module Puppet::Parser::Functions
     Puppet::Util::Log.levels.each do |level|
       newfunction(level,
                   :environment => root_env,
-                  :doc => "Log a message on the server at level #{level.to_s}.") do |vals|
+                  :doc => "Log a message on the server at level #{level}.") do |vals|
         send(level, vals.join(" "))
       end
     end
   end
 
+  class AutoloaderDelegate
+    attr_reader :delegatee
+
+    def initialize
+      @delegatee = Puppet::Util::Autoload.new(self, "puppet/parser/functions")
+    end
+
+    def loadall(env = Puppet.lookup(:current_environment))
+      if Puppet[:strict] != :off
+        Puppet.warn_once('deprecations', 'Puppet::Parser::Functions#loadall', _("The method 'Puppet::Parser::Functions.autoloader#loadall' is deprecated in favor of using 'Scope#call_function'."))
+      end
+
+      @delegatee.loadall(env)
+    end
+
+    def load(name, env = Puppet.lookup(:current_environment))
+      if Puppet[:strict] != :off
+        Puppet.warn_once('deprecations', "Puppet::Parser::Functions#load('#{name}')", _("The method 'Puppet::Parser::Functions.autoloader#load(\"%{name}\")' is deprecated in favor of using 'Scope#call_function'.") % {name: name})
+      end
+
+      @delegatee.load(name, env)
+    end
+
+    def loaded?(name)
+      if Puppet[:strict] != :off
+        Puppet.warn_once('deprecations', "Puppet::Parser::Functions.loaded?('#{name}')", _("The method 'Puppet::Parser::Functions.autoloader#loaded?(\"%{name}\")' is deprecated in favor of using 'Scope#call_function'.") % {name: name})
+      end
+
+      @delegatee.loaded?(name)
+    end
+  end
+
   # Accessor for singleton autoloader
   #
   # @api private
   def self.autoloader
-    @autoloader ||= Puppet::Util::Autoload.new(self, "puppet/parser/functions")
+    @autoloader ||= AutoloaderDelegate.new
   end
 
   # An adapter that ties the anonymous module that acts as the container for all 3x functions to the environment
@@ -44,15 +77,10 @@ module Puppet::Parser::Functions
   # @api private
   class AnonymousModuleAdapter < Puppet::Pops::Adaptable::Adapter
     attr_accessor :module
-  end
 
-  # Get the module that functions are mixed into corresponding to an
-  # environment
-  #
-  # @api private
-  def self.environment_module(env)
-    AnonymousModuleAdapter.adapt(env) do |a|
-      a.module ||= Module.new do
+    def self.create_adapter(env)
+      adapter = super(env)
+      adapter.module = Module.new do
         @metadata = {}
 
         def self.all_function_info
@@ -67,7 +95,20 @@ module Puppet::Parser::Functions
           @metadata[name] = info
         end
       end
-    end.module
+      adapter
+    end
+  end
+
+  @environment_module_lock = Puppet::Concurrent::Lock.new
+
+  # Get the module that functions are mixed into corresponding to an
+  # environment
+  #
+  # @api private
+  def self.environment_module(env)
+    @environment_module_lock.synchronize do
+      AnonymousModuleAdapter.adapt(env).module
+    end
   end
 
   # Create a new Puppet DSL function.
@@ -82,7 +123,7 @@ module Puppet::Parser::Functions
   # extend the behavior and functionality of Puppet.
   #
   # See also [Docs: Custom
-  # Functions](https://docs.puppetlabs.com/guides/custom_functions.html)
+  # Functions](https://puppet.com/docs/puppet/5.5/lang_write_functions_in_puppet.html)
   #
   # @example Define a new Puppet DSL Function
   #     >> Puppet::Parser::Functions.newfunction(:double, :arity => 1,
@@ -171,7 +212,9 @@ 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
-          self.send(real_fname, args[0])
+          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
         else
           raise ArgumentError, _("custom functions must be called with a single array that contains the arguments. For example, function_example([1]) instead of function_example(1)")
         end
@@ -198,9 +241,9 @@ module Puppet::Parser::Functions
   def self.function(name, environment = Puppet.lookup(:current_environment))
     name = name.intern
 
-    func = nil
-    unless func = get_function(name, environment)
-      autoloader.load(name, environment)
+    func = get_function(name, environment)
+    unless func
+      autoloader.delegatee.load(name, environment)
       func = get_function(name, environment)
     end
 
@@ -212,7 +255,7 @@ module Puppet::Parser::Functions
   end
 
   def self.functiondocs(environment = Puppet.lookup(:current_environment))
-    autoloader.loadall
+    autoloader.delegatee.loadall(environment)
 
     ret = ""
 

data/lib/puppet/parser/parser_factory.rb

@@ -16,7 +16,7 @@ module Puppet::Parser
     # EvaluatingParser to the 3x way of parsing.
     #
     def self.evaluating_parser
-      unless defined?(Puppet::Pops::Parser::E4ParserAdapter)
+      unless defined?(Puppet::Parser::E4ParserAdapter)
         require 'puppet/parser/e4_parser_adapter'
         require 'puppet/pops/parser/code_merger'
       end

data/lib/puppet/parser/relationship.rb

@@ -36,7 +36,8 @@ class Puppet::Parser::Relationship
     target_ref = canonical_ref(target)
     rel_param = param_name
 
-    unless source_resource = catalog.resource(*source_ref)
+    source_resource = catalog.resource(*source_ref)
+    unless source_resource
       raise ArgumentError, _("Could not find resource '%{source}' for relationship on '%{target}'") % { source: source.to_s, target: target.to_s }
     end
     unless catalog.resource(*target_ref)

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

@@ -2,14 +2,21 @@
 class Puppet::Parser::Resource::Param
   include Puppet::Util
   include Puppet::Util::Errors
-  include Puppet::Util::MethodHelper
 
   attr_accessor :name, :value, :source, :add, :file, :line
 
-  def initialize(hash)
-    set_options(hash)
-    requiredopts(:name)
-    @name = @name.intern
+  def initialize(name: nil, value: nil, source: nil, line: nil, file: nil, add: nil)
+    @value = value
+    @source = source
+    @line = line
+    @file = file
+    @add = add
+
+    unless name
+      # This must happen after file and line are set to have them reported in the error
+      self.fail(Puppet::ResourceError, "'name' is a required option for #{self.class}")
+    end
+    @name = name.intern
   end
 
   def line_to_i
@@ -19,4 +26,10 @@ class Puppet::Parser::Resource::Param
   def to_s
     "#{self.name} => #{self.value}"
   end
+
+  def self.from_param(param, value)
+    new_param = param.dup
+    new_param.value = value
+    return new_param
+  end
 end

data/lib/puppet/parser/resource.rb

@@ -8,13 +8,12 @@ class Puppet::Parser::Resource < Puppet::Resource
   require 'puppet/util/tagging'
 
   include Puppet::Util
-  include Puppet::Util::MethodHelper
   include Puppet::Util::Errors
   include Puppet::Util::Logging
 
   attr_accessor :source, :scope, :collector_id
   attr_accessor :virtual, :override, :translated, :catalog, :evaluated
-  attr_accessor :file, :line
+  attr_accessor :file, :line, :kind
 
   attr_reader :exported, :parameters
 
@@ -57,7 +56,8 @@ class Puppet::Parser::Resource < Puppet::Resource
   def add_edge_to_stage
     return unless self.class?
 
-    unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
+    stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
+    unless stage
       raise ArgumentError, _("Could not find stage %{stage} specified by %{resource}") % { stage: self[:stage] || :main, resource: self }
     end
 
@@ -299,7 +299,8 @@ class Puppet::Parser::Resource < Puppet::Resource
 
         # evaluate mappings in that scope
         resource_type.arguments.keys.each do |name|
-          if expr = blueprint[:mappings][name]
+          expr = blueprint[:mappings][name]
+          if expr
             # Explicit mapping
             value = expr.safeevaluate(cns_scope)
           else
@@ -332,15 +333,16 @@ class Puppet::Parser::Resource < Puppet::Resource
   def add_scope_tags
     scope_resource = scope.resource
     unless scope_resource.nil? || scope_resource.equal?(self)
-      merge_tags(scope_resource)
+      merge_tags_from(scope_resource)
     end
   end
 
   def replace_sensitive_data
-    parameters.each_pair do |name, param|
+    parameters.keys.each do |name|
+      param = parameters[name]
       if param.value.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
         @sensitive_parameters << name
-        param.value = param.value.unwrap
+        parameters[name] = Puppet::Parser::Resource::Param.from_param(param, param.value.unwrap)
       end
     end
   end
@@ -349,7 +351,8 @@ class Puppet::Parser::Resource < Puppet::Resource
   def override_parameter(param)
     # This can happen if the override is defining a new parameter, rather
     # than replacing an existing one.
-    (set_parameter(param) and return) unless current = @parameters[param.name]
+    current = @parameters[param.name]
+    (set_parameter(param) and return) unless current
 
     # Parameter is already set - if overriding with a default - simply ignore the setting of the default value
     return if scope.is_default?(type, param.name, param.value)

data/lib/puppet/parser/scope.rb

@@ -1,4 +1,4 @@
-
+# frozen_string_literal: true
 # The scope class, which handles storing and retrieving variables and types and
 # such.
 require 'forwardable'
@@ -7,8 +7,6 @@ require 'puppet/parser'
 require 'puppet/parser/templatewrapper'
 require 'puppet/parser/resource'
 
-require 'puppet/util/methodhelper'
-
 # This class is part of the internal parser/evaluator/compiler functionality of Puppet.
 # It is passed between the various classes that participate in evaluation.
 # None of its methods are API except those that are clearly marked as such.
@@ -16,7 +14,6 @@ require 'puppet/util/methodhelper'
 # @api public
 class Puppet::Parser::Scope
   extend Forwardable
-  include Puppet::Util::MethodHelper
 
   # Variables that always exist with nil value even if not set
   BUILT_IN_VARS = ['module_name'.freeze, 'caller_module_name'.freeze].freeze
@@ -70,8 +67,8 @@ class Puppet::Parser::Scope
       false
     end
 
-    def add_entries_to(target = {})
-      @parent.add_entries_to(target) unless @parent.nil?
+    def add_entries_to(target = {}, include_undef = false)
+      @parent.add_entries_to(target, include_undef) unless @parent.nil?
       # do not include match data ($0-$n)
       target
     end
@@ -109,10 +106,10 @@ class Puppet::Parser::Scope
       @symbols.include?(name)
     end
 
-    def add_entries_to(target = {})
+    def add_entries_to(target = {}, include_undef = false)
       super
       @symbols.each do |k, v|
-        if v == :undef || v.nil?
+        if (v == :undef || v.nil?) && !include_undef
           target.delete(k)
         else
           target[ k ] = v
@@ -164,7 +161,7 @@ class Puppet::Parser::Scope
       raise Puppet::ParseError, _("Numerical variables cannot be deleted: Attempt to delete: $%{name}") % { name: name }
     end
 
-    def add_entries_to(target = {})
+    def add_entries_to(target = {}, include_undef = false)
       # do not include match data ($0-$n)
       super
     end
@@ -374,14 +371,15 @@ class Puppet::Parser::Scope
   end
 
   # Initialize our new scope.  Defaults to having no parent.
-  def initialize(compiler, options = EMPTY_HASH)
-    if compiler.is_a? Puppet::Parser::Compiler
+  def initialize(compiler, source: nil, resource: nil)
+    if compiler.is_a? Puppet::Parser::AbstractCompiler
       @compiler = compiler
     else
       raise Puppet::DevError, _("you must pass a compiler instance to a new scope object")
     end
 
-    set_options(options)
+    @source = source
+    @resource = resource
 
     extend_with_functions_module
 
@@ -654,8 +652,10 @@ class Puppet::Parser::Scope
   private :has_enclosing_scope?
 
   def qualified_scope(classname)
-    raise _("class %{classname} could not be found") % { classname: classname }     unless klass = find_hostclass(classname)
-    raise _("class %{classname} has not been evaluated") % { classname: classname } unless kscope = class_scope(klass)
+    klass = find_hostclass(classname)
+    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
@@ -663,8 +663,9 @@ class Puppet::Parser::Scope
   # Returns a Hash containing all variables and their values, optionally (and
   # by default) including the values defined in parent. Local values
   # shadow parent values. Ephemeral scopes for match results ($0 - $n) are not included.
+  # Optionally include the variables that are explicitly set to `undef`.
   #
-  def to_hash(recursive = true)
+  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?
@@ -675,7 +676,7 @@ class Puppet::Parser::Scope
     end
 
     # add all local scopes
-    @ephemeral.last.add_entries_to(target)
+    @ephemeral.last.add_entries_to(target, include_undef)
     target
   end
 
@@ -708,7 +709,8 @@ class Puppet::Parser::Scope
 
   # Merge all settings for the given _env_name_ into this scope
   # @param env_name [Symbol] the name of the environment
-  def merge_settings(env_name)
+  # @param set_in_this_scope [Boolean] if the settings variables should also be set in this instance of scope
+  def merge_settings(env_name, set_in_this_scope=true)
     settings = Puppet.settings
     table = effective_symtable(false)
     global_table = compiler.qualified_variables
@@ -717,7 +719,9 @@ class Puppet::Parser::Scope
       next if :name == name
       key = name.to_s
       value = transform_setting(settings.value_sym(name, env_name))
-      table[key] = value
+      if set_in_this_scope
+        table[key] = value
+      end
       all_local[key] = value
       # also write the fqn into global table for direct lookup
       global_table["settings::#{key}"] = value
@@ -768,8 +772,8 @@ class Puppet::Parser::Scope
       raise Puppet::ParseError, _("Attempt to assign to a reserved variable name: '%{name}'") % { name: name }
     end
 
-    # Check for server_facts reserved variable name if the trusted_sever_facts setting is true
-    if name == VARNAME_SERVER_FACTS && !options[:privileged] && Puppet[:trusted_server_facts]
+    # Check for server_facts reserved variable name
+    if name == VARNAME_SERVER_FACTS && !options[:privileged]
       raise Puppet::ParseError, _("Attempt to assign to a reserved variable name: '%{name}'") % { name: name }
     end
 
@@ -813,7 +817,7 @@ class Puppet::Parser::Scope
   end
 
   # Deeply freezes the given object. The object and its content must be of the types:
-  # Array, Hash, Numeric, Boolean, Symbol, Regexp, NilClass, or String. All other types raises an Error.
+  # Array, Hash, Numeric, Boolean, Regexp, NilClass, or String. All other types raises an Error.
   # (i.e. if they are assignable to Puppet::Pops::Types::Data type).
   #
   def deep_freeze(object)
@@ -868,7 +872,26 @@ class Puppet::Parser::Scope
 
   # Used mainly for logging
   def to_s
-    "Scope(#{@resource})"
+    # As this is used for logging, this should really not be done in this class at all...
+    return "Scope(#{@resource})" unless @resource.nil?
+
+    # For logging of function-scope - it is now showing the file and line.
+    detail = Puppet::Pops::PuppetStack.top_of_stack
+    return "Scope()" if detail.empty?
+
+    # shorten the path if possible
+    path = detail[0]
+    env_path = 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
+      path = "<module>" + path[module_path.length..-1]
+    elsif env_path && path && path.start_with?(env_path)
+      path = "<env>" + path[env_path.length..-1]
+    end
+    # Make the output appear as "Scope(path, line)"
+    "Scope(#{[path, detail[1]].join(', ')})" 
   end
 
   alias_method :inspect, :to_s
@@ -1045,7 +1068,10 @@ class Puppet::Parser::Scope
   def transform_and_assert_classnames(names)
     names.map do |name|
       case name
+      when NilClass
+        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

data/lib/puppet/parser/script_compiler.rb

@@ -0,0 +1,123 @@
+require 'puppet/loaders'
+require 'puppet/pops'
+
+# A Script "compiler" that does not support catalog operations
+#
+# The Script compiler is "one shot" - it does not support rechecking if underlying source has changed or
+# deal with possible errors in a cached environment.
+#
+class Puppet::Parser::ScriptCompiler
+  # Allows the ScriptCompiler to use the 3.x Scope class without being an actual "Compiler"
+  #
+  include Puppet::Parser::AbstractCompiler
+
+  # @api private
+  attr_reader :topscope
+
+  # @api private
+  attr_reader :qualified_variables
+
+  # Access to the configured loaders for 4x
+  # @return [Puppet::Pops::Loader::Loaders] the configured loaders
+  # @api private
+  attr_reader :loaders
+
+  # @api private
+  attr_reader :environment
+
+  # @api private
+  attr_reader :node_name
+
+  def with_context_overrides(description = '', &block)
+    Puppet.override( @context_overrides , description, &block)
+  end
+
+  # Evaluates the configured setup for a script + code in an environment with modules
+  #
+  def compile
+    Puppet[:strict_variables] = true
+    Puppet[:strict] = :error
+
+    # 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
+      result = Puppet::Util::Profiler.profile(_("Script: Evaluated main"), [:script, :evaluate_main]) { evaluate_main }
+      if block_given?
+        yield self
+      else
+        result
+      end
+    end
+
+  rescue Puppet::ParseErrorWithIssue => detail
+    detail.node = node_name
+    Puppet.log_exception(detail)
+    raise
+  rescue => detail
+    message = "#{detail} on node #{node_name}"
+    Puppet.log_exception(detail, message)
+    raise Puppet::Error, message, detail.backtrace
+  end
+
+  # Constructs the overrides for the context
+  def context_overrides()
+    {
+      :current_environment => environment,
+      :global_scope => @topscope,             # 4x placeholder for new global scope
+      :loaders  => @loaders,                  # 4x loaders
+      :rich_data => true,
+    }
+  end
+
+  # Create a script compiler for the given environment where errors are logged as coming
+  # from the given node_name
+  #
+  def initialize(environment, node_name, for_agent=false)
+    @environment = environment
+    @node_name = node_name
+
+    # Create the initial scope, it is needed early
+    @topscope = Puppet::Parser::Scope.new(self)
+
+    # Initialize loaders and Pcore
+    if for_agent
+      @loaders = Puppet::Pops::Loaders.new(environment, true)
+    else
+      @loaders = Puppet::Pops::Loaders.new(environment)
+    end
+
+    # Need to compute overrides here, and remember them, because we are about to
+    # Expensive entries in the context are bound lazily.
+    @context_overrides = context_overrides()
+
+    # Resolutions of fully qualified variable names
+    @qualified_variables = {}
+  end
+
+  # Having multiple named scopes hanging from top scope is not supported when scripting
+  # in the regular compiler this is used to create one named scope per class.
+  # When scripting, the "main class" is just a container of the top level code to evaluate
+  # and it is not evaluated as a class added to a catalog. Since classes are not supported
+  # there is no need to support the concept of "named scopes" as all variables are local
+  # or in the top scope itself (notably, the $settings:: namespace is initialized
+  # as just a set of variables in that namespace - there is no named scope for 'settings'
+  # when scripting.
+  # 
+  # Keeping this method here to get specific error as being unsure if there are functions/logic
+  # that will call this. The AbstractCompiler defines this method, but maybe it does not
+  # have to (TODO).
+  #
+  def newscope(parent, options = {})
+     raise _('having multiple named scopes is not supported when scripting')
+  end
+
+  private
+
+  # Find and evaluate the top level code.
+  def evaluate_main
+    @loaders.pre_load
+    program = @loaders.load_main_manifest
+    return program.nil? ? nil : Puppet::Pops::Parser::EvaluatingParser.singleton.evaluator.evaluate(program, @topscope)
+  end
+end

data/lib/puppet/parser/templatewrapper.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'puppet/parser/files'
 require 'erb'
 require 'puppet/file_system'
@@ -50,7 +51,7 @@ class Puppet::Parser::TemplateWrapper
   # @return [Array<String>] The tags defined in the current scope
   # @api public
   def tags
-    scope.tags
+    raise NotImplementedError, "Call 'all_tags' instead."
   end
 
   # @return [Array<String>] All the defined tags
@@ -61,7 +62,8 @@ class Puppet::Parser::TemplateWrapper
 
   # @api private
   def file=(filename)
-    unless @__file__ = Puppet::Parser::Files.find_template(filename, scope.compiler.environment)
+    @__file__ = Puppet::Parser::Files.find_template(filename, scope.compiler.environment)
+    unless @__file__
       raise Puppet::ParseError, _("Could not find template '%{filename}'") % { filename: filename }
     end
   end

data/lib/puppet/parser/type_loader.rb

@@ -66,11 +66,12 @@ class Puppet::Parser::TypeLoader
     files_to_try_for(fqname).each do |filename|
       begin
         imported_types = import_from_modules(filename)
-        if result = imported_types.find { |t| t.type == type and t.name == fqname }
+        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 => detail
+      rescue TypeLoaderError
         # I'm not convinced we should just drop these errors, but this
         # preserves existing behaviours.
       end
@@ -80,7 +81,7 @@ class Puppet::Parser::TypeLoader
   end
 
   def parse_file(file)
-    Puppet.debug("importing '#{file}' in environment #{environment}")
+    Puppet.debug { "importing '#{file}' in environment #{environment}" }
     parser = Puppet::Parser::ParserFactory.parser
     parser.file = file
     return parser.parse
@@ -110,20 +111,20 @@ class Puppet::Parser::TypeLoader
     # 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
+      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)
+    end
 
-      @loaded[file] = true
+    @loaded[file] = true
     end
 
     loaded_asts.collect do |ast|

data/lib/puppet/parser.rb

@@ -2,6 +2,7 @@
 module Puppet::Parser; end
 
 require 'puppet/parser/ast'
+require 'puppet/parser/abstract_compiler'
 require 'puppet/parser/compiler'
 require 'puppet/parser/compiler/catalog_validator'
 require 'puppet/resource/type_collection'