puppet 4.4.0 → 4.5.0

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

@@ -82,7 +82,7 @@ module Runtime3Support
       # Must convert :undef back to nil - this can happen when an undefined variable is used in a
       # parameter's default value expression - there nil must be :undef to work with the rest of 3x.
       # Now that the value comes back to 4x it is changed to nil.
-      return (x == :undef) ? nil : x
+      return :undef == x ? nil : x
     }
     # It is always ok to reference numeric variables even if they are not assigned. They are always undef
     # if not set by a match expression.
@@ -90,7 +90,7 @@ module Runtime3Support
     unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
       optionally_fail(Puppet::Pops::Issues::UNKNOWN_VARIABLE, o, {:name => name})
     end
-    nil # in case unknown variable is configured as a warning
+    nil # in case unknown variable is configured as a warning or ignore
   end
 
   # Returns true if the variable of the given name is set in the given most nested scope. True is returned even if
@@ -497,7 +497,17 @@ module Runtime3Support
         p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
       end
 
-      p[Issues::UNKNOWN_VARIABLE]             = Puppet[:strict_variables] ? :error : :warning
+      # if strict variables are on, an error is raised
+      # if strict variables are off, the Puppet[strict] defines what is done
+      #
+      if Puppet[:strict_variables]
+        p[Issues::UNKNOWN_VARIABLE] = :error
+      elsif Puppet[:strict] == :off
+        p[Issues::UNKNOWN_VARIABLE] = :ignore
+      else
+        Puppet[:strict_variables]
+        p[Issues::UNKNOWN_VARIABLE] = Puppet[:strict]
+      end
 
       # Store config issues, ignore or warning
       p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
@@ -510,7 +520,7 @@ module Runtime3Support
     def accept(diagnostic)
       super
       IssueReporter.assert_and_report(self, {
-        :message => "Evaluation Error:", 
+        :message => "Evaluation Error:",
         :emit_warnings => true,  # log warnings
         :exception_class => Puppet::PreformattedError
       })

data/lib/puppet/pops/functions/dispatcher.rb

@@ -49,7 +49,7 @@ class Puppet::Pops::Functions::Dispatcher
     add(Puppet::Pops::Functions::Dispatch.new(type, method_name, param_names, block_name, injections, weaving, last_captures))
   end
 
-  # Adds a dispatch directly to the set of dispathers.
+  # Adds a dispatch directly to the set of dispatchers.
   # @api private
   def add(a_dispatch)
     @dispatchers << a_dispatch

data/lib/puppet/pops/issues.rb

@@ -228,6 +228,10 @@ module Issues
     "No value for required key '#{key}' in assignment to variables from hash"
   end
 
+  MISSING_MULTI_ASSIGNMENT_VARIABLE = hard_issue :MISSING_MULTI_ASSIGNMENT_VARIABLE, :name do
+    "No value for required variable '$#{name}' in assignment to variables from class reference"
+  end
+
   APPENDS_DELETES_NO_LONGER_SUPPORTED = hard_issue :APPENDS_DELETES_NO_LONGER_SUPPORTED, :operator do
     "The operator '#{operator}' is no longer supported. See http://links.puppetlabs.com/remove-plus-equals"
   end
@@ -280,6 +284,14 @@ module Issues
     "Illegal name. The given name '#{name}' does not conform to the naming rule /^((::)?[a-z_]\w*)(::[a-z]\\w*)*$/"
   end
 
+  ILLEGAL_SINGLE_TYPE_MAPPING = hard_issue :ILLEGAL_TYPE_MAPPING, :expression do
+    "Illegal type mapping. Expected a Type on the left side, got #{label.a_an_uc(semantic)}"
+  end
+
+  ILLEGAL_REGEXP_TYPE_MAPPING = hard_issue :ILLEGAL_TYPE_MAPPING, :expression do
+    "Illegal type mapping. Expected a Tuple[Regexp,String] on the left side, got #{label.a_an_uc(semantic)}"
+  end
+
   ILLEGAL_PARAM_NAME = hard_issue :ILLEGAL_PARAM_NAME, :name do
     "Illegal parameter name. The given name '#{name}' does not conform to the naming rule /^[a-z_]\\w*$/"
   end
@@ -494,7 +506,7 @@ module Issues
   end
 
   UNKNOWN_RESOURCE_TYPE = issue :UNKNOWN_RESOURCE_TYPE, :type_name do
