openvox 7.37.1

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

@@ -0,0 +1,93 @@
+module Puppet::Pops
+module Loader
+# The PuppetPlanInstantiator instantiates a Puppet::Functions::PuppetFunction given a Puppet Programming language
+# source that when called evaluates the Puppet logic it contains.
+#
+class PuppetPlanInstantiator
+  # 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 [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 [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 = Parser::EvaluatingParser.new()
+
+    # parse and validate
+    result = parser.parse_string(pp_code_string, source_ref)
+
+    # The parser attaches all definitions, including those nested in apply
+    # blocks, to the Program object. Node definitions in apply blocks are
+    # perfectly legal and don't count as the file containing multiple
+    # definitions for this purpose. By this point, we've already validated that
+    # there are no node definitions *outside* apply blocks, so we simply ignore
+    # them here.
+    definitions = result.definitions.reject { |definition| definition.is_a?(Puppet::Pops::Model::NodeDefinition) }
+
+    # Only one plan is allowed (and no other definitions)
+    case definitions.size
+    when 0
+      raise ArgumentError, _("The code loaded from %{source_ref} does not define the plan '%{plan_name}' - it is empty.") % { source_ref: source_ref, plan_name: typed_name.name }
+    when 1
+      # ok
+    else
+      raise ArgumentError, _("The code loaded from %{source_ref} must contain only the plan '%{plan_name}' - it has additional definitions.") % { source_ref: source_ref, plan_name: typed_name.name }
+    end
+    the_plan_definition = definitions[0]
+
+    unless the_plan_definition.is_a?(Model::PlanDefinition)
+      raise ArgumentError, _("The code loaded from %{source_ref} does not define the plan '%{plan_name}' - no plan found.") % { source_ref: source_ref, plan_name: typed_name.name }
+    end
+    unless the_plan_definition.name == typed_name.name
+      expected = typed_name.name
+      actual = the_plan_definition.name
+      raise ArgumentError, _("The code loaded from %{source_ref} produced plan with the wrong name, expected %{expected}, actual %{actual}") % { source_ref: source_ref, expected: expected, actual: actual }
+    end
+    unless result.body == the_plan_definition
+      raise ArgumentError, _("The code loaded from %{source} contains additional logic - can only contain the plan %{plan_name}") % { source: source_ref, plan_name: typed_name.name }
+    end
+
+    # Adapt the function definition with loader - this is used from logic contained in it body to find the
+    # 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
+    Adapters::LoaderAdapter.adapt(the_plan_definition).loader_name = private_loader.loader_name
+
+    # Cannot bind loaded functions to global scope, that must be done without binding that scope as
+    # loaders survive a compilation.
+    closure_scope = nil
+
+    created = create_function_class(the_plan_definition)
+    # 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
+
+    created.new(closure_scope, private_loader)
+  end
+
+  # Creates Function class and instantiates it based on a FunctionDefinition model
+  # @return [Array<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(plan_definition, loader)
+    created = create_function_class(plan_definition)
+    typed_name = TypedName.new(:plan, plan_definition.name)
+    [typed_name, created.new(nil, loader)]
+  end
+
+  def self.create_function_class(plan_definition)
+    # Create a 4x function wrapper around a named closure
+    Puppet::Functions.create_function(plan_definition.name, Puppet::Functions::PuppetFunction) do
+      # TODO: should not create a new evaluator per function
+      init_dispatch(Evaluator::Closure::Named.new(
+        plan_definition.name,
+        Evaluator::EvaluatorImpl.new(), plan_definition))
+    end
+  end
+end
+end
+end

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

