puppet 4.3.0 → 4.4.0

data/lib/puppet/parser/functions.rb

@@ -1,5 +1,6 @@
 require 'puppet/util/autoload'
 require 'puppet/parser/scope'
+require 'puppet/pops/adaptable'
 
 # A module for managing parser functions.  Each specified function
 # is added to a central module that then gets included into the Scope
@@ -17,12 +18,12 @@ module Puppet::Parser::Functions
   #
   # @api private
   def self.reset
-    @modules = {}
-
     # Runs a newfunction to create a function for each of the log levels
+    root_env = Puppet.lookup(:root_environment)
+    AnonymousModuleAdapter.clear(root_env)
     Puppet::Util::Log.levels.each do |level|
       newfunction(level,
-                  :environment => Puppet.lookup(:root_environment),
+                  :environment => root_env,
                   :doc => "Log a message on the server at level #{level.to_s}.") do |vals|
         send(level, vals.join(" "))
       end
@@ -36,26 +37,37 @@ module Puppet::Parser::Functions
     @autoloader ||= Puppet::Util::Autoload.new(self, "puppet/parser/functions")
   end
 
+  # An adapter that ties the anonymous module that acts as the container for all 3x functions to the environment
+  # where the functions are created. This adapter ensures that the life-cycle of those functions doesn't exceed
+  # the life-cycle of the environment.
+  #
+  # @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)
-    @modules[env.name] ||= Module.new do
-      @metadata = {}
+    AnonymousModuleAdapter.adapt(env) do |a|
+      a.module ||= Module.new do
+        @metadata = {}
 
-      def self.all_function_info
-        @metadata
-      end
+        def self.all_function_info
+          @metadata
+        end
 
-      def self.get_function_info(name)
-        @metadata[name]
-      end
+        def self.get_function_info(name)
+          @metadata[name]
+        end
 
-      def self.add_function_info(name, info)
-        @metadata[name] = info
+        def self.add_function_info(name, info)
+          @metadata[name] = info
+        end
       end
-    end
+    end.module
   end
 
   # Create a new Puppet DSL function.
@@ -70,7 +82,7 @@ module Puppet::Parser::Functions
   # extend the behavior and functionality of Puppet.
   #
   # See also [Docs: Custom
-  # Functions](http://docs.puppetlabs.com/guides/custom_functions.html)
+  # Functions](https://docs.puppetlabs.com/guides/custom_functions.html)
   #
   # @example Define a new Puppet DSL Function
   #     >> Puppet::Parser::Functions.newfunction(:double, :arity => 1,
@@ -113,7 +125,7 @@ module Puppet::Parser::Functions
   #   This string will be extracted by documentation generation tools.
   #
   # @option options [Integer] :arity (-1) the
-  #   [arity](http://en.wikipedia.org/wiki/Arity) of the function.  When
+  #   [arity](https://en.wikipedia.org/wiki/Arity) of the function.  When
   #   specified as a positive integer the function is expected to receive
   #   _exactly_ the specified number of arguments.  When specified as a
   #   negative number, the function is expected to receive _at least_ the

data/lib/puppet/parser/resource.rb

@@ -244,23 +244,25 @@ class Puppet::Parser::Resource < Puppet::Resource
       raise "Resource #{self} tries to consume #{cns} but no 'consumes' mapping exists for #{self.resource_type} and #{cns.type}" unless blueprint
 
       # setup scope that has, for each attr of cns, a binding to cns[attr]
-      cns_scope = scope.find_global_scope.newscope(:source => self, :resource => self)
-      cns.to_hash.each { |name, value| cns_scope[name.to_s] = value }
-
-      # evaluate mappings in that scope
-      resource_type.arguments.keys.each do |name|
-        if expr = blueprint[:mappings][name]
-          # Explicit mapping
-          value = expr.safeevaluate(cns_scope)
-        else
-          value = cns[name]
-        end
-        unless value.nil?
-          # @todo lutter 2015-07-01: this should be caught by the checker
-          # much earlier. We consume several capres, at least two of which
-          # want to map to the same parameter (PUP-5080)
-          raise "Attempt to reassign attribute '#{name}' in '#{self}' caused by multiple consumed mappings to the same attribute" if map[name]
-          map[name] = value
+      scope.with_global_scope do |global_scope|
+        cns_scope = global_scope.newscope(:source => self, :resource => self)
+        cns.to_hash.each { |name, value| cns_scope[name.to_s] = value }
+  
+        # evaluate mappings in that scope
+        resource_type.arguments.keys.each do |name|
+          if expr = blueprint[:mappings][name]
+            # Explicit mapping
+            value = expr.safeevaluate(cns_scope)
+          else
+            value = cns[name]
+          end
+          unless value.nil?
+            # @todo lutter 2015-07-01: this should be caught by the checker
+            # much earlier. We consume several capres, at least two of which
+            # want to map to the same parameter (PUP-5080)
+            raise "Attempt to reassign attribute '#{name}' in '#{self}' caused by multiple consumed mappings to the same attribute" if map[name]
+            map[name] = value
+          end
         end
       end
     end

