puppet 6.0.5-x64-mingw32 → 8.8.1-x64-mingw32

data/lib/puppet/pops/validation/checker4_0.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/pops/evaluator/external_syntax_support'
+
 module Puppet::Pops
 module Validation
 # A Validator validates a model.
@@ -12,6 +16,8 @@ module Validation
 #       This is however mostly valuable when validating model to model transformations, and is therefore T.B.D
 #
 class Checker4_0 < Evaluator::LiteralEvaluator
+  include Puppet::Pops::Evaluator::ExternalSyntaxSupport
+
   attr_reader :acceptor
   attr_reader :migration_checker
 
@@ -88,12 +94,12 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     o = container(idx)
     idx -= 1
     case o
-    when NilClass, Model::HostClassDefinition, Model::Program
+    when NilClass, Model::ApplyExpression, Model::HostClassDefinition, Model::Program
       # ok, stop scanning parents
     when Model::BlockExpression
       c = container(idx)
       if !c.is_a?(Model::Program) &&
-        (definition.is_a?(Model::FunctionDefinition) || definition.is_a?(Model::TypeAlias) || definition.is_a?(Model::TypeDefinition))
+         (definition.is_a?(Model::FunctionDefinition) || definition.is_a?(Model::TypeAlias) || definition.is_a?(Model::TypeDefinition))
 
         # not ok. These can never be nested in a block
         acceptor.accept(Issues::NOT_ABSOLUTE_TOP_LEVEL, definition)
@@ -167,7 +173,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   end
 
   def assign_LiteralList(o, via_index)
-    o.values.each {|x| assign(x) }
+    o.values.each { |x| assign(x) }
   end
 
   def assign_Object(o, via_index)
@@ -200,9 +206,9 @@ class Checker4_0 < Evaluator::LiteralEvaluator
       assign(o.left_expr)
       rvalue(o.right_expr)
     when '+=', '-='
-      acceptor.accept(Issues::APPENDS_DELETES_NO_LONGER_SUPPORTED, o, {:operator => o.operator})
+      acceptor.accept(Issues::APPENDS_DELETES_NO_LONGER_SUPPORTED, o, { :operator => o.operator })
     else
-      acceptor.accept(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
+      acceptor.accept(Issues::UNSUPPORTED_OPERATOR, o, { :operator => o.operator })
     end
   end
 
@@ -219,7 +225,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
       # Append operator use is constrained
       p = container
       unless p.is_a?(Model::CollectExpression) || p.is_a?(Model::ResourceOverrideExpression)
-        acceptor.accept(Issues::ILLEGAL_ATTRIBUTE_APPEND, o, {:name=>o.attribute_name, :parent=>p})
+        acceptor.accept(Issues::ILLEGAL_ATTRIBUTE_APPEND, o, { :name => o.attribute_name, :parent => p })
       end
     end
     rvalue(o.value_expr)
@@ -230,15 +236,15 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     p = container
     case p
     when Model::AbstractResource
+      # do nothing
     when Model::CollectExpression
-    when Model::CapabilityMapping
-      acceptor.accept(Issues::UNSUPPORTED_OPERATOR_IN_CONTEXT, p, :operator=>'* =>')
+      # do nothing
     else
       # protect against just testing a snippet that has no parent, error message will be a bit strange
       # but it is not for a real program.
       parent2 = p.nil? ? o : container(-2)
       unless parent2.is_a?(Model::AbstractResource)
-        acceptor.accept(Issues::UNSUPPORTED_OPERATOR_IN_CONTEXT, parent2, :operator=>'* =>')
+        acceptor.accept(Issues::UNSUPPORTED_OPERATOR_IN_CONTEXT, parent2, :operator => '* =>')
       end
     end
     rvalue(o.expr)
@@ -274,10 +280,11 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   def check_CallNamedFunctionExpression(o)
     functor = o.functor_expr
     if functor.is_a?(Model::QualifiedReference) ||
-      functor.is_a?(Model::AccessExpression) && functor.left_expr.is_a?(Model::QualifiedReference)
+       functor.is_a?(Model::AccessExpression) && functor.left_expr.is_a?(Model::QualifiedReference)
       # ok (a call to a type)
       return nil
     end
+
     case functor
     when Model::QualifiedName
       # ok
@@ -286,33 +293,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
       # helpful to point out this easy to make Epp error
       acceptor.accept(Issues::ILLEGAL_EPP_PARAMETERS, o)
     else
-      acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
-    end
-  end
-
-  def check_CapabilityMapping(o)
-    ok =
-    case o.component
-    when Model::QualifiedReference
-      name = o.component.cased_value
-      acceptor.accept(Issues::ILLEGAL_CLASSREF, o.component, {:name=>name}) unless name =~ Patterns::CLASSREF_EXT
-      true
-    when Model::AccessExpression
-      keys = o.component.keys
-      expr = o.component.left_expr
-      if expr.is_a?(Model::QualifiedReference) && keys.size == 1
-        key = keys[0]
-        key.is_a?(Model::LiteralString) || key.is_a?(Model::QualifiedName) || key.is_a?(Model::QualifiedReference)
-      else
-        false
-      end
-    else
-      false
-    end
-    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.component, :feature=>'capability mapping', :container => o) unless ok
-
-    if o.capability !~ Patterns::CLASSREF_EXT
-      acceptor.accept(Issues::ILLEGAL_CLASSREF, o, {:name=>o.capability})
+      acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.functor_expr, { :feature => 'function name', :container => o })
     end
   end
 
