bolt 0.17.1 → 0.17.2

data/vendored/puppet/lib/puppet/parser/parser_factory.rb

@@ -16,7 +16,7 @@ module Puppet::Parser
     # EvaluatingParser to the 3x way of parsing.
     #
     def self.evaluating_parser
-      unless defined?(Puppet::Pops::Parser::E4ParserAdapter)
+      unless defined?(Puppet::Parser::E4ParserAdapter)
         require 'puppet/parser/e4_parser_adapter'
         require 'puppet/pops/parser/code_merger'
       end

data/vendored/puppet/lib/puppet/parser/resource.rb

@@ -332,7 +332,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   def add_scope_tags
     scope_resource = scope.resource
     unless scope_resource.nil? || scope_resource.equal?(self)
-      merge_tags(scope_resource)
+      merge_tags_from(scope_resource)
     end
   end
 

data/vendored/puppet/lib/puppet/parser/type_loader.rb

@@ -110,20 +110,20 @@ class Puppet::Parser::TypeLoader
     # There is currently one user in indirector/resourcetype/parser
     #
     if Puppet.lookup(:squelch_parse_errors) {|| false }
-        begin
-          loaded_asts << parse_file(file)
-        rescue => e
-          # Resume from errors so that all parseable files may
-          # still be parsed. Mark this file as loaded so that
-          # it would not be parsed next time (handle it as if
-          # it was successfully parsed).
-          Puppet.debug("Unable to parse '#{file}': #{e.message}")
-        end
-      else
+      begin
         loaded_asts << parse_file(file)
+      rescue => e
+        # Resume from errors so that all parseable files may
+        # still be parsed. Mark this file as loaded so that
+        # it would not be parsed next time (handle it as if
+        # it was successfully parsed).
+        Puppet.debug("Unable to parse '#{file}': #{e.message}")
       end
+    else
+      loaded_asts << parse_file(file)
+    end
 
-      @loaded[file] = true
+    @loaded[file] = true
     end
 
     loaded_asts.collect do |ast|

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

@@ -80,7 +80,7 @@ class Closure < CallableSignature
 
   def call_by_name_with_scope(scope, args_hash, enforce_parameters)
     call_by_name_internal(scope, args_hash, enforce_parameters)
-   end
+  end
 
   def call_by_name(args_hash, enforce_parameters)
     call_by_name_internal(enclosing_scope, args_hash, enforce_parameters)

data/vendored/puppet/lib/puppet/pops/evaluator/collector_transformer.rb

@@ -124,7 +124,7 @@ protected
     end
   end
 
- def query_AccessExpression(o, scope)
+  def query_AccessExpression(o, scope)
     pops_object = @@evaluator.evaluate(o, scope)
 
     # Convert to Puppet 3 style objects since that is how they are represented

data/vendored/puppet/lib/puppet/pops/evaluator/epp_evaluator.rb

@@ -53,8 +53,6 @@ class Puppet::Pops::Evaluator::EppEvaluator
     evaluate(parser, 'epp', scope, true, result, template_args)
   end
 
-  private
-
   def self.evaluate(parser, func_name, scope, use_global_scope_only, parse_result, template_args)
     template_args, template_args_set = handle_template_args(func_name, template_args)
 
@@ -104,6 +102,7 @@ class Puppet::Pops::Evaluator::EppEvaluator
       parser.closure(body, scope).call_by_name(template_args, enforce_parameters)
     end
   end
+  private_class_method :evaluate
 
   def self.handle_template_args(func_name, template_args)
     if template_args.nil?
@@ -117,4 +116,5 @@ class Puppet::Pops::Evaluator::EppEvaluator
       [template_args, true]
     end
   end
+  private_class_method :handle_template_args
 end

data/vendored/puppet/lib/puppet/pops/evaluator/runtime3_resource_support.rb

@@ -89,8 +89,6 @@ module Runtime3ResourceSupport
     scope.environment.known_resource_types.find_hostclass(class_name)
   end
 
