puppet 3.6.2 → 3.7.0

data/lib/puppet/pops/issue_reporter.rb

@@ -1,17 +1,25 @@
 class Puppet::Pops::IssueReporter
 
   # @param acceptor [Puppet::Pops::Validation::Acceptor] the acceptor containing reported issues
-  # @option options [String] :message (nil) A message text to use as prefix in a single Error message
-  # @option options [Boolean] :emit_warnings (false) A message text to use as prefix in a single Error message
-  # @option options [Boolean] :emit_errors (true) whether errors should be emitted or only given message
+  # @option options [String] :message (nil) A message text to use as prefix in
+  #   a single Error message
+  # @option options [Boolean] :emit_warnings (false) whether warnings should be emitted
+  # @option options [Boolean] :emit_errors (true) whether errors should be
+  #   emitted or only the given message
   # @option options [Exception] :exception_class (Puppet::ParseError) The exception to raise
   #
   def self.assert_and_report(acceptor, options)
     return unless acceptor
 
     max_errors = Puppet[:max_errors]
-    max_warnings = Puppet[:max_warnings] + 1
-    max_deprecations = Puppet[:max_deprecations] + 1
+    max_warnings = Puppet[:max_warnings]
+    max_deprecations =
+    if Puppet[:disable_warnings].include?('deprecations')
+      0
+    else
+      Puppet[:max_deprecations]
+    end
+
     emit_warnings = options[:emit_warnings] || false
     emit_errors = options[:emit_errors].nil? ? true : !!options[:emit_errors]
     emit_message = options[:message]
@@ -35,7 +43,7 @@ class Puppet::Pops::IssueReporter
           Puppet.warning(formatter.format(w)) if emitted_w < max_warnings
           emitted_w += 1
         end
-        break if emitted_w > max_warnings && emitted_dw > max_deprecations # but only then
+        break if emitted_w >= max_warnings && emitted_dw >= max_deprecations # but only then
       end
     end
 

data/lib/puppet/pops/issues.rb

@@ -174,17 +174,9 @@ module Puppet::Pops::Issues
     "Illegal attempt to assign to the numeric match result variable '$#{varname}'. Numeric variables are not assignable"
   end
 
-  APPEND_FAILED = issue :APPEND_FAILED, :message do
-    "Append assignment += failed with error: #{message}"
-  end
-
-  DELETE_FAILED = issue :DELETE_FAILED, :message do
-    "'Delete' assignment -= failed with error: #{message}"
-  end
-
   # parameters cannot have numeric names, clashes with match result variables
   ILLEGAL_NUMERIC_PARAMETER = issue :ILLEGAL_NUMERIC_PARAMETER, :name do
-    "The numeric parameter name '$#{varname}' cannot be used (clashes with numeric match result variables)"
+    "The numeric parameter name '$#{name}' cannot be used (clashes with numeric match result variables)"
   end
 
   # In certain versions of Puppet it may be allowed to assign to a not already assigned key
@@ -202,9 +194,20 @@ module Puppet::Pops::Issues
     "Illegal attempt to assign to #{label.a_an(semantic)} via [index/key]. Not an assignable reference"
   end
 
-  # For unsupported operators (e.g. -= in puppet 3).
+  APPENDS_DELETES_NO_LONGER_SUPPORTED = hard_issue :APPENDS_DELETES_NO_LONGER_SUPPORTED, :operator do
+    "The operator '#{operator}' is no longer supported. See http://links.puppetlabs.com/remove-plus-equals"
+  end
+
+  # For unsupported operators (e.g. += and -= in puppet 4).
   #
   UNSUPPORTED_OPERATOR = hard_issue :UNSUPPORTED_OPERATOR, :operator do
+    "The operator '#{operator}' is not supported."
+  end
+
+  # For operators that are not supported in specific contexts (e.g. '* =>' in
+  # resource defaults)
+  #
+  UNSUPPORTED_OPERATOR_IN_CONTEXT = hard_issue :UNSUPPORTED_OPERATOR_IN_CONTEXT, :operator do
     "The operator '#{operator}' in #{label.a_an(semantic)} is not supported."
   end
 
@@ -292,8 +295,7 @@ module Puppet::Pops::Issues
     "Illegal expression. #{label.a_an_uc(semantic)} is unacceptable as #{feature} in #{label.a_an(container)}"
   end
 
