puppet 8.3.1-universal-darwin → 8.4.0-universal-darwin

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'iterable'
 require_relative 'recursion_guard'
 require_relative 'type_acceptor'
@@ -15,7 +16,6 @@ require_relative 'puppet_object'
 
 module Puppet::Pops
 module Types
-
 # The EMPTY_xxx declarations is for backward compatibility. They should not be explicitly referenced
 
 # @api private
@@ -61,8 +61,10 @@ class TypedModelObject < Object
     ]
     Types.constants.each do |c|
       next if c == :PType || c == :PHostClassType
+
       cls = Types.const_get(c)
       next unless cls.is_a?(Class) && cls < self
+
       type = cls.register_ptype(loader, ir)
       types << type unless type.nil?
     end
@@ -74,7 +76,6 @@ end
 # @api public
 #
 class PAnyType < TypedModelObject
-
   def self.register_ptype(loader, ir)
     @type = Pcore::create_object_type(loader, ir, self, 'Pcore::AnyType', 'Any', EMPTY_HASH)
   end
@@ -133,6 +134,7 @@ class PAnyType < TypedModelObject
       return true if self.class == PAnyType
       # An empty variant may be assignable to NotUndef[T] if T is assignable to empty variant
       return _assignable?(o, guard) if is_a?(PNotUndefType) && o.types.empty?
+
       !o.types.empty? && o.types.all? { |vt| assignable?(vt, guard) }
     when POptionalType
       # Assignable if undef and contained type is assignable
@@ -162,7 +164,7 @@ class PAnyType < TypedModelObject
   # @param args [Array] the arguments to test
   # @param block [Proc] block, or nil if not called with a block
   # @return [Boolean] `true` if this instance is a callable that accepts the given _args_
-  def callable_with?(args,  block = nil)
+  def callable_with?(args, block = nil)
     false
   end
 
@@ -464,13 +466,12 @@ end
 # @api public
 #
 class PTypeType < PTypeWithContainedType
-
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-       'type' => {
-         KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
-         KEY_VALUE => nil
-       }
+                 'type' => {
+                   KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
+                   KEY_VALUE => nil
+                 }
     )
   end
 
@@ -538,6 +539,7 @@ class PTypeType < PTypeWithContainedType
     return false unless o.is_a?(PTypeType)
     return true if @type.nil? # wide enough to handle all types
     return false if o.type.nil? # wider than t
+
     @type.assignable?(o.type, guard)
   end
 end
@@ -548,10 +550,10 @@ PType = PTypeType
 class PNotUndefType < PTypeWithContainedType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-       'type' => {
-         KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
-         KEY_VALUE => nil
-       }
+                 'type' => {
+                   KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
+                   KEY_VALUE => nil
+                 }
     )
   end
 
@@ -619,6 +621,7 @@ class PUndefType < PAnyType
   DEFAULT = PUndefType.new
 
   protected
+
   # @api private
   def _assignable?(o, guard)
     o.is_a?(PUndefType)
@@ -641,7 +644,7 @@ class PUnitType < PAnyType
   def self.new_function(type)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_unit, type.loader) do
       dispatch :from_args do
-        param          'Any',  :from
+        param 'Any', :from
       end
 
       def from_args(from)
@@ -680,6 +683,7 @@ class PDefaultType < PAnyType
   DEFAULT = PDefaultType.new
 
   protected
+
   # @api private
   def _assignable?(o, guard)
     o.is_a?(PDefaultType)
@@ -759,8 +763,8 @@ end
 class PEnumType < PScalarDataType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'ScalarDataType',
-      'values' => PArrayType.new(PStringType::NON_EMPTY),
-      'case_insensitive' => { 'type' => PBooleanType::DEFAULT, 'value' => false })
+                 'values' => PArrayType.new(PStringType::NON_EMPTY),
+                 'case_insensitive' => { 'type' => PBooleanType::DEFAULT, 'value' => false })
   end
 
   attr_reader :values, :case_insensitive
@@ -823,18 +827,19 @@ class PEnumType < PScalarDataType
   # @api private
   def _assignable?(o, guard)
     return true if self == o
+
     svalues = values
     if svalues.empty?
       return true if o.is_a?(PStringType) || o.is_a?(PEnumType) || o.is_a?(PPatternType)
     end
     case o