-    "Resource type not found: #{type_name.capitalize}"
+    "Resource type not found: #{type_name}"
   end
 
   ILLEGAL_RESOURCE_TYPE = hard_issue :ILLEGAL_RESOURCE_TYPE, :actual do
@@ -526,7 +538,7 @@ module Issues
   end
 
   UNKNOWN_RESOURCE = issue :UNKNOWN_RESOURCE, :type_name, :title do
-    "Resource not found: #{type_name.capitalize}['#{title}']"
+    "Resource not found: #{type_name}['#{title}']"
   end
 
   UNKNOWN_RESOURCE_PARAMETER = issue :UNKNOWN_RESOURCE_PARAMETER, :type_name, :title, :param_name do
@@ -594,6 +606,10 @@ module Issues
     "The parameter '#{param_name}' is declared more than once in the parameter list"
   end
 
+  DUPLICATE_KEY = issue :DUPLICATE_KEY, :key do
+    "The key '#{key}' is declared more than once"
+  end
+
   RESERVED_PARAMETER = hard_issue :RESERVED_PARAMETER, :container, :param_name do
     "The parameter $#{param_name} redefines a built in parameter in #{label.the(container)}"
   end

data/lib/puppet/pops/loader/base_loader.rb

@@ -38,6 +38,18 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
     end
   end
 
+  # @api public
+  #
+  def loaded_entry(typed_name, check_dependencies = false)
+    if @named_values.has_key?(typed_name)
+      @named_values[typed_name]
+    elsif parent
+      parent.loaded_entry(typed_name, check_dependencies)
+    else
+      nil
+    end
+  end
+
   # This method is final (subclasses should not override it)
   #
   # @api private
@@ -49,8 +61,24 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
   # @api private
   #
   def set_entry(typed_name, value, origin = nil)
-    if entry = @named_values[typed_name] then fail_redefine(entry); end
-    @named_values[typed_name] = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, value, origin)
+
+    # It is never ok to redefine in the very same loader unless redefining a 'not found'
+    if entry = @named_values[typed_name]
+      fail_redefine(entry) unless entry.value.nil?
+    end
+
+    # Check if new entry shadows existing entry and fail
+    # (unless special loader allows shadowing)
+    if typed_name.type == :type && !allow_shadowing?
+      entry = loaded_entry(typed_name)
+      if entry
+        fail_redefine(entry) unless entry.value.nil? #|| entry.value == value
+      end
+    end
+
+    @last_result = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, value, origin)
+    @last_name = typed_name
+    @named_values[typed_name] = @last_result
   end
 
   # @api private
@@ -69,25 +97,35 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
     @named_values[typed_name] = named_entry
   end
 
+  protected
+
+  def allow_shadowing?
+    false
+  end
+
   private
 
   def fail_redefine(entry)
-    origin_info = entry.origin ? " Originally set at #{origin_label(entry.origin)}." : "unknown location"
-    raise ArgumentError, "Attempt to redefine entity '#{entry.typed_name}' originally set at #{origin_info}"
+    origin_info = entry.origin ? "Originally set #{origin_label(entry.origin)}." : "Set at unknown location"
+    raise ArgumentError, "Attempt to redefine entity '#{entry.typed_name}'. #{origin_info}"
   end
 
   # TODO: Should not really be here?? - TODO: A Label provider ? semantics for the URI?
   #
   def origin_label(origin)
     if origin && origin.is_a?(URI)
-      origin.to_s
+      format_uri(origin)
     elsif origin.respond_to?(:uri)
-      origin.uri.to_s
+      format_uri(origin.uri)
     else
       origin
     end
   end
 
+  def format_uri(uri)
+    (uri.scheme == 'puppet' ? 'by ' : 'at ') + uri.to_s.sub(/^puppet:/,'')
+  end
+
   # loads in priority order:
   # 1. already loaded here
   # 2. load from parent
@@ -96,7 +134,10 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
   #
   def internal_load(typed_name)
     # avoid calling get_entry, by looking it up
-    @named_values[typed_name] || parent.load_typed(typed_name) || find(typed_name)
+    te = @named_values[typed_name]
+    te = parent.load_typed(typed_name) if te.nil? || te.value.nil?
+    te = find(typed_name) if te.nil? || te.value.nil?
+    te
   end
 
 end