-  # Issues when an expression is used where it is not legal.
-  # E.g. an arithmetic expression where a hostname is expected.
+  # Issues when a variable is not a NAME
   #
   ILLEGAL_VARIABLE_EXPRESSION = hard_issue :ILLEGAL_VARIABLE_EXPRESSION do
     "Illegal variable expression. #{label.a_an_uc(semantic)} did not produce a variable name (String or Numeric)."
@@ -319,10 +321,6 @@ module Puppet::Pops::Issues
     "Attempt to use unsupported range in #{label.a_an(semantic)}, #{count} values given for max 1"
   end
 
-  DEPRECATED_NAME_AS_TYPE = issue :DEPRECATED_NAME_AS_TYPE, :name do
-    "Resource references should now be capitalized. The given '#{name}' does not have the correct form"
-  end
-
   ILLEGAL_RELATIONSHIP_OPERAND_TYPE = issue :ILLEGAL_RELATIONSHIP_OPERAND_TYPE, :operand do
     "Illegal relationship operand, can not form a relationship with #{label.a_an(operand)}. A Catalog type is required."
   end
@@ -411,15 +409,24 @@ module Puppet::Pops::Issues
     "Illegal Class name in class reference. #{label.a_an_uc(name)} cannot be used where a String is expected"
   end
 
-  # Issues when an expression is used where it is not legal.
-  # E.g. an arithmetic expression where a hostname is expected.
-  #
   ILLEGAL_DEFINITION_NAME = hard_issue :ILLEGAL_DEFINTION_NAME, :name do
     "Unacceptable name. The name '#{name}' is unacceptable as the name of #{label.a_an(semantic)}"
   end
 
-  NON_NAMESPACED_FUNCTION = hard_issue :NON_NAMESPACED_FUNCTION, :name do
-    "A Puppet Function must be defined within a module name-space. The name '#{name}' is unacceptable."
+  CAPTURES_REST_NOT_LAST = hard_issue :CAPTURES_REST_NOT_LAST, :param_name do
+    "Parameter $#{param_name} is not last, and has 'captures rest'"
+  end
+
+  CAPTURES_REST_NOT_SUPPORTED = hard_issue :CAPTURES_REST_NOT_SUPPORTED, :container, :param_name do
+    "Parameter $#{param_name} has 'captures rest' - not supported in #{label.a_an(container)}"
+  end
+
+  REQUIRED_PARAMETER_AFTER_OPTIONAL = hard_issue :REQUIRED_PARAMETER_AFTER_OPTIONAL, :param_name do
+    "Parameter $#{param_name} is required but appears after optional parameters"
+  end
+
+  MISSING_REQUIRED_PARAMETER = hard_issue :MISSING_REQUIRED_PARAMETER, :param_name do
+    "Parameter $#{param_name} is required but no value was given"
   end
 
   NOT_NUMERIC = issue :NOT_NUMERIC, :value do
@@ -442,6 +449,34 @@ module Puppet::Pops::Issues
     "Resource type not found: #{type_name.capitalize}"
   end
 
+  ILLEGAL_RESOURCE_TYPE = hard_issue :ILLEGAL_RESOURCE_TYPE, :actual do
+    "Illegal Resource Type expression, expected result to be a type name, or untitled Resource, got #{actual}"
+  end
+
+  DUPLICATE_TITLE = issue :DUPLICATE_TITLE, :title  do
+    "The title '#{title}' has already been used in this resource expression"
+  end
+
+  DUPLICATE_ATTRIBUTE = issue :DUPLICATE_ATTRIBUE, :attribute  do
+    "The attribute '#{attribute}' has already been set in this resource body"
+  end
+
+  MISSING_TITLE = hard_issue :MISSING_TITLE do
+    "Missing title. The title expression resulted in undef"
+  end
+
+  MISSING_TITLE_AT = hard_issue :MISSING_TITLE_AT, :index do
+    "Missing title at index #{index}. The title expression resulted in an undef title"
+  end
+
+  ILLEGAL_TITLE_TYPE_AT = hard_issue :ILLEGAL_TITLE_TYPE_AT, :index, :actual do
+    "Illegal title type at index #{index}. Expected String, got #{actual}"
+  end
+
+  EMPTY_STRING_TITLE_AT = hard_issue :EMPTY_STRING_TITLE_AT, :index do
+    "Empty string title at #{index}. Title strings must have a length greater than zero."
+  end
+
   UNKNOWN_RESOURCE = issue :UNKNOWN_RESOURCE, :type_name, :title do
     "Resource not found: #{type_name.capitalize}['#{title}']"
   end
