diff --git a/lib/puppet/pops/evaluator/access_operator.rb b/lib/puppet/pops/evaluator/access_operator.rb
index fe1498fee..29a981538 100644
--- a/lib/puppet/pops/evaluator/access_operator.rb
+++ b/lib/puppet/pops/evaluator/access_operator.rb
@@ -1,593 +1,598 @@
 # AccessOperator handles operator []
 # This operator is part of evaluation.
 #
 class Puppet::Pops::Evaluator::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
 
   Issues = Puppet::Pops::Issues
   TYPEFACTORY = Puppet::Pops::Types::TypeFactory
 
   attr_reader :semantic
 
   # Initialize with AccessExpression to enable reporting issues
   # @param access_expression [Puppet::Pops::Model::AccessExpression] the semantic object being evaluated
   # @return [void]
   #
   def initialize(access_expression)
     @@access_visitor ||= Puppet::Pops::Visitor.new(self, "access", 2, nil)
     @semantic = access_expression
   end
 
   def access (o, scope, *keys)
     @@access_visitor.visit_this_2(self, o, scope, keys)
   end
 
   protected
 
   def access_Object(o, scope, keys)
     fail(Issues::OPERATOR_NOT_APPLICABLE, @semantic.left_expr, :operator=>'[]', :left_value => o)
   end
 
   def access_String(o, scope, keys)
     keys.flatten!
     result = case keys.size
     when 0
       fail(Puppet::Pops::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)
       bad_access_key_type(o, 0, k1, Integer) unless k1.is_a?(Integer)
       k2 = 1
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos
       # if k1 is outside, a length of 1 always produces an empty string
       if k1 < 0
         ''
       else
         o[ k1, k2 ]
       end
     when 2
       k1 = coerce_numeric(keys[0], @semantic.keys, scope)
       k2 = coerce_numeric(keys[1], @semantic.keys, 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)
       k2 = k2 < 0 ? o.length - k1 + k2 + 1 : k2  # abs length (negative k2 is length from pos to end count)
       # if k1 is outside, adjust to first position, and adjust length
       if k1 < 0
         k2 = k2 + k1
         k1 = 0
       end
       o[ k1, k2 ]
     else
       fail(Puppet::Pops::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?) ? '' : result
   end
 
   # Parameterizes a PRegexp Type with a pattern string or r ruby egexp
   #
   def access_PRegexpType(o, scope, keys)
     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)
     end
     assert_keys(keys, o, 1, 1, String, Regexp)
     Puppet::Pops::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.
   #
   def access_Array(o, scope, keys)
     keys.flatten!
     case keys.size
     when 0
       fail(Puppet::Pops::Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       k = coerce_numeric(keys[0], @semantic.keys[0], scope)
       unless k.is_a?(Integer)
         bad_access_key_type(o, 0, k, Integer)
       end
       o[k]
     when 2
       # A slice [from, to] with support for -1 to mean start, or end respectively.
       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) }
 
       # Help confused Ruby do the right thing (it truncates to the right, but negative index + length can never overlap
       # the available range.
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos (negative is count from end)
       k2 = k2 < 0 ? o.length - k1 + k2 + 1 : k2  # abs length (negative k2 is length from pos to end count)
       # if k1 is outside, adjust to first position, and adjust length
       if k1 < 0
         k2 = k2 + k1
         k1 = 0
       end
       # Help ruby always return empty array when asking for a sub array
       result = o[ k1, k2 ]
       result.nil? ? [] : result
     else
       fail(Puppet::Pops::Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     end
   end
 
 
   # Evaluates <hsh>[] with support for one or more arguments. If more than one argument is used, the result
   # is an array with each lookup.
   # @note
   #   Does not flatten its keys to enable looking up with a structure
   #
   def access_Hash(o, scope, keys)
     # Look up key in hash, if key is nil or :undef, try alternate form before giving up.
     # This makes :undef and nil "be the same key". (The alternative is to always only write one or the other
     # in all hashes - that is much harder to guarantee since the Hash is a regular Ruby hash.
     #
     result = keys.collect do |k|
       o.fetch(k) do |key|
         case key
         when nil
           o[:undef]
         when :undef
           o[:nil]
         else
           nil
         end
       end
     end
     case result.size
     when 0
       fail(Puppet::Pops::Issues::BAD_HASH_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       result.pop
     else
       # remove nil elements and return
       result.compact!
       result
     end
   end
 
   # Ruby does not have an infinity constant.  TODO: Consider having one constant in Puppet. Now it is in several places.
   INFINITY = 1.0 / 0.0
 
   def access_PEnumType(o, scope, keys)
     keys.flatten!
     assert_keys(keys, o, 1, INFINITY, String)
     Puppet::Pops::Types::TypeFactory.enum(*keys)
   end
 
   def access_PVariantType(o, scope, keys)
     keys.flatten!
     assert_keys(keys, o, 1, INFINITY, Puppet::Pops::Types::PAbstractType)
     Puppet::Pops::Types::TypeFactory.variant(*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])
       keys = keys[0, keys.size - 2]
     elsif TYPEFACTORY.is_range_parameter?(keys[-1])
       size_type = TYPEFACTORY.range(keys[-1], :default)
       keys = keys[0, keys.size - 1]
     end
     assert_keys(keys, o, 1, INFINITY, Puppet::Pops::Types::PAbstractType)
     t = Puppet::Pops::Types::TypeFactory.tuple(*keys)
     # set size type, or nil for default (exactly 1)
     t.size_type = size_type
     t
   end
 
   def access_PCallableType(o, scope, keys)
     TYPEFACTORY.callable(*keys)
   end
 
   def access_PStructType(o, scope, keys)
     assert_keys(keys, o, 1, 1, Hash)
     TYPEFACTORY.struct(keys[0])
   end
 
   def access_PStringType(o, scope, keys)
     keys.flatten!
     case keys.size
     when 1
       size_t = collection_size_t(0, keys[0])
     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})
     end
     string_t = Puppet::Pops::Types::TypeFactory.string()
     string_t.size_type = size_t
     string_t
   end
 
   # Asserts type of each key and calls fail with BAD_TYPE_SPECIFICATION
   # @param keys [Array<Object>] the evaluated keys
   # @param o [Object] evaluated LHS reported as :base_type
   # @param min [Integer] the minimum number of keys (typically 1)
   # @param max [Numeric] the maximum number of keys (use same as min, specific number, or INFINITY)
   # @param allowed_classes [Class] a variable number of classes that each key must be an instance of (any)
   # @api private
   #
   def assert_keys(keys, o, min, max, *allowed_classes)
     size = keys.size
     unless size.between?(min, max || INFINITY)
       fail(Puppet::Pops::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) }
         bad_type_specialization_key_type(o, i, k, *allowed_classes)
       end
     end
   end
 
   def bad_access_key_type(lhs, key_index, actual, *expected_classes)
     fail(Puppet::Pops::Issues::BAD_SLICE_KEY_TYPE, @semantic.keys[key_index], {
       :left_value => lhs,
       :actual => bad_key_type_name(actual),
       :expected_classes => expected_classes
     })
   end
 
   def bad_key_type_name(actual)
     case actual
     when nil, :undef
       'Undef'
     when :default
       'Default'
     else
       actual.class.name
     end
   end
 
   def bad_type_specialization_key_type(type, key_index, actual, *expected_classes)
     label_provider = Puppet::Pops::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], {
       :type => type,
       :message => "Cannot use #{bad_key_type_name(actual)} where #{expected} is expected"
     })
   end
 
   def access_PPatternType(o, scope, keys)
     keys.flatten!
     assert_keys(keys, o, 1, INFINITY, String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::Types::PRegexpType)
     Puppet::Pops::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::PAbstractType)
         fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => keys[0].class})
       end
       result = Puppet::Pops::Types::POptionalType.new()
       result.optional_type = keys[0]
       result
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Optional-Type', :min => 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::PAbstractType)
         fail(Puppet::Pops::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
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Type-Type', :min => 1, :actual => keys.size})
     end
   end
 
   def access_PRubyType(o, scope, keys)
     keys.flatten!
     assert_keys(keys, o, 1, 1, String)
     # create ruby type based on name of class, not inference of key's type
     Puppet::Pops::Types::TypeFactory.ruby_type(keys[0])
   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})
     end
     keys.each_with_index do |x, index|
       fail(Puppet::Pops::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
   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})
     end
     keys.each_with_index do |x, index|
       fail(Puppet::Pops::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
   end
 
   # A Hash can create a new Hash type, one arg sets value type, two args sets key and value type in new type.
   # With 3 or 4 arguments, these are used to create a size constraint.
   # It is not possible to create a collection of Hash types directly.
   #
   def access_PHashType(o, scope, keys)
     keys.flatten!
     keys[0,2].each_with_index do |k, index|
       unless k.is_a?(Puppet::Pops::Types::PAbstractType)
         fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[index], {:base_type => 'Hash-Type', :actual => k.class})
       end
     end
     case keys.size
     when 1
       result = Puppet::Pops::Types::PHashType.new()
       result.key_type = o.key_type.copy
       result.element_type = keys[0]
       result
     when 2
       result = Puppet::Pops::Types::PHashType.new()
       result.key_type = keys[0]
       result.element_type = keys[1]
       result
     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
     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
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {
         :base_type => 'Hash-Type', :min => 1, :max => 4, :actual => keys.size
       })
     end
     result.size_type = size_t if size_t
     result
   end
 
   # CollectionType is parameterized with a range
   def access_PCollectionType(o, scope, keys)
     keys.flatten!
     case keys.size
     when 1
       size_t = collection_size_t(1, keys[0])
     when 2
       size_t = collection_size_t(1, keys[0], keys[1])
     else
       fail(Puppet::Pops::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
   end
 
   # An Array can create a new Array type. It is not possible to create a collection of Array types.
   #
   def access_PArrayType(o, scope, keys)
     keys.flatten!
     case keys.size
     when 1
       size_t = nil
     when 2
       size_t = collection_size_t(1, keys[1])
     when 3
       size_t = collection_size_t(1, keys[1], keys[2])
     else
       fail(Puppet::Pops::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::PAbstractType)
       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
   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
     else
       keys.each_with_index do |x, index|
         fail(Puppet::Pops::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
     end
   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
   #   Resource[File]               # => File
   #   Resource[File, 'foo']        # => File[foo]
   #   Resource[File. 'foo', 'bar'] # => [File[foo], File[bar]]
   #   File['foo', 'bar']           # => [File[foo], File[bar]]
   #   File['foo']['bar']           # => Value of the 'bar' parameter in the File['foo'] resource
   #   Resource[File]['foo', 'bar'] # => [File[Foo], File[bar]]
   #   Resource[File, 'foo', 'bar'] # => [File[foo], File[bar]]
   #   Resource[File, 'foo']['bar'] # => Value of the 'bar' parameter in the File['foo'] resource
   #
   def access_PResourceType(o, scope, keys)
     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)
     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 = case type_name
     when Puppet::Pops::Types::PResourceType
       type_name.type_name
     when String
       type_name.downcase
     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 => type_name.class})
     end
 
     # The result is an array if multiple titles are given, or if titles are specified with an array
     # (possibly multiple arrays, and nested arrays).
     result_type_array = keys.size > 1 || keys[0].is_a?(Array)
     keys_orig_size = keys.size
 
     keys.flatten!
     keys.compact!
 
     # If given keys  that were just a mix of empty/nil with empty array as a result.
     # As opposed to calling the function the wrong way (without any arguments), (configurable issue),
     # Return an empty array
     #
     if keys.empty? && keys_orig_size > 0
       optionally_fail(Puppet::Pops::Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
       return result_type_array ? [] : nil
     end
 
     if !o.title.nil?
       # 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})
       end
 
       result = keys.map do |k|
         unless is_parameter_of_resource?(scope, resource, k)
           fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
             {:type_name => o.type_name, :title => o.title, :param_name=>k})
         end
         get_resource_parameter_value(scope, resource, k)
       end
       return result_type_array ? result : result.pop
     end
 
 
     keys = [:no_title] if keys.size < 1 # if there was only a type_name and it was consumed
     result = keys.each_with_index.map do |t, i|
       unless t.is_a?(String) || t == :no_title
         type_to_report = case t
         when nil, :undef
           'Undef'
         when :default
           'Default'
         else
           t.class.name
         end
         index = keys_orig_size != keys.size ? i+1 : i
         fail(Puppet::Pops::Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[index], {
           :type => o,
           :message => "Cannot use #{type_to_report} where String is expected"
         })
       end
 
       rtype = Puppet::Pops::Types::PResourceType.new()
       rtype.type_name = type_name
       rtype.title = (t == :no_title ? nil : t)
       rtype
     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
   end
 
   def access_PHostClassType(o, scope, keys)
     blamed = keys.size == 0 ? @semantic : @semantic.keys[0]
     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)
