puppet 4.4.2 → 4.5.0

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

@@ -17,8 +17,10 @@ module Types
       self.class == o.class && key == o.key
     end
 
-    alias :eql? :==
-  end
+    def eql?(o)
+      self == o
+    end
+   end
 
   class SubjectPathElement < TypePathElement
     def to_s
@@ -26,15 +28,15 @@ module Types
     end
   end
 
-  class MemberPathElement < TypePathElement
+  class EntryValuePathElement < TypePathElement
     def to_s
-      "struct member '#{key}'"
+      "entry '#{key}'"
     end
   end
 
-  class MemberKeyPathElement < TypePathElement
+  class EntryKeyPathElement < TypePathElement
     def to_s
-      "struct member key '#{key}'"
+      "key of entry '#{key}'"
     end
   end
 
@@ -104,6 +106,15 @@ module Types
         'did not have a'
       end
     end
+
+    def it_references(tense)
+      case tense
+        when :present
+          'references'
+        else
+          'referenced'
+      end
+    end
   end
 
   class Mismatch
@@ -130,7 +141,9 @@ module Types
       self.class == o.class && canonical_path == o.canonical_path
     end
 
-    alias :eql? :==
+    def eql?(o)
+      self == o
+    end
 
     def hash
       canonical_path.hash
@@ -201,7 +214,7 @@ module Types
 
   class ExtraneousKey < KeyMismatch
     def message(variant, position, tense = :present)
-      "#{variant}#{position} #{it_has_no(tense)} '#{@key}' key"
+      "#{variant}#{position} unrecognized key '#{@key}'"
     end
   end
 
@@ -223,12 +236,33 @@ module Types
     end
   end
 
+  class UnresolvedTypeReference < Mismatch
+    attr_reader :unresolved
+
+    def initialize(path, unresolved)
+      super(path)
+      @unresolved = unresolved
+    end
+
+    def ==(o)
+      super.==(o) && @unresolved == o.unresolved
+    end
+
+    def hash
+      @unresolved.hash
+    end
+
+    def message(variant, position, tense = :present)
+      "#{variant}#{position} #{it_references(tense)} an unresolved type '#{@unresolved}'"
+    end
+  end
+
   class ExpectedActualMismatch < Mismatch
     attr_reader :expected, :actual
 
     def initialize(path, expected, actual)
       super(path)
-      @expected = (expected.is_a?(Array) ? PVariantType.new(expected) : expected).normalize
+      @expected = (expected.is_a?(Array) ? PVariantType.maybe_create(expected) : expected).normalize
       @actual = actual.normalize
     end
 
@@ -711,6 +745,28 @@ module Types
       end
     end
 
+    def describe_PHashType(expected, actual, path)
+      descriptions = []
+      key_type = expected.key_type || PAnyType::DEFAULT
+      value_type = expected.element_type || PAnyType::DEFAULT
+      if actual.is_a?(PStructType)
+        elements = actual.elements
+        expected_size = expected.size_type || PCollectionType::DEFAULT_SIZE
+        actual_size = PIntegerType.new(elements.count { |a| !a.key_type.assignable?(PUndefType::DEFAULT) }, elements.size)
+        if expected_size.assignable?(actual_size)
+          elements.each do |a|
+            descriptions.concat(describe(key_type, a.key_type, path + [EntryKeyPathElement.new(a.name)])) unless key_type.assignable?(a.key_type)
+            descriptions.concat(describe(value_type, a.value_type, path + [EntryValuePathElement.new(a.name)])) unless value_type.assignable?(a.value_type)
+          end
+        else
+          descriptions << SizeMismatch.new(path, expected_size, actual_size)
+        end
+      else
+        descriptions << TypeMismatch.new(path, expected, actual)
+      end
+      descriptions
+    end
+
     def describe_PStructType(expected, actual, path)
       elements = expected.elements
       descriptions = []
