puppet 3.4.3 → 3.5.0.rc1

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

@@ -8,17 +8,21 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
   end
 
   # Produces a label for the given objects type/operator without article.
+  # If a Class is given, its name is used as label
+  #
   def label o
-   @@label_visitor.visit(o)
+    @@label_visitor.visit(o)
   end
 
   def label_Factory o                     ; label(o.current)                    end
-  def label_Array o                       ; "Array Object"                      end
-  def label_LiteralNumber o               ; "Literal Number"                    end
+  def label_Array o                       ; "Array"                             end
+  def label_LiteralInteger o              ; "Literal Integer"                   end
+  def label_LiteralFloat o                ; "Literal Float"                     end
   def label_ArithmeticExpression o        ; "'#{o.operator}' expression"        end
   def label_AccessExpression o            ; "'[]' expression"                   end
   def label_MatchExpression o             ; "'#{o.operator}' expression"        end
   def label_CollectExpression o           ; label(o.query)                      end
+  def label_EppExpression o               ; "Epp Template"                      end
   def label_ExportedQuery o               ; "Exported Query"                    end
   def label_VirtualQuery o                ; "Virtual Query"                     end
   def label_QueryExpression o             ; "Collect Query"                     end
@@ -26,16 +30,15 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
   def label_AndExpression o               ; "'and' expression"                  end
   def label_OrExpression o                ; "'or' expression"                   end
   def label_InExpression o                ; "'in' expression"                   end
-  def label_ImportExpression o            ; "'import' expression"               end
-  def label_InstanceReferences o          ; "Resource Reference"                end
   def label_AssignmentExpression o        ; "'#{o.operator}' expression"        end
   def label_AttributeOperation o          ; "'#{o.operator}' expression"        end
   def label_LiteralList o                 ; "Array Expression"                  end
   def label_LiteralHash o                 ; "Hash Expression"                   end
   def label_KeyedEntry o                  ; "Hash Entry"                        end
   def label_LiteralBoolean o              ; "Boolean"                           end
+  def label_TrueClass o                   ; "Boolean"                           end
+  def label_FalseClass o                  ; "Boolean"                           end
   def label_LiteralString o               ; "String"                            end
-  def label_LiteralText o                 ; "Text in Interpolated String"       end
   def label_LambdaExpression o            ; "Lambda"                            end
   def label_LiteralDefault o              ; "'default' expression"              end
   def label_LiteralUndef o                ; "'undef' expression"                end
@@ -49,6 +52,7 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
   def label_UnaryMinusExpression o        ; "Unary Minus"                       end
   def label_BlockExpression o             ; "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_NodeDefinition o              ; "Node Definition"                   end
   def label_ResourceTypeDefinition o      ; "'define' expression"               end
@@ -61,15 +65,40 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
   def label_CallMethodExpression o        ; "Method call"                       end
   def label_CaseExpression o              ; "'case' statement"                  end
   def label_CaseOption o                  ; "Case Option"                       end
+  def label_RenderStringExpression o      ; "Epp Text"                          end
+  def label_RenderExpression o            ; "Epp Interpolated Expression"       end
   def label_RelationshipExpression o      ; "'#{o.operator}' expression"        end
   def label_ResourceBody o                ; "Resource Instance Definition"      end
   def label_ResourceDefaultsExpression o  ; "Resource Defaults Expression"      end
   def label_ResourceExpression o          ; "Resource Statement"                end
   def label_SelectorExpression o          ; "Selector Expression"               end
   def label_SelectorEntry o               ; "Selector Option"                   end
-  def label_String o                      ; "Ruby String"                       end
-  def label_Object o                      ; "Ruby Object"                       end
+  def label_Integer o                     ; "Integer"                           end
+  def label_Fixnum o                      ; "Integer"                           end
+  def label_Bignum o                      ; "Integer"                           end
+  def label_Float o                       ; "Float"                             end
+  def label_String o                      ; "String"                            end
+  def label_Regexp o                      ; "Regexp"                            end
+  def label_Object o                      ; "Object"                            end
+  def label_Hash o                        ; "Hash"                              end
   def label_QualifiedName o               ; "Name"                              end