data/lib/puppet/pops/loader/dependency_loader.rb

@@ -48,13 +48,38 @@ class Puppet::Pops::Loader::DependencyLoader < Puppet::Pops::Loader::BaseLoader
     end
   end
 
-  def to_s()
+  # @api public
+  #
+  def loaded_entry(typed_name, check_dependencies = false)
+    super || (check_dependencies ? loaded_entry_in_dependency(typed_name, check_dependencies) : nil)
+  end
+
+  def to_s
     "(DependencyLoader '#{@loader_name}' [" + @dependency_loaders.map {|loader| loader.to_s }.join(' ,') + "])"
   end
 
   private
 
-  def index()
+  def loaded_entry_in_dependency(typed_name, check_dependencies)
+    if typed_name.qualified?
+      if l = index[typed_name.name_parts[0]]
+        l.loaded_entry(typed_name)
+      else
+        # no module entered as dependency with name matching first segment of wanted name
+        nil
+      end
+    else
+      # a non name-spaced name, have to search since it can be anywhere.
+      # (Note: superclass caches the result in this loader as it would have to repeat this search for every
+      # lookup otherwise).
+      @dependency_loaders.reduce(nil) do |previous, loader|
+        break previous if !previous.nil?
+        loader.loaded_entry(typed_name, check_dependencies)
+      end
+    end
+  end
+
+  def index
     @index ||= @dependency_loaders.reduce({}) { |index, loader| index[loader.module_name] = loader; index }
   end
 end

data/lib/puppet/pops/loader/loader.rb

@@ -55,6 +55,18 @@ class Puppet::Pops::Loader::Loader
     raise NotImplementedError.new
   end
 
+  # Returns an already loaded entry if one exists, or nil. This does not trigger loading
+  # of the given type/name.
+  #
+  # @param typed_name [TypedName] - the type, name combination to lookup
+  # @param check_dependencies [Boolean] - if dependencies should be checked in additiona to here and parent
+  # @return [NamedEntry, nil] the entry containing the loaded value, or nil if not found
+  # @api public
+  #
+  def loaded_entry(typed_name, check_dependencies = false)
+    raise NotImplementedError.new(self.class)
+  end
+
   # Produces the value associated with the given name if defined **in this loader**, or nil if not defined.
   # This lookup does not trigger any loading, or search of the given name.
   # An implementor of this method may not search or look up in any other loader, and it may not

data/lib/puppet/pops/loader/predefined_loader.rb

@@ -0,0 +1,29 @@
+module Puppet::Pops::Loader
+
+# A PredefinedLoader is a loader that is manually populated with loaded elements
+# before being used. It never loads anything on its own.
+# When searching for a type, it must exist or an error is raised
+#
+class PredefinedLoader < BaseLoader
+  def find(typed_name)
+    if typed_name.type == :type
+      raise Puppet::Pops::Loaders::LoaderError, "Cannot load undefined type '#{typed_name.name.capitalize}'"
+    else
+      nil
+    end
+  end
+
+  def to_s()
+    "(PredefinedLoader '#{loader_name}')"
+  end
+
+  # Allows shadowing since this loader is used internally for things like function local types
+  # And they should win as there is otherwise a risk that the local types clash with built in types
+  # that were added after the function was written, or by resource types loaded by the 3x auto loader.
+  #
+  def allow_shadowing?
+    true
+  end
+end
+
+end

data/lib/puppet/pops/loader/runtime3_type_loader.rb

@@ -0,0 +1,57 @@
+module Puppet::Pops
+module Loader
+
+# Runtime3TypeLoader
+# ===
+# Loads a resource type using the 3.x type loader
+#
+# @api private
+class Runtime3TypeLoader < BaseLoader
+  def initialize(parent_loader, environment)
+    super(parent_loader, environment.name)
+    @environment = environment
+  end
+
+  def to_s()
+    "(Runtime3TypeLoader '#{loader_name()}')"
+  end
+
+  # Finds typed/named entity in this module
+  # @param typed_name [TypedName] the type/name to find
+  # @return [Loader::NamedEntry, nil found/created entry, or nil if not found
+  #
+  def find(typed_name)
+    return nil unless typed_name.type == :type
+
+    name = typed_name.name
+    value = @environment.known_resource_types.find_definition(name)
+    if value.nil?
+      # Look for Puppet::Type
+      value = Puppet::Type.type(name)
+      if value.nil?
+        # Cache the fact that it wasn't found
+        set_entry(typed_name, nil)
+        return nil
+      end
+    end
+
+    # Loaded types doesn't have the same life cycle as this loader, so we must start by
+    # checking if the type was created. If it was, an entry will already be stored in
+    # this loader. If not, then it was created before this loader was instantiated and
+    # we must therefore add it.
+    te = get_entry(typed_name)
+    te = set_entry(typed_name, Types::TypeFactory.resource(value.name.to_s)) if te.nil? || te.value.nil?
+    te
+  end
+
+  # Allows shadowing since this loader is populalted with all loaded resource types at time
+  # of loading. This loading will, for built in types override the aliases configured in the static
+  # loader.
+  #
+  def allow_shadowing?
+    true
+  end
+
+end
+end
+end