-  private
-
   def self.find_builtin_resource_type(scope, type_name)
     if type_name.include?(':')
       # Skip the search for built in types as they are always in global namespace
@@ -106,11 +104,13 @@ module Runtime3ResourceSupport
     # horrible - should be loaded by a "last loader" in 4.x loaders instead.
     Puppet::Type.type(type_name)
   end
+  private_class_method :find_builtin_resource_type
 
   def self.find_defined_resource_type(scope, type_name)
     krt = scope.environment.known_resource_types
     krt.find_definition(type_name) || krt.application(type_name)
   end
+  private_class_method :find_defined_resource_type
 
 end
 end

data/vendored/puppet/lib/puppet/pops/evaluator/runtime3_support.rb

@@ -301,10 +301,13 @@ module Runtime3Support
   def call_function(name, args, o, scope, &block)
     file, line = extract_file_line(o)
     loader = Adapters::LoaderAdapter.loader_for_model_object(o, file)
-    if loader && func = loader.load(:function, name)
+    # 'ruby -wc' thinks that _func is unused, because the only reference to it
+    # is inside of the Kernel.eval string below. By prefixing it with the
+    # underscore, we let Ruby know to not worry about whether it's unused or not.
+    if loader && _func = loader.load(:function, name)
       Puppet::Util::Profiler.profile(name, [:functions, name]) do
         # Add stack frame when calling. See Puppet::Pops::PuppetStack
-        return Kernel.eval('func.call(scope, *args, &block)', Kernel.binding, file || '', line)
+        return Kernel.eval('_func.call(scope, *args, &block)'.freeze, Kernel.binding, file || '', line)
       end
     end
     # Call via 3x API if function exists there

data/vendored/puppet/lib/puppet/pops/functions/dispatch.rb

@@ -1,5 +1,5 @@
 module Puppet::Pops
-  module Functions
+module Functions
 # Defines a connection between a implementation method and the signature that
 # the method will handle.
 #

data/vendored/puppet/lib/puppet/pops/issue_reporter.rb

@@ -86,6 +86,22 @@ class IssueReporter
     [prefix, message].join(' ')
   end
 
+  def self.warning(semantic, issue, args)
+    Puppet::Util::Log.create({
+      :level => :warning,
+      :message => issue.format(args),
+      :arguments => args,
+      :issue_code => issue.issue_code,
+      :file => semantic.file,
+      :line => semantic.line,
+      :pos => semantic.pos,
+    })
+  end
+
+  def self.error(exception_class, semantic, issue, args)
+    raise exception_class.new(issue.format(args), semantic.file, semantic.line, semantic.pos, nil, issue.issue_code, args)
+  end
+
   def self.create_exception(exception_class, emit_message, formatter, diagnostic)
     file = diagnostic.file
     file = (file.is_a?(String) && file.empty?) ? nil : file
@@ -94,7 +110,7 @@ class IssueReporter
       line = diagnostic.source_pos.line
       pos = diagnostic.source_pos.pos
     end
-    exception_class.new(format_with_prefix(emit_message, formatter.format_message(diagnostic)), file, line, pos, nil, diagnostic.issue.issue_code)
+    exception_class.new(format_with_prefix(emit_message, formatter.format_message(diagnostic)), file, line, pos, nil, diagnostic.issue.issue_code, diagnostic.arguments)
   end
   private_class_method :create_exception
 
