puppet 4.2.3 → 4.3.0

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

@@ -665,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
 
@@ -684,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
@@ -720,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
@@ -779,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, :'=>') }
@@ -793,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

@@ -533,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

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"

data/lib/puppet/pops/lookup.rb

@@ -1,43 +1,45 @@
 # This class is the backing implementation of the Puppet function 'lookup'.
 # See puppet/functions/lookup.rb for documentation.
 #
-class Puppet::Pops::Lookup
+module Puppet::Pops::Lookup
   # Performs a lookup in the configured scopes and optionally merges the default.
   #
   # This is a backing function and all parameters are assumed to have been type checked.
   # See puppet/functions/lookup.rb for full documentation and all parameter combinations.
   #
-  # @param scope [Puppet::Parser::Scope] The scope to use for the lookup
   # @param name [String|Array<String>] The name or names to lookup
   # @param type [Puppet::Pops::Types::PAnyType|nil] The expected type of the found value
   # @param default_value [Object] The value to use as default when no value is found
   # @param has_default [Boolean] Set to _true_ if _default_value_ is included (_nil_ is a valid _default_value_)
-  # @param override [Hash<String,Object>|nil] A map to use as override. Values found here are returned immediately (no merge)
-  # @param default_values_hash [Hash<String,Object>] A map to use as the last resort (but before default)
-  # @param merge [String|Hash<String,Object>|nil] Merge strategy or hash with strategy and options
+  # @param merge [Puppet::Pops::MergeStrategy,String,Hash<String,Object>,nil] Merge strategy or hash with strategy and options
+  # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] Invocation data containing scope, overrides, and defaults
   # @return [Object] The found value
   #
-  def self.lookup(scope, name, value_type, default_value, has_default, override, default_values_hash, merge)
-    value_type = Puppet::Pops::Types::PDataType.new if value_type.nil?
+  def self.lookup(name, value_type, default_value, has_default, merge, lookup_invocation)
+    value_type = Puppet::Pops::Types::PDataType::DEFAULT if value_type.nil?
     names = name.is_a?(Array) ? name : [name]
 
     # find first name that yields a non-nil result and wrap it in a two element array
     # with name and value.
-    not_found = Object.new
-    result_with_name = names.reduce([nil,not_found]) do |memo, key|
-      value = override.include?(key) ? assert_type('override', value_type, override[key]) : not_found
-      value = search_and_merge(key, scope, merge, not_found) if value.equal?(not_found)
+    not_found = Puppet::Pops::MergeStrategy::NOT_FOUND
+    override_values = lookup_invocation.override_values
+    result_with_name = names.reduce([nil, not_found]) do |memo, key|
+      value = override_values.include?(key) ? assert_type('override', value_type, override_values[key]) : not_found
+      catch(:no_such_key) { value = search_and_merge(key, lookup_invocation, merge) } if value.equal?(not_found)
       break [key, assert_type('found', value_type, value)] unless value.equal?(not_found)
       memo
     end
 
-    # Use the 'default_values_hash' map as a last resort if nothing is found
-    if result_with_name[1].equal?(not_found) && !default_values_hash.empty?
-      result_with_name = names.reduce(result_with_name) do |memo, key|
-        value = default_values_hash.include?(key) ? assert_type('default_values_hash', value_type, default_values_hash[key]) : not_found
-        memo = [ key, value ]
-        break memo unless value.equal?(not_found)
-        memo
+    # Use the 'default_values' hash as a last resort if nothing is found
+    if result_with_name[1].equal?(not_found)
+      default_values = lookup_invocation.default_values
+      unless default_values.empty?
+        result_with_name = names.reduce(result_with_name) do |memo, key|
+          value = default_values.include?(key) ? assert_type('default_values_hash', value_type, default_values[key]) : not_found
+          memo = [key, value]
+          break memo unless value.equal?(not_found)
+          memo
+        end
       end
     end
 
@@ -54,34 +56,10 @@ class Puppet::Pops::Lookup
     answer
   end
 
-  def self.search_and_merge(name, scope, merge, not_found)
-    in_global = lambda { lookup_with_databinding(name, scope, merge) }
-    in_env = lambda { Puppet::DataProviders.lookup_in_environment(name, scope, merge) }
-    in_module = lambda { Puppet::DataProviders.lookup_in_module(name, scope, merge) }
-
-    [in_global, in_env, in_module].reduce(not_found) do |memo, f|
-      found = false # can't trust catch return value since nil is valid
-      value = catch (:no_such_key) do
-        answer = f.call
-        found = true
-        answer
-      end
-      next memo unless found
-      break value if merge.nil? # value found and no merge
-      strategy = Puppet::Pops::MergeStrategy.strategy(merge)
-      memo.equal?(not_found) ? strategy.convert_value(value) : strategy.merge(memo, value)
-    end
-  end
-  private_class_method :search_and_merge
-
-  def self.lookup_with_databinding(key, scope, merge)
-    begin
-      Puppet::DataBinding.indirection.find(key, { :environment => scope.environment.to_s, :variables => scope, :merge => merge })
-    rescue Puppet::DataBinding::LookupError => e
-      raise Puppet::Error, "Error from DataBinding '#{Puppet[:data_binding_terminus]}' while looking up '#{name}': #{e.message}", e
-    end
+  # @api private
+  def self.search_and_merge(name, lookup_invocation, merge)
+    return Puppet::DataProviders.lookup_adapter(lookup_invocation).lookup(name, lookup_invocation, merge)
   end
-  private_class_method :lookup_with_databinding
 
   def self.assert_type(subject, type, value)
     Puppet::Pops::Types::TypeAsserter.assert_instance_of(subject, type, value)
@@ -89,8 +67,8 @@ class Puppet::Pops::Lookup
   private_class_method :assert_type
 
   def self.fail_lookup(names)
-    name_part = names.size == 1 ? "the name '#{names[0]}'" : 'any of the names [' + names.map {|n| "'#{n}'"} .join(', ') + ']'
-    raise Puppet::Error, "Function lookup() did not find a value for #{name_part}"
+    name_part = names.size == 1 ? "the name '#{names[0]}'" : 'any of the names [' + names.map { |n| "'#{n}'" }.join(', ') + ']'
+    raise Puppet::DataBinding::LookupError, "Function lookup() did not find a value for #{name_part}"
   end
   private_class_method :fail_lookup
 end