-      when PStringType
-        # if the contained string is found in the set of enums
-        instance?(o.value, guard)
-      when PEnumType
-        !o.values.empty? && (case_insensitive? || !o.case_insensitive?) && o.values.all? { |s| instance?(s, guard) }
-      else
-        false
+    when PStringType
+      # if the contained string is found in the set of enums
+      instance?(o.value, guard)
+    when PEnumType
+      !o.values.empty? && (case_insensitive? || !o.case_insensitive?) && o.values.all? { |s| instance?(s, guard) }
+    else
+      false
     end
   end
 end
@@ -850,17 +855,17 @@ OPTIONAL_FRACTION = '(?:\.\d+)?'
 OPTIONAL_EXPONENT = '(?:[eE]-?\d+)?'
 FLOAT_DEC = '(?:' + INTEGER_DEC + OPTIONAL_FRACTION + OPTIONAL_EXPONENT + ')'
 
-INTEGER_PATTERN          = '\A' + SIGN_PREFIX + '(?:' + INTEGER_DEC + '|' + INTEGER_HEX + '|' + INTEGER_OCT + '|' + INTEGER_BIN + ')\z'
+INTEGER_PATTERN = '\A' + SIGN_PREFIX + '(?:' + INTEGER_DEC + '|' + INTEGER_HEX + '|' + INTEGER_OCT + '|' + INTEGER_BIN + ')\z'
 INTEGER_PATTERN_LENIENT = '\A' + SIGN_PREFIX + '(?:' + INTEGER_DEC_OR_OCT + '|' + INTEGER_HEX + '|' + INTEGER_BIN + ')\z'
-FLOAT_PATTERN            = '\A' + SIGN_PREFIX + '(?:' + FLOAT_DEC + '|' + INTEGER_HEX + '|' + INTEGER_OCT + '|' + INTEGER_BIN + ')\z'
+FLOAT_PATTERN = '\A' + SIGN_PREFIX + '(?:' + FLOAT_DEC + '|' + INTEGER_HEX + '|' + INTEGER_OCT + '|' + INTEGER_BIN + ')\z'
 
 # @api public
 #
 class PNumericType < PScalarDataType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'ScalarDataType',
-      'from' => { KEY_TYPE => POptionalType.new(PNumericType::DEFAULT), KEY_VALUE => nil },
-      'to' => { KEY_TYPE => POptionalType.new(PNumericType::DEFAULT), KEY_VALUE => nil }
+                 'from' => { KEY_TYPE => POptionalType.new(PNumericType::DEFAULT), KEY_VALUE => nil },
+                 'to' => { KEY_TYPE => POptionalType.new(PNumericType::DEFAULT), KEY_VALUE => nil }
     )
   end
 
@@ -877,7 +882,7 @@ class PNumericType < PScalarDataType
       end
 
       dispatch :from_hash do
-        param          'NamedArgs',  :hash_args
+        param          'NamedArgs', :hash_args
       end
 
       argument_mismatch :on_error do
@@ -940,6 +945,7 @@ class PNumericType < PScalarDataType
     from = -Float::INFINITY if from.nil? || from == :default
     to = Float::INFINITY if to.nil? || to == :default
     raise ArgumentError, "'from' must be less or equal to 'to'. Got (#{from}, #{to}" if from > to
+
     @from = from
     @to = to
   end
@@ -998,6 +1004,7 @@ class PNumericType < PScalarDataType
   # @api_private
   def _assignable?(o, guard)
     return false unless o.is_a?(self.class)
+
     # If o min and max are within the range of t
     @from <= o.numeric_from && @to >= o.numeric_to
   end
@@ -1033,7 +1040,7 @@ class PIntegerType < PNumericType
   # @return [Boolean] `true` if this range is adjacent to the other range
   # @api public
   def adjacent?(o)
-    o.is_a?(PIntegerType) &&  (@to + 1 == o.from || o.to + 1 == @from)
+    o.is_a?(PIntegerType) && (@to + 1 == o.from || o.to + 1 == @from)
   end
 
   # Concatenates this range with another range provided that the ranges intersect or