-  def label_QualifiedReference o          ; "Type Name"                         end
+  def label_QualifiedReference o          ; "Type-Name"                         end
+  def label_PAbstractType o               ; "#{Puppet::Pops::Types::TypeCalculator.string(o)}-Type" end
 
+  def label_PResourceType o
+    if o.title
+      "#{Puppet::Pops::Types::TypeCalculator.string(o)} Resource-Reference"
+    else
+      "#{Puppet::Pops::Types::TypeCalculator.string(o)}-Type"
+    end
+  end
+
+  def label_Class o
+    if o <= Puppet::Pops::Types::PAbstractType
+      simple_name = o.name.split('::').last
+      simple_name[1..-5] + "-Type"
+    else
+      o.name
+    end
+  end
 end

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

@@ -7,7 +7,11 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     o.collect {|e| do_dump(e) }
   end
 
-  def dump_LiteralNumber o
+  def dump_LiteralFloat o
+    o.value.to_s
+  end
+
+  def dump_LiteralInteger o
     case o.radix
     when 10
       o.value.to_s
@@ -54,6 +58,17 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     result
   end
 
+  def dump_EppExpression o
+    result = ["epp"]
+#    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_ExportedQuery o
     result = ["<<| |>>"]
     result += dump_QueryExpression(o) unless is_nop?(o.expr)
@@ -86,14 +101,6 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     ["in", do_dump(o.left_expr), do_dump(o.right_expr)]
   end
 