data/lib/puppet/parser/scope.rb

@@ -174,13 +174,104 @@ class Puppet::Parser::Scope
 
   end
 
+  # @api private
+  class ParameterScope < Ephemeral
+    class Access
+      attr_accessor :value
+
+      def assigned?
+        instance_variable_defined?(:@value)
+      end
+    end
+
+    # A parameter default must be evaluated using a special scope. The scope that is given to this method must
+    # have a `ParameterScope` as its last ephemeral scope. This method will then push a `MatchScope` while the
+    # given `expression` is evaluated. The method will catch any throw of `:unevaluated_parameter` and produce
+    # an error saying that the evaluated parameter X tries to access the unevaluated parameter Y.
+    #
+    # @param name [String] the name of the currently evaluated parameter
+    # @param expression [Puppet::Parser::AST] the expression to evaluate
+    # @param scope [Puppet::Parser::Scope] a scope where a `ParameterScope` has been pushed
+    # @return [Object] the result of the evaluation
+    #
+    # @api private
+    def evaluate3x(name, expression, scope)
+      scope.with_guarded_scope do
+        bad = catch(:unevaluated_parameter) do
+          scope.new_match_scope(nil)
+          return as_read_only { expression.safeevaluate(scope) }
+        end
+        raise Puppet::Error, "default expression for $#{name} tries to illegally access not yet evaluated $#{bad}"
+      end
+    end
+
+    def evaluate(name, expression, scope, evaluator)
+      scope.with_guarded_scope do
+        bad = catch(:unevaluated_parameter) do
+          scope.new_match_scope(nil)
+          return as_read_only { evaluator.evaluate(expression, scope) }
+        end
+        raise Puppet::Error, "default expression for $#{name} tries to illegally access not yet evaluated $#{bad}"
+      end
+    end
+
+    def initialize(parent, param_names)
+      super(parent)
+      @params = {}
+      param_names.each { |name| @params[name] = Access.new }
+    end
+
+    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" if @read_only
+      @params[name] ||= Access.new
+      @params[name].value = value
+    end
+
+    def bound?(name)
+      @params.include?(name)
+    end
+
+    def include?(name)
+      @params.include?(name) || super
+    end
+
+    def is_local_scope?
+      true
+    end
+
+    def as_read_only
+      read_only = @read_only
+      @read_only = true
+      begin
+        yield
+      ensure
+        @read_only = read_only
+      end
+    end
+
+    def to_hash
+      Hash[@params.select {|_, access| access.assigned? }.map { |name, access| [name, access.value] }]
+    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')
   #       this include? is only useful because of checking against the boolean value false.
   #
   def include?(name)
-    ! self[name].nil?
+    catch(:undefined_variable) {
+      return ! self[name].nil?
+    }
+    false
   end
 
   # Returns true if the variable of the given name is set to any value (including nil)
@@ -412,14 +503,28 @@ class Puppet::Parser::Scope
     end
   end
 
+  UNDEFINED_VARIABLES_KIND = 'undefined_variables'.freeze
+
   def variable_not_found(name, reason=nil)
     # Built in variables always exist
     if BUILT_IN_VARS.include?(name)
       return nil
     end
     if Puppet[:strict_variables]
-      throw :undefined_variable
+      throw(:undefined_variable, reason)
     else
