puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

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

@@ -0,0 +1,223 @@
+require 'rgen/metamodel_builder'
+
+# The Types model is a model of Puppet Language types.
+#
+# The exact relationship between types is not visible in this model wrt. the PDataType which is an abstraction
+# of Scalar, Array[Data], and Hash[Scalar, Data] nested to any depth. This means it is not possible to
+# infer the type by simply looking at the inheritance hierarchy. The {Puppet::Pops::Types::TypeCalculator} should
+# be used to answer questions about types. The {Puppet::Pops::Types::TypeFactory} should be used to create an instance
+# of a type whenever one is needed.
+#
+# The implementation of the Types model contains methods that are required for the type objects to behave as
+# expected when comparing them and using them as keys in hashes. (No other logic is, or should be included directly in
+# the model's classes).
+#
+# @api public
+#
+module Puppet::Pops::Types
+  extend RGen::MetamodelBuilder::ModuleExtension
+
+  class TypeModelObject < RGen::MetamodelBuilder::MMBase
+    abstract
+  end
+
+  # Base type for all types except {Puppet::Pops::Types::PType PType}, the type of types.
+  # @api public
+  #
+  class PAnyType < TypeModelObject
+  end
+
+  # The type of types.
+  # @api public
+  #
+  class PType < PAnyType
+    contains_one_uni 'type', PAnyType
+  end
+
+  # @api public
+  #
+  class PNilType < PAnyType
+  end
+
+
+  # A type private to the type system that describes "ignored type" - i.e. "I am what you are"
+  # @api private
+  #
+  class  PUnitType < PAnyType
+  end
+
+  # @api public
+  #
+  class PDefaultType < PAnyType
+  end
+
+  # A flexible data type, being assignable to its subtypes as well as PArrayType and PHashType with element type assignable to PDataType.
+  #
+  # @api public
+  #
+  class PDataType < PAnyType
+  end
+
+  # A flexible type describing an any? of other types
+  # @api public
+  #
+  class PVariantType < PAnyType
+    contains_many_uni 'types', PAnyType, :lowerBound => 1
+  end
+
+  # Type that is PDataType compatible, but is not a PCollectionType.
+  # @api public
+  #
+  class PScalarType < PAnyType
+  end
+
+  # A string type describing the set of strings having one of the given values
+  # @api public
+  #
+  class PEnumType < PScalarType
+    has_many_attr 'values', String, :lowerBound => 1
+  end
+
+  # @api public
+  #
+  class PNumericType < PScalarType
+  end
+
+  # @api public
+  #
+  class PIntegerType < PNumericType
+    has_attr 'from', Integer, :lowerBound => 0
+    has_attr 'to', Integer, :lowerBound => 0
+  end
+
+  # @api public
+  #
+  class PFloatType < PNumericType
+    has_attr 'from', Float, :lowerBound => 0
+    has_attr 'to', Float, :lowerBound => 0
+  end
+
+  # @api public
+  #
+  class PStringType < PScalarType
+    has_many_attr 'values', String, :lowerBound => 0, :upperBound => -1, :unique => true
+    contains_one_uni 'size_type', PIntegerType
+  end
+
+  # @api public
+  #
+  class PRegexpType < PScalarType
+    has_attr 'pattern', String, :lowerBound => 1
+    has_attr 'regexp', Object, :derived => true
+  end
+
+  # Represents a subtype of String that narrows the string to those matching the patterns
+  # If specified without a pattern it is basically the same as the String type.
+  #
+  # @api public
+  #
+  class PPatternType < PScalarType
+    contains_many_uni 'patterns', PRegexpType
+  end
+
+  # @api public
+  #
+  class PBooleanType < PScalarType
+  end
+
+  # @api public
+  #
+  class PCollectionType < PAnyType
+    contains_one_uni 'element_type', PAnyType
+    contains_one_uni 'size_type', PIntegerType
+  end
+
+  # @api public
+  #
+  class PStructElement < TypeModelObject
+    has_attr 'name', String, :lowerBound => 1
+    contains_one_uni 'type', PAnyType
+  end
+
+  # @api public
+  #
+  class PStructType < PAnyType
+    contains_many_uni 'elements', PStructElement, :lowerBound => 1
+    has_attr 'hashed_elements', Object, :derived => true
+  end
+
+  # @api public
+  #
+  class PTupleType < PAnyType
+    contains_many_uni 'types', PAnyType, :lowerBound => 1
+    # If set, describes min and max required of the given types - if max > size of
+    # types, the last type entry repeats
+    #
+    contains_one_uni 'size_type', PIntegerType, :lowerBound => 0
+  end
+
+  # @api public
+  #
+  class PCallableType < PAnyType
+    # Types of parameters as a Tuple with required/optional count, or an Integer with min (required), max count
+    contains_one_uni 'param_types', PAnyType, :lowerBound => 1
+
+    # Although being an abstract type reference, only Callable, or all Callables wrapped in
+    # Optional or Variant are supported
+    # If not set, the meaning is that block is not supported.
+    #
+    contains_one_uni 'block_type', PAnyType, :lowerBound => 0
+  end
+
+  # @api public
+  #
+  class PArrayType < PCollectionType
+  end
+
+  # @api public
+  #
+  class PHashType < PCollectionType
+    contains_one_uni 'key_type', PAnyType
+  end
+
+  RuntimeEnum = RGen::MetamodelBuilder::DataTypes::Enum.new(
+    :name => 'RuntimeEnum',
+    :literals => [:'ruby', ])
+
+  # @api public
+  #
+  class PRuntimeType < PAnyType
+    has_attr 'runtime', RuntimeEnum, :lowerBound => 1
+    has_attr 'runtime_type_name', String
+  end
+
+  # Abstract representation of a type that can be placed in a Catalog.
+  # @api public
+  #
+  class PCatalogEntryType < PAnyType
+  end
+
+  # Represents a (host-) class in the Puppet Language.
+  # @api public
+  #
+  class PHostClassType < PCatalogEntryType
+    has_attr 'class_name', String
+  end
+
+  # Represents a Resource Type in the Puppet Language
+  # @api public
+  #
+  class PResourceType < PCatalogEntryType
+    has_attr 'type_name', String
+    has_attr 'title', String
+  end
+
+  # Represents a type that accept PNilType instead of the type parameter
+  # required_type - is a short hand for Variant[T, Undef]
+  # @api public
+  #
+  class POptionalType < PAnyType
+    contains_one_uni 'optional_type', PAnyType
+  end
+
+end