@@ -324,6 +305,14 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     end
   end
 
+  def check_HeredocExpression(o)
+    # Only syntax check static text in heredoc during validation - dynamic text is validated by the evaluator.
+    expr = o.text_expr
+    if expr.is_a?(Model::LiteralString)
+      assert_external_syntax(nil, expr.value, o.syntax, o.text_expr)
+    end
+  end
+
   def check_MethodCallExpression(o)
     unless o.functor_expr.is_a? Model::QualifiedName
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.functor_expr, :feature => 'function name', :container => o)
@@ -336,11 +325,11 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     found_default = false
     o.options.each do |option|
       option.values.each do |value|
-        if value.is_a?(Model::LiteralDefault)
-          # Flag the second default as 'unreachable'
-          acceptor.accept(Issues::DUPLICATE_DEFAULT, value, :container => o) if found_default
-          found_default = true
-        end
+        next unless value.is_a?(Model::LiteralDefault)
+
+        # Flag the second default as 'unreachable'
+        acceptor.accept(Issues::DUPLICATE_DEFAULT, value, :container => o) if found_default
+        found_default = true
       end
     end
   end
@@ -351,7 +340,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
 
   def check_CollectExpression(o)
     unless o.type_expr.is_a? Model::QualifiedReference
-      acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.type_expr, :feature=> 'type name', :container => o)
+      acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.type_expr, :feature => 'type name', :container => o)
     end
   end
 
@@ -360,7 +349,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   def check_NamedAccessExpression(o)
     name = o.right_expr
     unless name.is_a? Model::QualifiedName
-      acceptor.accept(Issues::ILLEGAL_EXPRESSION, name, :feature=> 'function name', :container => container)
+      acceptor.accept(Issues::ILLEGAL_EXPRESSION, name, :feature => 'function name', :container => container)
     end
   end
 
@@ -384,6 +373,15 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     'regexp' => true,
     'pattern' => true,
     'runtime' => true,