+      # Always warn, unfortunately without location (unless given in "reason") since
+      # a location is in most cases not given to scope (operator [], and lookupvar), and
+      # would be too expensive to always give.
+      # The ideal solution would be to always throw :undefined_variable, but that has to
+      # wait until a major release. It would then force all callers of scope to deal with
+      # the case of :undefined_variable. (Should check with include? first or catch the throw).
+      # Use deprecation warning to enable turning off these warnings, and to ensure each variable
+      # is only logged once.
+      unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
+        Puppet.warn_once(UNDEFINED_VARIABLES_KIND, "Variable: #{name}",
+          "Undefined variable '#{name}'; #{reason}" )
+      end
       nil
     end
   end
@@ -511,7 +616,8 @@ class Puppet::Parser::Scope
                  else
                    ""
                  end
-      warning "Could not look up qualified variable '#{class_name}::#{variable_name}'; #{reason}#{location}"
+      variable_not_found("#{class_name}::#{variable_name}", "#{reason}#{location}")
+      return nil
     end
     variable_not_found("#{class_name}::#{variable_name}", reason)
   end
@@ -738,10 +844,12 @@ class Puppet::Parser::Scope
 
   alias_method :inspect, :to_s
 
-  # remove ephemeral scope up to level
-  # TODO: Who uses :all ? Remove ??
+  # Pop ephemeral scopes up to level and return them
   #
+  # @deprecated use #pop_epehemeral
+  # @api private
   def unset_ephemeral_var(level=:all)
+    Puppet.deprecation_warning('Method Parser::Scope#unset_ephemeral_var() is deprecated')
     if level == :all
       @ephemeral = [ MatchScope.new(@symtable, nil)]
     else
@@ -749,6 +857,22 @@ class Puppet::Parser::Scope
     end
   end
 
+  # Pop ephemeral scopes up to level and return them
+  #
+  # @param level [Fixnum] a positive integer
+  # @return [Array] the removed ephemeral scopes
+  # @api private
+  def pop_ephemerals(level)
+    @ephemeral.pop(@ephemeral.size - level)
+  end
+
+  # Push ephemeral scopes onto the ephemeral scope stack
+  # @param ephemeral_scopes [Array]
+  # @api private
+  def push_ephemerals(ephemeral_scopes)
+    ephemeral_scopes.each { |ephemeral_scope| @ephemeral.push(ephemeral_scope) } unless ephemeral_scopes.nil?
+  end
+
   def ephemeral_level
     @ephemeral.size
   end
@@ -762,6 +886,53 @@ class Puppet::Parser::Scope
     end
   end
 
+  # Execute given block in global scope with no ephemerals present
+  #
+  # @yieldparam [Scope] global_scope the global and ephemeral less scope
+  # @return [Object] the return of the block
+  #
+  # @api private
+  def with_global_scope(&block)
+    find_global_scope.without_ephemeral_scopes(&block)
+  end
+
+  # Execute given block with all ephemeral popped from the ephemeral stack
+  #
+  # @api private
+  def without_ephemeral_scopes
+    save_ephemeral = @ephemeral
+    begin
+      @ephemeral = [ @symtable ]
+      yield(self)
+    ensure
+      @ephemeral = save_ephemeral
+    end
+  end
+
+  # Nests a parameter scope
+  # @api private
+  def with_parameter_scope(param_names)
+    param_scope = ParameterScope.new(@ephemeral.last, param_names)
+    with_guarded_scope do
+      @ephemeral.push(param_scope)
+      yield(param_scope)
+    end
+  end
+
+  # Execute given block and ensure that ephemeral level is restored
+  #
+  # @return [Object] the return of the block
+  #
+  # @api private
+  def with_guarded_scope
+    elevel = ephemeral_level
+    begin
+      yield
+    ensure
+      pop_ephemerals(elevel)
+    end
+  end
+
   # Sets match data in the most nested scope (which always is a MatchScope), it clobbers match data already set there
   #
   def set_match_data(match_data)

data/lib/puppet/plugins/data_providers/data_provider.rb

@@ -72,7 +72,6 @@ module Puppet::Plugins::DataProviders
     def data_key(key, lookup_invocation)
       nil
     end
-    protected :data_key
 
     # Should be reimplemented by subclass to provide the hash that corresponds to the given name.
     #
@@ -94,10 +93,10 @@ module Puppet::Plugins::DataProviders
     def validate_data(data, data_key)
       data
     end
