puppet 4.0.0 → 4.5.0

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

@@ -19,9 +19,18 @@ module Puppet::Pops
   module Model
 
     class PopsObject
-      include Puppet::Pops::Visitable
-      include Puppet::Pops::Adaptable
-      include Puppet::Pops::Containment
+      include Visitable
+      include Adaptable
+      include Containment
+    end
+
+    class Positioned
+      module ClassModule
+        def set_loc(offset, length)
+          @offset = offset
+          @length = length
+        end
+      end
     end
 
     class LocatableExpression
@@ -34,7 +43,7 @@ module Puppet::Pops
         #
         def locator
           unless result = getLocator
-            setLocator(result = Puppet::Pops::Parser::Locator.locator(source_text, source_ref(), line_offsets))
+            setLocator(result = Parser::Locator.locator(source_text, source_ref(), line_offsets))
           end
           result
         end
@@ -46,18 +55,18 @@ module Puppet::Pops
         def locator
           unless result = getLocator
             # Adapt myself to get the Locator for me
-            adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(self)
+            adapter = Adapters::SourcePosAdapter.adapt(self)
             # Get the program (root), and deal with case when not contained in a program
             program = eAllContainers.find {|c| c.is_a?(Program) }
             source_ref = program.nil? ? '' : program.source_ref
 
             # An outer locator is needed since SubLocator only deals with offsets. This outer locator
             # has 0,0 as origin.
-            outer_locator = Puppet::Pops::Parser::Locator.locator(adpater.extract_text, source_ref, line_offsets)
+            outer_locator = Parser::Locator.locator(adpater.extract_text, source_ref, line_offsets)
 
             # Create a sublocator that describes an offset from the outer
             # NOTE: the offset of self is the same as the sublocator's leading_offset