data/lib/puppet/pops/loader/static_loader.rb

@@ -1,12 +1,16 @@
   # Static Loader contains constants, basic data types and other types required for the system
   # to boot.
   #
-class Puppet::Pops::Loader::StaticLoader < Puppet::Pops::Loader::Loader
+module Puppet::Pops
+module Loader
+class StaticLoader < Loader
 
   attr_reader :loaded
   def initialize
     @loaded = {}
     create_logging_functions()
+    create_built_in_types()
+    create_resource_type_references()
   end
 
   def load_typed(typed_name)
@@ -29,14 +33,17 @@ class Puppet::Pops::Loader::StaticLoader < Puppet::Pops::Loader::Loader
   def to_s()
     "(StaticLoader)"
   end
-  private
 
-  def load_constant(typed_name)
+  def loaded_entry(typed_name, _)
     @loaded[typed_name]
   end
 
   private
 
+  def load_constant(typed_name)
+    @loaded[typed_name]
+  end
+
   # Creates a function for each of the specified log levels
   #
   def create_logging_functions()
@@ -70,10 +77,90 @@ class Puppet::Pops::Loader::StaticLoader < Puppet::Pops::Loader::Loader
         end
       end
 
-      typed_name = Puppet::Pops::Loader::Loader::TypedName.new(:function, level)
+      typed_name = TypedName.new(:function, level)
       # TODO:closure scope is fake (an empty hash) - waiting for new global scope to be available via lookup of :scopes
       func = fc.new({},self)
-      @loaded[ typed_name ] = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, func, __FILE__)
+      @loaded[ typed_name ] = NamedEntry.new(typed_name, func, __FILE__)
+    end
+  end
+
+  def create_built_in_types
+    origin_uri = URI("puppet:Puppet-Type-System/Static-Loader")
+    type_map = Puppet::Pops::Types::TypeParser.type_map
+    type_map.each do |name, type|
+      typed_name = TypedName.new(:type, name)
+      @loaded[ typed_name ] = NamedEntry.new(typed_name, type, origin_uri)#__FILE__)
     end
   end
+
+  def create_resource_type_references()
+    # These needs to be done quickly and we do not want to scan the file system for these
+    # We are also not interested in their definition only that they exist.
+    # These types are in all environments.
+    #
+    %w{
+      Auegas
+      Component
+      Computer
+      Cron
+      Exec
+      File
+      Filebucket
+      Group
+      Host
+      Interface
+      K5login
+      Macauthorization
+      Mailalias
+      Maillist
+      Mcx
+      Mount
+      Nagios_command
+      Nagios_contact
+      Nagios_contactgroup
+      Nagios_host
+      Nagios_hostdependency
+      Nagios_hostescalation
+      Nagios_hostgroup
+      Nagios_hostextinfo
+      Nagios_service
+      Nagios_servicedependency
+      Nagios_serviceescalation
+      Nagios_serviceextinfo
+      Nagios_servicegroup
+      Nagios_timeperiod
+      Notify
+      Package
+      Resources
+      Router
+      Schedule
+      Scheduled_task
+      Selboolean
+      Selmodule
+      Service
+      Ssh_authorized_key
+      Sshkey
+      Stage
+      Tidy
+      User
+      Vlan
+      Whit
+      Yumrepo
+      Zfs
+      Zone
+      Zpool
+    }.each { |name| create_resource_type_reference(name) }
+
+    if Puppet[:app_management]
+      create_resource_type_reference('Node')
+    end
+  end
+
+  def create_resource_type_reference(name)
+    typed_name = TypedName.new(:type, name.downcase)
+    type = Puppet::Pops::Types::TypeFactory.resource(name)
+    @loaded[ typed_name ] = NamedEntry.new(typed_name, type, __FILE__)
+  end
+end
+end
 end

