puppet 6.17.0-x64-mingw32 → 7.1.0-x64-mingw32

data/lib/puppet/parser/templatewrapper.rb

@@ -50,7 +50,7 @@ class Puppet::Parser::TemplateWrapper
   # @return [Array<String>] The tags defined in the current scope
   # @api public
   def tags
-    scope.tags
+    raise NotImplementedError, "Call 'all_tags' instead."
   end
 
   # @return [Array<String>] All the defined tags

data/lib/puppet/parser/type_loader.rb

@@ -81,7 +81,7 @@ class Puppet::Parser::TypeLoader
   end
 
   def parse_file(file)
-    Puppet.debug("importing '#{file}' in environment #{environment}")
+    Puppet.debug { "importing '#{file}' in environment #{environment}" }
     parser = Puppet::Parser::ParserFactory.parser
     parser.file = file
     return parser.parse
@@ -118,7 +118,7 @@ class Puppet::Parser::TypeLoader
         # still be parsed. Mark this file as loaded so that
         # it would not be parsed next time (handle it as if
         # it was successfully parsed).
-        Puppet.debug("Unable to parse '#{file}': #{e.message}")
+        Puppet.debug { "Unable to parse '#{file}': #{e.message}" }
       end
     else
       loaded_asts << parse_file(file)

data/lib/puppet/pops/adaptable.rb

@@ -69,11 +69,7 @@ module Adaptable
     #
     def self.get(o)
       attr_name = self_attr_name
-      if o.instance_variable_defined?(attr_name)
-        o.instance_variable_get(attr_name)
-      else
-        nil
-      end
+      o.instance_variable_get(attr_name)
     end
 
     # Returns an existing adapter for the given object, or creates a new adapter if the
@@ -94,14 +90,13 @@ module Adaptable
     #
     def self.adapt(o, &block)
       attr_name = self_attr_name
-      value = o.instance_variable_get(attr_name) if o.instance_variable_defined?(attr_name)
+      value = o.instance_variable_get(attr_name)
       adapter = value || associate_adapter(create_adapter(o), o)
       if block_given?
-        case block.arity
-          when 1
-            block.call(adapter)
-          else
-            block.call(adapter, o)
+        if block.arity == 1
+          block.call(adapter)
+        else
+          block.call(adapter, o)
         end
       end
       adapter
@@ -127,8 +122,7 @@ module Adaptable
     def self.adapt_new(o, &block)
       adapter = associate_adapter(create_adapter(o), o)
       if block_given?
-        case block.arity
-        when 1
+        if block.arity == 1
           block.call(adapter)
         else
           block.call(adapter, o)

data/lib/puppet/pops/adapters.rb

@@ -99,6 +99,13 @@ module Adapters
 
     class PathsAndNameCacheAdapter < Puppet::Pops::Adaptable::Adapter
       attr_accessor :cache, :paths
+
+      def self.create_adapter(env)
+        adapter = super(env)
+        adapter.paths = env.modulepath.map { |p| Pathname.new(p) }
+        adapter.cache = {}
+        adapter
+      end
     end
 
     # Attempts to find the module that `instance` originates from by looking at it's {SourcePosAdapter} and
@@ -117,10 +124,7 @@ module Adapters
     def self.loader_name_by_source(environment, instance, file)
       file = instance.file if file.nil?
       return nil if file.nil? || EMPTY_STRING == file
-      pn_adapter = PathsAndNameCacheAdapter.adapt(environment) do |a|
-        a.paths ||= environment.modulepath.map { |p| Pathname.new(p) }
-        a.cache ||= {}
-      end
+      pn_adapter = PathsAndNameCacheAdapter.adapt(environment)
       dir = File.dirname(file)
       pn_adapter.cache.fetch(dir) do |key|
         mod = find_module_for_dir(environment, pn_adapter.paths, dir)

data/lib/puppet/pops/evaluator/collectors/abstract_collector.rb

@@ -45,9 +45,7 @@ class Puppet::Pops::Evaluator::Collectors::AbstractCollector
     return false if objects.empty?
 
     if @overrides and !objects.empty?
-      overrides[:source].meta_def(:child_of?) do |klass|
-        true
-      end
+      overrides[:source].override = true
 
       objects.each do |res|
         unless @collected.include?(res.ref)

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

