puppet 4.0.0 → 4.5.0

data/lib/puppet/pops/lookup/invocation.rb

@@ -0,0 +1,119 @@
+module Puppet::Pops::Lookup
+  class Invocation
+    attr_reader :scope, :override_values, :default_values, :explainer
+    attr_accessor :module_name, :top_key
+
+    # Creates a context object for a lookup invocation. The object contains the current scope, overrides, and default
+    # values and may optionally contain an {ExplanationAcceptor} instance that will receive book-keeping information
+    # about the progress of the lookup.
+    #
+    # If the _explain_ argument is a boolean, then _false_ means that no explanation is needed and _true_ means that
+    # the default explanation acceptor should be used. The _explain_ argument may also be an instance of the
+    # `ExplanationAcceptor` class.
+    #
+    # @param scope [Puppet::Parser::Scope] The scope to use for the lookup
+    # @param override_values [Hash<String,Object>|nil] A map to use as override. Values found here are returned immediately (no merge)
+    # @param default_values [Hash<String,Object>] A map to use as the last resort (but before default)
+    # @param explainer [boolean,Explanainer] An boolean true to use the default explanation acceptor or an explainer instance that will receive information about the lookup
+    def initialize(scope, override_values = {}, default_values = {}, explainer = nil)
+      @name_stack = []
+      @scope = scope
+      @override_values = override_values
+      @default_values = default_values
+      unless explainer.is_a?(Explainer)
+        explainer = explainer == true ? Explainer.new : nil
+      end
+      @explainer = explainer
+    end
+
+    def check(name)
+      if @name_stack.include?(name)
+        raise Puppet::DataBinding::RecursiveLookupError, "Recursive lookup detected in [#{@name_stack.join(', ')}]"
+      end
+      return unless block_given?
+
+      @name_stack.push(name)
+      begin
+        yield
+      rescue Puppet::DataBinding::LookupError
+        raise
+      rescue Puppet::Error => detail
+        raise Puppet::DataBinding::LookupError.new(detail.message, detail)
+      ensure
+        @name_stack.pop
+      end
+    end
+
+    # The qualifier_type can be one of:
+    # :global - qualifier is the data binding terminus name
+    # :data_provider - qualifier a DataProvider instance
+    # :path - qualifier is a ResolvedPath instance
+    # :merge - qualifier is a MergeStrategy instance
+    # :module - qualifier is the name of a module
+    # :interpolation - qualifier is the unresolved interpolation expression
+    # :meta - qualifier is the module name
+    # :data - qualifier is the key
+    #
+    # @param qualifier [Object] A branch, a provider, or a path
+    def with(qualifier_type, qualifier)
+      if @explainer.nil?
+        yield
+      else
+        @explainer.push(qualifier_type, qualifier)
+        begin
+          yield
+        ensure
+          @explainer.pop
+        end
+      end
+    end
+
+    def only_explain_options?
+      @explainer.nil? ? false : @explainer.only_explain_options?
+    end
+
+    def explain_options?
+      @explainer.nil? ? false : @explainer.explain_options?
+    end
+
+    def report_found_in_overrides(key, value)
+      @explainer.accept_found_in_overrides(key, value) unless @explainer.nil?
+      value
+    end
+
+    def report_found_in_defaults(key, value)
+      @explainer.accept_found_in_defaults(key, value) unless @explainer.nil?
+      value
+    end
+
+    def report_found(key, value)
+      @explainer.accept_found(key, value) unless @explainer.nil?
+      value
+    end
+
+    def report_merge_source(merge_source)
+      @explainer.accept_merge_source(merge_source) unless @explainer.nil?
+    end
+
+    # Report the result of a merge or fully resolved interpolated string
+    # @param value [Object] The result to report
+    # @return [Object] the given value
+    def report_result(value)
+      @explainer.accept_result(value) unless @explainer.nil?
+      value
+    end
+
+    def report_not_found(key)
+      @explainer.accept_not_found(key) unless @explainer.nil?
+    end
+
+    def report_path_not_found
+      @explainer.accept_path_not_found unless @explainer.nil?
+    end
+
+    def report_module_not_found
+      @explainer.accept_module_not_found unless @explainer.nil?
+    end
+  end
+end
+

data/lib/puppet/pops/lookup/sub_lookup.rb

