puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

data/lib/puppet/pops/parser/lexer2.rb

@@ -110,22 +110,23 @@ class Puppet::Pops::Parser::Lexer2
   # Booleans are pre-calculated (rather than evaluating the strings "false" "true" repeatedly.
   #
   KEYWORDS = {
-    "case"     => [:CASE,    'case',     4],
-    "class"    => [:CLASS,   'class',    5],
-    "default"  => [:DEFAULT, 'default',  7],
-    "define"   => [:DEFINE,  'define',   6],
-    "if"       => [:IF,      'if',       2],
-    "elsif"    => [:ELSIF,   'elsif',    5],
-    "else"     => [:ELSE,    'else',     4],
-    "inherits" => [:INHERITS,'inherits', 8],
-    "node"     => [:NODE,    'node',     4],
-    "and"      => [:AND,     'and',      3],
-    "or"       => [:OR,      'or',       2],
-    "undef"    => [:UNDEF,   'undef',    5],
-    "false"    => [:BOOLEAN, false,      5],
-    "true"     => [:BOOLEAN, true,       4],
-    "in"       => [:IN,      'in',       2],
-    "unless"   => [:UNLESS,  'unless',   6],
+    "case"     => [:CASE,     'case',     4],
+    "class"    => [:CLASS,    'class',    5],
+    "default"  => [:DEFAULT,  'default',  7],
+    "define"   => [:DEFINE,   'define',   6],
+    "if"       => [:IF,       'if',       2],
+    "elsif"    => [:ELSIF,    'elsif',    5],
+    "else"     => [:ELSE,     'else',     4],
+    "inherits" => [:INHERITS, 'inherits', 8],
+    "node"     => [:NODE,     'node',     4],
+    "and"      => [:AND,      'and',      3],
+    "or"       => [:OR,       'or',       2],
+    "undef"    => [:UNDEF,    'undef',    5],
+    "false"    => [:BOOLEAN,  false,      5],
+    "true"     => [:BOOLEAN,  true,       4],
+    "in"       => [:IN,       'in',       2],
+    "unless"   => [:UNLESS,   'unless',   6],
+    "function" => [:FUNCTION, 'function', 8],
   }
   KEYWORDS.each {|k,v| v[1].freeze; v.freeze }
   KEYWORDS.freeze

data/lib/puppet/pops/semantic_error.rb

@@ -0,0 +1,17 @@
+# Error that is used to raise an Issue. See {Puppet::Pops::Issues}.
+#
+class Puppet::Pops::SemanticError < RuntimeError
+  attr_accessor :issue
+  attr_accessor :semantic
+  attr_accessor :options
+
+  # @param issue [Puppet::Pops::Issues::Issue] the issue describing the severity and message
+  # @param semantic [Puppet::Pops::Model::Locatable, nil] the expression causing the failure, or nil if unknown
+  # @param options [Hash] an options hash with Symbol to valu mapping - these are the arguments to the issue
+  #
+  def initialize(issue, semantic=nil, options = {})
+    @issue = issue
+    @semantic = semantic
+    @options = options
+  end
+end

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

@@ -102,7 +102,22 @@ class Puppet::Pops::Types::TypeCalculator
     singleton.assignable?(t1,t2)
   end
 
+  # Answers, does the given callable accept the arguments given in args (an array or a tuple)
+  # @param callable [Puppet::Pops::Types::PCallableType] - the callable
+  # @param args [Puppet::Pops::Types::PArrayType, Puppet::Pops::Types::PTupleType] args optionally including a lambda callable at the end
+  # @return [Boolan] true if the callable accepts the arguments
+  #
+  # @api public
+  def self.callable?(callable, args)
+    singleton.callable?(callable, args)
+  end
+
+  # Produces a String representation of the given type.
+  # @param t [Puppet::Pops::Types::PAbstractType] the type to produce a string form
+  # @return [String] the type in string form
+  #
   # @api public
+  #
   def self.string(t)
     singleton.string(t)
   end
@@ -149,6 +164,7 @@ class Puppet::Pops::Types::TypeCalculator
     @@enumerable_visitor ||= Puppet::Pops::Visitor.new(nil,"enumerable",0,0)
     @@extract_visitor ||= Puppet::Pops::Visitor.new(nil,"extract",0,0)
     @@generalize_visitor ||= Puppet::Pops::Visitor.new(nil,"generalize",0,0)
+    @@callable_visitor ||= Puppet::Pops::Visitor.new(nil,"callable",1,1)
 
     da = Types::PArrayType.new()
     da.element_type = Types::PDataType.new()
@@ -191,6 +207,8 @@ class Puppet::Pops::Types::TypeCalculator
     non_empty_string.size_type.from = 1
     non_empty_string.size_type.to = nil # infinity
     @non_empty_string_t = non_empty_string