+    'init' => true,
+    'object' => true,
+    'sensitive' => true,
+    'semver' => true,
+    'semverrange' => true,
+    'string' => true,
+    'timestamp' => true,
+    'timespan' => true,
+    'typeset' => true,
   }
 
   FUTURE_RESERVED_WORDS = {
@@ -394,7 +392,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   def check_NamedDefinition(o)
     top(o)
     if o.name !~ Patterns::CLASSREF_DECL
-      acceptor.accept(Issues::ILLEGAL_DEFINITION_NAME, o, {:name=>o.name})
+      acceptor.accept(Issues::ILLEGAL_DEFINITION_NAME, o, { :name => o.name })
     end
 
     internal_check_file_namespace(o)
@@ -405,7 +403,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   def check_TypeAlias(o)
     top(o)
     if o.name !~ Patterns::CLASSREF_EXT_DECL
-      acceptor.accept(Issues::ILLEGAL_DEFINITION_NAME, o, {:name=>o.name})
+      acceptor.accept(Issues::ILLEGAL_DEFINITION_NAME, o, { :name => o.name })
     end
     internal_check_reserved_type_name(o, o.name)
     internal_check_type_ref(o, o.type_expr)
@@ -474,6 +472,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     internal_check_parameter_name_uniqueness(o)
     internal_check_reserved_params(o)
     internal_check_no_idem_last(o)
+    internal_check_parameter_type_literal(o)
   end
 
   def check_ResourceTypeDefinition(o)
@@ -484,6 +483,18 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     internal_check_no_idem_last(o)
   end
 
+  def internal_check_parameter_type_literal(o)
+    o.parameters.each do |p|
+      next unless p.type_expr
+
+      type = nil
+      catch :not_literal do
+        type = literal(p.type_expr)
+      end
+      acceptor.accept(Issues::ILLEGAL_NONLITERAL_PARAMETER_TYPE, p, { name: p.name, type_class: p.type_expr.class }) if type.nil?
+    end
+  end
+
   def internal_check_return_type(o)
     r = o.return_type
     internal_check_type_ref(o, r) unless r.nil?
@@ -499,16 +510,17 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   end
 
   def internal_check_no_idem_last(o)
-    if violator = ends_with_idem(o.body)
-      acceptor.accept(Issues::IDEM_NOT_ALLOWED_LAST, violator, {:container => o}) unless resource_without_title?(violator)
+    violator = ends_with_idem(o.body)
+    if violator
+      acceptor.accept(Issues::IDEM_NOT_ALLOWED_LAST, violator, { :container => o }) unless resource_without_title?(violator)
     end
   end
 
   def internal_check_capture_last(o)
-    accepted_index = o.parameters.size() -1
+    accepted_index = o.parameters.size() - 1
     o.parameters.each_with_index do |p, index|
       if p.captures_rest && index != accepted_index
-        acceptor.accept(Issues::CAPTURES_REST_NOT_LAST, p, {:param_name => p.name})
+        acceptor.accept(Issues::CAPTURES_REST_NOT_LAST, p, { :param_name => p.name })
       end
     end
   end
@@ -516,20 +528,20 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   def internal_check_no_capture(o, container = o)
     o.parameters.each do |p|
       if p.captures_rest
-        acceptor.accept(Issues::CAPTURES_REST_NOT_SUPPORTED, p, {:container => container, :param_name => p.name})
+        acceptor.accept(Issues::CAPTURES_REST_NOT_SUPPORTED, p, { :container => container, :param_name => p.name })
       end
     end
   end
 
   def internal_check_reserved_type_name(o, name)
     if RESERVED_TYPE_NAMES[name]
-      acceptor.accept(Issues::RESERVED_TYPE_NAME, o, {:name => name})
+      acceptor.accept(Issues::RESERVED_TYPE_NAME, o, { :name => name })
     end
   end
 
   def internal_check_future_reserved_word(o, name)
     if FUTURE_RESERVED_WORDS[name]
-      acceptor.accept(Issues::FUTURE_RESERVED_WORD, o, {:word => name})
+      acceptor.accept(Issues::FUTURE_RESERVED_WORD, o, { :word => name })
     end
   end
 
@@ -539,29 +551,29 @@ class Checker4_0 < Evaluator::LiteralEvaluator
 
   def internal_check_file_namespace(o)
     file = o.locator.file
-    return if file.nil? || file == '' #e.g. puppet apply -e '...'
+    return if file.nil? || file == '' # e.g. puppet apply -e '...'
 
     file_namespace = namespace_for_file(file)
     return if file_namespace == NO_NAMESPACE
 
     # Downcasing here because check is case-insensitive
     if file_namespace == BAD_MODULE_FILE || !o.name.downcase.start_with?(file_namespace)
-      acceptor.accept(Issues::ILLEGAL_DEFINITION_LOCATION, o, {:name => o.name, :file => file})
+      acceptor.accept(Issues::ILLEGAL_DEFINITION_LOCATION, o, { :name => o.name, :file => file })
     end
   end
 
   def internal_check_top_construct_in_module(prog)
     return unless prog.is_a?(Model::Program) && !prog.body.nil?
 
-    #Check that this is a module autoloaded file
+    # Check that this is a module autoloaded file
     file = prog.locator.file
     return if file.nil?
     return if namespace_for_file(file) == NO_NAMESPACE
 
     body = prog.body
-    return if prog.body.is_a?(Model::Nop) #Ignore empty or comment-only files
+    return if prog.body.is_a?(Model::Nop) # Ignore empty or comment-only files
 
-    if(body.is_a?(Model::BlockExpression))
+    if body.is_a?(Model::BlockExpression)
       body.statements.each { |s| acceptor.accept(Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION, s) unless valid_top_construct?(s) }
     else
       acceptor.accept(Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION, body) unless valid_top_construct?(body)
@@ -575,36 +587,40 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   # @api private
   class Puppet::Util::FileNamespaceAdapter < Puppet::Pops::Adaptable::Adapter
     attr_accessor :file_to_namespace
+
+    def self.create_adapter(env)
+      adapter = super(env)
+      adapter.file_to_namespace = {}
+      adapter
+    end
   end
 
   def namespace_for_file(file)
     env = Puppet.lookup(:current_environment)
     return NO_NAMESPACE if env.nil?
 
-    Puppet::Util::FileNamespaceAdapter.adapt(env) do |adapter|
-      adapter.file_to_namespace ||= {}
+    adapter = Puppet::Util::FileNamespaceAdapter.adapt(env)
 
-      file_namespace = adapter.file_to_namespace[file]
-      return file_namespace unless file_namespace.nil? # No cache entry, so we do the calculation
+    file_namespace = adapter.file_to_namespace[file]
+    return file_namespace unless file_namespace.nil? # No cache entry, so we do the calculation
 
-      path = Pathname.new(file)
+    path = Pathname.new(file)
 
-      return adapter.file_to_namespace[file] = NO_NAMESPACE if path.extname != ".pp"
+    return adapter.file_to_namespace[file] = NO_NAMESPACE if path.extname != ".pp"
 
-      path = path.expand_path
+    path = path.expand_path
 
-      return adapter.file_to_namespace[file] = NO_NAMESPACE if initial_manifest?(path, env.manifest)
+    return adapter.file_to_namespace[file] = NO_NAMESPACE if initial_manifest?(path, env.manifest)
 
-      #All auto-loaded files from modules come from a module search path dir
-      relative_path = get_module_relative_path(path, env.full_modulepath)
+    # All auto-loaded files from modules come from a module search path dir
+    relative_path = get_module_relative_path(path, env.full_modulepath)
 
-      return adapter.file_to_namespace[file] = NO_NAMESPACE if relative_path == NO_PATH
+    return adapter.file_to_namespace[file] = NO_NAMESPACE if relative_path == NO_PATH
 
-      #If a file comes from a module, but isn't in the right place, always error
-      names = dir_to_names(relative_path)
+    # If a file comes from a module, but isn't in the right place, always error
+    names = dir_to_names(relative_path)
 
-      return adapter.file_to_namespace[file] = (names == BAD_MODULE_FILE ? BAD_MODULE_FILE : names.join("::").freeze)
-    end
+    adapter.file_to_namespace[file] = (names == BAD_MODULE_FILE ? BAD_MODULE_FILE : names.join("::").freeze)
   end
 
   def initial_manifest?(path, manifest_setting)
@@ -615,20 +631,25 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     string_path == manifest_setting || string_path.start_with?(manifest_setting)
   end
 
+  # Get the path of +file_path+ relative to the first directory in
+  # +modulepath_directories+ that is an ancestor of +file_path+. Return NO_PATH
+  # if none is found.
   def get_module_relative_path(file_path, modulepath_directories)
-    clean_file = file_path.cleanpath
-    parent_path = modulepath_directories.find { |path_dir| is_parent_dir_of(path_dir, clean_file) }
+    clean_file = file_path.cleanpath.to_s
+    parent_path = modulepath_directories.find { |path_dir| is_parent_dir_of?(path_dir, clean_file) }
     return NO_PATH if parent_path.nil?
 
     file_path.relative_path_from(Pathname.new(parent_path))
   end
+  private :get_module_relative_path
 
-  def is_parent_dir_of(parent_dir, child_dir)
+  def is_parent_dir_of?(parent_dir, child_dir)
     parent_dir_path = Pathname.new(parent_dir)
     clean_parent = parent_dir_path.cleanpath.to_s + File::SEPARATOR
 
-    return child_dir.to_s.start_with?(clean_parent)
+    child_dir.start_with?(clean_parent)
   end
+  private :is_parent_dir_of?
 
   def dir_to_names(relative_path)
     # Downcasing here because check is case-insensitive
@@ -643,14 +664,14 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     # and from the manifests dir there.  This may never get used...
     return BAD_MODULE_FILE unless dir == 'manifests' || dir == 'functions' || dir == 'types' || dir == 'plans'
 
-    names = path_components[2 .. -2] # Directories inside module
+    names = path_components[2..-2] # Directories inside module
     names.unshift(path_components[0]) # Name of the module itself
 
     # Do not include name of module init file at top level of module
     # e.g. <module name>/manifests/init.pp
     filename = path_components[-1]
-    if !(path_components.length == 3 && filename == 'init.pp')
-      names.push(filename[0 .. -4]) # Remove .pp from filename
+    unless path_components.length == 3 && filename == 'init.pp'
+      names.push(filename[0..-4]) # Remove .pp from filename
     end
 
     names
@@ -664,7 +685,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   def internal_check_reserved_params(o)
     o.parameters.each do |p|
       if RESERVED_PARAMETERS[p.name]
-        acceptor.accept(Issues::RESERVED_PARAMETER, p, {:container => o, :param_name => p.name})
+        acceptor.accept(Issues::RESERVED_PARAMETER, p, { :container => o, :param_name => p.name })
       end
     end
   end
@@ -672,7 +693,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   def internal_check_parameter_name_uniqueness(o)
     unique = Set.new
     o.parameters.each do |p|
-      acceptor.accept(Issues::DUPLICATE_PARAMETER, p, {:param_name => p.name}) unless unique.add?(p.name)
+      acceptor.accept(Issues::DUPLICATE_PARAMETER, p, { :param_name => p.name }) unless unique.add?(p.name)
     end
   end
 
@@ -693,13 +714,13 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   end
 
   def check_LiteralList(o)
-    o.values.each {|v| rvalue(v) }
+    o.values.each { |v| rvalue(v) }
   end
 
   def check_LiteralInteger(o)
     v = o.value
     if v < MIN_INTEGER || v > MAX_INTEGER
-      acceptor.accept(Issues::NUMERIC_OVERFLOW, o, {:value => v})
+      acceptor.accept(Issues::NUMERIC_OVERFLOW, o, { :value => v })
     end
   end
 
@@ -709,7 +730,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     o.entries.each do |entry|
       catch(:not_literal) do
         literal_key = literal(entry.key)
-        acceptor.accept(Issues::DUPLICATE_KEY, entry, {:key => literal_key}) if unique.add?(literal_key).nil?
+        acceptor.accept(Issues::DUPLICATE_KEY, entry, { :key => literal_key }) if unique.add?(literal_key).nil?
       end
     end
   end
@@ -718,8 +739,9 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     # Check that hostnames are valid hostnames (or regular expressions)
     hostname(o.host_matches, o)
     top(o)
-    if violator = ends_with_idem(o.body)
-      acceptor.accept(Issues::IDEM_NOT_ALLOWED_LAST, violator, {:container => o}) unless resource_without_title?(violator)
+    violator = ends_with_idem(o.body)
+    if violator
+      acceptor.accept(Issues::IDEM_NOT_ALLOWED_LAST, violator, { :container => o }) unless resource_without_title?(violator)
     end
     unless o.parent.nil?
       acceptor.accept(Issues::ILLEGAL_NODE_INHERITANCE, o.parent)
@@ -739,12 +761,12 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   def check_QualifiedReference(o)
     # Is this a valid qualified name?
     if o.cased_value !~ Patterns::CLASSREF_EXT
-      acceptor.accept(Issues::ILLEGAL_CLASSREF, o, {:name=>o.cased_value})
+      acceptor.accept(Issues::ILLEGAL_CLASSREF, o, { :name => o.cased_value })
     end
   end
 
   def check_QueryExpression(o)
-    query(o.expr) if o.expr  # is optional
+    query(o.expr) if o.expr # is optional
   end
 
   def relation_Object(o)
@@ -774,11 +796,11 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     else
       # recursively check all contents unless it's a lambda expression. A lambda may contain
       # local assignments
-      o._pcore_contents {|model| internal_check_illegal_assignment(model) } unless o.is_a?(Model::LambdaExpression)
+      o._pcore_contents { |model| internal_check_illegal_assignment(model) } unless o.is_a?(Model::LambdaExpression)
     end
   end
 
-  #relationship_side: resource
+  # relationship_side: resource
   #  | resourceref
   #  | collection
   #  | variable
@@ -839,7 +861,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   def check_SelectorExpression(o)
     rvalue(o.left_expr)
     # There can only be one LiteralDefault case option value
-    defaults = o.selectors.select {|v| v.matching_expr.is_a?(Model::LiteralDefault) }
+    defaults = o.selectors.select { |v| v.matching_expr.is_a?(Model::LiteralDefault) }
     unless defaults.size <= 1
       # Flag the second default as 'unreachable'
       acceptor.accept(Issues::DUPLICATE_DEFAULT, defaults[1].matching_expr, :container => o)
@@ -864,12 +886,13 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     # The expression must be a qualified name or an integer
     name_expr = o.expr
     return if name_expr.is_a?(Model::LiteralInteger)
+
     if !name_expr.is_a?(Model::QualifiedName)
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, :feature => 'name', :container => o)
     else
       # name must be either a decimal string value, or a valid NAME
       name = o.expr.value