@@ -1064,6 +1071,7 @@ class PIntegerType < PNumericType
   # Returns Float.Infinity if one end of the range is unbound
   def size
     return Float::INFINITY if @from == -Float::INFINITY || @to == Float::INFINITY
+
     1+(to-from).abs
   end
 
@@ -1096,17 +1104,17 @@ class PIntegerType < PNumericType
       end
 
       dispatch :from_args do
-        param          'Convertible',  :from
+        param          'Convertible', :from
         optional_param 'Radix',   :radix
         optional_param 'Boolean', :abs
       end
 
       dispatch :from_hash do
-        param          'NamedArgs',  :hash_args
+        param          'NamedArgs', :hash_args
       end
 
       argument_mismatch :on_error_hash do
-        param          'Hash',  :hash_args
+        param          'Hash', :hash_args
       end
 
       argument_mismatch :on_error do
@@ -1178,12 +1186,12 @@ class PIntegerType < PNumericType
       def assert_radix(radix)
         case radix
         when 2, 8, 10, 16
+          # do nothing
         else
           raise ArgumentError.new(_("Illegal radix: %{radix}, expected 2, 8, 10, 16, or default") % { radix: radix })
         end
         radix
       end
-
     end
   end
 
@@ -1236,7 +1244,7 @@ class PFloatType < PNumericType
       end
 
       dispatch :from_hash do
-        param          'NamedArgs',  :hash_args
+        param          'NamedArgs', :hash_args
       end
 
       argument_mismatch :on_error do
@@ -1309,10 +1317,10 @@ end
 class PCollectionType < PAnyType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-      'size_type' => {
-        KEY_TYPE => POptionalType.new(PTypeType.new(PIntegerType::DEFAULT)),
-        KEY_VALUE => nil
-      }
+                 'size_type' => {
+                   KEY_TYPE => POptionalType.new(PTypeType.new(PIntegerType::DEFAULT)),
+                   KEY_VALUE => nil
+                 }
     )
   end
 
@@ -1366,7 +1374,6 @@ class PCollectionType < PAnyType
     self.class == o.class && @size_type == o.size_type
   end
 
-
   DEFAULT_SIZE = PIntegerType.new(0)
   ZERO_SIZE = PIntegerType.new(0, 0)
   NOT_EMPTY_SIZE = PIntegerType.new(1)
@@ -1378,22 +1385,22 @@ class PCollectionType < PAnyType
   #
   def _assignable?(o, guard)
     case o
-      when PCollectionType
-        (@size_type || DEFAULT_SIZE).assignable?(o.size_type || DEFAULT_SIZE, guard)
-      when PTupleType
-        # compute the tuple's min/max size, and check if that size matches
-        size_s = size_type || DEFAULT_SIZE
-        size_o = o.size_type
-        if size_o.nil?
-          type_count = o.types.size
-          size_o = PIntegerType.new(type_count, type_count)
-        end
-        size_s.assignable?(size_o)
-      when PStructType
-        from = to = o.elements.size
-        (@size_type || DEFAULT_SIZE).assignable?(PIntegerType.new(from, to), guard)
-      else
-        false
+    when PCollectionType
+      (@size_type || DEFAULT_SIZE).assignable?(o.size_type || DEFAULT_SIZE, guard)
+    when PTupleType
+      # compute the tuple's min/max size, and check if that size matches
+      size_s = size_type || DEFAULT_SIZE
+      size_o = o.size_type
+      if size_o.nil?
+        type_count = o.types.size
+        size_o = PIntegerType.new(type_count, type_count)
+      end
+      size_s.assignable?(size_o)
+    when PStructType
+      from = to = o.elements.size
+      (@size_type || DEFAULT_SIZE).assignable?(PIntegerType.new(from, to), guard)
+    else
+      false
     end
   end
 end
@@ -1401,10 +1408,10 @@ end
 class PIterableType < PTypeWithContainedType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-      'type' => {
-        KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
-        KEY_VALUE => nil
-      }
+                 'type' => {
+                   KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
+                   KEY_VALUE => nil
+                 }
     )
   end
 
@@ -1461,10 +1468,10 @@ end
 class PIteratorType < PTypeWithContainedType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-      'type' => {
-        KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
-        KEY_VALUE => nil
-      }
+                 'type' => {
+                   KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
+                   KEY_VALUE => nil
+                 }
     )
   end
 