@@ -109,6 +125,7 @@ class IssueReporter
     Puppet::Util::Log.create({
         :level => severity,
         :message => formatter.format_message(diagnostic),
+        :arguments => diagnostic.arguments,
         :issue_code => diagnostic.issue.issue_code,
         :file => file,
         :line => line,

data/vendored/puppet/lib/puppet/pops/issues.rb

@@ -49,7 +49,6 @@ module Issues
         # Evaluate the message block in the msg data's binding
         msgdata.format(hash, &message_block)
       rescue StandardError => e
-        MessageData
         raise RuntimeError, _("Error while reporting issue: %{code}. %{message}") % { code: issue_code, message: e.message }, caller
       end
     end
@@ -71,7 +70,7 @@ module Issues
 
     def format(hash, &block)
       @data = hash
-      instance_eval &block
+      instance_eval(&block)
     end
 
     # Obtains the label provider given as a key `:label` in the hash passed to #format. The label provider is
@@ -119,7 +118,7 @@ module Issues
   # @see MessageData
   # @api public
   #
-  def self.issue (issue_code, *args, &block)
+  def self.issue(issue_code, *args, &block)
     Issue.new(issue_code, *args, &block)
   end
 
@@ -741,6 +740,10 @@ module Issues
     _('Heredoc without any following lines of text')
   end
 
+  HEREDOC_EMPTY_ENDTAG = hard_issue :HEREDOC_EMPTY_ENDTAG do
+    _('Heredoc with an empty endtag')
+  end
+
   HEREDOC_MULTIPLE_AT_ESCAPES = hard_issue :HEREDOC_MULTIPLE_AT_ESCAPES, :escapes do
     _("An escape char for @() may only appear once. Got '%{escapes}'") % { escapes: escapes.join(', ') }
   end

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

@@ -29,12 +29,11 @@ class Puppet::Pops::Loader::RubyDataTypeInstantiator
     created
   end
 
-  private
-
   # Produces a binding where the given loader is bound as a local variable (loader_injected_arg). This variable can be used in loaded
   # ruby code - e.g. to call Puppet::Function.create_loaded_function(:name, loader,...)
   #
   def self.get_binding(loader_injected_arg)
     binding
   end
+  private_class_method :get_binding
 end

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

@@ -35,12 +35,11 @@ class Puppet::Pops::Loader::RubyFunctionInstantiator
     created.new(nil, loader_for_function)
   end
 
-  private
-
   # Produces a binding where the given loader is bound as a local variable (loader_injected_arg). This variable can be used in loaded
   # ruby code - e.g. to call Puppet::Function.create_loaded_function(:name, loader,...)
   #
   def self.get_binding(loader_injected_arg)
     binding
   end
+  private_class_method :get_binding
 end

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

@@ -27,11 +27,11 @@ class TaskInstantiator
 
   def self.create_task(loader, name, task_source, metadata)
     if metadata.nil?
-      create_task_from_hash(loader, name, task_source, EMPTY_HASH)
+      create_task_from_hash(name, task_source, EMPTY_HASH)
     else
       json_text = loader.get_contents(metadata)
       begin
-        create_task_from_hash(loader, name, task_source, JSON.parse(json_text) || EMPTY_HASH)
+        create_task_from_hash(name, task_source, JSON.parse(json_text) || EMPTY_HASH)
       rescue JSON::ParserError => ex
         raise Puppet::ParseError.new(ex.message, metadata)
       rescue Types::TypeAssertionError => ex
@@ -43,7 +43,7 @@ class TaskInstantiator
     end
   end
 
-  def self.create_task_from_hash(loader, name, task_source, hash)
+  def self.create_task_from_hash(name, task_source, hash)
     arguments = {
       'name' => name,
       'executable' => task_source
@@ -54,7 +54,7 @@ class TaskInstantiator
         value.each_pair do |k, v|
           pd = v.dup
           t = v['type']
-          pd['type'] = t.nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(t, loader)
+          pd['type'] = t.nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(t)
           ps[k] = pd
         end
         value = ps

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

@@ -73,7 +73,9 @@ class TypeDefinitionInstantiator
     case type_name
     when 'Object'
       # No need for an alias. The Object type itself will receive the name instead
-      type_expr = type_expr.keys.empty? ? nil : type_expr.keys[0] unless type_expr.is_a?(Hash)
+      unless type_expr.is_a?(Model::LiteralHash)
+        type_expr = type_expr.keys.empty? ? nil : type_expr.keys[0] unless type_expr.is_a?(Hash)
+      end
       Types::PObjectType.new(name, type_expr)
     when 'TypeSet'
       # No need for an alias. The Object type itself will receive the name instead
@@ -86,6 +88,7 @@ class TypeDefinitionInstantiator
 
   # @api private
   def self.named_definition(te)
+    return 'Object' if te.is_a?(Model::LiteralHash)
     te.is_a?(Model::AccessExpression) && (left = te.left_expr).is_a?(Model::QualifiedReference) ? left.cased_value : nil
   end
 

data/vendored/puppet/lib/puppet/pops/loaders.rb

@@ -15,7 +15,6 @@ class Loaders
   attr_reader :puppet_system_loader
   attr_reader :public_environment_loader
   attr_reader :private_environment_loader
-  attr_reader :implementation_registry
   attr_reader :environment
 
   def self.new(environment, for_agent = false)
@@ -55,12 +54,9 @@ class Loaders
       create_environment_loader(environment)
     end
 
-    # 3. The implementation registry maintains mappings between Puppet types and Runtime types for
-    #    the current environment
-    @implementation_registry = Types::ImplementationRegistry.new(@private_environment_loader)
-    Pcore.init(@puppet_system_loader, @implementation_registry, for_agent)
+    Pcore.init_env(@private_environment_loader)
 
-    # 4. module loaders are set up from the create_environment_loader, they register themselves
+    # 3. module loaders are set up from the create_environment_loader, they register themselves
   end
 
   # Called after loader has been added to Puppet Context as :loaders so that dynamic types can
@@ -91,11 +87,21 @@ class Loaders
     loaders.find_loader(module_name)
   end
 
+  def self.static_implementation_registry
+    if !class_variable_defined?(:@@static_implementation_registry) || @@static_implementation_registry.nil?
+      ir = Types::ImplementationRegistry.new
+      Types::TypeParser.type_map.values.each { |t| ir.register_implementation(t.simple_name, t.class.name) }
+      @@static_implementation_registry = ir
+    end
+    @@static_implementation_registry
+  end
+
   def self.static_loader
     # The static loader can only be changed after a reboot
     if !class_variable_defined?(:@@static_loader) || @@static_loader.nil?
       @@static_loader = Loader::StaticLoader.new()
       @@static_loader.register_aliases
+      Pcore.init(@@static_loader, static_implementation_registry)
     end
     @@static_loader
   end
@@ -206,6 +212,11 @@ class Loaders
     end
   end
 
+  def implementation_registry
+    # Environment specific implementation registry
+    @implementation_registry ||= Types::ImplementationRegistry.new(self.class.static_implementation_registry)
+  end
+
   def static_loader
     self.class.static_loader
   end
@@ -337,7 +348,7 @@ class Loaders
     tf = Types::TypeParser.singleton
     lhs = tf.interpret(type_mapping.type_expr, loader)
     rhs = tf.interpret_any(type_mapping.mapping_expr, loader)
-    implementation_registry.register_type_mapping(lhs, rhs, loader)
+    implementation_registry.register_type_mapping(lhs, rhs)
     nil
   end
 

data/vendored/puppet/lib/puppet/pops/lookup/global_data_provider.rb

@@ -1,3 +1,4 @@
+require 'hiera/scope'
 require_relative 'configured_data_provider'
 
 module Puppet::Pops
@@ -11,7 +12,6 @@ class GlobalDataProvider < ConfiguredDataProvider
   def unchecked_key_lookup(key, lookup_invocation, merge)
     config = config(lookup_invocation)
     if(config.version == 3)
-      require 'hiera/scope'
       # Hiera version 3 needs access to special scope variables
       scope = lookup_invocation.scope
       unless scope.is_a?(Hiera::Scope)

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

@@ -179,7 +179,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)
@@ -452,10 +453,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:
       #

data/vendored/puppet/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)

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

@@ -0,0 +1,400 @@
+module Puppet::Pops
+module Model
+
+
+class PNTransformer
+  def self.visitor
+    @visitor ||= Visitor.new(nil, 'transform', 0, 0)
+  end
+
+  def self.singleton
+    @singleton ||= new(visitor)
+  end
+
+  def self.transform(ast)
+    singleton.transform(ast)
+  end
+
+  def initialize(visitor)
+    @visitor = visitor
+  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
+
+  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