puppet 5.3.4 → 6.29.0

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Factory is a helper class that makes construction of a Pops Model
 # much more convenient. It can be viewed as a small internal DSL for model
 # constructions.
@@ -28,6 +29,7 @@ class Factory
   BUILD_VISITOR = Visitor.new(self, 'build')
   INFER_VISITOR = Visitor.new(self, 'infer')
   INTERPOLATION_VISITOR = Visitor.new(self, 'interpolate')
+  MAPOFFSET_VISITOR = Visitor.new(self, 'map_offset')
 
   def self.infer(o)
     if o.instance_of?(Factory)
@@ -37,7 +39,7 @@ class Factory
     end
   end
 
-  attr_reader :model_class
+  attr_reader :model_class, :unfolded
 
   def [](key)
     @init_hash[key]
@@ -89,6 +91,29 @@ class Factory
     end
   end
 
+  def map_offset(model, locator)
+    MAPOFFSET_VISITOR.visit_this_1(self, model, locator)
+  end
+
+  def map_offset_Object(o, locator)
+    o
+  end
+
+  def map_offset_Factory(o, locator)
+    map_offset(o.model, locator)
+  end
+
+  def map_offset_Positioned(o, locator)
+    # Transpose the local offset, length to global "coordinates"
+    global_offset, global_length = locator.to_global(o.offset, o.length)
+
+    # mutate
+    o.instance_variable_set(:'@offset', global_offset)
+    o.instance_variable_set(:'@length', global_length)
+    # Change locator since the positions were transposed to the global coordinates
+    o.instance_variable_set(:'@locator', locator.locator) if locator.is_a? Puppet::Pops::Parser::Locator::SubLocator
+  end
+
   # Polymorphic interpolate
   def interpolate()
     INTERPOLATION_VISITOR.visit_this_class(self, @model_class, EMPTY_ARRAY)
@@ -179,7 +204,8 @@ class Factory
   end
 
   def build_ConcatenatedString(o, args)
-    @init_hash['segments'] = args
+    # Strip empty segments
+    @init_hash['segments'] = args.reject { |arg| arg.model_class == LiteralString && arg['value'].empty? }
   end
 
   def build_HeredocExpression(o, name, expr)
@@ -213,8 +239,9 @@ class Factory
     @init_hash[KEY_VALUE] = v
   end
 
-  def build_LiteralHash(o, keyed_entries)
+  def build_LiteralHash(o, keyed_entries, unfolded)
     @init_hash['entries'] = keyed_entries
+    @unfolded = unfolded
   end
 
   def build_LiteralList(o, values)
@@ -240,6 +267,11 @@ class Factory
     @init_hash['else_expr'] = els
   end
 
+  def build_ApplyExpression(o, args, body)
+    @init_hash['arguments'] = args
+    @init_hash['body'] = body
+  end
+
   def build_MatchExpression(o, op, a, b)
     @init_hash[KEY_OPERATOR] = op
     build_BinaryExpression(o, a, b)
@@ -310,6 +342,7 @@ class Factory
   def infer_Hash(o)
     @model_class = LiteralHash
     @init_hash['entries'] = o.sort_by { |k,_| k.to_s }.map { |k, v| Factory.new(KeyedEntry, Factory.infer(k), Factory.infer(v)) }
+    @unfolded = false
   end
 
   def f_build_body(body)
@@ -347,6 +380,14 @@ class Factory
     @init_hash['return_type'] = return_type unless return_type.nil?
   end
 
+  def build_PlanDefinition(o, name, parameters, body, return_type=nil)
+    @init_hash[KEY_PARAMETERS] = parameters
+    b = f_build_body(body)
+    @init_hash[KEY_BODY] = b unless b.nil?
+    @init_hash[KEY_NAME] = name
+    @init_hash['return_type'] = return_type unless return_type.nil?
+  end
+
   def build_CapabilityMapping(o, kind, component, capability, mappings)
     @init_hash['kind'] = kind
     @init_hash['component'] = component
@@ -417,8 +458,7 @@ class Factory
     @init_hash[KEY_LOCATOR] = locator
     @init_hash['leading_line_count'] = locator.leading_line_count
     @init_hash['leading_line_offset'] = locator.leading_line_offset
