puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/types/type_factory.rb

@@ -0,0 +1,432 @@
+# Helper module that makes creation of type objects simpler.
+# @api public
+#
+module Puppet::Pops::Types::TypeFactory
+  @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
+
+  Types = Puppet::Pops::Types
+
+  # Produces the Integer type
+  # @api public
+  #
+  def self.integer()
+    Types::PIntegerType.new()
+  end
+
+  # Produces an Integer range type
+  # @api public
+  #
+  def self.range(from, to)
+    t = Types::PIntegerType.new()
+    # optimize eq with symbol (faster when it is left)
+    t.from = from unless (:default == from || from == 'default')
+    t.to = to unless (:default == to || to == 'default')
+    t
+  end
+
+  # Produces a Float range type
+  # @api public
+  #
+  def self.float_range(from, to)
+    t = Types::PFloatType.new()
+    # optimize eq with symbol (faster when it is left)
+    t.from = Float(from) unless :default == from || from.nil?
+    t.to = Float(to) unless :default == to || to.nil?
+    t
+  end
+
+  # Produces the Float type
+  # @api public
+  #
+  def self.float()
+    Types::PFloatType.new()
+  end
+
+  # Produces the Numeric type
+  # @api public
+  #
+  def self.numeric()
+    Types::PNumericType.new()
+  end
+
+  # Produces a string representation of the type
+  # @api public
+  #
+  def self.label(t)
+    @type_calculator.string(t)
+  end
+
+  # Produces the String type, optionally with specific string values
+  # @api public
+  #
+  def self.string(*values)
+    t = Types::PStringType.new()
+    values.each {|v| t.addValues(v) }
+    t
+  end
+
+  # Produces the Optional type, i.e. a short hand for Variant[T, Undef]
+  def self.optional(optional_type = nil)
+    t = Types::POptionalType.new
+    t.optional_type = type_of(optional_type)
+    t
+  end
+
+  # Produces the Enum type, optionally with specific string values
+  # @api public
+  #
+  def self.enum(*values)
+    t = Types::PEnumType.new()
+    values.each {|v| t.addValues(v) }
+    t
+  end
+
+  # Produces the Variant type, optionally with the "one of" types
+  # @api public
+  #
+  def self.variant(*types)
+    t = Types::PVariantType.new()
+    types.each {|v| t.addTypes(type_of(v)) }
+    t
+  end
+
+  # Produces the Struct type, either a non parameterized instance representing
+  # all structs (i.e. all hashes) or a hash with a given set of keys of String
+  # type (names), bound to a value of a given type. Type may be a Ruby Class, a
+  # Puppet Type, or an instance from which the type is inferred.
+  #
+  def self.struct(name_type_hash = {})
+    t = Types::PStructType.new
+    name_type_hash.map do |name, type|
+      elem = Types::PStructElement.new
+      if name.is_a?(String) && name.empty?
+        raise ArgumentError, "An empty String can not be used where a String[1, default] is expected"
+      end
+      elem.name = name
+      elem.type = type_of(type)
+      elem
+    end.each {|elem| t.addElements(elem) }
+    t
+  end
+
+  def self.tuple(*types)
+    t = Types::PTupleType.new
+    types.each {|elem| t.addTypes(type_of(elem)) }
+    t
+  end
+
+  # Produces the Boolean type
+  # @api public
+  #
+  def self.boolean()
+    Types::PBooleanType.new()
+  end
+
+  # Produces the Any type
+  # @api public
+  #
+  def self.any()
+    Types::PAnyType.new()
+  end
+
+  # Produces the Regexp type
+  # @param pattern [Regexp, String, nil] (nil) The regular expression object or
+  #   a regexp source string, or nil for bare type
+  # @api public
+  #
+  def self.regexp(pattern = nil)
+    t = Types::PRegexpType.new()
+    if pattern
+      t.pattern = pattern.is_a?(Regexp) ? pattern.inspect[1..-2] : pattern
+    end
+    t.regexp() unless pattern.nil? # compile pattern to catch errors
+    t
+  end
+
+  def self.pattern(*regular_expressions)
+    t = Types::PPatternType.new()
+    regular_expressions.each do |re|
+      case re
+      when String
+        re_T = Types::PRegexpType.new()
+        re_T.pattern = re
+        re_T.regexp()  # compile it to catch errors
+        t.addPatterns(re_T)
+
+      when Regexp
+        re_T = Types::PRegexpType.new()
+        # Regep.to_s includes options user did not enter and does not escape source
+        # to work either as a string or as a // regexp. The inspect method does a better
+        # job, but includes the //
+        re_T.pattern = re.inspect[1..-2]
+        t.addPatterns(re_T)
+
+      when Types::PRegexpType
+        t.addPatterns(re.copy)
+
+      when Types::PPatternType
+        re.patterns.each do |p|
+          t.addPatterns(p.copy)
+        end
+
+     else
+       raise ArgumentError, "Only String, Regexp, Pattern-Type, and Regexp-Type are allowed: got '#{re.class}"
+      end
+    end
+    t
+  end
+
+  # Produces the Literal type
+  # @api public
+  #
+  def self.scalar()
+    Types::PScalarType.new()
+  end
+
+  # Produces a CallableType matching all callables
+  # @api public
+  #
+  def self.all_callables()
+    return Puppet::Pops::Types::PCallableType.new
+  end
+
+  # Produces a Callable type with one signature without support for a block
+  # Use #with_block, or #with_optional_block to add a block to the callable
+  # If no parameters are given, the Callable will describe a signature
+  # that does not accept parameters. To create a Callable that matches all callables
+  # use {#all_callables}.
+  #
+  # The params is a list of types, where the three last entries may be
+  # optionally followed by min, max count, and a Callable which is taken as the
+  # block_type.
+  # If neither min or max are specified the parameters must match exactly.
+  # A min < params.size means that the difference are optional.
+  # If max > params.size means that the last type repeats.
+  # if max is :default, the max value is unbound (infinity).
+  #
+  # Params are given as a sequence of arguments to {#type_of}.
+  #
+  def self.callable(*params)
+    if Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(params.last)
+      last_callable = true
+    end
+    block_t = last_callable ? params.pop : nil
+
+    # compute a size_type for the signature based on the two last parameters
+    if is_range_parameter?(params[-2]) && is_range_parameter?(params[-1])
+      size_type = range(params[-2], params[-1])
+      params = params[0, params.size - 2]
+    elsif is_range_parameter?(params[-1])
+      size_type = range(params[-1], :default)
+      params = params[0, params.size - 1]
+    end
+
+    types = params.map {|p| type_of(p) }
+
+    # If the specification requires types, and none were given, a Unit type is used
+    if types.empty? && !size_type.nil? && size_type.range[1] > 0
+      types << Types::PUnitType.new
+    end
+    # create a signature
+    callable_t = Types::PCallableType.new()
+    tuple_t = tuple(*types)
+    tuple_t.size_type = size_type unless size_type.nil?
+    callable_t.param_types = tuple_t
+
+    callable_t.block_type = block_t
+    callable_t
+  end
+
+  def self.with_block(callable, *block_params)
+    callable.block_type = callable(*block_params)
+    callable
+  end
+
+  def self.with_optional_block(callable, *block_params)
+    callable.block_type = optional(callable(*block_params))
+    callable
+  end
+
+  # Produces the abstract type Collection
+  # @api public
+  #
+  def self.collection()
+    Types::PCollectionType.new()
+  end
+
+  # Produces the Data type
+  # @api public
+  #
+  def self.data()
+    Types::PDataType.new()
+  end
+
+  # Creates an instance of the Undef type
+  # @api public
+  def self.undef()
+    Types::PNilType.new()
+  end
+
+  # Creates an instance of the Default type
+  # @api public
+  def self.default()
+    Types::PDefaultType.new()
+  end
+
+  # Produces an instance of the abstract type PCatalogEntryType
+  def self.catalog_entry()
+    Types::PCatalogEntryType.new()
+  end
+
+  # Produces a PResourceType with a String type_name A PResourceType with a nil
+  # or empty name is compatible with any other PResourceType.  A PResourceType
+  # with a given name is only compatible with a PResourceType with the same
+  # name.  (There is no resource-type subtyping in Puppet (yet)).
+  #
+  def self.resource(type_name = nil, title = nil)
+    type = Types::PResourceType.new()
+    type_name = type_name.type_name if type_name.is_a?(Types::PResourceType)
+    type_name = type_name.downcase unless type_name.nil?
+    type.type_name = type_name
+    unless type_name.nil? || type_name =~ Puppet::Pops::Patterns::CLASSREF
+      raise ArgumentError, "Illegal type name '#{type.type_name}'"
+    end
+    if type_name.nil? && !title.nil?
+      raise ArgumentError, "The type name cannot be nil, if title is given"
+    end
+    type.title = title
+    type
+  end
+
+  # Produces PHostClassType with a string class_name.  A PHostClassType with
+  # nil or empty name is compatible with any other PHostClassType.  A
+  # PHostClassType with a given name is only compatible with a PHostClassType
+  # with the same name.
+  #
+  def self.host_class(class_name = nil)
+    type = Types::PHostClassType.new()
+    unless class_name.nil?
+      type.class_name = class_name.sub(/^::/, '')
+    end
+    type
+  end
+
+  # Produces a type for Array[o] where o is either a type, or an instance for
+  # which a type is inferred.
+  # @api public
+  #
+  def self.array_of(o)
+    type = Types::PArrayType.new()
+    type.element_type = type_of(o)
+    type
+  end
+
+  # Produces a type for Hash[Scalar, o] where o is either a type, or an
+  # instance for which a type is inferred.
+  # @api public
+  #
+  def self.hash_of(value, key = scalar())
+    type = Types::PHashType.new()
+    type.key_type = type_of(key)
+    type.element_type = type_of(value)
+    type
+  end
+
+  # Produces a type for Array[Data]
+  # @api public
+  #
+  def self.array_of_data()
+    type = Types::PArrayType.new()
+    type.element_type = data()
+    type
+  end
+
+  # Produces a type for Hash[Scalar, Data]
+  # @api public
+  #
+  def self.hash_of_data()
+    type = Types::PHashType.new()
+    type.key_type = scalar()
+    type.element_type = data()
+    type
+  end
+
+  # Produces a type for Type[T]
+  # @api public
+  #
+  def self.type_type(inst_type = nil)
+    type = Types::PType.new()
+    type.type = inst_type
+    type
+  end
+
+  # Produce a type corresponding to the class of given unless given is a
+  # String, Class or a PAnyType.  When a String is given this is taken as
+  # a classname.
+  #
+  def self.type_of(o)
+    if o.is_a?(Class)
+      @type_calculator.type(o)
+    elsif o.is_a?(Types::PAnyType)
+      o
+    elsif o.is_a?(String)
+      Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => o)
+    else
+      @type_calculator.infer_generic(o)
+    end
+  end
+
+  # Produces a type for a class or infers a type for something that is not a
+  # class
+  # @note
+  #   To get the type for the class' class use `TypeCalculator.infer(c)`
+  #
+  # @overload ruby(o)
+  #   @param o [Class] produces the type corresponding to the class (e.g.
+  #     Integer becomes PIntegerType)
+  # @overload ruby(o)
+  #   @param o [Object] produces the type corresponding to the instance class
+  #     (e.g. 3 becomes PIntegerType)
+  #
+  # @api public
+  #
+  def self.ruby(o)
+    if o.is_a?(Class)
+      @type_calculator.type(o)
+    else
+      Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => o.class.name)
+    end
+  end
+
+  # Generic creator of a RuntimeType["ruby"] - allows creating the Ruby type
+  # with nil name, or String name.  Also see ruby(o) which performs inference,
+  # or mapps a Ruby Class to its name.
+  #
+  def self.ruby_type(class_name = nil)
+    Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => class_name)
+  end
+
+  # Generic creator of a RuntimeType - allows creating the type with nil or
+  # String runtime_type_name.  Also see ruby_type(o) and ruby(o).
+  #
+  def self.runtime(runtime=nil, runtime_type_name = nil)
+    runtime = runtime.to_sym if runtime.is_a?(String)
+    Types::PRuntimeType.new(:runtime => runtime, :runtime_type_name => runtime_type_name)
+  end
+
+  # Sets the accepted size range of a collection if something other than the
+  # default 0 to Infinity is wanted. The semantics for from/to are the same as
+  # for #range
+  #
+  def self.constrain_size(collection_t, from, to)
+    collection_t.size_type = range(from, to)
+    collection_t
+  end
+
+  # Returns true if the given type t is of valid range parameter type (integer
+  # or literal default).
+  def self.is_range_parameter?(t)
+    t.is_a?(Integer) || t == 'default' || :default == t
+  end
+
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/types/type_parser.rb