@@ -0,0 +1,79 @@
+module Puppet::Pops
+module Loader
+# The PuppetResourceTypeImplInstantiator instantiates a Puppet::Pops::ResourceTypeImpl object.
+# given a Puppet Programming language source that when called evaluates the Puppet logic it contains.
+#
+class PuppetResourceTypeImplInstantiator
+  # Produces an instance of Puppet::Pops::ResourceTypeImpl, or fails with an error if the
+  # given puppet source does not produce such an instance when evaluated.
+  #
+  # @param loader [Loader] The loader the function is associated with
+  # @param typed_name [TypedName] the type / name of the resource type impl 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::ResourceTypeImpl] - an instantiated ResourceTypeImpl
+  #
+  def self.create(loader, typed_name, source_ref, pp_code_string)
+    parser = Parser::EvaluatingParser.new()
+
+    # parse and validate
+    model = parser.parse_string(pp_code_string, source_ref)
+    statements = if model.is_a?(Model::Program)
+                   if model.body.is_a?(Model::BlockExpression)
+                     model.body.statements
+                   else
+                     [model.body]
+                   end
+                 else
+                   EMPTY_ARRAY
+                 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 '%{type_name}' - it is empty") % { source_ref: source_ref, type_name: typed_name.name }
+    end
+
+    rname = Resource::ResourceTypeImpl._pcore_type.name
+    unless statements.find do |s|
+      if s.is_a?(Model::CallMethodExpression)
+        functor_expr = s.functor_expr
+        functor_expr.is_a?(Model::NamedAccessExpression) &&
+          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'
+      else
+        false
+      end
+    end
+      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 '%{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, 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 '%{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}'") % { 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
+    # 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
+    Adapters::LoaderAdapter.adapt(resource_type_impl).loader_name = loader.loader_name
+    resource_type_impl
+  end
+
+end
+end
+end

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

@@ -0,0 +1,39 @@
+# The RubyTypeInstantiator instantiates a data type from the ruby source
+# that calls Puppet::DataTypes.create_type.
+#
+class Puppet::Pops::Loader::RubyDataTypeInstantiator
+  # Produces an instance of class derived from PAnyType 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 type is associated with
+  # @param typed_name [Puppet::Pops::Loader::TypedName] the type / name of the type 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::Types::PAnyType] - an instantiated data type 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\:\:DataTypes\.create_type/
+      raise ArgumentError, _("The code loaded from %{source_ref} does not seem to be a Puppet 5x API data type - no create_type call.") % { source_ref: source_ref }
+    end
+    # make the private loader available in a binding to allow it to be passed on
+    loader_for_type = loader.private_loader
+    here = get_binding(loader_for_type)
+    created = eval(ruby_code_string, here, source_ref, 1) # rubocop:disable Security/Eval
+    unless created.is_a?(Puppet::Pops::Types::PAnyType)
+      raise ArgumentError, _("The code loaded from %{source_ref} did not produce a data type when evaluated. Got '%{klass}'") % { source_ref: source_ref, klass: created.class }
+    end
+    unless created.name.casecmp(typed_name.name) == 0
+      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
+    created
+  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/ruby_function_instantiator.rb