@@ -0,0 +1,86 @@
+module Puppet::Pops
+module Lookup
+module SubLookup
+  # Split key into segments. A segment may be a quoted string (both single and double quotes can
+  # be used) and the segment separator is the '.' character. Whitespace will be trimmed off on
+  # both sides of each segment. Whitespace within quotes are not trimmed.
+  #
+  # If the key cannot be parsed, this method will yield a string describing the problem to a one
+  # parameter block. The block must return an exception instance.
+  #
+  # @param key [String] the string to split
+  # @return Array<String> the array of segments
+  # @yieldparam problem [String] the problem, i.e. 'Syntax error'
+  # @yieldreturn [Exception] the exception to raise
+  #
+  # @api public
+  def split_key(key)
+    segments = key.split(/(\s*"[^"]+"\s*|\s*'[^']+'\s*|[^'".]+)/)
+    if segments.empty?
+      # Only happens if the original key was an empty string
+      ''
+    elsif segments.shift == ''
+      count = segments.size
+      raise yield('Syntax error') unless count > 0
+
+      segments.keep_if { |seg| seg != '.' }
+      raise yield('Syntax error') unless segments.size * 2 == count + 1
+      segments.map! do |segment|
+        segment.strip!
+        segment.start_with?('"') || segment.start_with?("'") ? segment[1..-2] : segment
+      end
+    else
+      raise yield('Syntax error')
+    end
+  end
+
+  # Perform a sub-lookup using the given _segments_ to access the given _value_. Each segment must be a string. A string
+  # consisting entirely of digits will be treated as an indexed lookup which means that the value that it is applied to
+  # must be an array. Other types of segments will expect that the given value is something other than a String that
+  # implements the '#[]' method.
+  #
+  # @param key [String] the original key (only used for error messages)
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @param segments [Array<String>] the segments to use for lookup
+  # @param value [Object] the value to access using the segments
+  # @return [Object] the value obtained when accessing the value
+  #
+  # @api public
+  def sub_lookup(key, lookup_invocation, segments, value)
+    lookup_invocation.with(:sub_lookup, segments) do
+      segments.each do |segment|
+        lookup_invocation.with(:segment, segment) do
+          if value.nil?
+            lookup_invocation.report_not_found(segment)
+            throw :no_such_key
+          end
+          if segment =~ /^[0-9]+$/
+            segment = segment.to_i
+            unless value.instance_of?(Array)
+              raise Puppet::DataBinding::LookupError,
+                "Data Provider type mismatch: Got #{value.class.name} when Array was expected to access value using '#{segment}' from key '#{key}'"
+            end
+            unless segment < value.size
+              lookup_invocation.report_not_found(segment)
+              throw :no_such_key
+            end
+          else
+            unless value.respond_to?(:'[]') && !(value.instance_of?(Array) || value.instance_of?(String))
+              raise Puppet::DataBinding::LookupError,
+                "Data Provider type mismatch: Got #{value.class.name} when a hash-like object was expected to access value using '#{segment}' from key '#{key}'"
+            end
+            unless value.include?(segment)
+              lookup_invocation.report_not_found(segment)
+              throw :no_such_key
+            end
+          end
+          value = value[segment]
+          lookup_invocation.report_found(segment, value)
+        end
+      end
+      value
+    end
+  end
+end
+end
+end

data/lib/puppet/pops/lookup.rb

@@ -1,52 +1,58 @@
 # This class is the backing implementation of the Puppet function 'lookup'.
 # See puppet/functions/lookup.rb for documentation.
 #
-class Puppet::Pops::Lookup
+module Puppet::Pops
+module Lookup
+  LOOKUP_OPTIONS = 'lookup_options'.freeze
+  GLOBAL = '__global__'.freeze
+
   # Performs a lookup in the configured scopes and optionally merges the default.
   #
   # This is a backing function and all parameters are assumed to have been type checked.
   # See puppet/functions/lookup.rb for full documentation and all parameter combinations.
   #
-  # @param scope [Puppet::Parser::Scope] The scope to use for the lookup
   # @param name [String|Array<String>] The name or names to lookup
-  # @param type [Puppet::Pops::Types::PAnyType|nil] The expected type of the found value
+  # @param type [Types::PAnyType|nil] The expected type of the found value
   # @param default_value [Object] The value to use as default when no value is found
   # @param has_default [Boolean] Set to _true_ if _default_value_ is included (_nil_ is a valid _default_value_)