@@ -470,4 +505,44 @@ module Puppet::Pops::Issues
   DISCONTINUED_IMPORT = hard_issue :DISCONTINUED_IMPORT do
     "Use of 'import' has been discontinued in favor of a manifest directory. See http://links.puppetlabs.com/puppet-import-deprecation"
   end
+
+  IDEM_EXPRESSION_NOT_LAST = issue :IDEM_EXPRESSION_NOT_LAST do
+    "This #{label.label(semantic)} is not productive. A non productive construct may only be placed last in a block/sequence"
+  end
+
+  IDEM_NOT_ALLOWED_LAST = hard_issue :IDEM_NOT_ALLOWED_LAST, :container do
+    "This #{label.label(semantic)} is not productive. #{label.a_an_uc(container)} can not end with a non productive construct"
+  end
+
+  RESERVED_WORD = hard_issue :RESERVED_WORD, :word do
+    "Use of reserved word: #{word}, must be quoted if intended to be a String value"
+  end
+
+  RESERVED_TYPE_NAME = hard_issue :RESERVED_TYPE_NAME, :name do
+    "The name: '#{name}' is already defined by Puppet and can not be used as the name of #{label.a_an(semantic)}."
+  end
+
+  UNMATCHED_SELECTOR = hard_issue :UNMATCHED_SELECTOR, :param_value do
+    "No matching entry for selector parameter with value '#{param_value}'"
+  end
+
+  ILLEGAL_NODE_INHERITANCE = issue :ILLEGAL_NODE_INHERITANCE do
+    "Node inheritance is not supported in Puppet >= 4.0.0. See http://links.puppetlabs.com/puppet-node-inheritance-deprecation"
+  end
+
+  ILLEGAL_OVERRIDEN_TYPE = issue :ILLEGAL_OVERRIDEN_TYPE, :actual do
+    "Resource Override can only operate on resources, got: #{label.label(actual)}"
+  end
+
+  RESERVED_PARAMETER = hard_issue :RESERVED_PARAMETER, :container, :param_name do
+    "The parameter $#{param_name} redefines a built in parameter in #{label.the(container)}"
+  end
+
+  TYPE_MISMATCH = hard_issue :TYPE_MISMATCH, :expected, :actual do
+    "Expected value of type #{expected}, got #{actual}"
+  end
+
+  MULTIPLE_ATTRIBUTES_UNFOLD = hard_issue :MULTIPLE_ATTRIBUTES_UNFOLD do
+    "Unfolding of attributes from Hash can only be used once per resource body"
+  end
 end

data/lib/puppet/pops/loader/base_loader.rb

@@ -65,7 +65,7 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
   #
   def promote_entry(named_entry)
     typed_name = named_entry.typed_name
-    if entry = @named_values[typed_name] then fail_redefined(entry); end
+    if entry = @named_values[typed_name] then fail_redefine(entry); end
     @named_values[typed_name] = named_entry
   end
 
@@ -73,7 +73,7 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
 
   def fail_redefine(entry)
     origin_info = entry.origin ? " Originally set at #{origin_label(entry.origin)}." : "unknown location"
-    raise ArgumentError, "Attempt to redefine entity '#{entry.typed_name}' originally set at #{origin_label(origin)}.#{origin_info}"
+    raise ArgumentError, "Attempt to redefine entity '#{entry.typed_name}' originally set at #{origin_info}"
   end
 
   # TODO: Should not really be here?? - TODO: A Label provider ? semantics for the URI?
@@ -84,7 +84,7 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
     elsif origin.respond_to?(:uri)
       origin.uri.to_s
     else
-      nil
+      origin
     end
   end
 

data/lib/puppet/pops/loader/loader.rb

@@ -127,7 +127,7 @@ class Puppet::Pops::Loader::Loader
     attr_reader :origin
 
     def initialize(typed_name, value, origin)
-      @name = typed_name
+      @typed_name = typed_name
       @value = value
       @origin = origin
       freeze()

data/lib/puppet/pops/loader/loader_paths.rb

@@ -11,18 +11,11 @@ module Puppet::Pops::Loader::LoaderPaths
   # and existence checks). The smart paths in the array appear in precedence order. The returned array may be
   # mutated.
   #
