puppet 8.3.1-universal-darwin → 8.5.0-universal-darwin

data/lib/puppet/pops/types/type_mismatch_describer.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
   # @api private
@@ -89,7 +90,7 @@ module Types
   # @api private
   class SignaturePathElement < VariantPathElement
     def to_s
-      "#{key+1}."
+      "#{key + 1}."
     end
   end
 
@@ -127,6 +128,7 @@ module Types
 
     def chop_path(element_index)
       return self if element_index >= @path.size
+
       chopped_path = @path.clone
       chopped_path.delete_at(element_index)
       copy = self.clone
@@ -298,7 +300,7 @@ module Types
           e = "#{e[0]} or #{e[1]}"
           multi = true
         else
-          e = "#{e[0..e.size-2].join(', ')}, or #{e[e.size-1]}"
+          e = "#{e[0..e.size - 2].join(', ')}, or #{e[e.size - 1]}"
           multi = true
         end
       else
@@ -330,7 +332,7 @@ module Types
     def short_name(t)
       # Ensure that Optional, NotUndef, Sensitive, and Type are reported with included
       # type parameter.
-      if t.is_a?(PTypeWithContainedType) && !(t.type.nil? || t.type.class == PAnyType)
+      if t.is_a?(PTypeWithContainedType) && !(t.type.nil? || t.type.instance_of?(PAnyType))
         "#{t.name}[#{t.type.name}]"
       else
         t.name.nil? ? t.simple_name : t.name
@@ -365,7 +367,7 @@ module Types
       if e.is_a?(Array)
         e.any? { |t| always_fully_detailed?(t, a) }
       else
-        e.class == a.class || e.is_a?(PTypeAliasType) || a.is_a?(PTypeAliasType) || specialization(e, a)
+        e.instance_of?(a.class) || e.is_a?(PTypeAliasType) || a.is_a?(PTypeAliasType) || specialization(e, a)
       end
     end
 
@@ -482,10 +484,6 @@ module Types
 
   # @api private
   class CountMismatch < SizeMismatch
-    def initialize(path, expected, actual)
-      super(path, expected, actual)
-    end
-
     def message(variant, position)
       min = expected.from || 0
       max = expected.to || Float::INFINITY
@@ -513,7 +511,7 @@ module Types
     end
 
     def tense_deprecated
-      #TRANSLATORS TypeMismatchDescriber is a class name and 'tense' is a method name and should not be translated
+      # TRANSLATORS TypeMismatchDescriber is a class name and 'tense' is a method name and should not be translated
       message = _("Passing a 'tense' argument to the TypeMismatchDescriber is deprecated and ignored.")
       message += ' ' + _("Everything is now reported using present tense")
       Puppet.warn_once('deprecations', 'typemismatch#tense', message)
@@ -533,6 +531,7 @@ module Types
       errors = describe_struct_signature(params_struct, given_hash, missing_ok).flatten
       case errors.size
       when 0
+        # do nothing
       when 1
         raise Puppet::ParseError.new("#{subject}:#{errors[0].format}")
       else
@@ -573,6 +572,7 @@ module Types
         errors = describe(param_type, TypeCalculator.singleton.infer_set(value).generalize, [ParameterPathElement.new(param_name)])
         case errors.size
         when 0
+          # do nothing
         when 1
           raise Puppet::ParseError.new("#{subject}:#{errors[0].format}")
         else
@@ -583,10 +583,11 @@ module Types
     end
 
     def get_deferred_function_return_type(value)
-      func = Puppet.lookup(:loaders).private_environment_loader.
-               load(:function, value.name)
+      func = Puppet.lookup(:loaders).private_environment_loader
+                   .load(:function, value.name)
       dispatcher = func.class.dispatcher.find_matching_dispatcher(value.arguments)
       raise ArgumentError, "No matching arity found for #{func.class.name} with arguments #{value.arguments}" unless dispatcher
+
       dispatcher.type.return_type
     end
     private :get_deferred_function_return_type
@@ -601,7 +602,7 @@ module Types
     # @return [Array<Mismatch>] An array of found errors. An empty array indicates no errors.
     def describe_struct_signature(params_struct, param_hash, missing_ok = false)
       param_type_hash = params_struct.hashed_elements