@@ -722,8 +778,8 @@ module Types
           if e2.nil?
             descriptions << MissingKey.new(path, key) unless e1.key_type.assignable?(PUndefType::DEFAULT)
           else
-            descriptions.concat(describe(e1.key_type, e2.key_type, path + [MemberKeyPathElement.new(key)])) unless e1.key_type.assignable?(e2.key_type)
-            descriptions.concat(describe(e1.value_type, e2.value_type, path + [MemberPathElement.new(key)])) unless e1.value_type.assignable?(e2.value_type)
+            descriptions.concat(describe(e1.key_type, e2.key_type, path + [EntryKeyPathElement.new(key)])) unless e1.key_type.assignable?(e2.key_type)
+            descriptions.concat(describe(e1.value_type, e2.value_type, path + [EntryValuePathElement.new(key)])) unless e1.value_type.assignable?(e2.value_type)
           end
         end
         h2.each_key { |key| descriptions << ExtraneousKey.new(path, key) }
@@ -827,26 +883,51 @@ module Types
       expected.assignable?(actual) ? EMPTY_ARRAY : [TypeMismatch.new(path, expected, actual)]
     end
 
+    class UnresolvedTypeFinder
+      include TypeAcceptor
+
+      attr_reader :unresolved
+
+      def initialize
+        @unresolved = nil
+      end
+
+      def visit(type, guard)
+        if @unresolved.nil? && type.is_a?(PTypeReferenceType)
+          @unresolved = type.type_string
+        end
+      end
+    end
+
     def describe(expected, actual, path)
-      case expected
-      when PVariantType
-        describe_PVariantType(expected, actual, path)
-      when PStructType
-        describe_PStructType(expected, actual, path)
-      when PTupleType
-        describe_PTupleType(expected, actual, path)
-      when PCallableType
-        describe_PCallableType(expected, actual, path)
-      when POptionalType
-        describe_POptionalType(expected, actual, path)
-      when PPatternType
-        describe_PPatternType(expected, actual, path)
-      when PEnumType
-        describe_PEnumType(expected, actual, path)
-      when PTypeAliasType
-        describe_PTypeAliasType(expected, actual, path)
+      ures_finder = UnresolvedTypeFinder.new
+      expected.accept(ures_finder, nil)
+      unresolved = ures_finder.unresolved
+      if unresolved
+        [UnresolvedTypeReference.new(path, unresolved)]
       else
-        describe_PAnyType(expected, actual, path)
+        case expected
+        when PVariantType
+          describe_PVariantType(expected, actual, path)
+        when PStructType
+          describe_PStructType(expected, actual, path)
+        when PHashType
+          describe_PHashType(expected, actual, path)
+        when PTupleType
+          describe_PTupleType(expected, actual, path)
+        when PCallableType
+          describe_PCallableType(expected, actual, path)
+        when POptionalType
+          describe_POptionalType(expected, actual, path)
+        when PPatternType
+          describe_PPatternType(expected, actual, path)
+        when PEnumType
+          describe_PEnumType(expected, actual, path)
+        when PTypeAliasType
+          describe_PTypeAliasType(expected, actual, path)
+        else
+          describe_PAnyType(expected, actual, path)
+        end
       end
     end
 

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

@@ -29,25 +29,14 @@ class TypeParser
   # @api public
   #
   def parse(string, context = nil)
-    # TODO: This state (@string) can be removed since the parse result of newer future parser
-    # contains a Locator in its SourcePosAdapter and the Locator keeps the string.
-    # This way, there is no difference between a parsed "string" and something that has been parsed
-    # earlier and fed to 'interpret'
-    #
-    @string = string
-    model = @parser.parse_string(@string)
-    if model
-      interpret(model.current, context)
-    else
-      raise_invalid_type_specification_error
-    end
+    model = @parser.parse_string(string)
+    interpret(model.current.body, context)
   end
 
   # @api private
   def interpret(ast, context)
     result = @type_transformer.visit_this_1(self, ast, context)