-    protected :validate_data
   end
 
   class ModuleDataProvider
+    LOOKUP_OPTIONS = Puppet::Pops::Lookup::LOOKUP_OPTIONS
     include DataProvider
 
     # Retrieve the first segment of the qualified name _key_. This method will throw
@@ -106,27 +105,34 @@ module Puppet::Plugins::DataProviders
     # @param key [String] The key
     # @return [String] The first segment of the given key
     def data_key(key, lookup_invocation)
-      return lookup_invocation.module_name if key == 'lookup_options'
+      return lookup_invocation.module_name if key == LOOKUP_OPTIONS
       qual_index = key.index('::')
       throw :no_such_key if qual_index.nil?
       key[0..qual_index-1]
     end
-    protected :data_key
 
-    # Assert that all keys in the given _data_ are prefixed with the given _module_name_.
+    # Asserts that all keys in the given _data_ are prefixed with the given _module_name_. Remove entries
+    # that does not follow the convention and log a warning.
     #
     # @param data [Hash] The data hash
     # @param module_name [String] The name of the module where the data was found
-    # @return [Hash] The data_hash unaltered
+    # @return [Hash] The possibly pruned hash
+    # @api public
     def validate_data(data, module_name)
       module_prefix = "#{module_name}::"
-      data.each_key do |k|
-        unless k.is_a?(String) && (k == 'lookup_options' || k.start_with?(module_prefix))
-          raise Puppet::DataBinding::LookupError, "Module data for module '#{module_name}' must use keys qualified with the name of the module"
+      data.each_key.reduce(data) do |memo, k|
+        if k.is_a?(String)
+          next memo if k == LOOKUP_OPTIONS || k.start_with?(module_prefix)
+          msg = 'must use keys qualified with the name of the module'
+        else
+          msg = "must use keys of type String, got #{k.class.name}"
         end
+        memo = memo.clone if memo.equal?(data)
+        memo.delete(k)
+        Puppet.warning("Module data for module '#{module_name}' #{msg}")
+        memo
       end
     end
-    protected :validate_data
   end
 
   class EnvironmentDataProvider
@@ -135,7 +141,6 @@ module Puppet::Plugins::DataProviders
     def data_key(key, lookup_invocation)
       'environment'
     end
-    protected :data_key
   end
 
   # Class that keeps track of the original path (as it appears in the declaration, before interpolation),
@@ -175,11 +180,38 @@ module Puppet::Plugins::DataProviders
 
     # @param name [String] The name of the data provider
     # @param paths [Array<ResolvedPath>] Paths used by this provider
+    # @param parent_data_provider [DataProvider] The data provider that is the container of this data provider
     #
     # @api public
-    def initialize(name, paths)
+    def initialize(name, paths, parent_data_provider = nil)
       @name = name
       @paths = paths
+      @parent_data_provider = parent_data_provider
+    end
+
+    # Gets the data from the compiler, or initializes it by calling #initialize_data if not present in the compiler.
+    # This means, that data is initialized once per compilation, and the data is cached for as long as the compiler
+    # lives (which is for one catalog production). This makes it possible to return data that is tailored for the
+    # request.
+    #
+    # If data is obtained using the #initialize_data method it will be sent to the #validate_data for validation
+    #
+    # @param path [String] The path to the data to be loaded (passed to #initialize_data)
+    # @param data_key [String] The data key such as the name of a module or the constant 'environment'
+    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
+    # @param merge [String|Hash<String,Object>|nil] Merge strategy or hash with strategy and options
+    # @return [Hash] The data hash for the given _key_
+    #
+    # @api public
+    def load_data(path, data_key, lookup_invocation)
+      compiler = lookup_invocation.scope.compiler
+      adapter = Puppet::DataProviders::DataAdapter.get(compiler) || Puppet::DataProviders::DataAdapter.adapt(compiler)
+      adapter.data[path] ||= validate_data(initialize_data(path, lookup_invocation), data_key)
+    end
+    protected :data
+
+    def validate_data(data, module_name)
+      @parent_data_provider.nil? ? data : @parent_data_provider.validate_data(data, module_name)
     end
 
     # Performs a lookup by searching all given paths for the given _key_. A merge will be performed if
@@ -191,13 +223,14 @@ module Puppet::Plugins::DataProviders
     #
     # @api public
     def unchecked_lookup(key, lookup_invocation, merge)
