puppet 5.3.4 → 6.29.0

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

@@ -57,7 +57,7 @@ class TypedModelObject < Object
   def self.register_ptypes(loader, ir)
     types = [
       Annotation.register_ptype(loader, ir),
-      RubyMethod.register_ptype(loader, ir)
+      RubyMethod.register_ptype(loader, ir),
     ]
     Types.constants.each do |c|
       next if c == :PType || c == :PHostClassType
@@ -129,8 +129,11 @@ class PAnyType < TypedModelObject
         assignable?(o.resolved_type, guard)
       end
     when PVariantType
-      # Assignable if all contained types are assignable
-      o.types.all? { |vt| assignable?(vt, guard) }
+      # Assignable if all contained types are assignable, or if this is exactly Any
+      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
       assignable?(PUndefType::DEFAULT) && (o.type.nil? || assignable?(o.type))
@@ -337,13 +340,13 @@ class PAnyType < TypedModelObject
   # @raises ArgumentError
   #
   def self.new_function(type)
-    raise ArgumentError.new("Creation of new instance of type '#{type.to_s}' is not supported")
+    raise ArgumentError.new("Creation of new instance of type '#{type}' is not supported")
   end
 
   # Answers the question if instances of this type can represent themselves as a string that
   # can then be passed to the create method
   #
-  # @return [Boolean] wether or not the instance has a canonical string representation
+  # @return [Boolean] whether or not the instance has a canonical string representation
   def roundtrip_with_string?
     false
   end
@@ -476,7 +479,7 @@ class PTypeType < PTypeWithContainedType
   def self.new_function(type)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_type, type.loader) do
       dispatch :from_string do
-        param 'String', :type_string
+        param 'String[1]', :type_string
       end
 
       def from_string(type_string)
@@ -573,7 +576,7 @@ class PNotUndefType < PTypeWithContainedType
         n.type
       else
         n
-       end
+      end
     end
   end
 
@@ -649,7 +652,12 @@ class PUnitType < PAnyType
 
   DEFAULT = PUnitType.new
 
+  def assignable?(o, guard=nil)
+    true
+  end
+
   protected
+
   # @api private
   def _assignable?(o, guard)
     true
@@ -728,7 +736,7 @@ class PScalarDataType < PScalarType
   end
 
   def instance?(o, guard = nil)
-    return o.is_a?(String) || o.is_a?(Integer) || o.is_a?(Float) || o.is_a?(TrueClass) || o.is_a?(FalseClass)
+    return o.instance_of?(String) || o.is_a?(Integer) || o.is_a?(Float) || o.is_a?(TrueClass) || o.is_a?(FalseClass)
   end
 
   DEFAULT = PScalarDataType.new
@@ -750,13 +758,20 @@ end
 #
 class PEnumType < PScalarDataType
   def self.register_ptype(loader, ir)
-    create_ptype(loader, ir, 'ScalarDataType', 'values' => PArrayType.new(PStringType::NON_EMPTY))
+    create_ptype(loader, ir, 'ScalarDataType',
+      'values' => PArrayType.new(PStringType::NON_EMPTY),
+      'case_insensitive' => { 'type' => PBooleanType::DEFAULT, 'value' => false })
   end
 
-  attr_reader :values
+  attr_reader :values, :case_insensitive
 
-  def initialize(values)
+  def initialize(values, case_insensitive = false)
     @values = values.uniq.sort.freeze
+    @case_insensitive = case_insensitive
+  end
+
+  def case_insensitive?
+    @case_insensitive
   end
 
   # Returns Enumerator if no block is given, otherwise, calls the given
@@ -786,15 +801,19 @@ class PEnumType < PScalarDataType
   end
 
   def hash
-    @values.hash
+    @values.hash ^ @case_insensitive.hash
   end
 
   def eql?(o)
-    self.class == o.class && @values == o.values
+    self.class == o.class && @values == o.values && @case_insensitive == o.case_insensitive?
   end
 
   def instance?(o, guard = nil)
