puppet 4.10.0 → 5.0.0

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

@@ -109,8 +109,8 @@ class BaseLoader < Loader
   private
 
   def fail_redefine(entry)
-    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}"
+    origin_info = entry.origin ? _("Originally set %{original}.") % { original: origin_label(entry.origin) } : _("Set at unknown location")
+    raise ArgumentError, _("Attempt to redefine entity '%{name}'. %{origin_info}") % { name: entry.typed_name, origin_info: origin_info }
   end
 
   # TODO: Should not really be here?? - TODO: A Label provider ? semantics for the URI?

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

@@ -27,7 +27,7 @@ module Puppet::Pops::Loader::GemSupport
   #
   def gem_dir_from_uri(uri)
     unless spec = Gem::Specification.find_by_name(uri.hostname)
-      raise ArgumentError, "Gem not found #{uri}"
+      raise ArgumentError, _("Gem not found %{uri}") % { uri: uri }
     end
     # if path given append that, else append given subdir
     if uri.path.empty?
@@ -42,7 +42,7 @@ module Puppet::Pops::Loader::GemSupport
   #
   def gem_dir_from_name(gem_name)
     unless spec = Gem::Specification.find_by_name(gem_name)
-      raise ArgumentError, "Gem not found '#{gem_name}'"
+      raise ArgumentError, _("Gem not found '%{gem_name}'") % { gem_name: gem_name }
     end
     spec.full_gem_path
   end

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

@@ -21,6 +21,10 @@
 #
 module Puppet::Pops
 module Loader
+
+ENVIRONMENT = 'environment'.freeze
+ENVIRONMENT_PRIVATE = 'environment private'.freeze
+
 class Loader
   attr_reader :loader_name
 

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

@@ -21,8 +21,6 @@ module Loader
 # @api private
 #
 module ModuleLoaders
-  ENVIRONMENT = 'environment'.freeze
-
   def self.system_loader_from(parent_loader, loaders)
     # Puppet system may be installed in a fixed location via RPM, installed as a Gem, via source etc.
     # The only way to find this across the different ways puppet can be installed is
@@ -138,6 +136,21 @@ module ModuleLoaders
         when :resource_type
         when :resource_type_pp
         when :type
+          if !global?
+            # Global name can only be the module typeset
+            return nil unless name_parts[0] == module_name
+
+            origin, smart_path = find_existing_path(init_typeset_name)
+            return nil unless smart_path
+
+            value = smart_path.instantiator.create(self, typed_name, origin, get_contents(origin))
+            if value.is_a?(Types::PTypeSetType)
+              # cache the entry and return it
+              return set_entry(typed_name, value, origin)
+            end
+
+            raise ArgumentError,"The code loaded from #{origin} does not define the TypeSet '#{module_name.capitalize}'"
+          end
         else
           # anything else cannot possibly be in this module
           # TODO: should not be allowed anyway... may have to revisit this decision
@@ -148,17 +161,31 @@ module ModuleLoaders
       # Get the paths that actually exist in this module (they are lazily processed once and cached).
       # The result is an array (that may be empty).
       # Find the file to instantiate, and instantiate the entity if file is found
-      origin = nil
-      if (smart_path = smart_paths.effective_paths(typed_name.type).find do |sp|
-          origin = sp.effective_path(typed_name, global? ? 0 : 1)
-          existing_path(origin)
-        end)
+      origin, smart_path = find_existing_path(typed_name)
+      if smart_path
         value = smart_path.instantiator.create(self, typed_name, origin, get_contents(origin))
         # cache the entry and return it
-        set_entry(typed_name, value, origin)
-      else
-        nil
+        return set_entry(typed_name, value, origin)
+      end
+
+      return nil unless typed_name.type == :type && typed_name.qualified?
+
+      # Search for TypeSet using parent name
+      ts_name = typed_name.parent
+      while ts_name
+        # Do not traverse parents here. This search must be confined to this loader
+        tse = get_entry(ts_name)
+        tse = find(ts_name) if tse.nil? || tse.value.nil?
+        if tse && (ts = tse.value).is_a?(Types::PTypeSetType)
+          # The TypeSet might be unresolved at this point. If so, it must be resolved using
+          # this loader. That in turn, adds all contained types to this loader.
+          ts.resolve(Types::TypeParser.singleton, self)
+          te = get_entry(typed_name)
+          return te unless te.nil?
+        end
+        ts_name = ts_name.parent
       end