-      if name[0,1] =~ /[0-9]/
+      if name[0, 1] =~ /[0-9]/
         unless name =~ Patterns::NUMERIC_VAR_NAME
           acceptor.accept(Issues::ILLEGAL_NUMERIC_VAR_NAME, o, :name => name)
         end
@@ -885,7 +908,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
 
   # Transforms Array of host matching expressions into a (Ruby) array of AST::HostName
   def hostname_Array(o, semantic)
-    o.each {|x| hostname(x, semantic) }
+    o.each { |x| hostname(x, semantic) }
   end
 
   def hostname_String(o, semantic)
@@ -904,7 +927,8 @@ class Checker4_0 < Evaluator::LiteralEvaluator
 
   def hostname_ConcatenatedString(o, semantic)
     # Puppet 3.1. only accepts a concatenated string without interpolated expressions
-    if the_expr = o.segments.index {|s| s.is_a?(Model::TextExpression) }
+    the_expr = o.segments.index { |s| s.is_a?(Model::TextExpression) }
+    if the_expr
       acceptor.accept(Issues::ILLEGAL_HOSTNAME_INTERPOLATION, o.segments[the_expr].expr)
     elsif o.segments.size() != 1
       # corner case, bad model, concatenation of several plain strings
@@ -937,7 +961,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   end
 
   def hostname_Object(o, semantic)