@@ -0,0 +1,45 @@
+# The RubyFunctionInstantiator instantiates a Puppet::Functions::Function given the ruby source
+# that calls Puppet::Functions.create_function.
+#
+class Puppet::Pops::Loader::RubyFunctionInstantiator
+  # 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\:\: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.") % { 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) # rubocop:disable Security/Eval
+    unless created.is_a?(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 '%{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.
+    # 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/ruby_legacy_function_instantiator.rb

@@ -0,0 +1,120 @@
+# The RubyLegacyFunctionInstantiator instantiates a Puppet::Functions::Function given the ruby source
+# that calls Puppet::Functions.create_function.
+#
+require 'ripper'
+class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
+  UNKNOWN = '<unknown>'.freeze
+
+  # 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)
+    # Assert content of 3x function by parsing
+    assertion_result = []
+    if assert_code(ruby_code_string, source_ref, assertion_result)
+      unless ruby_code_string.is_a?(String) && assertion_result.include?(:found_newfunction)
+        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
+    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)
+
+    # Avoid reloading the function if already loaded via one of the APIs that trigger 3x function loading
+    # Check if function is already loaded the 3x way (and obviously not the 4x way since we would not be here in the
+    # first place.
+    environment = Puppet.lookup(:current_environment)
+    func_info = Puppet::Parser::Functions.environment_module(environment).get_function_info(typed_name.name.to_sym)
+    if func_info.nil?
+      # This will 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) # rubocop:disable Security/Eval
+
+      # Validate what was loaded
+      unless func_info.is_a?(Hash)
+        # TRANSLATORS - the word 'newfunction' should not be translated as it is a method name.
+        raise ArgumentError, _("Illegal legacy function definition! The code loaded from %{source_ref} did not return the result of calling 'newfunction'. Got '%{klass}'") % { source_ref: source_ref, klass: func_info.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
+    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
+
+  def self.assert_code(code_string, source_ref, result)
+    ripped = Ripper.sexp(code_string)
+    return false if ripped.nil?  # Let the next real parse crash and tell where and what is wrong
+    ripped.each {|x| walk(x, source_ref, result) }
+    true
+  end
+  private_class_method :assert_code
+
+  def self.walk(x, source_ref, result)
+    return unless x.is_a?(Array)
+    first = x[0]
+    case first
+    when :fcall, :call
+      # Ripper returns a :fcall for a function call in a module (want to know there is a call to newfunction()).
+      # And it returns :call for a qualified named call
+      identity_part = find_identity(x)
+      result << :found_newfunction if identity_part.is_a?(Array) && identity_part[1] == 'newfunction'
+    when :def, :defs
+      # There should not be any calls to def in a 3x function
+      mname, mline = extract_name_line(find_identity(x))
+      raise SecurityError, _("Illegal method definition of method '%{method_name}' in source %{source_ref} on line %{line} in legacy function. See %{url} for more information") % {
+        method_name: mname,
+        source_ref: source_ref,
+        line: mline,
+        url: "https://puppet.com/docs/puppet/latest/functions_refactor_legacy.html"
+      }
+    end
+    x.each {|v| walk(v, source_ref, result) }
+  end
+  private_class_method :walk
+
+  def self.find_identity(rast)
+    rast.find{|x| x.is_a?(Array) && x[0] == :@ident }
+  end
+  private_class_method :find_identity
+
+  # Extracts the method name and line number from the Ripper Rast for an id entry.
+  # The expected input (a result from Ripper :@ident entry) is an array with:
+  # [0] == :def (or :defs for self.def)
+  # [1] == method name
+  # [2] == [ <filename>, <linenumber> ]
+  #
+  # Returns an Array; a tuple with method name and line number or "<unknown>" if either is missing, or format is not the expected
+  #
+  def self.extract_name_line(x)
+    (x.is_a?(Array) ? [ x[1], x[2].is_a?(Array) ? x[2][1] : nil] : [nil, nil]).map {|v| v.nil? ? UNKNOWN : v }
+  end
+  private_class_method :extract_name_line
+end

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

@@ -0,0 +1,103 @@
+module Puppet::Pops
+module Loader
+
+# Runtime3TypeLoader
+# ===
+# Loads a resource type using the 3.x type loader
+#
+# @api private
+class Runtime3TypeLoader < BaseLoader
+  attr_reader :resource_3x_loader
+
+  def initialize(parent_loader, loaders, environment, resource_3x_loader)
+    super(parent_loader, environment.name, environment)
+    @environment = environment
+    @resource_3x_loader = resource_3x_loader
+  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
+
+  # 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.name_authority == Pcore::RUNTIME_NAME_AUTHORITY
+    case typed_name.type
+    when :type
+      value = nil
+      name = typed_name.name
+      if @resource_3x_loader.nil?
+        value = Puppet::Type.type(name) unless typed_name.qualified?
+        if value.nil?
+          # Look for a user defined type
+          value = @environment.known_resource_types.find_definition(name)
+        end
+      else
+        impl_te = find_impl(TypedName.new(:resource_type_pp, name, typed_name.name_authority))
+        value = impl_te.value unless impl_te.nil?
+      end
+
+      if value.nil?
+        # Cache the fact that it wasn't found
+        set_entry(typed_name, nil)
+        return nil
+      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
+    when :resource_type_pp
+      @resource_3x_loader.nil? ? nil : find_impl(typed_name)
+    else
+      nil
+    end
+  end
+
+  # Find the implementation for the resource type by first consulting the internal loader for pp defined 'Puppet::Resource::ResourceType3'
+  # instances, then check for a Puppet::Type and lastly check for a defined type.
+  #
+  def find_impl(typed_name)
+    name = typed_name.name
+    te = StaticLoader::BUILTIN_TYPE_NAMES_LC.include?(name) ? nil : @resource_3x_loader.load_typed(typed_name)
+    if te.nil? || te.value.nil?
+      # Look for Puppet::Type
+      value = Puppet::Type.type(name) unless typed_name.qualified?
+      if value.nil?
+        # Look for a user defined type
+        value = @environment.known_resource_types.find_definition(name)
+        if value.nil?
+          # Cache the fact that it wasn't found
+          @resource_3x_loader.set_entry(typed_name, nil)
+          return nil
+        end
+      end
+      te = @resource_3x_loader.get_entry(typed_name)
+      te = @resource_3x_loader.set_entry(typed_name, value) if te.nil? || te.value.nil?
+    end
+    te
+  end
+  private :find_impl
+
+  # 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.
+  #
+  def allow_shadowing?
+    true
+  end
+
+end
+end
+end

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

@@ -0,0 +1,20 @@
+# SimpleEnvironmentLoader
+# ===
+# This loader does not load anything and it is populated by the bootstrapping logic that loads
+# the site.pp or equivalent for an environment. It does not restrict the names of what it may contain,
+# and what is loaded here overrides any child loaders (modules).
+#
+class Puppet::Pops::Loader::SimpleEnvironmentLoader < Puppet::Pops::Loader::BaseLoader
+
+  attr_accessor :private_loader
+
+  # Never finds anything, everything "loaded" is set externally
+  def find(typed_name)
+    nil
+  end
+
+  def to_s()
+    "(SimpleEnvironmentLoader '#{loader_name}')"
+  end
+
+end

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

@@ -0,0 +1,131 @@
+  # Static Loader contains constants, basic data types and other types required for the system
+  # to boot.
+  #
+module Puppet::Pops
+module Loader
+class StaticLoader < Loader
+
+  BUILTIN_TYPE_NAMES = %w{
+      Component
+      Exec
+      File
+      Filebucket
+      Group
+      Node
+      Notify
+      Package
+      Resources
+      Schedule
+      Service
+      Stage
+      Tidy
+      User
+      Whit
+    }.freeze
+
+  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,URI,Object,Undef,Default,Hash[RichDataKey,RichData],Array[RichData]]',
+
+    # Backward compatible aliases.
+    'Puppet::LookupKey' => 'RichDataKey',
+    'Puppet::LookupValue' => 'RichData'
+  }.freeze
+
+  attr_reader :loaded
+  def initialize
+    @loaded = {}
+    @runtime_3_initialized = false
+    create_built_in_types
+  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 #rubocop:disable Lint/AssignmentInCondition
+
+    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)
+    load_constant(typed_name)
+  end
+
+  def get_entry(typed_name)
+    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
+  end
+
+  def parent
+    nil # at top of the hierarchy
+  end
+
+  def to_s()
+    "(StaticLoader)"
+  end
+
+  def loaded_entry(typed_name, check_dependencies = false)
+    @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)
+    @loaded[typed_name]
+  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|
+      set_entry(TypedName.new(:type, name), type, origin_uri)
+    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.
+    #
+    BUILTIN_TYPE_NAMES.each { |name| create_resource_type_reference(name) }
+  end
+
+  def add_type(name, type)
+    set_entry(TypedName.new(:type, name), type)
+    type
+  end
+
+  def create_resource_type_reference(name)
+    add_type(name, Types::TypeFactory.resource(name))
+  end
+
+  def synchronize(&block)
+    yield
+  end
+end
+end
+end

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

@@ -0,0 +1,44 @@
+# The TypeDefinitionInstantiator instantiates a type alias or a type definition
+#
+require_relative '../../../puppet/module/task'
+module Puppet::Pops
+module Loader
+class TaskInstantiator
+  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 = Puppet::Module::Task.read_metadata(metadata_file) || {}
+
+    files = Puppet::Module::Task.find_files(name, dirname, metadata, executables)
+
+    task = { 'name' => name, 'metadata' => metadata, 'files' => files }
+
+    begin
+      unless metadata['parameters'].is_a?(Hash) || metadata['parameters'].nil?
+        msg = _('Failed to load metadata for task %{name}: \'parameters\' must be a hash') % { name: name }
+        raise Puppet::ParseError.new(msg, metadata_file)
+      end
+      task['parameters'] = convert_types(metadata['parameters'])
+
+      Types::TypeFactory.task.from_hash(task)
+    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
+
+  def self.convert_types(args)
+    args.each_with_object({}) do |(k, v), hsh|
+      hsh[k] = v['type'].nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(v['type'])
+    end if args
+  end
+  private_class_method :convert_types
+end
+end
+end