+      nil
     end
 
     # Abstract method that subclasses override that checks if it is meaningful to search using a generic smart path.
@@ -221,6 +248,28 @@ module ModuleLoaders
       # that can only by called by puppet runtime - if so, it acts as the private loader directly.
       @private_loader ||= (global? ? self : @loaders.private_loader_for_module(module_name))
     end
+
+    private
+
+    # @return [TypedName] the fake typed name that maps to the init_typeset path for this module
+    def init_typeset_name
+      @init_typeset_name ||= TypedName.new(:type, "#{module_name}::init_typeset")
+    end
+
+    # Find an existing path for the given `typed_name`. Return `nil` if no such path is found
+    # @param typed_name [TypedName] the `typed_name` to find a path for
+    # @return [Array,nil] `nil`or a two element array an effective path `String` and the `SmartPath` that produced the effective path.
+    def find_existing_path(typed_name)
+      is_global = global?
+      smart_paths.effective_paths(typed_name.type).each do |sp|
+        origin = sp.effective_path(typed_name, is_global ? 0 : 1)
+        unless origin.nil?
+          existing = existing_path(origin)
+          return [origin, sp] unless existing.nil?
+        end
+      end
+      nil
+    end
   end
 
   # @api private

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

@@ -2,15 +2,10 @@ 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
+    nil
   end
 
   def to_s()

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

@@ -20,26 +20,26 @@ class PuppetFunctionInstantiator
     # parse and validate
     result = parser.parse_string(pp_code_string, source_ref)
     # Only one function is allowed (and no other definitions)
-    case result.model.definitions.size
+    case result.definitions.size
     when 0
-      raise ArgumentError, "The code loaded from #{source_ref} does not define the function '#{typed_name.name}' - it is empty."
+      raise ArgumentError, _("The code loaded from %{source_ref} does not define the function '%{func_name}' - it is empty.") % { source_ref: source_ref, func_name: typed_name.name }
     when 1
       # ok
     else
-      raise ArgumentError, "The code loaded from #{source_ref} must contain only the function '#{typed_name.name}' - it has additional definitions."
+      raise ArgumentError, _("The code loaded from %{source_ref} must contain only the function '%{type_name}' - it has additional definitions.") % { source_ref: source_ref, type_name: typed_name.name }
     end
-    the_function_definition = result.model.definitions[0]
+    the_function_definition = result.definitions[0]
 
     unless the_function_definition.is_a?(Model::FunctionDefinition)
-      raise ArgumentError, "The code loaded from #{source_ref} does not define the function '#{typed_name.name}' - no function found."
+      raise ArgumentError, _("The code loaded from %{source_ref} does not define the function '%{type_name}' - no function found.") % { source_ref: source_ref, type_name: typed_name.name }
     end
     unless the_function_definition.name == typed_name.name
       expected = typed_name.name
       actual = the_function_definition.name
-      raise ArgumentError, "The code loaded from #{source_ref} produced function with the wrong name, expected #{expected}, actual #{actual}"
+      raise ArgumentError, _("The code loaded from %{source_ref} produced function with the wrong name, expected %{expected}, actual %{actual}") % { source_ref: source_ref, expected: expected, actual: actual }
     end
-    unless result.model().body == the_function_definition
-      raise ArgumentError, "The code loaded from #{source_ref} contains additional logic - can only contain the function #{typed_name.name}"
+    unless result.body == the_function_definition
+      raise ArgumentError, _("The code loaded from %{source} contains additional logic - can only contain the function %{name}") % { source: source_ref, name: typed_name.name }
     end
 
     # Adapt the function definition with loader - this is used from logic contained in it body to find the

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

@@ -18,8 +18,7 @@ class PuppetResourceTypeImplInstantiator
     parser = Parser::EvaluatingParser.new()
 
     # parse and validate
-    result = parser.parse_string(pp_code_string, source_ref)
-    model = result.model
+    model = parser.parse_string(pp_code_string, source_ref)
     statements = if model.is_a?(Model::Program)
       if model.body.is_a?(Model::BlockExpression)
         statements = model.body.statements