-  def self.relative_paths_for_type(type, loader) #, start_index_in_name)
+  def self.relative_paths_for_type(type, loader)
     result =
-    case type # typed_name.type
+    case type
     when :function
-      if Puppet[:biff] == true
-        [FunctionPath4x.new(loader), FunctionPath3x.new(loader)]
-      else
         [FunctionPath4x.new(loader)]
-      end
-
-    # when :xxx # TODO: Add all other types
-
     else
       # unknown types, simply produce an empty result; no paths to check, nothing to find... move along...
       []
@@ -93,18 +86,6 @@ module Puppet::Pops::Loader::LoaderPaths
     end
   end
 
-  class FunctionPath3x < RubySmartPath
-    FUNCTION_PATH_3X = File.join('lib', 'puppet', 'parser', 'functions')
-
-    def relative_path
-      FUNCTION_PATH_3X
-    end
-
-    def instantiator()
-      Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
-    end
-  end
-
   # SmartPaths
   # ===
   # Holds effective SmartPath instances per type

data/lib/puppet/pops/loader/ruby_function_instantiator.rb

@@ -16,7 +16,7 @@ class Puppet::Pops::Loader::RubyFunctionInstantiator
     unless ruby_code_string.is_a?(String) && ruby_code_string =~ /Puppet\:\:Functions\.create_function/
       raise ArgumentError, "The code loaded from #{source_ref} does not seem to be a Puppet 4x API function - no create_function call."
     end
-    created = eval(ruby_code_string)
+    created = eval(ruby_code_string, nil, source_ref, 1)
     unless created.is_a?(Class)
       raise ArgumentError, "The code loaded from #{source_ref} did not produce a Function class when evaluated. Got '#{created.class}'"
     end

data/lib/puppet/pops/loader/static_loader.rb

@@ -49,14 +49,24 @@ class Puppet::Pops::Loader::StaticLoader < Puppet::Pops::Loader::Loader
 
         # Logs per the specified level, outputs formatted information for arrays, hashes etc.
         # Overrides the implementation in Function that uses dispatching. This is not needed here
-        # since it accepts 0-n Optional[Object]
+        # since it accepts 0-n Object.
         #
         define_method(:call) do |scope, *vals|
           # NOTE: 3x, does this: vals.join(" ")
           # New implementation uses the evaluator to get proper formatting per type
           # TODO: uses a fake scope (nil) - fix when :scopes are available via settings
           mapped = vals.map {|v| Puppet::Pops::Evaluator::EvaluatorImpl.new.string(v, nil) }
-          Puppet.send(level, mapped.join(" "))
+
+          # Bypass Puppet.<level> call since it picks up source from "self" which is not applicable in the 4x
+          # Function API.
+          # TODO: When a function can obtain the file, line, pos of the call merge those in (3x supports
+          #       options :file, :line. (These were never output when calling the 3x logging functions since
+          #       3x scope does not know about the calling location at that detailed level, nor do they
+          #       appear in a report to stdout/error when included). Now, the output simply uses scope (like 3x)
+          #       as this is good enough, but does not reflect the true call-stack, but is a rough estimate
+          #       of where the logging call originates from).
+          #
+          Puppet::Util::Log.create({:level => level, :source => scope, :message => mapped.join(" ")})
         end
       end
 

data/lib/puppet/pops/model/ast_transformer.rb

@@ -519,23 +519,7 @@ class Puppet::Pops::Model::AstTransformer
   # the "titles" to be an ASTArray.
   #
   def transform_ResourceOverrideExpression(o)
-    resource_ref = o.resources
-    raise "Unacceptable expression for resource override" unless resource_ref.is_a? Model::AccessExpression
-
-    type = case resource_ref.left_expr
-    when Model::QualifiedName
-      # This is deprecated "Resource references should now be capitalized" - this is caught elsewhere
-      resource_ref.left_expr.value
-    when Model::QualifiedReference
-      resource_ref.left_expr.value
-    else
-      raise "Unacceptable expression for resource override; need NAME or CLASSREF"
-    end
-
-    result_ref = ast o, AST::ResourceReference, :type => type, :title => transform(resource_ref.keys)
-
-    # title is one or more expressions, if more than one it should be an ASTArray
-    ast o, AST::ResourceOverride, :object => result_ref, :parameters => transform(o.operations)
+    raise "Unsupported transformation - use the new evaluator"
   end
 
   # Parameter is a parameter in a definition of some kind.
