puppet 4.3.2 → 4.4.0

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

@@ -49,7 +49,7 @@ 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_redefined(entry); end
+    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)
   end
 

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

@@ -22,7 +22,7 @@
 class Puppet::Pops::Loader::Loader
 
   # Describes the kinds of things that loaders can load
-  LOADABLE_KINDS = [:func_4x, :func_4xpp].freeze
+  LOADABLE_KINDS = [:func_4x, :func_4xpp, :type_pp].freeze
 
   # Produces the value associated with the given name if already loaded, or available for loading
   # by this loader, one of its parents, or other loaders visible to this loader.

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

@@ -23,6 +23,8 @@ module Puppet::Pops::Loader::LoaderPaths
           result << FunctionPathPP.new(loader)
         end
         # When wanted also add FunctionPath3x to load 3x functions
+    when :type
+      result << TypePathPP.new(loader) if loader.loadables.include?(:type_pp)
     else
       # unknown types, simply produce an empty result; no paths to check, nothing to find... move along...
       []
@@ -147,6 +149,19 @@ module Puppet::Pops::Loader::LoaderPaths
     end
   end
 
+  class TypePathPP < PuppetSmartPath
+    # Navigate to directory where 'lib' is, then down again
+    TYPE_PATH_PP = File.join('types')
+
+    def relative_path
+      TYPE_PATH_PP
+    end
+
+    def instantiator()
+      Puppet::Pops::Loader::TypeDefinitionInstantiator
+    end
+  end
+
   # SmartPaths
   # ===
   # Holds effective SmartPath instances per type

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

@@ -1,4 +1,5 @@
-
+module Puppet::Pops
+module Loader
 # =ModuleLoaders
 # A ModuleLoader loads items from a single module.
 # The ModuleLoaders (ruby) module contains various such loaders. There is currently one concrete
@@ -14,12 +15,12 @@
 # internal layout etc.)
 #
 # A module loader is also not aware of the mapping of name to relative paths - this is performed by the
-# included module Puppet::Pops::Loader::PathBasedInstantatorConfig which knows about the map from type/name to
+# included module PathBasedInstantatorConfig which knows about the map from type/name to
 # relative path, and the logic that can instantiate what is expected to be found in the content of that path.
 #
 # @api private
 #
-module Puppet::Pops::Loader::ModuleLoaders
+module ModuleLoaders
   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
@@ -27,7 +28,7 @@ module Puppet::Pops::Loader::ModuleLoaders
     # puppet.
     #
     puppet_lib = File.join(File.dirname(__FILE__), '../../..')