+      module_name = @parent_data_provider.nil? ? nil : @parent_data_provider.data_key(key, lookup_invocation)
       lookup_invocation.with(:data_provider, self) do
         merge_strategy = Puppet::Pops::MergeStrategy.strategy(merge)
         lookup_invocation.with(:merge, merge_strategy) do
           merged_result = merge_strategy.merge_lookup(@paths) do |path|
             lookup_invocation.with(:path, path) do
               if path.exists?
-                hash = data(path.path, lookup_invocation)
+                hash = load_data(path.path, module_name, lookup_invocation)
                 value = hash[key]
                 if value || hash.include?(key)
                   lookup_invocation.report_found(key, post_process(value, lookup_invocation))
@@ -226,10 +259,11 @@ module Puppet::Plugins::DataProviders
     #
     # @param name [String] the name of the created provider (for logging and debugging)
     # @param paths [Array<String>] array of resolved paths
+    # @param parent_data_provider [DataProvider] The data provider that is the container of this data provider
     # @return [DataProvider] The created data provider
     #
     # @api public
-    def create(name, paths)
+    def create(name, paths, parent_data_provider)
       raise NotImplementedError, "Subclass of PathBasedDataProviderFactory must implement 'create' method"
     end
 
@@ -249,6 +283,14 @@ module Puppet::Plugins::DataProviders
     def resolve_paths(datadir, declared_paths, paths, lookup_invocation)
       []
     end
+
+    # Returns the data provider factory version.
+    #
+    # return [Integer] the version of this data provider factory
+    # @api public
+    def version
+      2
+    end
   end
 
   # Factory for creating file based data providers. This is an extension of the path based

data/lib/puppet/pops/adaptable.rb

@@ -15,7 +15,8 @@
 #   be exploited as the implementation of _being adaptable_ may change in the future.
 # @api private
 #
-module Puppet::Pops::Adaptable
+module Puppet::Pops
+module Adaptable
   # Base class for an Adapter.
   #
   # A typical adapter just defines some accessors.
@@ -199,3 +200,5 @@ module Puppet::Pops::Adaptable
     end
   end
 end
+end
+

data/lib/puppet/pops/adapters.rb

@@ -1,11 +1,12 @@
 # The Adapters module contains adapters for Documentation, Origin, SourcePosition, and Loader.
 #
-module Puppet::Pops::Adapters
+module Puppet::Pops
+module Adapters
   # A documentation adapter adapts an object with a documentation string.
   # (The intended use is for a source text parser to extract documentation and store this
   # in DocumentationAdapter instances).
   #
-  class DocumentationAdapter < Puppet::Pops::Adaptable::Adapter
+  class DocumentationAdapter < Adaptable::Adapter
     # @return [String] The documentation associated with an object
     attr_accessor :documentation
   end
@@ -19,10 +20,11 @@ module Puppet::Pops::Adapters
   # @note It is relatively expensive to compute line and position on line - it is not something that
   #   should be done for every token or model object.
   #
-  # @see Puppet::Pops::Utils#find_adapter, Puppet::Pops::Utils#find_closest_positioned
+  # @see Utils#find_adapter, Utils#find_closest_positioned
   #
-  class SourcePosAdapter < Puppet::Pops::Adaptable::Adapter
+  class SourcePosAdapter < Adaptable::Adapter
     attr_accessor :locator
+    attr_reader :adapted
 
     def self.create_adapter(o)
       new(o)
@@ -44,10 +46,10 @@ module Puppet::Pops::Adapters
         raise ArgumentError, "InternalError: SourcePosAdapter for something that has no locator among parents"
       end
       case
-      when o.is_a?(Puppet::Pops::Model::Program)
+      when o.is_a?(Model::Program)
         return o.locator
       # TODO_HEREDOC use case of SubLocator instead
-      when o.is_a?(Puppet::Pops::Model::SubLocatedExpression) && !(found_locator = o.locator).nil?
+      when o.is_a?(Model::SubLocatedExpression) && !(found_locator = o.locator).nil?
         return found_locator
       when adapter = self.class.get(o)
         return adapter.locator
@@ -82,7 +84,7 @@ module Puppet::Pops::Adapters
 
     # Extracts the text represented by this source position (the string is obtained from the locator)
     def extract_text