-    o.is_a?(String) && @values.any? { |p| p == o }
+    if o.is_a?(String)
+      @case_insensitive ? @values.any? { |p| p.casecmp(o) == 0 } : @values.any? { |p| p == o }
+    else
+      false
+    end
   end
 
   DEFAULT = PEnumType.new(EMPTY_ARRAY)
@@ -813,13 +832,28 @@ class PEnumType < PScalarDataType
         # if the contained string is found in the set of enums
         instance?(o.value, guard)
       when PEnumType
-        !o.values.empty? && o.values.all? { |s| instance?(s, guard) }
+        !o.values.empty? && (case_insensitive? || !o.case_insensitive?) && o.values.all? { |s| instance?(s, guard) }
       else
         false
     end
   end
 end
 
+INTEGER_HEX = '(?:0[xX][0-9A-Fa-f]+)'
+INTEGER_OCT = '(?:0[0-7]+)'
+INTEGER_BIN = '(?:0[bB][01]+)'
+INTEGER_DEC = '(?:0|[1-9]\d*)'
+INTEGER_DEC_OR_OCT = '(?:\d+)'
+SIGN_PREFIX = '[+-]?\s*'
+
+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_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'
+
 # @api public
 #
 class PNumericType < PScalarDataType
@@ -833,7 +867,7 @@ class PNumericType < PScalarDataType
   def self.new_function(type)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_numeric, type.loader) do
       local_types do
-        type 'Convertible = Variant[Undef, Integer, Float, Boolean, String, Timespan, Timestamp]'
+        type "Convertible = Variant[Integer, Float, Boolean, Pattern[/#{FLOAT_PATTERN}/], Timespan, Timestamp]"
         type 'NamedArgs   = Struct[{from => Convertible, Optional[abs] => Boolean}]'
       end
 
@@ -846,6 +880,11 @@ class PNumericType < PScalarDataType
         param          'NamedArgs',  :hash_args
       end
 
+      argument_mismatch :on_error do
+        param          'Any',     :from
+        optional_param 'Boolean', :abs
+      end
+
       def from_args(from, abs = false)
         result = from_convertible(from)
         abs ? result.abs : result
@@ -857,8 +896,6 @@ class PNumericType < PScalarDataType
 
       def from_convertible(from)
         case from
-        when NilClass
-          throw :undefined_value
         when Float
           from
         when Integer
@@ -869,21 +906,31 @@ class PNumericType < PScalarDataType
           1
         when FalseClass
           0
-        when String
+        else
           begin
-            if from[0] == '0' && (from[1].downcase == 'b' || from[1].downcase == 'x')
-              Integer(from)
-            else
-              Puppet::Pops::Utils.to_n(from)
+            if from[0] == '0'
+              second_char = (from[1] || '').downcase
+              if second_char == 'b' || second_char == 'x'
+                # use built in conversion
+                return Integer(from)
+              end
             end
+
+            Puppet::Pops::Utils.to_n(from)
           rescue TypeError => e
             raise TypeConversionError.new(e.message)
           rescue ArgumentError => e
             raise TypeConversionError.new(e.message)
           end
+        end
+      end
+
+      def on_error(from, abs = false)
+        if from.is_a?(String)
+          _("The string '%{str}' cannot be converted to Numeric") % { str: from }
         else
-          t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
-          raise TypeConversionError.new("Value of type '#{t}' cannot be converted to Numeric")
+          t = TypeCalculator.singleton.infer(from).generalize
+          _("Value of type %{type} cannot be converted to Numeric") % { type: t }
         end
       end
     end
@@ -1044,7 +1091,7 @@ class PIntegerType < PNumericType
     @@new_function ||= Puppet::Functions.create_loaded_function(:new, loader) do
       local_types do
         type 'Radix       = Variant[Default, Integer[2,2], Integer[8,8], Integer[10,10], Integer[16,16]]'
-        type 'Convertible = Variant[Undef, Numeric, Boolean, String, Timespan, Timestamp]'
+        type "Convertible = Variant[Numeric, Boolean, Pattern[/#{INTEGER_PATTERN_LENIENT}/], Timespan, Timestamp]"
         type 'NamedArgs   = Struct[{from => Convertible, Optional[radix] => Radix, Optional[abs] => Boolean}]'
       end
 