@@ -31,10 +30,10 @@ class PuppetResourceTypeImplInstantiator
     end
     statements = statements.reject { |s| s.is_a?(Model::Nop) }
     if statements.empty?
-      raise ArgumentError, "The code loaded from #{source_ref} does not create the resource type '#{typed_name.name}' - it is empty"
+      raise ArgumentError, _("The code loaded from %{source_ref} does not create the resource type '%{type_name}' - it is empty") % { source_ref: source_ref, type_name: typed_name.name }
     end
 
-    rname = Resource::ResourceTypeImpl._ptype.name
+    rname = Resource::ResourceTypeImpl._pcore_type.name
     unless statements.find do |s|
       if s.is_a?(Model::CallMethodExpression)
         functor_expr = s.functor_expr
@@ -42,30 +41,30 @@ class PuppetResourceTypeImplInstantiator
           functor_expr.left_expr.is_a?(Model::QualifiedReference) &&
           functor_expr.left_expr.cased_value == rname &&
           functor_expr.right_expr.is_a?(Model::QualifiedName) &&
-          functor_expr.right_expr.value == 'new'
+          functor_expr.right_expr.value == _('new')
       else
         false
       end
     end
-      raise ArgumentError, "The code loaded from #{source_ref} does not create the resource type '#{typed_name.name}' - no call to #{rname}.new found."
+      raise ArgumentError, _("The code loaded from %{source_ref} does not create the resource type '%{type_name}' - no call to %{rname}.new found.") % { source_ref: source_ref, type_name: typed_name.name, rname: rname }
     end
 
     unless statements.size == 1
-      raise ArgumentError, "The code loaded from #{source_ref} must contain only the creation of resource type '#{typed_name.name}' - it has additional logic."
+      raise ArgumentError, _("The code loaded from %{source_ref} must contain only the creation of resource type '%{type_name}' - it has additional logic.") % { source_ref: source_ref, type_name: typed_name.name }
     end
 
     closure_scope = Puppet.lookup(:global_scope) { {} }
-    resource_type_impl = parser.evaluate(closure_scope, result)
+    resource_type_impl = parser.evaluate(closure_scope, model)
 
     unless resource_type_impl.is_a?(Puppet::Pops::Resource::ResourceTypeImpl)
       got = resource_type.class
-      raise ArgumentError, "The code loaded from #{source_ref} does not define the resource type '#{typed_name.name}' - got '#{got}'."
+      raise ArgumentError, _("The code loaded from %{source_ref} does not define the resource type '%{type_name}' - got '%{got}'.") % { source_ref: source_ref, type_name: typed_name.name, got: got }
     end
 
     unless resource_type_impl.name == typed_name.name
       expected = typed_name.name
       actual = resource_type_impl.name
-      raise ArgumentError, "The code loaded from #{source_ref} produced resource type with the wrong name, expected '#{expected}', actual '#{actual}'"
+      raise ArgumentError, _("The code loaded from %{source_ref} produced resource type with the wrong name, expected '%{expected}', actual '%{actual}'") % { source_ref: source_ref, expected: expected, actual: actual }
     end
 
     # Adapt the resource type definition with loader - this is used from logic contained in it body to find the

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

@@ -14,17 +14,17 @@ class Puppet::Pops::Loader::RubyFunctionInstantiator
   #
   def self.create(loader, typed_name, source_ref, ruby_code_string)
     unless ruby_code_string.is_a?(String) && ruby_code_string =~ /Puppet\:\:Functions\.create_function/