@@ -1499,10 +1506,10 @@ end
 class PStringType < PScalarDataType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'ScalarDataType',
-      'size_type_or_value' => {
-        KEY_TYPE => POptionalType.new(PVariantType.new([PStringType::DEFAULT, PTypeType.new(PIntegerType::DEFAULT)])),
-      KEY_VALUE => nil
-    })
+                 'size_type_or_value' => {
+                   KEY_TYPE => POptionalType.new(PVariantType.new([PStringType::DEFAULT, PTypeType.new(PIntegerType::DEFAULT)])),
+                   KEY_VALUE => nil
+                 })
   end
 
   attr_reader :size_type_or_value
@@ -1510,7 +1517,7 @@ class PStringType < PScalarDataType
   def initialize(size_type_or_value, deprecated_multi_args = EMPTY_ARRAY)
     unless deprecated_multi_args.empty?
       if Puppet[:strict] != :off
-        #TRANSLATORS 'PStringType#initialize' is a class and method name and should not be translated
+        # TRANSLATORS 'PStringType#initialize' is a class and method name and should not be translated
         Puppet.warn_once('deprecations', "PStringType#initialize_multi_args",
                          _("Passing more than one argument to PStringType#initialize is deprecated"))
       end
@@ -1565,7 +1572,7 @@ class PStringType < PScalarDataType
   # @api private
   def values
     if Puppet[:strict] != :off
-      #TRANSLATORS 'PStringType#values' and '#value' are classes and method names and should not be translated
+      # TRANSLATORS 'PStringType#values' and '#value' are classes and method names and should not be translated
       Puppet.warn_once('deprecations', "PStringType#values", _("Method PStringType#values is deprecated. Use #value instead"))
     end
     @value.is_a?(String) ? [@value] : EMPTY_ARRAY
@@ -1673,13 +1680,12 @@ end
 class PRegexpType < PScalarType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'ScalarType',
-      'pattern' => {
-        KEY_TYPE => PVariantType.new([PUndefType::DEFAULT, PStringType::DEFAULT, PRegexpType::DEFAULT]),
-        KEY_VALUE => nil
-      })
+                 'pattern' => {
+                   KEY_TYPE => PVariantType.new([PUndefType::DEFAULT, PStringType::DEFAULT, PRegexpType::DEFAULT]),
+                   KEY_VALUE => nil
+                 })
   end
 
-
   # Returns a new function that produces a Regexp instance
   #
   def self.new_function(type)
@@ -1805,6 +1811,7 @@ class PPatternType < PScalarDataType
   #
   def _assignable?(o, guard)
     return true if self == o
+
     case o
     when PStringType
       v = o.value
@@ -1869,7 +1876,7 @@ class PBooleanType < PScalarDataType
   def self.new_function(type)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_boolean, type.loader) do
       dispatch :from_args do
-        param "Variant[Integer, Float, Boolean, Enum['false','true','yes','no','y','n',true]]",  :from
+        param "Variant[Integer, Float, Boolean, Enum['false','true','yes','no','y','n',true]]", :from
       end
 
       argument_mismatch :on_error do
@@ -1879,10 +1886,8 @@ class PBooleanType < PScalarDataType
       def from_args(from)
         from = from.downcase if from.is_a?(String)
         case from
-        when Float
-          from != 0.0
-        when Integer
-          from != 0
+        when Float, Integer
+          !from.zero?
         when false, 'false', 'no', 'n'
           false
         else
@@ -1921,8 +1926,8 @@ end
 class PStructElement < TypedModelObject
   def self.register_ptype(loader, ir)
     @type = Pcore::create_object_type(loader, ir, self, 'Pcore::StructElement', nil,
-      'key_type' => PTypeType::DEFAULT,
-      'value_type' => PTypeType::DEFAULT)
+                                      'key_type' => PTypeType::DEFAULT,
+                                      'value_type' => PTypeType::DEFAULT)
   end
 
   attr_accessor :key_type, :value_type
@@ -2026,9 +2031,11 @@ class PStructType < PAnyType
     end
   end
 
+  # rubocop:disable Naming/MemoizedInstanceVariableName
   def hashed_elements
     @hashed ||= @elements.reduce({}) {|memo, e| memo[e.name] = e; memo }
   end