-    Puppet::Pops::Loader::ModuleLoaders::FileBased.new(parent_loader,
+    ModuleLoaders::FileBased.new(parent_loader,
                                                        loaders,
                                                        nil,
                                                        puppet_lib,   # may or may not have a 'lib' above 'puppet'
@@ -37,7 +38,7 @@ module Puppet::Pops::Loader::ModuleLoaders
   end
 
   def self.module_loader_from(parent_loader, loaders, module_name, module_path)
-    Puppet::Pops::Loader::ModuleLoaders::FileBased.new(parent_loader,
+    ModuleLoaders::FileBased.new(parent_loader,
                                                        loaders,
                                                        module_name,
                                                        File.join(module_path, 'lib'),
@@ -45,7 +46,7 @@ module Puppet::Pops::Loader::ModuleLoaders
                                                        )
   end
 
-  class AbstractPathBasedModuleLoader < Puppet::Pops::Loader::BaseLoader
+  class AbstractPathBasedModuleLoader < BaseLoader
 
     # The name of the module, or nil, if this is a global "component"
     attr_reader :module_name
@@ -64,7 +65,7 @@ module Puppet::Pops::Loader::ModuleLoaders
     attr_accessor :private_loader
 
     # Initialize a kind of ModuleLoader for one module
-    # @param parent_loader [Puppet::Pops::Loader] loader with higher priority
+    # @param parent_loader [Loader] loader with higher priority
     # @param module_name [String] the name of the module (non qualified name), may be nil for a global "component"
     # @param path [String] the path to the root of the module (semantics defined by subclass)
     # @param loader_name [String] a name that is used for human identification (useful when module_name is nil)
@@ -74,7 +75,7 @@ module Puppet::Pops::Loader::ModuleLoaders
 
       @module_name = module_name
       @path = path
-      @smart_paths = Puppet::Pops::Loader::LoaderPaths::SmartPaths.new(self)
+      @smart_paths = LoaderPaths::SmartPaths.new(self)
       @loaders = loaders
       @loadables = loadables
       unless (loadables - LOADABLE_KINDS).empty?
@@ -87,8 +88,8 @@ module Puppet::Pops::Loader::ModuleLoaders
     end
 
     # Finds typed/named entity in this module
-    # @param typed_name [Puppet::Pops::Loader::TypedName] the type/name to find
-    # @return [Puppet::Pops::Loader::Loader::NamedEntry, nil found/created entry, or nil if not found
+    # @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)
       # Assume it is a global name, and that all parts of the name should be used when looking up
@@ -115,6 +116,7 @@ module Puppet::Pops::Loader::ModuleLoaders
         case typed_name.type
         when :function
         when :resource_type
+        when :type
         else
           # anything else cannot possibly be in this module
           # TODO: should not be allowed anyway... may have to revisit this decision
@@ -201,7 +203,7 @@ module Puppet::Pops::Loader::ModuleLoaders
 
     # Create a kind of ModuleLoader for one module (Puppet Module, or module like)
     #
-    # @param parent_loader [Puppet::Pops::Loader::Loader] typically the loader for the environment or root
+    # @param parent_loader [Loader] typically the loader for the environment or root
     # @param module_name [String] the name of the module (non qualified name), may be nil for "modules" only containing globals
     # @param path [String] the path to the root of the module (semantics defined by subclass)
     # @param loader_name [String] a name that identifies the loader
@@ -231,7 +233,7 @@ module Puppet::Pops::Loader::ModuleLoaders
     end
 
     def get_contents(effective_path)
-      Puppet::FileSystem.read(effective_path)
+      Puppet::FileSystem.read(effective_path, :encoding => 'utf-8')
     end
   end
 
@@ -246,7 +248,7 @@ module Puppet::Pops::Loader::ModuleLoaders
   # @api private
   #
   class GemBased < FileBased
-    include Puppet::Pops::Loader::GemSupport
+    include GemSupport
 
     attr_reader :gem_ref
 
@@ -267,3 +269,5 @@ module Puppet::Pops::Loader::ModuleLoaders
     end
   end
 end
+end
+end

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

@@ -1,19 +1,21 @@
+module Puppet::Pops
+module Loader
 # The PuppetFunctionInstantiator instantiates a Puppet::Functions::PuppetFunction given a Puppet Programming language
 # source that when called evaluates the Puppet logic it contains.
 #
-class Puppet::Pops::Loader::PuppetFunctionInstantiator
+class PuppetFunctionInstantiator
   # Produces an instance of the Function class with the given typed_name, or fails with an error if the
   # given puppet 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 loader [Loader] The loader the function is associated with
+  # @param typed_name [TypedName] the type / name of the function to load
   # @param source_ref [URI, String] a reference to the source / origin of the puppet code to evaluate
   # @param pp_code_string [String] puppet code in a string
   #
-  # @return [Puppet::Pops::Functions::Function] - an instantiated function with global scope closure associated with the given loader
+  # @return [Functions::Function] - an instantiated function with global scope closure associated with the given loader
   #
   def self.create(loader, typed_name, source_ref, pp_code_string)
-    parser = Puppet::Pops::Parser::EvaluatingParser.new()
+    parser = Parser::EvaluatingParser.new()
 
     # parse and validate
     result = parser.parse_string(pp_code_string, source_ref)
@@ -28,7 +30,7 @@ class Puppet::Pops::Loader::PuppetFunctionInstantiator
     end
     the_function_definition = result.model.definitions[0]
 
-    unless the_function_definition.is_a?(Puppet::Pops::Model::FunctionDefinition)
+    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."
     end
     unless the_function_definition.name == typed_name.name
@@ -44,7 +46,7 @@ class Puppet::Pops::Loader::PuppetFunctionInstantiator
     # loader to use when making calls to the new function API. Such logic have a hard time finding the closure (where
     # the loader is known - hence this mechanism
     private_loader = loader.private_loader
-    Puppet::Pops::Adapters::LoaderAdapter.adapt(the_function_definition).loader = private_loader
+    Adapters::LoaderAdapter.adapt(the_function_definition).loader = private_loader
 
     # TODO: Cheating wrt. scope - assuming it is found in the context
     closure_scope = Puppet.lookup(:global_scope) { {} }
@@ -58,22 +60,24 @@ class Puppet::Pops::Loader::PuppetFunctionInstantiator
   end
 
   # Creates Function class and instantiates it based on a FunctionDefinition model
-  # @return [Array<Puppet::Pops::Loader::Loader::TypedName, Puppet::Pops::Functions.Function>] - array of 
+  # @return [Array<Loader::TypedName, Functions.Function>] - array of 
   #   typed name, and an instantiated function with global scope closure associated with the given loader
   #
   def self.create_from_model(function_definition, loader)
     closure_scope = Puppet.lookup(:global_scope) { {} }
     created = create_function_class(function_definition, closure_scope)
-    typed_name = Puppet::Pops::Loader::Loader::TypedName.new(:function, function_definition.name)
+    typed_name = Loader::TypedName.new(:function, function_definition.name)
     [typed_name, created.new(closure_scope, loader)]
   end
 
   def self.create_function_class(function_definition, closure_scope)
     # Create a 4x function wrapper around a named closure
     Puppet::Functions.create_function(function_definition.name, Puppet::Functions::PuppetFunction) do
-      init_dispatch(Puppet::Pops::Evaluator::Closure::Named.new(
+      init_dispatch(Evaluator::Closure::Named.new(
         function_definition.name,
-        Puppet::Pops::Evaluator::EvaluatorImpl.new(), function_definition, closure_scope))
+        Evaluator::EvaluatorImpl.new(), function_definition, closure_scope))
     end
   end
-end
+end
+end
+end

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

@@ -16,7 +16,10 @@ class Puppet::Pops::Loader::RubyFunctionInstantiator
     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."
     end
-    created = eval(ruby_code_string, nil, source_ref, 1)
+    # 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}'"
     end
@@ -27,8 +30,18 @@ class Puppet::Pops::Loader::RubyFunctionInstantiator
     # when calling functions etc.
     # It should be bound to global scope
 
-    # TODO: Cheating wrt. scope - assuming it is found in the context
+    # Cheating wrt. scope - assuming it is found in the context (else an empty hash is used).
     closure_scope = Puppet.lookup(:global_scope) { {} }
-    created.new(closure_scope, loader.private_loader)
+    # If function definition used the loader from the binding to create a new loader, that loader wins
+    created.new(closure_scope, loader_for_function)
+  end
+
+  private
+
+  # 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
 end

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

@@ -0,0 +1,55 @@
+# The TypeDefinitionInstantiator instantiates a type alias or a type definition
+#
+module Puppet::Pops
+module Loader
+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
+    # 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."
+    when 1
+      # ok
+    else
+      raise ArgumentError,
+        "The code loaded from #{source_ref} must contain only the type '#{name}' - it has additional definitions."
+    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."
+    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}'"
+    end
+
+    unless model.body == type_definition
+      raise ArgumentError,
+        "The code loaded from #{source_ref} contains additional logic - can only contain the type '#{name}'"
+    end
+
+    # Adapt the type definition with loader - this is used from logic contained in its body to find the
+    # loader to use when resolving contained aliases API. Such logic have a hard time finding the closure (where
+    # 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)
+  end
+
+  def self.create_from_model(type_definition, loader)
+    name = type_definition.name
+    [Loader::TypedName.new(:type, name.downcase), Types::PTypeAliasType.new(name, type_definition.type_expr)]
+  end
+end
+end
+end

data/lib/puppet/pops/loaders.rb

@@ -1,4 +1,5 @@
-class Puppet::Pops::Loaders
+module Puppet::Pops
+class Loaders
   class LoaderError < Puppet::Error; end
 
   attr_reader :static_loader
@@ -8,7 +9,7 @@ class Puppet::Pops::Loaders
 
   def initialize(environment)
     # The static loader can only be changed after a reboot
-    @@static_loader ||= Puppet::Pops::Loader::StaticLoader.new()
+    @@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
@@ -35,6 +36,46 @@ class Puppet::Pops::Loaders
     @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.
+  #
+  # @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 = Puppet.lookup(:loaders) { nil }
+    raise Puppet::ParseError, "Internal Error: Puppet Context ':loaders' missing" if loaders.nil?
+    loaders.find_loader(module_name)
+  end
+
+  # Finds 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 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
+    else
+      # 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?
+      loader
+    end
+  end
+
   def static_loader
     @@static_loader
   end
@@ -66,7 +107,7 @@ class Puppet::Pops::Loaders
   private
 
   def create_puppet_system_loader()
-    Puppet::Pops::Loader::ModuleLoaders.system_loader_from(static_loader, self)
+    Loader::ModuleLoaders.system_loader_from(static_loader, self)
   end
 
   def create_environment_loader(environment)
@@ -91,10 +132,10 @@ class Puppet::Pops::Loaders
     env_conf = Puppet.lookup(:environments).get_conf(environment.name)
     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 = Puppet::Pops::Loader::SimpleEnvironmentLoader.new(puppet_system_loader, loader_name)
+      loader = Loader::SimpleEnvironmentLoader.new(puppet_system_loader, loader_name)
     else
       # View the environment as a module to allow loading from it - this module is always called 'environment'
-      loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(puppet_system_loader, self, 'environment', env_conf.path_to_env)
+      loader = Loader::ModuleLoaders.module_loader_from(puppet_system_loader, self, 'environment', env_conf.path_to_env)
     end
 
     # An environment has a module path even if it has a null loader
@@ -105,7 +146,7 @@ class Puppet::Pops::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 = Puppet::Pops::Loader::DependencyLoader.new(loader, "environment", @module_resolver.all_module_loaders())
+    loader = Loader::DependencyLoader.new(loader, "environment", @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.
@@ -121,7 +162,7 @@ class Puppet::Pops::Loaders
       # Create data about this module
       md = LoaderModuleData.new(puppet_module)
       mr[puppet_module.name] = md
-      md.public_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(parent_loader, self, md.name, md.path)
+      md.public_loader = Loader::ModuleLoaders.module_loader_from(parent_loader, self, md.name, md.path)
     end
     # NOTE: Do not resolve all modules here - this is wasteful if only a subset of modules / functions are used
     #       The resolution is triggered by asking for a module's private loader, since this means there is interest
@@ -224,7 +265,7 @@ class Puppet::Pops::Loaders
     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"}
 
-      Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, all_module_loaders())
+      Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, all_module_loaders())
     end
 
     def create_loader_with_only_dependencies_visible(from_module_data)
@@ -234,7 +275,8 @@ class Puppet::Pops::Loaders
           " Use 'puppet module list --tree' to see information about modules")
       end
       dependency_loaders = from_module_data.dependency_names.collect { |name| @index[name].public_loader }