-  # @param override [Hash<String,Object>|nil] A map to use as override. Values found here are returned immediately (no merge)
-  # @param default_values_hash [Hash<String,Object>] A map to use as the last resort (but before default)
-  # @param merge [String|Hash<String,Object>|nil] Merge strategy or hash with strategy and options
+  # @param merge [MergeStrategy,String,Hash<String,Object>,nil] Merge strategy or hash with strategy and options
+  # @param lookup_invocation [Invocation] Invocation data containing scope, overrides, and defaults
   # @return [Object] The found value
   #
-  def self.lookup(scope, name, value_type, default_value, has_default, override, default_values_hash, merge)
-    value_type = Puppet::Pops::Types::PDataType.new if value_type.nil?
+  def self.lookup(name, value_type, default_value, has_default, merge, lookup_invocation)
+    value_type = Types::PDataType::DEFAULT if value_type.nil?
     names = name.is_a?(Array) ? name : [name]
 
     # find first name that yields a non-nil result and wrap it in a two element array
     # with name and value.
-    not_found = Object.new
-    result_with_name = names.reduce([nil,not_found]) do |memo, key|
-      value = override.include?(key) ? assert_type('override', value_type, override[key]) : not_found
-      value = search_and_merge(key, scope, merge, not_found) if value.equal?(not_found)
-      break [key, assert_type('found', value_type, value)] unless value.equal?(not_found)
+    not_found = MergeStrategy::NOT_FOUND
+    override_values = lookup_invocation.override_values
+    result_with_name = names.reduce([nil, not_found]) do |memo, key|
+      value = override_values.include?(key) ? assert_type(["Value found for key '%s' in override hash", key], value_type, override_values[key]) : not_found
+      catch(:no_such_key) { value = search_and_merge(key, lookup_invocation, merge) } if value.equal?(not_found)
+      break [key, assert_type('Found value', value_type, value)] unless value.equal?(not_found)
       memo
     end
 
-    # Use the 'default_values_hash' map as a last resort if nothing is found
-    if result_with_name[1].equal?(not_found) && !default_values_hash.empty?
-      result_with_name = names.reduce(result_with_name) do |memo, key|
-        value = default_values_hash.include?(key) ? assert_type('default_values_hash', value_type, default_values_hash[key]) : not_found
-        memo = [ key, value ]
-        break memo unless value.equal?(not_found)
-        memo
+    # Use the 'default_values' hash as a last resort if nothing is found
+    if result_with_name[1].equal?(not_found)
+      default_values = lookup_invocation.default_values
+      unless default_values.empty?
+        result_with_name = names.reduce(result_with_name) do |memo, key|
+          value = default_values.include?(key) ? assert_type(["Value found for key '%s' in default values hash", key], value_type, default_values[key]) : not_found
+          memo = [key, value]
+          break memo unless value.equal?(not_found)
+          memo
+        end
       end
     end
 
     answer = result_with_name[1]
     if answer.equal?(not_found)
       if block_given?
-        answer = assert_type('default_block', value_type, yield(name))
+        answer = assert_type('Value returned from default block', value_type, yield(name))
       elsif has_default
-        answer = assert_type('default_value', value_type, default_value)
+        answer = assert_type('Default value', value_type, default_value)
       else
         fail_lookup(names)
       end
@@ -54,43 +60,20 @@ class Puppet::Pops::Lookup
     answer
   end
 
-  def self.search_and_merge(name, scope, merge, not_found)
-    in_global = lambda { lookup_with_databinding(name, scope, merge) }
-    in_env = lambda { Puppet::DataProviders.lookup_in_environment(name, scope, merge) }
-    in_module = lambda { Puppet::DataProviders.lookup_in_module(name, scope, merge) }
-
-    [in_global, in_env, in_module].reduce(not_found) do |memo, f|
-      found = false # can't trust catch return value since nil is valid
-      value = catch (:no_such_key) do
-        answer = f.call
-        found = true
-        answer
-      end
-      next memo unless found
-      break value if merge.nil? # value found and no merge
-      strategy = Puppet::Pops::MergeStrategy.strategy(merge)
-      memo.equal?(not_found) ? strategy.convert_value(value) : strategy.merge(memo, value)
-    end
-  end
-  private_class_method :search_and_merge
-
-  def self.lookup_with_databinding(key, scope, merge)
-    begin
-      Puppet::DataBinding.indirection.find(key, { :environment => scope.environment.to_s, :variables => scope, :merge => merge })
-    rescue Puppet::DataBinding::LookupError => e
-      raise Puppet::Error, "Error from DataBinding '#{Puppet[:data_binding_terminus]}' while looking up '#{name}': #{e.message}", e
-    end
+  # @api private
+  def self.search_and_merge(name, lookup_invocation, merge)
+    return Puppet::DataProviders.lookup_adapter(lookup_invocation).lookup(name, lookup_invocation, merge)
   end