+    end
+
     # The result is an array if multiple classnames are given, or if classnames are specified with an array
     # (possibly multiple arrays, and nested arrays).
     result_type_array = keys.size > 1 || keys[0].is_a?(Array)
 
     keys.flatten!
     keys.compact!
 
-    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)
-    end
-
     # If given keys  that were just a mix of empty/nil with empty array as a result.
     # As opposed to calling the function the wrong way (without any arguments), (configurable issue),
     # Return an empty array
     #
     if keys.empty? && keys_orig_size > 0
       optionally_fail(Puppet::Pops::Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
       return result_type_array ? [] : nil
     end
 
-    if ! o.class_name.nil?
+    if o.class_name.nil?
+      # The type argument may be a Resource Type - the Puppet Language allows a reference such as
+      # Class[Foo], and this is interpreted as Class[Resource[Foo]] - which is ok as long as the resource
+      # 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?
+                 # type_name is already downcase. Don't waste time trying to downcase again
+                 c.type_name
+               elsif c.is_a?(String)
+                 c.downcase
+               else
+                 fail(Puppet::Pops::Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[i], {:name => c})
+               end
+
+        if name =~ Puppet::Pops::Patterns::NAME
+          ctype = Puppet::Pops::Types::PHostClassType.new()
+          # Remove leading '::' since all references are global, and 3x runtime does the wrong thing
+          ctype.class_name = name.sub(/^::/, '')
+          ctype
+        else
+          fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c})
+        end
+      end
+    else
       # lookup class resource and return one or more parameter values
       resource = find_resource(scope, 'class', o.class_name)