-      result =  param_hash.each_key.reject { |name| param_type_hash.include?(name) }.map { |name| InvalidParameter.new(nil, name) }
+      result = param_hash.each_key.reject { |name| param_type_hash.include?(name) }.map { |name| InvalidParameter.new(nil, name) }
 
       params_struct.elements.each do |elem|
         name = elem.name
@@ -613,7 +614,7 @@ module Types
               result << describe(value_type, df_return_type, [ParameterPathElement.new(name)]) unless value_type.generalize.assignable?(df_return_type.generalize)
             else
               warning_text = _("Deferred function %{function_name} has no return_type, unable to guarantee value type during compilation.") %
-                             {function_name: value.name }
+                             { function_name: value.name }
               Puppet.warn_once('deprecations',
                                "#{value.name}_deferred_warning",
                                warning_text)
@@ -676,9 +677,10 @@ module Types
       params_tuple = signature.type.param_types
       params_size_t = params_tuple.size_type || TypeFactory.range(*params_tuple.size_range)
 
-      if args_tuple.is_a?(PTupleType)
+      case args_tuple
+      when PTupleType
         arg_types = args_tuple.types
-      elsif args_tuple.is_a?(PArrayType)
+      when PArrayType
         arg_types = Array.new(params_tuple.types.size, args_tuple.element_type || PUndefType::DEFAULT)
       else
         return [TypeMismatch.new(path, params_tuple, args_tuple)]
@@ -705,13 +707,11 @@ module Types
           # Check that the block is of the right type
           describe(param_block_t, arg_block_t, path + [BlockPathElement.new])
         end
-      else
+      elsif param_block_t.nil? || param_block_t.assignable?(PUndefType::DEFAULT)
         # Check that the block is optional
-        if param_block_t.nil? || param_block_t.assignable?(PUndefType::DEFAULT)
-          EMPTY_ARRAY
-        else
-          [MissingRequiredBlock.new(path)]
-        end
+        EMPTY_ARRAY
+      else
+        [MissingRequiredBlock.new(path)]
       end
     end
 
@@ -741,6 +741,7 @@ module Types
       types.each_with_index do |vt, index|
         d = describe(vt, actual, path + [VariantPathElement.new(index)])
         return EMPTY_ARRAY if d.empty?
+
         variant_descriptions << d
       end
       descriptions = merge_descriptions(path.length, SizeMismatch, variant_descriptions)
@@ -761,6 +762,7 @@ module Types
           # If they all have the same canonical path, then we can compact this into one
           generic_mismatch = mismatches.inject do |prev, curr|
             break nil unless prev.canonical_path == curr.canonical_path
+
             prev.merge(prev.path, curr)
           end
           unless generic_mismatch.nil?
@@ -776,6 +778,7 @@ module Types
 
     def describe_POptionalType(expected, original, actual, path)
       return EMPTY_ARRAY if actual.is_a?(PUndefType) || expected.optional_type.nil?
+
       internal_describe(expected.optional_type, original.is_a?(PTypeAliasType) ? original : expected, actual, path)
     end
 
@@ -794,7 +797,8 @@ module Types
     def describe_PArrayType(expected, original, actual, path)
       descriptions = []
       element_type = expected.element_type || PAnyType::DEFAULT
-      if actual.is_a?(PTupleType)
+      case actual
+      when PTupleType
         types = actual.types
         expected_size = expected.size_type || PCollectionType::DEFAULT_SIZE
         actual_size = actual.size_type || PIntegerType.new(types.size, types.size)
@@ -805,7 +809,7 @@ module Types
         else
           descriptions << SizeMismatch.new(path, expected_size, actual_size)
         end
-      elsif actual.is_a?(PArrayType)
+      when PArrayType
         expected_size = expected.size_type
         actual_size = actual.size_type || PCollectionType::DEFAULT_SIZE
         if expected_size.nil? || expected_size.assignable?(actual_size)
@@ -823,7 +827,8 @@ module Types
       descriptions = []
       key_type = expected.key_type || PAnyType::DEFAULT
       value_type = expected.value_type || PAnyType::DEFAULT
-      if actual.is_a?(PStructType)
+      case actual
+      when PStructType
         elements = actual.elements
         expected_size = expected.size_type || PCollectionType::DEFAULT_SIZE
         actual_size = PIntegerType.new(elements.count { |a| !a.key_type.assignable?(PUndefType::DEFAULT) }, elements.size)
@@ -835,7 +840,7 @@ module Types
         else
           descriptions << SizeMismatch.new(path, expected_size, actual_size)
         end
