puppet 4.2.0 → 4.3.0

data/lib/puppet/pops/binder/scheme_handler/module_scheme.rb

@@ -15,7 +15,18 @@ require 'puppet/pops/binder/scheme_handler/symbolic_scheme'
 #   Does currently only support checking of optionality against files under a module. If the result should be loaded
 #   from any other location it can not be marked as optional as it will be ignored.
 #
-class Puppet::Pops::Binder::SchemeHandler::ModuleScheme < Puppet::Pops::Binder::SchemeHandler::SymbolicScheme
+module Puppet::Pops::Binder
+class SchemeHandler::ModuleScheme < SchemeHandler::SymbolicScheme
+
+  METADATA_DATA_PROVIDER = 'data_provider'.freeze
+
+  def contributed_bindings(uri, scope, composer)
+    split_name, fqn = fqn_from_path(uri)
+    bindings = Puppet::Bindings.resolve(scope, split_name[0]) || load_bindings(uri, scope, composer, split_name, fqn)
+
+    # Must clone as the rest mutates the model
+    BindingsFactory.contributed_bindings(fqn, Marshal.load(Marshal.dump(bindings)))
+  end
 
   # Expands URIs with wildcards and checks optionality.
   # @param uri [URI] the uri to possibly expand
@@ -29,13 +40,18 @@ class Puppet::Pops::Binder::SchemeHandler::ModuleScheme < Puppet::Pops::Binder::
     # supports wild card in the module name
     case split_name[0]
     when '*'
-      # create new URIs, one per module name that has a corresponding .rb file relative to its
-      # '<root>/lib/puppet/bindings/'
+      # create new URIs, one per module name that has a corresponding data_provider entry in metadata.json
+      # or an .rb file relative to its '<root>/lib/puppet/bindings/'
       #
-      composer.name_to_module.each_pair do | mod_name, mod |
-        expanded_name_parts = [mod_name] + split_name[1..-1]
+      composer.name_to_module.each_pair do | module_name, mod |
+        expanded_name_parts = [module_name] + split_name[1..-1]
         expanded_name = expanded_name_parts.join('::')
-        if Puppet::Pops::Binder::BindingsLoader.loadable?(mod.path, expanded_name)
+
+        if is_metadata?(split_name)
+          if mod.metadata && mod.metadata[METADATA_DATA_PROVIDER]
+            result << URI.parse('module:/' + expanded_name)
+          end
+        elsif BindingsLoader.loadable?(mod.path, expanded_name)
           result << URI.parse('module:/' + expanded_name)
         end
       end
@@ -43,11 +59,18 @@ class Puppet::Pops::Binder::SchemeHandler::ModuleScheme < Puppet::Pops::Binder::
       raise ArgumentError, "Bad bindings uri, the #{uri} has neither module name or wildcard '*' in its first path position"
     else
       joined_name = split_name.join('::')
+      module_name = split_name[0]
       # skip optional uri if it does not exist
       if is_optional?(uri)
-        mod = composer.name_to_module[split_name[0]]
-        if mod && Puppet::Binder::BindingsLoader.loadable?(mod.path, joined_name)
-          result << URI.parse('module:/' + joined_name)
+        mod = composer.name_to_module[module_name]
+        unless mod.nil?
+          if is_metadata?(split_name)
+            if mod.metadata && mod.metadata[METADATA_DATA_PROVIDER]
+              result << URI.parse('module:/' + joined_name)
+            end
+          elsif BindingsLoader.loadable?(mod.path, joined_name)
+            result << URI.parse('module:/' + joined_name)
+          end
         end
       else
         # assume it exists (do not give error if not, since it may be excluded later)
@@ -81,4 +104,40 @@ class Puppet::Pops::Binder::SchemeHandler::ModuleScheme < Puppet::Pops::Binder::
     end
     result
   end
