puppet 4.0.0 → 4.5.0

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

@@ -1,24 +1,24 @@
+module Puppet::Pops
+module Evaluator
 # AccessOperator handles operator []
 # This operator is part of evaluation.
 #
-class Puppet::Pops::Evaluator::AccessOperator
+class AccessOperator
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
-  include Puppet::Pops::Evaluator::Runtime3Support
+  include Runtime3Support
 
-  Issues = Puppet::Pops::Issues
-  TYPEFACTORY = Puppet::Pops::Types::TypeFactory
   EMPTY_STRING = ''.freeze
 
   attr_reader :semantic
 
   # Initialize with AccessExpression to enable reporting issues
-  # @param access_expression [Puppet::Pops::Model::AccessExpression] the semantic object being evaluated
+  # @param access_expression [Model::AccessExpression] the semantic object being evaluated
   # @return [void]
   #
   def initialize(access_expression)
-    @@access_visitor ||= Puppet::Pops::Visitor.new(self, "access", 2, nil)
+    @@access_visitor ||= Visitor.new(self, "access", 2, nil)
     @semantic = access_expression
   end
 
@@ -36,10 +36,10 @@ class Puppet::Pops::Evaluator::AccessOperator
     keys.flatten!
     result = case keys.size
     when 0
-      fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+      fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       # Note that Ruby 1.8.7 requires a length of 1 to produce a String
-      k1 = coerce_numeric(keys[0], @semantic.keys, scope)
+      k1 = coerce_numeric(keys[0], @semantic.keys[0], scope)
       bad_access_key_type(o, 0, k1, Integer) unless k1.is_a?(Integer)
       k2 = 1
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos
@@ -50,8 +50,8 @@ class Puppet::Pops::Evaluator::AccessOperator
         o[ k1, k2 ]
       end
     when 2
-      k1 = coerce_numeric(keys[0], @semantic.keys, scope)
-      k2 = coerce_numeric(keys[1], @semantic.keys, scope)
+      k1 = coerce_numeric(keys[0], @semantic.keys[0], scope)
+      k2 = coerce_numeric(keys[1], @semantic.keys[1], scope)
       [k1, k2].each_with_index { |k,i| bad_access_key_type(o, i, k, Integer) unless k.is_a?(Integer) }
 
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos (negative is count from end)
@@ -63,7 +63,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       end
       o[ k1, k2 ]
     else
-      fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+      fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     end
     # Specified as: an index outside of range, or empty result == empty string
     (result.nil? || result.empty?) ? EMPTY_STRING : result
@@ -75,10 +75,10 @@ class Puppet::Pops::Evaluator::AccessOperator
     keys.flatten!
     unless keys.size == 1
       blamed = keys.size == 0 ? @semantic : @semantic.keys[1]
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed, :base_type => o, :min=>1, :actual => keys.size)
+      fail(Issues::BAD_TYPE_SLICE_ARITY, blamed, :base_type => o, :min=>1, :actual => keys.size)
     end
     assert_keys(keys, o, 1, 1, String, Regexp)
-    Puppet::Pops::Types::TypeFactory.regexp(*keys)
+    Types::TypeFactory.regexp(*keys)
   end
 
   # Evaluates <ary>[] with 1 or 2 arguments. One argument is an index lookup, two arguments is a slice from/to.
@@ -87,7 +87,7 @@ class Puppet::Pops::Evaluator::AccessOperator
     keys.flatten!
     case keys.size
     when 0