-      elsif actual.is_a?(PHashType)
+      when PHashType
         expected_size = expected.size_type
         actual_size = actual.size_type || PCollectionType::DEFAULT_SIZE
         if expected_size.nil? || expected_size.assignable?(actual_size)
@@ -852,7 +857,8 @@ module Types
     def describe_PStructType(expected, original, actual, path)
       elements = expected.elements
       descriptions = []
-      if actual.is_a?(PStructType)
+      case actual
+      when PStructType
         h2 = actual.hashed_elements.clone
         elements.each do |e1|
           key = e1.name
@@ -865,7 +871,7 @@ module Types
           end
         end
         h2.each_key { |key| descriptions << ExtraneousKey.new(path, key) }
-      elsif actual.is_a?(PHashType)
+      when PHashType
         actual_size = actual.size_type || PCollectionType::DEFAULT_SIZE
         expected_size = PIntegerType.new(elements.count { |e| !e.key_type.assignable?(PUndefType::DEFAULT) }, elements.size)
         if expected_size.assignable?(actual_size)
@@ -889,9 +895,11 @@ module Types
 
     def describe_tuple(expected, original, actual, path, size_mismatch_class)
       return EMPTY_ARRAY if expected == actual || expected.types.empty? && (actual.is_a?(PArrayType))
+
       expected_size = expected.size_type || TypeFactory.range(*expected.size_range)
 
-      if actual.is_a?(PTupleType)
+      case actual
+      when PTupleType
         actual_size = actual.size_type || TypeFactory.range(*actual.size_range)
 
         # not assignable if the number of types in actual is outside number of types in expected
@@ -908,7 +916,7 @@ module Types
         else
           [size_mismatch_class.new(path, expected_size, actual_size)]
         end
-      elsif actual.is_a?(PArrayType)
+      when PArrayType
         t2_entry = actual.element_type
 
         if t2_entry.nil?

data/lib/puppet/pops/types/type_parser.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/concurrent/thread_local_singleton'
 
 # This class provides parsing of Type Specification from a string into the Type
@@ -39,6 +40,7 @@ class TypeParser
     if t
       return t
     end
+
     model = @parser.parse_string(string)
     interpret(model.model.body, context)
   end