-    # Index is held in sublocator's parent locator - needed to be able to reconstruct
-    @init_hash['line_offsets'] = locator.locator.line_index
+    @init_hash['line_offsets'] = locator.line_index # index of lines in sublocated
   end
 
   def build_SelectorEntry(o, matching, value)
@@ -442,10 +482,12 @@ class Factory
       #
       parent = type_expr['key']
       hash = type_expr['value']
-      unless parent['cased_value'] == 'Object'
+      pn = parent['cased_value']
+      unless pn == 'Object' || pn == 'TypeSet'
         hash['entries'] << Factory.KEY_ENTRY(Factory.QNAME('parent'), parent)
+        parent = Factory.QREF('Object')
       end
-      type_expr = Factory.QREF('Object').access([hash])
+      type_expr = parent.access([hash])
     elsif type_expr.model_class <= LiteralHash
       # LiteralHash is used for the form:
       #
@@ -703,14 +745,14 @@ class Factory
 
   def self.KEY_ENTRY(key, val);          new(KeyedEntry, key, val);                      end
 
-  def self.HASH(entries);                new(LiteralHash, entries);                      end
+  def self.HASH(entries);                new(LiteralHash, entries, false);               end
+
+  def self.HASH_UNFOLDED(entries);       new(LiteralHash, entries, true);                end
 
   def self.HEREDOC(name, expr);          new(HeredocExpression, name, expr);             end
 
   def self.STRING(*args);                new(ConcatenatedString, args);                  end
 
-  def self.SUBLOCATE(token, expr)        new(SubLocatedExpression, token, expr);         end
-
   def self.LIST(entries);                new(LiteralList, entries);                      end
 
   def self.PARAM(name, expr=nil);        new(Parameter, name, expr);                     end
@@ -745,6 +787,19 @@ class Factory
     o.instance_of?(Factory) && o.model_class <= QualifiedReference ? self : new(QualifiedReference, o)
   end
 
+  def self.SUBLOCATE(token, expr_factory)
+    # expr is a Factory wrapped LiteralString, or ConcatenatedString
+    # The token is SUBLOCATED token which has a SubLocator as the token's locator
+    # Use the SubLocator to recalculate the offsets and lengths.
+    model = expr_factory.model
+    locator = token.locator
+    expr_factory.map_offset(model, locator)
+    model._pcore_all_contents([]) { |element| expr_factory.map_offset(element, locator) }
+
+    # Returned the factory wrapping the now offset/length transformed expression(s)
+    expr_factory
+  end
+
   def self.TEXT(expr)
     new(TextExpression, infer(expr).interpolate)
   end
@@ -781,7 +836,8 @@ class Factory
   end
 
   def self.NUMBER(name_or_numeric)
-    if n_radix = Utils.to_n_with_radix(name_or_numeric)
+    n_radix = Utils.to_n_with_radix(name_or_numeric)
+    if n_radix
       val, radix = n_radix
       if val.is_a?(Float)
         new(LiteralFloat, val)
@@ -799,7 +855,8 @@ class Factory
   # Convert input string to either a qualified name, a LiteralInteger with radix, or a LiteralFloat
   #
   def self.QNAME_OR_NUMBER(name)
-    if n_radix = Utils.to_n_with_radix(name)
+    n_radix = Utils.to_n_with_radix(name)
+    if n_radix
       val, radix = n_radix
       if val.is_a?(Float)
         new(LiteralFloat, val)
@@ -823,6 +880,17 @@ class Factory
     new(ExportedQuery, query_expr)
   end
 
+  def self.ARGUMENTS(args, arg)
+    if !args.empty? && arg.model_class <= LiteralHash && arg.unfolded
+      last = args[args.size() - 1]
+      if last.model_class <= LiteralHash && last.unfolded
+        last['entries'].concat(arg['entries'])
+        return args
+      end
+    end
+    args.push(arg)
+  end
+
   def self.ATTRIBUTE_OP(name, op, expr)
     new(AttributeOperation, name, op, expr)
   end
@@ -907,6 +975,18 @@ class Factory
     new(Application, name, parameters, body)
   end
 