data/lib/puppet/pops/utils.rb

@@ -7,8 +7,8 @@ module Puppet::Pops::Utils
   # and check if value is nil.
   def self.is_numeric?(o)
     case o
-    when Numeric, Integer, Fixnum, Float
-      !!o
+    when Numeric
+      true
     else
       !!Puppet::Pops::Patterns::NUMERIC.match(relativize_name(o.to_s))
     end
@@ -17,6 +17,7 @@ module Puppet::Pops::Utils
   # To Numeric with radix, or nil if not a number.
   # If the value is already Numeric it is returned verbatim with a radix of 10.
   # @param o [String, Number] a string containing a number in octal, hex, integer (decimal) or floating point form
+  #   with optional sign +/-
   # @return [Array<Number, Integer>, nil] array with converted number and radix, or nil if not possible to convert
   # @api public
   #
@@ -27,23 +28,23 @@ module Puppet::Pops::Utils
         match = Puppet::Pops::Patterns::NUMERIC.match(relativize_name(o))
         if !match
           nil
-        elsif match[3].to_s.length > 0
+        elsif match[5].to_s.length > 0
           # Use default radix (default is decimal == 10) for floats
-          [Float(match[0]), 10]
+          match[1] == '-' ? [-Float(match[2]), 10] : [Float(match[2]), 10]
         else
           # Set radix (default is decimal == 10)
           radix = 10