-  private_class_method :lookup_with_databinding
 
   def self.assert_type(subject, type, value)
-    Puppet::Pops::Types::TypeAsserter.assert_instance_of(subject, type, value)
+    Types::TypeAsserter.assert_instance_of(subject, type, value)
   end
   private_class_method :assert_type
 
   def self.fail_lookup(names)
-    name_part = names.size == 1 ? "the name '#{names[0]}'" : 'any of the names [' + names.map {|n| "'#{n}'"} .join(', ') + ']'
-    raise Puppet::Error, "Function lookup() did not find a value for #{name_part}"
+    name_part = names.size == 1 ? "the name '#{names[0]}'" : 'any of the names [' + names.map { |n| "'#{n}'" }.join(', ') + ']'
+    raise Puppet::DataBinding::LookupError, "Function lookup() did not find a value for #{name_part}"
   end
   private_class_method :fail_lookup
 end
+end

data/lib/puppet/pops/merge_strategy.rb

@@ -4,12 +4,11 @@ module Puppet::Pops
   # Merges to objects into one based on an implemented strategy.
   #
   class MergeStrategy
-    TypeAsserter = Puppet::Pops::Types::TypeAsserter
-    TypeParser = Puppet::Pops::Types::TypeParser
+    NOT_FOUND = Object.new.freeze
 
     # The type used for validation of the _merge_ argument
     def self.merge_t
-      @@merge_t ||=  TypeParser.new.parse("Variant[String[1],Runtime[ruby,'Symbol'],Hash[Variant[String[1],Runtime[ruby,'Symbol']],Scalar,1]]")
+      @@merge_t ||=  Types::TypeParser.new.parse("Variant[String[1],Runtime[ruby,'Symbol'],Hash[Variant[String[1],Runtime[ruby,'Symbol']],Scalar,1]]")
     end
     private_class_method :merge_t
 
@@ -20,12 +19,14 @@ module Puppet::Pops
 
     # Finds the merge strategy for the given _merge_, creates an instance of it and returns that instance.
     #
-    # @param merge [String|Symbol|Hash<String,Object>] The merge strategy. Can be a string or symbol denoting the key
+    # @param merge [MergeStrategy,String,Hash<String,Object>,nil] The merge strategy. Can be a string or symbol denoting the key
     #   identifier or a hash with options where the key 'strategy' denotes the key
     # @return [MergeStrategy] The matching merge strategy
     #
     def self.strategy(merge)
-      TypeAsserter.assert_instance_of("MergeStrategies.merge 'merge' parameter", merge_t, merge)
+      return merge if merge.is_a?(MergeStrategy)
+      merge = :first if merge.nil?
+      Types::TypeAsserter.assert_instance_of("MergeStrategy 'merge' parameter", merge_t, merge)
       if merge.is_a?(Hash)
         merge_strategy = merge['strategy']
         if merge_strategy.nil?
@@ -78,11 +79,11 @@ module Puppet::Pops
     # Create a new instance of this strategy configured with the given _options_
     # @param merge_options [Hash<String,Object>] Merge options
     def initialize(options)
-      assert_type('merge_options', options_t, options)
+      assert_type('The merge options', options_t, options)
       @options = options
     end
 
-    # Merges the elements of _e1_ and _e2_ accoring to the implemented strategy and options given when this
+    # Merges the elements of _e1_ and _e2_ according to the rules of this strategy and options given when this
     # instance was created
     #
     # @param e1 [Object] The first element
@@ -91,8 +92,35 @@ module Puppet::Pops
     #
     def merge(e1, e2)
       checked_merge(
-        assert_type('e1', value_t, e1),
-        assert_type('e2', value_t, e2))
+        assert_type('The first element of the merge', value_t, e1),
+        assert_type('The second element of the merge', value_t, e2))
+    end
+
+    # Merges the result of yielding the given _lookup_variants_ to a given block.
+    #
+    # @param lookup_variants [Array] The variants to pass as second argument to the given block
+    # @return [Object] the merged value.
+    # @yield [} ]
+    # @yieldparam variant [Object] each variant given in the _lookup_variants_ array.
+    # @yieldreturn [Object] the value to merge with other values
+    # @throws :no_such_key if the lookup was unsuccessful
+    #
+    def merge_lookup(lookup_variants)
+      result = lookup_variants.reduce(NOT_FOUND) do |memo, lookup_variant|
+        not_found = true
+        value = catch(:no_such_key) do
+          v = yield(lookup_variant)
+          not_found = false
+          v
+        end
+        if not_found
+          memo
+        else
+          memo.equal?(NOT_FOUND) ? convert_value(value) : merge(memo, value)
+        end
+      end
+      throw :no_such_key if result == NOT_FOUND
+      result
     end
 
     # Converts a single value to the type expeced when peforming a merge of two elements