-      fail(Puppet::Pops::Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+      fail(Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       key = coerce_numeric(keys[0], @semantic.keys[0], scope)
       unless key.is_a?(Integer)
@@ -114,7 +114,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       result = o[ k1, k2 ]
       result.nil? ? [] : result
     else
-      fail(Puppet::Pops::Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+      fail(Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     end
   end
 
@@ -132,7 +132,7 @@ class Puppet::Pops::Evaluator::AccessOperator
     end
     case result.size
     when 0
-      fail(Puppet::Pops::Issues::BAD_HASH_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+      fail(Issues::BAD_HASH_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       result.pop
     else
@@ -145,38 +145,41 @@ class Puppet::Pops::Evaluator::AccessOperator
   def access_PEnumType(o, scope, keys)
     keys.flatten!
     assert_keys(keys, o, 1, Float::INFINITY, String)
-    Puppet::Pops::Types::TypeFactory.enum(*keys)
+    Types::TypeFactory.enum(*keys)
   end
 
   def access_PVariantType(o, scope, keys)
     keys.flatten!
-    assert_keys(keys, o, 1, Float::INFINITY, Puppet::Pops::Types::PAnyType)
-    Puppet::Pops::Types::TypeFactory.variant(*keys)
+    assert_keys(keys, o, 1, Float::INFINITY, Types::PAnyType)
+    Types::TypeFactory.variant(*keys)
+  end
+
+  def access_PSemVerType(o, scope, keys)
+    keys.flatten!
+    assert_keys(keys, o, 1, Float::INFINITY, String, Semantic::VersionRange)
+    Types::TypeFactory.sem_ver(*keys)
   end
 
   def access_PTupleType(o, scope, keys)
     keys.flatten!
-    if TYPEFACTORY.is_range_parameter?(keys[-2]) && TYPEFACTORY.is_range_parameter?(keys[-1])
-      size_type = TYPEFACTORY.range(keys[-2], keys[-1])
+    if Types::TypeFactory.is_range_parameter?(keys[-2]) && Types::TypeFactory.is_range_parameter?(keys[-1])
+      size_type = Types::TypeFactory.range(keys[-2], keys[-1])
       keys = keys[0, keys.size - 2]
-    elsif TYPEFACTORY.is_range_parameter?(keys[-1])
-      size_type = TYPEFACTORY.range(keys[-1], :default)
+    elsif Types::TypeFactory.is_range_parameter?(keys[-1])
+      size_type = Types::TypeFactory.range(keys[-1], :default)
       keys = keys[0, keys.size - 1]
     end
-    assert_keys(keys, o, 1, Float::INFINITY, Puppet::Pops::Types::PAnyType)
-    t = Puppet::Pops::Types::TypeFactory.tuple(*keys)
-    # set size type, or nil for default (exactly 1)
-    t.size_type = size_type
-    t
+    assert_keys(keys, o, 1, Float::INFINITY, Types::PAnyType)
+    Types::TypeFactory.tuple(keys, size_type)
   end
 
   def access_PCallableType(o, scope, keys)
-    TYPEFACTORY.callable(*keys)
+    Types::TypeFactory.callable(*keys)
   end
 
   def access_PStructType(o, scope, keys)
     assert_keys(keys, o, 1, 1, Hash)
-    TYPEFACTORY.struct(keys[0])
+    Types::TypeFactory.struct(keys[0])
   end
 
   def access_PStringType(o, scope, keys)
@@ -187,11 +190,9 @@ class Puppet::Pops::Evaluator::AccessOperator
     when 2
       size_t = collection_size_t(0, keys[0], keys[1])
     else
-      fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic, {:actual => keys.size})
+      fail(Issues::BAD_STRING_SLICE_ARITY, @semantic, {:actual => keys.size})
     end
-    string_t = Puppet::Pops::Types::TypeFactory.string()
-    string_t.size_type = size_t
-    string_t
+    Types::TypeFactory.string(size_t)
   end
 
   # Asserts type of each key and calls fail with BAD_TYPE_SPECIFICATION
@@ -205,7 +206,7 @@ class Puppet::Pops::Evaluator::AccessOperator
   def assert_keys(keys, o, min, max, *allowed_classes)
     size = keys.size
     unless size.between?(min, max || Float::INFINITY)
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>1, :max => max, :actual => keys.size)
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>1, :max => max, :actual => keys.size)
     end
     keys.each_with_index do |k, i|
       unless allowed_classes.any? {|clazz| k.is_a?(clazz) }
@@ -215,7 +216,7 @@ class Puppet::Pops::Evaluator::AccessOperator
   end
 
   def bad_access_key_type(lhs, key_index, actual, *expected_classes)
-    fail(Puppet::Pops::Issues::BAD_SLICE_KEY_TYPE, @semantic.keys[key_index], {
+    fail(Issues::BAD_SLICE_KEY_TYPE, @semantic.keys[key_index], {
       :left_value => lhs,
       :actual => bad_key_type_name(actual),
       :expected_classes => expected_classes
@@ -229,14 +230,14 @@ class Puppet::Pops::Evaluator::AccessOperator
     when :default
       'Default'
     else
-      Puppet::Pops::Types::TypeCalculator.generalize!(Puppet::Pops::Types::TypeCalculator.infer(actual)).to_s
+      Types::TypeCalculator.generalize(Types::TypeCalculator.infer(actual)).to_s
     end
   end
 
   def bad_type_specialization_key_type(type, key_index, actual, *expected_classes)
-    label_provider = Puppet::Pops::Model::ModelLabelProvider.new()
+    label_provider = Model::ModelLabelProvider.new()
     expected = expected_classes.map {|c| label_provider.label(c) }.join(' or ')
-    fail(Puppet::Pops::Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[key_index], {
+    fail(Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[key_index], {
       :type => type,
       :message => "Cannot use #{bad_key_type_name(actual)} where #{expected} is expected"
     })
@@ -244,35 +245,90 @@ class Puppet::Pops::Evaluator::AccessOperator
 
   def access_PPatternType(o, scope, keys)
     keys.flatten!
-    assert_keys(keys, o, 1, Float::INFINITY, String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::Types::PRegexpType)
-    Puppet::Pops::Types::TypeFactory.pattern(*keys)
+    assert_keys(keys, o, 1, Float::INFINITY, String, Regexp, Types::PPatternType, Types::PRegexpType)
+    Types::TypeFactory.pattern(*keys)
   end
 
   def access_POptionalType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
-      unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
-        fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => keys[0].class})
+      type = keys[0]
+      unless type.is_a?(Types::PAnyType)
+        if type.is_a?(String)
+          type = Types::TypeFactory.string(nil, type)
+        else
+          fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => type.class})
+        end
       end
-      result = Puppet::Pops::Types::POptionalType.new()
-      result.optional_type = keys[0]
-      result
+      Types::POptionalType.new(type)
+    else
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Optional-Type', :min => 1, :actual => keys.size})
+    end
+  end
+
+  def access_PObjectType(o, scope, keys)
+    keys.flatten!
+    if keys.size == 1
+      Types::TypeFactory.object(keys[0])
     else
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Optional-Type', :min => 1, :actual => keys.size})
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Object-Type', :min => 1, :actual => keys.size})
+    end
+  end
+
+  def access_PNotUndefType(o, scope, keys)
+    keys.flatten!
+    case keys.size
+    when 0
+      Types::TypeFactory.not_undef
+    when 1
+      type = keys[0]
+      case type
+      when String
+        type = Types::TypeFactory.string(nil, type)
+      when Types::PAnyType
+        type = nil if type.class == Types::PAnyType
+      else
+        fail(Issues::BAD_NOT_UNDEF_SLICE_TYPE, @semantic.keys[0], {:base_type => 'NotUndef-Type', :actual => type.class})
+      end
+      Types::TypeFactory.not_undef(type)
+    else
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'NotUndef-Type', :min => 0, :max => 1, :actual => keys.size})
     end
   end
 
   def access_PType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
-      unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
-        fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Type-Type', :actual => keys[0].class})
+      unless keys[0].is_a?(Types::PAnyType)
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Type-Type', :actual => keys[0].class})
       end
-      result = Puppet::Pops::Types::PType.new()
-      result.type = keys[0]
-      result
+      Types::PType.new(keys[0])
     else
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Type-Type', :min => 1, :actual => keys.size})
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Type-Type', :min => 1, :actual => keys.size})
+    end
+  end
+
+  def access_PIterableType(o, scope, keys)
+    keys.flatten!
+    if keys.size == 1
+      unless keys[0].is_a?(Types::PAnyType)
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Iterable-Type', :actual => keys[0].class})
+      end
+      Types::PIterableType.new(keys[0])
+    else
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Iterable-Type', :min => 1, :actual => keys.size})
+    end
+  end
+
+  def access_PIteratorType(o, scope, keys)
+    keys.flatten!
+    if keys.size == 1
+      unless keys[0].is_a?(Types::PAnyType)
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Iterator-Type', :actual => keys[0].class})
+      end
+      Types::PIteratorType.new(keys[0])
+    else
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Iterator-Type', :min => 1, :actual => keys.size})
     end
   end
 
@@ -280,39 +336,34 @@ class Puppet::Pops::Evaluator::AccessOperator
     keys.flatten!
     assert_keys(keys, o, 2, 2, String, String)
     # create runtime type based on runtime and name of class, (not inference of key's type)
-    Puppet::Pops::Types::TypeFactory.runtime(*keys)
+    Types::TypeFactory.runtime(*keys)
   end
 
   def access_PIntegerType(o, scope, keys)
     keys.flatten!
     unless keys.size.between?(1, 2)
-      fail(Puppet::Pops::Issues::BAD_INTEGER_SLICE_ARITY, @semantic, {:actual => keys.size})
+      fail(Issues::BAD_INTEGER_SLICE_ARITY, @semantic, {:actual => keys.size})
     end
     keys.each_with_index do |x, index|
-      fail(Puppet::Pops::Issues::BAD_INTEGER_SLICE_TYPE, @semantic.keys[index],
+      fail(Issues::BAD_INTEGER_SLICE_TYPE, @semantic.keys[index],
         {:actual => x.class}) unless (x.is_a?(Integer) || x == :default)
     end
-    ranged_integer = Puppet::Pops::Types::PIntegerType.new()
-    from, to = keys
-    ranged_integer.from = from == :default ? nil : from
-    ranged_integer.to = to == :default ? nil : to
-    ranged_integer
+    Types::PIntegerType.new(*keys)
   end
 
   def access_PFloatType(o, scope, keys)
     keys.flatten!
     unless keys.size.between?(1, 2)
-      fail(Puppet::Pops::Issues::BAD_FLOAT_SLICE_ARITY, @semantic, {:actual => keys.size})
+      fail(Issues::BAD_FLOAT_SLICE_ARITY, @semantic, {:actual => keys.size})
     end
     keys.each_with_index do |x, index|
-      fail(Puppet::Pops::Issues::BAD_FLOAT_SLICE_TYPE, @semantic.keys[index],
+      fail(Issues::BAD_FLOAT_SLICE_TYPE, @semantic.keys[index],
         {:actual => x.class}) unless (x.is_a?(Float) || x.is_a?(Integer) || x == :default)
     end
-    ranged_float = Puppet::Pops::Types::PFloatType.new()
     from, to = keys
-    ranged_float.from = from == :default || from.nil? ? nil : Float(from)
-    ranged_float.to = to == :default || to.nil? ? nil : Float(to)
-    ranged_float
+    from = from == :default || from.nil? ? nil : Float(from)
+    to = to == :default || to.nil? ? nil : Float(to)
+    Types::PFloatType.new(from, to)
   end
 
   # A Hash can create a new Hash type, one arg sets value type, two args sets key and value type in new type.
@@ -321,36 +372,29 @@ class Puppet::Pops::Evaluator::AccessOperator
   #
   def access_PHashType(o, scope, keys)
     keys.flatten!
+    if keys.size == 2 && keys[0].is_a?(Integer) && keys[1].is_a?(Integer)
+      return Types::PHashType.new(nil, nil, Types::PIntegerType.new(*keys))
+    end
+
     keys[0,2].each_with_index do |k, index|
-      unless k.is_a?(Puppet::Pops::Types::PAnyType)
-        fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[index], {:base_type => 'Hash-Type', :actual => k.class})
+      unless k.is_a?(Types::PAnyType)
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[index], {:base_type => 'Hash-Type', :actual => k.class})
       end
     end
     case keys.size
     when 2
-      result = Puppet::Pops::Types::PHashType.new()
-      result.key_type = keys[0]
-      result.element_type = keys[1]
-      result
+      size_t = nil
     when 3
-      result = Puppet::Pops::Types::PHashType.new()
-      result.key_type = keys[0]
-      result.element_type = keys[1]
-      size_t = collection_size_t(1, keys[2])
-      result
+      size_t = keys[2]
+      size_t = Types::PIntegerType.new(size_t) unless size_t.is_a?(Types::PIntegerType)
     when 4
-      result = Puppet::Pops::Types::PHashType.new()
-      result.key_type = keys[0]
-      result.element_type = keys[1]
-      size_t = collection_size_t(1, keys[2], keys[3])
-      result
+      size_t = collection_size_t(2, keys[2], keys[3])
     else
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {
         :base_type => 'Hash-Type', :min => 2, :max => 4, :actual => keys.size
       })
     end
-    result.size_type = size_t if size_t
-    result
+    Types::PHashType.new(keys[0], keys[1], size_t)
   end
 
   # CollectionType is parameterized with a range
@@ -358,16 +402,14 @@ class Puppet::Pops::Evaluator::AccessOperator
     keys.flatten!
     case keys.size
     when 1
-      size_t = collection_size_t(1, keys[0])
+      size_t = collection_size_t(0, keys[0])
     when 2
-      size_t = collection_size_t(1, keys[0], keys[1])
+      size_t = collection_size_t(0, keys[0], keys[1])
     else
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic,
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic,
         {:base_type => 'Collection-Type', :min => 1, :max => 2, :actual => keys.size})
     end
-    result = Puppet::Pops::Types::PCollectionType.new()
-    result.size_type = size_t
-    result
+    Types::PCollectionType.new(nil, size_t)
   end
 
   # An Array can create a new Array type. It is not possible to create a collection of Array types.
@@ -376,38 +418,43 @@ class Puppet::Pops::Evaluator::AccessOperator
     keys.flatten!
     case keys.size
     when 1
+      unless keys[0].is_a?(Types::PAnyType)
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Array-Type', :actual => keys[0].class})
+      end
+      type = keys[0]
       size_t = nil
     when 2
-      size_t = collection_size_t(1, keys[1])
+      if keys[0].is_a?(Types::PAnyType)
+        size_t = collection_size_t(1, keys[1])
+        type = keys[0]
+      else
+        size_t = collection_size_t(0, keys[0], keys[1])
+        type = nil
+      end
     when 3
-      size_t = collection_size_t(1, keys[1], keys[2])
+      if keys[0].is_a?(Types::PAnyType)
+        size_t = collection_size_t(1, keys[1], keys[2])
+        type = keys[0]
+      else
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Array-Type', :actual => keys[0].class})
+      end
     else
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic,
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic,
         {:base_type => 'Array-Type', :min => 1, :max => 3, :actual => keys.size})
     end