@@ -1058,6 +1105,16 @@ class PIntegerType < PNumericType
         param          'NamedArgs',  :hash_args
       end
 
+      argument_mismatch :on_error_hash do
+        param          'Hash',  :hash_args
+      end
+
+      argument_mismatch :on_error do
+        param          'Any',     :from
+        optional_param 'Integer', :radix
+        optional_param 'Boolean', :abs
+      end
+
       def from_args(from, radix = :default, abs = false)
         result = from_convertible(from, radix)
         abs ? result.abs : result
@@ -1069,8 +1126,6 @@ class PIntegerType < PNumericType
 
       def from_convertible(from, radix)
         case from
-        when NilClass
-          throw :undefined_value
         when Float, Time::TimeData
           from.to_i
         when Integer
@@ -1079,9 +1134,9 @@ class PIntegerType < PNumericType
           1
         when FalseClass
           0
-        when String
+        else
           begin
-            radix == :default ? Integer(from) : Integer(from, assert_radix(radix))
+            radix == :default ? Integer(from) : Integer(from, radix)
           rescue TypeError => e
             raise TypeConversionError.new(e.message)
           rescue ArgumentError => e
@@ -1097,17 +1152,34 @@ class PIntegerType < PNumericType
             end
             raise TypeConversionError.new(e.message)
           end
+        end
+      end
+
+      def on_error_hash(args_hash)
+        if args_hash.include?('from')
+          from = args_hash['from']
+          return on_error(from) unless loader.load(:type, 'convertible').instance?(from)
+        end
+        radix = args_hash['radix']
+        assert_radix(radix) unless radix.nil? || radix == :default
+        TypeAsserter.assert_instance_of('Integer.new', loader.load(:type, 'namedargs'), args_hash)
+      end
+
+      def on_error(from, radix = :default, abs = nil)
+        assert_radix(radix) unless radix == :default
+        if from.is_a?(String)
+          _("The string '%{str}' cannot be converted to Integer") % { str: from }
         else
-          t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
-          raise TypeConversionError.new("Value of type '#{t}' cannot be converted to an Integer")
+          t = TypeCalculator.singleton.infer(from).generalize
+          _("Value of type %{type} cannot be converted to Integer") % { type: t }
         end
       end
 
       def assert_radix(radix)
         case radix
-        when 2, 8, 10, 16, :default
+        when 2, 8, 10, 16
         else
-          raise ArgumentError.new("Illegal radix: '#{radix}', expected 2, 8, 10, 16, or default")
+          raise ArgumentError.new(_("Illegal radix: %{radix}, expected 2, 8, 10, 16, or default") % { radix: radix })
         end
         radix
       end
@@ -1154,7 +1226,7 @@ class PFloatType < PNumericType
   def self.new_function(type)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_float, type.loader) do
       local_types do
-        type 'Convertible = Variant[Undef, Numeric, Boolean, String, Timespan, Timestamp]'
+        type "Convertible = Variant[Numeric, Boolean, Pattern[/#{FLOAT_PATTERN}/], Timespan, Timestamp]"
         type 'NamedArgs   = Struct[{from => Convertible, Optional[abs] => Boolean}]'
       end
 
@@ -1167,6 +1239,11 @@ class PFloatType < PNumericType
         param          'NamedArgs',  :hash_args
       end
 
+      argument_mismatch :on_error do
+        param          'Any',     :from
+        optional_param 'Boolean', :abs
+      end
+
       def from_args(from, abs = false)
         result = from_convertible(from)
         abs ? result.abs : result
@@ -1178,8 +1255,6 @@ class PFloatType < PNumericType
 
       def from_convertible(from)
         case from
-        when NilClass
-          throw :undefined_value
         when Float
           from
         when Integer
@@ -1190,10 +1265,10 @@ class PFloatType < PNumericType
           1.0
         when FalseClass
           0.0
-        when String
+        else
           begin
             # support a binary as float