@@ -102,23 +130,31 @@ module Puppet::Pops
       value
     end
 
-    protected
-
     def options
       @options
     end
 
+    def configuration
+      if @options.nil? || @options.empty?
+        self.class.key.to_s
+      else
+        @options.include?('strategy') ? @options : { 'strategy' => self.class.key.to_s }.merge(@options)
+      end
+    end
+
+    protected
+
     # Returns the type used to validate the options hash
     #
-    # @return [Puppet::Pops::Types::PStructType] the puppet type
+    # @return [Types::PStructType] the puppet type
     #
     def options_t
-      @options_t ||=TypeParser.new.parse("Struct[{strategy=>Optional[Pattern[#{self.class.key}]]}]")
+      @options_t ||=Types::TypeParser.new.parse("Struct[{strategy=>Optional[Pattern[#{self.class.key}]]}]")
     end
 
     # Returns the type used to validate the options hash
     #
-    # @return [Puppet::Pops::Types::PAnyType] the puppet type
+    # @return [Types::PAnyType] the puppet type
     #
     def value_t
       raise NotImplementedError, "Subclass must implement 'value_t'"
@@ -129,8 +165,37 @@ module Puppet::Pops
     end
 
     def assert_type(param, type, value)
-      TypeAsserter.assert_instance_of(param, type, value)
+      Types::TypeAsserter.assert_instance_of(param, type, value)
+    end
+  end
+
+  # Simple strategy that returns the first value found. It never merges any values.
+  #
+  class FirstFoundStrategy < MergeStrategy
+    def self.key
+      :first
+    end
+
+    # Returns the first value found
+    #
+    # @param lookup_variants [Array] The variants to pass as second argument to the given block
+    # @return [Object] the merged value
+    # @throws :no_such_key unless the lookup was successful
+    #
+    def merge_lookup(lookup_variants)
+      lookup_variants.each do |lookup_variant|
+        catch(:no_such_key) { return yield(lookup_variant) }
+      end
+      throw :no_such_key
+    end
+
+    protected
+
+    def value_t
+      @value_t ||= Types::PAnyType::DEFAULT
     end
+
+    MergeStrategy.add_strategy(self)
   end
 
   # Produces a new hash by merging hash e1 with hash e2 in such a way that the values of duplicate keys
@@ -152,7 +217,7 @@ module Puppet::Pops
     protected
 
     def value_t
-      @value_t ||= Puppet::Pops::Types::TypeParser.new.parse('Hash[String,Data]')
+      @value_t ||= Types::TypeParser.new.parse('Hash[String,Data]')
     end
 
     MergeStrategy.add_strategy(self)
@@ -184,7 +249,7 @@ module Puppet::Pops
     protected
 
     def value_t
-      @value_t ||= Puppet::Pops::Types::TypeParser.new.parse('Variant[Scalar,Array[Data]]')
+      @value_t ||= Types::TypeParser.new.parse('Variant[Scalar,Array[Data]]')
     end
 
     MergeStrategy.add_strategy(self)
@@ -214,7 +279,6 @@ module Puppet::Pops
   #   hash.deep_merge!({:x => [1,2]}, {:knockout_prefix => '--'})
   #   - 'knockout_prefix' Set to string value to signify prefix which deletes elements from existing element. Defaults is _undef_
   #   - 'sort_merged_arrays' Set to _true_ to sort all arrays that are merged together. Default is _false_
-  #   - 'unpack_arrays' Set to string value used as a deliminator to join all array values and then split them again. Default is _undef_
   #   - 'merge_hash_arrays' Set to _true_ to merge hashes within arrays. Default is _false_
   #
   # Selected Options Details:
@@ -230,14 +294,6 @@ module Puppet::Pops
   #    dest   = {:x => [1,2,3]}
   #    dest.ko_deep_merge!(source)
   #    Results: {:x => ""}