@@ -614,22 +598,18 @@ class Puppet::Pops::Model::AstTransformer
   end
 
   def transform_ResourceBody(o)
-    # expects AST, AST::ASTArray of AST
-    ast o, AST::ResourceInstance, :title => transform(o.title), :parameters => transform(o.operations)
+    raise "Unsupported transformation - use the new evaluator"
   end
 
   def transform_ResourceDefaultsExpression(o)
-    ast o, AST::ResourceDefaults, :type => o.type_ref.value, :parameters => transform(o.operations)
+    raise "Unsupported transformation - use the new evaluator"
   end
 
   # Transformation of ResourceExpression requires calling a method on the resulting
   # AST::Resource if it is virtual or exported
   #
   def transform_ResourceExpression(o)
-    raise "Unacceptable type name expression" unless o.type_name.is_a? Model::QualifiedName
-    resource = ast o, AST::Resource, :type => o.type_name.value, :instances => transform(o.bodies)
-    resource.send("#{o.form}=", true) unless o.form == :regular
-    resource
+    raise "Unsupported transformation - use the new evaluator"
   end
 
   # Transformation of SelectorExpression is limited to certain types of expressions.

data/lib/puppet/pops/model/factory.rb

@@ -70,6 +70,11 @@ class Puppet::Pops::Model::Factory
     o
   end
 
+  def build_AttributesOperation(o, value)
+    o.expr = build(value)
+    o
+  end
+
   def build_AccessExpression(o, left, *keys)
     o.left_expr = to_ops(left)
     keys.each {|expr| o.addKeys(to_ops(expr)) }
@@ -146,6 +151,11 @@ class Puppet::Pops::Model::Factory
     o
   end
 
+  def build_ReservedWord(o, name)
+    o.word = name
+    o
+  end
+
   def build_KeyedEntry(o, k, v)
     o.key = to_ops(k)
     o.value = to_ops(v)
@@ -329,6 +339,10 @@ class Puppet::Pops::Model::Factory
     o
   end
 
+  def build_TokenValue(o)
+    raise "Factory can not deal with a Lexer Token. Got token: #{o}. Probably caused by wrong index in grammar val[n]."
+  end
+
   # Puppet::Pops::Model::Factory helpers
   def f_build_unary(klazz, expr)
     Puppet::Pops::Model::Factory.new(build(klazz.new, expr))
@@ -369,6 +383,8 @@ class Puppet::Pops::Model::Factory
 
   def minus();  f_build_unary(Model::UnaryMinusExpression, self);         end
 
+  def unfold(); f_build_unary(Model::UnfoldExpression, self);             end
+
   def text();   f_build_unary(Model::TextExpression, self);               end
 
   def var();    f_build_unary(Model::VariableExpression, self);           end
@@ -483,7 +499,18 @@ class Puppet::Pops::Model::Factory
     Puppet::Pops::Adapters::SourcePosAdapter.adapt(current)
   end
 
-  # Returns symbolic information about an expected share of a resource expression given the LHS of a resource expr.
+  # Sets the form of the resource expression (:regular (the default), :virtual, or :exported).
+  # Produces true if the expression was a resource expression, false otherwise.
+  #
+  def self.set_resource_form(expr, form)
+    expr = expr.current if expr.is_a?(Puppet::Pops::Model::Factory)
+    # Note: Validation handles illegal combinations
+    return false unless expr.is_a?(Puppet::Pops::Model::AbstractResource)
+    expr.form = form
+    return true
+  end
+
+  # Returns symbolic information about an expected shape of a resource expression given the LHS of a resource expr.
   #
   # * `name { }` => `:resource`,  create a resource of the given type
   # * `Name { }` => ':defaults`, set defaults for the referenced type
@@ -498,7 +525,12 @@ class Puppet::Pops::Model::Factory
     when Model::QualifiedReference
       :defaults
     when Model::AccessExpression
-      :override
+      # if Resource[e], then it is not resource specific
+      if expr.left_expr.is_a?(Model::QualifiedReference) && expr.left_expr.value == 'resource' && expr.keys.size == 1
+        :defaults
+      else
+        :override
+      end
     when 'class'
       :class
     else
@@ -511,6 +543,8 @@ class Puppet::Pops::Model::Factory
 
   def self.minus(o);                     new(o).minus;                                           end
 