+  # rubocop:enable Naming/MemoizedInstanceVariableName
 
   def hash
     @elements.hash
@@ -2044,9 +2051,9 @@ class PStructType < PAnyType
     else
       PIterableType.new(
         PTupleType.new([
-          PVariantType.maybe_create(@elements.map {|se| se.key_type }),
-          PVariantType.maybe_create(@elements.map {|se| se.value_type })],
-          PHashType::KEY_PAIR_TUPLE_SIZE))
+                         PVariantType.maybe_create(@elements.map {|se| se.key_type }),
+                         PVariantType.maybe_create(@elements.map {|se| se.value_type })],
+                       PHashType::KEY_PAIR_TUPLE_SIZE))
     end
   end
 
@@ -2071,6 +2078,7 @@ class PStructType < PAnyType
   def instance?(o, guard = nil)
     # The inferred type of a class derived from Hash is either Runtime or Object. It's not assignable to the Struct type.
     return false unless o.instance_of?(Hash)
+
     matched = 0
     @elements.all? do |e|
       key = e.name
@@ -2146,11 +2154,11 @@ class PTupleType < PAnyType
 
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-      'types' => PArrayType.new(PTypeType::DEFAULT),
-      'size_type' => {
-        KEY_TYPE => POptionalType.new(PTypeType.new(PIntegerType::DEFAULT)),
-        KEY_VALUE => nil
-      }
+                 'types' => PArrayType.new(PTypeType::DEFAULT),
+                 'size_type' => {
+                   KEY_TYPE => POptionalType.new(PTypeType.new(PIntegerType::DEFAULT)),
+                   KEY_VALUE => nil
+                 }
     )
   end
 
@@ -2244,6 +2252,7 @@ class PTupleType < PAnyType
   def instance?(o, guard = nil)
     # The inferred type of a class derived from Array is either Runtime or Object. It's not assignable to the Tuple type.
     return false unless o.instance_of?(Array)
+
     if @size_type
       return false unless @size_type.instance?(o.size, guard)
     else
@@ -2280,6 +2289,7 @@ class PTupleType < PAnyType
     if @size_type.nil?
       return [1, 1]
     end
+
     types_size = @types.size
     from, to = @size_type.range
     min = from - (types_size-1)
@@ -2310,15 +2320,18 @@ class PTupleType < PAnyType
   def _assignable?(o, guard)
     return true if self == o
     return false unless o.is_a?(PTupleType) || o.is_a?(PArrayType)
+
     s_types = types
     size_s = size_type || PIntegerType.new(*size_range)
 
     if o.is_a?(PTupleType)
       size_o = o.size_type || PIntegerType.new(*o.size_range)
       return false unless size_s.assignable?(size_o, guard)
+
       unless s_types.empty?
         o_types = o.types
         return size_s.numeric_from == 0 if o_types.empty?
+
         o_types.size.times do |index|
           return false unless (s_types[index] || s_types[-1]).assignable?(o_types[index], guard)
         end
@@ -2326,12 +2339,14 @@ class PTupleType < PAnyType
     else
       size_o = o.size_type || PCollectionType::DEFAULT_SIZE
       return false unless size_s.assignable?(size_o, guard)
+
       unless s_types.empty?
         o_entry = o.element_type
         # Array of anything can not be assigned (unless tuple is tuple of anything) - this case
         # was handled at the top of this method.
         #
         return false if o_entry.nil?
+
         [s_types.size, size_o.range[1]].min.times { |index| return false unless (s_types[index] || s_types[-1]).assignable?(o_entry, guard) }
       end
     end
@@ -2344,18 +2359,18 @@ end
 class PCallableType < PAnyType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-      'param_types' => {
-        KEY_TYPE => POptionalType.new(PTypeType.new(PTupleType::DEFAULT)),
-        KEY_VALUE => nil
-      },
-      'block_type' => {
-        KEY_TYPE => POptionalType.new(PTypeType.new(PCallableType::DEFAULT)),
-        KEY_VALUE => nil
-      },
-      'return_type' => {
-        KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
-        KEY_VALUE => PAnyType::DEFAULT
-      }
+                 'param_types' => {
+                   KEY_TYPE => POptionalType.new(PTypeType.new(PTupleType::DEFAULT)),
+                   KEY_VALUE => nil
+                 },
+                 'block_type' => {
+                   KEY_TYPE => POptionalType.new(PTypeType.new(PCallableType::DEFAULT)),
+                   KEY_VALUE => nil
+                 },
+                 'return_type' => {
+                   KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
+                   KEY_VALUE => PAnyType::DEFAULT
+                 }
     )
   end
 