-  def dump_ImportExpression o
-    ["import"] + o.files.collect {|f| do_dump(f) }
-  end
-
-  def dump_InstanceReferences o
-    ["instances", do_dump(o.type_name)] + o.names.collect {|n| do_dump(n) }
-  end
-
   def dump_AssignmentExpression o
     [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
   end
@@ -123,10 +130,6 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     "'#{o.value}'"
   end
 
-  def dump_LiteralText o
-    o.value
-  end
-
   def dump_LambdaExpression o
     result = ["lambda"]
     result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
@@ -188,6 +191,10 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     ["cat"] + o.segments.collect {|x| do_dump(x)}
   end
 
+  def dump_HeredocExpression(o)
+    result = ["@(#{o.syntax})", :indent, :break, do_dump(o.text_expr), :dedent, :break]
+  end
+
   def dump_HostClassDefinition o
     result = ["class", o.name]
     result << ["inherits", o.parent_class] if o.parent_class
@@ -245,6 +252,12 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     do_dump(o.expr)
   end
 
+  # Hides that Program exists in the output (only its body is shown), the definitions are just
+  # references to contained classes, resource types, and nodes
+  def dump_Program(o)
+    dump(o.body)
+  end
+
   def dump_IfExpression o
     result = ["if", do_dump(o.test), :indent, :break,
       ["then", :indent, do_dump(o.then_expr), :dedent]]
@@ -306,6 +319,14 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
   end
 
+  def dump_RenderStringExpression o
+    ["render-s", " '#{o.value}'"]
+  end
+
+  def dump_RenderExpression o
+    ["render", do_dump(o.expr)]
+  end
+
   def dump_ResourceBody o
     result = [do_dump(o.title), :indent]
     o.operations.each do |p|
@@ -342,6 +363,10 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     [do_dump(o.matching_expr), "=>", do_dump(o.value_expr)]
   end
 
+  def dump_SubLocatedExpression o
+    ["sublocated", do_dump(o.expr)]
+  end
+
   def dump_Object o
     [o.class.to_s, o.to_s]
   end

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

@@ -0,0 +1,17 @@
+
+class Puppet::Pops::Parser::CodeMerger
+
+  # Concatenates the logic in the array of parse results into one parse result.
+  # @return Puppet::Parser::AST::BlockExpression
+  #
+  def concatenate(parse_results)
+    # 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.
+    #
+    children = parse_results.select {|x| !x.nil? && x.code}.reduce([]) do |memo, parsed_class|
+      memo << parsed_class.code
+    end
+    Puppet::Parser::AST::BlockExpression.new(:children => children)
+  end
+end

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

@@ -6,15 +6,18 @@ class Puppet::Pops::Parser::Parser
 
 token STRING DQPRE DQMID DQPOST
 token LBRACK  RBRACK LBRACE RBRACE SYMBOL FARROW COMMA TRUE
-token FALSE EQUALS APPENDS LESSEQUAL NOTEQUAL DOT COLON LLCOLLECT RRCOLLECT
+token FALSE EQUALS APPENDS DELETES LESSEQUAL NOTEQUAL DOT COLON LLCOLLECT RRCOLLECT
 token QMARK LPAREN RPAREN ISEQUAL GREATEREQUAL GREATERTHAN LESSTHAN
 token IF ELSE
 token DEFINE ELSIF VARIABLE CLASS INHERITS NODE BOOLEAN
-token NAME SEMIC CASE DEFAULT AT LCOLLECT RCOLLECT CLASSREF
+token NAME SEMIC CASE DEFAULT AT ATAT LCOLLECT RCOLLECT CLASSREF
 token NOT OR AND UNDEF PARROW PLUS MINUS TIMES DIV LSHIFT RSHIFT UMINUS
 token MATCH NOMATCH REGEX IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
 token IN UNLESS PIPE
-token SELBRACE
+token LAMBDA SELBRACE
+token NUMBER
+token HEREDOC SUBLOCATE
+token RENDER_STRING RENDER_EXPR EPP_START EPP_END EPP_END_TRIM
 token LOW
 
 prechigh
@@ -23,10 +26,12 @@ prechigh
   left  PIPE
   left  LPAREN
   left  RPAREN
-  left  AT
+  left  AT ATAT
   left  DOT
   left  CALL
-  left  LBRACK
+  nonassoc EPP_START
+  left  LBRACK LISTSTART
+  left  RBRACK
   left  QMARK
   left  LCOLLECT LLCOLLECT
   right NOT
@@ -40,7 +45,7 @@ prechigh
   left  GREATEREQUAL GREATERTHAN LESSTHAN LESSEQUAL
   left  AND
   left  OR
-  right APPENDS EQUALS
+  right APPENDS DELETES EQUALS
   left  LBRACE
   left  SELBRACE
   left  RBRACE
@@ -49,13 +54,16 @@ prechigh
   left  CASE_COLON
   left  FARROW
   left  COMMA
+  nonassoc RENDER_EXPR
+  nonassoc RENDER_STRING
   left  LOW
 preclow
 
 rule
 # Produces [Model::BlockExpression, Model::Expression, nil] depending on multiple statements, single statement or empty
 program
-  : statements { result = Factory.block_or_expression(*val[0]) }
+  : statements { result = create_program(Factory.block_or_expression(*val[0])) }
+  | epp_expression { result = create_program(Factory.block_or_expression(*val[0])) }
   | nil
 
 # Produces a semantic model (non validated, but semantically adjusted).
@@ -92,8 +100,8 @@ expression
   : higher_precedence
   | expression LBRACK       expressions RBRACK =LBRACK { result = val[0][*val[2]]         ; loc result, val[0], val[3] }
   | expression IN           expression                 { result = val[0].in val[2]        ; loc result, val[1] }
-  | expression MATCH        match_rvalue               { result = val[0] =~  val[2]       ; loc result, val[1] }
-  | expression NOMATCH      match_rvalue               { result = val[0].mne 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] }
   | expression PLUS         expression                 { result = val[0] +   val[2]       ; loc result, val[1] }
   | expression MINUS        expression                 { result = val[0] -   val[2]       ; loc result, val[1] }
   | expression DIV          expression                 { result = val[0] /   val[2]       ; loc result, val[1] }