-      unless resource
-        fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => 'Class', :title => o.class_name})
-      end
-      result = keys.map do |k|
-        unless is_parameter_of_resource?(scope, resource, k)
-          fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
-            {:type_name => 'Class', :title => o.class_name, :param_name=>k})
+      if resource
+        result = keys.map do |k|
+          if is_parameter_of_resource?(scope, resource, k)
+            get_resource_parameter_value(scope, resource, k)
+          else
+            fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
+              {:type_name => 'Class', :title => o.class_name, :param_name=>k})
+          end
         end
-        get_resource_parameter_value(scope, resource, k)
-      end
-      return result_type_array ? result : result.pop
-    end
-
-    # The type argument may be a Resource Type - the Puppet Language allows a reference such as
-    # Class[Foo], and this is interpreted as Class[Resource[Foo]] - which is ok as long as the resource
-    # does not have a title. This should probably be deprecated.
-    #
-    result = keys.each_with_index.map do |c, i|
-      ctype = Puppet::Pops::Types::PHostClassType.new()
-      if c.is_a?(Puppet::Pops::Types::PResourceType) && !c.type_name.nil? && c.title.nil?
-        # Remove leading '::' since all references are global, and 3x runtime does the wrong thing
-        c = c.type_name.downcase.sub(/^::/, '')
-      end
-      unless c.is_a?(String)
-        fail(Puppet::Pops::Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[i], {:name => c})
-      end
-      if c !~ Puppet::Pops::Patterns::NAME
-        fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c})
+      else
+        fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => 'Class', :title => o.class_name})
       end