+  def self.unfold(o);                    new(o).unfold;                                          end
+
   def self.var(o);                       new(o).var;                                             end
 
   def self.block(*args);                 new(Model::BlockExpression, *args);                     end
@@ -539,7 +573,6 @@ class Puppet::Pops::Model::Factory
 
   def self.HASH(entries);                new(Model::LiteralHash, *entries);                      end
 
-  # TODO_HEREDOC
   def self.HEREDOC(name, expr);          new(Model::HeredocExpression, name, expr);              end
 
   def self.SUBLOCATE(token, expr)        new(Model::SubLocatedExpression, token, expr);          end
@@ -550,6 +583,19 @@ class Puppet::Pops::Model::Factory
 
   def self.NODE(hosts, parent, body);    new(Model::NodeDefinition, hosts, parent, body);        end
 
+
+  # Parameters
+
+  # Mark parameter as capturing the rest of arguments
+  def captures_rest()
+    current.captures_rest = true
+  end
+
+  # Set Expression that should evaluate to the parameter's type
+  def type_expr(o)
+    current.type_expr = to_ops(o)
+  end
+
   # Creates a QualifiedName representation of o, unless o already represents a QualifiedName in which
   # case it is returned.
   #
@@ -582,13 +628,18 @@ class Puppet::Pops::Model::Factory
   end
 
   def self.EPP(parameters, body)
-    see_scope = false
-    params = parameters
     if parameters.nil?
       params = []
-      see_scope = true
+      parameters_specified = false
+    else
+      params = parameters
+      parameters_specified = true
     end
-    LAMBDA(params, new(Model::EppExpression, see_scope, body))
+    LAMBDA(params, new(Model::EppExpression, parameters_specified, body))
+  end
+
+  def self.RESERVED(name)
+    new(Model::ReservedWord, name)
   end
 
   # TODO: This is the same a fqn factory method, don't know if callers to fqn and QNAME can live with the
@@ -643,6 +694,10 @@ class Puppet::Pops::Model::Factory
     new(Model::AttributeOperation, name, op, expr)
   end
 
+  def self.ATTRIBUTES_OP(expr)
+    new(Model::AttributesOperation, expr)
+  end
+
   def self.CALL_NAMED(name, rval_required, argument_list)
     unless name.kind_of?(Model::PopsObject)
       name = Puppet::Pops::Model::Factory.fqn(name) unless name.is_a?(Puppet::Pops::Model::Factory)
@@ -712,6 +767,7 @@ class Puppet::Pops::Model::Factory
     'realize' => true,
     'include' => true,
     'contain' => true,
+    'tag'     => true,
 
     'debug'   => true,
     'info'    => true,
@@ -763,8 +819,9 @@ class Puppet::Pops::Model::Factory
   # Transforms a left expression followed by an untitled resource (in the form of attribute_operations)
   # @param left [Factory, Expression] the lhs followed what may be a hash
   def self.transform_resource_wo_title(left, attribute_ops)
+    # Returning nil means accepting the given as a potential resource expression
     return nil unless attribute_ops.is_a? Array
-#    return nil if attribute_ops.find { |ao| ao.operator == :'+>' }
+    return nil unless left.current.is_a?(Puppet::Pops::Model::QualifiedName)
     keyed_entries = attribute_ops.map do |ao|
       return nil if ao.operator == :'+>'
       KEY_ENTRY(ao.attribute_name, ao.value_expr)
@@ -819,8 +876,8 @@ class Puppet::Pops::Model::Factory
     x
   end
 
-  def build_EppExpression(o, see_scope, body)
-    o.see_scope = see_scope
+  def build_EppExpression(o, parameters_specified, body)
+    o.parameters_specified = parameters_specified
     b = f_build_body(body)
     o.body = b.current if b
     o
@@ -833,6 +890,7 @@ class Puppet::Pops::Model::Factory
 
   # Creates a String literal, unless the symbol is one of the special :undef, or :default
   # which instead creates a LiterlUndef, or a LiteralDefault.
+  # Supports :undef because nil creates a no-op instruction.
   def build_Symbol(o)
     case o
     when :undef
@@ -975,4 +1033,8 @@ class Puppet::Pops::Model::Factory
       end
     end.join(''))
   end
+
+  def to_s
+    Puppet::Pops::Model::ModelTreeDumper.new.dump(self)
+  end
 end