@@ -113,6 +121,7 @@ expression
   | expression OR           expression                 { result = val[0].or  val[2]       ; loc result, val[1] }
   | expression EQUALS       expression                 { result = val[0].set(val[2])      ; loc result, val[1] }
   | expression APPENDS      expression                 { result = val[0].plus_set(val[2]) ; loc result, val[1] }
+  | expression DELETES      expression                 { result = val[0].minus_set(val[2]); loc result, val[1] }
   | expression QMARK selector_entries                  { result = val[0].select(*val[2])  ; loc result, val[0] }
   |            LPAREN       expression RPAREN          { result = val[1].paren()          ; loc result, val[0] }
 
@@ -140,6 +149,7 @@ primary_expression
   | definition_expression
   | hostclass_expression
   | node_definition_expression
+  | epp_render_expression
 
 # Aleways have the same value
 literal_expression
@@ -148,7 +158,8 @@ literal_expression
   | default
   | hash
   | regex
-  | text_or_name =LOW # resolves hash key ambiguity (racc W U require this?)
+  | text_or_name
+  | number
   | type
   | undef
 
@@ -334,10 +345,6 @@ case_expression
   selector_entry
     : expression FARROW expression { result = Factory.MAP(val[0], val[2]) ; loc result, val[1] }
 
-# --- IMPORT
-#     IMPORT is handled as a non parenthesized call and is transformed to an ImportExpression.
-#     i.e. there is no special grammar for it - it is just a "call statement".
-
 #---RESOURCE
 #
 # Produces [Model::ResourceExpression, Model::ResourceDefaultsExpression]
@@ -357,24 +364,20 @@ resource_expression
         tmp.form = val[0]
         tmp
       when :defaults
-        error "A resource default can not be virtual or exported"
+        error val[1], "A resource default can not be virtual or exported"
       when :override
-        error "A resource override can not be virtual or exported"
+        error val[1], "A resource override can not be virtual or exported"
       else
-        error "Expression is not valid as a resource, resource-default, or resource-override"
+        error val[1], "Expression is not valid as a resource, resource-default, or resource-override"
       end
       loc result, val[1], val[4]
     }
   | at expression LBRACE attribute_operations endcomma RBRACE {
       result = case Factory.resource_shape(val[1])
-      when :resource, :class
-        error "Defaults are not virtualizable"
-      when :defaults
-        error "Defaults are not virtualizable"
-      when :override
-        error "Defaults are not virtualizable"
+      when :resource, :class, :defaults, :override
+        error val[1], "Defaults are not virtualizable"
       else
-        error "Expression is not valid as a resource, resource-default, or resource-override"
+        error val[1], "Expression is not valid as a resource, resource-default, or resource-override"
       end
     }
   | expression LBRACE resourceinstances endsemi RBRACE {
@@ -382,11 +385,11 @@ resource_expression
       when :resource, :class
         Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
       when :defaults
-        error "A resource default can not specify a resource name"
+        error val[1], "A resource default can not specify a resource name"
       when :override
-        error "A resource override does not allow override of name of resource"
+        error val[1], "A resource override does not allow override of name of resource"
       else
-        error "Expression is not valid as a resource, resource-default, or resource-override"
+        error val[1], "Expression is not valid as a resource, resource-default, or resource-override"
       end
       loc result, val[0], val[4]
     }
@@ -394,17 +397,28 @@ resource_expression
       result = case Factory.resource_shape(val[0])
       when :resource, :class
         # This catches deprecated syntax.
-        error "All resource specifications require names"
+        # 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])
+          error val[1], "Syntax error resource body without title or hash with +>"
+        end
+        tmp
       when :defaults
         Factory.RESOURCE_DEFAULTS(val[0], val[2])
       when :override
         # This was only done for override in original - TODO shuld it be here at all
         Factory.RESOURCE_OVERRIDE(val[0], val[2])
       else
-        error "Expression is not valid as a resource, resource-default, or resource-override"
+        error val[0], "Expression is not valid as a resource, resource-default, or resource-override"
       end
       loc result, val[0], val[4]
     }
