puppet 6.29.0 → 7.0.0

data/lib/puppet/parser/resource.rb

@@ -13,7 +13,7 @@ class Puppet::Parser::Resource < Puppet::Resource
 
   attr_accessor :source, :scope, :collector_id
   attr_accessor :virtual, :override, :translated, :catalog, :evaluated
-  attr_accessor :file, :line, :kind
+  attr_accessor :file, :line
 
   attr_reader :exported, :parameters
 
@@ -150,15 +150,6 @@ class Puppet::Parser::Resource < Puppet::Resource
     end
   end
 
-  def is_unevaluated_consumer?
-    # We don't declare a new variable here just to test. Saves memory
-    instance_variable_defined?(:@unevaluated_consumer)
-  end
-
-  def mark_unevaluated_consumer
-    @unevaluated_consumer = true
-  end
-
   # Merge an override resource in.  This will throw exceptions if
   # any overrides aren't allowed.
   def merge(resource)
@@ -260,66 +251,6 @@ class Puppet::Parser::Resource < Puppet::Resource
     super || ((scope_resource = scope.resource) && !scope_resource.equal?(self) && scope_resource.raw_tagged?(tag_array))
   end
 
-  # Fills resource params from a capability
-  #
-  # This backs 'consumes => Sql[one]'
-  # @api private
-  def add_parameters_from_consume
-    return if self[:consume].nil?
-
-    map = {}
-    [ self[:consume] ].flatten.map do |ref|
-      # Assert that the ref really is a resource reference
-      raise Puppet::Error, _("Invalid consume in %{value0}: %{ref} is not a resource") % { value0: self.ref, ref: ref } unless ref.is_a?(Puppet::Resource)
-
-      # Resolve references
-      t = ref.type
-      t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
-      cap = catalog.resource(t, ref.title)
-      if cap.nil?
-        raise Puppet::Error, _("Resource %{ref} could not be found; it might not have been produced yet") % { ref: ref }
-      end
-
-      # Ensure that the found resource is a capability resource
-      raise Puppet::Error, _("Invalid consume in %{ref}: %{cap} is not a capability resource") % { ref: ref, cap: cap } unless cap.resource_type.is_capability?
-      cap
-    end.each do |cns|
-      # Establish mappings
-      blueprint = resource_type.consumes.find do |bp|
-        bp[:capability] == cns.type
-      end
-      # @todo lutter 2015-08-03: catch this earlier, can we do this during
-      # static analysis ?
-      raise _("Resource %{res} tries to consume %{cns} but no 'consumes' mapping exists for %{resource_type} and %{cns_type}") % { res: self, cns: cns, resource_type: self.resource_type, cns_type: cns.type } unless blueprint
-
-      # setup scope that has, for each attr of cns, a binding to cns[attr]
-      scope.with_global_scope do |global_scope|
-        cns_scope = global_scope.newscope(:source => self, :resource => self)
-        cns.to_hash.each { |name, value| cns_scope[name.to_s] = value }
-
-        # evaluate mappings in that scope
-        resource_type.arguments.keys.each do |name|
-          expr = blueprint[:mappings][name]
-          if expr
-            # Explicit mapping
-            value = expr.safeevaluate(cns_scope)
-          else
-            value = cns[name]
-          end
-          unless value.nil?
-            # @todo lutter 2015-07-01: this should be caught by the checker
-            # much earlier. We consume several capres, at least two of which
-            # want to map to the same parameter (PUP-5080)
-            raise _("Attempt to reassign attribute '%{name}' in '%{resource}' caused by multiple consumed mappings to the same attribute") % { name: name, resource: self } if map[name]
-            map[name] = value
-          end
-        end
-      end
-    end
-
-    map.each { |name, value| self[name] = value if self[name].nil? }
-  end
-
   def offset
     nil
   end

data/lib/puppet/parser/scope.rb

@@ -1,4 +1,3 @@
-# frozen_string_literal: true
 # The scope class, which handles storing and retrieving variables and types and
 # such.
 require 'forwardable'

data/lib/puppet/parser/templatewrapper.rb

@@ -1,4 +1,3 @@
-# frozen_string_literal: true
 require 'puppet/parser/files'
 require 'erb'
 require 'puppet/file_system'
@@ -51,7 +50,7 @@ class Puppet::Parser::TemplateWrapper
   # @return [Array<String>] The tags defined in the current scope
   # @api public
   def tags
-    raise NotImplementedError, "Call 'all_tags' instead."
+    scope.tags
   end
 
   # @return [Array<String>] All the defined tags

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

@@ -219,15 +219,16 @@ class Closure < CallableSignature
   def call_with_scope(scope, args)
     variable_bindings = combine_values_with_parameters(scope, args)
 
-    final_args = parameters.reduce([]) do |tmp_args, param|
+    tc = Types::TypeCalculator.singleton
+    final_args = tc.infer_set(parameters.reduce([]) do |tmp_args, param|
       if param.captures_rest
         tmp_args.concat(variable_bindings[param.name])
       else
         tmp_args << variable_bindings[param.name]
       end
-    end
+    end)
 