-    unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Array-Type', :actual => keys[0].class})
-    end
-    result = Puppet::Pops::Types::PArrayType.new()
-    result.element_type = keys[0]
-    result.size_type = size_t
-    result
+    Types::PArrayType.new(type, size_t)
   end
 
   # Produces an PIntegerType (range) given one or two keys.
   def collection_size_t(start_index, *keys)
-    if keys.size == 1 && keys[0].is_a?(Puppet::Pops::Types::PIntegerType)
-      keys[0].copy
+    if keys.size == 1 && keys[0].is_a?(Types::PIntegerType)
+      keys[0]
     else
       keys.each_with_index do |x, index|
-        fail(Puppet::Pops::Issues::BAD_COLLECTION_SLICE_TYPE, @semantic.keys[start_index + index],
+        fail(Issues::BAD_COLLECTION_SLICE_TYPE, @semantic.keys[start_index + index],
           {:actual => x.class}) unless (x.is_a?(Integer) || x == :default)
       end
-      ranged_integer = Puppet::Pops::Types::PIntegerType.new()
-      from, to = keys
-      ranged_integer.from = from == :default ? nil : from
-      ranged_integer.to = to == :default ? nil : to
-      ranged_integer
+      Types::PIntegerType.new(*keys)
     end
   end
 
@@ -416,12 +463,17 @@ class Puppet::Pops::Evaluator::AccessOperator
   def access_Resource(o, scope, keys)
     # To access a Puppet::Resource as if it was a PResourceType, simply infer it, and take the type of
     # the parameterized meta type (i.e. Type[Resource[the_resource_type, the_resource_title]])
-    t = Puppet::Pops::Types::TypeCalculator.infer(o).type
+    t = Types::TypeCalculator.infer(o).type
     # must map "undefined title" from resource to nil
     t.title = nil if t.title == EMPTY_STRING
     access(t, scope, *keys)
   end
 
+  # If a type reference is encountered here, it's an error
+  def access_PTypeReferenceType(o, scope, keys)
+    fail(Issues::UNKNOWN_RESOURCE_TYPE, @semantic, {:type_name => o.type_string })
+  end
+
   # A Resource can create a new more specific Resource type, and/or an array of resource types
   # If the given type has title set, it can not be specified further.
   # @example
@@ -438,28 +490,28 @@ class Puppet::Pops::Evaluator::AccessOperator
     blamed = keys.size == 0 ? @semantic : @semantic.keys[0]
 
     if keys.size == 0
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed,
-        :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :max => -1, :actual => 0)
+      fail(Issues::BAD_TYPE_SLICE_ARITY, blamed,
+        :base_type => o.to_s, :min => 1, :max => -1, :actual => 0)
     end
 
     # Must know which concrete resource type to operate on in all cases.
     # It is not allowed to specify the type in an array arg - e.g. Resource[[File, 'foo']]
     # type_name is LHS type_name if set, else the first given arg