+  def self.PLAN(name, parameters, body)
+    new(PlanDefinition, name, parameters, body, nil)
+  end
+
+  def self.APPLY(arguments, body)
+    new(ApplyExpression, arguments, body)
+  end
+
+  def self.APPLY_BLOCK(statements)
+    new(ApplyBlockExpression, statements)
+  end
+
   def self.FUNCTION(name, parameters, body, return_type)
     new(FunctionDefinition, name, parameters, body, return_type)
   end
@@ -1077,7 +1157,7 @@ class Factory
   end
 
   def self.concat(*args)
-    result = ''
+    result = ''.dup
     args.each do |e|
       if e.instance_of?(Factory) && e.model_class <= LiteralString
         result << e[KEY_VALUE]

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

@@ -56,10 +56,12 @@ class ModelLabelProvider
   def label_UnaryMinusExpression o        ; "Unary Minus"                       end
   def label_UnfoldExpression o            ; "Unfold"                            end
   def label_BlockExpression o             ; "Block Expression"                  end
+  def label_ApplyBlockExpression o        ; "Apply Block Expression"            end
   def label_ConcatenatedString o          ; "Double Quoted String"              end
   def label_HeredocExpression o           ; "'@(#{o.syntax})' expression"       end
   def label_HostClassDefinition o         ; "Host Class Definition"             end
   def label_FunctionDefinition o          ; "Function Definition"               end
+  def label_PlanDefinition o              ; "Plan Definition"                   end
   def label_NodeDefinition o              ; "Node Definition"                   end
   def label_SiteDefinition o              ; "Site Definition"                   end
   def label_ResourceTypeDefinition o      ; "'define' expression"               end
@@ -70,6 +72,7 @@ class ModelLabelProvider
   def label_UnlessExpression o            ; "'unless' Statement"                end
   def label_CallNamedFunctionExpression o ; "Function Call"                     end
   def label_CallMethodExpression o        ; "Method call"                       end
+  def label_ApplyExpression o             ; "'apply' expression"                end
   def label_CapabilityMapping o           ; "Capability Mapping"                end
   def label_CaseExpression o              ; "'case' statement"                  end
   def label_CaseOption o                  ; "Case Option"                       end
@@ -103,6 +106,8 @@ class ModelLabelProvider
   def label_Sensitive o                   ; "Sensitive"                         end
   def label_Timestamp o                   ; "Timestamp"                         end
   def label_Timespan o                    ; "Timespan"                          end
+  def label_Version o                     ; "Semver"                            end
+  def label_VersionRange o                ; "SemverRange"                       end
 
   def label_PResourceType o
     if o.title
@@ -123,7 +128,10 @@ class ModelLabelProvider
       simple_name[1..-5] + "-Type"
     else
       n = o.name
-      n.nil? ? 'Anonymous Class' : n
+      if n.nil?
+        n = o.respond_to?(:_pcore_type) ? o._pcore_type.name : 'Anonymous Class'
+      end
+      n
     end
   end
 end

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

@@ -28,6 +28,10 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     o.value.to_s
   end
 
+  def dump_QualifiedReference o
+    o.cased_value.to_s
+  end
+
   def dump_Factory o
     o['locator'] ||= Puppet::Pops::Parser::Locator.locator("<not from source>", nil)
     do_dump(o.model)
@@ -209,7 +213,7 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
   end
 
   def dump_HeredocExpression(o)
-    result = ["@(#{o.syntax})", :indent, :break, do_dump(o.text_expr), :dedent, :break]
+    ["@(#{o.syntax})", :indent, :break, do_dump(o.text_expr), :dedent, :break]
   end
 
   def dump_HostClassDefinition o
@@ -224,6 +228,17 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     result
   end
 
+  def dump_PlanDefinition o
+    result = ["plan", o.name]
+    result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
+    if o.body
+      result << do_dump(o.body)
+    else
+      result << []
+    end
+    result
+  end
+
   def dump_NodeDefinition o
     result = ["node"]
     result << ["matches"] + o.host_matches.collect {|m| do_dump(m) }

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

