diff --git a/lib/puppet/parser/ast/pops_bridge.rb b/lib/puppet/parser/ast/pops_bridge.rb
index 9c6a31744..22a687971 100644
--- a/lib/puppet/parser/ast/pops_bridge.rb
+++ b/lib/puppet/parser/ast/pops_bridge.rb
@@ -1,252 +1,242 @@
 require 'puppet/parser/ast/top_level_construct'
 require 'puppet/pops'
 
 # The AST::Bridge contains classes that bridges between the new Pops based model
 # and the 3.x AST. This is required to be able to reuse the Puppet::Resource::Type which is
 # fundamental for the rest of the logic.
 #
 class Puppet::Parser::AST::PopsBridge
 
   # Bridges to one Pops Model Expression
   # The @value is the expression
   # This is used to represent the body of a class, definition, or node, and for each parameter's default value
   # expression.
   #
   class Expression < Puppet::Parser::AST::Leaf
 
     def initialize args
       super
       @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new()
     end
 
     def to_s
       Puppet::Pops::Model::ModelTreeDumper.new.dump(@value)
     end
 
     def evaluate(scope)
       @@evaluator.evaluate(scope, @value)
     end
 
     # Adapts to 3x where top level constructs needs to have each to iterate over children. Short circuit this
     # by yielding self. By adding this there is no need to wrap a pops expression inside an AST::BlockExpression
     #
     def each
       yield self
     end
 
     def sequence_with(other)
       if value.nil?
         # This happens when testing and not having a complete setup
         other
       else
         # When does this happen ? Ever ?
         raise "sequence_with called on Puppet::Parser::AST::PopsBridge::Expression - please report use case"
         # What should be done if the above happens (We don't want this to happen).
         # Puppet::Parser::AST::BlockExpression.new(:children => [self] + other.children)
       end
     end
 
     # The 3x requires code plugged in to an AST to have this in certain positions in the tree. The purpose
     # is to either print the content, or to look for things that needs to be defined. This implementation
     # cheats by always returning an empty array. (This allows simple files to not require a "Program" at the top.
     #
     def children
       []
     end
   end
 
-  class NilAsUndefExpression < Expression
-    def evaluate(scope)
-      result = super
-      result.nil? ? :undef : result
-    end
-  end
-
   # Bridges the top level "Program" produced by the pops parser.
   # Its main purpose is to give one point where all definitions are instantiated (actually defined since the
   # Puppet 3x terminology is somewhat misleading - the definitions are instantiated, but instances of the created types
   # are not created, that happens when classes are included / required, nodes are matched and when resources are instantiated
   # by a resource expression (which is also used to instantiate a host class).
   #
   class Program < Puppet::Parser::AST::TopLevelConstruct
     attr_reader :program_model, :context
 
     def initialize(program_model, context = {})
       @program_model = program_model
       @context = context
       @ast_transformer ||= Puppet::Pops::Model::AstTransformer.new(@context[:file])
       @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new()
     end
 
     # This is the 3x API, the 3x AST searches through all code to find the instructions that can be instantiated.
     # This Pops-model based instantiation relies on the parser to build this list while parsing (which is more
     # efficient as it avoids one full scan of all logic via recursive enumeration/yield)
     #
     def instantiate(modname)
       @program_model.definitions.collect do |d|
         case d
         when Puppet::Pops::Model::HostClassDefinition
           instantiate_HostClassDefinition(d, modname)
         when Puppet::Pops::Model::ResourceTypeDefinition
           instantiate_ResourceTypeDefinition(d, modname)
         when Puppet::Pops::Model::NodeDefinition
           instantiate_NodeDefinition(d, modname)
         else
           raise Puppet::ParseError, "Internal Error: Unknown type of definition - got '#{d.class}'"
         end
       end.flatten().compact() # flatten since node definition may have returned an array
                               # Compact since functions are not understood by compiler
     end
 
     def evaluate(scope)
       @@evaluator.evaluate(scope, program_model)
     end
 
     # Adapts to 3x where top level constructs needs to have each to iterate over children. Short circuit this
     # by yielding self. This means that the HostClass container will call this bridge instance with `instantiate`.
     #
     def each
       yield self
     end
 
     private
 
     def instantiate_Parameter(o)
       # 3x needs parameters as an array of `[name]` or `[name, value_expr]`
-      # One problem is that the parameter evaluation takes place in the wrong context in 3x (the caller's and
-      # can thus reference all sorts of information. Here the value expression is wrapped in an AST Bridge to a Pops
-      # expression since the Pops side can not control the evaluation
       if o.value
-        [o.name, NilAsUndefExpression.new(:value => o.value)]
+        [o.name, Expression.new(:value => o.value)]
       else
         [o.name]
       end
     end
 
     def create_type_map(definition)
       result = {}
       # No need to do anything if there are no parameters
       return result unless definition.parameters.size > 0
 
       # No need to do anything if there are no typed parameters
       typed_parameters = definition.parameters.select {|p| p.type_expr }
       return result if typed_parameters.empty?
 
       # If there are typed parameters, they need to be evaluated to produce the corresponding type
       # instances. This evaluation requires a scope. A scope is not available when doing deserialization
       # (there is also no initialized evaluator). When running apply and test however, the environment is
       # reused and we may reenter without a scope (which is fine). A debug message is then output in case
       # there is the need to track down the odd corner case. See {#obtain_scope}.
       #
       if scope = obtain_scope
         typed_parameters.each do |p|
           result[p.name] =  @@evaluator.evaluate(scope, p.type_expr)
         end
       end
       result
     end
 
     # Obtains the scope or issues a warning if :global_scope is not bound
     def obtain_scope
       scope = Puppet.lookup(:global_scope) do
         # This occurs when testing and when applying a catalog (there is no scope available then), and
         # when running tests that run a partial setup.
         # This is bad if the logic is trying to compile, but a warning can not be issues since it is a normal
         # use case that there is no scope when requesting the type in order to just get the parameters.
         Puppet.debug("Instantiating Resource with type checked parameters - scope is missing, skipping type checking.")
         nil
       end
       scope
     end
 
     # Produces a hash with data for Definition and HostClass
     def args_from_definition(o, modname)
       args = {
        :arguments => o.parameters.collect {|p| instantiate_Parameter(p) },
        :argument_types => create_type_map(o),
        :module_name => modname
       }
       unless is_nop?(o.body)
         args[:code] = Expression.new(:value => o.body)
       end
       @ast_transformer.merge_location(args, o)
     end
 
     def instantiate_HostClassDefinition(o, modname)
       args = args_from_definition(o, modname)
       args[:parent] = absolute_reference(o.parent_class)
       Puppet::Resource::Type.new(:hostclass, o.name, @context.merge(args))
     end
 
     def instantiate_ResourceTypeDefinition(o, modname)
       Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname)))
     end
 
     def instantiate_NodeDefinition(o, modname)
       args = { :module_name => modname }
 
       unless is_nop?(o.body)
         args[:code] = Expression.new(:value => o.body)
       end
 
       unless is_nop?(o.parent)
         args[:parent] = @ast_transformer.hostname(o.parent)
       end
 
       host_matches = @ast_transformer.hostname(o.host_matches)
       @ast_transformer.merge_location(args, o)
       host_matches.collect do |name|
         Puppet::Resource::Type.new(:node, name, @context.merge(args))
       end
     end
 
     # Propagates a found Function to the appropriate loader.
     # This is for 4x future-evaluator/loader
     #
     def instantiate_FunctionDefinition(function_definition, modname)
       loaders = (Puppet.lookup(:loaders) { nil })
       unless loaders
         raise Puppet::ParseError, "Internal Error: Puppet Context ':loaders' missing - cannot define any functions"
       end
       loader =
       if modname.nil? || modname == ""
         # TODO : Later when functions can be private, a decision is needed regarding what that means.
         #        A private environment loader could be used for logic outside of modules, then only that logic
         #        would see the function.
         #
         # Use the private loader, this function may see the environment's dependencies (currently, all modules)
         loaders.private_environment_loader()
       else
         # TODO : Later check if function is private, and then add it to
         #        private_loader_for_module
         #
         loaders.public_loader_for_module(modname)
       end
       unless loader
         raise Puppet::ParseError, "Internal Error: did not find public loader for module: '#{modname}'"
       end
 
       # Instantiate Function, and store it in the environment loader
       typed_name, f = Puppet::Pops::Loader::PuppetFunctionInstantiator.create_from_model(function_definition, loader)
       loader.set_entry(typed_name, f, Puppet::Pops::Adapters::SourcePosAdapter.adapt(function_definition).to_uri)
 
       nil # do not want the function to inadvertently leak into 3x
     end
 
     def code()
       Expression.new(:value => @value)
     end
 
     def is_nop?(o)
       @ast_transformer.is_nop?(o)
     end
 
     def absolute_reference(ref)
       if ref.nil? || ref.empty? || ref.start_with?('::')
         ref
       else
         "::#{ref}"
       end
     end
   end
 end
diff --git a/lib/puppet/parser/resource.rb b/lib/puppet/parser/resource.rb
index cde664a33..f1f8ccd00 100644
--- a/lib/puppet/parser/resource.rb
+++ b/lib/puppet/parser/resource.rb
@@ -1,277 +1,275 @@
 require 'puppet/resource'
 
 # The primary difference between this class and its
 # parent is that this class has rules on who can set
 # parameters
 class Puppet::Parser::Resource < Puppet::Resource
   require 'puppet/parser/resource/param'
   require 'puppet/util/tagging'
   require 'puppet/parser/yaml_trimmer'
   require 'puppet/resource/type_collection_helper'
 
   include Puppet::Resource::TypeCollectionHelper
 
   include Puppet::Util
   include Puppet::Util::MethodHelper
   include Puppet::Util::Errors
   include Puppet::Util::Logging
   include Puppet::Parser::YamlTrimmer
 
   attr_accessor :source, :scope, :collector_id
   attr_accessor :virtual, :override, :translated, :catalog, :evaluated
   attr_accessor :file, :line
 
   attr_reader :exported, :parameters
 
   # Determine whether the provided parameter name is a relationship parameter.
   def self.relationship_parameter?(name)
     @relationship_names ||= Puppet::Type.relationship_params.collect { |p| p.name }
     @relationship_names.include?(name)
   end
 
   # Set up some boolean test methods
   def translated?; !!@translated; end
   def override?;   !!@override;   end
   def evaluated?;  !!@evaluated;  end
 
   def [](param)
     param = param.intern
     if param == :title
       return self.title
     end
     if @parameters.has_key?(param)
       @parameters[param].value
     else
       nil
     end
   end
 
   def eachparam
     @parameters.each do |name, param|
       yield param
     end
   end
 
   def environment
     scope.environment
   end
 
   # Process the  stage metaparameter for a class.   A containment edge
   # is drawn from  the class to the stage.   The stage for containment
   # defaults to main, if none is specified.
   def add_edge_to_stage
     return unless self.class?
 
     unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
       raise ArgumentError, "Could not find stage #{self[:stage] || :main} specified by #{self}"
     end
 
     self[:stage] ||= stage.title unless stage.title == :main
     catalog.add_edge(stage, self)
   end
 
   # Retrieve the associated definition and evaluate it.
   def evaluate
     return if evaluated?
     @evaluated = true
     if klass = resource_type and ! builtin_type?
       finish
       evaluated_code = klass.evaluate_code(self)
 
       return evaluated_code
     elsif builtin?
       devfail "Cannot evaluate a builtin type (#{type})"
     else
       self.fail "Cannot find definition #{type}"
     end
   end
 
   # Mark this resource as both exported and virtual,
   # or remove the exported mark.
   def exported=(value)
     if value
       @virtual = true
       @exported = value
     else
       @exported = value
     end
   end
 
   # Do any finishing work on this object, called before evaluation or
   # before storage/translation.
   def finish
     return if finished?
     @finished = true
     add_defaults
     add_scope_tags
     validate
   end
 
   # Has this resource already been finished?
   def finished?
     @finished
   end
 
   def initialize(*args)
     raise ArgumentError, "Resources require a hash as last argument" unless args.last.is_a? Hash
     raise ArgumentError, "Resources require a scope" unless args.last[:scope]
     super
 
     @source ||= scope.source
   end
 
   # Is this resource modeling an isomorphic resource type?
   def isomorphic?
     if builtin_type?
       return resource_type.isomorphic?
     else
       return true
     end
   end
 
   # Merge an override resource in.  This will throw exceptions if
   # any overrides aren't allowed.
   def merge(resource)
     # Test the resource scope, to make sure the resource is even allowed
     # to override.
     unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
       raise Puppet::ParseError.new("Only subclasses can override parameters", resource.line, resource.file)
     end
     # Some of these might fail, but they'll fail in the way we want.
     resource.parameters.each do |name, param|
       override_parameter(param)
     end
   end
 
   # This only mattered for clients < 0.25, which we don't support any longer.
   # ...but, since this hasn't been deprecated, and at least some functions
   # used it, deprecate now rather than just eliminate. --daniel 2012-07-15
   def metaparam_compatibility_mode?
     Puppet.deprecation_warning "metaparam_compatibility_mode? is obsolete since < 0.25 clients are really, really not supported any more"
     false
   end
 
   def name
     self[:name] || self.title
   end
 
   # A temporary occasion, until I get paths in the scopes figured out.
   alias path to_s
 
   # Define a parameter in our resource.
   # if we ever receive a parameter named 'tag', set
   # the resource tags with its value.
   def set_parameter(param, value = nil)
-    if ! value.nil?
+    if ! param.is_a?(Puppet::Parser::Resource::Param)
       param = Puppet::Parser::Resource::Param.new(
         :name => param, :value => value, :source => self.source
       )
-    elsif ! param.is_a?(Puppet::Parser::Resource::Param)
-      raise ArgumentError, "Received incomplete information - no value provided for parameter #{param}"
     end
 
     tag(*param.value) if param.name == :tag
 
     # And store it in our parameter hash.
     @parameters[param.name] = param
   end
   alias []= set_parameter
 
   def to_hash
     @parameters.inject({}) do |hash, ary|
       param = ary[1]
       # Skip "undef" and nil values.
       hash[param.name] = param.value if param.value != :undef && !param.value.nil?
       hash
     end
   end
 
   # Convert this resource to a RAL resource.
   def to_ral
     copy_as_resource.to_ral
   end
 
   # Is the receiver tagged with the given tags?
   # This match takes into account the tags that a resource will inherit from its container
   # but have not been set yet.
   # It does *not* take tags set via resource defaults as these will *never* be set on
   # the resource itself since all resources always have tags that are automatically
   # assigned.
   #
   def tagged?(*tags)
     super || ((scope_resource = scope.resource) && scope_resource != self && scope_resource.tagged?(tags))
   end
 
   private
 
   # Add default values from our definition.
   def add_defaults
     scope.lookupdefaults(self.type).each do |name, param|
       unless @parameters.include?(name)
         self.debug "Adding default for #{name}"
 
         @parameters[name] = param.dup
       end
     end
   end
 
   def add_scope_tags
     if scope_resource = scope.resource
       tag(*scope_resource.tags)
     end
   end
 
   # Accept a parameter from an override.
   def override_parameter(param)
     # This can happen if the override is defining a new parameter, rather
     # than replacing an existing one.
     (set_parameter(param) and return) unless current = @parameters[param.name]
 
     # The parameter is already set.  Fail if they're not allowed to override it.
     unless param.source.child_of?(current.source)
       msg = "Parameter '#{param.name}' is already set on #{self}"
       msg += " by #{current.source}" if current.source.to_s != ""
       if current.file or current.line
         fields = []
         fields << current.file if current.file
         fields << current.line.to_s if current.line
         msg += " at #{fields.join(":")}"
       end
       msg += "; cannot redefine"
       raise Puppet::ParseError.new(msg, param.line, param.file)
     end
 
     # If we've gotten this far, we're allowed to override.
 
     # Merge with previous value, if the parameter was generated with the +>
     # syntax.  It's important that we use a copy of the new param instance
     # here, not the old one, and not the original new one, so that the source
     # is registered correctly for later overrides but the values aren't
     # implcitly shared when multiple resources are overrriden at once (see
     # ticket #3556).
     if param.add
       param = param.dup
       param.value = [current.value, param.value].flatten
     end
 
     set_parameter(param)
   end
 
   # Make sure the resource's parameters are all valid for the type.
   def validate
     @parameters.each do |name, param|
       validate_parameter(name)
     end
   rescue => detail
     self.fail Puppet::ParseError, detail.to_s + " on #{self}", detail
   end
 
   def extract_parameters(params)
     params.each do |param|
       # Don't set the same parameter twice
       self.fail Puppet::ParseError, "Duplicate parameter '#{param.name}' for on #{self}" if @parameters[param.name]
 
       set_parameter(param)
     end
   end
 end