-    type_name = o.type_name || keys.shift
+    type_name = o.type_name || Types::TypeFormatter.singleton.capitalize_segments(keys.shift)
     type_name = case type_name
-    when Puppet::Pops::Types::PResourceType
+    when Types::PResourceType
       type_name.type_name
     when String
-      type_name.downcase
+      type_name
     else
       # blame given left expression if it defined the type, else the first given key expression
       blame = o.type_name.nil? ? @semantic.keys[0] : @semantic.left_expr
-      fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_SPECIALIZATION, blame, {:actual => bad_key_type_name(type_name)})
+      fail(Issues::ILLEGAL_RESOURCE_SPECIALIZATION, blame, {:actual => bad_key_type_name(type_name)})
     end
 
     # type name must conform
-    if type_name !~ Puppet::Pops::Patterns::CLASSREF
-      fail(Puppet::Pops::Issues::ILLEGAL_CLASSREF, blamed, {:name=>type_name})
+    if type_name !~ Patterns::CLASSREF_EXT
+      fail(Issues::ILLEGAL_CLASSREF, blamed, {:name=>type_name})
     end
 
     # The result is an array if multiple titles are given, or if titles are specified with an array
@@ -475,7 +527,7 @@ class Puppet::Pops::Evaluator::AccessOperator
     # Return an empty array
     #
     if keys.empty? && keys_orig_size > 0