data/lib/puppet/pops/loader/type_definition_instantiator.rb

@@ -42,14 +42,36 @@ class TypeDefinitionInstantiator
     # the loader is known - hence this mechanism
     private_loader = loader.private_loader
     Adapters::LoaderAdapter.adapt(type_definition).loader = private_loader
-
-    Types::PTypeAliasType.new(name, type_definition.type_expr)
+    create_type(type_definition, loader)
   end
 
   def self.create_from_model(type_definition, loader)
+    typed_name = Loader::TypedName.new(:type, type_definition.name.downcase)
+    type = create_type(type_definition, loader)
+    loader.set_entry(
+      typed_name,
+      type,
+      Adapters::SourcePosAdapter.adapt(type_definition).to_uri)
+    type
+  end
+
+  def self.create_type(type_definition, loader)
+    type_expr = type_definition.type_expr
     name = type_definition.name
-    [Loader::TypedName.new(:type, name.downcase), Types::PTypeAliasType.new(name, type_definition.type_expr)]
+    if object_definition?(type_expr)
+      # No need for an alias. The Object type itself will receive the name instead
+      i12n_hash_expr = type_expr.keys.empty? ? nil : type_expr.keys[0]
+      Types::PObjectType.new(name, i12n_hash_expr)
+    else
+      Types::PTypeAliasType.new(name, type_expr)
+    end
+  end
+  private_class_method :create_type
+
+  def self.object_definition?(te)
+    te.is_a?(Model::AccessExpression) && (left = te.left_expr).is_a?(Model::QualifiedReference) && left.cased_value == 'Object'
   end
+  private_class_method :object_definition?
 end
 end
 end

data/lib/puppet/pops/loaders.rb

@@ -6,10 +6,9 @@ class Loaders
   attr_reader :puppet_system_loader
   attr_reader :public_environment_loader
   attr_reader :private_environment_loader
+  attr_reader :implementation_registry
 
   def initialize(environment)
-    # The static loader can only be changed after a reboot
-    @@static_loader ||= Loader::StaticLoader.new()
 
     # Create the set of loaders
     # 1. Puppet, loads from the "running" puppet - i.e. bundled functions, types, extension points and extensions
@@ -26,28 +25,81 @@ class Loaders
     #
     @private_environment_loader = create_environment_loader(environment)
 
-    # 3. module loaders are set up from the create_environment_loader, they register themselves
+    # 3. The implementation registry maintains mappings between Puppet types and Runtime types for
+    #    the current environment
+    @implementation_registry = Types::ImplementationRegistry.new(@private_environment_loader)
+    Pcore.init(@puppet_system_loader, @implementation_registry)
+
+    # 4. module loaders are set up from the create_environment_loader, they register themselves
   end
 
   # Clears the cached static and puppet_system loaders (to enable testing)
   #
   def self.clear
     @@static_loader = nil
-    @puppet_system_loader = nil
   end
 
-  # Finds the `Loaders` instance by looking up the :loaders in the global Puppet context and then uses it to
-  # find the appropriate loader for the given `module_name`, or for the environment in case `module_name`
-  # is `nil` or empty.
+  # Calls {#loaders} to obtain the {{Loaders}} instance and then uses it to find the appropriate loader
+  # for the given `module_name`, or for the environment in case `module_name` is `nil` or empty.
   #
   # @param module_name [String,nil] the name of the module
   # @return [Loader::Loader] the found loader
   # @raise [Puppet::ParseError] if no loader can be found
   # @api private
   def self.find_loader(module_name)