@@ -0,0 +1,475 @@
+# This class provides parsing of Type Specification from a string into the Type
+# Model that is produced by the Puppet::Pops::Types::TypeFactory.
+#
+# The Type Specifications that are parsed are the same as the stringified forms
+# of types produced by the {Puppet::Pops::Types::TypeCalculator TypeCalculator}.
+#
+# @api public
+class Puppet::Pops::Types::TypeParser
+  # @api private
+  TYPES = Puppet::Pops::Types::TypeFactory
+
+  # @api public
+  def initialize
+    @parser = Puppet::Pops::Parser::Parser.new()
+    @type_transformer = Puppet::Pops::Visitor.new(nil, "interpret", 0, 0)
+  end
+
+  # Produces a *puppet type* based on the given string.
+  #
+  # @example
+  #     parser.parse('Integer')
+  #     parser.parse('Array[String]')
+  #     parser.parse('Hash[Integer, Array[String]]')
+  #
+  # @param string [String] a string with the type expressed in stringified form as produced by the 
+  #   {Puppet::Pops::Types::TypeCalculator#string TypeCalculator#string} method.
+  # @return [Puppet::Pops::Types::PAnyType] a specialization of the PAnyType representing the type.
+  #
+  # @api public
+  #
+  def parse(string)
+    # 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)
+    else
+      raise_invalid_type_specification_error
+    end
+  end
+
+  # @api private
+  def interpret(ast)
+    result = @type_transformer.visit_this_0(self, ast)
+    result = result.body if result.is_a?(Puppet::Pops::Model::Program)
+    raise_invalid_type_specification_error unless result.is_a?(Puppet::Pops::Types::PAnyType)
+    result
+  end
+
+  # @api private
+  def interpret_any(ast)
+    @type_transformer.visit_this_0(self, ast)
+  end
+
+  # @api private
+  def interpret_Object(o)
+    raise_invalid_type_specification_error
+  end
+
+  # @api private
+  def interpret_Program(o)
+    interpret(o.body)
+  end
+
+  # @api private
+  def interpret_QualifiedName(o)
+    o.value
+  end
+
+  # @api private
+  def interpret_LiteralString(o)
+    o.value
+  end
+
+  def interpret_LiteralRegularExpression(o)
+    o.value
+  end
+
+  # @api private
+  def interpret_String(o)
+    o
+  end
+
+  # @api private
+  def interpret_LiteralDefault(o)
+    :default
+  end
+
+  # @api private
+  def interpret_LiteralInteger(o)
+    o.value
+  end
+
+  # @api private
+  def interpret_LiteralFloat(o)
+    o.value
+  end
+
+  # @api private
+  def interpret_LiteralHash(o)
+    result = {}
+    o.entries.each do |entry|
+      result[@type_transformer.visit_this_0(self, entry.key)] = @type_transformer.visit_this_0(self, entry.value)
+    end
+    result
+  end
+
+  # @api private
+  def interpret_QualifiedReference(name_ast)
+    case name_ast.value
+    when "integer"
+      TYPES.integer
+
+    when "float"
+      TYPES.float
+
+    when "numeric"
+        TYPES.numeric
+
+    when "string"
+      TYPES.string
+
+    when "enum"
+      TYPES.enum
+
+    when "boolean"
+      TYPES.boolean
+
+    when "pattern"
+      TYPES.pattern
+
+    when "regexp"
+      TYPES.regexp
+
+    when "data"
+      TYPES.data
+
+    when "array"
+      TYPES.array_of_data
+
+    when "hash"
+      TYPES.hash_of_data
+
+    when "class"
+      TYPES.host_class()
+
+    when "resource"
+      TYPES.resource()
+
+    when "collection"
+      TYPES.collection()
+
+    when "scalar"
+      TYPES.scalar()
+
+    when "catalogentry"
+      TYPES.catalog_entry()
+
+    when "undef"
+      TYPES.undef()
+
+    when "default"
+      TYPES.default()
+
+    when "any"
+      TYPES.any()
+
+    when "variant"
+      TYPES.variant()
+
+    when "optional"
+      TYPES.optional()
+
+    when "runtime"
+      TYPES.runtime()
+
+    when "type"
+      TYPES.type_type()
+
+    when "tuple"
+      TYPES.tuple()
+
+    when "struct"
+      TYPES.struct()
+
+    when "callable"
+      # A generic callable as opposed to one that does not accept arguments
+      TYPES.all_callables()
+
+    else
+      TYPES.resource(name_ast.value)
+    end
+  end
+
+  # @api private
+  def interpret_AccessExpression(parameterized_ast)
+    parameters = parameterized_ast.keys.collect { |param| interpret_any(param) }
+
+    unless parameterized_ast.left_expr.is_a?(Puppet::Pops::Model::QualifiedReference)
+      raise_invalid_type_specification_error
+    end
+
+    case parameterized_ast.left_expr.value
+    when "array"
+      case parameters.size
+      when 1
+      when 2
+        size_type =
+        if parameters[1].is_a?(Puppet::Pops::Types::PIntegerType)
+          parameters[1].copy
+        else
+          assert_range_parameter(parameters[1])
+          TYPES.range(parameters[1], :default)
+        end
+      when 3
+        assert_range_parameter(parameters[1])
+        assert_range_parameter(parameters[2])
+        size_type = TYPES.range(parameters[1], parameters[2])
+      else
+        raise_invalid_parameters_error("Array", "1 to 3", parameters.size)
+      end
+      assert_type(parameters[0])
+      t = TYPES.array_of(parameters[0])
+      t.size_type = size_type if size_type
+      t
+
+    when "hash"
+      result = case parameters.size
+      when 1
+        assert_type(parameters[0])
+        TYPES.hash_of(parameters[0])
+      when 2
+        assert_type(parameters[0])
+        assert_type(parameters[1])
+        TYPES.hash_of(parameters[1], parameters[0])
+      when 3
+        size_type =
+        if parameters[2].is_a?(Puppet::Pops::Types::PIntegerType)
+          parameters[2].copy
+        else
+          assert_range_parameter(parameters[2])
+          TYPES.range(parameters[2], :default)
+        end
+        assert_type(parameters[0])
+        assert_type(parameters[1])
+        TYPES.hash_of(parameters[1], parameters[0])
+      when 4
+        assert_range_parameter(parameters[2])
+        assert_range_parameter(parameters[3])
+        size_type = TYPES.range(parameters[2], parameters[3])
+        assert_type(parameters[0])
+        assert_type(parameters[1])
+        TYPES.hash_of(parameters[1], parameters[0])
+      else
+        raise_invalid_parameters_error("Hash", "1 to 4", parameters.size)
+      end
+      result.size_type = size_type if size_type
+      result
+
+    when "collection"
+      size_type = case parameters.size
+      when 1
+        if parameters[0].is_a?(Puppet::Pops::Types::PIntegerType)
+          parameters[0].copy
+        else
+          assert_range_parameter(parameters[0])
+          TYPES.range(parameters[0], :default)
+        end
+      when 2
+        assert_range_parameter(parameters[0])
+        assert_range_parameter(parameters[1])
+        TYPES.range(parameters[0], parameters[1])
+      else
+        raise_invalid_parameters_error("Collection", "1 to 2", parameters.size)
+      end
+      result = TYPES.collection
+      result.size_type = size_type
+      result
+
+    when "class"
+      if parameters.size != 1
+        raise_invalid_parameters_error("Class", 1, parameters.size)
+      end
+      TYPES.host_class(parameters[0])
+
+    when "resource"
+      if parameters.size == 1
+        TYPES.resource(parameters[0])
+      elsif parameters.size != 2
+        raise_invalid_parameters_error("Resource", "1 or 2", parameters.size)
+      else
+        TYPES.resource(parameters[0], parameters[1])
+      end
+
+    when "regexp"
+      # 1 parameter being a string, or regular expression
+      raise_invalid_parameters_error("Regexp", "1", parameters.size) unless parameters.size == 1
+      TYPES.regexp(parameters[0])
+
+    when "enum"
+      # 1..m parameters being strings
+      raise_invalid_parameters_error("Enum", "1 or more", parameters.size) unless parameters.size >= 1
+      TYPES.enum(*parameters)
+
+    when "pattern"
+      # 1..m parameters being strings or regular expressions
+      raise_invalid_parameters_error("Pattern", "1 or more", parameters.size) unless parameters.size >= 1
+      TYPES.pattern(*parameters)
+
+    when "variant"
+      # 1..m parameters being strings or regular expressions
+      raise_invalid_parameters_error("Variant", "1 or more", parameters.size) unless parameters.size >= 1
+      TYPES.variant(*parameters)
+
+    when "tuple"
+      # 1..m parameters being types (last two optionally integer or literal default
+      raise_invalid_parameters_error("Tuple", "1 or more", parameters.size) unless parameters.size >= 1
+      length = parameters.size
+      if TYPES.is_range_parameter?(parameters[-2])
+        # min, max specification
+        min = parameters[-2]
+        min = (min == :default || min == 'default') ? 0 : min
+        assert_range_parameter(parameters[-1])
+        max = parameters[-1]
+        max = max == :default ? nil : max
+        parameters = parameters[0, length-2]
+      elsif TYPES.is_range_parameter?(parameters[-1])
+        min = parameters[-1]
+        min = (min == :default || min == 'default') ? 0 : min
+        max = nil
+        parameters = parameters[0, length-1]
+      end
+      t = TYPES.tuple(*parameters)
+      if min || max
+        TYPES.constrain_size(t, min, max)
+      end
+      t
+
+    when "callable"
+      # 1..m parameters being types (last three optionally integer or literal default, and a callable)
+      TYPES.callable(*parameters)
+
+    when "struct"
+      # 1..m parameters being types (last two optionally integer or literal default
+      raise_invalid_parameters_error("Struct", "1", parameters.size) unless parameters.size == 1
+      assert_struct_parameter(parameters[0])
+      TYPES.struct(parameters[0])
+
+    when "integer"
+      if parameters.size == 1
+        case parameters[0]
+        when Integer
+          TYPES.range(parameters[0], parameters[0])
+        when :default
+          TYPES.integer # unbound
+        end
+      elsif parameters.size != 2
+        raise_invalid_parameters_error("Integer", "1 or 2", parameters.size)
+     else
+       TYPES.range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
+     end
+
+    when "float"
+      if parameters.size == 1
+        case parameters[0]
+        when Integer, Float
+          TYPES.float_range(parameters[0], parameters[0])
+        when :default
+          TYPES.float # unbound
+        end
+      elsif parameters.size != 2
+        raise_invalid_parameters_error("Float", "1 or 2", parameters.size)
+     else
+       TYPES.float_range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
+     end
+
+    when "string"
+      size_type =
+      case parameters.size
+      when 1
+        if parameters[0].is_a?(Puppet::Pops::Types::PIntegerType)
+          parameters[0].copy
+        else
+          assert_range_parameter(parameters[0])
+          TYPES.range(parameters[0], :default)
+        end
+      when 2
+        assert_range_parameter(parameters[0])
+        assert_range_parameter(parameters[1])
+        TYPES.range(parameters[0], parameters[1])
+      else
+        raise_invalid_parameters_error("String", "1 to 2", parameters.size)
+      end
+      result = TYPES.string
+      result.size_type = size_type
+      result
+
+    when "optional"
+      if parameters.size != 1
+        raise_invalid_parameters_error("Optional", 1, parameters.size)
+      end
+      assert_type(parameters[0])
+      TYPES.optional(parameters[0])
+
+    when "any", "data", "catalogentry", "boolean", "scalar", "undef", "numeric", "default"
+      raise_unparameterized_type_error(parameterized_ast.left_expr)
+
+    when "type"
+      if parameters.size != 1
+        raise_invalid_parameters_error("Type", 1, parameters.size)
+      end
+      assert_type(parameters[0])
+      TYPES.type_type(parameters[0])
+
+    when "runtime"
+      raise_invalid_parameters_error("Runtime", "2", parameters.size) unless parameters.size == 2
+      TYPES.runtime(*parameters)
+
+    else
+      # It is a resource such a File['/tmp/foo']
+      type_name = parameterized_ast.left_expr.value
+      if parameters.size != 1
+        raise_invalid_parameters_error(type_name.capitalize, 1, parameters.size)
+      end
+      TYPES.resource(type_name, parameters[0])
+    end
+  end
+
+  private
+
+  def assert_type(t)
+    raise_invalid_type_specification_error unless t.is_a?(Puppet::Pops::Types::PAnyType)
+    true
+  end
+
+  def assert_range_parameter(t)
+    raise_invalid_type_specification_error unless TYPES.is_range_parameter?(t)
+  end
+
+  def assert_struct_parameter(h)
+    raise_invalid_type_specification_error unless h.is_a?(Hash)
+    h.each do |k,v|
+      # TODO: Should have stricter name rule
+      raise_invalid_type_specification_error unless k.is_a?(String) && !k.empty?
+      assert_type(v)
+    end
+  end
+
+  def raise_invalid_type_specification_error
+    raise Puppet::ParseError,
+      "The expression <#{@string}> is not a valid type specification."
+  end
+
+  def raise_invalid_parameters_error(type, required, given)
+    raise Puppet::ParseError,
+      "Invalid number of type parameters specified: #{type} requires #{required}, #{given} provided"
+  end
+
+  def raise_unparameterized_type_error(ast)
+    raise Puppet::ParseError, "Not a parameterized type <#{original_text_of(ast)}>"
+  end
+
+  def raise_unknown_type_error(ast)
+    raise Puppet::ParseError, "Unknown type <#{original_text_of(ast)}>"
+  end
+
+  def original_text_of(ast)
+    position = Puppet::Pops::Adapters::SourcePosAdapter.adapt(ast)
+    position.extract_text()
+  end
+end