@@ -462,10 +462,24 @@ class EvaluatorImpl
   end
 
   def eval_EppExpression(o, scope)
+    contains_sensitive = false
+
     scope["@epp"] = []
     evaluate(o.body, scope)
-    result = scope["@epp"].join
-    result
+    result = scope["@epp"].map do |r|
+      if r.instance_of?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+        contains_sensitive = true
+        string(r.unwrap, scope)
+      else
+        r
+      end
+    end.join
+
+    if contains_sensitive
+      Puppet::Pops::Types::PSensitiveType::Sensitive.new(result)
+    else
+      result
+    end
   end
 
   def eval_RenderStringExpression(o, scope)
@@ -474,7 +488,12 @@ class EvaluatorImpl
   end
 
   def eval_RenderExpression(o, scope)
-    scope["@epp"] << string(evaluate(o.expr, scope), scope)
+    result = evaluate(o.expr, scope)
+    if result.instance_of?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+      scope["@epp"] << result
+    else
+      scope["@epp"] << string(result, scope)
+    end
     nil
   end
 
@@ -1021,11 +1040,6 @@ class EvaluatorImpl
     end
   end
 
-  # SubLocatable is simply an expression that holds location information
-  def eval_SubLocatedExpression o, scope
-    evaluate(o.expr, scope)
-  end
-
   # Evaluates Puppet DSL Heredoc
   def eval_HeredocExpression o, scope
     expr = o.text_expr

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

@@ -79,9 +79,9 @@ class Runtime3Converter
 
   def convert_String(o, scope, undef_value)
     # Although wasteful, a dup is needed because user code may mutate these strings when applying
-    # Resources. This does not happen when in master mode since it only uses Resources that are
+    # Resources. This does not happen when in server mode since it only uses Resources that are
     # in puppet core and those are all safe.
-    o.frozen? && !Puppet.run_mode.master? ? o.dup : o
+    o.frozen? && !Puppet.run_mode.server? ? o.dup : o
   end
 
   def convert_Object(o, scope, undef_value)

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

@@ -19,7 +19,7 @@ module Runtime3ResourceSupport
       # resolved type is just the string CLASS
       resolved_type = CLASS_STRING
     else
-      # resolve a resource type - pcore based, ruby impl, user defined, or application
+      # resolve a resource type - pcore based, ruby impl or user defined
       resolved_type = find_resource_type(scope, type_name)
     end
 
@@ -109,10 +109,10 @@ module Runtime3ResourceSupport
 
   def self.find_defined_resource_type(scope, type_name)
     krt = scope.environment.known_resource_types
-    krt.find_definition(type_name) || krt.application(type_name)
+    krt.find_definition(type_name)
   end
   private_class_method :find_defined_resource_type
 
 end
 end
-end
+end

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

@@ -505,7 +505,7 @@ module Runtime3Support
       # Store config issues, ignore or warning
       p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
       p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
-      p[Issues::CLASS_NOT_VIRTUALIZABLE]      = Puppet[:strict] == :off ? :warning : Puppet[:strict]
+      p[Issues::CLASS_NOT_VIRTUALIZABLE]      = :error
       p[Issues::NUMERIC_COERCION]             = Puppet[:strict] == :off ? :ignore : Puppet[:strict]
       p[Issues::SERIALIZATION_DEFAULT_CONVERTED_TO_STRING] = Puppet[:strict] == :off ? :warning : Puppet[:strict]
       p[Issues::SERIALIZATION_UNKNOWN_CONVERTED_TO_STRING] = Puppet[:strict] == :off ? :warning : Puppet[:strict]

data/lib/puppet/pops/issues.rb

@@ -920,10 +920,5 @@ module Issues
   LOADER_FAILURE = issue :LOADER_FAILURE, :type do
     _('Failed to load: %{type_name}') % { type: type }
   end
-
-  DEPRECATED_APP_ORCHESTRATION = issue :DEPRECATED_APP_ORCHESTRATION, :klass do
-    _("Use of the application-orchestration %{expr} is deprecated. See https://puppet.com/docs/puppet/5.5/deprecated_language.html" % { expr: label(klass) })
-  end
-
 end
 end

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

