puppet 5.0.0 → 6.0.0

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

@@ -0,0 +1,54 @@
+# The RubyLegacyFunctionInstantiator instantiates a Puppet::Functions::Function given the ruby source
+# that calls Puppet::Functions.create_function.
+#
+class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
+  # Produces an instance of the Function class with the given typed_name, or fails with an error if the
+  # given ruby source does not produce this instance when evaluated.
+  #
+  # @param loader [Puppet::Pops::Loader::Loader] The loader the function is associated with
+  # @param typed_name [Puppet::Pops::Loader::TypedName] the type / name of the function to load
+  # @param source_ref [URI, String] a reference to the source / origin of the ruby code to evaluate
+  # @param ruby_code_string [String] ruby code in a string
+  #
+  # @return [Puppet::Pops::Functions.Function] - an instantiated function with global scope closure associated with the given loader
+  #
+  def self.create(loader, typed_name, source_ref, ruby_code_string)
+    unless ruby_code_string.is_a?(String) && ruby_code_string =~ /Puppet\:\:Parser\:\:Functions.*newfunction/m
+      raise ArgumentError, _("The code loaded from %{source_ref} does not seem to be a Puppet 3x API function - no 'newfunction' call.") % { source_ref: source_ref }
+    end
+    # make the private loader available in a binding to allow it to be passed on
+    loader_for_function = loader.private_loader
+    here = get_binding(loader_for_function)
+
+    # This will to do the 3x loading and define the "function_<name>" and "real_function_<name>" methods
+    # in the anonymous module used to hold function definitions.
+    #
+    func_info = eval(ruby_code_string, here, source_ref, 1)
+
+    unless func_info.is_a?(Hash)
+      raise ArgumentError, _("The code loaded from %{source_ref} did not produce the expected 3x function info Hash when evaluated. Got '%{klass}'") % { source_ref: source_ref, klass: created.class }
+    end
+    unless func_info[:name] == "function_#{typed_name.name()}"
+      raise ArgumentError, _("The code loaded from %{source_ref} produced mis-matched name, expected 'function_%{type_name}', got %{created_name}") % { 
+        source_ref: source_ref, type_name: typed_name.name, created_name: func_info[:name] }
+    end
+
+    created = Puppet::Functions::Function3x.create_function(typed_name.name(), func_info, loader_for_function)
+
+    # create the function instance - it needs closure (scope), and loader (i.e. where it should start searching for things
+    # when calling functions etc.
+    # It should be bound to global scope
+
+    # Sets closure scope to nil, to let it be picked up at runtime from Puppet.lookup(:global_scope)
+    # If function definition used the loader from the binding to create a new loader, that loader wins
+    created.new(nil, loader_for_function)
+  end
+
+  # Produces a binding where the given loader is bound as a local variable (loader_injected_arg). This variable can be used in loaded
+  # ruby code - e.g. to call Puppet::Function.create_loaded_function(:name, loader,...)
+  #
+  def self.get_binding(loader_injected_arg)
+    binding
+  end
+  private_class_method :get_binding
+end

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

@@ -13,6 +13,11 @@ class Runtime3TypeLoader < BaseLoader
     @resource_3x_loader = env_path.nil? ? nil : ModuleLoaders.pcore_resource_type_loader_from(parent_loader, loaders, env_path)
   end
 
+  def discover(type, error_collector = nil, name_authority = Pcore::RUNTIME_NAME_AUTHORITY, &block)
+    # TODO: Use generated index of all known types (requires separate utility).
+    parent.discover(type, error_collector, name_authority, &block)
+  end
+
   def to_s()
     "(Runtime3TypeLoader '#{loader_name()}')"
   end
@@ -83,7 +88,7 @@ class Runtime3TypeLoader < BaseLoader
   end
   private :find_impl
 
-  # Allows shadowing since this loader is populalted with all loaded resource types at time
+  # Allows shadowing since this loader is populated with all loaded resource types at time
   # of loading. This loading will, for built in types override the aliases configured in the static
   # loader.
   #

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