-          if match[1].to_s.length > 0
+          if match[3].to_s.length > 0
             radix = 16
-          elsif match[2].to_s.length > 1 && match[2][0,1] == '0'
+          elsif match[4].to_s.length > 1 && match[4][0,1] == '0'
             radix = 8
           end
           # Ruby 1.8.7 does not have a second argument to Kernel method that creates an
           # integer from a string, it relies on the prefix 0x, 0X, 0 (and unsupported in puppet binary 'b')
-          # We have the correct string here, match[0] is safe to parse without passing on radix
-          [Integer(match[0]), radix]
+          # We have the correct string here, match[2] is safe to parse without passing on radix
+          match[1] == '-' ? [-Integer(match[2]), radix] : [Integer(match[2]), radix]
         end
-      when Numeric, Fixnum, Integer, Float
+      when Numeric
         # Impossible to calculate radix, assume decimal
         [o, 10]
       else
@@ -55,7 +56,8 @@ module Puppet::Pops::Utils
   end
 
   # To Numeric (or already numeric)
-  # Returns nil if value is not numeric, else an Integer or Float
+  # Returns nil if value is not numeric, else an Integer or Float. A String may have an optional sign.
+  #
   # A leading '::' is accepted (and ignored)
   #
   def self.to_n o
@@ -65,12 +67,12 @@ module Puppet::Pops::Utils
         match = Puppet::Pops::Patterns::NUMERIC.match(relativize_name(o))
         if !match
           nil
-        elsif match[3].to_s.length > 0
-          Float(match[0])
+        elsif match[5].to_s.length > 0
+          match[1] == '-' ? -Float(match[2]) : Float(match[2])
         else
-          Integer(match[0])
+          match[1] == '-' ? -Integer(match[2]) : Integer(match[2])
         end
-      when Numeric, Fixnum, Integer, Float
+      when Numeric
         o
       else
         nil

data/lib/puppet/pops/validation/checker4_0.rb

@@ -25,6 +25,7 @@ class Puppet::Pops::Validation::Checker4_0
     @@query_visitor       ||= Puppet::Pops::Visitor.new(nil, "query", 0, 0)
     @@top_visitor         ||= Puppet::Pops::Visitor.new(nil, "top", 1, 1)
     @@relation_visitor    ||= Puppet::Pops::Visitor.new(nil, "relation", 0, 0)
+    @@idem_visitor        ||= Puppet::Pops::Visitor.new(self, "idem", 0, 0)
 
     @acceptor = diagnostics_producer
   end
@@ -77,6 +78,25 @@ class Puppet::Pops::Validation::Checker4_0
     @@assignment_visitor.visit_this_1(self, o, via_index)
   end
 
+  # Checks if the expression has side effect ('idem' is latin for 'the same', here meaning that the evaluation state
+  # is known to be unchanged after the expression has been evaluated). The result is not 100% authoritative for
+  # negative answers since analysis of function behavior is not possible.
+  # @return [Boolean] true if expression is known to have no effect on evaluation state
+  #
+  def idem(o)
+    @@idem_visitor.visit_this_0(self, o)
+  end
+
+  # Returns the last expression in a block, or the expression, if that expression is idem
+  def ends_with_idem(o)
+    if o.is_a?(Puppet::Pops::Model::BlockExpression)
+      last = o.statements[-1]
+      idem(last) ? last : nil
+    else
+      idem(o) ? o : nil
+    end
+  end
+
   #---ASSIGNMENT CHECKS
 
   def assign_VariableExpression(o, via_index)
@@ -130,9 +150,15 @@ class Puppet::Pops::Validation::Checker4_0
   end
 
   def check_AssignmentExpression(o)