-      raise ArgumentError, "The code loaded from #{source_ref} does not seem to be a Puppet 4x API function - no create_function call."
+      raise ArgumentError, _("The code loaded from %{source_ref} does not seem to be a Puppet 4x API function - no create_function 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)
     created = eval(ruby_code_string, here, source_ref, 1)
     unless created.is_a?(Class)
-      raise ArgumentError, "The code loaded from #{source_ref} did not produce a Function class when evaluated. Got '#{created.class}'"
+      raise ArgumentError, _("The code loaded from %{source_ref} did not produce a Function class when evaluated. Got '%{klass}'") % { source_ref: source_ref, klass: created.class }
     end
     unless created.name.to_s == typed_name.name()
-      raise ArgumentError, "The code loaded from #{source_ref} produced mis-matched name, expected '#{typed_name.name}', got #{created.name}"
+      raise ArgumentError, _("The code loaded from %{source_ref} produced mis-matched name, expected '%{type_name}', got %{created_name}") % { source_ref: source_ref, type_name: typed_name.name, created_name: created.name }
     end
     # create the function instance - it needs closure (scope), and loader (i.e. where it should start searching for things
     # when calling functions etc.

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

@@ -36,6 +36,7 @@ class StaticLoader < Loader
       Nagios_serviceextinfo
       Nagios_servicegroup
       Nagios_timeperiod
+      Node
       Notify
       Package
       Resources
@@ -60,11 +61,22 @@ class StaticLoader < Loader
 
   BUILTIN_TYPE_NAMES_LC = Set.new(BUILTIN_TYPE_NAMES.map { |n| n.downcase }).freeze
 
+  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]]',
+
+    # Backward compatible aliases.
+    'Puppet::LookupKey' => 'RichDataKey',
+    'Puppet::LookupValue' => 'RichData'
+  }.freeze
+
   attr_reader :loaded
   def initialize
     @loaded = {}
-    create_built_in_types()
-    create_resource_type_references()
+    create_built_in_types
+    create_resource_type_references
+    register_aliases
   end
 
   def load_typed(typed_name)
@@ -75,6 +87,10 @@ class StaticLoader < Loader
     load_constant(typed_name)
   end
 
+  def set_entry(typed_name, value, origin = nil)
+    @loaded[typed_name] = Loader::NamedEntry.new(typed_name, value, origin)
+  end
+
   def find(name)
     # There is nothing to search for, everything this loader knows about is already available
     nil
@@ -88,7 +104,7 @@ class StaticLoader < Loader
     "(StaticLoader)"
   end
 
-  def loaded_entry(typed_name, _)
+  def loaded_entry(typed_name, check_dependencies = false)
     @loaded[typed_name]
   end
 
@@ -102,8 +118,7 @@ class StaticLoader < Loader
     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__)
+      set_entry(TypedName.new(:type, name), type, origin_uri)
     end
   end
 
@@ -112,68 +127,22 @@ class StaticLoader < Loader
     # 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) }
+    BUILTIN_TYPE_NAMES.each { |name| create_resource_type_reference(name) }
+  end
 
-    if Puppet[:app_management]
-      create_resource_type_reference('Node')
-    end
+  def add_type(name, type)
+    set_entry(TypedName.new(:type, name), type)
+    type
   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__)
+    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

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

@@ -6,35 +6,35 @@ class TypeDefinitionInstantiator
   def self.create(loader, typed_name, source_ref, pp_code_string)
     # parse and validate
     parser = Parser::EvaluatingParser.new()
-    model = parser.parse_string(pp_code_string, source_ref).model
+    model = parser.parse_string(pp_code_string, source_ref)
     # Only one type is allowed (and no other definitions)
 
     name = typed_name.name
     case model.definitions.size
     when 0
-      raise ArgumentError, "The code loaded from #{source_ref} does not define the type '#{name}' - it is empty."
+      raise ArgumentError, _("The code loaded from %{source_ref} does not define the type '%{name}' - it is empty.") % { source_ref: source_ref, name: name }
     when 1
       # ok
     else
       raise ArgumentError,
-        "The code loaded from #{source_ref} must contain only the type '#{name}' - it has additional definitions."
+        _("The code loaded from %{source_ref} must contain only the type '%{name}' - it has additional definitions.") % { source_ref: source_ref, name: name }
     end
     type_definition = model.definitions[0]
 
     unless type_definition.is_a?(Model::TypeAlias) || type_definition.is_a?(Model::TypeDefinition)
       raise ArgumentError,
-        "The code loaded from #{source_ref} does not define the type '#{name}' - no type alias or type definition found."
+        _("The code loaded from %{source_ref} does not define the type '%{name}' - no type alias or type definition found.") % { source_ref: source_ref, name: name }
     end
 
     actual_name = type_definition.name
     unless name == actual_name.downcase
       raise ArgumentError,