diff --git a/lib/puppet/parser/resource/param.rb b/lib/puppet/parser/resource/param.rb
index 423ae65f1..cb81043ba 100644
--- a/lib/puppet/parser/resource/param.rb
+++ b/lib/puppet/parser/resource/param.rb
@@ -1,25 +1,25 @@
 require 'puppet/parser/yaml_trimmer'
 
 # The parameters we stick in Resources.
 class Puppet::Parser::Resource::Param
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Util::MethodHelper
   include Puppet::Parser::YamlTrimmer
 
   attr_accessor :name, :value, :source, :add, :file, :line
 
   def initialize(hash)
     set_options(hash)
-    requiredopts(:name, :value)
+    requiredopts(:name)
     @name = @name.intern
   end
 
   def line_to_i
     line ? Integer(line) : nil
   end
 
   def to_s
     "#{self.name} => #{self.value}"
   end
 end
diff --git a/lib/puppet/pops/evaluator/evaluator_impl.rb b/lib/puppet/pops/evaluator/evaluator_impl.rb
index 02098d674..94e7a2a8b 100644
--- a/lib/puppet/pops/evaluator/evaluator_impl.rb
+++ b/lib/puppet/pops/evaluator/evaluator_impl.rb
@@ -1,1115 +1,1115 @@
 require 'rgen/ecore/ecore'
 require 'puppet/pops/evaluator/compare_operator'
 require 'puppet/pops/evaluator/relationship_operator'
 require 'puppet/pops/evaluator/access_operator'
 require 'puppet/pops/evaluator/closure'
 require 'puppet/pops/evaluator/external_syntax_support'
 
 # This implementation of {Puppet::Pops::Evaluator} performs evaluation using the puppet 3.x runtime system
 # in a manner largely compatible with Puppet 3.x, but adds new features and introduces constraints.
 #
 # The evaluation uses _polymorphic dispatch_ which works by dispatching to the first found method named after
 # the class or one of its super-classes. The EvaluatorImpl itself mainly deals with evaluation (it currently
 # also handles assignment), and it uses a delegation pattern to more specialized handlers of some operators
 # that in turn use polymorphic dispatch; this to not clutter EvaluatorImpl with too much responsibility).
 #
 # Since a pattern is used, only the main entry points are fully documented. The parameters _o_ and _scope_ are
 # the same in all the polymorphic methods, (the type of the parameter _o_ is reflected in the method's name;
 # either the actual class, or one of its super classes). The _scope_ parameter is always the scope in which
 # the evaluation takes place. If nothing else is mentioned, the return is always the result of evaluation.
 #
 # See {Puppet::Pops::Visitable} and {Puppet::Pops::Visitor} for more information about
 # polymorphic calling.
 #
 class Puppet::Pops::Evaluator::EvaluatorImpl
   include Puppet::Pops::Utils
 
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
   include Puppet::Pops::Evaluator::Runtime3Support
   include Puppet::Pops::Evaluator::ExternalSyntaxSupport
 
   # This constant is not defined as Float::INFINITY in Ruby 1.8.7 (but is available in later version
   # Refactor when support is dropped for Ruby 1.8.7.
   #
   INFINITY = 1.0 / 0.0
   EMPTY_STRING = ''.freeze
   COMMA_SEPARATOR = ', '.freeze
 
   # Reference to Issues name space makes it easier to refer to issues
   # (Issues are shared with the validator).
   #
   Issues = Puppet::Pops::Issues
 
   def initialize
     @@eval_visitor     ||= Puppet::Pops::Visitor.new(self, "eval", 1, 1)
     @@lvalue_visitor   ||= Puppet::Pops::Visitor.new(self, "lvalue", 1, 1)
     @@assign_visitor   ||= Puppet::Pops::Visitor.new(self, "assign", 3, 3)
     @@string_visitor   ||= Puppet::Pops::Visitor.new(self, "string", 1, 1)
 
     @@type_calculator  ||= Puppet::Pops::Types::TypeCalculator.new()
     @@type_parser      ||= Puppet::Pops::Types::TypeParser.new()
 
     @@compare_operator     ||= Puppet::Pops::Evaluator::CompareOperator.new()
     @@relationship_operator ||= Puppet::Pops::Evaluator::RelationshipOperator.new()
 
     # Initialize the runtime module
     Puppet::Pops::Evaluator::Runtime3Support.instance_method(:initialize).bind(self).call()
   end
 
   # @api private
   def type_calculator
     @@type_calculator
   end
 
   # Evaluates the given _target_ object in the given scope.
   #
   # @overload evaluate(target, scope)
   # @param target [Object] evaluation target - see methods on the pattern assign_TYPE for actual supported types.
   # @param scope [Object] the runtime specific scope class where evaluation should take place
   # @return [Object] the result of the evaluation
   #
   # @api public
   #
   def evaluate(target, scope)
     begin
       @@eval_visitor.visit_this_1(self, target, scope)
 
     rescue Puppet::Pops::SemanticError => e
       # a raised issue may not know the semantic target
       fail(e.issue, e.semantic || target, e.options, e)
 
     rescue StandardError => e
       if e.is_a? Puppet::ParseError
         # ParseError's are supposed to be fully configured with location information
         raise e
       end
       fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e)
     end
   end
 
   # Assigns the given _value_ to the given _target_. The additional argument _o_ is the instruction that
   # produced the target/value tuple and it is used to set the origin of the result.
   #
   # @param target [Object] assignment target - see methods on the pattern assign_TYPE for actual supported types.
   # @param value [Object] the value to assign to `target`
   # @param o [Puppet::Pops::Model::PopsObject] originating instruction
   # @param scope [Object] the runtime specific scope where evaluation should take place
   #
   # @api private
   #
   def assign(target, value, o, scope)
     @@assign_visitor.visit_this_3(self, target, value, o, scope)
   end
 
   # Computes a value that can be used as the LHS in an assignment.
   # @param o [Object] the expression to evaluate as a left (assignable) entity
   # @param scope [Object] the runtime specific scope where evaluation should take place
   #
   # @api private
   #
   def lvalue(o, scope)
     @@lvalue_visitor.visit_this_1(self, o, scope)
   end
 
   # Produces a String representation of the given object _o_ as used in interpolation.
   # @param o [Object] the expression of which a string representation is wanted
   # @param scope [Object] the runtime specific scope where evaluation should take place
   #
   # @api public
   #
   def string(o, scope)
     @@string_visitor.visit_this_1(self, o, scope)
   end
 
   # Evaluate a BlockExpression in a new scope with variables bound to the
   # given values.
   #
   # @param scope [Puppet::Parser::Scope] the parent scope
   # @param variable_bindings [Hash{String => Object}] the variable names and values to bind (names are keys, bound values are values)
   # @param block [Puppet::Pops::Model::BlockExpression] the sequence of expressions to evaluate in the new scope
   #
   # @api private
   #
   def evaluate_block_with_bindings(scope, variable_bindings, block_expr)
     with_guarded_scope(scope) do
       # change to create local scope_from - cannot give it file and line -
       # that is the place of the call, not "here"
       create_local_scope_from(variable_bindings, scope)
       evaluate(block_expr, scope)
     end
   end
 
   protected
 
   def lvalue_VariableExpression(o, scope)
     # evaluate the name
     evaluate(o.expr, scope)
   end
 
   # Catches all illegal lvalues
   #
   def lvalue_Object(o, scope)
     fail(Issues::ILLEGAL_ASSIGNMENT, o)
   end
 
   # Assign value to named variable.
   # The '$' sign is never part of the name.
   # @example In Puppet DSL
   #   $name = value
   # @param name [String] name of variable without $
   # @param value [Object] value to assign to the variable
   # @param o [Puppet::Pops::Model::PopsObject] originating instruction
   # @param scope [Object] the runtime specific scope where evaluation should take place
   # @return [value<Object>]
   #
   def assign_String(name, value, o, scope)
     if name =~ /::/
       fail(Issues::CROSS_SCOPE_ASSIGNMENT, o.left_expr, {:name => name})
     end
     set_variable(name, value, o, scope)
     value
   end
 
   def assign_Numeric(n, value, o, scope)
     fail(Issues::ILLEGAL_NUMERIC_ASSIGNMENT, o.left_expr, {:varname => n.to_s})
   end
 
   # Catches all illegal assignment (e.g. 1 = 2, {'a'=>1} = 2, etc)
   #
   def assign_Object(name, value, o, scope)
     fail(Issues::ILLEGAL_ASSIGNMENT, o)
   end
 
   def eval_Factory(o, scope)
     evaluate(o.current, scope)
   end
 
   # Evaluates any object not evaluated to something else to itself.
   def eval_Object o, scope
     o
   end
 
   # Allows nil to be used as a Nop, Evaluates to nil
   def eval_NilClass(o, scope)
     nil
   end
 
   # Evaluates Nop to nil.
   def eval_Nop(o, scope)
     nil
   end
 
   # Captures all LiteralValues not handled elsewhere.
   #
   def eval_LiteralValue(o, scope)
     o.value
   end
 
   # Reserved Words fail to evaluate
   #
   def eval_ReservedWord(o, scope)
     fail(Puppet::Pops::Issues::RESERVED_WORD, o, {:word => o.word})
   end
 
   def eval_LiteralDefault(o, scope)
     :default
   end
 
   def eval_LiteralUndef(o, scope)
     nil
   end
 
   # A QualifiedReference (i.e. a  capitalized qualified name such as Foo, or Foo::Bar) evaluates to a PType
   #
   def eval_QualifiedReference(o, scope)
     @@type_parser.interpret(o)
   end
 
   def eval_NotExpression(o, scope)
     ! is_true?(evaluate(o.expr, scope))
   end
 
   def eval_UnaryMinusExpression(o, scope)
     - coerce_numeric(evaluate(o.expr, scope), o, scope)
   end
 
   def eval_UnfoldExpression(o, scope)
     candidate = evaluate(o.expr, scope)
     case candidate
     when Array
       candidate
     when Hash
       candidate.to_a
     else
       # turns anything else into an array (so result can be unfolded)
       [candidate]
     end
   end
 
   # Abstract evaluation, returns array [left, right] with the evaluated result of left_expr and
   # right_expr
   # @return <Array<Object, Object>> array with result of evaluating left and right expressions
   #
   def eval_BinaryExpression o, scope
     [ evaluate(o.left_expr, scope), evaluate(o.right_expr, scope) ]
   end
 
   # Evaluates assignment with operators =, +=, -= and
   #
   # @example Puppet DSL
   #   $a = 1
   #   $a += 1
   #   $a -= 1
   #
   def eval_AssignmentExpression(o, scope)
     name = lvalue(o.left_expr, scope)
     value = evaluate(o.right_expr, scope)
 
     if o.operator == :'='
       assign(name, value, o, scope)
     else
       fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
     end
     value
   end
 
   ARITHMETIC_OPERATORS = [:'+', :'-', :'*', :'/', :'%', :'<<', :'>>']
   COLLECTION_OPERATORS = [:'+', :'-', :'<<']
 
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
   def eval_ArithmeticExpression(o, scope)
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
 
     begin
       result = calculate(left, right, o.operator, o.left_expr, o.right_expr, scope)
     rescue ArgumentError => e
       fail(Issues::RUNTIME_ERROR, o, {:detail => e.message}, e)
     end
     result
   end
 
 
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
   def calculate(left, right, operator, left_o, right_o, scope)
     unless ARITHMETIC_OPERATORS.include?(operator)
       fail(Issues::UNSUPPORTED_OPERATOR, left_o.eContainer, {:operator => o.operator})
     end
 
     if (left.is_a?(Array) || left.is_a?(Hash)) && COLLECTION_OPERATORS.include?(operator)
       # Handle operation on collections
       case operator
       when :'+'
         concatenate(left, right)
       when :'-'
         delete(left, right)
       when :'<<'
         unless left.is_a?(Array)
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
         end
         left + [right]
       end
     else
       # Handle operation on numeric
       left = coerce_numeric(left, left_o, scope)
       right = coerce_numeric(right, right_o, scope)
       begin
         if operator == :'%' && (left.is_a?(Float) || right.is_a?(Float))
           # Deny users the fun of seeing severe rounding errors and confusing results
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
         end
         result = left.send(operator, right)
       rescue NoMethodError => e
         fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
       rescue ZeroDivisionError => e
         fail(Issues::DIV_BY_ZERO, right_o)
       end
       if result == INFINITY || result == -INFINITY
         fail(Issues::RESULT_IS_INFINITY, left_o, {:operator => operator})
       end
       result
     end
   end
 
   def eval_EppExpression(o, scope)
     scope["@epp"] = []
     evaluate(o.body, scope)
     result = scope["@epp"].join
     result
   end
 
   def eval_RenderStringExpression(o, scope)
     scope["@epp"] << o.value.dup
     nil
   end
 
   def eval_RenderExpression(o, scope)
     scope["@epp"] << string(evaluate(o.expr, scope), scope)
     nil
   end
 
   # Evaluates Puppet DSL ->, ~>, <-, and <~
   def eval_RelationshipExpression(o, scope)
     # First level evaluation, reduction to basic data types or puppet types, the relationship operator then translates this
     # to the final set of references (turning strings into references, which can not naturally be done by the main evaluator since
     # all strings should not be turned into references.
     #
     real = eval_BinaryExpression(o, scope)
     @@relationship_operator.evaluate(real, o, scope)
   end
 
   # Evaluates x[key, key, ...]
   #
   def eval_AccessExpression(o, scope)
     left = evaluate(o.left_expr, scope)
     keys = o.keys.nil? ? [] : o.keys.collect {|key| evaluate(key, scope) }
     Puppet::Pops::Evaluator::AccessOperator.new(o).access(left, scope, *keys)
   end
 
   # Evaluates <, <=, >, >=, and ==
   #
   def eval_ComparisonExpression o, scope
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
 
     begin
     # Left is a type
     if left.is_a?(Puppet::Pops::Types::PAnyType)
       case o.operator
       when :'=='
         @@type_calculator.equals(left,right)
 
       when :'!='
         !@@type_calculator.equals(left,right)
 
       when :'<'
         # left can be assigned to right, but they are not equal
         @@type_calculator.assignable?(right, left) && ! @@type_calculator.equals(left,right)
       when :'<='
         # left can be assigned to right
         @@type_calculator.assignable?(right, left)
       when :'>'
         # right can be assigned to left, but they are not equal
         @@type_calculator.assignable?(left,right) && ! @@type_calculator.equals(left,right)
       when :'>='
         # right can be assigned to left
         @@type_calculator.assignable?(left, right)
       else
         fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
       end
     else
       case o.operator
       when :'=='
         @@compare_operator.equals(left,right)
       when :'!='
         ! @@compare_operator.equals(left,right)
       when :'<'
         @@compare_operator.compare(left,right) < 0
       when :'<='
         @@compare_operator.compare(left,right) <= 0
       when :'>'
         @@compare_operator.compare(left,right) > 0
       when :'>='
         @@compare_operator.compare(left,right) >= 0
       else
         fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
       end
     end
     rescue ArgumentError => e
       fail(Issues::COMPARISON_NOT_POSSIBLE, o, {
         :operator => o.operator,
         :left_value => left,
         :right_value => right,
         :detail => e.message}, e)
     end
   end
 
   # Evaluates matching expressions with type, string or regexp rhs expression.
   # If RHS is a type, the =~ matches compatible (instance? of) type.
   #
   # @example
   #   x =~ /abc.*/
   # @example
   #   x =~ "abc.*/"
   # @example
   #   y = "abc"
   #   x =~ "${y}.*"
   # @example
   #   [1,2,3] =~ Array[Integer[1,10]]
   #
   # Note that a string is not instance? of Regexp, only Regular expressions are.
   # The Pattern type should instead be used as it is specified as subtype of String.
   #
   # @return [Boolean] if a match was made or not. Also sets $0..$n to matchdata in current scope.
   #
   def eval_MatchExpression o, scope
     left = evaluate(o.left_expr, scope)
     pattern = evaluate(o.right_expr, scope)
 
     # matches RHS types as instance of for all types except a parameterized Regexp[R]
     if pattern.is_a?(Puppet::Pops::Types::PAnyType)
       # evaluate as instance? of type check
       matched = @@type_calculator.instance?(pattern, left)
       # convert match result to Boolean true, or false
       return o.operator == :'=~' ? !!matched : !matched
     end
 
     begin
       pattern = Regexp.new(pattern) unless pattern.is_a?(Regexp)
     rescue StandardError => e
       fail(Issues::MATCH_NOT_REGEXP, o.right_expr, {:detail => e.message}, e)
     end
     unless left.is_a?(String)
       fail(Issues::MATCH_NOT_STRING, o.left_expr, {:left_value => left})
     end
 
     matched = pattern.match(left) # nil, or MatchData
     set_match_data(matched,scope) # creates ephemeral
 
     # convert match result to Boolean true, or false
     o.operator == :'=~' ? !!matched : !matched
   end
 
   # Evaluates Puppet DSL `in` expression
   #
   def eval_InExpression o, scope
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
     @@compare_operator.include?(right, left, scope)
   end
 
   # @example
   #   $a and $b
   # b is only evaluated if a is true
   #
   def eval_AndExpression o, scope
     is_true?(evaluate(o.left_expr, scope)) ? is_true?(evaluate(o.right_expr, scope)) : false
   end
 
   # @example
   #   a or b
   # b is only evaluated if a is false
   #
   def eval_OrExpression o, scope
     is_true?(evaluate(o.left_expr, scope)) ? true : is_true?(evaluate(o.right_expr, scope))
   end
 
   # Evaluates each entry of the literal list and creates a new Array
   # Supports unfolding of entries
   # @return [Array] with the evaluated content
   #
   def eval_LiteralList o, scope
     unfold([], o.values, scope)
   end
 
   # Evaluates each entry of the literal hash and creates a new Hash.
   # @return [Hash] with the evaluated content
   #
   def eval_LiteralHash o, scope
     # optimized
     o.entries.reduce({}) {|h,entry| h[evaluate(entry.key, scope)] = evaluate(entry.value, scope); h }
   end
 
   # Evaluates all statements and produces the last evaluated value
   #
   def eval_BlockExpression o, scope
     r = nil
     o.statements.each {|s| r = evaluate(s, scope)}
     r
   end
 
   # Performs optimized search over case option values, lazily evaluating each
   # until there is a match. If no match is found, the case expression's default expression
   # is evaluated (it may be nil or Nop if there is no default, thus producing nil).
   # If an option matches, the result of evaluating that option is returned.
   # @return [Object, nil] what a matched option returns, or nil if nothing matched.
   #
   def eval_CaseExpression(o, scope)
     # memo scope level before evaluating test - don't want a match in the case test to leak $n match vars
     # to expressions after the case expression.
     #
     with_guarded_scope(scope) do
       test = evaluate(o.test, scope)
       result = nil
       the_default = nil
       if o.options.find do |co|
         # the first case option that matches
         if co.values.find do |c|
           case c
           when Puppet::Pops::Model::LiteralDefault
             the_default = co.then_expr
             is_match?(test, evaluate(c, scope), c, scope)
           when Puppet::Pops::Model::UnfoldExpression
             # not ideal for error reporting, since it is not known which unfolded result
             # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
             evaluate(c, scope).any? {|v| is_match?(test, v, c, scope) }
           else
             is_match?(test, evaluate(c, scope), c, scope)
           end
         end
         result = evaluate(co.then_expr, scope)
         true # the option was picked
         end
       end
         result # an option was picked, and produced a result
       else
         evaluate(the_default, scope) # evaluate the default (should be a nop/nil) if there is no default).
       end
     end
   end
 
   # Evaluates a CollectExpression by transforming it into a 3x AST::Collection and then evaluating that.
   # This is done because of the complex API between compiler, indirector, backends, and difference between
   # collecting virtual resources and exported resources.
   #
   def eval_CollectExpression o, scope
     # The Collect Expression and its contained query expressions are implemented in such a way in
     # 3x that it is almost impossible to do anything about them (the AST objects are lazily evaluated,
     # and the built structure consists of both higher order functions and arrays with query expressions
     # that are either used as a predicate filter, or given to an indirection terminus (such as the Puppet DB
     # resource terminus). Unfortunately, the 3x implementation has many inconsistencies that the implementation
     # below carries forward.
     #
     collect_3x = Puppet::Pops::Model::AstTransformer.new().transform(o)
     collected = collect_3x.evaluate(scope)
     # the 3x returns an instance of Parser::Collector (but it is only registered with the compiler at this
     # point and does not contain any valuable information (like the result)
     # Dilemma: If this object is returned, it is a first class value in the Puppet Language and we
     # need to be able to perform operations on it. We can forbid it from leaking by making CollectExpression
     # a non R-value. This makes it possible for the evaluator logic to make use of the Collector.
     collected
   end
 
   def eval_ParenthesizedExpression(o, scope)
     evaluate(o.expr, scope)
   end
 
   # This evaluates classes, nodes and resource type definitions to nil, since 3x:
   # instantiates them, and evaluates their parameters and body. This is achieved by
   # providing bridge AST classes in Puppet::Parser::AST::PopsBridge that bridges a
   # Pops Program and a Pops Expression.
   #
   # Since all Definitions are handled "out of band", they are treated as a no-op when
   # evaluated.
   #
   def eval_Definition(o, scope)
     nil
   end
 
   def eval_Program(o, scope)
     evaluate(o.body, scope)
   end
 
   # Produces Array[PAnyType], an array of resource references
   #
   def eval_ResourceExpression(o, scope)
     exported = o.exported
     virtual = o.virtual
 
     # Get the type name
     type_name =
     if (tmp_name = o.type_name).is_a?(Puppet::Pops::Model::QualifiedName)
       tmp_name.value # already validated as a name
     else
       type_name_acceptable =
       case o.type_name
       when Puppet::Pops::Model::QualifiedReference
         true
       when Puppet::Pops::Model::AccessExpression
         o.type_name.left_expr.is_a?(Puppet::Pops::Model::QualifiedReference)
       end
 
       evaluated_name = evaluate(tmp_name, scope)
       unless type_name_acceptable
         actual = type_calculator.generalize!(type_calculator.infer(evaluated_name)).to_s
         fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual => actual})
       end
 
       # must be a CatalogEntry subtype
       case evaluated_name
       when Puppet::Pops::Types::PHostClassType
         unless evaluated_name.class_name.nil?
           fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
         end
         'class'
 
       when Puppet::Pops::Types::PResourceType
         unless evaluated_name.title().nil?
           fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
         end
         evaluated_name.type_name # assume validated
 
       else
         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
 
     # This is a runtime check - the model is valid, but will have runtime issues when evaluated
     # and storeconfigs is not set.
     if(o.exported)
       optionally_fail(Puppet::Pops::Issues::RT_NO_STORECONFIGS_EXPORT, o);
     end
 
     titles_to_body = {}
     body_to_titles = {}
     body_to_params = {}
 
     # titles are evaluated before attribute operations
     o.bodies.map do | body |
       titles = evaluate(body.title, scope)
 
       # Title may not be nil
       # Titles may be given as an array, it is ok if it is empty, but not if it contains nil entries
       # Titles may not be an empty String
       # Titles must be unique in the same resource expression
       # There may be a :default entry, its entries apply with lower precedence
       #
       if titles.nil?
         fail(Puppet::Pops::Issues::MISSING_TITLE, body.title)
       end
       titles = [titles].flatten
 
       # Check types of evaluated titles and duplicate entries
       titles.each_with_index do |title, index|
         if title.nil?
           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
           fail(Puppet::Pops::Issues::ILLEGAL_TITLE_TYPE_AT, body.title, {:index => index, :actual => actual})
 
         elsif title == EMPTY_STRING
          fail(Puppet::Pops::Issues::EMPTY_STRING_TITLE_AT, body.title, {:index => index})
 
         elsif titles_to_body[title]
           fail(Puppet::Pops::Issues::DUPLICATE_TITLE, o, {:title => title})
         end
         titles_to_body[title] = body
       end
 
       # Do not create a real instance from the :default case
       titles.delete(:default)
 
       body_to_titles[body] = titles
 
       # Store evaluated parameters in a hash associated with the body, but do not yet create resource
       # since the entry containing :defaults may appear later
       body_to_params[body] = body.operations.reduce({}) do |param_memo, op|
         params = evaluate(op, scope)
         params = [params] unless params.is_a?(Array)
         params.each do |p|
           if param_memo.include? p.name
             fail(Puppet::Pops::Issues::DUPLICATE_ATTRIBUTE, o, {:attribute => p.name})
           end