-    result = result.body if result.is_a?(Model::Program)
-    raise_invalid_type_specification_error unless result.is_a?(PAnyType)
+    raise_invalid_type_specification_error(ast) unless result.is_a?(PAnyType)
     result
   end
 
@@ -58,31 +47,26 @@ class TypeParser
 
   # @api private
   def interpret_Object(o, context)
-    raise_invalid_type_specification_error
+    raise_invalid_type_specification_error(o)
   end
 
   # @api private
   def interpret_Program(o, context)
-    interpret(o.body, context)
+    interpret_any(o.body, context)
   end
 
-  # @api private
-  def interpret_QualifiedName(o, context)
-    o.value
+  def interpret_LambdaExpression(o, context)
+    o
   end
 
   # @api private
-  def interpret_LiteralString(o, context)
-    o.value
-  end
-
-  def interpret_LiteralRegularExpression(o, context)
+  def interpret_QualifiedName(o, context)
     o.value
   end
 
   # @api private
-  def interpret_String(o, context)
-    o
+  def interpret_LiteralBoolean(o, context)
+    o.value
   end
 
   # @api private
@@ -90,16 +74,6 @@ class TypeParser
     :default
   end
 
-  # @api private
-  def interpret_LiteralInteger(o, context)
-    o.value
-  end
-
-  # @api private
-  def interpret_UnaryMinusExpression(o, context)
-    -@type_transformer.visit_this_1(self, o.expr, context)
-  end
-
   # @api private
   def interpret_LiteralFloat(o, context)
     o.value
@@ -115,167 +89,172 @@ class TypeParser
   end
 
   # @api private
-  def interpret_QualifiedReference(name_ast, context)
-    name = name_ast.value
-    case name
-    when 'integer'
-      TypeFactory.integer
-
-    when 'float'
-      TypeFactory.float
-
-    when 'numeric'
-        TypeFactory.numeric
-
-    when 'iterable'
-      TypeFactory.iterable
-
-    when 'iterator'
-      TypeFactory.iterator
-
-    when 'string'
-      TypeFactory.string
-
-    when 'enum'
-      TypeFactory.enum
-
-    when 'boolean'
-      TypeFactory.boolean
-
-    when 'pattern'
-      TypeFactory.pattern
-
-    when 'regexp'
-      TypeFactory.regexp
-
-    when 'data'
-      TypeFactory.data
-
-    when 'array'
-      TypeFactory.array_of_data
-
-    when 'hash'
-      TypeFactory.hash_of_data
-
-    when 'class'
-      TypeFactory.host_class
-
-    when 'resource'
-      TypeFactory.resource
-
-    when 'collection'
-      TypeFactory.collection
-
-    when 'scalar'
-      TypeFactory.scalar
-
-    when 'catalogentry'
-      TypeFactory.catalog_entry
-
-    when 'undef'
-      TypeFactory.undef
-
-    when 'notundef'
-      TypeFactory.not_undef()
-
-    when 'default'
-      TypeFactory.default()
- 
-    when 'any'
-      TypeFactory.any
+  def interpret_LiteralInteger(o, context)
+    o.value
+  end
 
-    when 'variant'
-      TypeFactory.variant
+  # @api private
+  def interpret_LiteralList(o, context)
+    o.values.map { |value| @type_transformer.visit_this_1(self, value, context) }
+  end
 
-    when 'optional'
-      TypeFactory.optional
+  # @api private
+  def interpret_LiteralRegularExpression(o, context)
+    o.value
+  end
 
-    when 'runtime'
-      TypeFactory.runtime
+  # @api private
+  def interpret_LiteralString(o, context)
+    o.value
+  end
 
-    when 'type'
-      TypeFactory.type_type
+  # @api private
+  def interpret_LiteralUndef(o, context)
+    nil
+  end
 