@@ -162,48 +164,48 @@ class TypeParser
   # @api private
   def self.type_map
     @type_map ||= {
-        'integer'      => TypeFactory.integer,
-        'float'        => TypeFactory.float,
-        'numeric'      => TypeFactory.numeric,
-        'init'         => TypeFactory.init,
-        'iterable'     => TypeFactory.iterable,
-        'iterator'     => TypeFactory.iterator,
-        'string'       => TypeFactory.string,
-        'binary'       => TypeFactory.binary,
-        'sensitive'    => TypeFactory.sensitive,
-        'enum'         => TypeFactory.enum,
-        'boolean'      => TypeFactory.boolean,
-        'pattern'      => TypeFactory.pattern,
-        'regexp'       => TypeFactory.regexp,
-        'array'        => TypeFactory.array_of_any,
-        'hash'         => TypeFactory.hash_of_any,
-        'class'        => TypeFactory.host_class,
-        'resource'     => TypeFactory.resource,
-        'collection'   => TypeFactory.collection,
-        'scalar'       => TypeFactory.scalar,
-        'scalardata'   => TypeFactory.scalar_data,
-        'catalogentry' => TypeFactory.catalog_entry,
-        'undef'        => TypeFactory.undef,
-        'notundef'     => TypeFactory.not_undef,
-        'default'      => TypeFactory.default,
-        'any'          => TypeFactory.any,
-        'variant'      => TypeFactory.variant,
-        'optional'     => TypeFactory.optional,
-        'runtime'      => TypeFactory.runtime,
-        'type'         => TypeFactory.type_type,
-        'tuple'        => TypeFactory.tuple,
-        'struct'       => TypeFactory.struct,
-        'object'       => TypeFactory.object,
-        'typealias'    => TypeFactory.type_alias,
-        'typereference' => TypeFactory.type_reference,
-        'typeset'      => TypeFactory.type_set,
-         # A generic callable as opposed to one that does not accept arguments
-        'callable'     => TypeFactory.all_callables,
-        'semver'       => TypeFactory.sem_ver,
-        'semverrange'  => TypeFactory.sem_ver_range,
-        'timestamp'    => TypeFactory.timestamp,
-        'timespan'     => TypeFactory.timespan,
-        'uri'          => TypeFactory.uri,
+      'integer' => TypeFactory.integer,
+      'float' => TypeFactory.float,
+      'numeric' => TypeFactory.numeric,
+      'init' => TypeFactory.init,
+      'iterable' => TypeFactory.iterable,
+      'iterator' => TypeFactory.iterator,
+      'string' => TypeFactory.string,
+      'binary' => TypeFactory.binary,
+      'sensitive' => TypeFactory.sensitive,
+      'enum' => TypeFactory.enum,
+      'boolean' => TypeFactory.boolean,
+      'pattern' => TypeFactory.pattern,
+      'regexp' => TypeFactory.regexp,
+      'array' => TypeFactory.array_of_any,
+      'hash' => TypeFactory.hash_of_any,
+      'class' => TypeFactory.host_class,
+      'resource' => TypeFactory.resource,
+      'collection' => TypeFactory.collection,
+      'scalar' => TypeFactory.scalar,
+      'scalardata' => TypeFactory.scalar_data,
+      'catalogentry' => TypeFactory.catalog_entry,
+      'undef' => TypeFactory.undef,
+      'notundef' => TypeFactory.not_undef,
+      'default' => TypeFactory.default,
+      'any' => TypeFactory.any,
+      'variant' => TypeFactory.variant,
+      'optional' => TypeFactory.optional,
+      'runtime' => TypeFactory.runtime,
+      'type' => TypeFactory.type_type,
+      'tuple' => TypeFactory.tuple,
+      'struct' => TypeFactory.struct,
+      'object' => TypeFactory.object,
+      'typealias' => TypeFactory.type_alias,
+      'typereference' => TypeFactory.type_reference,
+      'typeset' => TypeFactory.type_set,
+      # A generic callable as opposed to one that does not accept arguments
+      'callable' => TypeFactory.all_callables,
+      'semver' => TypeFactory.sem_ver,
+      'semverrange' => TypeFactory.sem_ver_range,
+      'timestamp' => TypeFactory.timestamp,
+      'timespan' => TypeFactory.timespan,
+      'uri' => TypeFactory.uri,
     }.freeze
   end
 