-    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature => 'hostname', :container => semantic})
+    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, { :feature => 'hostname', :container => semantic })
   end
 
   #---QUERY CHECKS
@@ -1067,7 +1091,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
 
   def idem_BlockExpression(o)
     # productive if there is at least one productive expression
-    ! o.statements.any? {|expr| !idem(expr) }
+    !o.statements.any? { |expr| !idem(expr) }
   end
 
   # Returns true even though there may be interpolated expressions that have side effect.
@@ -1095,18 +1119,20 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   end
 
   def idem_IfExpression(o)
-    [o.test, o.then_expr, o.else_expr].all? {|e| idem(e) }
+    [o.test, o.then_expr, o.else_expr].all? { |e| idem(e) }
   end
 
   # Case expression is idem, if test, and all options are idem
   def idem_CaseExpression(o)
-    return false if !idem(o.test)
-    ! o.options.any? {|opt| !idem(opt) }
+    return false unless idem(o.test)
+
+    !o.options.any? { |opt| !idem(opt) }
   end
 
   # An option is idem if values and the then_expression are idem
   def idem_CaseOption(o)
     return false if o.values.any? { |value| !idem(value) }
+
     idem(o.then_expr)
   end
 

data/lib/puppet/pops/validation/tasks_checker.rb

@@ -1,26 +1,20 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Validation
-
 # Validator that limits the set of allowed expressions to not include catalog related operations
 # @api private
 class TasksChecker < Checker4_0
   def in_ApplyExpression?
     top = container(0)
     step = -1