-            result = Puppet::Pops::Parser::Locator::SubLocator.new(outer_locator,
+            result = Parser::Locator::SubLocator.new(outer_locator,
               leading_line_count, offset, leading_line_offset)
             setLocator(result)
           end
@@ -98,11 +107,19 @@ module Puppet::Pops
       end
     end
 
+    class QualifiedReference
+      module ClassModule
+        def value
+          @value ||= cased_value.downcase
+        end
+      end
+    end
+
     class Program < PopsObject
       module ClassModule
         def locator
           unless result = getLocator
-            setLocator(result = Puppet::Pops::Parser::Locator.locator(source_text, source_ref(), line_offsets, char_offsets))
+            setLocator(result = Parser::Locator.locator(source_text, source_ref(), line_offsets, char_offsets))
           end
           result
         end

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

@@ -1,10 +1,14 @@
+module Puppet::Pops
+module Model
 # A provider of labels for model object, producing a human name for the model object.
 # As an example, if object is an ArithmeticExpression with operator +, `#a_an(o)` produces "a '+' Expression",
 # #the(o) produces "the + Expression", and #label produces "+ Expression".
 #
-class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
+class ModelLabelProvider
+  include LabelProvider
+
   def initialize
-    @@label_visitor ||= Puppet::Pops::Visitor.new(self,"label",0,0)
+    @@label_visitor ||= Visitor.new(self,"label",0,0)
   end
 
   # Produces a label for the given objects type/operator without article.
@@ -55,7 +59,9 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
   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_NodeDefinition o              ; "Node Definition"                   end
+  def label_SiteDefinition o              ; "Site Definition"                   end
   def label_ResourceTypeDefinition o      ; "'define' expression"               end
   def label_ResourceOverrideExpression o  ; "Resource Override"                 end
   def label_Parameter o                   ; "Parameter Definition"              end
@@ -64,6 +70,7 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
   def label_UnlessExpression o            ; "'unless' Statement"                end
   def label_CallNamedFunctionExpression o ; "Function Call"                     end
   def label_CallMethodExpression o        ; "Method call"                       end
+  def label_CapabilityMapping o           ; "Capability Mapping"                end
   def label_CaseExpression o              ; "'case' statement"                  end
   def label_CaseOption o                  ; "Case Option"                       end
   def label_RenderStringExpression o      ; "Epp Text"                          end
@@ -84,19 +91,29 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
   def label_Hash o                        ; "Hash"                              end
   def label_QualifiedName o               ; "Name"                              end
   def label_QualifiedReference o          ; "Type-Name"                         end
-  def label_PAnyType o                    ; "#{Puppet::Pops::Types::TypeCalculator.string(o)}-Type" end
+  def label_PAnyType o                    ; "#{o}-Type" end
   def label_ReservedWord o                ; "Reserved Word '#{o.word}'"         end
+  def label_CatalogCollector o            ; "Catalog-Collector"                 end
+  def label_ExportedCollector o           ; "Exported-Collector"                end
+  def label_TypeAlias o                   ; "Type Alias"                        end
+  def label_TypeMapping o                 ; "Type Mapping"                      end
+  def label_TypeDefinition o              ; "Type Definition"                   end
 
   def label_PResourceType o
     if o.title
-      "#{Puppet::Pops::Types::TypeCalculator.string(o)} Resource-Reference"
+      "#{o} Resource-Reference"
     else
-      "#{Puppet::Pops::Types::TypeCalculator.string(o)}-Type"
+      "#{o}-Type"
     end
   end
 
+  def label_Resource o
+    'Resource Statement'
+  end
+
+
   def label_Class o
-    if o <= Puppet::Pops::Types::PAnyType
+    if o <= Types::PAnyType
       simple_name = o.name.split('::').last
       simple_name[1..-5] + "-Type"
     else
@@ -104,3 +121,5 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
     end
   end
 end
+end
+end

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

@@ -258,7 +258,7 @@ module Puppet::Pops::Model
   class CollectExpression < Expression
     contains_one_uni 'type_expr', Expression, :lowerBound => 1
     contains_one_uni 'query', QueryExpression, :lowerBound => 1
-    contains_many_uni 'operations', AttributeOperation
+    contains_many_uni 'operations', AbstractAttributeOperation
   end
 
   class Parameter < Positioned
@@ -282,11 +282,41 @@ module Puppet::Pops::Model
     contains_one_uni 'body', Expression
   end
 
+  # A function written in the Puppet Langauge
+  class FunctionDefinition < NamedDefinition
+  end
+
   # A resource type definition (a 'define' in the DSL).
   #
   class ResourceTypeDefinition < NamedDefinition
   end
 
+  class Application < NamedDefinition
+  end
+
+  # Abstract base class for QREF named non-parameterized definitions
+  class QRefDefinition < Definition
+    abstract
+    has_attr 'name', String, :lowerBound => 1
+  end
+
+  # A type alias assignment
+  class TypeAlias < QRefDefinition
+    contains_one_uni 'type_expr', Expression
+  end
+
+  # A type mapping assignment
+  class TypeMapping < Definition
+    contains_one_uni 'type_expr', Expression
+    contains_one_uni 'mapping_expr', Expression
+  end
+
+  # A type definition
+  class TypeDefinition < QRefDefinition
+    has_attr 'parent', String
+    contains_one_uni 'body', Expression
+  end
+
   # A node definition matches hosts using Strings, or Regular expressions. It may inherit from
   # a parent node (also using a String or Regular expression).
   #
@@ -296,6 +326,10 @@ module Puppet::Pops::Model
     contains_one_uni 'body', Expression
   end
 
+  class SiteDefinition < Definition
+    contains_one_uni 'body', Expression
+  end
+
   class LocatableExpression < Expression
     has_many_attr 'line_offsets', Integer
     has_attr 'locator', Object, :lowerBound => 1, :transient => true
@@ -463,15 +497,18 @@ module Puppet::Pops::Model
     has_attr 'value', String, :lowerBound => 1
   end
 
-  # Represents a parsed reserved word
+  # Represents a parsed reserved word. If the 'future' attribute is true
+  # the ReserwedWord functions as a deprecation warning + string value
+  #
   class ReservedWord < LiteralValue
     has_attr 'word', String, :lowerBound => 1
+    has_attr 'future', Boolean
   end
 
   # A DSL CLASSREF (one or multiple parts separated by '::' where (at least) the first part starts with an upper case letter).
   #
   class QualifiedReference < LiteralValue
-    has_attr 'value', String, :lowerBound => 1
+    has_attr 'cased_value', String, :lowerBound => 1
   end
 
   # A Variable expression looks up value of expr (some kind of name) in scope.
@@ -527,6 +564,14 @@ module Puppet::Pops::Model
     contains_many_uni 'bodies', ResourceBody
   end
 
+  class CapabilityMapping < Definition
+    # 'produces' or 'consumes'
+    has_attr 'kind', String, :lowerBound => 1
+    has_attr 'capability', String, :lowerBound => 1
+    contains_one_uni 'component', Expression, :lowerBound => 1
+    contains_many_uni 'mappings', AbstractAttributeOperation
+  end
+
   # A resource defaults sets defaults for a resource type. This class inherits from AbstractResource
   # but does only support the :regular form (this is intentional to be able to produce better error messages
   # when illegal forms are applied to a model.

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

@@ -32,6 +32,10 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     do_dump(o.current)
   end
 
+  def dump_Application o
+    ["application", o.name, do_dump(o.parameters), do_dump(o.body)]
+  end
+
   def dump_ArithmeticExpression o
     [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
   end
@@ -230,6 +234,16 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     result
   end
 
+  def dump_SiteDefinition o
+    result = ["site"]
+    if o.body
+      result << do_dump(o.body)
+    else
+      result << []
+    end
+    result
+  end
+
   def dump_NamedDefinition o
     # the nil must be replaced with a string
     result = [nil, o.name]
@@ -248,6 +262,10 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     result
   end
 
+  def dump_CapabilityMapping o
+    [o.kind, do_dump(o.component), o.capability, do_dump(o.mappings)]
+  end
+
   def dump_ResourceOverrideExpression o
     form = o.form == :regular ? '' : o.form.to_s + "-"
     result = [form+"override", do_dump(o.resources), :indent]
@@ -397,6 +415,18 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     ["sublocated", do_dump(o.expr)]
   end
 
+  def dump_TypeAlias(o)
+    ['type-alias', o.name, do_dump(o.type_expr)]
+  end
+
+  def dump_TypeMapping(o)
+    ['type-mapping', do_dump(o.type_expr), do_dump(o.mapping_expr)]
+  end
+
+  def dump_TypeDefinition(o)
+    ['type-definition', o.name, o.parent, do_dump(o.body)]
+  end
+
   def dump_Object o
     [o.class.to_s, o.to_s]
   end

data/lib/puppet/pops/parser/code_merger.rb

@@ -8,9 +8,21 @@ class Puppet::Pops::Parser::CodeMerger
     # this is a bit brute force as the result is already 3x ast with wrapped 4x content
     # this could be combined in a more elegant way, but it is only used to process a handful of files
     # at the beginning of a puppet run. TODO: Revisit for Puppet 4x when there is no 3x ast at the top.
+    # PUP-5299, some sites have thousands of entries, and run out of stack when evaluating - the logic
+    # below maps the logic as flatly as possible.
     #
     children = parse_results.select {|x| !x.nil? && x.code}.reduce([]) do |memo, parsed_class|
-      memo << parsed_class.code
+      case parsed_class.code
+      when Puppet::Parser::AST::BlockExpression
+        # the BlockExpression wraps a single 4x instruction that is most likely wrapped in a Factory
+        memo += parsed_class.code.children.map {|c| c.is_a?(Puppet::Pops::Model::Factory) ? c.model : c }
+      when Puppet::Pops::Model::Factory
+        # If it is a 4x instruction wrapped in a Factory
+        memo += parsed_class.code.model
+      else
+        # It is the instruction directly
+        memo << parsed_class.code
+      end
     end
     Puppet::Parser::AST::BlockExpression.new(:children => children)
   end

data/lib/puppet/pops/parser/egrammar.ra

@@ -20,7 +20,10 @@ token NUMBER
 token HEREDOC SUBLOCATE
 token RENDER_STRING RENDER_EXPR EPP_START EPP_END EPP_END_TRIM
 token FUNCTION
-token PRIVATE ATTR TYPE
+token TYPE
+token PRIVATE ATTR
+token APPLICATION_R CONSUMES_R PRODUCES_R SITE_R
+token APPLICATION PRODUCES CONSUMES SITE
 token LOW
 
 prechigh
@@ -157,7 +160,7 @@ resource
         # If the attribute operations does not include +>, then the found expression
         # is actually a LEFT followed by LITERAL_HASH
         #
-        unless tmp = transform_resource_wo_title(val[0], val[2])
+        unless tmp = transform_resource_wo_title(val[0], val[2], val[1], val[4])
           error val[1], "Syntax error resource body without title or hash with +>"
         end
         tmp
@@ -191,8 +194,9 @@ resource
 #
 expression
   : primary_expression
+  | capability_mapping
   | call_function_expression
-  | expression LBRACK       expressions RBRACK =LBRACK { result = val[0][*val[2]]         ; loc result, val[0], val[3] }
+  | bracketed_expression
   | expression IN           expression                 { result = val[0].in val[2]        ; loc result, val[1] }
   | expression MATCH        expression                 { result = val[0] =~  val[2]       ; loc result, val[1] }
   | expression NOMATCH      expression                 { result = val[0].mne val[2]       ; loc result, val[1] }
@@ -217,6 +221,8 @@ expression
   | expression QMARK selector_entries                  { result = val[0].select(*val[2])  ; loc result, val[0] }
   |            LPAREN       assignment RPAREN          { result = val[1].paren()          ; loc result, val[0] }
 
+bracketed_expression
+  : expression LBRACK       expressions endcomma RBRACK =LBRACK { result = val[0][*val[2]]         ; loc result, val[0], val[4] }
 
 #---EXPRESSIONS
 #   (i.e. "argument list")
@@ -236,9 +242,16 @@ primary_expression
   | if_expression
   | unless_expression
   | definition_expression
+  # @todo lutter 2014-09-03: application declarations must be at the toplevel
+  # in a manifest - Should be validated, not handled here. helindbe 2015-09-10
+  | application_expression
   | hostclass_expression
   | node_definition_expression
+  | site_definition_expression
   | epp_render_expression
+  | function_definition
+  | type_alias
+  | type_definition
   | reserved_word
   | array
   | hash
@@ -257,25 +270,29 @@ primary_expression
 # Produces Model::CallNamedFunction
 
 call_function_expression
-  : expression LPAREN assignments endcomma RPAREN {
-      result = Factory.CALL_NAMED(val[0], true, val[2])
-      loc result, val[0], val[4]
+  : call_function_start assignments endcomma RPAREN {
+      result = Factory.CALL_NAMED(val[0], true, val[1])
+      loc result, val[0], val[3]
     }
-  | expression LPAREN RPAREN {
+  | call_function_start RPAREN {
       result = Factory.CALL_NAMED(val[0], true, [])
-      loc result, val[0], val[2]
+      loc result, val[0], val[1]
     }
-  | expression LPAREN assignments endcomma RPAREN lambda {
-      result = Factory.CALL_NAMED(val[0], true, val[2])
+  | call_function_start assignments endcomma RPAREN lambda {
+      result = Factory.CALL_NAMED(val[0], true, val[1])
       loc result, val[0], val[4]
-      result.lambda = val[5]
+      result.lambda = val[4]
     }
-  | expression LPAREN RPAREN  lambda {
+  | call_function_start RPAREN  lambda {
       result = Factory.CALL_NAMED(val[0], true, [])
       loc result, val[0], val[2]
-      result.lambda = val[3]
+      result.lambda = val[2]
     }
 
+call_function_start
+  : expression LPAREN { result = val[0] }
+  | TYPE LPAREN { result = Factory.QNAME(val[0][:value]); loc result, val[0] }
+
 #---CALL METHOD
 #
 call_method_with_lambda_expression
@@ -354,7 +371,7 @@ unless_expression
       loc result, val[0], val[4]
     }
   | UNLESS expression LBRACE RBRACE unless_else {
-      result = Factory.UNLESS(val[1], nil, nil)
+      result = Factory.UNLESS(val[1], nil, val[4])
       loc result, val[0], val[4]
     }
 
@@ -453,7 +470,10 @@ attribute_operations
   attribute_name
     : NAME
     | keyword
-#    | BOOLEAN
+    | APPLICATION_R
+    | CONSUMES_R
+    | PRODUCES_R
+    | SITE_R
 
   # In this version, illegal combinations are validated instead of producing syntax errors
   # (Can give nicer error message "+> is not applicable to...")
@@ -486,6 +506,33 @@ definition_expression
       end
     }
 
+#---APPLICATION
+application_expression
+  : APPLICATION classname parameter_list LBRACE opt_statements RBRACE {
+    result = add_definition(Factory.APPLICATION(classname(val[1][:value]), val[2], val[4]))
+    loc result, val[0], val[5]
+  }
+
+capability_mapping
+  : classname capability_kw classname LBRACE  attribute_operations endcomma RBRACE {
+    result = Factory.CAPABILITY_MAPPING(val[1][:value],
+                                        Factory.QNAME(classname(val[0][:value])),
+                                        classname(val[2][:value]), val[4])
+    loc result, val[0], val[6]
+    add_mapping(result)
+  }
+  | bracketed_expression capability_kw classname LBRACE  attribute_operations endcomma RBRACE {
+    result = Factory.CAPABILITY_MAPPING(val[1][:value],
+                                        val[0],
+                                        classname(val[2][:value]), val[4])
+    loc result, val[0], val[6]
+    add_mapping(result)
+  }
+
+capability_kw
+  : PRODUCES
+  | CONSUMES
+
 #---HOSTCLASS
 #
 # Produces Model::HostClassDefinition
@@ -522,6 +569,20 @@ hostclass_expression
     : classname
     | DEFAULT
 
+#---SITE
+#
+# Produces Model::SiteDefinition
+#
+site_definition_expression
+  : SITE LBRACE statements RBRACE {
+    result = add_definition(Factory.SITE(val[2]))
+    loc result, val[0], val[3]
+    }
+  | SITE LBRACE RBRACE {
+    result = add_definition(Factory.SITE(nil))
+    loc result, val[0], val[2]
+    }
+
 #---NODE
 #
 # Produces Model::NodeDefinition
@@ -568,13 +629,11 @@ node_definition_expression
 
 #---FUNCTION DEFINITION
 #
-#function_definition
-  # For now the function word will just be reserved, in the future it will
-  # produce a function definition
-  # FUNCTION classname parameter_list LBRACE opt_statements RBRACE {
-  #   result = add_definition(Factory.FUNCTION(val[1][:value], val[2], val[4]))
-  #   loc result, val[0], val[5]
-  # }
+function_definition
+  : FUNCTION classname parameter_list LBRACE opt_statements RBRACE {
+      result = add_definition(Factory.FUNCTION(val[1][:value], val[2], val[4]))
+      loc result, val[0], val[5]
+    }
 
 #---NAMES AND PARAMETERS COMMON TO SEVERAL RULES
 #   Produces String
@@ -583,6 +642,10 @@ classname
   : NAME
   | WORD
   | CLASSREF
+  | APPLICATION_R
+  | CONSUMES_R
+  | PRODUCES_R
+  | SITE_R
   | CLASS { error val[0], "'class' is not a valid classname" }
 
 # Produces Array<Model::Parameter>
@@ -619,6 +682,25 @@ parameter_type
   : type { result = val[0] }
   | type LBRACK expressions RBRACK { result = val[0][*val[2]] ; loc result, val[0], val[3] }
 
+#--TYPE ALIAS
+type_alias
+  : TYPE parameter_type EQUALS expression {
+      result = add_definition(Factory.TYPE_ASSIGNMENT(val[1], val[3]))
+      loc(result, val[0], val[3])
+    }
+
+#--TYPE definition
+# TODO: Uses the optional_statements rule temporarily since the actual body awaits final spec on methods and attributes.
+type_definition
+  : TYPE CLASSREF LBRACE optional_statements RBRACE {
+        result = add_definition(Factory.TYPE_DEFINITION(val[1][:value], nil, val[3]))
+        loc(result, val[0], val[4])
+      }
+  | TYPE CLASSREF INHERITS CLASSREF LBRACE optional_statements RBRACE {
+        result = add_definition(Factory.TYPE_DEFINITION(val[1][:value], val[3][:value], val[5]))
+        loc(result, val[0], val[6])
+      }
+
 #--VARIABLE
 #
 variable
@@ -627,19 +709,21 @@ variable
 #---RESERVED WORDS
 #
 reserved_word
-  : FUNCTION  { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
-  | PRIVATE   { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
-  | TYPE      { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
+  : PRIVATE   { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
   | ATTR      { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
+  | APPLICATION_R { result = Factory.RESERVED(val[0][:value], true) ; loc result, val[0] }
+  | CONSUMES_R    { result = Factory.RESERVED(val[0][:value], true) ; loc result, val[0] }
+  | PRODUCES_R    { result = Factory.RESERVED(val[0][:value], true) ; loc result, val[0] }
+  | SITE_R        { result = Factory.RESERVED(val[0][:value], true) ; loc result, val[0] }
 
 #---LITERALS (dynamic and static)
 #
 
 array
-  : LISTSTART assignments endcomma  RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
-  | LISTSTART                       RBRACK { result = Factory.literal([]) ; loc result, val[0], val[1] }
-  | LBRACK    assignments endcomma  RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
-  | LBRACK                          RBRACK { result = Factory.literal([]) ; loc result, val[0], val[1] }
+  : LISTSTART collection_entries endcomma  RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
+  | LISTSTART                              RBRACK { result = Factory.literal([]) ; loc result, val[0], val[1] }
+  | LBRACK    collection_entries endcomma  RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
+  | LBRACK                                 RBRACK { result = Factory.literal([]) ; loc result, val[0], val[1] }
 
 hash
   : LBRACE hashpairs RBRACE       { result = Factory.HASH(val[1]); loc result, val[0], val[2] }
@@ -651,7 +735,24 @@ hash
     | hashpairs COMMA hashpair { result = val[0].push val[2] }
 
   hashpair
-    : assignment FARROW assignment { result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1] }
+    : collection_entry FARROW collection_entry { result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1] }
+
+collection_entry:
+  : assignment
+  | collection_entry_keyword { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
+
+collection_entries
+  : collection_entry                           { result = [val[0]] }
+  | collection_entries COMMA collection_entry  { result = val[0].push(val[2]) }
+
+# Keywords valid as a collection value
+collection_entry_keyword
+  : TYPE
+  | FUNCTION
+  | APPLICATION
+  | CONSUMES
+  | PRODUCES
+  | SITE
 
 quotedtext
   : string
@@ -735,6 +836,8 @@ keyword
   | ATTR
   | FUNCTION
   | PRIVATE
+  | APPLICATION
+  | PRODUCES
 
 nil
   : { result = nil}