-  # :unpack_arrays => The purpose of this is to permit compound elements to be passed
-  #   in as strings and to be converted into discrete array elements
-  #   irsource = {:x => ['1,2,3', '4']}
-  #   dest   = {:x => ['5','6','7,8']}
-  #   dest.deep_merge!(source, {:unpack_arrays => ','})
-  #   Results: {:x => ['1','2','3','4','5','6','7','8']}
-  #   Why: If receiving data from an HTML form, this makes it easy for a checkbox
-  #    to pass multiple values from within a single HTML element
   #
   # :merge_hash_arrays => merge hashes within arrays
   #   source = {:x => [{:y => 1}]}
@@ -262,20 +318,19 @@ module Puppet::Pops
     # Returns a type that allows all deep_merge options except 'preserve_unmergeables' since we force
     # the setting of that option to false
     #
-    # @return [Puppet::Pops::Types::PAnyType] the puppet type used when validating the options hash
+    # @return [Types::PAnyType] the puppet type used when validating the options hash
     def options_t
-      @options_t ||= Puppet::Pops::Types::TypeParser.new.parse('Struct[{'\
+      @options_t ||= Types::TypeParser.new.parse('Struct[{'\
           "strategy=>Optional[Pattern[#{self.class.key}]],"\
           'knockout_prefix=>Optional[String],'\
           'merge_debug=>Optional[Boolean],'\
           'merge_hash_arrays=>Optional[Boolean],'\
           'sort_merge_arrays=>Optional[Boolean],'\
-          'unpack_arrays=>Optional[String]'\
           '}]')
     end
 
     def value_t
-      @value_t ||= Puppet::Pops::Types::TypeParser.new.parse('Variant[Array[Data],Hash[String,Data]]')
+      @value_t ||= Types::TypeParser.new.parse('Variant[Array[Data],Hash[String,Data]]')
     end
 
     MergeStrategy.add_strategy(self)

data/lib/puppet/pops/migration/migration_checker.rb

@@ -0,0 +1,54 @@
+# This class defines the private API of the MigrationChecker support.
+# @api private
+#
+class Puppet::Pops::Migration::MigrationChecker
+
+  def initialize()
+  end
+
+  # Produces a hash of available migrations; a map from a symbolic name in string form to a brief description.
+  # This version has no such supported migrations.
+  def available_migrations()
+    { }
+  end
+
+  # For 3.8/4.0
+  def report_ambiguous_integer(o)
+    raise Puppet::DevError, "Unsupported migration method called"
+  end
+
+  # For 3.8/4.0
+  def report_ambiguous_float(o)
+    raise Puppet::DevError, "Unsupported migration method called"
+  end
+
+  # For 3.8/4.0
+  def report_empty_string_true(value, o)
+    raise Puppet::DevError, "Unsupported migration method called"
+  end
+
+  # For 3.8/4.0
+  def report_uc_bareword_type(value, o)
+    raise Puppet::DevError, "Unsupported migration method called"
+  end
+
+  # For 3.8/4.0
+  def report_equality_type_mismatch(left, right, o)
+    raise Puppet::DevError, "Unsupported migration method called"
+  end
+
+  # For 3.8/4.0
+  def report_option_type_mismatch(test_value, option_value, option_expr, matching_expr)
+    raise Puppet::DevError, "Unsupported migration method called"
+  end
+
+  # For 3.8/4.0
+  def report_in_expression(o)
+    raise Puppet::DevError, "Unsupported migration method called"
+  end
+
+  # For 3.8/4.0
+  def report_array_last_in_block(o)
+    raise Puppet::DevError, "Unsupported migration method called"
+  end
+end

data/lib/puppet/pops/model/ast_transformer.rb

@@ -47,8 +47,11 @@ class Puppet::Pops::Model::AstTransformer
       if source_pos
         pos[:line] = source_pos.line
         pos[:pos]  = source_pos.pos
+        pos[:file] = source_pos.locator.file
+      end
+      if nil_or_empty?(pos[:file]) && !nil_or_empty?(@source_file)
+        pos[:file] = @source_file
       end
-      pos[:file] = @source_file if @source_file
       hash = hash.merge(pos)
     end
     hash
@@ -122,4 +125,8 @@ class Puppet::Pops::Model::AstTransformer
   def is_nop?(o)
     o.nil? || o.is_a?(Model::Nop)
   end
+
+  def nil_or_empty?(x)
+    x.nil? || x == ''
+  end
 end