@@ -2422,6 +2437,7 @@ class PCallableType < PAnyType
     # nil param_types and compatible return type means other Callable is assignable
     return true if @param_types.nil?
     return false unless @param_types.instance?(args)
+
     if @block_type.nil?
       block == nil
     else
@@ -2494,7 +2510,8 @@ class PCallableType < PAnyType
     # (it's lower bound), not its upper bound
     other_param_types = o.param_types
 
-    return false if other_param_types.nil? ||  !other_param_types.assignable?(@param_types, guard)
+    return false if other_param_types.nil? || !other_param_types.assignable?(@param_types, guard)
+
     # names are ignored, they are just information
     # Blocks must be compatible
     this_block_t = @block_type || PUndefType::DEFAULT
@@ -2506,13 +2523,12 @@ end
 # @api public
 #
 class PArrayType < PCollectionType
-
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'CollectionType',
-      'element_type' => {
-        KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
-        KEY_VALUE => PAnyType::DEFAULT
-      }
+                 'element_type' => {
+                   KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
+                   KEY_VALUE => PAnyType::DEFAULT
+                 }
     )
   end
 
@@ -2575,6 +2591,7 @@ class PArrayType < PCollectionType
     # The inferred type of a class derived from Array is either Runtime or Object. It's not assignable to the Array type.
     return false unless o.instance_of?(Array)
     return false unless o.all? {|element| @element_type.instance?(element, guard) }
+
     size_t = size_type
     size_t.nil? || size_t.instance?(o.size, guard)
   end
@@ -2587,7 +2604,6 @@ class PArrayType < PCollectionType
   #
   def self.new_function(type)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_array, type.loader) do
-
       dispatch :to_array do
         param           'Variant[Array,Hash,Binary,Iterable]', :from
         optional_param  'Boolean[false]', :wrap
@@ -2656,17 +2672,16 @@ end
 # @api public
 #
 class PHashType < PCollectionType
-
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'CollectionType',
-      'key_type' => {
-        KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
-        KEY_VALUE => PAnyType::DEFAULT
-      },
-      'value_type' => {
-        KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
-        KEY_VALUE => PAnyType::DEFAULT
-      }
+                 'key_type' => {
+                   KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
+                   KEY_VALUE => PAnyType::DEFAULT
+                 },
+                 'value_type' => {
+                   KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
+                   KEY_VALUE => PAnyType::DEFAULT
+                 }
     )
   end
 
@@ -2691,9 +2706,9 @@ class PHashType < PCollectionType
 
   def element_type
     if Puppet[:strict] != :off
-      #TRANSLATOR 'Puppet::Pops::Types::PHashType#element_type' and '#value_type' are class and method names and should not be translated
+      # TRANSLATOR 'Puppet::Pops::Types::PHashType#element_type' and '#value_type' are class and method names and should not be translated
       Puppet.warn_once('deprecations', 'Puppet::Pops::Types::PHashType#element_type',
-        _('Puppet::Pops::Types::PHashType#element_type is deprecated, use #value_type instead'))
+                       _('Puppet::Pops::Types::PHashType#element_type is deprecated, use #value_type instead'))
     end
     @value_type
   end
@@ -2727,6 +2742,7 @@ class PHashType < PCollectionType
   def instance?(o, guard = nil)
     # The inferred type of a class derived from Hash is either Runtime or Object. It's not assignable to the Hash type.
     return false unless o.instance_of?(Hash)
+
     if o.keys.all? {|key| @key_type.instance?(key, guard) } && o.values.all? {|value| @value_type.instance?(value, guard) }
       size_t = size_type
       size_t.nil? || size_t.instance?(o.size, guard)
@@ -2763,6 +2779,7 @@ class PHashType < PCollectionType
 
   def self.array_as_hash(value)
     return value unless value.is_a?(Array)