+
+  def load_bindings(uri, scope, composer, split_name, fqn)
+    module_name = split_name[0]
+    mod = composer.name_to_module[module_name]
+    # given module name must exist
+    raise ArgumentError, "Cannot load bindings '#{uri}' - module not found." if mod.nil?
+
+    if is_metadata?(split_name)
+      metadata = mod.metadata
+      data_provider = metadata.nil? ? nil : metadata[METADATA_DATA_PROVIDER]
+      unless data_provider.nil?
+        # bind the data provider in a binding named after the module
+        # loader.load('thallgren/sample_module_data', Puppet.lookup(:current_environment))
+        Puppet::Bindings.newbindings(module_name) do
+          bind {
+            name(module_name)
+            to(data_provider)
+            in_multibind(Puppet::Plugins::DataProviders::PER_MODULE_DATA_PROVIDER_KEY)
+          }
+        end
+        # pick up and return the just created and registered bindings
+        bindings = Puppet::Bindings.resolve(scope, module_name)
+      end
+    else
+      bindings = BindingsLoader.provide(scope, fqn)
+    end
+    raise ArgumentError, "Cannot load bindings '#{uri}' - no bindings found." unless bindings
+    bindings
+  end
+  private :load_bindings
+
+  def is_metadata?(split_name)
+    split_name.size > 1 && split_name[1] == 'metadata'
+  end
+  private :is_metadata?
+end
 end

data/lib/puppet/pops/evaluator/access_operator.rb

@@ -164,10 +164,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       keys = keys[0, keys.size - 1]
     end
     assert_keys(keys, o, 1, Float::INFINITY, Puppet::Pops::Types::PAnyType)
-    t = Puppet::Pops::Types::TypeFactory.tuple(*keys)
-    # set size type, or nil for default (exactly 1)
-    t.size_type = size_type
-    t
+    Puppet::Pops::Types::TypeFactory.tuple(keys, size_type)
   end
 
   def access_PCallableType(o, scope, keys)
@@ -189,9 +186,7 @@ class Puppet::Pops::Evaluator::AccessOperator
     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
+    TYPEFACTORY.string(size_t)
   end
 
   # Asserts type of each key and calls fail with BAD_TYPE_SPECIFICATION
@@ -229,7 +224,7 @@ class Puppet::Pops::Evaluator::AccessOperator
     when :default
       'Default'
     else
-      Puppet::Pops::Types::TypeCalculator.generalize!(Puppet::Pops::Types::TypeCalculator.infer(actual)).to_s
+      Puppet::Pops::Types::TypeCalculator.generalize(Puppet::Pops::Types::TypeCalculator.infer(actual)).to_s
     end
   end
 
@@ -252,10 +247,14 @@ class Puppet::Pops::Evaluator::AccessOperator
     keys.flatten!
     if keys.size == 1
       type = keys[0]
-      unless type.is_a?(Puppet::Pops::Types::PAnyType) || type.is_a?(String)
-        fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => type.class})
+      unless type.is_a?(Puppet::Pops::Types::PAnyType)
+        if type.is_a?(String)
+          type = TYPEFACTORY.string(nil, type)
+        else
+          fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => type.class})
+        end
       end
-      TYPEFACTORY.optional(type)
+      Puppet::Pops::Types::POptionalType.new(type)
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Optional-Type', :min => 1, :actual => keys.size})
     end
@@ -270,7 +269,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       type = keys[0]
       case type
       when String
-        type = TYPEFACTORY.string(type)
+        type = TYPEFACTORY.string(nil, type)
       when Puppet::Pops::Types::PAnyType
         type = nil if type.class == Puppet::Pops::Types::PAnyType
       else
@@ -288,9 +287,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
         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
+      Puppet::Pops::Types::PType.new(keys[0])
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Type-Type', :min => 1, :actual => keys.size})
     end
@@ -312,11 +309,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       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
+    Puppet::Pops::Types::PIntegerType.new(*keys)
   end
 
   def access_PFloatType(o, scope, keys)
@@ -328,11 +321,10 @@ class Puppet::Pops::Evaluator::AccessOperator
       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