@@ -16,13 +16,11 @@ class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
   # @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)
-    # When func3x turned on, assert content by parsing, when turned off continue with (legacy) undefined behavior
-    if Puppet[:func3x_check]
-      assertion_result = []
-      if assert_code(ruby_code_string, 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
+    # Assert content of 3x function by parsing
+    assertion_result = []
+    if assert_code(ruby_code_string, 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
 
@@ -91,7 +89,7 @@ class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
     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}' on line %{line}' in legacy function. See %{url} for more information") % { 
+      raise SecurityError, _("Illegal method definition of method '%{method_name}' on line %{line} in legacy function. See %{url} for more information") % { 
         method_name: mname,
         line: mline,
         url: "https://puppet.com/docs/puppet/latest/functions_refactor_legacy.html"

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

@@ -7,10 +7,12 @@ module Loader
 #
 # @api private
 class Runtime3TypeLoader < BaseLoader
-  def initialize(parent_loader, loaders, environment, env_path)
+  attr_reader :resource_3x_loader
+
+  def initialize(parent_loader, loaders, environment, resource_3x_loader)
     super(parent_loader, environment.name)
     @environment = environment
-    @resource_3x_loader = env_path.nil? ? nil : ModuleLoaders.pcore_resource_type_loader_from(parent_loader, loaders, env_path)
+    @resource_3x_loader = resource_3x_loader
   end
 
   def discover(type, error_collector = nil, name_authority = Pcore::RUNTIME_NAME_AUTHORITY, &block)

data/lib/puppet/pops/loaders.rb

@@ -18,18 +18,18 @@ class Loaders
   attr_reader :private_environment_loader
   attr_reader :environment
 
-  def self.new(environment, for_agent = false)
+  def self.new(environment, for_agent = false, load_from_pcore = true)
     environment.lock.synchronize do
       obj = environment.loaders
       if obj.nil?
         obj = self.allocate
-        obj.send(:initialize, environment, for_agent)
+        obj.send(:initialize, environment, for_agent, load_from_pcore)
       end
       obj
     end
   end
 
-  def initialize(environment, for_agent)
+  def initialize(environment, for_agent, load_from_pcore = true)
     # Protect against environment havoc
     raise ArgumentError.new(_("Attempt to redefine already initialized loaders for environment")) unless environment.loaders.nil?
     environment.loaders = self
@@ -51,12 +51,13 @@ class Loaders
     #    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
-      @puppet_cache_loader = create_puppet_cache_loader()
-      create_environment_loader(environment, @puppet_cache_loader)
-    else
-      create_environment_loader(environment, @puppet_system_loader)
-    end
+    @private_environment_loader =
+      if for_agent
+        @puppet_cache_loader = create_puppet_cache_loader
+        create_environment_loader(environment, @puppet_cache_loader, load_from_pcore)
+      else
+        create_environment_loader(environment, @puppet_system_loader, load_from_pcore)
+      end
 
     Pcore.init_env(@private_environment_loader)
 
@@ -362,7 +363,7 @@ class Loaders
     Loader::ModuleLoaders.cached_loader_from(puppet_system_loader, self)
   end
 
-  def create_environment_loader(environment, parent_loader)
+  def create_environment_loader(environment, parent_loader, load_from_pcore = true)
     # 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
@@ -387,7 +388,13 @@ class Loaders
     else
       # 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))
+      # Create pcore resource type loader, if applicable
+      pcore_resource_type_loader = if load_from_pcore && env_path
+                                     Loader::ModuleLoaders.pcore_resource_type_loader_from(parent_loader, self, env_path)
+                                   else
+                                     nil
+                                   end
+      @runtime3_type_loader = add_loader_by_name(Loader::Runtime3TypeLoader.new(parent_loader, self, environment, pcore_resource_type_loader))
 
       if env_path.nil?
         # Not a real directory environment, cannot work as a module TODO: Drop when legacy env are dropped?

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

@@ -47,7 +47,7 @@ class EnvironmentContext < Adaptable::Adapter
     file_data = @file_data_cache[path]
     stat = Puppet::FileSystem.stat(path)
     unless file_data && file_data.valid?(stat)
-      Puppet.debug("File at '#{path}' was changed, reloading") if file_data
+      Puppet.debug { "File at '#{path}' was changed, reloading" } if file_data
       content = Puppet::FileSystem.read(path, :encoding => 'utf-8')
       file_data = FileData.new(path, stat.ino, stat.mtime, stat.size, block_given? ? yield(content) : content)
       @file_data_cache[path] = file_data

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

@@ -46,6 +46,7 @@ class HieraConfig
   KEY_DATADIR = 'datadir'.freeze
   KEY_DEFAULT_HIERARCHY = 'default_hierarchy'.freeze
   KEY_HIERARCHY = 'hierarchy'.freeze
+  KEY_PLAN_HIERARCHY = 'plan_hierarchy'.freeze
   KEY_LOGGER = 'logger'.freeze
   KEY_OPTIONS = 'options'.freeze
   KEY_PATH = 'path'.freeze
@@ -580,6 +581,7 @@ class HieraConfigV5 < HieraConfig
           tf.optional(KEY_OPTIONS) => tf.hash_kv(option_name_t, tf.data),
         }),
       tf.optional(KEY_HIERARCHY) => hierarchy_t,