@@ -6,57 +6,21 @@ module Loader
 class StaticLoader < Loader
 
   BUILTIN_TYPE_NAMES = %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
       Node
       Notify
       Package
       Resources
-      Router
       Schedule
-      Scheduled_task
-      Selboolean
-      Selmodule
       Service
-      Ssh_authorized_key
-      Sshkey
       Stage
       Tidy
       User
-      Vlan
       Whit
-      Yumrepo
-      Zfs
-      Zone
-      Zpool
     }.freeze
 
   BUILTIN_TYPE_NAMES_LC = Set.new(BUILTIN_TYPE_NAMES.map { |n| n.downcase }).freeze
@@ -64,7 +28,7 @@ class StaticLoader < Loader
   BUILTIN_ALIASES = {
     'Data' => 'Variant[ScalarData,Undef,Hash[String,Data],Array[Data]]',
     'RichDataKey' => 'Variant[String,Numeric]',
-    'RichData' => 'Variant[Scalar,SemVerRange,Binary,Sensitive,Type,TypeSet,Undef,Hash[RichDataKey,RichData],Array[RichData]]',
+    'RichData' => 'Variant[Scalar,SemVerRange,Binary,Sensitive,Type,TypeSet,URI,Object,Undef,Default,Hash[RichDataKey,RichData],Array[RichData]]',
 
     # Backward compatible aliases.
     'Puppet::LookupKey' => 'RichDataKey',
@@ -74,9 +38,16 @@ class StaticLoader < Loader
   attr_reader :loaded
   def initialize
     @loaded = {}
+    @runtime_3_initialized = false
     create_built_in_types
-    create_resource_type_references
-    register_aliases
+  end
+
+  def discover(type, error_collector = nil, name_authority = Pcore::RUNTIME_NAME_AUTHORITY)
+    # Static loader only contains runtime types
+    return EMPTY_ARRAY unless type == :type && name_authority == name_authority = Pcore::RUNTIME_NAME_AUTHORITY
+
+    typed_names = type == :type && name_authority == Pcore::RUNTIME_NAME_AUTHORITY ? @loaded.keys : EMPTY_ARRAY
+    block_given? ? typed_names.select { |tn| yield(tn) } : typed_names
   end
 
   def load_typed(typed_name)
@@ -108,6 +79,19 @@ class StaticLoader < Loader
     @loaded[typed_name]
   end
 
+  def runtime_3_init
+    unless @runtime_3_initialized
+      @runtime_3_initialized = true
+      create_resource_type_references
+    end
+    nil
+  end
+
+  def register_aliases
+    aliases = BUILTIN_ALIASES.map { |name, string| add_type(name, Types::PTypeAliasType.new(name, Types::TypeFactory.type_reference(string), nil)) }
+    aliases.each { |type| type.resolve(self) }
+  end
+
   private
 
   def load_constant(typed_name)
@@ -138,12 +122,6 @@ class StaticLoader < Loader
   def create_resource_type_reference(name)
     add_type(name, Types::TypeFactory.resource(name))
   end
-
-  def register_aliases
-    aliases = BUILTIN_ALIASES.map { |name, string| add_type(name, Types::PTypeAliasType.new(name, Types::TypeFactory.type_reference(string), nil)) }
-    parser = Types::TypeParser.singleton
-    aliases.each { |type| type.resolve(parser, self) }
-  end
 end
 end
 end

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

@@ -0,0 +1,97 @@
+# The TypeDefinitionInstantiator instantiates a type alias or a type definition
+#
+module Puppet::Pops
+module Loader
+class TaskInstantiator
+  def self.load_metadata(loader, metadata)
+    if metadata.nil?
+      EMPTY_HASH
+    else
+      json_text = loader.get_contents(metadata)
+      begin
+        Puppet::Util::Json.load(json_text).freeze || EMPTY_HASH
+      rescue Puppet::Util::Json::ParseError => ex
+        raise Puppet::ParseError.new(ex.message, metadata)
+      end
+    end
+  end
+
+  def self.validate_implementations(typed_name, directory, metadata, executables)
+    name = typed_name.name
+    basename = typed_name.name_parts[1] || 'init'
+    # If 'implementations' is defined, it needs to mention at least one
+    # implementation, and everything it mentions must exist.
+    if metadata.key?('implementations')
+      if metadata['implementations'].is_a?(Array)
+        metadata['implementations'].map do |impl|
+          path = executables.find { |real_impl| File.basename(real_impl) == impl['name'] }
+          if path
+            { "name" => impl['name'], "requirements" => impl.fetch('requirements', []), "path" => path }
+          else
+            raise ArgumentError, _("Task metadata for task %{name} specifies missing implementation %{implementation}") %
+              { name: name, implementation: impl['name'] }
+          end
+        end
+      else
+        # If 'implementations' is the wrong type, we just pass it through and
+        # let the task type definition reject it.
+        metadata['implementations']
+      end
+    # If implementations isn't defined, then we use executables matching the
+    # task name, and only one may exist.
+    else
+      implementations = executables.select { |impl| File.basename(impl, '.*') == basename }
+      if implementations.empty?
+        raise ArgumentError, _('No source besides task metadata was found in directory %{directory} for task %{name}') %
+          { name: name, directory: directory }
+      elsif implementations.length > 1
+        raise ArgumentError, _("Multiple executables were found in directory %{directory} for task %{name}; define 'implementations' in metadata to differentiate between them") %
+          { name: name, directory: implementations[0] }
+      end
+
+      [{ "name" => File.basename(implementations.first), "path" => implementations.first, "requirements" => [] }]
+    end
+  end
+
+  def self.create(loader, typed_name, source_refs)
+    name = typed_name.name
+    basename = typed_name.name_parts[1] || 'init'
+    dirname = File.dirname(source_refs[0])
+    metadata_files, executables = source_refs.partition { |source_ref| source_ref.end_with?('.json') }
+    metadata_file = metadata_files.find { |source_ref| File.basename(source_ref, '.json') == basename }
+
+    metadata = load_metadata(loader, metadata_file)
+
+    implementation_metadata = validate_implementations(typed_name, dirname, metadata, executables)
+
+    arguments = {
+      'name' => name,
+      'implementations' => implementation_metadata
+    }
+
+    begin
+      metadata.each_pair do |key, value|
+        if %w[parameters output].include?(key)
+          ps = {}
+          value.each_pair do |k, v|
+            pd = v.dup
+            t = v['type']
+            pd['type'] = t.nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(t)
+            ps[k] = pd
+          end
+          value = ps
+        end
+        arguments[key] = value unless arguments.key?(key)
+      end
+
+      Types::TypeFactory.task.from_hash(arguments)
+    rescue Types::TypeAssertionError => ex
+      # Not strictly a parser error but from the users perspective, the file content didn't parse properly. The
+      # ParserError also conveys file info (even though line is unknown)
+      msg = _('Failed to load metadata for task %{name}: %{reason}') % { name: name, reason: ex.message }
+      raise Puppet::ParseError.new(msg, metadata_file)
+    end
+  end
+end
+end
+end

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

@@ -73,7 +73,9 @@ class TypeDefinitionInstantiator
     case type_name
     when 'Object'
       # No need for an alias. The Object type itself will receive the name instead
-      type_expr = type_expr.keys.empty? ? nil : type_expr.keys[0] unless type_expr.is_a?(Hash)
+      unless type_expr.is_a?(Model::LiteralHash)
+        type_expr = type_expr.keys.empty? ? nil : type_expr.keys[0] unless type_expr.is_a?(Hash)
+      end
       Types::PObjectType.new(name, type_expr)
     when 'TypeSet'
       # No need for an alias. The Object type itself will receive the name instead
@@ -86,8 +88,13 @@ class TypeDefinitionInstantiator
 
   # @api private
   def self.named_definition(te)
+    return 'Object' if te.is_a?(Model::LiteralHash)
     te.is_a?(Model::AccessExpression) && (left = te.left_expr).is_a?(Model::QualifiedReference) ? left.cased_value : nil
   end
+
+  def several_paths?
+    false
+  end
 end
 end
 end

data/lib/puppet/pops/loaders.rb

@@ -13,9 +13,9 @@ class Loaders
 
   attr_reader :static_loader
   attr_reader :puppet_system_loader
+  attr_reader :puppet_cache_loader
   attr_reader :public_environment_loader
   attr_reader :private_environment_loader
-  attr_reader :implementation_registry
   attr_reader :environment
 
   def self.new(environment, for_agent = false)
@@ -44,29 +44,34 @@ class Loaders
     #
     @puppet_system_loader = create_puppet_system_loader()
 
-    # 2. Environment loader - i.e. what is bound across the environment, may change for each setup
+    # 2. Cache loader(optional) - i.e. what puppet stores on disk via pluginsync; gate behind the for_agent flag.
+    # 3. Environment loader - i.e. what is bound across the environment, may change for each setup
     #    TODO: loaders need to work when also running in an agent doing catalog application. There is no
     #    concept of environment the same way as when running as a master (except when doing apply).
     #    The creation mechanisms should probably differ between the two.
-    #
     @private_environment_loader = if for_agent
-      add_loader_by_name(Loader::SimpleEnvironmentLoader.new(@puppet_system_loader, 'agent environment'))
+      @puppet_cache_loader = create_puppet_cache_loader()
+      create_environment_loader(environment, @puppet_cache_loader)
     else
-      create_environment_loader(environment)
+      create_environment_loader(environment, @puppet_system_loader)
     end
 
-    # 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, for_agent)
+    Pcore.init_env(@private_environment_loader)
 
     # 4. module loaders are set up from the create_environment_loader, they register themselves
   end
 
+  # Called after loader has been added to Puppet Context as :loaders so that dynamic types can
+  # be pre-loaded with a fully configured loader system
+  def pre_load
+    @puppet_system_loader.load(:type, 'error')
+  end
+
   # Clears the cached static and puppet_system loaders (to enable testing)
   #
   def self.clear
     @@static_loader = nil
+    Puppet::Pops::Types::TypeFactory.clear
     Model.class_variable_set(:@@pcore_ast_initialized, false)
     Model.register_pcore_types
   end
@@ -82,9 +87,23 @@ class Loaders
     loaders.find_loader(module_name)
   end
 
+  def self.static_implementation_registry
+    if !class_variable_defined?(:@@static_implementation_registry) || @@static_implementation_registry.nil?
+      ir = Types::ImplementationRegistry.new
+      Types::TypeParser.type_map.values.each { |t| ir.register_implementation(t.simple_name, t.class.name) }
+      @@static_implementation_registry = ir
+    end
+    @@static_implementation_registry
+  end
+
   def self.static_loader
     # The static loader can only be changed after a reboot
-    @@static_loader ||= Loader::StaticLoader.new()
+    if !class_variable_defined?(:@@static_loader) || @@static_loader.nil?
+      @@static_loader = Loader::StaticLoader.new()
+      @@static_loader.register_aliases
+      Pcore.init(@@static_loader, static_implementation_registry)
+    end
+    @@static_loader
   end
 
   def self.implementation_registry
@@ -93,7 +112,7 @@ class Loaders
   end
 
   def register_implementations(obj_classes, name_authority)
-    self.class.register_implementations_with_loader(obj_classes, name_authority, loader = @private_environment_loader)
+    self.class.register_implementations_with_loader(obj_classes, name_authority, @private_environment_loader)
   end
 
   # Register implementations using the global static loader
@@ -110,8 +129,7 @@ class Loaders
       type
     end
     # Resolve lazy so that all types can cross reference each other
-    parser = Types::TypeParser.singleton
-    types.each { |type| type.resolve(parser, loader) }
+    types.each { |type| type.resolve(loader) }
   end
 
   # Register the given type with the Runtime3TypeLoader. The registration will not happen unless
@@ -153,7 +171,7 @@ class Loaders
   # @api private
   def self.loaders
     loaders = Puppet.lookup(:loaders) { nil }
-    raise Puppet::ParseError, "Internal Error: Puppet Context ':loaders' missing" if loaders.nil?
+    raise Puppet::ParseError, _("Internal Error: Puppet Context ':loaders' missing") if loaders.nil?
     loaders
   end
 
@@ -187,11 +205,18 @@ class Loaders
       # TODO : Later check if definition is private, and then add it to private_loader_for_module
       #
       loader = public_loader_for_module(module_name)
-      raise Puppet::ParseError, "Internal Error: did not find public loader for module: '#{module_name}'" if loader.nil?
+      if loader.nil?
+        raise Puppet::ParseError, _("Internal Error: did not find public loader for module: '%{module_name}'") % { module_name: module_name }
+      end
       loader
     end
   end
 
+  def implementation_registry
+    # Environment specific implementation registry
+    @implementation_registry ||= Types::ImplementationRegistry.new(self.class.static_implementation_registry)
+  end
+
   def static_loader
     self.class.static_loader
   end
@@ -226,17 +251,116 @@ class Loaders
 
   def add_loader_by_name(loader)
     name = loader.loader_name
-    raise Puppet::ParseError, "Internal Error: Attempt to redefine loader named '#{name}'" if @loaders_by_name.include?(name)
+    if @loaders_by_name.include?(name)
+      raise Puppet::ParseError, _("Internal Error: Attempt to redefine loader named '%{name}'") % { name: name }
+    end
     @loaders_by_name[name] = loader
   end
 
+  # Load the main manifest for the given environment
+  #
+  # There are two sources that can be used for the initial parse:
+  #
+  #   1. The value of `Puppet[:code]`: Puppet can take a string from
+  #     its settings and parse that as a manifest. This is used by various
+  #     Puppet applications to read in a manifest and pass it to the
+  #     environment as a side effect. This is attempted first.
+  #   2. The contents of the environment's +manifest+ attribute: Puppet will
+  #     try to load the environment manifest. The manifest must be a file.
+  #
+  # @return [Model::Program] The manifest parsed into a model object
+  def load_main_manifest
+    parser = Parser::EvaluatingParser.singleton
+    parsed_code = Puppet[:code]
+    program = if parsed_code != ""
+      parser.parse_string(parsed_code, 'unknown-source-location')
+    else
+      file = @environment.manifest
+
+      # if the manifest file is a reference to a directory, parse and combine
+      # all .pp files in that directory
+      if file == Puppet::Node::Environment::NO_MANIFEST
+        nil
+      elsif File.directory?(file)
+        raise Puppet::Error, "manifest of environment '#{@environment.name}' appoints directory '#{file}'. It must be a file"
+      elsif File.exists?(file)
+        parser.parse_file(file)
+      else
+        raise Puppet::Error, "manifest of environment '#{@environment.name}' appoints '#{file}'. It does not exist"
+      end
+    end
+    instantiate_definitions(program, public_environment_loader) unless program.nil?
+    program
+  rescue Puppet::ParseErrorWithIssue => detail
+    detail.environment = @environment.name
+    raise
+  rescue => detail
+    msg = _('Could not parse for environment %{env}: %{detail}') % { env: @environment, detail: detail }
+    error = Puppet::Error.new(msg)
+    error.set_backtrace(detail.backtrace)
+    raise error
+  end
+
+  # Add 4.x definitions found in the given program to the given loader.
+  def instantiate_definitions(program, loader)
+    program.definitions.each { |d| instantiate_definition(d, loader) }
+    nil
+  end
+
+  # Add given 4.x definition to the given loader.
+  def instantiate_definition(definition, loader)
+    case definition
+    when Model::PlanDefinition
+      instantiate_PlanDefinition(definition, loader)
+    when Model::FunctionDefinition
+      instantiate_FunctionDefinition(definition, loader)
+    when Model::TypeAlias
+      instantiate_TypeAlias(definition, loader)
+    when Model::TypeMapping
+      instantiate_TypeMapping(definition, loader)
+    else
+      raise Puppet::ParseError, "Internal Error: Unknown type of definition - got '#{definition.class}'"
+    end
+  end
+
   private
 
+  def instantiate_PlanDefinition(plan_definition, loader)
+    typed_name, f = Loader::PuppetPlanInstantiator.create_from_model(plan_definition, loader)
+    loader.set_entry(typed_name, f, plan_definition.locator.to_uri(plan_definition))
+    nil
+  end
+
+  def instantiate_FunctionDefinition(function_definition, loader)
+    # Instantiate Function, and store it in the loader
+    typed_name, f = Loader::PuppetFunctionInstantiator.create_from_model(function_definition, loader)
+    loader.set_entry(typed_name, f, function_definition.locator.to_uri(function_definition))
+    nil
+  end
+
+  def instantiate_TypeAlias(type_alias, loader)
+    # Bind the type alias to the loader using the alias
+    Puppet::Pops::Loader::TypeDefinitionInstantiator.create_from_model(type_alias, loader)
+    nil
+  end
+
+  def instantiate_TypeMapping(type_mapping, loader)
+    tf = Types::TypeParser.singleton
+    lhs = tf.interpret(type_mapping.type_expr, loader)
+    rhs = tf.interpret_any(type_mapping.mapping_expr, loader)
+    implementation_registry.register_type_mapping(lhs, rhs)
+    nil
+  end
+
   def create_puppet_system_loader()
     Loader::ModuleLoaders.system_loader_from(static_loader, self)
   end
 
-  def create_environment_loader(environment)
+  def create_puppet_cache_loader()
+    Loader::ModuleLoaders.cached_loader_from(puppet_system_loader, self)
+  end
+
+  def create_environment_loader(environment, parent_loader)
     # This defines where to start parsing/evaluating - the "initial import" (to use 3x terminology)
     # Is either a reference to a single .pp file, or a directory of manifests. If the environment becomes
     # a module and can hold functions, types etc. then these are available across all other modules without
@@ -256,15 +380,20 @@ class Loaders
     env_conf = Puppet.lookup(:environments).get_conf(environment.name)
     env_path = env_conf.nil? || !env_conf.is_a?(Puppet::Settings::EnvironmentConf) ? nil : env_conf.path_to_env
 
-    # Create the 3.x resource type loader
-    @runtime3_type_loader = add_loader_by_name(Loader::Runtime3TypeLoader.new(puppet_system_loader, self, environment, env_conf.nil? ? nil : env_path))
-
-    if env_path.nil?
-      # Not a real directory environment, cannot work as a module TODO: Drop when legacy env are dropped?
-      loader = add_loader_by_name(Loader::SimpleEnvironmentLoader.new(@runtime3_type_loader, Loader::ENVIRONMENT))
+    if Puppet[:tasks]
+      loader = Loader::ModuleLoaders.environment_loader_from(parent_loader, self, env_path)
     else
-      # View the environment as a module to allow loading from it - this module is always called 'environment'
-      loader = Loader::ModuleLoaders.environment_loader_from(@runtime3_type_loader, self, env_path)
+      # Create the 3.x resource type loader
+      static_loader.runtime_3_init
+      @runtime3_type_loader = add_loader_by_name(Loader::Runtime3TypeLoader.new(parent_loader, self, environment, env_conf.nil? ? nil : env_path))
+
+      if env_path.nil?
+        # Not a real directory environment, cannot work as a module TODO: Drop when legacy env are dropped?
+        loader = add_loader_by_name(Loader::SimpleEnvironmentLoader.new(@runtime3_type_loader, Loader::ENVIRONMENT))
+      else
+        # View the environment as a module to allow loading from it - this module is always called 'environment'
+        loader = Loader::ModuleLoaders.environment_loader_from(@runtime3_type_loader, self, env_path)
+      end
     end
 
     # An environment has a module path even if it has a null loader
@@ -381,7 +510,7 @@ class Loaders
       else
         module_data.private_loader =
           if module_data.restrict_to_dependencies?
-            create_loader_with_only_dependencies_visible(module_data)
+            create_loader_with_dependencies_first(module_data)
           else
             create_loader_with_all_modules_visible(module_data)
           end
@@ -391,29 +520,13 @@ class Loaders
     private
 
     def create_loader_with_all_modules_visible(from_module_data)
-      Puppet.debug{"ModuleLoader: module '#{from_module_data.name}' has unknown dependencies - it will have all other modules visible"}
-
       @loaders.add_loader_by_name(Loader::DependencyLoader.new(from_module_data.public_loader, "#{from_module_data.name} private", all_module_loaders()))
     end
 
-    def create_loader_with_only_dependencies_visible(from_module_data)
-      if from_module_data.unmet_dependencies?
-        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
+    def create_loader_with_dependencies_first(from_module_data)
       dependency_loaders = from_module_data.dependency_names.collect { |name| @index[name].public_loader }
-      @loaders.add_loader_by_name(Loader::DependencyLoader.new(from_module_data.public_loader, "#{from_module_data.name} private", dependency_loaders))
+      visible_loaders = dependency_loaders + (all_module_loaders() - dependency_loaders)
+      @loaders.add_loader_by_name(Loader::DependencyLoader.new(from_module_data.public_loader, "#{from_module_data.name} private", visible_loaders))
     end
   end
 end

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

@@ -157,7 +157,7 @@ class Context
           tf.callable([0, 0], tf.iterable(tf.tuple([key_type, tf.any])))),
         'cached_file_data' => tf.callable(tf.string, tf.optional(tf.callable([1, 1])))
       }