+    from = from == :default || from.nil? ? nil : Float(from)
+    to = to == :default || to.nil? ? nil : Float(to)
+    Puppet::Pops::Types::PFloatType.new(from, to)
   end
 
   # A Hash can create a new Hash type, one arg sets value type, two args sets key and value type in new type.
@@ -348,29 +340,18 @@ class Puppet::Pops::Evaluator::AccessOperator
     end
     case keys.size
     when 2
-      result = Puppet::Pops::Types::PHashType.new()
-      result.key_type = keys[0]
-      result.element_type = keys[1]
-      result
+      Puppet::Pops::Types::PHashType.new(keys[0], keys[1], nil)
     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
+      size_t = keys[2]
+      size_t = Puppet::Pops::Types::PIntegerType.new(size_t) unless size_t.is_a?(Puppet::Pops::Types::PIntegerType)
+      Puppet::Pops::Types::PHashType.new(keys[0], keys[1], size_t)
     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
+      Puppet::Pops::Types::PHashType.new(keys[0], keys[1], collection_size_t(1, keys[2], keys[3]))
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {
         :base_type => 'Hash-Type', :min => 2, :max => 4, :actual => keys.size
       })
     end
-    result.size_type = size_t if size_t
-    result
   end
 
   # CollectionType is parameterized with a range
@@ -385,9 +366,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       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
+    Puppet::Pops::Types::PCollectionType.new(size_t)
   end
 
   # An Array can create a new Array type. It is not possible to create a collection of Array types.
@@ -408,26 +387,19 @@ class Puppet::Pops::Evaluator::AccessOperator
     unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
       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
+    Puppet::Pops::Types::PArrayType.new(keys[0], size_t)
   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
+      keys[0]
     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
+      Puppet::Pops::Types::PIntegerType.new(*keys)
     end
   end
 
@@ -527,10 +499,7 @@ class Puppet::Pops::Evaluator::AccessOperator
         })
       end
 
-      rtype = Puppet::Pops::Types::PResourceType.new()
-      rtype.type_name = type_name
-      rtype.title = (t == :no_title ? nil : t)
-      rtype
+      Puppet::Pops::Types::PResourceType.new(type_name, t == :no_title ? nil : t)
     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
@@ -577,10 +546,8 @@ class Puppet::Pops::Evaluator::AccessOperator
                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(/^::/, EMPTY_STRING)
-          ctype
+          Puppet::Pops::Types::PHostClassType.new(name.sub(/^::/, EMPTY_STRING))
         else
           fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c})
         end

data/lib/puppet/pops/evaluator/closure.rb

@@ -27,8 +27,8 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
   def call(*args)
     variable_bindings = combine_values_with_parameters(args)
 