-            if from[0] == '0' && from[1].downcase == 'b'
+            if from[0] == '0' && from[1].casecmp('b').zero?
               from = Integer(from)
             end
             Float(from)
@@ -1212,9 +1287,15 @@ class PFloatType < PNumericType
             end
             raise TypeConversionError.new(e.message)
           end
+        end
+      end
+
+      def on_error(from, _ = false)
+        if from.is_a?(String)
+          _("The string '%{str}' cannot be converted to Float") % { str: from }
         else
-          t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
-          raise TypeConversionError.new("Value of type '#{t}' cannot be converted to Float")
+          t = TypeCalculator.singleton.infer(from).generalize
+          _("Value of type %{type} cannot be converted to Float") % { type: t }
         end
       end
     end
@@ -1238,7 +1319,7 @@ class PCollectionType < PAnyType
   attr_reader :size_type
 
   def initialize(size_type)
-    @size_type = size_type
+    @size_type = size_type.nil? ? nil : size_type.to_size
   end
 
   def accept(visitor, guard)
@@ -1435,7 +1516,7 @@ class PStringType < PScalarDataType
       end
       size_type_or_value = deprecated_multi_args[0]
     end
-    @size_type_or_value = size_type_or_value
+    @size_type_or_value = size_type_or_value.is_a?(PIntegerType) ? size_type_or_value.to_size : size_type_or_value
   end
 
   def accept(visitor, guard)
@@ -1576,7 +1657,7 @@ class PStringType < PScalarDataType
         # Must match exactly when value is a string
         @size_type_or_value.nil? || @size_type_or_value == o.size_type_or_value
       when PEnumType
-        @size_type_or_value.nil? ? true : o.values.size == 1 && @size_type_or_value == o.values[0]
+        @size_type_or_value.nil? ? true : o.values.size == 1 && !o.case_insensitive? && o.values[0]
       when PPatternType
         @size_type_or_value.nil?
       else
@@ -1605,10 +1686,11 @@ class PRegexpType < PScalarType
     @new_function ||= Puppet::Functions.create_loaded_function(:new_float, type.loader) do
       dispatch :from_string do
         param 'String', :pattern
+        optional_param 'Boolean', :escape
       end
 
-      def from_string(pattern)
-        Regexp.new(pattern)
+      def from_string(pattern, escape = false)
+        Regexp.new(escape ? Regexp.escape(pattern) : pattern)
       end
     end
   end
@@ -1618,36 +1700,13 @@ class PRegexpType < PScalarType
   # @param regexp [Regexp] the regular expression
   # @return [String] the Regexp as a slash delimited string with slashes escaped
   def self.regexp_to_s_with_delimiters(regexp)
-    regexp.options == 0 ? regexp.inspect : "/#{regexp.to_s}/"
+    regexp.options == 0 ? regexp.inspect : "/#{regexp}/"
   end
 
   # @param regexp [Regexp] the regular expression
   # @return [String] the Regexp as a string without escaped slash
   def self.regexp_to_s(regexp)
-    # Rubies < 2.0.0 retains escaped delimiters in the source string.
-    @source_retains_escaped_slash ||= Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('2.0.0')
-    source = regexp.source
-    if @source_retains_escaped_slash && source.include?('\\')
-      # Restore corrupt string in rubies <2.0.0, i.e. turn '\/' into '/' but
-      # don't touch valid escapes such as '\s', '\{' etc.
-      escaped = false
-      bld = ''
-      source.each_codepoint do |codepoint|
-        if escaped
-          bld << 0x5c unless codepoint == 0x2f # '/'
-          bld << codepoint
-          escaped = false
-        elsif codepoint == 0x5c # '\'
-          escaped = true
-        elsif codepoint <= 0x7f
-          bld << codepoint
-        else
-          bld << [codepoint].pack('U')
-        end
-      end
-      source = bld
-    end
-    append_flags_group(source, regexp.options)
+    append_flags_group(regexp.source, regexp.options)
   end
 
   def self.append_flags_group(rx_string, options)
@@ -1785,46 +1844,73 @@ class PBooleanType < PScalarDataType
     create_ptype(loader, ir, 'ScalarDataType')
   end
 