+      tf.optional(KEY_PLAN_HIERARCHY) => hierarchy_t,
       tf.optional(KEY_DEFAULT_HIERARCHY) => hierarchy_t
     })
   end
@@ -600,7 +602,15 @@ class HieraConfigV5 < HieraConfig
       return data_providers
     end
 
-    @config[use_default_hierarchy ? KEY_DEFAULT_HIERARCHY : KEY_HIERARCHY].each do |he|
+    compiler = Puppet.lookup(:pal_compiler) { nil }
+    config_key = if compiler.is_a?(Puppet::Pal::ScriptCompiler) && !@config[KEY_PLAN_HIERARCHY].nil?
+          KEY_PLAN_HIERARCHY
+        elsif use_default_hierarchy
+          KEY_DEFAULT_HIERARCHY
+        else
+          KEY_HIERARCHY
+        end
+    @config[config_key].each do |he|
       name = he[KEY_NAME]
       if data_providers.include?(name)
         first_line = find_line_matching(/\s+name:\s+['"]?#{name}(?:[^\w]|$)/)
@@ -691,6 +701,9 @@ class HieraConfigV5 < HieraConfig
     defaults = config[KEY_DEFAULTS]
     validate_defaults(defaults) unless defaults.nil?
     config[KEY_HIERARCHY].each { |he| validate_hierarchy(he, defaults, owner) }
+    if config.include?(KEY_PLAN_HIERARCHY)
+      config[KEY_PLAN_HIERARCHY].each { |he| validate_hierarchy(he, defaults, owner) }
+    end
 
     if config.include?(KEY_DEFAULT_HIERARCHY)
       unless owner.is_a?(ModuleDataProvider)

data/lib/puppet/pops/model/ast.pp

@@ -276,9 +276,6 @@ type Puppet::AST = TypeSet[{
     ResourceTypeDefinition => Object[{
       parent => NamedDefinition
     }],
-    Application => Object[{
-      parent => NamedDefinition
-    }],
     QRefDefinition => Object[{
       parent => Definition,
       attributes => {
@@ -334,33 +331,6 @@ type Puppet::AST = TypeSet[{
         }
       }
     }],
-    SiteDefinition => Object[{
-      parent => Definition,
-      attributes => {
-        'body' => {
-          type => Optional[Expression],
-          value => undef
-        }
-      }
-    }],
-    SubLocatedExpression => Object[{
-      parent => Expression,
-      attributes => {
-        'expr' => Expression,
-        'line_offsets' => {
-          type => Array[Integer],
-          value => []
-        },
-        'leading_line_count' => {
-          type => Optional[Integer],
-          value => undef
-        },
-        'leading_line_offset' => {
-          type => Optional[Integer],
-          value => undef
-        }
-      }
-    }],
     HeredocExpression => Object[{
       parent => Expression,
       attributes => {
@@ -616,18 +586,6 @@ type Puppet::AST = TypeSet[{
         }
       }
     }],
-    CapabilityMapping => Object[{
-      parent => Definition,
-      attributes => {
-        'kind' => String,
-        'capability' => String,
-        'component' => Expression,
-        'mappings' => {
-          type => Array[AbstractAttributeOperation],
-          value => []
-        }
-      }
-    }],
     ResourceDefaultsExpression => Object[{
       parent => AbstractResource,
       attributes => {

data/lib/puppet/pops/model/ast.rb

@@ -2055,32 +2055,6 @@ class ResourceTypeDefinition < NamedDefinition
   end
 end
 
-class Application < NamedDefinition
-  def self._pcore_type
-    @_pcore_type ||= Types::PObjectType.new('Puppet::AST::Application', {
-      'parent' => NamedDefinition._pcore_type
-    })
-  end
-
-  def _pcore_contents
-    @parameters.each { |value| yield(value) }
-    yield(@body) unless @body.nil?
-  end
-
-  def _pcore_all_contents(path, &block)
-    path << self
-    @parameters.each do |value|
-      block.call(value, path)
-      value._pcore_all_contents(path, &block)
-    end
-    unless @body.nil?
-      block.call(@body, path)
-      @body._pcore_all_contents(path, &block)
-    end
-    path.pop
-  end
-end
-
 class QRefDefinition < Definition
   def self._pcore_type
     @_pcore_type ||= Types::PObjectType.new('Puppet::AST::QRefDefinition', {
@@ -2466,171 +2440,6 @@ class NodeDefinition < Definition
   alias == eql?
 end
 
-class SiteDefinition < Definition
-  def self._pcore_type
-    @_pcore_type ||= Types::PObjectType.new('Puppet::AST::SiteDefinition', {
-      'parent' => Definition._pcore_type,
-      'attributes' => {
-        'body' => {
-          'type' => Types::POptionalType.new(Expression._pcore_type),
-          'value' => nil
-        }
-      }
-    })
-  end
-
-  def self.from_hash(init_hash)
-    from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::SiteDefinition initializer', _pcore_type.init_hash_type, init_hash))
-  end
-
-  def self.from_asserted_hash(init_hash)
-    new(
-      init_hash['locator'],
-      init_hash['offset'],
-      init_hash['length'],
-      init_hash['body'])
-  end
-
-  def self.create(locator, offset, length, body = nil)
-    ta = Types::TypeAsserter
-    attrs = _pcore_type.attributes(true)
-    ta.assert_instance_of('Puppet::AST::Positioned[locator]', attrs['locator'].type, locator)
-    ta.assert_instance_of('Puppet::AST::Positioned[offset]', attrs['offset'].type, offset)
-    ta.assert_instance_of('Puppet::AST::Positioned[length]', attrs['length'].type, length)
-    ta.assert_instance_of('Puppet::AST::SiteDefinition[body]', attrs['body'].type, body)
-    new(locator, offset, length, body)
-  end
-
-  attr_reader :body
-
-  def initialize(locator, offset, length, body = nil)
-    super(locator, offset, length)
-    @hash = @hash ^ body.hash
-    @body = body
-  end
-
-  def _pcore_init_hash
-    result = super
-    result['body'] = @body unless @body == nil
-    result
-  end
-
-  def _pcore_contents
-    yield(@body) unless @body.nil?
-  end
-
-  def _pcore_all_contents(path, &block)
-    path << self
-    unless @body.nil?
-      block.call(@body, path)
-      @body._pcore_all_contents(path, &block)
-    end
-    path.pop
-  end
-
-  def eql?(o)
-    super &&
-    @body.eql?(o.body)
-  end
-  alias == eql?
-end
-
-class SubLocatedExpression < Expression
-  def self._pcore_type
-    @_pcore_type ||= Types::PObjectType.new('Puppet::AST::SubLocatedExpression', {
-      'parent' => Expression._pcore_type,
-      'attributes' => {
-        'expr' => Expression._pcore_type,
-        'line_offsets' => {
-          'type' => Types::PArrayType.new(Types::PIntegerType::DEFAULT),
-          'value' => []
-        },
-        'leading_line_count' => {
-          'type' => Types::POptionalType.new(Types::PIntegerType::DEFAULT),
-          'value' => nil
-        },
-        'leading_line_offset' => {
-          'type' => Types::POptionalType.new(Types::PIntegerType::DEFAULT),
-          'value' => nil
-        }
-      }
-    })
-  end
-
-  def self.from_hash(init_hash)
-    from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::SubLocatedExpression initializer', _pcore_type.init_hash_type, init_hash))
-  end
-
-  def self.from_asserted_hash(init_hash)
-    new(
-      init_hash['locator'],
-      init_hash['offset'],
-      init_hash['length'],
-      init_hash['expr'],
-      init_hash.fetch('line_offsets') { _pcore_type['line_offsets'].value },
-      init_hash['leading_line_count'],
-      init_hash['leading_line_offset'])
-  end
-
-  def self.create(locator, offset, length, expr, line_offsets = _pcore_type['line_offsets'].value, leading_line_count = nil, leading_line_offset = nil)
-    ta = Types::TypeAsserter
-    attrs = _pcore_type.attributes(true)
-    ta.assert_instance_of('Puppet::AST::Positioned[locator]', attrs['locator'].type, locator)
-    ta.assert_instance_of('Puppet::AST::Positioned[offset]', attrs['offset'].type, offset)
-    ta.assert_instance_of('Puppet::AST::Positioned[length]', attrs['length'].type, length)
-    ta.assert_instance_of('Puppet::AST::SubLocatedExpression[expr]', attrs['expr'].type, expr)
-    ta.assert_instance_of('Puppet::AST::SubLocatedExpression[line_offsets]', attrs['line_offsets'].type, line_offsets)
-    ta.assert_instance_of('Puppet::AST::SubLocatedExpression[leading_line_count]', attrs['leading_line_count'].type, leading_line_count)
-    ta.assert_instance_of('Puppet::AST::SubLocatedExpression[leading_line_offset]', attrs['leading_line_offset'].type, leading_line_offset)
-    new(locator, offset, length, expr, line_offsets, leading_line_count, leading_line_offset)
-  end
-
-  attr_reader :expr
-  attr_reader :line_offsets
-  attr_reader :leading_line_count
-  attr_reader :leading_line_offset
-
-  def initialize(locator, offset, length, expr, line_offsets = _pcore_type['line_offsets'].value, leading_line_count = nil, leading_line_offset = nil)
-    super(locator, offset, length)
-    @hash = @hash ^ expr.hash ^ line_offsets.hash ^ leading_line_count.hash ^ leading_line_offset.hash
-    @expr = expr
-    @line_offsets = line_offsets
-    @leading_line_count = leading_line_count
-    @leading_line_offset = leading_line_offset
-  end
-
-  def _pcore_init_hash
-    result = super
-    result['expr'] = @expr
-    result['line_offsets'] = @line_offsets unless _pcore_type['line_offsets'].default_value?(@line_offsets)
-    result['leading_line_count'] = @leading_line_count unless @leading_line_count == nil
-    result['leading_line_offset'] = @leading_line_offset unless @leading_line_offset == nil
-    result
-  end
-
-  def _pcore_contents
-    yield(@expr) unless @expr.nil?
-  end
-
-  def _pcore_all_contents(path, &block)
-    path << self
-    unless @expr.nil?
-      block.call(@expr, path)
-      @expr._pcore_all_contents(path, &block)
-    end
-    path.pop
-  end
-
-  def eql?(o)
-    super &&
-    @expr.eql?(o.expr) &&
-    @line_offsets.eql?(o.line_offsets) &&
-    @leading_line_count.eql?(o.leading_line_count) &&
-    @leading_line_offset.eql?(o.leading_line_offset)
-  end
-  alias == eql?
-end
-
 class HeredocExpression < Expression
   def self._pcore_type
     @_pcore_type ||= Types::PObjectType.new('Puppet::AST::HeredocExpression', {
@@ -4284,101 +4093,6 @@ class ResourceExpression < AbstractResource
   alias == eql?
 end
 
-class CapabilityMapping < Definition
-  def self._pcore_type
-    @_pcore_type ||= Types::PObjectType.new('Puppet::AST::CapabilityMapping', {
-      'parent' => Definition._pcore_type,
-      'attributes' => {
-        'kind' => Types::PStringType::DEFAULT,
-        'capability' => Types::PStringType::DEFAULT,
-        'component' => Expression._pcore_type,
-        'mappings' => {
-          'type' => Types::PArrayType.new(AbstractAttributeOperation._pcore_type),
-          'value' => []
-        }
-      }
-    })
-  end
-
-  def self.from_hash(init_hash)
-    from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::CapabilityMapping initializer', _pcore_type.init_hash_type, init_hash))
-  end
-
-  def self.from_asserted_hash(init_hash)
-    new(
-      init_hash['locator'],
-      init_hash['offset'],
-      init_hash['length'],
-      init_hash['kind'],
-      init_hash['capability'],
-      init_hash['component'],
-      init_hash.fetch('mappings') { _pcore_type['mappings'].value })
-  end
-
-  def self.create(locator, offset, length, kind, capability, component, mappings = _pcore_type['mappings'].value)
-    ta = Types::TypeAsserter
-    attrs = _pcore_type.attributes(true)
-    ta.assert_instance_of('Puppet::AST::Positioned[locator]', attrs['locator'].type, locator)
-    ta.assert_instance_of('Puppet::AST::Positioned[offset]', attrs['offset'].type, offset)
-    ta.assert_instance_of('Puppet::AST::Positioned[length]', attrs['length'].type, length)
-    ta.assert_instance_of('Puppet::AST::CapabilityMapping[kind]', attrs['kind'].type, kind)
-    ta.assert_instance_of('Puppet::AST::CapabilityMapping[capability]', attrs['capability'].type, capability)
-    ta.assert_instance_of('Puppet::AST::CapabilityMapping[component]', attrs['component'].type, component)
-    ta.assert_instance_of('Puppet::AST::CapabilityMapping[mappings]', attrs['mappings'].type, mappings)
-    new(locator, offset, length, kind, capability, component, mappings)
-  end
-
-  attr_reader :kind
-  attr_reader :capability
-  attr_reader :component
-  attr_reader :mappings
-
-  def initialize(locator, offset, length, kind, capability, component, mappings = _pcore_type['mappings'].value)
-    super(locator, offset, length)
-    @hash = @hash ^ kind.hash ^ capability.hash ^ component.hash ^ mappings.hash
-    @kind = kind
-    @capability = capability
-    @component = component
-    @mappings = mappings
-  end
-
-  def _pcore_init_hash
-    result = super
-    result['kind'] = @kind
-    result['capability'] = @capability
-    result['component'] = @component
-    result['mappings'] = @mappings unless _pcore_type['mappings'].default_value?(@mappings)
-    result
-  end
-
-  def _pcore_contents
-    yield(@component) unless @component.nil?
-    @mappings.each { |value| yield(value) }
-  end
-
-  def _pcore_all_contents(path, &block)
-    path << self
-    unless @component.nil?
-      block.call(@component, path)
-      @component._pcore_all_contents(path, &block)
-    end
-    @mappings.each do |value|
-      block.call(value, path)
-      value._pcore_all_contents(path, &block)
-    end
-    path.pop
-  end
-
-  def eql?(o)
-    super &&
-    @kind.eql?(o.kind) &&
-    @capability.eql?(o.capability) &&
-    @component.eql?(o.component) &&
-    @mappings.eql?(o.mappings)
-  end
-  alias == eql?
-end
-
 class ResourceDefaultsExpression < AbstractResource
   def self._pcore_type
     @_pcore_type ||= Types::PObjectType.new('Puppet::AST::ResourceDefaultsExpression', {
@@ -4895,14 +4609,11 @@ def self.register_pcore_types
   Model::NamedDefinition,
   Model::FunctionDefinition,
   Model::ResourceTypeDefinition,
-  Model::Application,
   Model::QRefDefinition,
   Model::TypeAlias,
   Model::TypeMapping,
   Model::TypeDefinition,
   Model::NodeDefinition,
-  Model::SiteDefinition,
-  Model::SubLocatedExpression,
   Model::HeredocExpression,
   Model::HostClassDefinition,
   Model::PlanDefinition,
@@ -4936,7 +4647,6 @@ def self.register_pcore_types
   Model::ResourceBody,
   Model::AbstractResource,
   Model::ResourceExpression,
-  Model::CapabilityMapping,
   Model::ResourceDefaultsExpression,
   Model::ResourceOverrideExpression,
   Model::SelectorEntry,