+
+    @nil_t = Types::PNilType.new
   end
 
   # Convenience method to get a data type for comparisons
@@ -234,13 +252,12 @@ class Puppet::Pops::Types::TypeCalculator
     end
   end
 
-  # Answers 'can an instance of type t2 be assigned to a variable of type t'
+  # Answers 'can an instance of type t2 be assigned to a variable of type t'.
+  # Does not accept nil/undef unless the type accepts it.
+  #
   # @api public
   #
   def assignable?(t, t2)
-    # nil is assignable to anything except to required types
-    return true if is_pnil?(t2)
-
     if t.is_a?(Class)
       t = type(t)
     end
@@ -257,6 +274,14 @@ class Puppet::Pops::Types::TypeCalculator
     @@enumerable_visitor.visit_this_0(self, t)
   end
 
+  # Answers, does the given callable accept the arguments given in args (an array or a tuple)
+  #
+  def callable?(callable, args)
+    return false if !callable.is_a?(Types::PCallableType)
+    # Note that polymorphism is for the args type, the callable is always a callable
+    @@callable_visitor.visit_this_1(self, args, callable)
+  end
+
   # Answers if the two given types describe the same type
   def equals(left, right)
     return false unless left.is_a?(Types::PAbstractType) && right.is_a?(Types::PAbstractType)
@@ -362,7 +387,6 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   def instance_of(t, o)
-#    return true if o.nil? && !t.is_a?(Types::PRequiredType)
     @@instance_of_visitor.visit_this_1(self, t, o)
   end
 
@@ -566,6 +590,12 @@ class Puppet::Pops::Types::TypeCalculator
       return Types::PPatternType.new()
     end
 
+    if t1.is_a?(Types::PCallableType) && t2.is_a?(Types::PCallableType)
+      # They do not have the same signature, and one is not assignable to the other,
+      # what remains is the most general form of Callable
+      return Types::PCallableType.new()
+    end
+
     # Common abstract types, from most specific to most general
     if common_numeric?(t1, t2)
       return Types::PNumericType.new()
@@ -659,6 +689,16 @@ class Puppet::Pops::Types::TypeCalculator
     Types::PType.new()
   end
 
+  # @api private
+  def infer_Closure(o)
+    o.type()
+  end
+
+  # @api private
+  def infer_Function(o)
+    o.class.dispatcher.to_type
+  end
+
   # @api private
   def infer_Object(o)
     type = Types::PRubyType.new()
@@ -669,7 +709,7 @@ class Puppet::Pops::Types::TypeCalculator
   # The type of all types is PType
   # @api private
   #
-  def infer_PObjectType(o)
+  def infer_PAbstractType(o)
     type = Types::PType.new()
     type.type = o.copy
     type
@@ -743,7 +783,10 @@ class Puppet::Pops::Types::TypeCalculator
   def infer_Resource(o)
     t = Types::PResourceType.new()
     t.type_name = o.type.to_s
-    t.title = o.title
+    # Only Puppet::Resource can have a title that is a symbol :undef, a PResource cannot.
+    # A mapping must be made to empty string. A nil value will result in an error later
+    title = o.title
+    t.title = (title == :undef ? '' : title)
     t
   end
 
@@ -790,15 +833,14 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   def infer_set_Array(o)
-    type = Types::PArrayType.new()
-    type.element_type = if o.empty?
-      Types::PNilType.new()
+    if o.empty?
+      type = Types::PArrayType.new()
+      type.element_type = Types::PNilType.new()
+      type.size_type = size_as_type(o)
     else
-      t = Types::PVariantType.new()
-      t.types = o.map() {|x| infer_set(x) }
-      t.types.size == 1 ? t.types[0] : t
+      type = Types::PTupleType.new()
+      type.types = o.map() {|x| infer_set(x) }
     end
-    type.size_type = size_as_type(o)
     type
   end
 
@@ -913,6 +955,39 @@ class Puppet::Pops::Types::TypeCalculator
     end
   end
 
+  # Catch all not callable combinations
+  def callable_Object(o, callable_t)
+    false
+  end
+
+  def callable_PTupleType(args_tuple, callable_t)
+    if args_tuple.size_type
+      raise ArgumentError, "Callable tuple may not have a size constraint when used as args"
+    end
+    # Assume no block was given - i.e. it is nil, and its type is PNilType
+    block_t = @nil_t
+    if args_tuple.types.last.is_a?(Types::PCallableType)
+      # a split is needed to make it possible to use required, optional, and varargs semantics
+      # of the tuple type.
+      #
+      args_tuple = args_tuple.copy
+      # to drop the callable, it must be removed explicitly since this is an rgen array
+      args_tuple.removeTypes(block_t = args_tuple.types.last())
+    else
+      # no block was given, if it is required, the below will fail
+    end
+    # unless argument types match parameter types
+    return false unless assignable?(callable_t.param_types, args_tuple)
+    # unless given block (or no block) matches expected block (or no block)
+    assignable?(callable_t.block_type || @nil_t, block_t)
+  end
+
+  def callable_PArrayType(args_array, callable_t)
+    return false unless assignable?(callable_t.param_types, args_array)
+    # does not support calling with a block, but have to check that callable expects it
+    assignable?(callable_t.block_type || @nil_t, @nil_t)
+  end
+
   def max(a,b)
     a >=b ? a : b
   end