-    until container(step) == top do
+    until container(step) == top
       return true if container(step).is_a? Puppet::Pops::Model::ApplyBlockExpression
+
       step -= 1
     end
   end
 
-  def check_Application(o)
-    illegalTasksExpression(o)
-  end
-
-  def check_CapabilityMapping(o)
-    illegalTasksExpression(o)
-  end
-
   def check_CollectExpression(o)
     # Only virtual resource queries are allowed in apply blocks, not exported
     # resource queries
@@ -28,7 +22,7 @@ class TasksChecker < Checker4_0
       if o.query.is_a?(Puppet::Pops::Model::VirtualQuery)
         super(o)
       else
-        acceptor.accept(Issues::EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING, o, {:klass => o})
+        acceptor.accept(Issues::EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING, o, { :klass => o })
       end
     else
       illegalTasksExpression(o)
@@ -40,7 +34,11 @@ class TasksChecker < Checker4_0
   end
 
   def check_NodeDefinition(o)
-    illegalTasksExpression(o)
+    if in_ApplyExpression?
+      super(o)
+    else
+      illegalTasksExpression(o)
+    end
   end
 
   def check_RelationshipExpression(o)
@@ -79,18 +77,14 @@ class TasksChecker < Checker4_0
     illegalTasksExpression(o)
   end
 