-    when 'tuple'
-      TypeFactory.tuple
+  # @api private
+  def interpret_String(o, context)
+    o
+  end
 
-    when 'struct'
-      TypeFactory.struct
+  # @api private
+  def interpret_UnaryMinusExpression(o, context)
+    -@type_transformer.visit_this_1(self, o.expr, context)
+  end
 
-    when 'callable'
+  # @api private
+  def self.type_map
+    @type_map ||= {
+       'integer'       => TypeFactory.integer,
+       'float'         => TypeFactory.float,
+        'numeric'      => TypeFactory.numeric,
+        'iterable'     => TypeFactory.iterable,
+        'iterator'     => TypeFactory.iterator,
+        'string'       => TypeFactory.string,
+        'enum'         => TypeFactory.enum,
+        'boolean'      => TypeFactory.boolean,
+        'pattern'      => TypeFactory.pattern,
+        'regexp'       => TypeFactory.regexp,
+        'data'         => TypeFactory.data,
+        'array'        => TypeFactory.array_of_data,
+        'hash'         => TypeFactory.hash_of_data,
+        'class'        => TypeFactory.host_class,
+        'resource'     => TypeFactory.resource,
+        'collection'   => TypeFactory.collection,
+        'scalar'       => TypeFactory.scalar,
+        'catalogentry' => TypeFactory.catalog_entry,
+        'undef'        => TypeFactory.undef,
+        'notundef'     => TypeFactory.not_undef(),
+        'default'      => TypeFactory.default(),
+        'any'          => TypeFactory.any,
+        'variant'      => TypeFactory.variant,
+        'optional'     => TypeFactory.optional,
+        'runtime'      => TypeFactory.runtime,
+        'type'         => TypeFactory.type_type,
+        'tuple'        => TypeFactory.tuple,
+        'struct'       => TypeFactory.struct,
+        'object'       => TypeFactory.object,
+        'typealias'    => TypeFactory.type_alias,
+        'typereference' => TypeFactory.type_reference,
       # A generic callable as opposed to one that does not accept arguments
-      TypeFactory.all_callables
+        'callable'     => TypeFactory.all_callables,
+        'semver'       => TypeFactory.sem_ver,
+        'semverrange'  => TypeFactory.sem_ver_range
+    }
+  end
 
+  # @api private
+  def interpret_QualifiedReference(name_ast, context)
+    name = name_ast.value
+    if found = self.class.type_map[name]
+      found
     else
-      if context.nil?
-        TypeFactory.type_reference(name.capitalize)
-      else
-        if context.is_a?(Puppet::Pops::Loader::Loader)
-          loader = context
-        else
-          loader = Puppet::Pops::Adapters::LoaderAdapter.loader_for_model_object(name_ast, context)
-        end
-        unless loader.nil?
-          type = loader.load(:type, name)
-          type = type.resolve(self, loader) unless type.nil?
-        end
-        type || TypeFactory.resource(name)
+      loader = loader_from_context(name_ast, context)
+      unless loader.nil?
+        type = loader.load(:type, name)
+        type = type.resolve(self, loader) unless type.nil?
       end
+      type || TypeFactory.type_reference(name_ast.cased_value)
     end
   end
 
   # @api private
-  def interpret_AccessExpression(parameterized_ast, context)
-    parameters = parameterized_ast.keys.collect { |param| interpret_any(param, context) }
-
-    unless parameterized_ast.left_expr.is_a?(Model::QualifiedReference)
-      raise_invalid_type_specification_error
+  def loader_from_context(ast, context)
+    if context.nil?
+      nil
+    elsif context.is_a?(Puppet::Pops::Loader::Loader)
+      context
+    else
+      Puppet::Pops::Adapters::LoaderAdapter.loader_for_model_object(ast, context)
     end