+  attr_reader :value
+
+  def initialize(value = nil)
+    @value = value
+  end
+
+  def eql?(o)
+    o.is_a?(PBooleanType) && @value == o.value
+  end
+
+  def generalize
+    PBooleanType::DEFAULT
+  end
+
+  def hash
+    31 ^ @value.hash
+  end
+
   def instance?(o, guard = nil)
-    o == true || o == false
+    (o == true || o == false) && (@value.nil? || value == o)
   end
 
   def self.new_function(type)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_boolean, type.loader) do
       dispatch :from_args do
-        param          'Variant[Undef, Integer, Float, Boolean, String]',  :from
+        param "Variant[Integer, Float, Boolean, Enum['false','true','yes','no','y','n',true]]",  :from
+      end
+
+      argument_mismatch :on_error do
+        param  'Any', :from
       end
 
       def from_args(from)
         from = from.downcase if from.is_a?(String)
         case from
-        when NilClass
-          throw :undefined_value
         when Float
           from != 0.0
         when Integer
           from != 0
-        when true, false
-          from
-        when 'false', 'no', 'n'
+        when false, 'false', 'no', 'n'
           false
-        when 'true', 'yes', 'y'
+        else
           true
+        end
+      end
+
+      def on_error(from)
+        if from.is_a?(String)
+          _("The string '%{str}' cannot be converted to Boolean") % { str: from }
         else
-          raise TypeConversionError.new("Value '#{from}' of type '#{from.class}' cannot be converted to Boolean")
+          t = TypeCalculator.singleton.infer(from).generalize
+          _("Value of type %{type} cannot be converted to Boolean") % { type: t }
         end
       end
     end
   end
 
   DEFAULT = PBooleanType.new
+  TRUE = PBooleanType.new(true)
+  FALSE = PBooleanType.new(false)
 
   protected
 
   # @api private
   #
   def _assignable?(o, guard)
-    o.is_a?(PBooleanType)
+    o.is_a?(PBooleanType) && (@value.nil? || @value == o.value)
   end
 end
 
@@ -1956,7 +2042,6 @@ class PStructType < PAnyType
     if self == DEFAULT
       PIterableType.new(PHashType::DEFAULT_KEY_PAIR_TUPLE)
     else