-          param_memo[p.name] = p 
+          param_memo[p.name] = p
         end
         param_memo
       end
     end
 
     # Titles and Operations have now been evaluated and resources can be created
     # Each production is a PResource, and an array of all is produced as the result of
     # evaluating the ResourceExpression.
     #
     defaults_hash = body_to_params[titles_to_body[:default]] || {}
     o.bodies.map do | body |
       titles = body_to_titles[body]
       params = defaults_hash.merge(body_to_params[body] || {})
       create_resources(o, scope, virtual, exported, type_name, titles, params.values)
     end.flatten.compact
   end
 
   def eval_ResourceOverrideExpression(o, scope)
     evaluated_resources = evaluate(o.resources, scope)
     evaluated_parameters = o.operations.map { |op| evaluate(op, scope) }
     create_resource_overrides(o, scope, [evaluated_resources].flatten, evaluated_parameters)
     evaluated_resources
   end
 
   # Produces 3x parameter
   def eval_AttributeOperation(o, scope)
     create_resource_parameter(o, scope, o.attribute_name, evaluate(o.value_expr, scope), o.operator)
   end
 
   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
       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, :'=>') }
   end
 
   # Sets default parameter values for a type, produces the type
   #
   def eval_ResourceDefaultsExpression(o, scope)
     type = evaluate(o.type_ref, scope)
     type_name =
     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))
       fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_ref, {:actual => actual})
     end
     evaluated_parameters = o.operations.map {|op| evaluate(op, scope) }
     create_resource_defaults(o, scope, type_name, evaluated_parameters)
     # Produce the type
     type
   end
 
   # Evaluates function call by name.
   #
   def eval_CallNamedFunctionExpression(o, scope)
     # The functor expression is not evaluated, it is not possible to select the function to call
     # via an expression like $a()
     case o.functor_expr
     when Puppet::Pops::Model::QualifiedName
       # ok
     when Puppet::Pops::Model::RenderStringExpression
       # helpful to point out this easy to make Epp error
       fail(Issues::ILLEGAL_EPP_PARAMETERS, o)
     else
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end
     name = o.functor_expr.value
 
     evaluated_arguments = unfold([], o.arguments, scope)
 
     # wrap lambda in a callable block if it is present
     evaluated_arguments << Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope) if o.lambda
     call_function(name, evaluated_arguments, o, scope)
   end
 
   # Evaluation of CallMethodExpression handles a NamedAccessExpression functor (receiver.function_name)
   #
   def eval_CallMethodExpression(o, scope)
     unless o.functor_expr.is_a? Puppet::Pops::Model::NamedAccessExpression
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function accessor', :container => o})
     end
     receiver = evaluate(o.functor_expr.left_expr, scope)
     name = o.functor_expr.right_expr
     unless name.is_a? Puppet::Pops::Model::QualifiedName
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end 
     name = name.value # the string function name
 
     evaluated_arguments = unfold([receiver], o.arguments || [], scope)
 
     # wrap lambda in a callable block if it is present
     evaluated_arguments << Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope) if o.lambda
     call_function(name, evaluated_arguments, o, scope)
   end
 
   # @example
   #   $x ? { 10 => true, 20 => false, default => 0 }
   #
   def eval_SelectorExpression o, scope
     # memo scope level before evaluating test - don't want a match in the case test to leak $n match vars
     # to expressions after the selector expression.
     #
     with_guarded_scope(scope) do
       test = evaluate(o.left_expr, scope)
       the_default = nil
       selected = o.selectors.find do |s|
         me = s.matching_expr
         case me
         when Puppet::Pops::Model::LiteralDefault
           the_default = s.value_expr
           false
         when Puppet::Pops::Model::UnfoldExpression
           # not ideal for error reporting, since it is not known which unfolded result
           # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
           evaluate(me, scope).any? {|v| is_match?(test, v, me, scope) }
         else
           is_match?(test, evaluate(me, scope), me, scope)
         end
       end
       if selected
         evaluate(selected.value_expr, scope)
       elsif the_default
         evaluate(the_default, scope)
       else
         fail(Issues::UNMATCHED_SELECTOR, o.left_expr, :param_value => test)
       end
     end
   end
 
   # SubLocatable is simply an expression that holds location information
   def eval_SubLocatedExpression o, scope
     evaluate(o.expr, scope)
   end
 
   # Evaluates Puppet DSL Heredoc
   def eval_HeredocExpression o, scope
     result = evaluate(o.text_expr, scope)
     assert_external_syntax(scope, result, o.syntax, o.text_expr)
     result
   end
 
   # Evaluates Puppet DSL `if`
   def eval_IfExpression o, scope
     with_guarded_scope(scope) do
       if is_true?(evaluate(o.test, scope))
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
       end
     end
   end
 
   # Evaluates Puppet DSL `unless`
   def eval_UnlessExpression o, scope
     with_guarded_scope(scope) do
       unless is_true?(evaluate(o.test, scope))
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
       end
     end
   end
 
   # Evaluates a variable (getting its value)
   # The evaluator is lenient; any expression producing a String is used as a name
   # of a variable.
   #
   def eval_VariableExpression o, scope
     # Evaluator is not too fussy about what constitutes a name as long as the result
     # is a String and a valid variable name
     #
     name = evaluate(o.expr, scope)
 
     # Should be caught by validation, but make this explicit here as well, or mysterious evaluation issues
     # may occur for some evaluation use cases.
     case name
     when String
     when Numeric
     else
       fail(Issues::ILLEGAL_VARIABLE_EXPRESSION, o.expr)
     end
     get_variable_value(name, o, scope)
   end
 
   # Evaluates double quoted strings that may contain interpolation
   #
   def eval_ConcatenatedString o, scope
     o.segments.collect {|expr| string(evaluate(expr, scope), scope)}.join
   end
 
 
   # If the wrapped expression is a QualifiedName, it is taken as the name of a variable in scope.
   # Note that this is different from the 3.x implementation, where an initial qualified name
   # is accepted. (e.g. `"---${var + 1}---"` is legal. This implementation requires such concrete
   # syntax to be expressed in a model as `(TextExpression (+ (Variable var) 1)` - i.e. moving the decision to
   # the parser.
   #
   # Semantics; the result of an expression is turned into a string, nil is silently transformed to empty
   # string.
   # @return [String] the interpolated result
   #
   def eval_TextExpression o, scope
     if o.expr.is_a?(Puppet::Pops::Model::QualifiedName)
       string(get_variable_value(o.expr.value, o, scope), scope)
     else
       string(evaluate(o.expr, scope), scope)
     end
   end
 
   def string_Object(o, scope)
     o.to_s
   end
 
   def string_Symbol(o, scope)
     if :undef == o  # optimized comparison 1.44 vs 1.95
       EMPTY_STRING
     else
       o.to_s
     end
   end
 
   def string_Array(o, scope)
     "[#{o.map {|e| string(e, scope)}.join(COMMA_SEPARATOR)}]"
   end
 
   def string_Hash(o, scope)
     "{#{o.map {|k,v| "#{string(k, scope)} => #{string(v, scope)}"}.join(COMMA_SEPARATOR)}}"
   end
 
   def string_Regexp(o, scope)
     "/#{o.source}/"
   end
 
   def string_PAnyType(o, scope)
     @@type_calculator.string(o)
   end
 
   # Produces concatenation / merge of x and y.
   #
   # When x is an Array, y of type produces:
   #
   # * Array => concatenation `[1,2], [3,4] => [1,2,3,4]`
   # * Hash => concatenation of hash as array `[key, value, key, value, ...]`
   # * any other => concatenation of single value
   #
   # When x is a Hash, y of type produces:
   #
   # * Array => merge of array interpreted as `[key, value, key, value,...]`
   # * Hash => a merge, where entries in `y` overrides
   # * any other => error
   #
   # When x is something else, wrap it in an array first.
   #
   # When x is nil, an empty array is used instead.
   #
   # @note to concatenate an Array, nest the array - i.e. `[1,2], [[2,3]]`
   #
   # @overload concatenate(obj_x, obj_y)
   #   @param obj_x [Object] object to wrap in an array and concatenate to; see other overloaded methods for return type
   #   @param ary_y [Object] array to concatenate at end of `ary_x`
   #   @return [Object] wraps obj_x in array before using other overloaded option based on type of obj_y
   # @overload concatenate(ary_x, ary_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param ary_y [Array] array to concatenate at end of `ary_x`
   #   @return [Array] new array with `ary_x` + `ary_y`
   # @overload concatenate(ary_x, hsh_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param hsh_y [Hash] converted to array form, and concatenated to array
   #   @return [Array] new array with `ary_x` + `hsh_y` converted to array
   # @overload concatenate (ary_x, obj_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param obj_y [Object] non array or hash object to add to array
   #   @return [Array] new array with `ary_x` + `obj_y` added as last entry
   # @overload concatenate(hsh_x, ary_y)
   #   @param hsh_x [Hash] the hash to merge with
   #   @param ary_y [Array] array interpreted as even numbered sequence of key, value merged with `hsh_x`
   #   @return [Hash] new hash with `hsh_x` merged with `ary_y` interpreted as hash in array form
   # @overload concatenate(hsh_x, hsh_y)
   #   @param hsh_x [Hash] the hash to merge to
   #   @param hsh_y [Hash] hash merged with `hsh_x`
   #   @return [Hash] new hash with `hsh_x` merged with `hsh_y`
   # @raise [ArgumentError] when `xxx_x` is neither an Array nor a Hash
   # @raise [ArgumentError] when `xxx_x` is a Hash, and `xxx_y` is neither Array nor Hash.
   #
   def concatenate(x, y)
     x = [x] unless x.is_a?(Array) || x.is_a?(Hash)
     case x
     when Array
       y = case y
       when Array then y
       when Hash  then y.to_a
       else
         [y]
       end
       x + y # new array with concatenation
     when Hash
       y = case y
       when Hash then y
       when Array
         # Hash[[a, 1, b, 2]] => {}
         # Hash[a,1,b,2] => {a => 1, b => 2}
         # Hash[[a,1], [b,2]] => {[a,1] => [b,2]}
         # Hash[[[a,1], [b,2]]] => {a => 1, b => 2}
         # Use type calcultor to determine if array is Array[Array[?]], and if so use second form
         # of call
         t = @@type_calculator.infer(y)
         if t.element_type.is_a? Puppet::Pops::Types::PArrayType
           Hash[y]
         else
           Hash[*y]
         end
       else
         raise ArgumentError.new("Can only append Array or Hash to a Hash")
       end
       x.merge y # new hash with overwrite
     else
       raise ArgumentError.new("Can only append to an Array or a Hash.")
     end
   end
 
   # Produces the result x \ y (set difference)
   # When `x` is an Array, `y` is transformed to an array and then all matching elements removed from x.
   # When `x` is a Hash, all contained keys are removed from x as listed in `y` if it is an Array, or all its keys if it is a Hash.
   # The difference is returned. The given `x` and `y` are not modified by this operation.
   # @raise [ArgumentError] when `x` is neither an Array nor a Hash
   #
   def delete(x, y)
     result = x.dup
     case x
     when Array
       y = case y
       when Array then y
       when Hash then y.to_a
       else
         [y]
       end
       y.each {|e| result.delete(e) }
     when Hash
       y = case y
       when Array then y
       when Hash then y.keys
       else
         [y]
       end
       y.each {|e| result.delete(e) }
     else
       raise ArgumentError.new("Can only delete from an Array or Hash.")
     end
     result
   end
 
   # Implementation of case option matching.
   #
   # This is the type of matching performed in a case option, using == for every type
   # of value except regular expression where a match is performed.
   #
   def is_match? left, right, o, scope
     if right.is_a?(Regexp)
       return false unless left.is_a? String
       matched = right.match(left)
       set_match_data(matched, scope) # creates or clears ephemeral
       !!matched # convert to boolean
     elsif right.is_a?(Puppet::Pops::Types::PAnyType)
       # right is a type and left is not - check if left is an instance of the given type
       # (The reverse is not terribly meaningful - computing which of the case options that first produces
       # an instance of a given type).
       #
       @@type_calculator.instance?(right, left)
     else
       # Handle equality the same way as the language '==' operator (case insensitive etc.)
       @@compare_operator.equals(left,right)
     end
   end
 
   def with_guarded_scope(scope)
     scope_memo = get_scope_nesting_level(scope)
     begin
       yield
     ensure
       set_scope_nesting_level(scope, scope_memo)
     end
   end
 
   # Maps the expression in the given array to their product except for UnfoldExpressions which are first unfolded.
   # The result is added to the given result Array.
   # @param result [Array] Where to add the result (may contain information to add to)
   # @param array [Array[Puppet::Pops::Model::Expression] the expressions to map
   # @param scope [Puppet::Parser::Scope] the scope to evaluate in
   # @return [Array] the given result array with content added from the operation
   #
   def unfold(result, array, scope)
     array.each do |x|
       if x.is_a?(Puppet::Pops::Model::UnfoldExpression)
         result.concat(evaluate(x, scope))
       else
         result << evaluate(x, scope)
       end
     end
     result
   end
   private :unfold
 
 end