-    acceptor.accept(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator}) unless [:'=', :'+=', :'-='].include? o.operator
-    assign(o.left_expr)
-    rvalue(o.right_expr)
+    case o.operator
+    when :'='
+      assign(o.left_expr)
+      rvalue(o.right_expr)
+    when :'+=', :'-='
+      acceptor.accept(Issues::APPENDS_DELETES_NO_LONGER_SUPPORTED, o, {:operator => o.operator})
+    else
+      acceptor.accept(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
+    end
   end
 
   # Checks that operation with :+> is contained in a ResourceOverride or Collector.
@@ -154,11 +180,31 @@ class Puppet::Pops::Validation::Checker4_0
     rvalue(o.value_expr)
   end
 
+  def check_AttributesOperation(o)
+    # Append operator use is constrained
+    parent = o.eContainer
+    parent = parent.eContainer unless parent.nil?
+    unless parent.is_a?(Model::ResourceExpression)
+      acceptor.accept(Issues::UNSUPPORTED_OPERATOR_IN_CONTEXT, o, :operator=>'* =>')
+    end
+
+    rvalue(o.expr)
+  end
+
   def check_BinaryExpression(o)
     rvalue(o.left_expr)
     rvalue(o.right_expr)
   end
 
+  def check_BlockExpression(o)
+    o.statements[0..-2].each do |statement|
+      if idem(statement)
+        acceptor.accept(Issues::IDEM_EXPRESSION_NOT_LAST, statement)
+        break # only flag the first
+      end
+    end
+  end
+
   def check_CallNamedFunctionExpression(o)
     case o.functor_expr
     when Puppet::Pops::Model::QualifiedName
@@ -172,6 +218,12 @@ class Puppet::Pops::Validation::Checker4_0
     end
   end
 
+  def check_EppExpression(o)
+    if o.eContainer.is_a?(Puppet::Pops::Model::LambdaExpression)
+      internal_check_no_capture(o.eContainer, o)
+    end
+  end
+
   def check_MethodCallExpression(o)
     unless o.functor_expr.is_a? Model::QualifiedName
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.functor_expr, :feature => 'function name', :container => o)
@@ -210,12 +262,84 @@ class Puppet::Pops::Validation::Checker4_0
     end
   end
 
+  RESERVED_TYPE_NAMES = {
+    'type' => true,
+    'any' => true,
+    'unit' => true,
+    'scalar' => true,
+    'boolean' => true,
+    'numeric' => true,
+    'integer' => true,
+    'float' => true,
+    'collection' => true,
+    'array' => true,
+    'hash' => true,
+    'tuple' => true,
+    'struct' => true,
+    'variant' => true,
+    'optional' => true,
+    'enum' => true,
+    'regexp' => true,
+    'pattern' => true,
+    'runtime' => true,
+  }
+
   # for 'class', 'define', and function
   def check_NamedDefinition(o)
     top(o.eContainer, o)
     if o.name !~ Puppet::Pops::Patterns::CLASSREF
       acceptor.accept(Issues::ILLEGAL_DEFINITION_NAME, o, {:name=>o.name})
     end