@@ -215,58 +217,58 @@ class TypeParser
     # back to the parser for evaluation).
     #
     @opt_type_map ||= {
-        'Integer'      => TypeFactory.integer,
-        'Float'        => TypeFactory.float,
-        'Numeric'      => TypeFactory.numeric,
+      'Integer' => TypeFactory.integer,
+      'Float' => TypeFactory.float,
+      'Numeric' => TypeFactory.numeric,
 
-        'String'       => TypeFactory.string,
-        'String[1]'    => TypeFactory.string(TypeFactory.range(1, :default)),
+      'String' => TypeFactory.string,
+      'String[1]' => TypeFactory.string(TypeFactory.range(1, :default)),
 
-        'Binary'       => TypeFactory.binary,
+      'Binary' => TypeFactory.binary,
 
-        'Boolean'      => TypeFactory.boolean,
-        'Boolean[true]'  => TypeFactory.boolean(true),
-        'Boolean[false]' => TypeFactory.boolean(false),
+      'Boolean' => TypeFactory.boolean,
+      'Boolean[true]' => TypeFactory.boolean(true),
+      'Boolean[false]' => TypeFactory.boolean(false),
 
-        'Array'        => TypeFactory.array_of_any,
-        'Array[1]'     => TypeFactory.array_of(TypeFactory.any, TypeFactory.range(1, :default)),
+      'Array' => TypeFactory.array_of_any,
+      'Array[1]' => TypeFactory.array_of(TypeFactory.any, TypeFactory.range(1, :default)),
 
-        'Hash'         => TypeFactory.hash_of_any,
-        'Collection'   => TypeFactory.collection,
-        'Scalar'       => TypeFactory.scalar,
+      'Hash' => TypeFactory.hash_of_any,
+      'Collection' => TypeFactory.collection,
+      'Scalar' => TypeFactory.scalar,
 
-        'Scalardata'   => TypeFactory.scalar_data,
-        'ScalarData'   => TypeFactory.scalar_data,
+      'Scalardata' => TypeFactory.scalar_data,
+      'ScalarData' => TypeFactory.scalar_data,
 
-        'Catalogentry' => TypeFactory.catalog_entry,
-        'CatalogEntry' => TypeFactory.catalog_entry,
+      'Catalogentry' => TypeFactory.catalog_entry,
+      'CatalogEntry' => TypeFactory.catalog_entry,
 
-        'Undef'        => TypeFactory.undef,
-        'Default'      => TypeFactory.default,
-        'Any'          => TypeFactory.any,
-        'Type'         => TypeFactory.type_type,
-        'Callable'     => TypeFactory.all_callables,
+      'Undef' => TypeFactory.undef,
+      'Default' => TypeFactory.default,
+      'Any' => TypeFactory.any,
+      'Type' => TypeFactory.type_type,
+      'Callable' => TypeFactory.all_callables,
 
-        'Semver'       => TypeFactory.sem_ver,
-        'SemVer'       => TypeFactory.sem_ver,
+      'Semver' => TypeFactory.sem_ver,
+      'SemVer' => TypeFactory.sem_ver,
 
-        'Semverrange'  => TypeFactory.sem_ver_range,
-        'SemVerRange'  => TypeFactory.sem_ver_range,
+      'Semverrange' => TypeFactory.sem_ver_range,
+      'SemVerRange' => TypeFactory.sem_ver_range,
 
-        'Timestamp'    => TypeFactory.timestamp,
-        'TimeStamp'    => TypeFactory.timestamp,
+      'Timestamp' => TypeFactory.timestamp,
+      'TimeStamp' => TypeFactory.timestamp,
 
-        'Timespan'     => TypeFactory.timespan,
-        'TimeSpan'     => TypeFactory.timespan,
+      'Timespan' => TypeFactory.timespan,
+      'TimeSpan' => TypeFactory.timespan,
 
-        'Uri'          => TypeFactory.uri,
-        'URI'          => TypeFactory.uri,
+      'Uri' => TypeFactory.uri,
+      'URI' => TypeFactory.uri,
 
-        'Optional[Integer]'      => TypeFactory.optional(TypeFactory.integer),
-        'Optional[String]'       => TypeFactory.optional(TypeFactory.string),
-        'Optional[String[1]]'    => TypeFactory.optional(TypeFactory.string(TypeFactory.range(1, :default))),
-        'Optional[Array]'        => TypeFactory.optional(TypeFactory.array_of_any),
-        'Optional[Hash]'         => TypeFactory.optional(TypeFactory.hash_of_any),
+      'Optional[Integer]' => TypeFactory.optional(TypeFactory.integer),
+      'Optional[String]' => TypeFactory.optional(TypeFactory.string),
+      'Optional[String[1]]' => TypeFactory.optional(TypeFactory.string(TypeFactory.range(1, :default))),
+      'Optional[Array]' => TypeFactory.optional(TypeFactory.array_of_any),
+      'Optional[Hash]' => TypeFactory.optional(TypeFactory.hash_of_any),
 
     }.freeze
   end
@@ -371,20 +373,21 @@ class TypeParser
 
     when 'collection'
       size_type = case parameters.size
-        when 1
-          if parameters[0].is_a?(PIntegerType)
-            parameters[0]
-          else
-            assert_range_parameter(ast, parameters[0])
-            TypeFactory.range(parameters[0], :default)
-          end
-        when 2
-          assert_range_parameter(ast, parameters[0])
-          assert_range_parameter(ast, parameters[1])
-          TypeFactory.range(parameters[0], parameters[1])
-        else
-          raise_invalid_parameters_error('Collection', '1 to 2', parameters.size)
-        end
+                  when 1
+                    if parameters[0].is_a?(PIntegerType)
+                      parameters[0]
+                    else
+                      assert_range_parameter(ast, parameters[0])
+                      TypeFactory.range(parameters[0], :default)
+                    end
+                  when 2
+                    assert_range_parameter(ast, parameters[0])
+                    assert_range_parameter(ast, parameters[1])
+                    TypeFactory.range(parameters[0], parameters[1])
+                  else
+                    raise_invalid_parameters_error('Collection', '1 to 2',
+                                                   parameters.size)
+                  end
       TypeFactory.collection(size_type)
 
     when 'class'
@@ -401,9 +404,9 @@ class TypeParser
         if param_start.nil?
           type = type_str
         else