diff --git a/lib/puppet/pops/evaluator/runtime3_support.rb b/lib/puppet/pops/evaluator/runtime3_support.rb
index c1d8e42ff..a86228d33 100644
--- a/lib/puppet/pops/evaluator/runtime3_support.rb
+++ b/lib/puppet/pops/evaluator/runtime3_support.rb
@@ -1,600 +1,599 @@
 # A module with bindings between the new evaluator and the 3x runtime.
 # The intention is to separate all calls into scope, compiler, resource, etc. in this module
 # to make it easier to later refactor the evaluator for better implementations of the 3x classes.
 #
 # @api private
 module Puppet::Pops::Evaluator::Runtime3Support
 
   NAME_SPACE_SEPARATOR = '::'.freeze
 
   # Fails the evaluation of _semantic_ with a given issue.
   #
   # @param issue [Puppet::Pops::Issue] the issue to report
   # @param semantic [Puppet::Pops::ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
   # @param options [Hash] hash of optional named data elements for the given issue
   # @return [!] this method does not return
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
   #
   def fail(issue, semantic, options={}, except=nil)
     optionally_fail(issue, semantic, options, except)
     # an error should have been raised since fail always fails
     raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
   end
 
   # Optionally (based on severity) Fails the evaluation of _semantic_ with a given issue
   # If the given issue is configured to be of severity < :error it is only reported, and the function returns.
   #
   # @param issue [Puppet::Pops::Issue] the issue to report
   # @param semantic [Puppet::Pops::ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
   # @param options [Hash] hash of optional named data elements for the given issue
   # @return [!] this method does not return
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
   #
   def optionally_fail(issue, semantic, options={}, except=nil)
     if except.nil?
       # Want a stacktrace, and it must be passed as an exception
       begin
        raise EvaluationError.new()
       rescue EvaluationError => e
         except = e
       end
     end
     diagnostic_producer.accept(issue, semantic, options, except)
   end
 
   # Binds the given variable name to the given value in the given scope.
   # The reference object `o` is intended to be used for origin information - the 3x scope implementation
   # only makes use of location when there is an error. This is now handled by other mechanisms; first a check
   # is made if a variable exists and an error is raised if attempting to change an immutable value. Errors
   # in name, numeric variable assignment etc. have also been validated prior to this call. In the event the
   # scope.setvar still raises an error, the general exception handling for evaluation of the assignment
   # expression knows about its location. Because of this, there is no need to extract the location for each
   # setting (extraction is somewhat expensive since 3x requires line instead of offset).
   #
   def set_variable(name, value, o, scope)
     # Scope also checks this but requires that location information are passed as options.
     # Those are expensive to calculate and a test is instead made here to enable failing with better information.
     # The error is not specific enough to allow catching it - need to check the actual message text.
     # TODO: Improve the messy implementation in Scope.
     #
     if scope.bound?(name)
       if Puppet::Parser::Scope::RESERVED_VARIABLE_NAMES.include?(name)
         fail(Puppet::Pops::Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
       else
         fail(Puppet::Pops::Issues::ILLEGAL_REASSIGNMENT, o, {:name => name} )
       end
     end
     scope.setvar(name, value)
   end
 
   # Returns the value of the variable (nil is returned if variable has no value, or if variable does not exist)
   #
   def get_variable_value(name, o, scope)
     # Puppet 3x stores all variables as strings (then converts them back to numeric with a regexp... to see if it is a match variable)
     # Not ideal, scope should support numeric lookup directly instead.
     # TODO: consider fixing scope
     catch(:undefined_variable) {
       x = scope.lookupvar(name.to_s)
       # Must convert :undef back to nil - this can happen when an undefined variable is used in a
       # parameter's default value expression - there nil must be :undef to work with the rest of 3x.
       # Now that the value comes back to 4x it is changed to nil.
       return (x == :undef) ? nil : x
     }
     # It is always ok to reference numeric variables even if they are not assigned. They are always undef
     # if not set by a match expression.
     #
     unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
       fail(Puppet::Pops::Issues::UNKNOWN_VARIABLE, o, {:name => name})
     end
   end
 
   # Returns true if the variable of the given name is set in the given most nested scope. True is returned even if
   # variable is bound to nil.
   #
   def variable_bound?(name, scope)
     scope.bound?(name.to_s)
   end
 
   # Returns true if the variable is bound to a value or nil, in the scope or it's parent scopes.
   #
   def variable_exists?(name, scope)
     scope.exist?(name.to_s)
   end
 
   def set_match_data(match_data, scope)
     # See set_variable for rationale for not passing file and line to ephemeral_from.
     # NOTE: The 3x scope adds one ephemeral(match) to its internal stack per match that succeeds ! It never
     # clears anything. Thus a context that performs many matches will get very deep (there simply is no way to
     # clear the match variables without rolling back the ephemeral stack.)
     # This implementation does not attempt to fix this, it behaves the same bad way.
     unless match_data.nil?
       scope.ephemeral_from(match_data)
     end
   end
 
   # Creates a local scope with vairalbes set from a hash of variable name to value
   #
   def create_local_scope_from(hash, scope)
     # two dummy values are needed since the scope tries to give an error message (can not happen in this
     # case - it is just wrong, the error should be reported by the caller who knows in more detail where it
     # is in the source.
     #
     raise ArgumentError, "Internal error - attempt to create a local scope without a hash" unless hash.is_a?(Hash)
     scope.ephemeral_from(hash)
   end
 
   # Creates a nested match scope
   def create_match_scope_from(scope)
     # Create a transparent match scope (for future matches)
     scope.new_match_scope(nil)
   end
 
   def get_scope_nesting_level(scope)
     scope.ephemeral_level
   end
 
   def set_scope_nesting_level(scope, level)
     # Yup, 3x uses this method to reset the level, it also supports passing :all to destroy all 
     # ephemeral/local scopes - which is a sure way to create havoc.
     #
     scope.unset_ephemeral_var(level)
   end
 
   # Adds a relationship between the given `source` and `target` of the given `relationship_type`
   # @param source [Puppet:Pops::Types::PCatalogEntryType] the source end of the relationship (from)
   # @param target [Puppet:Pops::Types::PCatalogEntryType] the target end of the relationship (to)
   # @param relationship_type [:relationship, :subscription] the type of the relationship
   #
   def add_relationship(source, target, relationship_type, scope)
     # The 3x way is to record a Puppet::Parser::Relationship that is evaluated at the end of the compilation.
     # This means it is not possible to detect any duplicates at this point (and signal where an attempt is made to
     # add a duplicate. There is also no location information to signal the original place in the logic. The user will have
     # to go fish.
     # The 3.x implementation is based on Strings :-o, so the source and target must be transformed. The resolution is
     # done by Catalog#resource(type, title). To do that, it creates a Puppet::Resource since it is responsible for
     # translating the name/type/title and create index-keys used by the catalog. The Puppet::Resource has bizarre parsing of
     # the type and title (scan for [] that is interpreted as type/title (but it gets it wrong).
     # Moreover if the type is "" or "component", the type is Class, and if the type is :main, it is :main, all other cases
     # undergo capitalization of name-segments (foo::bar becomes Foo::Bar). (This was earlier done in the reverse by the parser).
     # Further, the title undergoes the same munging !!!
     #
     # That bug infested nest of messy logic needs serious Exorcism!
     #
     # Unfortunately it is not easy to simply call more intelligent methods at a lower level as the compiler evaluates the recorded
     # Relationship object at a much later point, and it is responsible for invoking all the messy logic.
     #
     # TODO: Revisit the below logic when there is a sane implementation of the catalog, compiler and resource. For now
     # concentrate on transforming the type references to what is expected by the wacky logic.
     #
     # HOWEVER, the Compiler only records the Relationships, and the only method it calls is @relationships.each{|x| x.evaluate(catalog) }
     # Which means a smarter Relationship class could do this right. Instead of obtaining the resource from the catalog using
     # the borked resource(type, title) which creates a resource for the purpose of looking it up, it needs to instead
     # scan the catalog's resources
     #
     # GAAAH, it is even worse!
     # It starts in the parser, which parses "File['foo']" into an AST::ResourceReference with type = File, and title = foo
     # This AST is evaluated by looking up the type/title in the scope - causing it to be loaded if it exists, and if not, the given
     # type name/title is used. It does not search for resource instances, only classes and types. It returns symbolic information
     # [type, [title, title]]. From this, instances of Puppet::Resource are created and returned. These only have type/title information
     # filled out. One or an array of resources are returned.
     # This set of evaluated (empty reference) Resource instances are then passed to the relationship operator. It creates a
     # Puppet::Parser::Relationship giving it a source and a target that are (empty reference) Resource instances. These are then remembered
     # until the relationship is evaluated by the compiler (at the end). When evaluation takes place, the (empty reference) Resource instances
     # are converted to String (!?! WTF) on the simple format "#{type}[#{title}]", and the catalog is told to find a resource, by giving
     # it this string. If it cannot find the resource it fails, else the before/notify parameter is appended with the target.
     # The search for the resource begin with (you guessed it) again creating an (empty reference) resource from type and title (WTF?!?!).
     # The catalog now uses the reference resource to compute a key [r.type, r.title.to_s] and also gets a uniqueness key from the
     # resource (This is only a reference type created from title and type). If it cannot find it with the first key, it uses the
     # uniqueness key to lookup.
     #
     # This is probably done to allow a resource type to munge/translate the title in some way (but it is quite unclear from the long
     # and convoluted path of evaluation.
     # In order to do this in a way that is similar to 3.x two resources are created to be used as keys.
     #
     # And if that is not enough, a source/target may be a Collector (a baked query that will be evaluated by the
     # compiler - it is simply passed through here for processing by the compiler at the right time).
     #
     if source.is_a?(Puppet::Parser::Collector)
       # use verbatim - behavior defined by 3x
       source_resource = source
     else
       # transform into the wonderful String representation in 3x
       type, title = catalog_type_to_split_type_title(source)
       source_resource = Puppet::Resource.new(type, title)
     end
     if target.is_a?(Puppet::Parser::Collector)
       # use verbatim - behavior defined by 3x
       target_resource = target
     else
       # transform into the wonderful String representation in 3x
       type, title = catalog_type_to_split_type_title(target)
       target_resource = Puppet::Resource.new(type, title)
     end
     # Add the relationship to the compiler for later evaluation.
     scope.compiler.add_relationship(Puppet::Parser::Relationship.new(source_resource, target_resource, relationship_type))
   end
 
   # Coerce value `v` to numeric or fails.
   # The given value `v` is coerced to Numeric, and if that fails the operation
   # calls {#fail}.
   # @param v [Object] the value to convert
   # @param o [Object] originating instruction
   # @param scope [Object] the (runtime specific) scope where evaluation of o takes place
   # @return [Numeric] value `v` converted to Numeric.
   #
   def coerce_numeric(v, o, scope)
     unless n = Puppet::Pops::Utils.to_n(v)
       fail(Puppet::Pops::Issues::NOT_NUMERIC, o, {:value => v})
     end
     n
   end
 
   def call_function(name, args, o, scope)
     # Call via 4x API if the function exists there
     loaders = scope.compiler.loaders
     # find the loader that loaded the code, or use the private_environment_loader (sees env + all modules)
     adapter = Puppet::Pops::Utils.find_adapter(o, Puppet::Pops::Adapters::LoaderAdapter)
     loader = adapter.nil? ? loaders.private_environment_loader : adapter.loader
     if loader && func = loader.load(:function, name)
       return func.call(scope, *args)
     end
 
     # Call via 3x API if function exists there
     fail(Puppet::Pops::Issues::UNKNOWN_FUNCTION, o, {:name => name}) unless Puppet::Parser::Functions.function(name)
 
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
     # NOTE: Passing an empty string last converts nil/:undef to empty string
     mapped_args = args.map {|a| convert(a, scope, '') }
     result = scope.send("function_#{name}", mapped_args)
     # Prevent non r-value functions from leaking their result (they are not written to care about this)
     Puppet::Parser::Functions.rvalue?(name) ? result : nil
   end
 
   # The o is used for source reference
   def create_resource_parameter(o, scope, name, value, operator)
     file, line = extract_file_line(o)
     Puppet::Parser::Resource::Param.new(
       :name   => name,
-      # Here we must convert nil values to :undef for the 3x logic to work
-      :value  => convert(value, scope, :undef), # converted to 3x since 4x supports additional objects / types
+      :value  => convert(value, scope, nil), # converted to 3x since 4x supports additional objects / types
       :source => scope.source, :line => line, :file => file,
       :add    => operator == :'+>'
     )
   end
 
   CLASS_STRING = 'class'.freeze
 
   def create_resources(o, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
 
     # TODO: Unknown resource causes creation of Resource to fail with ArgumentError, should give
     # a proper Issue. Now the result is "Error while evaluating a Resource Statement" with the message
     # from the raised exception. (It may be good enough).
 
     # resolve in scope.
     fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type_name, resource_titles)
 
     # Not 100% accurate as this is the resource expression location and each title is processed separately
     # The titles are however the result of evaluation and they have no location at this point (an array
     # of positions for the source expressions are required for this to work).
     # TODO: Revisit and possible improve the accuracy.
     #
     file, line = extract_file_line(o)
     # Build a resource for each title
     resource_titles.map do |resource_title|
         resource = Puppet::Parser::Resource.new(
           fully_qualified_type, resource_title,
           :parameters => evaluated_parameters,
           :file => file,
           :line => line,
           :exported => exported,
           :virtual => virtual,
           # WTF is this? Which source is this? The file? The name of the context ?
           :source => scope.source,
           :scope => scope,
           :strict => true
         )
 
         if resource.resource_type.is_a? Puppet::Resource::Type
           resource.resource_type.instantiate_resource(scope, resource)
         end
         scope.compiler.add_resource(scope, resource)
         scope.compiler.evaluate_classes([resource_title], scope, false, true) if fully_qualified_type == CLASS_STRING
         # Turn the resource into a PType (a reference to a resource type)
         # weed out nil's
         resource_to_ptype(resource)
     end
   end
 
   # Defines default parameters for a type with the given name.
   #
   def create_resource_defaults(o, scope, type_name, evaluated_parameters)
     # Note that name must be capitalized in this 3x call
     # The 3x impl creates a Resource instance with a bogus title and then asks the created resource
     # for the type of the name.
     # Note, locations are available per parameter.
     #
     scope.define_settings(capitalize_qualified_name(type_name), evaluated_parameters)
   end
 
   # Capitalizes each segment of a qualified name
   #
   def capitalize_qualified_name(name)
     name.split(/::/).map(&:capitalize).join(NAME_SPACE_SEPARATOR)
   end
 
   # Creates resource overrides for all resource type objects in evaluated_resources. The same set of
   # evaluated parameters are applied to all.
   #
   def create_resource_overrides(o, scope, evaluated_resources, evaluated_parameters)
     # Not 100% accurate as this is the resource expression location and each title is processed separately
     # The titles are however the result of evaluation and they have no location at this point (an array
     # of positions for the source expressions are required for this to work.
     # TODO: Revisit and possible improve the accuracy.
     #
     file, line = extract_file_line(o)
 
     evaluated_resources.each do |r|
       unless r.is_a?(Puppet::Pops::Types::PResourceType) && r.type_name != 'class'
         fail(Puppet::Pops::Issues::ILLEGAL_OVERRIDEN_TYPE, o, {:actual => r} )
       end
       resource = Puppet::Parser::Resource.new(
       r.type_name, r.title,
         :parameters => evaluated_parameters,
         :file => file,
         :line => line,
         # WTF is this? Which source is this? The file? The name of the context ?
         :source => scope.source,
         :scope => scope
       )
 
       scope.compiler.add_override(resource)
     end
   end
 
   # Finds a resource given a type and a title.
   #
   def find_resource(scope, type_name, title)
     scope.compiler.findresource(type_name, title)
   end
 
   # Returns the value of a resource's parameter by first looking up the parameter in the resource
   # and then in the defaults for the resource. Since the resource exists (it must in order to look up its
   # parameters, any overrides have already been applied). Defaults are not applied to a resource until it
   # has been finished (which typically has not taken place when this is evaluated; hence the dual lookup).
   #
   def get_resource_parameter_value(scope, resource, parameter_name)
     # This gets the parameter value, or nil (for both valid parameters and parameters that do not exist).
     val = resource[parameter_name]
 
     # Sometimes the resource is a Puppet::Parser::Resource and sometimes it is
     # a Puppet::Resource. The Puppet::Resource case occurs when puppet language
     # is evaluated against an already completed catalog (where all instances of
     # Puppet::Parser::Resource are converted to Puppet::Resource instances).
     # Evaluating against an already completed catalog is really only found in
     # the language specification tests, where the puppet language is used to
     # test itself.
     if resource.is_a?(Puppet::Parser::Resource)
       # The defaults must be looked up in the scope where the resource was created (not in the given
       # scope where the lookup takes place.
       resource_scope = resource.scope
       if val.nil? && resource_scope && defaults = resource_scope.lookupdefaults(resource.type)
         # NOTE: 3x resource keeps defaults as hash using symbol for name as key to Parameter which (again) holds
         # name and value.
         # NOTE: meta parameters that are unset ends up here, and there are no defaults for those encoded
         # in the defaults, they may receive hardcoded defaults later (e.g. 'tag').
         param = defaults[parameter_name.to_sym]
         # Some parameters (meta parameters like 'tag') does not return a param from which the value can be obtained
         # at all times. Instead, they return a nil param until a value has been set.
         val = param.nil? ? nil : param.value
       end
     end
     val
   end
 
   # Returns true, if the given name is the name of a resource parameter.
   #
   def is_parameter_of_resource?(scope, resource, name)
     return false unless name.is_a?(String)
     resource.valid_parameter?(name)
   end
 
   def resource_to_ptype(resource)
     nil if resource.nil?
     # inference returns the meta type since the 3x Resource is an alternate way to describe a type
     type_calculator.infer(resource).type
   end
 
   # This is the same type of "truth" as used in the current Puppet DSL.
   #
   def is_true? o
     # Is the value true?  This allows us to control the definition of truth
     # in one place.
     case o
     # Support :undef since it may come from a 3x structure
     when :undef
       false
     else
       !!o
     end
   end
 
   # Utility method for TrueClass || FalseClass
   # @param x [Object] the object to test if it is instance of TrueClass or FalseClass
   def is_boolean? x
     x.is_a?(TrueClass) || x.is_a?(FalseClass)
   end
 
   def initialize
     @@convert_visitor   ||= Puppet::Pops::Visitor.new(self, "convert", 2, 2)
     @@convert2_visitor   ||= Puppet::Pops::Visitor.new(self, "convert2", 2, 2)
   end
 
   # Converts 4x supported values to 3x values. This is required because
   # resources and other objects do not know about the new type system, and does not support
   # regular expressions. Unfortunately this has to be done for array and hash as well.
   # A complication is that catalog types needs to be resolved against the scope.
   #
   def convert(o, scope, undef_value)
     @@convert_visitor.visit_this_2(self, o, scope, undef_value)
   end
 
   # Converts nested 4x supported values to 3x values. This is required because
   # resources and other objects do not know about the new type system, and does not support
   # regular expressions. Unfortunately this has to be done for array and hash as well.
   # A complication is that catalog types needs to be resolved against the scope.
   #
   def convert2(o, scope, undef_value)
     @@convert2_visitor.visit_this_2(self, o, scope, undef_value)
   end
 
 
   def convert_NilClass(o, scope, undef_value)
     undef_value
   end
 
   def convert2_NilClass(o, scope, undef_value)
     :undef
   end
 
   def convert_String(o, scope, undef_value)
     # although wasteful, needed because user code may mutate these strings in Resources
     o.frozen? ? o.dup : o
   end
   alias convert2_String :convert_String
 
   def convert_Object(o, scope, undef_value)
     o
   end
   alias :convert2_Object :convert_Object
 
   def convert_Array(o, scope, undef_value)
     o.map {|x| convert2(x, scope, undef_value) }
   end
   alias :convert2_Array :convert_Array
 
   def convert_Hash(o, scope, undef_value)
     result = {}
     o.each {|k,v| result[convert2(k, scope, undef_value)] = convert2(v, scope, undef_value) }
     result
   end
   alias :convert2_Hash :convert_Hash
 
   def convert_Regexp(o, scope, undef_value)
     # Puppet 3x cannot handle parameter values that are reqular expressions. Turn into regexp string in
     # source form
     o.inspect
   end
   alias :convert2_Regexp :convert_Regexp
 
   def convert_Symbol(o, scope, undef_value)
     case o
     # Support :undef since it may come from a 3x structure
     when :undef
       undef_value  # 3x wants undef as either empty string or :undef
     else
       o   # :default, and all others are verbatim since they are new in future evaluator
     end
   end
 
   # The :undef symbol should not be converted when nested in arrays or hashes
   def convert2_Symbol(o, scope, undef_value)
     o
   end
 
   def convert_PAnyType(o, scope, undef_value)
     o
   end
   alias :convert2_PAnyType :convert_PAnyType
 
   def convert_PCatalogEntryType(o, scope, undef_value)
     # Since 4x does not support dynamic scoping, all names are absolute and can be
     # used as is (with some check/transformation/mangling between absolute/relative form
     # due to Puppet::Resource's idiosyncratic behavior where some references must be
     # absolute and others cannot be.
     # Thus there is no need to call scope.resolve_type_and_titles to do dynamic lookup.
 
     Puppet::Resource.new(*catalog_type_to_split_type_title(o))
   end
   alias :convert2_PCatalogEntryType :convert_PCatalogEntryType
 
   private
 
   # Produces an array with [type, title] from a PCatalogEntryType
   # This method is used to produce the arguments for creation of reference resource instances
   # (used when 3x is operating on a resource).
   # Ensures that resources are *not* absolute.
   #
   def catalog_type_to_split_type_title(catalog_type)
     split_type = catalog_type.is_a?(Puppet::Pops::Types::PType) ? catalog_type.type : catalog_type
     case split_type
     when Puppet::Pops::Types::PHostClassType
       class_name = split_type.class_name
       ['class', class_name.nil? ? nil : class_name.sub(/^::/, '')]
     when Puppet::Pops::Types::PResourceType
       type_name = split_type.type_name
       title = split_type.title
       if type_name =~ /^(::)?[Cc]lass/
         ['class', title.nil? ? nil : title.sub(/^::/, '')]
       else
         # Ensure that title is '' if nil
         # Resources with absolute name always results in error because tagging does not support leading ::
         [type_name.nil? ? nil : type_name.sub(/^::/, ''), title.nil? ? '' : title]
       end
     else
       raise ArgumentError, "Cannot split the type #{catalog_type.class}, it represents neither a PHostClassType, nor a PResourceType."
     end
   end
 
   def extract_file_line(o)
     source_pos = Puppet::Pops::Utils.find_closest_positioned(o)
     return [nil, -1] unless source_pos
     [source_pos.locator.file, source_pos.line]
   end
 
   def find_closest_positioned(o)
     return nil if o.nil? || o.is_a?(Puppet::Pops::Model::Program)
     o.offset.nil? ? find_closest_positioned(o.eContainer) : Puppet::Pops::Adapters::SourcePosAdapter.adapt(o)
   end
 
   # Creates a diagnostic producer
   def diagnostic_producer
     Puppet::Pops::Validation::DiagnosticProducer.new(
       ExceptionRaisingAcceptor.new(),                   # Raises exception on all issues
       SeverityProducer.new(), # All issues are errors
       Puppet::Pops::Model::ModelLabelProvider.new())
   end
 
   # Configure the severity of failures
   class SeverityProducer < Puppet::Pops::Validation::SeverityProducer
     Issues = Puppet::Pops::Issues
 
     def initialize
       super
       p = self
       # Issues triggering warning only if --debug is on
       if Puppet[:debug]
         p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :warning
       else
         p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
       end
 
       # Store config issues, ignore or warning
       p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
       p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
     end
   end
 
   # An acceptor of diagnostics that immediately raises an exception.
   class ExceptionRaisingAcceptor < Puppet::Pops::Validation::Acceptor
     def accept(diagnostic)
       super
       Puppet::Pops::IssueReporter.assert_and_report(self, {:message => "Evaluation Error:", :emit_warnings => true })
       if errors?
         raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
       end
     end
   end
 
   class EvaluationError < StandardError
   end
 end
diff --git a/spec/integration/parser/future_compiler_spec.rb b/spec/integration/parser/future_compiler_spec.rb
index 3a27a3aad..9b612e400 100644
--- a/spec/integration/parser/future_compiler_spec.rb
+++ b/spec/integration/parser/future_compiler_spec.rb
@@ -1,770 +1,806 @@
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/parser/parser_factory'
 require 'puppet_spec/compiler'
 require 'puppet_spec/pops'
 require 'puppet_spec/scope'
 require 'matchers/resource'
 require 'rgen/metamodel_builder'
 
 # Test compilation using the future evaluator
 describe "Puppet::Parser::Compiler" do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
   before :each do
     Puppet[:parser] = 'future'
   end
 
   describe "the compiler when using future parser and evaluator" do
     it "should be able to determine the configuration version from a local version control repository" do
       pending("Bug #14071 about semantics of Puppet::Util::Execute on Windows", :if => Puppet.features.microsoft_windows?) do
         # This should always work, because we should always be
         # in the puppet repo when we run this.
         version = %x{git rev-parse HEAD}.chomp
 
         Puppet.settings[:config_version] = 'git rev-parse HEAD'
 
         compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("testnode"))
         compiler.catalog.version.should == version
       end
     end
 
     it "should not create duplicate resources when a class is referenced both directly and indirectly by the node classifier (4792)" do
       node = Puppet::Node.new("testnodex")
       node.classes = ['foo', 'bar']
       catalog = compile_to_catalog(<<-PP, node)
         class foo
         {
           notify { foo_notify: }
           include bar
         }
         class bar
         {
           notify { bar_notify: }
         }
       PP
 
       catalog = Puppet::Parser::Compiler.compile(node)
 
       expect(catalog).to have_resource("Notify[foo_notify]")
       expect(catalog).to have_resource("Notify[bar_notify]")
     end
 
     it 'applies defaults for defines with qualified names (PUP-2302)' do
       catalog = compile_to_catalog(<<-CODE)
         define my::thing($msg = 'foo') { notify {'check_me': message => $msg } }
         My::Thing { msg => 'evoe' }
         my::thing { 'name': }
       CODE
 
       expect(catalog).to have_resource("Notify[check_me]").with_parameter(:message, "evoe")
     end
 
     it 'Applies defaults from dynamic scopes (3x and future with reverted PUP-867)' do
       catalog = compile_to_catalog(<<-CODE)
       class a {
         Notify { message => "defaulted" }
         include b
         notify { bye: }
       }
       class b { notify { hi: } }
 
       include a
       CODE
       expect(catalog).to have_resource("Notify[hi]").with_parameter(:message, "defaulted")
       expect(catalog).to have_resource("Notify[bye]").with_parameter(:message, "defaulted")
     end
 
     it 'gets default from inherited class (PUP-867)' do
       catalog = compile_to_catalog(<<-CODE)
       class a {
         Notify { message => "defaulted" }
         include c
         notify { bye: }
       }
       class b { Notify { message => "inherited" } }
       class c inherits b { notify { hi: } }
 
       include a
       CODE
 
       expect(catalog).to have_resource("Notify[hi]").with_parameter(:message, "inherited")
       expect(catalog).to have_resource("Notify[bye]").with_parameter(:message, "defaulted")
     end
 
     it 'looks up default parameter values from inherited class (PUP-2532)' do
       catalog = compile_to_catalog(<<-CODE)
       class a {
         Notify { message => "defaulted" }
         include c
         notify { bye: }
       }
       class b { Notify { message => "inherited" } }
       class c inherits b { notify { hi: } }
 
       include a
       notify {hi_test: message => Notify[hi][message] }
       notify {bye_test: message => Notify[bye][message] }
       CODE
 
       expect(catalog).to have_resource("Notify[hi_test]").with_parameter(:message, "inherited")
       expect(catalog).to have_resource("Notify[bye_test]").with_parameter(:message, "defaulted")
     end
 
     it 'does not allow override of class parameters using a resource override expression' do
       expect do
         compile_to_catalog(<<-CODE)
           Class[a] { x => 2}
         CODE
       end.to raise_error(/Resource Override can only.*got: Class\[a\].*/)
     end
 
     describe "when resolving class references" do
       it "should not favor local scope (with class included in topscope)" do
         catalog = compile_to_catalog(<<-PP)
           class experiment {
             class baz {
             }
             notify {"x" : require => Class[Baz] }
             notify {"y" : require => Class[Experiment::Baz] }
           }
           class baz {
           }
           include baz
           include experiment
           include experiment::baz
         PP
 
         expect(catalog).to have_resource("Notify[x]").with_parameter(:require, be_resource("Class[Baz]"))
         expect(catalog).to have_resource("Notify[y]").with_parameter(:require, be_resource("Class[Experiment::Baz]"))
       end
 
       it "should not favor local scope, (with class not included in topscope)" do
         catalog = compile_to_catalog(<<-PP)
           class experiment {
             class baz {
             }
             notify {"x" : require => Class[Baz] }
             notify {"y" : require => Class[Experiment::Baz] }
           }
           class baz {
           }
           include experiment
           include experiment::baz
         PP
 
         expect(catalog).to have_resource("Notify[x]").with_parameter(:require, be_resource("Class[Baz]"))
         expect(catalog).to have_resource("Notify[y]").with_parameter(:require, be_resource("Class[Experiment::Baz]"))
       end
     end
 
     describe "(ticket #13349) when explicitly specifying top scope" do
       ["class {'::bar::baz':}", "include ::bar::baz"].each do |include|
         describe "with #{include}" do
           it "should find the top level class" do
             catalog = compile_to_catalog(<<-MANIFEST)
               class { 'foo::test': }
               class foo::test {
               	#{include}
               }
               class bar::baz {
               	notify { 'good!': }
               }
               class foo::bar::baz {
               	notify { 'bad!': }
               }
             MANIFEST
 
             expect(catalog).to have_resource("Class[Bar::Baz]")
             expect(catalog).to have_resource("Notify[good!]")
             expect(catalog).to_not have_resource("Class[Foo::Bar::Baz]")
             expect(catalog).to_not have_resource("Notify[bad!]")
           end
         end
       end
     end
 
     it "should recompute the version after input files are re-parsed" do
       Puppet[:code] = 'class foo { }'
       Time.stubs(:now).returns(1)
       node = Puppet::Node.new('mynode')
       Puppet::Parser::Compiler.compile(node).version.should == 1
       Time.stubs(:now).returns(2)
       Puppet::Parser::Compiler.compile(node).version.should == 1 # no change because files didn't change
       Puppet::Resource::TypeCollection.any_instance.stubs(:stale?).returns(true).then.returns(false) # pretend change
       Puppet::Parser::Compiler.compile(node).version.should == 2
     end
 
     ['define', 'class', 'node'].each do |thing|
       it "'#{thing}' is not allowed inside evaluated conditional constructs" do
         expect do
           compile_to_catalog(<<-PP)
             if true {
               #{thing} foo {
               }
               notify { decoy: }
             }
           PP
         end.to raise_error(Puppet::Error, /Classes, definitions, and nodes may only appear at toplevel/)
       end
 
       it "'#{thing}' is not allowed inside un-evaluated conditional constructs" do
         expect do
           compile_to_catalog(<<-PP)
             if false {
               #{thing} foo {
               }
               notify { decoy: }
             }
           PP
         end.to raise_error(Puppet::Error, /Classes, definitions, and nodes may only appear at toplevel/)
       end
     end
 
     describe "relationships can be formed" do
       def extract_name(ref)
         ref.sub(/File\[(\w+)\]/, '\1')
       end
 
       def assert_creates_relationships(relationship_code, expectations)
         base_manifest = <<-MANIFEST
           file { [a,b,c]:
             mode => '0644',
           }
           file { [d,e]:
             mode => '0755',
           }
         MANIFEST
         catalog = compile_to_catalog(base_manifest + relationship_code)
 
         resources = catalog.resources.select { |res| res.type == 'File' }
 
         actual_relationships, actual_subscriptions = [:before, :notify].map do |relation|
           resources.map do |res|
             dependents = Array(res[relation])
             dependents.map { |ref| [res.title, extract_name(ref)] }
           end.inject(&:concat)
         end
 
         actual_relationships.should =~ (expectations[:relationships] || [])
         actual_subscriptions.should =~ (expectations[:subscriptions] || [])
       end
 
       it "of regular type" do
         assert_creates_relationships("File[a] -> File[b]",
                                      :relationships => [['a','b']])
       end
 
       it "of subscription type" do
         assert_creates_relationships("File[a] ~> File[b]",
                                      :subscriptions => [['a', 'b']])
       end
 
       it "between multiple resources expressed as resource with multiple titles" do
         assert_creates_relationships("File[a,b] -> File[c,d]",
                                      :relationships => [['a', 'c'],
                                                         ['b', 'c'],
                                                         ['a', 'd'],
                                                         ['b', 'd']])
       end
 
       it "between collection expressions" do
         assert_creates_relationships("File <| mode == 0644 |> -> File <| mode == 0755 |>",
                                      :relationships => [['a', 'd'],
                                                         ['b', 'd'],
                                                         ['c', 'd'],
                                                         ['a', 'e'],
                                                         ['b', 'e'],
                                                         ['c', 'e']])
       end
 
       it "between resources expressed as Strings" do
         assert_creates_relationships("'File[a]' -> 'File[b]'",
                                      :relationships => [['a', 'b']])
       end
 
       it "between resources expressed as variables" do
         assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
           $var = File[a]
           $var -> File[b]
         MANIFEST
 
       end
 
       it "between resources expressed as case statements" do
         assert_creates_relationships(<<-MANIFEST, :relationships => [['s1', 't2']])
           $var = 10
           case $var {
             10: {
               file { s1: }
             }
             12: {
               file { s2: }
             }
           }
           ->
           case $var + 2 {
             10: {
               file { t1: }
             }
             12: {
               file { t2: }
             }
           }
         MANIFEST
       end
 
       it "using deep access in array" do
         assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
           $var = [ [ [ File[a], File[b] ] ] ]
           $var[0][0][0] -> $var[0][0][1]
         MANIFEST
 
       end
 
       it "using deep access in hash" do
         assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
           $var = {'foo' => {'bar' => {'source' => File[a], 'target' => File[b]}}}
           $var[foo][bar][source] -> $var[foo][bar][target]
         MANIFEST
 
       end
 
       it "using resource declarations" do
         assert_creates_relationships("file { l: } -> file { r: }", :relationships => [['l', 'r']])
       end
 
       it "between entries in a chain of relationships" do
         assert_creates_relationships("File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]",
                                      :relationships => [['a', 'b'], ['d', 'c']],
                                      :subscriptions => [['b', 'c'], ['e', 'd']])
       end
     end
 
     context "when dealing with variable references" do
       it 'an initial underscore in a variable name is ok' do
         catalog = compile_to_catalog(<<-MANIFEST)
           class a { $_a = 10}
           include a
           notify { 'test': message => $a::_a }
         MANIFEST
 
         expect(catalog).to have_resource("Notify[test]").with_parameter(:message, 10)
       end
 
       it 'an initial underscore in not ok if elsewhere than last segment' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class a { $_a = 10}
             include a
             notify { 'test': message => $_a::_a }
           MANIFEST
         end.to raise_error(/Illegal variable name/)
       end
 
       it 'a missing variable as default value becomes undef' do
         # strict variables not on
         catalog = compile_to_catalog(<<-MANIFEST)
         class a ($b=$x) { notify {test: message=>"yes ${undef == $b}" } }
           include a
         MANIFEST
 
         expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "yes true")
       end
     end
 
     context 'when working with the trusted data hash' do
       context 'and have opted in to hashed_node_data' do
         before :each do
           Puppet[:trusted_node_data] = true
         end
 
         it 'should make $trusted available' do
           node = Puppet::Node.new("testing")
           node.trusted_data = { "data" => "value" }
 
           catalog = compile_to_catalog(<<-MANIFEST, node)
             notify { 'test': message => $trusted[data] }
           MANIFEST
 
           expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "value")
         end
 
         it 'should not allow assignment to $trusted' do
           node = Puppet::Node.new("testing")
           node.trusted_data = { "data" => "value" }
 
           expect do
             compile_to_catalog(<<-MANIFEST, node)
               $trusted = 'changed'
               notify { 'test': message => $trusted == 'changed' }
             MANIFEST
           end.to raise_error(Puppet::Error, /Attempt to assign to a reserved variable name: 'trusted'/)
         end
       end
 
       context 'and have not opted in to hashed_node_data' do
         before :each do
           Puppet[:trusted_node_data] = false
         end
 
         it 'should not make $trusted available' do
           node = Puppet::Node.new("testing")
           node.trusted_data = { "data" => "value" }
 
           catalog = compile_to_catalog(<<-MANIFEST, node)
             notify { 'test': message => ($trusted == undef) }
           MANIFEST
 
           expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
         end
 
         it 'should allow assignment to $trusted' do
           catalog = compile_to_catalog(<<-MANIFEST)
             $trusted = 'changed'
             notify { 'test': message => $trusted == 'changed' }
           MANIFEST
 
           expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
         end
       end
     end
 
     context 'when using typed parameters in definition' do
       it 'accepts type compliant arguments' do
         catalog = compile_to_catalog(<<-MANIFEST)
           define foo(String $x) { }
           foo { 'test': x =>'say friend' }
         MANIFEST
         expect(catalog).to have_resource("Foo[test]").with_parameter(:x, 'say friend')
       end
 
       it 'accepts undef as the default for an Optional argument' do
         catalog = compile_to_catalog(<<-MANIFEST)
           define foo(Optional[String] $x = undef) {
             notify { "expected": message => $x == undef }
           }
           foo { 'test': }
         MANIFEST
         expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, true)
       end
 
       it 'accepts anything when parameters are untyped' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
           define foo($a, $b, $c) { }
           foo { 'test': a => String, b=>10, c=>undef }
         MANIFEST
         end.to_not raise_error()
       end
 
       it 'denies non type compliant arguments' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             define foo(Integer $x) { }
             foo { 'test': x =>'say friend' }
           MANIFEST
         end.to raise_error(/type Integer, got String/)
       end
 