-  def check_SiteDefinition(o)
-    illegalTasksExpression(o)
-  end
-
   def check_ApplyExpression(o)
     if in_ApplyExpression?
-      acceptor.accept(Issues::EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING, o, {:klass => o})
+      acceptor.accept(Issues::EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING, o, { :klass => o })
     end
   end
 
   def illegalTasksExpression(o)
-    acceptor.accept(Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING, o, {:klass => o})
+    acceptor.accept(Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING, o, { :klass => o })
   end
 
   def resource_without_title?(o)

data/lib/puppet/pops/validation/validator_factory_4_0.rb

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Validation
 # Configures validation suitable for 4.0
 #
 class ValidatorFactory_4_0 < Factory
-  Issues = Issues
-
   # Produces the checker to use
   def checker diagnostic_producer
     if Puppet[:tasks]
@@ -35,7 +35,9 @@ class ValidatorFactory_4_0 < Factory
     p[Issues::DUPLICATE_KEY]                  = Puppet[:strict] == :off ? :ignore : Puppet[:strict]
     p[Issues::NAME_WITH_HYPHEN]               = :error
     p[Issues::EMPTY_RESOURCE_SPECIALIZATION]  = :ignore
-    p[Issues::CLASS_NOT_VIRTUALIZABLE]        = Puppet[:strict] == :off ? :warning : Puppet[:strict]
+    p[Issues::CLASS_NOT_VIRTUALIZABLE]        = :error
+
+    p[Issues::ILLEGAL_NONLITERAL_PARAMETER_TYPE] = :deprecation
     p
   end
 end