-      locator.string.slice(offset, length)
+      locator.extract_text(offset, length)
     end
 
     def extract_tree_text
@@ -90,11 +92,12 @@ module Puppet::Pops::Adapters
       last = first + @adapted.length
       @adapted.eAllContents.each do |m|
         m_offset = m.offset
+        next if m_offset.nil?
         first = m_offset if m_offset < first
         m_last = m_offset + m.length
         last = m_last if m_last > last
       end
-      locator.string.slice(first, last-first)
+      locator.extract_text(first, last-first)
     end
 
     # Produces an URI with path?line=n&pos=n. If origin is unknown the URI is string:?line=n&pos=n
@@ -105,17 +108,82 @@ module Puppet::Pops::Adapters
     end
   end
 
-  # A LoaderAdapter adapts an object with a {Puppet::Pops::Loader}. This is used to make further loading from the
+  # A LoaderAdapter adapts an object with a {Loader}. This is used to make further loading from the
   # perspective of the adapted object take place in the perspective of this Loader.
   #
   # It is typically enough to adapt the root of a model as a search is made towards the root of the model
   # until a loader is found, but there is no harm in duplicating this information provided a contained
   # object is adapted with the correct loader.
   #
-  # @see Puppet::Pops::Utils#find_adapter
+  # @see Utils#find_adapter
   #
-  class LoaderAdapter < Puppet::Pops::Adaptable::Adapter
-    # @return [Puppet::Pops::Loader::Loader] the loader
+  class LoaderAdapter < Adaptable::Adapter
+    # @return [Loader::Loader] the loader
     attr_accessor :loader
+
+    # Finds the loader to use when loading originates from the source position of the given argument.
+    #
+    # @param instance [Model::PopsObject] The model object
+    # @param scope [Puppet::Parser::Scope] The scope to use
+    # @return [Loader,nil] the found loader or `nil` if it could not be found
+    #
+    def self.loader_for_model_object(model, scope)
+      # find the loader that loaded the code, or use the private_environment_loader (sees env + all modules)
+      adapter = Utils.find_adapter(model, self)
+      return adapter.loader unless adapter.nil?
+
+      if scope.nil?
+        loaders = Puppet.lookup(:loaders) { nil }
+        loaders.nil? ? nil : loaders.private_environment_loader
+      else
+        # Use source location to determine calling module, or use the private_environment_loader (sees env + all modules)
+        # This is necessary since not all .pp files are loaded by a Loader (see PUP-1833)
+        adapter = adapt_by_source(scope, model)
+        adapter.nil? ? scope.compiler.loaders.private_environment_loader : adapter.loader
+      end
+    end
+
+    # Attempts to find the module that `instance` originates from by looking at it's {SourcePosAdapter} and
+    # compare the `locator.file` found there with the module paths given in the environment found in the
+    # given `scope`. If the file is found to be relative to a path, then the first segment of the relative
+    # path is interpreted as the name of a module. The object that the {SourcePosAdapter} is adapted to
+    # will then be adapted to the private loader for that module and that adapter is returned.
+    #
+    # The method returns `nil` when no module could be found.
+    #
+    # @param scope
+    # @param instance
+    def self.adapt_by_source(scope, instance)
+      source_pos = Utils.find_adapter(instance, SourcePosAdapter)
+      unless source_pos.nil?
+        mod = find_module_for_file(scope.environment, source_pos.locator.file)
+        unless mod.nil?
+          adapter = LoaderAdapter.adapt(source_pos.adapted)
+          adapter.loader = scope.compiler.loaders.private_loader_for_module(mod.name)
+          return adapter
+        end
+      end
+      nil
+    end
+
+    def self.find_module_for_file(environment, file)
+      return nil if file.nil?
+      file_path = Pathname.new(file)
+      environment.modulepath.each do |path|
+        begin
+          relative_path = file_path.relative_path_from(Pathname.new(path)).to_s.split(File::SEPARATOR)
+        rescue ArgumentError
+          # file_path was not relative to the module_path. That's OK.
+          next
+        end
+        if relative_path.length > 1
+          mod = environment.module(relative_path[0])
+          return mod unless mod.nil?
+        end
+      end
+      nil
+    end
+    private_class_method :find_module_for_file
   end
 end
+end