-      ctype.class_name = c.downcase.sub(/^::/,'')
-      ctype
     end
 
     # returns single type as type, else an array of types
     return result_type_array ? result : result.pop
   end
 end
diff --git a/spec/unit/pops/evaluator/access_ops_spec.rb b/spec/unit/pops/evaluator/access_ops_spec.rb
index ab485057e..d0965ad5d 100644
--- a/spec/unit/pops/evaluator/access_ops_spec.rb
+++ b/spec/unit/pops/evaluator/access_ops_spec.rb
@@ -1,435 +1,441 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/pops'
 require 'puppet/pops/evaluator/evaluator_impl'
 require 'puppet/pops/types/type_factory'
 
 
 # relative to this spec file (./) does not work as this file is loaded by rspec
 require File.join(File.dirname(__FILE__), '/evaluator_rspec_helper')
 
 describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
   include EvaluatorRspecHelper
 
   def range(from, to)
     Puppet::Pops::Types::TypeFactory.range(from, to)
   end
 
   def float_range(from, to)
     Puppet::Pops::Types::TypeFactory.float_range(from, to)
   end
 
   context 'The evaluator when operating on a String' do
     it 'can get a single character using a single key index to []' do
       expect(evaluate(literal('abc')[1])).to eql('b')
     end
 
     it 'can get the last character using the key -1 in []' do
       expect(evaluate(literal('abc')[-1])).to eql('c')
     end
 
     it 'can get a substring by giving two keys' do
       expect(evaluate(literal('abcd')[1,2])).to eql('bc')
       # flattens keys
       expect(evaluate(literal('abcd')[[1,2]])).to eql('bc')
     end
 
     it 'produces empty string for a substring out of range' do
       expect(evaluate(literal('abc')[100])).to eql('')
     end
 
     it 'raises an error if arity is wrong for []' do
       expect{evaluate(literal('abc')[])}.to raise_error(/String supports \[\] with one or two arguments\. Got 0/)
       expect{evaluate(literal('abc')[1,2,3])}.to raise_error(/String supports \[\] with one or two arguments\. Got 3/)
     end
   end
 
   context 'The evaluator when operating on an Array' do
     it 'is tested with the correct assumptions' do
       expect(literal([1,2,3])[1].current.is_a?(Puppet::Pops::Model::AccessExpression)).to eql(true)
     end
 
     it 'can get an element using a single key index to []' do
       expect(evaluate(literal([1,2,3])[1])).to eql(2)
     end
 
     it 'can get the last element using the key -1 in []' do
       expect(evaluate(literal([1,2,3])[-1])).to eql(3)
     end
 
     it 'can get a slice of elements using two keys' do
       expect(evaluate(literal([1,2,3,4])[1,2])).to eql([2,3])
       # flattens keys
       expect(evaluate(literal([1,2,3,4])[[1,2]])).to eql([2,3])
     end
 
     it 'produces nil for a missing entry' do
       expect(evaluate(literal([1,2,3])[100])).to eql(nil)
     end
 
     it 'raises an error if arity is wrong for []' do
       expect{evaluate(literal([1,2,3,4])[])}.to raise_error(/Array supports \[\] with one or two arguments\. Got 0/)
       expect{evaluate(literal([1,2,3,4])[1,2,3])}.to raise_error(/Array supports \[\] with one or two arguments\. Got 3/)
     end
   end
 
   context 'The evaluator when operating on a Hash' do
     it 'can get a single element giving a single key to []' do
       expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3})['b'])).to eql(2)
     end
 
     it 'can lookup an array' do
       expect(evaluate(literal({[1]=>10,[2]=>20})[[2]])).to eql(20)
     end
 
     it 'produces nil for a missing key' do
       expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3})['x'])).to eql(nil)
     end
 
     it 'can get multiple elements by giving multiple keys to []' do
       expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3, 'd'=>4})['b', 'd'])).to eql([2, 4])
     end
 
     it 'compacts the result when using multiple keys' do
       expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3, 'd'=>4})['b', 'x'])).to eql([2])
     end
 
     it 'produces an empty array if none of multiple given keys were missing' do
       expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3, 'd'=>4})['x', 'y'])).to eql([])
     end
 
     it 'raises an error if arity is wrong for []' do
       expect{evaluate(literal({'a'=>1,'b'=>2,'c'=>3})[])}.to raise_error(/Hash supports \[\] with one or more arguments\. Got 0/)
     end
   end
 
   context "When applied to a type it" do
     let(:types) { Puppet::Pops::Types::TypeFactory }
 
     # Integer
     #
     it 'produces an Integer[from, to]' do
       expr = fqr('Integer')[1, 3]
       expect(evaluate(expr)).to eql(range(1,3))
 
       # arguments are flattened
       expr = fqr('Integer')[[1, 3]]
       expect(evaluate(expr)).to eql(range(1,3))
     end
 
     it 'produces an Integer[1]' do
       expr = fqr('Integer')[1]
       expect(evaluate(expr)).to eql(range(1,1))
     end
 
     it 'produces an Integer[from, <from]' do
       expr = fqr('Integer')[1,0]
       expect(evaluate(expr)).to eql(range(1,0))
     end
 
     it 'produces an error for Integer[] if there are more than 2 keys' do
       expr = fqr('Integer')[1,2,3]
       expect { evaluate(expr)}.to raise_error(/with one or two arguments/)
     end
 
     # Float
     #
     it 'produces a Float[from, to]' do
       expr = fqr('Float')[1, 3]
       expect(evaluate(expr)).to eql(float_range(1.0,3.0))
 
       # arguments are flattened
       expr = fqr('Float')[[1, 3]]
       expect(evaluate(expr)).to eql(float_range(1.0,3.0))
     end
 
     it 'produces a Float[1.0]' do
       expr = fqr('Float')[1.0]
       expect(evaluate(expr)).to eql(float_range(1.0,1.0))
     end
 
     it 'produces a Float[1]' do
       expr = fqr('Float')[1]
       expect(evaluate(expr)).to eql(float_range(1.0,1.0))
     end
 
     it 'produces a Float[from, <from]' do
       expr = fqr('Float')[1.0,0.0]
       expect(evaluate(expr)).to eql(float_range(1.0,0.0))
     end
 
     it 'produces an error for Float[] if there are more than 2 keys' do
       expr = fqr('Float')[1,2,3]
       expect { evaluate(expr)}.to raise_error(/with one or two arguments/)
     end
 
     # Hash Type
     #
     it 'produces a Hash[Scalar,String] from the expression Hash[String]' do
       expr = fqr('Hash')[fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.scalar))
 
       # arguments are flattened
       expr = fqr('Hash')[[fqr('String')]]
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.scalar))
     end
 
     it 'produces a Hash[String,String] from the expression Hash[String, String]' do
       expr = fqr('Hash')[fqr('String'), fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.string))
     end
 
     it 'produces a Hash[Scalar,String] from the expression Hash[Integer][String]' do
       expr = fqr('Hash')[fqr('Integer')][fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.scalar))
     end
 
     it "gives an error if parameter is not a type" do
       expr = fqr('Hash')['String']
       expect { evaluate(expr)}.to raise_error(/Hash-Type\[\] arguments must be types/)
     end
 
     # Array Type
     #
     it 'produces an Array[String] from the expression Array[String]' do
       expr = fqr('Array')[fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.array_of(types.string))
 
       # arguments are flattened
       expr = fqr('Array')[[fqr('String')]]
       expect(evaluate(expr)).to be_the_type(types.array_of(types.string))
     end
 
     it 'produces an Array[String] from the expression Array[Integer][String]' do
       expr = fqr('Array')[fqr('Integer')][fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.array_of(types.string))
     end
 
     it 'produces a size constrained Array when the last two arguments specify this' do
       expr = fqr('Array')[fqr('String'), 1]
       expected_t = types.array_of(String)
       types.constrain_size(expected_t, 1, :default)
       expect(evaluate(expr)).to be_the_type(expected_t)
 
       expr = fqr('Array')[fqr('String'), 1, 2]
       expected_t = types.array_of(String)
       types.constrain_size(expected_t, 1, 2)
       expect(evaluate(expr)).to be_the_type(expected_t)
     end
 
     it "Array parameterization gives an error if parameter is not a type" do
       expr = fqr('Array')['String']
       expect { evaluate(expr)}.to raise_error(/Array-Type\[\] arguments must be types/)
     end
 
     # Tuple Type
     #
     it 'produces a Tuple[String] from the expression Tuple[String]' do
       expr = fqr('Tuple')[fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.tuple(String))
 
       # arguments are flattened
       expr = fqr('Tuple')[[fqr('String')]]
       expect(evaluate(expr)).to be_the_type(types.tuple(String))
     end
 
     it "Tuple parameterization gives an error if parameter is not a type" do
       expr = fqr('Tuple')['String']
       expect { evaluate(expr)}.to raise_error(/Tuple-Type, Cannot use String where Abstract-Type is expected/)
     end
 
     it 'produces a varargs Tuple when the last two arguments specify size constraint' do
       expr = fqr('Tuple')[fqr('String'), 1]
       expected_t = types.tuple(String)
       types.constrain_size(expected_t, 1, :default)
       expect(evaluate(expr)).to be_the_type(expected_t)
 
       expr = fqr('Tuple')[fqr('String'), 1, 2]
       expected_t = types.tuple(String)
       types.constrain_size(expected_t, 1, 2)
       expect(evaluate(expr)).to be_the_type(expected_t)
     end
 
     # Pattern Type
     #
     it 'creates a PPatternType instance when applied to a Pattern' do
       regexp_expr = fqr('Pattern')['foo']
       expect(evaluate(regexp_expr)).to eql(Puppet::Pops::Types::TypeFactory.pattern('foo'))
     end
 
     # Regexp Type
     #
     it 'creates a Regexp instance when applied to a Pattern' do
       regexp_expr = fqr('Regexp')['foo']
       expect(evaluate(regexp_expr)).to eql(Puppet::Pops::Types::TypeFactory.regexp('foo'))
 
       # arguments are flattened
       regexp_expr = fqr('Regexp')[['foo']]
       expect(evaluate(regexp_expr)).to eql(Puppet::Pops::Types::TypeFactory.regexp('foo'))
     end
 
     # Class
     #
     it 'produces a specific class from Class[classname]' do
       expr = fqr('Class')[fqn('apache')]
       expect(evaluate(expr)).to be_the_type(types.host_class('apache'))
       expr = fqr('Class')[literal('apache')]
       expect(evaluate(expr)).to be_the_type(types.host_class('apache'))
     end
 
     it 'produces an array of Class when args are in an array' do
       # arguments are flattened
       expr = fqr('Class')[[fqn('apache')]]
       expect(evaluate(expr)[0]).to be_the_type(types.host_class('apache'))
     end
 
     it 'produces undef for Class if arg is undef' do
       # arguments are flattened
       expr = fqr('Class')[nil]
       expect(evaluate(expr)).to be_nil
     end
 
     it 'produces empty array for Class if arg is [undef]' do
       # arguments are flattened
       expr = fqr('Class')[[]]
       expect(evaluate(expr)).to be_eql([])
       expr = fqr('Class')[[nil]]
       expect(evaluate(expr)).to be_eql([])
     end
 
     it 'raises error if access is to no keys' do
       expr = fqr('Class')[fqn('apache')][]
       expect { evaluate(expr) }.to raise_error(/Evaluation Error: Class\[apache\]\[\] accepts 1 or more arguments\. Got 0/)
     end
 
     it 'produces a collection of classes when multiple class names are given' do
       expr = fqr('Class')[fqn('apache'), literal('nginx')]
       result = evaluate(expr)
       expect(result[0]).to be_the_type(types.host_class('apache'))
       expect(result[1]).to be_the_type(types.host_class('nginx'))
     end
 
     it 'removes leading :: in class name' do
       expr = fqr('Class')['::evoe']
       expect(evaluate(expr)).to be_the_type(types.host_class('evoe'))
     end
 
     it 'raises error if the name is not a valid name' do
       expr = fqr('Class')['fail-whale']
       expect { evaluate(expr) }.to raise_error(/Illegal name/)
     end
 