-    tc = Puppet::Pops::Types::TypeCalculator
-    final_args = tc.infer_set(parameters.inject([]) do |tmp_args, param|
+    tc = Puppet::Pops::Types::TypeCalculator.singleton
+    final_args = tc.infer_set(parameters.reduce([]) do |tmp_args, param|
       if param.captures_rest
         tmp_args.concat(variable_bindings[param.name])
       else
@@ -36,10 +36,10 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
       end
     end)
 
-    if tc.callable?(type, final_args)
+    if type.callable?(final_args)
       @evaluator.evaluate_block_with_bindings(@enclosing_scope, variable_bindings, @model.body)
     else
-      raise ArgumentError, "#{closure_name} called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string(closure_name, final_args, [self])}"
+      raise ArgumentError, Puppet::Pops::Types::TypeMismatchDescriber.describe_signatures(closure_name, [self], final_args)
     end
   end
 
@@ -78,10 +78,10 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
         raise ArgumentError, "Too few arguments; no value given for required parameters #{missing.collect(&:name).join(" ,")}"
       end
 
-      tc = Puppet::Pops::Types::TypeCalculator
+      tc = Puppet::Pops::Types::TypeCalculator.singleton
       final_args = tc.infer_set(parameter_names.collect { |param| scope_hash[param] })
-      if !tc.callable?(type, final_args)
-        raise ArgumentError, "#{closure_name} called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string(closure_name, final_args, [self])}"
+      if !type.callable?(final_args)
+        raise ArgumentError, Puppet::Pops::Types::TypeMismatchDescriber.describe_signatures(closure_name, [self], final_args)
       end
     else
       scope_hash = args_hash
@@ -199,7 +199,7 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
       type = if param.type_expr
                @evaluator.evaluate(param.type_expr, @enclosing_scope)
              else
-               Puppet::Pops::Types::TypeFactory.any()
+               Puppet::Pops::Types::PAnyType::DEFAULT
              end
 
       if param.captures_rest && type.is_a?(Puppet::Pops::Types::PArrayType)

data/lib/puppet/pops/evaluator/collectors/abstract_collector.rb

@@ -61,7 +61,7 @@ class Puppet::Pops::Evaluator::Collectors::AbstractCollector
 
     return false if objects.empty?
 
-    objects.inject(@collected) { |c,o| c[o.ref]=o; c }
+    objects.reduce(@collected) { |c,o| c[o.ref]=o; c }
 
     objects
   end

data/lib/puppet/pops/evaluator/evaluator_impl.rb

@@ -256,7 +256,11 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # Reserved Words fail to evaluate
   #
   def eval_ReservedWord(o, scope)
-    fail(Puppet::Pops::Issues::RESERVED_WORD, o, {:word => o.word})
+    if !o.future
+      fail(Puppet::Pops::Issues::RESERVED_WORD, o, {:word => o.word})
+    else
+      o.word
+    end
   end
 
   def eval_LiteralDefault(o, scope)
@@ -661,7 +665,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
 
       evaluated_name = evaluate(tmp_name, scope)
       unless type_name_acceptable
-        actual = type_calculator.generalize!(type_calculator.infer(evaluated_name)).to_s
+        actual = type_calculator.generalize(type_calculator.infer(evaluated_name)).to_s
         fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual => actual})
       end
 
@@ -680,7 +684,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
         evaluated_name.type_name # assume validated
 
       else
-        actual = type_calculator.generalize!(type_calculator.infer(evaluated_name)).to_s
+        actual = type_calculator.generalize(type_calculator.infer(evaluated_name)).to_s
         fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=>actual})
       end
     end
@@ -716,7 +720,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
           fail(Puppet::Pops::Issues::MISSING_TITLE_AT, body.title, {:index => index})
 
         elsif !title.is_a?(String) && title != :default
-          actual = type_calculator.generalize!(type_calculator.infer(title)).to_s
+          actual = type_calculator.generalize(type_calculator.infer(title)).to_s
           fail(Puppet::Pops::Issues::ILLEGAL_TITLE_TYPE_AT, body.title, {:index => index, :actual => actual})
 
         elsif title == EMPTY_STRING
@@ -775,7 +779,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   def eval_AttributesOperation(o, scope)
     hashed_params = evaluate(o.expr, scope)
     unless hashed_params.is_a?(Hash)
-      actual = type_calculator.generalize!(type_calculator.infer(hashed_params)).to_s
+      actual = type_calculator.generalize(type_calculator.infer(hashed_params)).to_s
       fail(Puppet::Pops::Issues::TYPE_MISMATCH, o.expr, {:expected => 'Hash', :actual => actual})
     end
     hashed_params.map { |k,v| create_resource_parameter(o, scope, k, v, :'=>') }
@@ -789,7 +793,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     if type.is_a?(Puppet::Pops::Types::PResourceType) && !type.type_name.nil? && type.title.nil?
       type.type_name # assume it is a valid name
     else
-      actual = type_calculator.generalize!(type_calculator.infer(type))
+      actual = type_calculator.generalize(type_calculator.infer(type))
       fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_ref, {:actual => actual})
     end
     evaluated_parameters = o.operations.map {|op| evaluate(op, scope) }