+      it 'denies undef for a non-optional type' do
+        expect do
+          catalog = compile_to_catalog(<<-MANIFEST)
+            define foo(Integer $x) { }
+            foo { 'test': x => undef }
+          MANIFEST
+        end.to raise_error(/type Integer, got Undef/)
+      end
+
       it 'denies non type compliant default argument' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             define foo(Integer $x = 'pow') { }
             foo { 'test':  }
           MANIFEST
         end.to raise_error(/type Integer, got String/)
       end
 
+      it 'denies undef as the default for a non-optional type' do
+        expect do
+          catalog = compile_to_catalog(<<-MANIFEST)
+            define foo(Integer $x = undef) { }
+            foo { 'test':  }
+          MANIFEST
+        end.to raise_error(/type Integer, got Undef/)
+      end
+
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
           define foo(Type[Bar] $x) {
             notify { 'test': message => $x[text] }
           }
           define bar($text) { }
           bar { 'joke': text => 'knock knock' }
           foo { 'test': x => Bar[joke] }
         MANIFEST
         expect(catalog).to have_resource("Notify[test]").with_parameter(:message, 'knock knock')
       end
     end
 
     context 'when using typed parameters in class' do
       it 'accepts type compliant arguments' do
         catalog = compile_to_catalog(<<-MANIFEST)
           class foo(String $x) { }
           class { 'foo': x =>'say friend' }
         MANIFEST
         expect(catalog).to have_resource("Class[Foo]").with_parameter(:x, 'say friend')
       end
 
       it 'accepts undef as the default for an Optional argument' do
         catalog = compile_to_catalog(<<-MANIFEST)
           class foo(Optional[String] $x = undef) {
             notify { "expected": message => $x == undef }
           }
           class { 'foo': }
         MANIFEST
         expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, true)
       end
 
       it 'accepts anything when parameters are untyped' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class foo($a, $b, $c) { }
             class { 'foo': a => String, b=>10, c=>undef }
           MANIFEST
         end.to_not raise_error()
       end
 
       it 'denies non type compliant arguments' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class foo(Integer $x) { }
             class { 'foo': x =>'say friend' }
           MANIFEST
         end.to raise_error(/type Integer, got String/)
       end
 