+    loaders.find_loader(module_name)
+  end
+
+  def self.static_loader
+    # The static loader can only be changed after a reboot
+    @@static_loader ||= Loader::StaticLoader.new()
+  end
+
+  def self.implementation_registry
+    loaders = Puppet.lookup(:loaders) { nil }
+    loaders.nil? ? nil : loaders.implementation_registry
+  end
+
+  def register_implementations(*obj_classes)
+    loader = @private_environment_loader
+    types = obj_classes.map do |obj_class|
+      type = obj_class._ptype
+      typed_name = Loader::Loader::TypedName.new(:type, type.name.downcase)
+      entry = loader.loaded_entry(typed_name)
+      loader.set_entry(typed_name, type, obj_class._plocation) if entry.nil? || entry.value.nil?
+      type
+    end
+    # Resolve lazy so that all types can cross reference eachother
+    parser = Types::TypeParser.new
+    types.each { |type| type.resolve(parser, loader) }
+  end
+
+  # Register the given type with the Runtime3TypeLoader. The registration will not happen unless
+  # the type system has been initialized.
+  #
+  # @param name [String,Symbol] the name of the entity being set
+  # @param origin [URI] the origin or the source where the type is defined
+  # @api private
+  def self.register_runtime3_type(name, origin)
+    loaders = Puppet.lookup(:loaders) { nil }
+    unless loaders.nil?
+      name = name.to_s
+      caps_name = Types::TypeFormatter.singleton.capitalize_segments(name)
+      typed_name = Loader::Loader::TypedName.new(:type, name.downcase)
+      loaders.runtime3_type_loader.set_entry(typed_name, Types::PResourceType.new(caps_name), origin)
+    end
+    nil
+  end
+
+  # Finds the `Loaders` instance by looking up the :loaders in the global Puppet context
+  #
+  # @return [Loaders] the loaders instance
+  # @raise [Puppet::ParseError] if loader has been bound to the global context
+  # @api private
+  def self.loaders
     loaders = Puppet.lookup(:loaders) { nil }
     raise Puppet::ParseError, "Internal Error: Puppet Context ':loaders' missing" if loaders.nil?
-    loaders.find_loader(module_name)
+    loaders
   end
 
   # Finds the appropriate loader for the given `module_name`, or for the environment in case `module_name`
@@ -77,13 +129,17 @@ class Loaders
   end
 
   def static_loader
-    @@static_loader
+    self.class.static_loader
   end
 
   def puppet_system_loader
     @puppet_system_loader
   end
 
+  def runtime3_type_loader
+    @runtime3_type_loader
+  end
+
   def public_loader_for_module(module_name)
     md = @module_resolver[module_name] || (return nil)
     # Note, this loader is not resolved until there is interest in the visibility of entities from the
@@ -130,12 +186,16 @@ class Loaders
     module_name = nil
     loader_name = "environment:#{environment.name}"
     env_conf = Puppet.lookup(:environments).get_conf(environment.name)
+
+    # Create the 3.x resource type loader
+    @runtime3_type_loader = Loader::Runtime3TypeLoader.new(puppet_system_loader, environment)
+
     if env_conf.nil? || !env_conf.is_a?(Puppet::Settings::EnvironmentConf)
       # Not a real directory environment, cannot work as a module TODO: Drop when legacy env are dropped?
-      loader = Loader::SimpleEnvironmentLoader.new(puppet_system_loader, loader_name)
+      loader = Loader::SimpleEnvironmentLoader.new(@runtime3_type_loader, loader_name)
     else
       # View the environment as a module to allow loading from it - this module is always called 'environment'
-      loader = Loader::ModuleLoaders.module_loader_from(puppet_system_loader, self, 'environment', env_conf.path_to_env)
+      loader = Loader::ModuleLoaders.module_loader_from(@runtime3_type_loader, self, 'environment', env_conf.path_to_env)
     end
 
     # An environment has a module path even if it has a null loader
@@ -270,9 +330,19 @@ class Loaders
 
     def create_loader_with_only_dependencies_visible(from_module_data)
       if from_module_data.unmet_dependencies?
-        Puppet.warning("ModuleLoader: module '#{from_module_data.name}' has unresolved dependencies"+
-          " - it will only see those that are resolved."+
-          " Use 'puppet module list --tree' to see information about modules")
+        if Puppet[:strict] != :off
+          msg = "ModuleLoader: module '#{from_module_data.name}' has unresolved dependencies" \
+              " - it will only see those that are resolved." \
+              " Use 'puppet module list --tree' to see information about modules"
+          case Puppet[:strict]
+          when :error
+              raise LoaderError.new(msg)
+          when :warning
+            Puppet.warn_once(:unresolved_module_dependencies,
+                             "unresolved_dependencies_for_module_#{from_module_data.name}",
+                             msg)
+          end
+        end
       end
       dependency_loaders = from_module_data.dependency_names.collect { |name| @index[name].public_loader }
       Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, dependency_loaders)