-    if type.callable_with?(final_args, block_type)
+    if type.callable?(final_args)
       result = catch(:next) do
         @evaluator.evaluate_block_with_bindings(scope, variable_bindings, @model.body)
       end
@@ -235,9 +236,7 @@ class Closure < CallableSignature
         "value returned from #{closure_name}"
       end
     else
-      tc = Types::TypeCalculator.singleton
-      args_type = tc.infer_set(final_args)
-      raise ArgumentError, Types::TypeMismatchDescriber.describe_signatures(closure_name, [self], args_type)
+      raise ArgumentError, Types::TypeMismatchDescriber.describe_signatures(closure_name, [self], final_args)
     end
   end
 
@@ -310,7 +309,6 @@ class Closure < CallableSignature
       to += param_range[1]
     end
     param_types = Types::PTupleType.new(types, Types::PIntegerType.new(from, to))
-    # The block_type for a Closure is always nil for now, see comment in block_name above
     Types::PCallableType.new(param_types, nil, return_type)
   end
 

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

@@ -16,12 +16,10 @@ class DeferredResolver
   #
   # @param facts [Puppet::Node::Facts] the facts object for the node
   # @param catalog [Puppet::Resource::Catalog] the catalog where all deferred values should be replaced
-  # @param environment [Puppet::Node::Environment] the environment whose anonymous module methods
-  #  are to be mixed into the scope
   # @return [nil] does not return anything - the catalog is modified as a side effect
   #
-  def self.resolve_and_replace(facts, catalog, environment = catalog.environment_instance)
-    compiler = Puppet::Parser::ScriptCompiler.new(environment, catalog.name, true)
+  def self.resolve_and_replace(facts, catalog)
+    compiler = Puppet::Parser::ScriptCompiler.new(catalog.environment_instance, catalog.name, true)
     resolver = new(compiler)
     resolver.set_facts_variable(facts)
     # TODO:
@@ -110,7 +108,7 @@ class DeferredResolver
     # If any of the arguments to a future is a future it needs to be resolved first
     func_name = f.name
     mapped_arguments = map_arguments(f.arguments)
-    # if name starts with $ then this is a call to dig
+    # if name starts with $ then this is a call to dig 
     if func_name[0] == DOLLAR
       var_name = func_name[1..-1]
       func_name = DIG

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

@@ -1040,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_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
 
@@ -40,7 +40,6 @@ module Runtime3ResourceSupport
           :parameters => evaluated_parameters,
           :file => file,
           :line => line,
-          :kind => Puppet::Resource.to_kind(resolved_type),
           :exported => exported,
           :virtual => virtual,
           # WTF is this? Which source is this? The file? The name of the context ?
@@ -110,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/lookup/lookup_adapter.rb

@@ -292,8 +292,7 @@ class LookupAdapter < DataAdapter
   PROVIDER_STACK = [:lookup_global, :lookup_in_environment, :lookup_in_module].freeze
 
   def validate_lookup_options(options, module_name)
-    return nil if options.nil?
-    raise Puppet::DataBinding::LookupError.new(_("value of %{opts} must be a hash") % { opts: LOOKUP_OPTIONS }) unless options.is_a?(Hash)
+    raise Puppet::DataBinding::LookupError.new(_("value of %{opts} must be a hash") % { opts: LOOKUP_OPTIONS }) unless options.is_a?(Hash) unless options.nil?
     return options if module_name.nil?
 
     pfx = "#{module_name}::"
@@ -353,7 +352,7 @@ class LookupAdapter < DataAdapter
               module_opts = validate_lookup_options(lookup_in_module(LookupKey::LOOKUP_OPTIONS, meta_invocation, merge_strategy), module_name)
               opts = if opts.nil?
                 module_opts
-              elsif module_opts
+              else
                 merge_strategy.lookup([GLOBAL_ENV_MERGE, "Module #{lookup_invocation.module_name}"], meta_invocation) do |n|
                   meta_invocation.with(:scope, n) { meta_invocation.report_found(LOOKUP_OPTIONS,  n == GLOBAL_ENV_MERGE ? opts : module_opts) }
                 end

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

@@ -1,4 +1,3 @@
-# frozen_string_literal: true
 # # Generated by Puppet::Pops::Types::RubyGenerator from TypeSet Puppet::AST on -4712-01-01
 
 module Puppet
@@ -2056,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', {
@@ -2467,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', {
@@ -4285,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', {
@@ -4896,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,
@@ -4937,7 +4647,6 @@ def self.register_pcore_types
   Model::ResourceBody,
   Model::AbstractResource,
   Model::ResourceExpression,
-  Model::CapabilityMapping,
   Model::ResourceDefaultsExpression,
   Model::ResourceOverrideExpression,
   Model::SelectorEntry,