-    ).resolve(Types::TypeParser.singleton, loader)
+    ).resolve(loader)
   end
 
   # Mainly for test purposes. Makes it possible to create a {Context} in Puppet code provided that a current {Invocation} exists.

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

@@ -71,7 +71,7 @@ class V3BackendFunctionProvider < DataDigFunctionProvider
     # A merge_behavior retrieved from hiera.yaml must not be converted here. Instead, passing the symbol :hash
     # tells the V3 backend to pick it up from the config.
     resolution_type = lookup_invocation.hiera_v3_merge_behavior? ? :hash : convert_merge(merge)
-    @backend.lookup(key.to_s, lookup_invocation.scope, lookup_invocation.hiera_v3_location_overrides, resolution_type, context = {:recurse_guard => nil})
+    @backend.lookup(key.to_s, lookup_invocation.scope, lookup_invocation.hiera_v3_location_overrides, resolution_type, {:recurse_guard => nil})
   end
 
   def full_name

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

@@ -491,7 +491,8 @@ module Lookup
         when :invalid_key
           ExplainInvalidKey.new(@current, qualifier)
         else
-          raise ArgumentError, "Unknown Explain type #{qualifier_type}"
+          #TRANSLATORS 'Explain' is referring to the 'Explainer' class and should not be translated
+          raise ArgumentError, _("Unknown Explain type %{qualifier_type}") % { qualifier_type: qualifier_type }
         end
       @current.branches << node
       @current = node

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

@@ -1,3 +1,4 @@
+require 'hiera/scope'
 require_relative 'configured_data_provider'
 
 module Puppet::Pops
@@ -11,7 +12,6 @@ class GlobalDataProvider < ConfiguredDataProvider
   def unchecked_key_lookup(key, lookup_invocation, merge)
     config = config(lookup_invocation)
     if(config.version == 3)
-      require 'hiera/scope'
       # Hiera version 3 needs access to special scope variables
       scope = lookup_invocation.scope
       unless scope.is_a?(Hiera::Scope)