+  | at CLASS LBRACE resourceinstances endsemi RBRACE {
+        result = Factory.RESOURCE(Factory.fqn(token_text(val[1])), val[3])
+        result.form = val[0]
+        loc result, val[1], val[5]
+    }
   | CLASS LBRACE resourceinstances endsemi RBRACE {
         result = Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
         loc result, val[0], val[4]
@@ -424,6 +438,7 @@ resource_expression
   at
     : AT    { result = :virtual  }
     | AT AT { result = :exported }
+    | ATAT  { result = :exported }
 
 #---COLLECTION
 #
@@ -489,36 +504,36 @@ attribute_operations
 # Produces Model::Definition
 #
 definition_expression
-  : DEFINE classname parameter_list LBRACE statements RBRACE {
-      result = Factory.DEFINITION(classname(val[1][:value]), val[2], val[4])
+  : DEFINE classname parameter_list LBRACE opt_statements RBRACE {
+      result = add_definition(Factory.DEFINITION(classname(val[1][:value]), val[2], val[4]))
       loc result, val[0], val[5]
-      @lexer.indefine = false
-    }
-  | DEFINE classname parameter_list LBRACE RBRACE {
-      result = Factory.DEFINITION(classname(val[1][:value]), val[2], nil)
-      loc result, val[0], val[4]
-      @lexer.indefine = false
+      # New lexer does not keep track of this, this is done in validation
+      if @lexer.respond_to?(:'indefine=')
+        @lexer.indefine = false
+      end
     }
 
 #---HOSTCLASS
-# ORIGINAL COMMENT: Our class gets defined in the parent namespace, not our own.
-#    WAT ??! This is way odd; should get its complete name, classnames do not nest
-#    Seems like the call to classname makes use of the name scope
-#    (This is uneccesary, since the parent name is known when evaluating)
 #
 # Produces Model::HostClassDefinition
 #
 hostclass_expression
-  : CLASS classname parameter_list classparent LBRACE statements RBRACE {
-      @lexer.namepop
-      result = Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), val[5])
+  : CLASS stacked_classname parameter_list classparent LBRACE opt_statements RBRACE {
+      # Remove this class' name from the namestack as all nested classes have been parsed
+      namepop
+      result = add_definition(Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), val[5]))
       loc result, val[0], val[6]
     }
-  | CLASS classname parameter_list classparent LBRACE RBRACE {
-      @lexer.namepop
-      result = Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), nil)
-      loc result, val[0], val[5]
-      }
+
+  # Record the classname so nested classes gets a fully qualified name at parse-time
+  # This is a separate rule since racc does not support intermediate actions.
+  #
+  stacked_classname
+    : classname { namestack(val[0][:value]) ; result = val[0] }
+
+  opt_statements
+    : statements
+    | nil
 
   # Produces String, name or nil result
   classparent
@@ -540,11 +555,11 @@ hostclass_expression
 #
 node_definition_expression
   : NODE hostnames nodeparent LBRACE statements RBRACE {
-      result = Factory.NODE(val[1], val[2], val[4])
+      result = add_definition(Factory.NODE(val[1], val[2], val[4]))
       loc result, val[0], val[5]
     }
   | NODE hostnames nodeparent LBRACE RBRACE {
-      result = Factory.NODE(val[1], val[2], nil)
+      result = add_definition(Factory.NODE(val[1], val[2], nil))
       loc result, val[0], val[4]
     }
 
@@ -560,21 +575,26 @@ node_definition_expression
   # Produces a LiteralExpression (string, :default, or regexp)
   # String with interpolation is validated for better error message
   hostname
-    : NAME        { result = Factory.fqn(val[0][:value]); loc result, val[0] }
-    | quotedtext  { result = val[0] } 
+    : dotted_name { result = val[0] }
+    | quotedtext  { result = val[0] }
     | DEFAULT     { result = Factory.literal(:default); loc result, val[0] }
     | regex
 