+      it 'denies undef for a non-optional type' do
+        expect do
+          catalog = compile_to_catalog(<<-MANIFEST)
+            class foo(Integer $x) { }
+            class { 'foo': x => undef }
+          MANIFEST
+        end.to raise_error(/type Integer, got Undef/)
+      end
+
       it 'denies non type compliant default argument' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class foo(Integer $x = 'pow') { }
             class { 'foo':  }
           MANIFEST
         end.to raise_error(/type Integer, got String/)
       end
 
+      it 'denies undef as the default for a non-optional type' do
+        expect do
+          catalog = compile_to_catalog(<<-MANIFEST)
+            class foo(Integer $x = undef) { }
+            class { 'foo':  }
+          MANIFEST
+        end.to raise_error(/type Integer, got Undef/)
+      end
+
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
           class foo(Type[Bar] $x) {
             notify { 'test': message => $x[text] }
           }
           define bar($text) { }
           bar { 'joke': text => 'knock knock' }
           class { 'foo': x => Bar[joke] }
         MANIFEST
         expect(catalog).to have_resource("Notify[test]").with_parameter(:message, 'knock knock')
       end
     end
 
     context 'when using typed parameters in lambdas' do
       it 'accepts type compliant arguments' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with('value') |String $x| { notify { "$x": } }
         MANIFEST
         expect(catalog).to have_resource("Notify[value]")
       end
 
       it 'handles an array as a single argument' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with(['value', 'second']) |$x| { notify { "${x[0]} ${x[1]}": } }
         MANIFEST
         expect(catalog).to have_resource("Notify[value second]")
       end
 
       it 'denies when missing required arguments' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(1) |$x, $y| { }
           MANIFEST
         end.to raise_error(/Parameter \$y is required but no value was given/m)
       end
 
       it 'accepts anything when parameters are untyped' do
         catalog = compile_to_catalog(<<-MANIFEST)
           ['value', 1, true, undef].each |$x| { notify { "value: $x": } }
         MANIFEST
 
         expect(catalog).to have_resource("Notify[value: value]")
         expect(catalog).to have_resource("Notify[value: 1]")
         expect(catalog).to have_resource("Notify[value: true]")
         expect(catalog).to have_resource("Notify[value: ]")
       end
 
       it 'accepts type-compliant, slurped arguments' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with(1, 2) |Integer *$x| { notify { "${$x[0] + $x[1]}": } }
         MANIFEST
         expect(catalog).to have_resource("Notify[3]")
       end
 
       it 'denies non-type-compliant arguments' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(1) |String $x| { }
           MANIFEST
         end.to raise_error(/expected.*String.*actual.*Integer/m)
       end
 
       it 'denies non-type-compliant, slurped arguments' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(1, "hello") |Integer *$x| { }
           MANIFEST
         end.to raise_error(/called with mis-matched arguments.*expected.*Integer.*actual.*Integer, String/m)
       end
 
       it 'denies non-type-compliant default argument' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(1) |$x, String $defaulted = 1| { notify { "${$x + $defaulted}": }}
           MANIFEST
         end.to raise_error(/expected.*Any.*String.*actual.*Integer.*Integer/m)
       end
 
       it 'raises an error when a default argument value is an incorrect type and there are no arguments passed' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |String $defaulted = 1| {}
           MANIFEST
         end.to raise_error(/expected.*String.*actual.*Integer/m)
       end
 
       it 'raises an error when the default argument for a slurped parameter is an incorrect type' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |String *$defaulted = 1| {}
           MANIFEST
         end.to raise_error(/expected.*String.*actual.*Integer/m)
       end
 
       it 'allows using an array as the default slurped value' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with() |String *$defaulted = [hi]| { notify { $defaulted[0]: } }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
       end
 
       it 'allows using a value of the type as the default slurped value' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with() |String *$defaulted = hi| { notify { $defaulted[0]: } }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
       end
 
       it 'allows specifying the type of a slurped parameter as an array' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with() |Array[String] *$defaulted = hi| { notify { $defaulted[0]: } }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
       end
 
       it 'raises an error when the number of default values does not match the parameter\'s size specification' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |Array[String, 2] *$defaulted = hi| { }
           MANIFEST
         end.to raise_error(/expected.*arg count \{2,\}.*actual.*arg count \{1\}/m)
       end
 
       it 'raises an error when the number of passed values does not match the parameter\'s size specification' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(hi) |Array[String, 2] *$passed| { }
           MANIFEST
         end.to raise_error(/expected.*arg count \{2,\}.*actual.*arg count \{1\}/m)
       end
 
       it 'matches when the number of arguments passed for a slurp parameter match the size specification' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with(hi, bye) |Array[String, 2] *$passed| {
             $passed.each |$n| { notify { $n: } }
           }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
         expect(catalog).to have_resource('Notify[bye]')
       end
 
       it 'raises an error when the number of allowed slurp parameters exceeds the size constraint' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(hi, bye) |Array[String, 1, 1] *$passed| { }
           MANIFEST
         end.to raise_error(/expected.*arg count \{1\}.*actual.*arg count \{2\}/m)
       end
 
       it 'allows passing slurped arrays by specifying an array of arrays' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with([hi], [bye]) |Array[Array[String, 1, 1]] *$passed| {
             notify { $passed[0][0]: }
             notify { $passed[1][0]: }
           }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
         expect(catalog).to have_resource('Notify[bye]')
       end
 
       it 'raises an error when a required argument follows an optional one' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |$y = first, $x, Array[String, 1] *$passed = bye| {}
           MANIFEST
         end.to raise_error(/Parameter \$x is required/)
       end
 
       it 'raises an error when the minimum size of a slurped argument makes it required and it follows an optional argument' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |$x = first, Array[String, 1] *$passed| {}
           MANIFEST
         end.to raise_error(/Parameter \$passed is required/)
       end
 
       it 'allows slurped arguments with a minimum size of 0 after an optional argument' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with() |$x = first, Array[String, 0] *$passed| {
             notify { $x: }
           }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[first]')
       end
 
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
           define bar($text) { }
           bar { 'joke': text => 'knock knock' }
 
           with(Bar[joke]) |Type[Bar] $joke| { notify { "${joke[text]}": } }
         MANIFEST
         expect(catalog).to have_resource("Notify[knock knock]")
       end
     end
   end
 
   context 'when evaluating collection' do
     it 'matches on container inherited tags' do
       Puppet[:code] = <<-MANIFEST
       class xport_test {
         tag('foo_bar')
         @notify { 'nbr1':
           message => 'explicitly tagged',
           tag => 'foo_bar'
         }
 
         @notify { 'nbr2':
           message => 'implicitly tagged'
         }
 
         Notify <| tag == 'foo_bar' |> {
           message => 'overridden'
         }
       }
       include xport_test
       MANIFEST
 
       catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
       expect(catalog).to have_resource("Notify[nbr1]").with_parameter(:message, 'overridden')
       expect(catalog).to have_resource("Notify[nbr2]").with_parameter(:message, 'overridden')
     end
   end
 
 end