+
+    if RESERVED_TYPE_NAMES[o.name()]
+      acceptor.accept(Issues::RESERVED_TYPE_NAME, o, {:name => o.name})
+    end
+
+    if violator = ends_with_idem(o.body)
+      acceptor.accept(Issues::IDEM_NOT_ALLOWED_LAST, violator, {:container => o})
+    end
+  end
+
+  def check_HostClassDefinition(o)
+    check_NamedDefinition(o)
+    internal_check_no_capture(o)
+    internal_check_reserved_params(o)
+  end
+
+  def check_ResourceTypeDefinition(o)
+    check_NamedDefinition(o)
+    internal_check_no_capture(o)
+    internal_check_reserved_params(o)
+  end
+
+  def internal_check_capture_last(o)
+    accepted_index = o.parameters.size() -1
+    o.parameters.each_with_index do |p, index|
+      if p.captures_rest && index != accepted_index
+        acceptor.accept(Issues::CAPTURES_REST_NOT_LAST, p, {:param_name => p.name})
+      end
+    end
+  end
+
+  def internal_check_no_capture(o, container = o)
+    o.parameters.each do |p|
+      if p.captures_rest
+        acceptor.accept(Issues::CAPTURES_REST_NOT_SUPPORTED, p, {:container => container, :param_name => p.name})
+      end
+    end
+  end
+
+  RESERVED_PARAMETERS = {
+    'name' => true,
+    'title' => true,
+  }
+
+  def internal_check_reserved_params(o)
+    o.parameters.each do |p|
+      if RESERVED_PARAMETERS[p.name]
+        acceptor.accept(Issues::RESERVED_PARAMETER, p, {:container => o, :param_name => p.name})
+      end
+    end
   end
 
   def check_IfExpression(o)
@@ -229,9 +353,8 @@ class Puppet::Pops::Validation::Checker4_0
     # acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.key, :feature => 'hash key', :container => o.eContainer)
   end
 
-  # A Lambda is a Definition, but it may appear in other scopes than top scope (Which check_Definition asserts).
-  #
   def check_LambdaExpression(o)
+    internal_check_capture_last(o)
   end
 
   def check_LiteralList(o)
@@ -243,6 +366,12 @@ class Puppet::Pops::Validation::Checker4_0
     hostname(o.host_matches, o)
     hostname(o.parent, o, 'parent') unless o.parent.nil?
     top(o.eContainer, o)
+    if violator = ends_with_idem(o.body)
+      acceptor.accept(Issues::IDEM_NOT_ALLOWED_LAST, violator, {:container => o})
+    end
+    unless o.parent.nil?
+      acceptor.accept(Issues::ILLEGAL_NODE_INHERITANCE, o.parent)
+    end
   end
 
   # No checking takes place - all expressions using a QualifiedName need to check. This because the
@@ -275,7 +404,7 @@ class Puppet::Pops::Validation::Checker4_0
   def relation_RelationshipExpression(o); end
 
   def check_Parameter(o)
-    if o.name =~ /^[0-9]+$/
+    if o.name =~ /^(?:0x)?[0-9]+$/
       acceptor.accept(Issues::ILLEGAL_NUMERIC_PARAMETER, o, :name => o.name)
     end
   end
@@ -295,24 +424,41 @@ class Puppet::Pops::Validation::Checker4_0
   end
 
   def check_ResourceExpression(o)
-    # A resource expression must have a lower case NAME as its type e.g. 'file { ... }'
-    unless o.type_name.is_a? Model::QualifiedName
-      acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.type_name, :feature => 'resource type', :container => o)
+    # The expression for type name cannot be statically checked - this is instead done at runtime
+    # to enable better error message of the result of the expression rather than the static instruction.
+    # (This can be revised as there are static constructs that are illegal, but require updating many
+    # tests that expect the detailed reporting).
+  end
+
+  def check_ResourceBody(o)
+    seenUnfolding = false
+    o.operations.each do |ao|
+      if ao.is_a?(Puppet::Pops::Model::AttributesOperation)
+        if seenUnfolding
+          acceptor.accept(Issues::MULTIPLE_ATTRIBUTES_UNFOLD, ao)
+        else
+          seenUnfolding = true
+        end
+      end
     end
+  end
 
-    # This is a runtime check - the model is valid, but will have runtime issues when evaluated
-    # and storeconfigs is not set.
-    if acceptor.will_accept?(Issues::RT_NO_STORECONFIGS) && o.exported
-      acceptor.accept(Issues::RT_NO_STORECONFIGS_EXPORT, o)
+  def check_ResourceDefaultsExpression(o)
+    if o.form && o.form != :regular
+      acceptor.accept(Issues::NOT_VIRTUALIZEABLE, o)
     end
   end
 