+  dotted_name
+    : NAME        { result = Factory.literal(val[0][:value]); loc result, val[0] }
+    | dotted_name DOT NAME { result = Factory.concat(val[0], '.', val[2][:value]); loc result, val[0], val[2] }
+
   # Produces Expression, since hostname is an Expression
   nodeparent
     : nil
     | INHERITS hostname { result = val[1] }
 
-#---NAMES AND PARAMTERS COMMON TO SEVERAL RULES
-# String result
+#---NAMES AND PARAMETERS COMMON TO SEVERAL RULES
+#   Produces String
+#
 classname
   : NAME  { result = val[0] }
-  | CLASS { result = val[0] }
+  | CLASS { error val[0], "'class' is not a valid classname" }
 
 # Produces Array<Model::Parameter>
 parameter_list
@@ -595,10 +615,10 @@ parameter
 #--RESTRICTED EXPRESSIONS
 #  i.e. where one could have expected an expression, but the set is limited
 
-# What is allowed RHS of match operators (see expression)
-match_rvalue
-  : regex
-  | text_or_name
+## What is allowed RHS of match operators (see expression)
+#match_rvalue
+#  : regex
+#  | text_or_name
 
 #--VARIABLE
 #
@@ -612,6 +632,9 @@ array
   : LBRACK expressions       RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[2] }
   | LBRACK expressions COMMA RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
   | LBRACK                   RBRACK { result = Factory.literal([]) ; loc result, val[0] }
+  | LISTSTART expressions       RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[2] }
+  | LISTSTART expressions COMMA RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
+  | LISTSTART                   RBRACK { result = Factory.literal([]) ; loc result, val[0] }
 
 hash
   : LBRACE hashpairs RBRACE       { result = Factory.HASH(val[1]); loc result, val[0], val[2] }
@@ -623,11 +646,12 @@ hash
     | hashpairs COMMA hashpair { result = val[0].push val[2] }
 
   hashpair
-    : text_or_name FARROW expression { result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1] }
+    : expression FARROW expression { result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1] }
 
 quotedtext
   : string
   | dq_string
+  | heredoc
 
 string          : STRING                 { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
 dq_string       : dqpre dqrval           { result = Factory.string(val[0], *val[1]) ; loc result, val[0], val[1][-1] }
@@ -641,6 +665,31 @@ dqtail
   : dqpost        { result = [val[0]] }
   | dqmid dqrval  { result = [val[0]] + val[1] }
 
+heredoc
+  : HEREDOC sublocated_text  { result = Factory.HEREDOC(val[0][:value], val[1]); loc result, val[0] }
+
+sublocated_text
+  : SUBLOCATE string    { result = Factory.SUBLOCATE(val[0], val[1]); loc result, val[0] }
+  | SUBLOCATE dq_string { result = Factory.SUBLOCATE(val[0], val[1]); loc result, val[0] }
+
+epp_expression
+  : EPP_START epp_parameters_list statements { result = Factory.EPP(val[1], val[2]); loc result, val[0] }
+
+epp_parameters_list
+  :                                  =LOW{ result = nil }
+  | PIPE PIPE                        { result = [] }
+  | PIPE parameters endcomma PIPE    { result = val[1] }
+
+epp_render_expression
+  : RENDER_STRING                  { result = Factory.RENDER_STRING(val[0][:value]); loc result, val[0] }
+  | RENDER_EXPR expression epp_end { result = Factory.RENDER_EXPR(val[1]); loc result, val[0], val[2] }
+  | RENDER_EXPR LBRACE statements RBRACE epp_end { result = Factory.RENDER_EXPR(Factory.block_or_expression(*val[2])); loc result, val[0], val[4] }
+
+epp_end
+  : EPP_END
+  | EPP_END_TRIM
+
+number   : NUMBER   { result = Factory.NUMBER(val[0][:value]) ; loc result, val[0] }
 name     : NAME     { result = Factory.QNAME_OR_NUMBER(val[0][:value]) ; loc result, val[0] }
 type     : CLASSREF { result = Factory.QREF(val[0][:value])  ; loc result, val[0] }
 undef    : UNDEF    { result = Factory.literal(:undef); loc result, val[0] }