+  end
+
+  # @api private
+  def interpret_AccessExpression(ast, context)
+    parameters = ast.keys.collect { |param| interpret_any(param, context) }
+
+    qref = ast.left_expr
+    raise_invalid_type_specification_error(ast) unless qref.is_a?(Model::QualifiedReference)
 
-    case parameterized_ast.left_expr.value
+    type_name = qref.value
+    case type_name
     when 'array'
       case parameters.size
       when 1
+        type = assert_type(ast, parameters[0])
       when 2
-        size_type =
-          if parameters[1].is_a?(PIntegerType)
-            parameters[1]
-          else
-            assert_range_parameter(parameters[1])
-            TypeFactory.range(parameters[1], :default)
-          end
+        if parameters[0].is_a?(PAnyType)
+          type = parameters[0]
+          size_type =
+            if parameters[1].is_a?(PIntegerType)
+              size_type = parameters[1]
+            else
+              assert_range_parameter(ast, parameters[1])
+              TypeFactory.range(parameters[1], :default)
+            end
+        else
+          type = :default
+          assert_range_parameter(ast, parameters[0])
+          assert_range_parameter(ast, parameters[1])
+          size_type = TypeFactory.range(parameters[0], parameters[1])
+        end
       when 3
-        assert_range_parameter(parameters[1])
-        assert_range_parameter(parameters[2])
+        type = assert_type(ast, parameters[0])
+        assert_range_parameter(ast, parameters[1])
+        assert_range_parameter(ast, parameters[2])
         size_type = TypeFactory.range(parameters[1], parameters[2])
       else
         raise_invalid_parameters_error('Array', '1 to 3', parameters.size)
       end
-      assert_type(parameters[0])
-      TypeFactory.array_of(parameters[0], size_type)
+      TypeFactory.array_of(type, size_type)
 
     when 'hash'
       case parameters.size
       when 2
-        assert_type(parameters[0])
-        assert_type(parameters[1])
-        TypeFactory.hash_of(parameters[1], parameters[0])
+        if parameters[0].is_a?(PAnyType) && parameters[1].is_a?(PAnyType)
+          TypeFactory.hash_of(parameters[1], parameters[0])
+        else
+          assert_range_parameter(ast, parameters[0])
+          assert_range_parameter(ast, parameters[1])
+          TypeFactory.hash_of(:default, :default, TypeFactory.range(parameters[0], parameters[1]))
+        end
       when 3
         size_type =
           if parameters[2].is_a?(PIntegerType)
             parameters[2]
           else
-            assert_range_parameter(parameters[2])
+            assert_range_parameter(ast, parameters[2])
             TypeFactory.range(parameters[2], :default)
           end
-        assert_type(parameters[0])
-        assert_type(parameters[1])
+        assert_type(ast, parameters[0])
+        assert_type(ast, parameters[1])
         TypeFactory.hash_of(parameters[1], parameters[0], size_type)
       when 4
-        assert_range_parameter(parameters[2])
-        assert_range_parameter(parameters[3])
-        assert_type(parameters[0])
-        assert_type(parameters[1])
+        assert_range_parameter(ast, parameters[2])
+        assert_range_parameter(ast, parameters[3])
+        assert_type(ast, parameters[0])
+        assert_type(ast, parameters[1])
         TypeFactory.hash_of(parameters[1], parameters[0], TypeFactory.range(parameters[2], parameters[3]))
       else
         raise_invalid_parameters_error('Hash', '2 to 4', parameters.size)
@@ -287,12 +266,12 @@ class TypeParser
           if parameters[0].is_a?(PIntegerType)
             parameters[0]
           else
-            assert_range_parameter(parameters[0])
+            assert_range_parameter(ast, parameters[0])
             TypeFactory.range(parameters[0], :default)
           end
         when 2
-          assert_range_parameter(parameters[0])
-          assert_range_parameter(parameters[1])
+          assert_range_parameter(ast, parameters[0])
+          assert_range_parameter(ast, parameters[1])
           TypeFactory.range(parameters[0], parameters[1])
         else
           raise_invalid_parameters_error('Collection', '1 to 2', parameters.size)