-      Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, dependency_loaders)
+      Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, dependency_loaders)
     end
   end
 end
+end

data/lib/puppet/pops/lookup.rb

@@ -1,7 +1,8 @@
 # This class is the backing implementation of the Puppet function 'lookup'.
 # See puppet/functions/lookup.rb for documentation.
 #
-module Puppet::Pops::Lookup
+module Puppet::Pops
+module Lookup
   LOOKUP_OPTIONS = 'lookup_options'.freeze
   GLOBAL = '__global__'.freeze
 
@@ -11,25 +12,25 @@ module Puppet::Pops::Lookup
   # See puppet/functions/lookup.rb for full documentation and all parameter combinations.
   #
   # @param name [String|Array<String>] The name or names to lookup
-  # @param type [Puppet::Pops::Types::PAnyType|nil] The expected type of the found value
+  # @param type [Types::PAnyType|nil] The expected type of the found value
   # @param default_value [Object] The value to use as default when no value is found
   # @param has_default [Boolean] Set to _true_ if _default_value_ is included (_nil_ is a valid _default_value_)
-  # @param merge [Puppet::Pops::MergeStrategy,String,Hash<String,Object>,nil] Merge strategy or hash with strategy and options
-  # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] Invocation data containing scope, overrides, and defaults
+  # @param merge [MergeStrategy,String,Hash<String,Object>,nil] Merge strategy or hash with strategy and options
+  # @param lookup_invocation [Invocation] Invocation data containing scope, overrides, and defaults
   # @return [Object] The found value
   #
   def self.lookup(name, value_type, default_value, has_default, merge, lookup_invocation)