+
     result = {}
     value.each_with_index {|v, idx| result[idx] = array_as_hash(v) }
     result
@@ -2784,11 +2801,11 @@ class PHashType < PCollectionType
       end
 
       dispatch :from_tuples do
-        param           'KeyValueArray',  :from
+        param           'KeyValueArray', :from
       end
 
       dispatch :from_array do
-        param           'Any',  :from
+        param           'Any', :from
       end
 
       def from_tuples(tuple_array)
@@ -2799,6 +2816,7 @@ class PHashType < PCollectionType
         if build_option.nil?
           return from_tuples(tuple_array)
         end
+
         # only remaining possible options is 'tree' or 'hash_tree'
 
         all_hashes = build_option == 'hash_tree'
@@ -2832,6 +2850,7 @@ class PHashType < PCollectionType
             unless from.size % 2 == 0
               raise TypeConversionError.new(_('odd number of arguments for Hash'))
             end
+
             Hash[*from]
           end
         when Hash
@@ -2863,6 +2882,7 @@ class PHashType < PCollectionType
       size_s = size_type
       return true if (size_s.nil? || size_s.from == 0) && o.is_the_empty_hash?
       return false unless @key_type.assignable?(o.key_type, guard) && @value_type.assignable?(o.value_type, guard)
+
       super
     when PStructType
       # hash must accept String as key type
@@ -2995,6 +3015,7 @@ class PVariantType < PAnyType
     @types.reduce(-1) do |memo, type|
       ri = type.really_instance?(o, guard)
       break ri if ri > 0
+
       ri > memo ? ri : memo
     end
   end
@@ -3018,6 +3039,7 @@ class PVariantType < PAnyType
     return super unless o.is_a?(PVariantType)
     # If empty, all Variant types match irrespective of the types they hold (including being empty)
     return true if types.empty?
+
     # Since this variant is not empty, an empty Variant cannot match, because it matches nothing
     # otherwise all types in o must be assignable to this
     !o.types.empty? && o.types.all? { |vt| super(vt, guard) }
@@ -3038,7 +3060,7 @@ class PVariantType < PAnyType
       not_undefs = parts[0]
       if not_undefs.size > 1
         others = parts[1]
-        others <<  PNotUndefType.new(PVariantType.maybe_create(not_undefs.map { |not_undef| not_undef.type }).normalize)
+        others << PNotUndefType.new(PVariantType.maybe_create(not_undefs.map { |not_undef| not_undef.type }).normalize)
         array = others
       end
     end
@@ -3053,7 +3075,7 @@ class PVariantType < PAnyType
       enums = parts[0]
       if enums.size > 1
         others = parts[1]
-        others <<  PEnumType.new(enums.map { |enum| enum.is_a?(PStringType) ? enum.value : enum.values }.flatten.uniq)
+        others << PEnumType.new(enums.map { |enum| enum.is_a?(PStringType) ? enum.value : enum.values }.flatten.uniq)
         array = others
       end
     end
@@ -3067,7 +3089,7 @@ class PVariantType < PAnyType
         values = []
         enums.each { |enum| enum.values.each { |value| values << value.downcase }}
         values.uniq!
-        others <<  PEnumType.new(values, true)
+        others << PEnumType.new(values, true)
         array = others
       end
     end
@@ -3081,7 +3103,7 @@ class PVariantType < PAnyType
       patterns = parts[0]
       if patterns.size > 1
         others = parts[1]
-        others <<  PPatternType.new(patterns.map { |pattern| pattern.patterns }.flatten.uniq)
+        others << PPatternType.new(patterns.map { |pattern| pattern.patterns }.flatten.uniq)
         array = others
       end
     end
@@ -3143,6 +3165,7 @@ class PCatalogEntryType < PAnyType
   end
 
   protected
+
   # @api private
   def _assignable?(o, guard)
     o.is_a?(PCatalogEntryType)
@@ -3157,10 +3180,10 @@ class PClassType < PCatalogEntryType
 
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'CatalogEntryType',
-      'class_name' => {
-        KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
-        KEY_VALUE => nil
-      }
+                 'class_name' => {
+                   KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
+                   KEY_VALUE => nil
+                 }
     )
   end
 