@@ -306,13 +285,20 @@ class TypeParser
       TypeFactory.host_class(parameters[0])
 
     when 'resource'
-      if parameters.size == 1
-        TypeFactory.resource(parameters[0])
-      elsif parameters.size != 2
-        raise_invalid_parameters_error('Resource', '1 or 2', parameters.size)
-      else
-        TypeFactory.resource(parameters[0], parameters[1])
+      type = parameters[0]
+      if type.is_a?(PTypeReferenceType)
+        type_str = type.type_string
+        param_start = type_str.index('[')
+        if param_start.nil?
+          type = type_str
+        else
+          tps = interpret_any(@parser.parse_string(type_str[param_start..-1]).current, context)
+          raise_invalid_parameters_error(type.to_s, '1', tps.size) unless tps.size == 1
+          type = type_str[0..param_start-1]
+          parameters = [type] + tps
+        end
       end
+      create_resource(type, parameters)
 
     when 'regexp'
       # 1 parameter being a string, or regular expression
@@ -343,7 +329,7 @@ class TypeParser
         # min, max specification
         min = parameters[-2]
         min = (min == :default || min == 'default') ? 0 : min
-        assert_range_parameter(parameters[-1])
+        assert_range_parameter(ast, parameters[-1])
         max = parameters[-1]
         max = max == :default ? nil : max
         parameters = parameters[0, length-2]
@@ -365,7 +351,7 @@ class TypeParser
       # 1..m parameters being types (last two optionally integer or literal default
       raise_invalid_parameters_error('Struct', '1', parameters.size) unless parameters.size == 1
       h = parameters[0]
-      raise_invalid_type_specification_error unless h.is_a?(Hash)
+      raise_invalid_type_specification_error(ast) unless h.is_a?(Hash)
       TypeFactory.struct(h)
 
     when 'integer'
@@ -382,18 +368,22 @@ class TypeParser
        TypeFactory.range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
      end
 
+    when 'object'
+      raise_invalid_parameters_error('Object', 1, parameters.size) unless parameters.size == 1
+      TypeFactory.object(parameters[0])
+
     when 'iterable'
       if parameters.size != 1
         raise_invalid_parameters_error('Iterable', 1, parameters.size)
       end
-      assert_type(parameters[0])
+      assert_type(ast, parameters[0])
       TypeFactory.iterable(parameters[0])
 
     when 'iterator'
       if parameters.size != 1
         raise_invalid_parameters_error('Iterator', 1, parameters.size)
       end
-      assert_type(parameters[0])
+      assert_type(ast, parameters[0])
       TypeFactory.iterator(parameters[0])
 
     when 'float'
@@ -417,12 +407,12 @@ class TypeParser
         if parameters[0].is_a?(PIntegerType)
           parameters[0]
         else
-          assert_range_parameter(parameters[0])
+          assert_range_parameter(ast, parameters[0])
           TypeFactory.range(parameters[0], :default)
         end
       when 2
-        assert_range_parameter(parameters[0])
-        assert_range_parameter(parameters[1])
+        assert_range_parameter(ast, parameters[0])
+        assert_range_parameter(ast, parameters[1])
         TypeFactory.range(parameters[0], parameters[1])
       else
         raise_invalid_parameters_error('String', '1 to 2', parameters.size)
@@ -434,11 +424,11 @@ class TypeParser
         raise_invalid_parameters_error('Optional', 1, parameters.size)
       end
       param = parameters[0]
-      assert_type(param) unless param.is_a?(String)
+      assert_type(ast, param) unless param.is_a?(String)
       TypeFactory.optional(param)
 