-        "The code loaded from #{source_ref} produced type with the wrong name, expected '#{name}', actual '#{actual_name}'"
+        _("The code loaded from %{source_ref} produced type with the wrong name, expected '%{name}', actual '%{actual_name}'") % { source_ref: source_ref, name: name, actual_name: actual_name }
     end
 
     unless model.body == type_definition
       raise ArgumentError,
-        "The code loaded from #{source_ref} contains additional logic - can only contain the type '#{name}'"
+        _("The code loaded from %{source_ref} contains additional logic - can only contain the type '%{name}'") % { source_ref: source_ref, name: name }
     end
 
     # Adapt the type definition with loader - this is used from logic contained in its body to find the
@@ -46,12 +46,12 @@ class TypeDefinitionInstantiator
   end
 
   def self.create_from_model(type_definition, loader)
-    typed_name = TypedName.new(:type, type_definition.name.downcase)
+    typed_name = TypedName.new(:type, type_definition.name)
     type = create_runtime_type(type_definition)
     loader.set_entry(
       typed_name,
       type,
-      Adapters::SourcePosAdapter.adapt(type_definition).to_uri)
+      type_definition.locator.to_uri(type_definition))
     type
   end
 

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

@@ -12,6 +12,7 @@ class TypedName
   attr_reader :compound_name
 
   def initialize(type, name, name_authority = Pcore::RUNTIME_NAME_AUTHORITY)
+    name = name.downcase
     @type = type
     @name_authority = name_authority
     # relativize the name (get rid of leading ::), and make the split string available
@@ -36,6 +37,11 @@ class TypedName
 
   alias eql? ==
 
+  # @return the parent of this instance, or nil if this instance is not qualified
+  def parent
+    @name_parts.size > 1 ? self.class.new(@type, @name_parts[0...-1].join(DOUBLE_COLON), @name_authority) : nil
+  end
+
   def qualified?
     @name_parts.size > 1
   end

data/lib/puppet/pops/loaders.rb

@@ -29,7 +29,7 @@ class Loaders
 
   def initialize(environment, for_agent)
     # Protect against environment havoc
-    raise ArgumentError.new("Attempt to redefine already initialized loaders for environment") unless environment.loaders.nil?
+    raise ArgumentError.new(_("Attempt to redefine already initialized loaders for environment")) unless environment.loaders.nil?
     environment.loaders = self
     @environment = environment
     @loaders_by_name = {}
@@ -67,6 +67,8 @@ class Loaders
   #
   def self.clear
     @@static_loader = nil
+    Model.class_variable_set(:@@pcore_ast_initialized, false)
+    Model.register_pcore_types
   end
 
   # Calls {#loaders} to obtain the {{Loaders}} instance and then uses it to find the appropriate loader
@@ -91,12 +93,20 @@ class Loaders
   end
 
   def register_implementations(obj_classes, name_authority)
-    loader = @private_environment_loader
+    self.class.register_implementations_with_loader(obj_classes, name_authority, loader = @private_environment_loader)
+  end
+
+  # Register implementations using the global static loader
+  def self.register_static_implementations(obj_classes)
+    register_implementations_with_loader(obj_classes, Pcore::RUNTIME_NAME_AUTHORITY, static_loader)
+  end
+
+  def self.register_implementations_with_loader(obj_classes, name_authority, loader)
     types = obj_classes.map do |obj_class|
-      type = obj_class._ptype
-      typed_name = Loader::TypedName.new(:type, type.name.downcase, name_authority)
+      type = obj_class._pcore_type
+      typed_name = Loader::TypedName.new(:type, type.name, name_authority)
       entry = loader.loaded_entry(typed_name)
-      loader.set_entry(typed_name, type, obj_class._plocation) if entry.nil? || entry.value.nil?
+      loader.set_entry(typed_name, type) if entry.nil? || entry.value.nil?
       type
     end
     # Resolve lazy so that all types can cross reference each other
@@ -119,7 +129,7 @@ class Loaders
 
     name = name.to_s
     caps_name = Types::TypeFormatter.singleton.capitalize_segments(name)
-    typed_name = Loader::TypedName.new(:type, name.downcase)
+    typed_name = Loader::TypedName.new(:type, name)
     rt3_loader.set_entry(typed_name, Types::PResourceType.new(caps_name), origin)
     nil
   end