diff --git a/spec/unit/parser/resource/param_spec.rb b/spec/unit/parser/resource/param_spec.rb
index 7989d060d..dcb8a3616 100755
--- a/spec/unit/parser/resource/param_spec.rb
+++ b/spec/unit/parser/resource/param_spec.rb
@@ -1,44 +1,32 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Parser::Resource::Param do
-  it "can be instantiated" do
-    Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => 'foo')
-  end
-
-  it "stores the source file" do
-    param = Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => 'foo', :file => 'foo.pp')
-    param.file.should == 'foo.pp'
-  end
+  it "has readers for all of the attributes" do
+    param = Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => 'foo', :file => 'foo.pp', :line => 42)
 
-  it "stores the line number" do
-    param = Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => 'foo', :line => 42)
-    param.line.should == 42
+    expect(param.name).to eq(:myparam)
+    expect(param.value).to eq('foo')
+    expect(param.file).to eq('foo.pp')
+    expect(param.line).to eq(42)
   end
 
   context "parameter validation" do
     it "throws an error when instantiated without a name" do
       expect {
         Puppet::Parser::Resource::Param.new(:value => 'foo')
       }.to raise_error(Puppet::Error, /name is a required option/)
     end
 
-    it "throws an error when instantiated without a value" do
-      expect {
-        Puppet::Parser::Resource::Param.new(:name => 'myparam')
-      }.to raise_error(Puppet::Error, /value is a required option/)
-    end
+    it "does not require a value" do
+      param = Puppet::Parser::Resource::Param.new(:name => 'myparam')
 
-    it "throws an error when instantiated with a nil value" do
-      expect {
-        Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => nil)
-      }.to raise_error(Puppet::Error, /value is a required option/)
+      expect(param.value).to be_nil
     end
 
     it "includes file/line context in errors" do
       expect {
-        Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => nil, :file => 'foo.pp', :line => 42)
+        Puppet::Parser::Resource::Param.new(:file => 'foo.pp', :line => 42)
       }.to raise_error(Puppet::Error, /foo.pp:42/)
     end
   end
 end