+    it 'downcases capitalized class names' do
+      expr = fqr('Class')['My::Class']
+
+      expect(evaluate(expr)).to be_the_type(types.host_class('my::class'))
+    end
+
     it 'gives an error if no keys are given as argument' do
       expr = fqr('Class')[]
       expect {evaluate(expr)}.to raise_error(/Evaluation Error: Class\[\] accepts 1 or more arguments. Got 0/)
     end
 
     it 'produces an empty array if the keys reduce to empty array' do
       expr = fqr('Class')[literal([[],[]])]
       expect(evaluate(expr)).to be_eql([])
     end
 
     # Resource
     it 'produces a specific resource type from Resource[type]' do
       expr = fqr('Resource')[fqr('File')]
       expect(evaluate(expr)).to be_the_type(types.resource('File'))
       expr = fqr('Resource')[literal('File')]
       expect(evaluate(expr)).to be_the_type(types.resource('File'))
     end
 
     it 'does not allow the type to be specified in an array' do
       # arguments are flattened
       expr = fqr('Resource')[[fqr('File')]]
       expect{evaluate(expr)}.to raise_error(Puppet::ParseError, /must be a resource type or a String/)
     end
 
     it 'produces a specific resource reference type from File[title]' do
       expr = fqr('File')[literal('/tmp/x')]
       expect(evaluate(expr)).to be_the_type(types.resource('File', '/tmp/x'))
     end
 
     it 'produces a collection of specific resource references when multiple titles are used' do
       # Using a resource type
       expr = fqr('File')[literal('x'),literal('y')]
       result = evaluate(expr)
       expect(result[0]).to be_the_type(types.resource('File', 'x'))
       expect(result[1]).to be_the_type(types.resource('File', 'y'))
 
       # Using generic resource
       expr = fqr('Resource')[fqr('File'), literal('x'),literal('y')]
       result = evaluate(expr)
       expect(result[0]).to be_the_type(types.resource('File', 'x'))
       expect(result[1]).to be_the_type(types.resource('File', 'y'))
     end
 
     it 'produces undef for Resource if arg is undef' do
       # arguments are flattened
       expr = fqr('File')[nil]
       expect(evaluate(expr)).to be_nil
     end
 
     it 'gives an error if no keys are given as argument to Resource' do
       expr = fqr('Resource')[]
       expect {evaluate(expr)}.to raise_error(/Evaluation Error: Resource\[\] accepts 1 or more arguments. Got 0/)
     end
 
     it 'produces an empty array if the type is given, and keys reduce to empty array for Resource' do
       expr = fqr('Resource')[fqr('File'),literal([[],[]])]
       expect(evaluate(expr)).to be_eql([])
     end
 
     it 'gives an error i no keys are given as argument to a specific Resource type' do
       expr = fqr('File')[]
       expect {evaluate(expr)}.to raise_error(/Evaluation Error: File\[\] accepts 1 or more arguments. Got 0/)
     end
 
     it 'produces an empty array if the keys reduce to empty array for a specific Resource tyoe' do
       expr = fqr('File')[literal([[],[]])]
       expect(evaluate(expr)).to be_eql([])
     end
 
     it 'gives an error if resource is not found' do
       expr = fqr('File')[fqn('x')][fqn('y')]
       expect {evaluate(expr)}.to raise_error(/Resource not found: File\['x'\]/)
     end
 
     # Type Type
     #
     it 'creates a Type instance when applied to a Type' do
       type_expr = fqr('Type')[fqr('Integer')]
       tf = Puppet::Pops::Types::TypeFactory
       expect(evaluate(type_expr)).to eql(tf.type_type(tf.integer))
 
       # arguments are flattened
       type_expr = fqr('Type')[[fqr('Integer')]]
       expect(evaluate(type_expr)).to eql(tf.type_type(tf.integer))
     end
 
     # Ruby Type
     #
     it 'creates a Ruby Type instance when applied to a Ruby Type' do
       type_expr = fqr('Ruby')['String']
       tf = Puppet::Pops::Types::TypeFactory
       expect(evaluate(type_expr)).to eql(tf.ruby_type('String'))
 
       # arguments are flattened
       type_expr = fqr('Ruby')[['String']]
       expect(evaluate(type_expr)).to eql(tf.ruby_type('String'))
     end
 
   end
 
   matcher :be_the_type do |type|
     calc = Puppet::Pops::Types::TypeCalculator.new
 
     match do |actual|
       calc.assignable?(actual, type) && calc.assignable?(type, actual)
     end
 
     failure_message_for_should do |actual|
       "expected #{type.to_s}, but was #{actual.to_s}"
     end
   end
 
 end