@@ -157,7 +167,7 @@ class Loaders
     if loader.nil?
       # Unable to find the module private loader. Try resolving the module
       loader = private_loader_for_module(loader_name[0..-9]) if loader_name.end_with?(' private')
-      raise Puppet::ParseError, "Unable to find loader named '#{loader_name}'" if loader.nil?
+      raise Puppet::ParseError, _("Unable to find loader named '%{loader_name}'") % { loader_name: loader_name } if loader.nil?
     end
     loader
   end
@@ -170,15 +180,9 @@ class Loaders
   # @raise [Puppet::ParseError] if no loader can be found
   # @api private
   def find_loader(module_name)
-    if module_name.nil? || module_name == ''
-      # TODO : Later when fdefinition can be private, a decision is needed regarding what that means.
-      #        A private environment loader could be used for logic outside of modules, then only that logic
-      #        would see the definition.
-      #
-      # Use the private loader, this definition may see the environment's dependencies (currently, all modules)
-      loader = private_environment_loader()
-      raise Puppet::ParseError, 'Internal Error: did not find public loader' if loader.nil?
-      loader
+    if module_name.nil? || EMPTY_STRING == module_name
+      # Use the public environment loader
+      public_environment_loader
     else
       # TODO : Later check if definition is private, and then add it to private_loader_for_module
       #
@@ -248,8 +252,6 @@ class Loaders
     # available modules. (3x is everyone sees everything).
     # Puppet binder currently reads confdir/bindings - that is bad, it should be using the new environment support.
 
-    # The environment is not a namespace, so give it a nil "module_name"
-    loader_name = "environment:#{environment.name}"
     # env_conf is setup from the environment_dir value passed into Puppet::Environments::Directories.new
     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
@@ -259,7 +261,7 @@ class Loaders
 
     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_name))
+      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)
@@ -273,7 +275,7 @@ class Loaders
     # Code in the environment gets to see all modules (since there is no metadata for the environment)
     # but since this is not given to the module loaders, they can not load global code (since they can not
     # have prior knowledge about this
-    loader = add_loader_by_name(Loader::DependencyLoader.new(loader, 'environment private', @module_resolver.all_module_loaders()))
+    loader = add_loader_by_name(Loader::DependencyLoader.new(loader, Loader::ENVIRONMENT_PRIVATE, @module_resolver.all_module_loaders()))
 
     # The module loader gets the private loader via a lazy operation to look up the module's private loader.
     # This does not work for an environment since it is not resolved the same way.

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

@@ -126,7 +126,7 @@ class Context
   include Types::PuppetObject
   extend Forwardable
 
-  def self._ptype
+  def self._pcore_type
     @type
   end
 

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

@@ -11,24 +11,9 @@ module DataProvider
   end
 
   def self.register_types(loader)
-    (@key_type, @value_type) = Pcore::register_aliases({
-      # The Pcore type for all keys and subkeys in a data hash.
-      'Puppet::LookupKey' => 'Variant[String,Numeric]',
-
-      # The Pcore type for all values and sub-values in a data hash. The
-      # type is self-recursive to enforce the same constraint on values contained
-      # in arrays and hashes
-      'Puppet::LookupValue' => <<-PUPPET
-        Variant[
-          Scalar,
-          Undef,
-          Sensitive,
-          Type,
-          Hash[Puppet::LookupKey, Puppet::LookupValue],
-          Array[Puppet::LookupValue]
-        ]
-        PUPPET
-    }, Pcore::RUNTIME_NAME_AUTHORITY, loader)
+    tp = Types::TypeParser.singleton
+    @key_type = tp.parse('RichDataKey', loader)
+    @value_type = tp.parse('RichData', loader)
   end
 
   # Performs a lookup with an endless recursion check.

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

@@ -17,7 +17,7 @@ class EnvironmentDataProvider < ConfiguredDataProvider
       if Puppet[:strict] == :error
         config.fail(Issues::HIERA_VERSION_3_NOT_GLOBAL, :where => 'environment')
       else
-        Puppet.warn_once(:hiera_v3_at_env_root, config.config_path, 'hiera.yaml version 3 found at the environment root was ignored')
+        Puppet.warn_once(:hiera_v3_at_env_root, config.config_path, _('hiera.yaml version 3 found at the environment root was ignored'), config.config_path)
       end
       nil
     end