-  def check_ResourceDefaultsExpression(o)
+  def check_ResourceOverrideExpression(o)
     if o.form && o.form != :regular
       acceptor.accept(Issues::NOT_VIRTUALIZEABLE, o)
     end
   end
 
+  def check_ReservedWord(o)
+    acceptor.accept(Issues::RESERVED_WORD, o, :word => o.word)
+  end
+
   def check_SelectorExpression(o)
     rvalue(o.left_expr)
   end
@@ -452,10 +598,6 @@ class Puppet::Pops::Validation::Checker4_0
   #
   def rvalue_Expression(o); end
 
-  def rvalue_ResourceDefaultsExpression(o); acceptor.accept(Issues::NOT_RVALUE, o) ; end
-
-  def rvalue_ResourceOverrideExpression(o); acceptor.accept(Issues::NOT_RVALUE, o) ; end
-
   def rvalue_CollectExpression(o)         ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_Definition(o)                ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
@@ -497,6 +639,110 @@ class Puppet::Pops::Validation::Checker4_0
     acceptor.accept(Issues::NOT_TOP_LEVEL, definition)
   end
 
+  #--IDEM CHECK
+  def idem_Object(o)
+    false
+  end
+
+  def idem_Nop(o)
+    true
+  end
+
+  def idem_NilClass(o)
+    true
+  end
+
+  def idem_Literal(o)
+    true
+  end
+
+  def idem_LiteralList(o)
+    true
+  end
+
+  def idem_LiteralHash(o)
+    true
+  end
+
+  def idem_Factory(o)
+    idem(o.current)
+  end
+
+  def idem_AccessExpression(o)
+    true
+  end
+
+  def idem_BinaryExpression(o)
+    true
+  end
+
+  def idem_RelationshipExpression(o)
+    # Always side effect
+    false
+  end
+
+  def idem_AssignmentExpression(o)
+    # Always side effect
+    false
+  end
+
+  # Handles UnaryMinusExpression, NotExpression, VariableExpression
+  def idem_UnaryExpression(o)
+    true
+  end
+
+  # Allow (no-effect parentheses) to be used around a productive expression
+  def idem_ParenthesizedExpression(o)
+    idem(o.expr)
+  end
+
+  def idem_RenderExpression(o)
+    false
+  end
+
+  def idem_RenderStringExpression(o)
+    false
+  end
+
+  def idem_BlockExpression(o)
+    # productive if there is at least one productive expression
+    ! o.statements.any? {|expr| !idem(expr) }
+  end
+
+  # Returns true even though there may be interpolated expressions that have side effect.
+  # Report as idem anyway, as it is very bad design to evaluate an interpolated string for its
+  # side effect only.
+  def idem_ConcatenatedString(o)
+    true
+  end
+
+  # Heredoc is just a string, but may contain interpolated string (which may have side effects).
+  # This is still bad design and should be reported as idem.
+  def idem_HeredocExpression(o)
+    true
+  end
+
+  # May technically have side effects inside the Selector, but this is bad design - treat as idem
+  def idem_SelectorExpression(o)
+    true
+  end
+
+  def idem_IfExpression(o)
+    [o.test, o.then_expr, o.else_expr].all? {|e| idem(e) }
+  end
+
+  # Case expression is idem, if test, and all options are idem
+  def idem_CaseExpression(o)
+    return false if !idem(o.test)
+    ! o.options.any? {|opt| !idem(opt) }
+  end
+
+  # An option is idem if values and the then_expression are idem
+  def idem_CaseOption(o)
+    return false if o.values.any? { |value| !idem(value) }
+    idem(o.then_expr)
+  end
+
   #--- NON POLYMORPH, NON CHECKING CODE
 
   # Produces string part of something named, or nil if not a QualifiedName or QualifiedReference