-      tc = TypeCalculator.singleton
       PIterableType.new(
         PTupleType.new([
           PVariantType.maybe_create(@elements.map {|se| se.key_type }),
@@ -2260,11 +2345,11 @@ class PCallableType < PAnyType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
       'param_types' => {
-        KEY_TYPE => POptionalType.new(PTupleType::DEFAULT),
+        KEY_TYPE => POptionalType.new(PTypeType.new(PTupleType::DEFAULT)),
         KEY_VALUE => nil
       },
       'block_type' => {
-        KEY_TYPE => POptionalType.new(PCallableType::DEFAULT),
+        KEY_TYPE => POptionalType.new(PTypeType.new(PCallableType::DEFAULT)),
         KEY_VALUE => nil
       },
       'return_type' => {
@@ -2346,7 +2431,7 @@ class PCallableType < PAnyType
 
   # @api private
   def callable_args?(required_callable_t, guard)
-    # If the required callable is euqal or more specific than self, self is acceptable arguments
+    # If the required callable is equal or more specific than self, self is acceptable arguments
     required_callable_t.assignable?(self, guard)
   end
 
@@ -2503,41 +2588,43 @@ class PArrayType < PCollectionType
   def self.new_function(type)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_array, type.loader) do
 
-      dispatch :from_args do
-        param           'Any',  :from
-        optional_param  'Boolean',      :wrap
+      dispatch :to_array do
+        param           'Variant[Array,Hash,Binary,Iterable]', :from
+        optional_param  'Boolean[false]', :wrap
+      end
+
+      dispatch :wrapped do
+        param  'Any',           :from
+        param  'Boolean[true]', :wrap
       end
 
-      def from_args(from, wrap = false)
+      argument_mismatch :on_error do
+        param  'Any',             :from
+        optional_param 'Boolean', :wrap
+      end
+
+      def wrapped(from, _)
+        from.is_a?(Array) ? from : [from]
+      end
+
+      def to_array(from, _ = false)
         case from
-        when NilClass
-          if wrap
-            [nil]
-          else
-            throw :undefined_value
-          end
         when Array
           from
         when Hash
-          wrap ? [from] : from.to_a
-
+          from.to_a
         when PBinaryType::Binary
           # For older rubies, the #bytes method returns an Enumerator that must be rolled out
-          wrap ? [from] : from.binary_buffer.bytes.to_a
-
+          from.binary_buffer.bytes.to_a
         else
-          if wrap
-            [from]
-          else
-            if PIterableType::DEFAULT.instance?(from)
-              Iterable.on(from).to_a
-            else
-              t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
-              raise TypeConversionError.new("Value of type '#{t}' cannot be converted to Array")
-            end
-          end
+          Iterable.on(from).to_a
         end
       end
+
+      def on_error(from, _ = false)
+        t = TypeCalculator.singleton.infer(from).generalize
+        _("Value of type %{type} cannot be converted to Array") % { type: t }
+      end
     end
   end
 
@@ -2738,14 +2825,12 @@ class PHashType < PCollectionType
 
       def from_array(from)
         case from
-        when NilClass
-          throw :undefined_value
         when Array
           if from.size == 0
             {}
           else
             unless from.size % 2 == 0
-              raise TypeConversionError.new("odd number of arguments for Hash")
+              raise TypeConversionError.new(_('odd number of arguments for Hash'))
             end
             Hash[*from]
           end
@@ -2755,8 +2840,8 @@ class PHashType < PCollectionType
           if PIterableType::DEFAULT.instance?(from)
             Hash[*Iterable.on(from).to_a]
           else
-            t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
-            raise TypeConversionError.new("Value of type '#{t}' cannot be converted to Hash")
+            t = TypeCalculator.singleton.infer(from).generalize
+            raise TypeConversionError.new(_("Value of type %{type} cannot be converted to Hash") % { type: t })
           end
         end
       end
@@ -2924,6 +3009,20 @@ class PVariantType < PAnyType
 
   DEFAULT = PVariantType.new(EMPTY_ARRAY)
 
+  def assignable?(o, guard = nil)
+    # an empty Variant does not match Undef (it is void - not even undef)
+    if o.is_a?(PUndefType) && types.empty?
+      return false
+    end
+
+    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) }
+  end
+
   protected
 
   # @api private
@@ -2948,8 +3047,9 @@ class PVariantType < PAnyType
 
   # @api private
   def merge_enums(array)
+    # Merge case sensitive enums and strings
     if array.size > 1
-      parts = array.partition {|t| t.is_a?(PEnumType) && !t.values.empty? || t.is_a?(PStringType) && !t.value.nil? }
+      parts = array.partition {|t| t.is_a?(PEnumType) && !t.values.empty? && !t.case_insensitive? || t.is_a?(PStringType) && !t.value.nil? }
       enums = parts[0]
       if enums.size > 1
         others = parts[1]
@@ -2957,6 +3057,20 @@ class PVariantType < PAnyType
         array = others
       end
     end
+
+    # Merge case insensitive enums
+    if array.size > 1
+      parts = array.partition {|t| t.is_a?(PEnumType) && !t.values.empty? && t.case_insensitive? }
+      enums = parts[0]
+      if enums.size > 1
+        others = parts[1]
+        values = []
+        enums.each { |enum| enum.values.each { |value| values << value.downcase }}
+        values.uniq!
+        others <<  PEnumType.new(values, true)
+        array = others
+      end
+    end
     array
   end
 
@@ -3513,6 +3627,8 @@ require_relative 'p_timespan_type'
 require_relative 'p_timestamp_type'
 require_relative 'p_binary_type'
 require_relative 'p_init_type'
+require_relative 'p_object_type_extension'
+require_relative 'p_uri_type'
 require_relative 'type_set_reference'
 require_relative 'implementation_registry'
 require_relative 'tree_iterators'