@@ -1048,6 +1123,9 @@ class Puppet::Pops::Types::TypeCalculator
           # no string can match this enum anyway since it does not accept anything
           false
         end
+      else
+        # no other type matches string
+        false
       end
     elsif t2.is_a?(Types::PStringType)
       # A specific string acts as a set of strings - must have exactly the same strings
@@ -1093,6 +1171,19 @@ class Puppet::Pops::Types::TypeCalculator
     t2.is_a?(Types::PRegexpType) && (t.pattern.nil? || t.pattern == t2.pattern)
   end
 
+  # @api private
+  def assignable_PCallableType(t, t2)
+    return false unless t2.is_a?(Types::PCallableType)
+    # nil param_types means, any other Callable is assignable
+    return true if t.param_types.nil?
+    return false unless assignable?(t.param_types, t2.param_types)
+    # names are ignored, they are just information
+    # Blocks must be compatible
+    this_block_t = t.block_type || @nil_t
+    that_block_t = t2.block_type || @nil_t
+    assignable?(this_block_t, that_block_t)
+  end
+
   # @api private
   def assignable_PCollectionType(t, t2)
     size_t = t.size_type || @collection_default_size_t
@@ -1183,7 +1274,7 @@ class Puppet::Pops::Types::TypeCalculator
       struct_size = t2.elements.size
       element_type = t.element_type
       ( struct_size >= min && struct_size <= max &&
-        assignable?(t.key_type, @non_emptry_string_t)  &&
+        assignable?(t.key_type, @non_empty_string_t)  &&
         t2.hashed_elements.all? {|k,v| assignable?(element_type, v) })
     else
       false
@@ -1343,6 +1434,35 @@ class Puppet::Pops::Types::TypeCalculator
     s
   end
 
+  # @api private
+  def string_PCallableType(t)
+    # generic
+    return "Callable" if t.param_types.nil?
+
+    if t.param_types.types.empty?
+      range = [0, 0]
+    else
+      range = range_array_part(t.param_types.size_type)
+    end
+    types = t.param_types.types.map {|t2| string(t2) }
+
+    params_part= types.join(', ')
+
+    s = "Callable[" << types.join(', ')
+    unless range.empty?
+      (s << ', ') unless types.empty?
+      s << range.join(', ')
+    end
+    # Add block T last (after min, max) if present)
+    #
+    unless t.block_type.nil?
+      (s << ', ') unless types.empty? && range.empty?
+      s << string(t.block_type)
+    end
+    s << "]"
+    s
+  end
+
   # @api private
   def string_PStructType(t)
     return "Struct" if t.elements.empty?
@@ -1432,6 +1552,21 @@ class Puppet::Pops::Types::TypeCalculator
     t
   end
 
+  def self.copy_as_tuple(t)
+    case t
+    when Types::PTupleType
+      t.copy
+    when Types::PArrayType
+      # transform array to tuple
+      result = Types::PTupleType.new
+      result.addTypes(t.element_type.copy)
+      result.size_type = t.size_type.nil? ? nil : t.size_type.copy
+      result
+    else
+      raise ArgumentError, "Internal Error: Only Array and Tuple can be given to copy_as_tuple"
+    end
+  end
+
   private
 
   def class_from_string(str)

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

@@ -70,6 +70,11 @@ module Puppet::Pops::Types::TypeFactory
     t
   end
 
+  # Convenience method to produce an Optional[Object] type
+  def self.optional_object()
+    optional(object())
+  end
+
   # Produces the Enum type, optionally with specific string values
   # @api public
   #
@@ -135,6 +140,7 @@ module Puppet::Pops::Types::TypeFactory
     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
 
@@ -145,6 +151,7 @@ module Puppet::Pops::Types::TypeFactory
       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
@@ -177,6 +184,68 @@ module Puppet::Pops::Types::TypeFactory
     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)
+    case params.last
+    when Types::PCallableType
+      last_callable = true
+    when Types::POptionalType
+      last_callable = true if params.last.optional_type.is_a?(Types::PCallableType)
+    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) }
+
+    # 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
   #

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

@@ -180,6 +180,11 @@ class Puppet::Pops::Types::TypeParser
 
     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
@@ -329,6 +334,10 @@ class Puppet::Pops::Types::TypeParser
       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