@@ -3171,6 +3194,7 @@ class PClassType < PCatalogEntryType
   def hash
     11 ^ @class_name.hash
   end
+
   def eql?(o)
     self.class == o.class && @class_name == o.class_name
   end
@@ -3184,6 +3208,7 @@ class PClassType < PCatalogEntryType
     return false unless o.is_a?(PClassType)
     # Class = Class[name}, Class[name] != Class
     return true if @class_name.nil?
+
     # Class[name] = Class[name]
     @class_name == o.class_name
   end
@@ -3192,22 +3217,20 @@ end
 # For backward compatibility
 PHostClassType = PClassType
 
-
 # Represents a Resource Type in the Puppet Language
 # @api public
 #
 class PResourceType < PCatalogEntryType
-
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'CatalogEntryType',
-      'type_name' => {
-        KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
-        KEY_VALUE => nil
-      },
-      'title' => {
-        KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
-        KEY_VALUE => nil
-      }
+                 'type_name' => {
+                   KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
+                   KEY_VALUE => nil
+                 },
+                 'title' => {
+                   KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
+                   KEY_VALUE => nil
+                 }
     )
   end
 
@@ -3242,13 +3265,12 @@ end
 # @api public
 #
 class POptionalType < PTypeWithContainedType
-
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-      'type' => {
-        KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
-        KEY_VALUE => nil
-      }
+                 'type' => {
+                   KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
+                   KEY_VALUE => nil
+                 }
     )
   end
 
@@ -3257,7 +3279,7 @@ class POptionalType < PTypeWithContainedType
   end
 
   def kind_of_callable?(optional=true, guard = nil)
-      optional && !@type.nil? && @type.kind_of_callable?(optional, guard)
+    optional && !@type.nil? && @type.kind_of_callable?(optional, guard)
   end
 
   def instance?(o, guard = nil)
@@ -3293,6 +3315,7 @@ class POptionalType < PTypeWithContainedType
   def _assignable?(o, guard)
     return true if o.is_a?(PUndefType)
     return true if @type.nil?
+
     if o.is_a?(POptionalType)
       @type.assignable?(o.optional_type, guard)
     else
@@ -3302,7 +3325,6 @@ class POptionalType < PTypeWithContainedType
 end
 
 class PTypeReferenceType < PAnyType
-
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType', 'type_string' => PStringType::NON_EMPTY)
   end
@@ -3351,15 +3373,14 @@ end
 #
 # @api public
 class PTypeAliasType < PAnyType
-
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-       'name' => PStringType::NON_EMPTY,
-       'type_expr' => PAnyType::DEFAULT,
-       'resolved_type' => {
-         KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
-         KEY_VALUE => nil
-       }
+                 'name' => PStringType::NON_EMPTY,
+                 'type_expr' => PAnyType::DEFAULT,
+                 'resolved_type' => {
+                   KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
+                   KEY_VALUE => nil
+                 }
     )
   end
 
@@ -3391,6 +3412,7 @@ class PTypeAliasType < PAnyType
   # @raise [Puppet::Error] unless the type has been resolved prior to calling this method
   def resolved_type
     raise Puppet::Error, "Reference to unresolved type #{@name}" unless @resolved_type
+
     @resolved_type
   end
 
@@ -3453,6 +3475,7 @@ class PTypeAliasType < PAnyType
 
   def set_self_recursion_status
     return if @self_recursion || @resolved_type.is_a?(PTypeReferenceType)
+
     @self_recursion = true
     guard = RecursionGuard.new
     accept(NoopTypeAcceptor::INSTANCE, guard)
@@ -3490,6 +3513,7 @@ class PTypeAliasType < PAnyType
         unless real_type_asserter.other_type_detected?
           raise ArgumentError, "Type alias '#{name}' cannot be resolved to a real type"
         end
+
         @self_recursion = guard.recursive_this?(self)
         # All aliases involved must re-check status since this alias is now resolved
         if @self_recursion
@@ -3587,6 +3611,7 @@ class PTypeAliasType < PAnyType
       resolved_types = @resolved_type.types
       real_types = resolved_types.select do |type|
         next false if type == self
+
         real_type_asserter = AssertOtherTypeAcceptor.new
         type.accept(real_type_asserter, RecursionGuard.new)
         real_type_asserter.other_type_detected?