data/lib/puppet/pops/evaluator/literal_evaluator.rb

@@ -0,0 +1,87 @@
+require 'rgen/ecore/ecore'
+
+# Literal values for
+# String (not containing interpolation)
+# Numbers
+# Booleans
+# Undef (produces nil)
+# Array
+# Hash
+# QualifiedName
+# Default (produced :default)
+# Regular Expression (produces ruby reqular expression)
+#
+# Not considered literal
+# QualifiedReference  # i.e. File, FooBar
+#
+class Puppet::Pops::Evaluator::LiteralEvaluator
+  #include Puppet::Pops::Utils
+
+  EMPTY_STRING = ''.freeze
+  COMMA_SEPARATOR = ', '.freeze
+
+  def initialize
+    @@literal_visitor ||= Puppet::Pops::Visitor.new(self, "literal", 0, 0)
+  end
+
+  def literal(ast)
+    @@literal_visitor.visit_this_0(self, ast)
+  end
+
+  def literal_Object(o)
+    throw :not_literal
+  end
+
+  def literal_Factory(o)
+    literal(o.model)
+  end
+
+  def literal_Program(o)
+    literal(o.body)
+  end
+
+  def literal_LiteralString(o)
+    o.value
+  end
+
+  def literal_QualifiedName(o)
+    o.value
+  end
+
+  def literal_LiteralNumber(o)
+    o.value
+  end
+
+  def literal_LiteralBoolean(o)
+    o.value
+  end
+
+  def literal_LiteralUndef(o)
+    nil
+  end
+
+  def literal_LiteralDefault(o)
+    :default
+  end
+
+  def literal_LiteralRegularExpression(o)
+    o.value
+  end
+
+  def literal_ConcatenatedString(o)
+    # use double quoted string value if there is no interpolation
+    throw :not_literal unless o.segments.size == 1 && o.segments[0].is_a?(Puppet::Pops::Model::LiteralString)
+    o.segments[0].value
+  end
+
+  def literal_LiteralList(o)
+    o.values.map {|v| literal(v) }
+  end
+
+  def literal_LiteralHash(o)
+    o.entries.reduce({}) do |result, entry|
+      result[literal(entry.key)] = literal(entry.value)
+      result
+    end
+  end
+end

data/lib/puppet/pops/evaluator/relationship_operator.rb

@@ -48,6 +48,12 @@ class Puppet::Pops::Evaluator::RelationshipOperator
     raise IllegalRelationshipOperandError.new(o)
   end
 
+  # A Resource is by definition a Catalog type, but of 3.x type
+  # @api private
+  def transform_Resource(o, scope)
+    Puppet::Pops::Types::TypeFactory.resource(o.type, o.title)
+  end
+
   # A string must be a type reference in string format
   # @api private
   def transform_String(o, scope)
@@ -149,7 +155,7 @@ class Puppet::Pops::Evaluator::RelationshipOperator
       # Produce the transformed source RHS (if this is a chain, this does not need to be done again)
       real.slice(1)
     rescue NotCatalogTypeError => e
-      fail(Issues::ILLEGAL_RELATIONSHIP_OPERAND_TYPE, relationship_expression, {:type => @type_calculator.string(e.type)})
+      fail(Issues::NOT_CATALOG_TYPE, relationship_expression, {:type => @type_calculator.string(e.type)})
     rescue IllegalRelationshipOperandError => e
       fail(Issues::ILLEGAL_RELATIONSHIP_OPERAND_TYPE, relationship_expression, {:operand => e.operand})
     end

data/lib/puppet/pops/functions/dispatcher.rb

@@ -28,13 +28,13 @@ class Puppet::Pops::Functions::Dispatcher
   #
   # @api private
   def dispatch(instance, calling_scope, args, &block)