-          tps = interpret_any(@parser.parse_string(type_str[param_start..-1]).model, context)
+          tps = interpret_any(@parser.parse_string(type_str[param_start..]).model, context)
           raise_invalid_parameters_error(type.to_s, '1', tps.size) unless tps.size == 1
-          type = type_str[0..param_start-1]
+          type = type_str[0..param_start - 1]
           parameters = [type] + tps
         end
       end
@@ -454,13 +457,13 @@ class TypeParser
         assert_range_parameter(ast, parameters[-1])
         max = parameters[-1]
         max = max == :default ? nil : max
-        parameters = parameters[0, length-2]
+        parameters = parameters[0, length - 2]
         size_type = TypeFactory.range(min, max)
       elsif TypeFactory.is_range_parameter?(parameters[-1])
         min = parameters[-1]
         min = (min == :default || min == 'default') ? 0 : min
         max = nil
-        parameters = parameters[0, length-1]
+        parameters = parameters[0, length - 1]
         size_type = TypeFactory.range(min, max)
       end
       TypeFactory.tuple(parameters, size_type)
@@ -483,6 +486,7 @@ class TypeParser
       raise_invalid_parameters_error('Boolean', '1', parameters.size) unless parameters.size == 1
       p = parameters[0]
       raise Puppet::ParseError, 'Boolean parameter must be true or false' unless p == true || p == false
+
       TypeFactory.boolean(p)
 
     when 'integer'
@@ -541,27 +545,28 @@ class TypeParser
 
     when 'string'
       size_type =
-      case parameters.size
-      when 1
-        if parameters[0].is_a?(PIntegerType)
-          parameters[0]
-        else
+        case parameters.size
+        when 1
+          if parameters[0].is_a?(PIntegerType)
+            parameters[0]
+          else
+            assert_range_parameter(ast, parameters[0])
+            TypeFactory.range(parameters[0], :default)
+          end
+        when 2
           assert_range_parameter(ast, parameters[0])
-          TypeFactory.range(parameters[0], :default)
+          assert_range_parameter(ast, parameters[1])
+          TypeFactory.range(parameters[0], parameters[1])
+        else
+          raise_invalid_parameters_error('String', '1 to 2', parameters.size)
         end
-      when 2
-        assert_range_parameter(ast, parameters[0])
-        assert_range_parameter(ast, parameters[1])
-        TypeFactory.range(parameters[0], parameters[1])
-      else
-        raise_invalid_parameters_error('String', '1 to 2', parameters.size)
-      end
       TypeFactory.string(size_type)
 
     when 'sensitive'
-      if parameters.size == 0
+      case parameters.size
+      when 0
         TypeFactory.sensitive
-      elsif parameters.size == 1
+      when 1
         param = parameters[0]
         assert_type(ast, param)
         TypeFactory.sensitive(param)
@@ -640,9 +645,10 @@ class TypeParser
   private
 
   def create_resource(name, parameters)
-    if parameters.size == 1
+    case parameters.size
+    when 1
       TypeFactory.resource(name)
-    elsif parameters.size == 2
+    when 2
       TypeFactory.resource(name, parameters[1])
     else
       raise_invalid_parameters_error('Resource', '1 or 2', parameters.size)
@@ -660,12 +666,12 @@ class TypeParser
 
   def raise_invalid_type_specification_error(ast)
     raise Puppet::ParseError, _("The expression <%{expression}> is not a valid type specification.") %
-        { expression: original_text_of(ast) }
+                              { expression: original_text_of(ast) }
   end
 
   def raise_invalid_parameters_error(type, required, given)
     raise Puppet::ParseError, _("Invalid number of type parameters specified: %{type} requires %{required}, %{given} provided") %
-        { type: type, required: required, given: given }
+                              { type: type, required: required, given: given }
   end
 
   def raise_unparameterized_type_error(ast)

data/lib/puppet/pops/types/type_set_reference.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
 class TypeSetReference
@@ -49,6 +50,7 @@ class TypeSetReference
     unless @version_range.include?(@type_set.version)
       raise ArgumentError, "#{self} resolves to an incompatible version. Expected #{@version_range}, got #{type_set.version}"
     end
+
     nil
   end
 

data/lib/puppet/pops/types/type_with_members.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
 # Interface implemented by a type that has InvocableMembers
 module TypeWithMembers
   # @return [InvocableMember,nil] An invocable member if it exists, or `nil`
@@ -41,4 +41,3 @@ class AttrReader
 end
 end
 end
-