diff --git a/spec/unit/parser/resource_spec.rb b/spec/unit/parser/resource_spec.rb
index d0ec5f49c..97f19e21a 100755
--- a/spec/unit/parser/resource_spec.rb
+++ b/spec/unit/parser/resource_spec.rb
@@ -1,586 +1,582 @@
 require 'spec_helper'
 
 describe Puppet::Parser::Resource do
   before do
     environment = Puppet::Node::Environment.create(:testing, [])
     @node = Puppet::Node.new("yaynode", :environment => environment)
     @known_resource_types = environment.known_resource_types
     @compiler = Puppet::Parser::Compiler.new(@node)
     @source = newclass ""
     @scope = @compiler.topscope
   end
 
   def mkresource(args = {})
     args[:source] ||= @source
     args[:scope] ||= @scope
 
     params = args[:parameters] || {:one => "yay", :three => "rah"}
     if args[:parameters] == :none
       args.delete(:parameters)
     elsif not args[:parameters].is_a? Array
       args[:parameters] = paramify(args[:source], params)
     end
 
     Puppet::Parser::Resource.new("resource", "testing", args)
   end
 
   def param(name, value, source)
     Puppet::Parser::Resource::Param.new(:name => name, :value => value, :source => source)
   end
 
   def paramify(source, hash)
     hash.collect do |name, value|
       Puppet::Parser::Resource::Param.new(
         :name => name, :value => value, :source => source
       )
     end
   end
 
   def newclass(name)
     @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
   end
 
   def newdefine(name)
     @known_resource_types.add Puppet::Resource::Type.new(:definition, name)
   end
 
   def newnode(name)
     @known_resource_types.add Puppet::Resource::Type.new(:node, name)
   end
 
   it "should get its environment from its scope" do
     scope = stub 'scope', :source => stub("source"), :namespaces => nil
     scope.expects(:environment).returns("foo").at_least_once
     Puppet::Parser::Resource.new("file", "whatever", :scope => scope).environment.should == "foo"
   end
 
   it "should use the resource type collection helper module" do
     Puppet::Parser::Resource.ancestors.should be_include(Puppet::Resource::TypeCollectionHelper)
   end
 
   it "should use the scope's environment as its environment" do
     @scope.expects(:environment).returns("myenv").at_least_once
     Puppet::Parser::Resource.new("file", "whatever", :scope => @scope).environment.should == "myenv"
   end
 
   it "should be isomorphic if it is builtin and models an isomorphic type" do
     Puppet::Type.type(:file).expects(:isomorphic?).returns(true)
     @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
   end
 
   it "should not be isomorphic if it is builtin and models a non-isomorphic type" do
     Puppet::Type.type(:file).expects(:isomorphic?).returns(false)
     @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source).isomorphic?.should be_false
   end
 
   it "should be isomorphic if it is not builtin" do
     newdefine "whatever"
     @resource = Puppet::Parser::Resource.new("whatever", "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
   end
 
   it "should have an array-indexing method for retrieving parameter values" do
     @resource = mkresource
     @resource[:one].should == "yay"
   end
 
   it "should use a Puppet::Resource for converting to a ral resource" do
     trans = mock 'resource', :to_ral => "yay"
     @resource = mkresource
     @resource.expects(:copy_as_resource).returns trans
     @resource.to_ral.should == "yay"
   end
 
   it "should be able to use the indexing operator to access parameters" do
     resource = Puppet::Parser::Resource.new("resource", "testing", :source => "source", :scope => @scope)
     resource["foo"] = "bar"
     resource["foo"].should == "bar"
   end
 
   it "should return the title when asked for a parameter named 'title'" do
     Puppet::Parser::Resource.new("resource", "testing", :source => @source, :scope => @scope)[:title].should == "testing"
   end
 
   describe "when initializing" do
     before do
       @arguments = {:scope => @scope}
     end
 
     it "should fail unless #{name.to_s} is specified" do
       expect {
         Puppet::Parser::Resource.new('file', '/my/file')
       }.to raise_error(ArgumentError, /Resources require a hash as last argument/)
     end
 
     it "should set the reference correctly" do
       res = Puppet::Parser::Resource.new("resource", "testing", @arguments)
       res.ref.should == "Resource[testing]"
     end
 
     it "should be tagged with user tags" do
       tags = [ "tag1", "tag2" ]
       @arguments[:parameters] = [ param(:tag, tags , :source) ]
       res = Puppet::Parser::Resource.new("resource", "testing", @arguments)
       res.should be_tagged("tag1")
       res.should be_tagged("tag2")
     end
   end
 
   describe "when evaluating" do
     before do
       @catalog = Puppet::Resource::Catalog.new
       source = stub('source')
       source.stubs(:module_name)
       @scope = Puppet::Parser::Scope.new(@compiler, :source => source)
       @catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => @scope))
     end
 
     it "should evaluate the associated AST definition" do
       definition = newdefine "mydefine"
       res = Puppet::Parser::Resource.new("mydefine", "whatever", :scope => @scope, :source => @source, :catalog => @catalog)
       definition.expects(:evaluate_code).with(res)
 
       res.evaluate
     end
 
     it "should evaluate the associated AST class" do
       @class = newclass "myclass"
       res = Puppet::Parser::Resource.new("class", "myclass", :scope => @scope, :source => @source, :catalog => @catalog)
       @class.expects(:evaluate_code).with(res)
       res.evaluate
     end
 
     it "should evaluate the associated AST node" do
       nodedef = newnode("mynode")
       res = Puppet::Parser::Resource.new("node", "mynode", :scope => @scope, :source => @source, :catalog => @catalog)
       nodedef.expects(:evaluate_code).with(res)
       res.evaluate
     end
 
     it "should add an edge to any specified stage for class resources" do
       @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
 
       other_stage = Puppet::Parser::Resource.new(:stage, "other", :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, other_stage)
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       resource[:stage] = 'other'
       @compiler.add_resource(@scope, resource)
 
       resource.evaluate
 
       @compiler.catalog.edge?(other_stage, resource).should be_true
     end
 
     it "should fail if an unknown stage is specified" do
       @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
 
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       resource[:stage] = 'other'
 
       expect { resource.evaluate }.to raise_error(ArgumentError, /Could not find stage other specified by/)
     end
 
     it "should add edges from the class resources to the parent's stage if no stage is specified" do
       main      = @compiler.catalog.resource(:stage, :main)
       foo_stage = Puppet::Parser::Resource.new(:stage, :foo_stage, :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, foo_stage)
       @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       resource[:stage] = 'foo_stage'
       @compiler.add_resource(@scope, resource)
 
       resource.evaluate
 
       @compiler.catalog.should be_edge(foo_stage, resource)
     end
 
     it "should allow edges to propagate multiple levels down the scope hierarchy" do
       Puppet[:code] = <<-MANIFEST
         stage { before: before => Stage[main] }
 
         class alpha {
           include beta
         }
         class beta {
           include gamma
         }
         class gamma { }
         class { alpha: stage => before }
       MANIFEST
 
       catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
 
       # Stringify them to make for easier lookup
       edges = catalog.edges.map {|e| [e.source.ref, e.target.ref]}
 
       edges.should include(["Stage[before]", "Class[Alpha]"])
       edges.should include(["Stage[before]", "Class[Beta]"])
       edges.should include(["Stage[before]", "Class[Gamma]"])
     end
 
     it "should use the specified stage even if the parent scope specifies one" do
       Puppet[:code] = <<-MANIFEST
         stage { before: before => Stage[main], }
         stage { after: require => Stage[main], }
 
         class alpha {
           class { beta: stage => after }
         }
         class beta { }
         class { alpha: stage => before }
       MANIFEST
 
       catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
 
       edges = catalog.edges.map {|e| [e.source.ref, e.target.ref]}
 
       edges.should include(["Stage[before]", "Class[Alpha]"])
       edges.should include(["Stage[after]", "Class[Beta]"])
     end
 
     it "should add edges from top-level class resources to the main stage if no stage is specified" do
       main = @compiler.catalog.resource(:stage, :main)
       @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, resource)
 
       resource.evaluate
 
       @compiler.catalog.should be_edge(main, resource)
     end
   end
 
   describe "when finishing" do
     before do
       @class = newclass "myclass"
       @nodedef = newnode("mynode")
 
       @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source)
     end
 
     it "should do nothing if it has already been finished" do
       @resource.finish
       @resource.expects(:add_defaults).never
       @resource.finish
     end
 
     it "should add all defaults available from the scope" do
       @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => param(:owner, "default", @resource.source))
       @resource.finish
 
       @resource[:owner].should == "default"
     end
 
     it "should not replace existing parameters with defaults" do
       @resource.set_parameter :owner, "oldvalue"
       @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => :replaced)
       @resource.finish
 
       @resource[:owner].should == "oldvalue"
     end
 
     it "should add a copy of each default, rather than the actual default parameter instance" do
       newparam = param(:owner, "default", @resource.source)
       other = newparam.dup
       other.value = "other"
       newparam.expects(:dup).returns(other)
       @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => newparam)
       @resource.finish
 
       @resource[:owner].should == "other"
     end
   end
 
   describe "when being tagged" do
     before do
       @scope_resource = stub 'scope_resource', :tags => %w{srone srtwo}
       @scope.stubs(:resource).returns @scope_resource
       @resource = Puppet::Parser::Resource.new("file", "yay", :scope => @scope, :source => mock('source'))
     end
 
     it "should get tagged with the resource type" do
       @resource.tags.should be_include("file")
     end
 
     it "should get tagged with the title" do
       @resource.tags.should be_include("yay")
     end
 
     it "should get tagged with each name in the title if the title is a qualified class name" do
       resource = Puppet::Parser::Resource.new("file", "one::two", :scope => @scope, :source => mock('source'))
       resource.tags.should be_include("one")
       resource.tags.should be_include("two")
     end
 
     it "should get tagged with each name in the type if the type is a qualified class name" do
       resource = Puppet::Parser::Resource.new("one::two", "whatever", :scope => @scope, :source => mock('source'))
       resource.tags.should be_include("one")
       resource.tags.should be_include("two")
     end
 
     it "should not get tagged with non-alphanumeric titles" do
       resource = Puppet::Parser::Resource.new("file", "this is a test", :scope => @scope, :source => mock('source'))
       resource.tags.should_not be_include("this is a test")
     end
 
     it "should fail on tags containing '*' characters" do
       expect { @resource.tag("bad*tag") }.to raise_error(Puppet::ParseError)
     end
 
     it "should fail on tags starting with '-' characters" do
       expect { @resource.tag("-badtag") }.to raise_error(Puppet::ParseError)
     end
 
     it "should fail on tags containing ' ' characters" do
       expect { @resource.tag("bad tag") }.to raise_error(Puppet::ParseError)
     end
 
     it "should allow alpha tags" do
       expect { @resource.tag("good_tag") }.to_not raise_error
     end
   end
 
   describe "when merging overrides" do
     before do
       @source = "source1"
       @resource = mkresource :source => @source
       @override = mkresource :source => @source
     end
 
     it "should fail when the override was not created by a parent class" do
       @override.source = "source2"
       @override.source.expects(:child_of?).with("source1").returns(false)
       expect { @resource.merge(@override) }.to raise_error(Puppet::ParseError)
     end
 
     it "should succeed when the override was created in the current scope" do
       @resource.source = "source3"
       @override.source = @resource.source
       @override.source.expects(:child_of?).with("source3").never
       params = {:a => :b, :c => :d}
       @override.expects(:parameters).returns(params)
       @resource.expects(:override_parameter).with(:b)
       @resource.expects(:override_parameter).with(:d)
       @resource.merge(@override)
     end
 
     it "should succeed when a parent class created the override" do
       @resource.source = "source3"
       @override.source = "source4"
       @override.source.expects(:child_of?).with("source3").returns(true)
       params = {:a => :b, :c => :d}
       @override.expects(:parameters).returns(params)
       @resource.expects(:override_parameter).with(:b)
       @resource.expects(:override_parameter).with(:d)
       @resource.merge(@override)
     end
 
     it "should add new parameters when the parameter is not set" do
       @source.stubs(:child_of?).returns true
       @override.set_parameter(:testing, "value")
       @resource.merge(@override)
 
       @resource[:testing].should == "value"
     end
 
     it "should replace existing parameter values" do
       @source.stubs(:child_of?).returns true
       @resource.set_parameter(:testing, "old")
       @override.set_parameter(:testing, "value")
 
       @resource.merge(@override)
 
       @resource[:testing].should == "value"
     end
 
     it "should add values to the parameter when the override was created with the '+>' syntax" do
       @source.stubs(:child_of?).returns true
       param = Puppet::Parser::Resource::Param.new(:name => :testing, :value => "testing", :source => @resource.source)
       param.add = true
 
       @override.set_parameter(param)
 
       @resource.set_parameter(:testing, "other")
 
       @resource.merge(@override)
 
       @resource[:testing].should == %w{other testing}
     end
 
     it "should not merge parameter values when multiple resources are overriden with '+>' at once " do
       @resource_2 = mkresource :source => @source
 
       @resource.  set_parameter(:testing, "old_val_1")
       @resource_2.set_parameter(:testing, "old_val_2")
 
       @source.stubs(:child_of?).returns true
       param = Puppet::Parser::Resource::Param.new(:name => :testing, :value => "new_val", :source => @resource.source)
       param.add = true
       @override.set_parameter(param)
 
       @resource.  merge(@override)
       @resource_2.merge(@override)
 
       @resource  [:testing].should == %w{old_val_1 new_val}
       @resource_2[:testing].should == %w{old_val_2 new_val}
     end
 
     it "should promote tag overrides to real tags" do
       @source.stubs(:child_of?).returns true
       param = Puppet::Parser::Resource::Param.new(:name => :tag, :value => "testing", :source => @resource.source)
 
       @override.set_parameter(param)
 
       @resource.merge(@override)
 
       @resource.tagged?("testing").should be_true
     end
 
   end
 
   it "should be able to be converted to a normal resource" do
     @source = stub 'scope', :name => "myscope"
     @resource = mkresource :source => @source
     @resource.should respond_to(:copy_as_resource)
   end
 
   describe "when being converted to a resource" do
     before do
       @parser_resource = mkresource :scope => @scope, :parameters => {:foo => "bar", :fee => "fum"}
     end
 
     it "should create an instance of Puppet::Resource" do
       @parser_resource.copy_as_resource.should be_instance_of(Puppet::Resource)
     end
 
     it "should set the type correctly on the Puppet::Resource" do
       @parser_resource.copy_as_resource.type.should == @parser_resource.type
     end
 
     it "should set the title correctly on the Puppet::Resource" do
       @parser_resource.copy_as_resource.title.should == @parser_resource.title
     end
 
     it "should copy over all of the parameters" do
       result = @parser_resource.copy_as_resource.to_hash
 
       # The name will be in here, also.
       result[:foo].should == "bar"
       result[:fee].should == "fum"
     end
 
     it "should copy over the tags" do
       @parser_resource.tag "foo"
       @parser_resource.tag "bar"
 
       @parser_resource.copy_as_resource.tags.should == @parser_resource.tags
     end
 
     it "should copy over the line" do
       @parser_resource.line = 40
       @parser_resource.copy_as_resource.line.should == 40
     end
 
     it "should copy over the file" do
       @parser_resource.file = "/my/file"
       @parser_resource.copy_as_resource.file.should == "/my/file"
     end
 
     it "should copy over the 'exported' value" do
       @parser_resource.exported = true
       @parser_resource.copy_as_resource.exported.should be_true
     end
 
     it "should copy over the 'virtual' value" do
       @parser_resource.virtual = true
       @parser_resource.copy_as_resource.virtual.should be_true
     end
 
     it "should convert any parser resource references to Puppet::Resource instances" do
       ref = Puppet::Resource.new("file", "/my/file")
       @parser_resource = mkresource :source => @source, :parameters => {:foo => "bar", :fee => ref}
       result = @parser_resource.copy_as_resource
       result[:fee].should == Puppet::Resource.new(:file, "/my/file")
     end
 
     it "should convert any parser resource references to Puppet::Resource instances even if they are in an array" do
       ref = Puppet::Resource.new("file", "/my/file")
       @parser_resource = mkresource :source => @source, :parameters => {:foo => "bar", :fee => ["a", ref]}
       result = @parser_resource.copy_as_resource
       result[:fee].should == ["a", Puppet::Resource.new(:file, "/my/file")]
     end
 
     it "should convert any parser resource references to Puppet::Resource instances even if they are in an array of array, and even deeper" do
       ref1 = Puppet::Resource.new("file", "/my/file1")
       ref2 = Puppet::Resource.new("file", "/my/file2")
       @parser_resource = mkresource :source => @source, :parameters => {:foo => "bar", :fee => ["a", [ref1,ref2]]}
       result = @parser_resource.copy_as_resource
       result[:fee].should == ["a", Puppet::Resource.new(:file, "/my/file1"), Puppet::Resource.new(:file, "/my/file2")]
     end
 
     it "should fail if the same param is declared twice" do
       lambda do
         @parser_resource = mkresource :source => @source, :parameters => [
           Puppet::Parser::Resource::Param.new(
             :name => :foo, :value => "bar", :source => @source
           ),
           Puppet::Parser::Resource::Param.new(
             :name => :foo, :value => "baz", :source => @source
           )
         ]
       end.should raise_error(Puppet::ParseError)
     end
   end
 
   describe "when validating" do
     it "should check each parameter" do
       resource = Puppet::Parser::Resource.new :foo, "bar", :scope => @scope, :source => stub("source")
       resource[:one] = :two
       resource[:three] = :four
       resource.expects(:validate_parameter).with(:one)
       resource.expects(:validate_parameter).with(:three)
       resource.send(:validate)
     end
 
     it "should raise a parse error when there's a failure" do
       resource = Puppet::Parser::Resource.new :foo, "bar", :scope => @scope, :source => stub("source")
       resource[:one] = :two
       resource.expects(:validate_parameter).with(:one).raises ArgumentError
       expect { resource.send(:validate) }.to raise_error(Puppet::ParseError)
     end
   end
 
   describe "when setting parameters" do
     before do
       @source = newclass "foobar"
       @resource = Puppet::Parser::Resource.new :foo, "bar", :scope => @scope, :source => @source
     end
 
     it "should accept Param instances and add them to the parameter list" do
       param = Puppet::Parser::Resource::Param.new :name => "foo", :value => "bar", :source => @source
       @resource.set_parameter(param)
       @resource["foo"].should == "bar"
     end
 
-    it "should fail when provided a parameter name but no value" do
-      expect { @resource.set_parameter("myparam") }.to raise_error(ArgumentError)
-    end
-
     it "should allow parameters to be set to 'false'" do
       @resource.set_parameter("myparam", false)
       @resource["myparam"].should be_false
     end
 
     it "should use its source when provided a parameter name and value" do
       @resource.set_parameter("myparam", "myvalue")
       @resource["myparam"].should == "myvalue"
     end
   end
 
   # part of #629 -- the undef keyword.  Make sure 'undef' params get skipped.
   it "should not include 'undef' parameters when converting itself to a hash" do
     resource = Puppet::Parser::Resource.new "file", "/tmp/testing", :source => mock("source"), :scope => mock("scope")
     resource[:owner] = :undef
     resource[:mode] = "755"
     resource.to_hash[:owner].should be_nil
   end
 end