@@ -0,0 +1,401 @@
+require 'puppet/concurrent/thread_local_singleton'
+
+module Puppet::Pops
+module Model
+
+
+class PNTransformer
+  extend Puppet::Concurrent::ThreadLocalSingleton
+
+  def self.transform(ast)
+    singleton.transform(ast)
+  end
+
+  def initialize
+    @visitor = Visitor.new(nil, 'transform', 0, 0)
+  end
+
+  def transform(ast)
+    @visitor.visit_this_0(self, ast)
+  end
+
+  def transform_AccessExpression(e)
+    PN::List.new([transform(e.left_expr)] + pn_array(e.keys)).as_call('access')
+  end
+
+  def transform_AndExpression(e)
+    binary_op(e, 'and')
+  end
+
+  def transform_Application(e)
+    definition_to_pn(e, 'application')
+  end
+
+  def transform_ArithmeticExpression(e)
+    binary_op(e, e.operator)
+  end
+
+  def transform_Array(a)
+    PN::List.new(pn_array(a))
+  end
+
+  def transform_AssignmentExpression(e)
+    binary_op(e, e.operator)
+  end
+
+  def transform_AttributeOperation(e)
+    PN::Call.new(e.operator, PN::Literal.new(e.attribute_name), transform(e.value_expr))
+  end
+
+  def transform_AttributesOperation(e)
+    PN::Call.new('splat-hash', transform(e.expr))
+  end
+
+  def transform_BlockExpression(e)
+    transform(e.statements).as_call('block')
+  end
+
+  def transform_CallFunctionExpression(e)
+    call_to_pn(e, 'call-lambda', 'invoke-lambda')
+  end
+
+  def transform_CallMethodExpression(e)
+    call_to_pn(e, 'call-method', 'invoke-method')
+  end
+
+  def transform_CallNamedFunctionExpression(e)
+    call_to_pn(e, 'call', 'invoke')
+  end
+
+  def transform_CapabilityMapping(e)
+    PN::Call.new(e.kind, transform(e.component), PN::List.new([PN::Literal.new(e.capability)] + pn_array(e.mappings)))
+  end
+
+  def transform_CaseExpression(e)
+    PN::Call.new('case', transform(e.test), transform(e.options))
+  end
+
+  def transform_CaseOption(e)
+    PN::Map.new([transform(e.values).with_name('when'), block_as_entry('then', e.then_expr)])
+  end
+
+  def transform_CollectExpression(e)
+    entries = [transform(e.type_expr).with_name('type'), transform(e.query).with_name('query')]
+    entries << transform(e.operations).with_name('ops') unless e.operations.empty?
+    PN::Map.new(entries).as_call('collect')
+  end
+
+  def transform_ComparisonExpression(e)
+    binary_op(e, e.operator)
+  end
+
+  def transform_ConcatenatedString(e)
+    transform(e.segments).as_call('concat')
+  end
+
+  def transform_EppExpression(e)
+    e.body.nil? ? PN::Call.new('epp') : transform(e.body).as_call('epp')
+  end
+
+  def transform_ExportedQuery(e)
+    is_nop?(e.expr) ? PN::Call.new('exported-query') : PN::Call.new('exported-query', transform(e.expr))
+  end
+
+  def transform_Factory(e)
+    transform(e.model)
+  end
+
+  def transform_FunctionDefinition(e)
+    definition_to_pn(e, 'function', nil, e.return_type)
+  end
+
+  def transform_HeredocExpression(e)
+    entries = []
+    entries << PN::Literal.new(e.syntax).with_name('syntax') unless e.syntax == ''
+    entries << transform(e.text_expr).with_name('text')
+    PN::Map.new(entries).as_call('heredoc')
+  end
+
+  def transform_HostClassDefinition(e)
+    definition_to_pn(e, 'class', e.parent_class)
+  end
+
+  def transform_IfExpression(e)
+    if_to_pn(e, 'if')
+  end
+
+  def transform_InExpression(e)
+    binary_op(e, 'in')
+  end
+
+  def transform_KeyedEntry(e)
+    PN::Call.new('=>', transform(e.key), transform(e.value))
+  end
+
+  def transform_LambdaExpression(e)
+    entries = []
+    entries << parameters_entry(e.parameters) unless e.parameters.empty?
+    entries << transform(e.return_type).with_name('returns') unless e.return_type.nil?
+    entries << block_as_entry('body', e.body) unless e.body.nil?
+    PN::Map.new(entries).as_call('lambda')
+  end
+
+  def transform_LiteralBoolean(e)
+    PN::Literal.new(e.value)
+  end
+
+  def transform_LiteralDefault(_)
+    PN::Call.new('default')
+  end
+
+  def transform_LiteralFloat(e)
+    PN::Literal.new(e.value)
+  end
+
+  def transform_LiteralHash(e)
+    transform(e.entries).as_call('hash')
+  end
+
+  def transform_LiteralInteger(e)
+    vl = PN::Literal.new(e.value)
+    e.radix == 10 ? vl : PN::Map.new([PN::Literal.new(e.radix).with_name('radix'), vl.with_name('value')]).as_call('int')
+  end
+
+  def transform_LiteralList(e)
+    transform(e.values).as_call('array')
+  end
+
+  def transform_LiteralRegularExpression(e)
+    PN::Literal.new(Types::PRegexpType.regexp_to_s(e.value)).as_call('regexp')
+  end
+
+  def transform_LiteralString(e)
+    PN::Literal.new(e.value)
+  end
+
+  def transform_LiteralUndef(_)
+    PN::Literal.new(nil)
+  end
+
+  def transform_MatchExpression(e)
+    binary_op(e, e.operator)
+  end
+
+  def transform_NamedAccessExpression(e)
+    binary_op(e, '.')
+  end
+
+  def transform_NodeDefinition(e)
+    entries = [transform(e.host_matches).with_name('matches')]
+    entries << transform(e.parent).with_name('parent') unless e.parent.nil?
+    entries << block_as_entry('body', e.body) unless e.body.nil?
+    PN::Map.new(entries).as_call('node')
+  end
+
+  def transform_Nop(_)
+    PN::Call.new('nop')
+  end
+
+  # Some elements may have a nil element instead of a Nop Expression
+  def transform_NilClass(e)
+    PN::Call.new('nop')
+  end
+
+  def transform_NotExpression(e)
+    PN::Call.new('!', transform(e.expr))
+  end
+
+  def transform_OrExpression(e)
+    binary_op(e, 'or')
+  end
+
+  def transform_Parameter(e)
+    entries = [PN::Literal.new(e.name).with_name('name')]
+    entries << transform(e.type_expr).with_name('type') unless e.type_expr.nil?
+    entries << PN::Literal.new(true).with_name('splat') if e.captures_rest
+    entries << transform(e.value).with_name('value') unless e.value.nil?
+    PN::Map.new(entries).with_name('param')
+  end
+
+  def transform_ParenthesizedExpression(e)
+    PN::Call.new('paren', transform(e.expr))
+  end
+
+  def transform_PlanDefinition(e)
+    definition_to_pn(e, 'plan', nil, e.return_type)
+  end
+
+  def transform_Program(e)
+    transform(e.body)
+  end
+
+  def transform_QualifiedName(e)
+    PN::Call.new('qn', PN::Literal.new(e.value))
+  end
+
+  def transform_QualifiedReference(e)
+    PN::Call.new('qr', PN::Literal.new(e.cased_value))
+  end
+
+  def transform_RelationshipExpression(e)
+    binary_op(e, e.operator)
+  end
+
+  def transform_RenderExpression(e)
+    PN::Call.new('render', transform(e.expr))
+  end
+
+  def transform_RenderStringExpression(e)
+    PN::Literal.new(e.value).as_call('render-s')
+  end
+
+  def transform_ReservedWord(e)
+    PN::Literal.new(e.word).as_call('reserved')
+  end
+
+  def transform_ResourceBody(e)
+    PN::Map.new([
+      transform(e.title).with_name('title'),
+      transform(e.operations).with_name('ops')
+    ]).as_call('resource_body')
+  end
+
+  def transform_ResourceDefaultsExpression(e)
+    entries = [transform(e.type_ref).with_name('type'), transform(e.operations).with_name('ops')]
+    entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
+    PN::Map.new(entries).as_call('resource-defaults')
+  end
+
+  def transform_ResourceExpression(e)
+    entries = [
+      transform(e.type_name).with_name('type'),
+      PN::List.new(pn_array(e.bodies).map { |body| body[0] }).with_name('bodies')
+    ]
+    entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
+    PN::Map.new(entries).as_call('resource')
+  end
+
+  def transform_ResourceOverrideExpression(e)
+    entries = [transform(e.resources).with_name('resources'), transform(e.operations).with_name('ops')]
+    entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
+    PN::Map.new(entries).as_call('resource-override')
+  end
+
+  def transform_ResourceTypeDefinition(e)
+    definition_to_pn(e, 'define')
+  end
+
+  def transform_SelectorEntry(e)
+    PN::Call.new('=>', transform(e.matching_expr), transform(e.value_expr))
+  end
+
+  def transform_SelectorExpression(e)
+    PN::Call.new('?', transform(e.left_expr), transform(e.selectors))
+  end
+
+  def transform_SiteDefinition(e)
+    transform(e.body).as_call('site')
+  end
+
+  def transform_SubLocatedExpression(e)
+    transform(e.expr)
+  end
+
+  def transform_TextExpression(e)
+    PN::Call.new('str', transform(e.expr))
+  end
+
+  def transform_TypeAlias(e)
+    PN::Call.new('type-alias', PN::Literal.new(e.name), transform(e.type_expr))
+  end
+
+  def transform_TypeDefinition(e)
+    PN::Call.new('type-definition', PN::Literal.new(e.name), PN::Literal.new(e.parent), transform(e.body))
+  end
+
+  def transform_TypeMapping(e)
+    PN::Call.new('type-mapping', transform(e.type_expr), transform(e.mapping_expr))
+  end
+
+  def transform_UnaryMinusExpression(e)
+    if e.expr.is_a?(LiteralValue)
+      v = e.expr.value
+      if v.is_a?(Numeric)
+        return PN::Literal.new(-v)
+      end
+    end
+    PN::Call.new('-', transform(e.expr))
+  end
+
+  def transform_UnfoldExpression(e)
+    PN::Call.new('unfold', transform(e.expr))
+  end
+
+  def transform_UnlessExpression(e)
+    if_to_pn(e, 'unless')
+  end
+
+  def transform_VariableExpression(e)
+    ne = e.expr
+    PN::Call.new('var', ne.is_a?(Model::QualifiedName) ? PN::Literal.new(ne.value) : transform(ne))
+  end
+
+  def transform_VirtualQuery(e)
+    is_nop?(e.expr) ? PN::Call.new('virtual-query') : PN::Call.new('virtual-query', transform(e.expr))
+  end
+
+  def is_nop?(e)
+    e.nil? || e.is_a?(Nop)
+  end
+
+  def binary_op(e, op)
+    PN::Call.new(op, transform(e.left_expr), transform(e.right_expr))
+  end
+
+  def definition_to_pn(e, type_name, parent = nil, return_type = nil)
+    entries = [PN::Literal.new(e.name).with_name('name')]
+    entries << PN::Literal.new(parent).with_name('parent') unless parent.nil?
+    entries << parameters_entry(e.parameters) unless e.parameters.empty?
+    entries << block_as_entry('body', e.body) unless e.body.nil?
+    entries << transform(return_type).with_name('returns') unless return_type.nil?
+    PN::Map.new(entries).as_call(type_name)
+  end
+
+  def parameters_entry(parameters)
+    PN::Map.new(parameters.map do |p|
+      entries = []
+      entries << transform(p.type_expr).with_name('type') unless p.type_expr.nil?
+      entries << PN::Literal(true).with_name('splat') if p.captures_rest
+      entries << transform(p.value).with_name('value') unless p.value.nil?
+      PN::Map.new(entries).with_name(p.name)
+    end).with_name('params')
+  end
+
+  def block_as_entry(name, expr)
+    if expr.is_a?(BlockExpression)
+      transform(expr.statements).with_name(name)
+    else
+      transform([expr]).with_name(name)
+    end
+  end
+
+  def pn_array(a)
+    a.map { |e| transform(e) }
+  end
+
+  def call_to_pn(e, r, nr)
+    entries = [transform(e.functor_expr).with_name('functor'), transform(e.arguments).with_name('args')]
+    entries << transform(e.lambda).with_name('block') unless e.lambda.nil?
+    PN::Map.new(entries).as_call(e.rval_required ? r : nr)
+  end
+
+  def if_to_pn(e, name)
+    entries = [transform(e.test).with_name('test')]
+    entries << block_as_entry('then', e.then_expr) unless is_nop?(e.then_expr)
+    entries << block_as_entry('else', e.else_expr) unless is_nop?(e.else_expr)
+    PN::Map.new(entries).as_call(name)
+  end
+end
+
+end
+end