-    tc = Puppet::Pops::Types::TypeCalculator
+    tc = Puppet::Pops::Types::TypeCalculator.singleton
     actual = tc.infer_set(block_given? ? args + [block] : args)
     found = @dispatchers.find { |d| tc.callable?(d.type, actual) }
     if found
       found.invoke(instance, calling_scope, args, &block)
     else
-      raise ArgumentError, "function '#{instance.class.name}' called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string(instance.class.name, actual, @dispatchers)}"
+      raise ArgumentError, Puppet::Pops::Types::TypeMismatchDescriber.describe_signatures(instance.class.name, @dispatchers, actual)
     end
   end
 
@@ -62,7 +62,7 @@ class Puppet::Pops::Functions::Dispatcher
     # make a copy to make sure it can be contained by someone else (even if it is not contained here, it
     # should be treated as immutable).
     #
-    callables = dispatchers.map { | dispatch | dispatch.type.copy }
+    callables = dispatchers.map { | dispatch | dispatch.type }
 
     # multiple signatures, produce a Variant type of Callable1-n (must copy them)
     # single signature, produce single Callable

data/lib/puppet/pops/issues.rb

@@ -261,11 +261,15 @@ module Puppet::Pops::Issues
   end
 
   ILLEGAL_NAME = hard_issue :ILLEGAL_NAME, :name do
-    "Illegal name. The given name #{name} does not conform to the naming rule /^((::)?[a-z_]\w*)(::[a-z]\w*)*$/"
+    "Illegal name. The given name '#{name}' does not conform to the naming rule /^((::)?[a-z_]\w*)(::[a-z]\\w*)*$/"
+  end
+
+  ILLEGAL_PARAM_NAME = hard_issue :ILLEGAL_PARAM_NAME, :name do
+    "Illegal parameter name. The given name '#{name}' does not conform to the naming rule /^[a-z_]\\w*$/"
   end
 
   ILLEGAL_VAR_NAME = hard_issue :ILLEGAL_VAR_NAME, :name do
-    "Illegal variable name, The given name '#{name}' does not conform to the naming rule /^((::)?[a-z]\w*)*((::)?[a-z_]\w*)$/"
+    "Illegal variable name, The given name '#{name}' does not conform to the naming rule /^((::)?[a-z]\\w*)*((::)?[a-z_]\\w*)$/"
   end
 
   ILLEGAL_NUMERIC_VAR_NAME = hard_issue :ILLEGAL_NUMERIC_VAR_NAME, :name do
@@ -529,7 +533,7 @@ module Puppet::Pops::Issues
   end
 
   IDEM_EXPRESSION_NOT_LAST = issue :IDEM_EXPRESSION_NOT_LAST do
-    "This #{label.label(semantic)} has no effect. A value-producing expression without other effect may only be placed last in a block/sequence"
+    "This #{label.label(semantic)} has no effect. A value was produced and then forgotten (one or more preceding expressions may have the wrong form)"
   end
 
   IDEM_NOT_ALLOWED_LAST = hard_issue :IDEM_NOT_ALLOWED_LAST, :container do
@@ -540,6 +544,10 @@ module Puppet::Pops::Issues
     "Use of reserved word: #{word}, must be quoted if intended to be a String value"
   end
 
+  FUTURE_RESERVED_WORD = issue :FUTURE_RESERVED_WORD, :word do
+    "Use of future reserved word: '#{word}'"
+  end
+
   RESERVED_TYPE_NAME = hard_issue :RESERVED_TYPE_NAME, :name do
     "The name: '#{name}' is already defined by Puppet and can not be used as the name of #{label.a_an(semantic)}."
   end

data/lib/puppet/pops/label_provider.rb

@@ -1,7 +1,7 @@
 # Provides a label for an object.
 # This simple implementation calls #to_s on the given object, and handles articles 'a/an/the'.
 #
-class Puppet::Pops::LabelProvider
+module Puppet::Pops::LabelProvider
   VOWELS = %w{a e i o u y}
   SKIPPED_CHARACTERS = %w{" '}
   A = "a"