-    when 'any', 'data', 'catalogentry', 'boolean', 'scalar', 'undef', 'numeric', 'default'
-      raise_unparameterized_type_error(parameterized_ast.left_expr)
+    when 'any', 'data', 'catalogentry', 'boolean', 'scalar', 'undef', 'numeric', 'default', 'semverrange'
+      raise_unparameterized_type_error(qref)
 
     when 'notundef'
       case parameters.size
@@ -446,7 +436,7 @@ class TypeParser
         TypeFactory.not_undef
       when 1
         param = parameters[0]
-        assert_type(param) unless param.is_a?(String)
+        assert_type(ast, param) unless param.is_a?(String)
         TypeFactory.not_undef(param)
       else
         raise_invalid_parameters_error("NotUndef", "0 to 1", parameters.size)
@@ -456,43 +446,61 @@ class TypeParser
       if parameters.size != 1
         raise_invalid_parameters_error('Type', 1, parameters.size)
       end
-      assert_type(parameters[0])
+      assert_type(ast, parameters[0])
       TypeFactory.type_type(parameters[0])
 
     when 'runtime'
       raise_invalid_parameters_error('Runtime', '2', parameters.size) unless parameters.size == 2
       TypeFactory.runtime(*parameters)
 
+    when 'semver'
+      raise_invalid_parameters_error('SemVer', '1 or more', parameters.size) unless parameters.size >= 1
+      TypeFactory.sem_ver(*parameters)
+
     else
-      type_name = parameterized_ast.left_expr.value
-      if context.nil?
-        # Will be impossible to tell from a typed alias (when implemented) so a type reference
-        # is returned here for now
-        TypeFactory.type_reference(type_name.capitalize, parameters)
+      loader = loader_from_context(qref, context)
+      type = nil
+      unless loader.nil?
+        type = loader.load(:type, type_name)
+        type = type.resolve(self, loader) unless type.nil?
+      end
+
+      if type.nil?
+        TypeFactory.type_reference(original_text_of(qref.eContainer))
+      elsif type.is_a?(PResourceType)
+        raise_invalid_parameters_error(type_name, 1, parameters.size) unless parameters.size == 1
+        TypeFactory.resource(type.type_name, parameters[0])
       else
-        # It is a resource such a File['/tmp/foo']
-       if parameters.size != 1
-          raise_invalid_parameters_error(type_name.capitalize, 1, parameters.size)
-        end
-        TypeFactory.resource(type_name, parameters[0])
+        # Must be a type alias. They can't use parameters (yet)
+        raise_unparameterized_type_error(qref)
       end
     end
   end
 
   private
 
-  def assert_type(t)
-    raise_invalid_type_specification_error unless t.is_a?(PAnyType)
-    true
+  def create_resource(name, parameters)
+    if parameters.size == 1
+      TypeFactory.resource(name)
+    elsif parameters.size == 2
+      TypeFactory.resource(name, parameters[1])
+    else
+      raise_invalid_parameters_error('Resource', '1 or 2', parameters.size)
+    end
+  end
+
+  def assert_type(ast, t)
+    raise_invalid_type_specification_error(ast) unless t.is_a?(PAnyType)
+    t
   end
 
-  def assert_range_parameter(t)
-    raise_invalid_type_specification_error unless TypeFactory.is_range_parameter?(t)
+  def assert_range_parameter(ast, t)
+    raise_invalid_type_specification_error(ast) unless TypeFactory.is_range_parameter?(t)
   end
 
-  def raise_invalid_type_specification_error
+  def raise_invalid_type_specification_error(ast)
     raise Puppet::ParseError,
-      "The expression <#{@string}> is not a valid type specification."
+      "The expression <#{original_text_of(ast)}> is not a valid type specification."
   end
 
   def raise_invalid_parameters_error(type, required, given)
@@ -510,7 +518,7 @@ class TypeParser
 
   def original_text_of(ast)
     position = Adapters::SourcePosAdapter.adapt(ast)
-    position.extract_text
+    position.extract_tree_text
   end
 end
 end