-      optionally_fail(Puppet::Pops::Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
+      optionally_fail(Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
       return result_type_array ? [] : nil
     end
 
@@ -483,12 +535,12 @@ class Puppet::Pops::Evaluator::AccessOperator
       # lookup resource and return one or more parameter values
       resource = find_resource(scope, o.type_name, o.title)
       unless resource
-        fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => o.type_name, :title => o.title})
+        fail(Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => o.type_name, :title => o.title})
       end
 
       result = keys.map do |k|
         unless is_parameter_of_resource?(scope, resource, k)
-          fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
+          fail(Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
             {:type_name => o.type_name, :title => o.title, :param_name=>k})
         end
         get_resource_parameter_value(scope, resource, k)
@@ -501,16 +553,13 @@ class Puppet::Pops::Evaluator::AccessOperator
     result = keys.each_with_index.map do |t, i|
       unless t.is_a?(String) || t == :no_title
         index = keys_orig_size != keys.size ? i+1 : i
-        fail(Puppet::Pops::Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[index], {
+        fail(Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[index], {
           :type => o,
           :message => "Cannot use #{bad_key_type_name(t)} where a resource title String is expected"
         })
       end
 
-      rtype = Puppet::Pops::Types::PResourceType.new()
-      rtype.type_name = type_name
-      rtype.title = (t == :no_title ? nil : t)
-      rtype
+      Types::PResourceType.new(type_name, t == :no_title ? nil : t)
     end
     # returns single type if request was for a single entity, else an array of types (possibly empty)
     return result_type_array ? result : result.pop
@@ -521,8 +570,8 @@ class Puppet::Pops::Evaluator::AccessOperator
     keys_orig_size = keys.size
 
     if keys_orig_size == 0
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed,
-        :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :max => -1, :actual => 0)
+      fail(Issues::BAD_TYPE_SLICE_ARITY, blamed,
+        :base_type => o.to_s, :min => 1, :max => -1, :actual => 0)
     end
 
     # The result is an array if multiple classnames are given, or if classnames are specified with an array
@@ -537,7 +586,7 @@ class Puppet::Pops::Evaluator::AccessOperator
     # Return an empty array
     #
     if keys.empty? && keys_orig_size > 0
-      optionally_fail(Puppet::Pops::Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
+      optionally_fail(Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
       return result_type_array ? [] : nil
     end
 
@@ -547,20 +596,20 @@ class Puppet::Pops::Evaluator::AccessOperator
       # does not have a title. This should probably be deprecated.
       #
       result = keys.each_with_index.map do |c, i|
-        name = if c.is_a?(Puppet::Pops::Types::PResourceType) && !c.type_name.nil? && c.title.nil?
+        name = if c.is_a?(Types::PResourceType) && !c.type_name.nil? && c.title.nil?
                  # type_name is already downcase. Don't waste time trying to downcase again
                  c.type_name
                elsif c.is_a?(String)
                  c.downcase
+               elsif c.is_a?(Types::PTypeReferenceType)
+                 c.type_string.downcase
                else
-                 fail(Puppet::Pops::Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[i], {:name => c})
+                 fail(Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[i], {:name => c})
                end
 
-        if name =~ Puppet::Pops::Patterns::NAME
-          ctype = Puppet::Pops::Types::PHostClassType.new()
+        if name =~ Patterns::NAME
           # Remove leading '::' since all references are global, and 3x runtime does the wrong thing
-          ctype.class_name = name.sub(/^::/, EMPTY_STRING)
-          ctype
+          Types::PHostClassType.new(name.sub(/^::/, EMPTY_STRING))
         else
           fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c})
         end
@@ -573,12 +622,12 @@ class Puppet::Pops::Evaluator::AccessOperator
           if is_parameter_of_resource?(scope, resource, k)
             get_resource_parameter_value(scope, resource, k)
           else
-            fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
+            fail(Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
               {:type_name => 'Class', :title => o.class_name, :param_name=>k})
           end
         end
       else
-        fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => 'Class', :title => o.class_name})
+        fail(Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => 'Class', :title => o.class_name})
       end
     end
 
@@ -586,3 +635,5 @@ class Puppet::Pops::Evaluator::AccessOperator
     return result_type_array ? result : result.pop
   end
 end
+end
+end