-    value_type = Puppet::Pops::Types::PDataType::DEFAULT if value_type.nil?
+    value_type = Types::PDataType::DEFAULT if value_type.nil?
     names = name.is_a?(Array) ? name : [name]
 
     # find first name that yields a non-nil result and wrap it in a two element array
     # with name and value.
-    not_found = Puppet::Pops::MergeStrategy::NOT_FOUND
+    not_found = MergeStrategy::NOT_FOUND
     override_values = lookup_invocation.override_values
     result_with_name = names.reduce([nil, not_found]) do |memo, key|
-      value = override_values.include?(key) ? assert_type('override', value_type, override_values[key]) : not_found
+      value = override_values.include?(key) ? assert_type(["Value found for key '%s' in override hash", key], value_type, override_values[key]) : not_found
       catch(:no_such_key) { value = search_and_merge(key, lookup_invocation, merge) } if value.equal?(not_found)
-      break [key, assert_type('found', value_type, value)] unless value.equal?(not_found)
+      break [key, assert_type('Found value', value_type, value)] unless value.equal?(not_found)
       memo
     end
 
@@ -38,7 +39,7 @@ module Puppet::Pops::Lookup
       default_values = lookup_invocation.default_values
       unless default_values.empty?
         result_with_name = names.reduce(result_with_name) do |memo, key|
-          value = default_values.include?(key) ? assert_type('default_values_hash', value_type, default_values[key]) : not_found
+          value = default_values.include?(key) ? assert_type(["Value found for key '%s' in default values hash", key], value_type, default_values[key]) : not_found
           memo = [key, value]
           break memo unless value.equal?(not_found)
           memo
@@ -49,9 +50,9 @@ module Puppet::Pops::Lookup
     answer = result_with_name[1]
     if answer.equal?(not_found)
       if block_given?
-        answer = assert_type('default_block', value_type, yield(name))
+        answer = assert_type('Value returned from default block', value_type, yield(name))
       elsif has_default
-        answer = assert_type('default_value', value_type, default_value)
+        answer = assert_type('Default value', value_type, default_value)
       else
         fail_lookup(names)
       end
@@ -65,7 +66,7 @@ module Puppet::Pops::Lookup
   end
 
   def self.assert_type(subject, type, value)
-    Puppet::Pops::Types::TypeAsserter.assert_instance_of(subject, type, value)
+    Types::TypeAsserter.assert_instance_of(subject, type, value)
   end
   private_class_method :assert_type
 
@@ -75,3 +76,4 @@ module Puppet::Pops::Lookup
   end
   private_class_method :fail_lookup
 end
+end