puppet 3.6.2 → 3.7.0

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

@@ -110,6 +110,10 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     [o.attribute_name, o.operator, do_dump(o.value_expr)]
   end
 
+  def dump_AttributesOperation o
+    ['* =>', do_dump(o.expr)]
+  end
+
   def dump_LiteralList o
     ["[]"] + o.values.collect {|x| do_dump(x)}
   end
@@ -182,8 +186,15 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     ['-', do_dump(o.expr)]
   end
 
+  def dump_UnfoldExpression o
+    ['unfold', do_dump(o.expr)]
+  end
+
   def dump_BlockExpression o
-    ["block"] + o.statements.collect {|x| do_dump(x) }
+    result = ["block", :indent]
+    o.statements.each {|x| result << :break; result << do_dump(x) }
+    result << :dedent << :break
+    result
   end
 
   # Interpolated strings are shown as (cat seg0 seg1 ... segN)
@@ -238,7 +249,8 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
   end
 
   def dump_ResourceOverrideExpression o
-    result = ["override", do_dump(o.resources), :indent]
+    form = o.form == :regular ? '' : o.form.to_s + "-"
+    result = [form+"override", do_dump(o.resources), :indent]
     o.operations.each do |p|
       result << :break << do_dump(p)
     end
@@ -246,11 +258,20 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     result
   end
 
+  def dump_ReservedWord o
+    [ 'reserved', o.word ]
+  end
+
   # Produces parameters as name, or (= name value)
   def dump_Parameter o
-    name_part = "#{o.name}"
-    if o.value
+    name_prefix = o.captures_rest ? '*' : ''
+    name_part = "#{name_prefix}#{o.name}"
+    if o.value && o.type_expr
+      ["=t", do_dump(o.type_expr), name_part, do_dump(o.value)]
+    elsif o.value
       ["=", name_part, do_dump(o.value)]
+    elsif o.type_expr
+      ["t", do_dump(o.type_expr), name_part]
     else
       name_part
     end
@@ -345,7 +366,8 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
   end
 
   def dump_ResourceDefaultsExpression o
-    result = ["resource-defaults", do_dump(o.type_ref), :indent]
+    form = o.form == :regular ? '' : o.form.to_s + "-"
+    result = [form+"resource-defaults", do_dump(o.type_ref), :indent]
     o.operations.each do |p|
       result << :break << do_dump(p)
     end

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

@@ -20,6 +20,7 @@ token NUMBER
 token HEREDOC SUBLOCATE
 token RENDER_STRING RENDER_EXPR EPP_START EPP_END EPP_END_TRIM
 token FUNCTION
+token PRIVATE ATTR TYPE
 token LOW
 
 prechigh
@@ -28,15 +29,14 @@ prechigh
   left  PIPE
   left  LPAREN
   left  RPAREN
-  left  AT ATAT
   left  DOT
-  left  CALL
   nonassoc EPP_START
   left  LBRACK LISTSTART
   left  RBRACK
   left  QMARK
   left  LCOLLECT LLCOLLECT
   right NOT
+  nonassoc SPLAT
   nonassoc UMINUS
   left  IN
   left  MATCH NOMATCH
@@ -47,13 +47,12 @@ prechigh
   left  GREATEREQUAL GREATERTHAN LESSTHAN LESSEQUAL
   left  AND
   left  OR
-  right APPENDS DELETES EQUALS
   left  LBRACE
   left  SELBRACE
   left  RBRACE
+  right AT ATAT
+  right APPENDS DELETES EQUALS
   left  IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
-  left  TITLE_COLON
-  left  CASE_COLON
   left  FARROW
   left  COMMA
   nonassoc RENDER_EXPR
@@ -62,44 +61,137 @@ prechigh
 preclow
 
 rule
-# Produces [Model::BlockExpression, Model::Expression, nil] depending on multiple statements, single statement or empty
+# Produces [Model::Program] with a body containing what was parsed
 program
-  : statements { result = create_program(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
+  |                { result = create_empty_program() }
 
 # Produces a semantic model (non validated, but semantically adjusted).
 statements
   : syntactic_statements { result = transform_calls(val[0]) }
 
-# Change may have issues with nil; i.e. program is a sequence of nils/nops
-# Simplified from original which had validation for top level constructs - see statement rule
+# Collects sequence of elements into a list that the statements rule can transform
+# (Needed because language supports function calls without parentheses around arguments).
 # Produces Array<Model::Expression>
+#
 syntactic_statements
   : syntactic_statement                            { result = [val[0]]}
   | syntactic_statements SEMIC syntactic_statement { result = val[0].push val[2] }
   | syntactic_statements syntactic_statement       { result = val[0].push val[1] }
 
 # Produce a single expression or Array of expression
+# This exists to handle multiple arguments to non parenthesized function call. If e is expression,
+# the a program can consists of e [e,e,e] where the first may be a name of a function to call.
+#
 syntactic_statement
-  : any_expression                            { result = val[0] }
-  | syntactic_statement COMMA any_expression  { result = aryfy(val[0]).push val[2] }
+  : assignment                             =LOW { result = val[0] }
+  | syntactic_statement COMMA assignment   =LOW { result = aryfy(val[0]).push val[2] }
+
+# Assignment (is right recursive since assignment is right associative)
+assignment
+  : relationship =LOW
+  | relationship EQUALS  assignment         { result = val[0].set(val[2])      ; loc result, val[1] }
+  | relationship APPENDS assignment         { result = val[0].plus_set(val[2]) ; loc result, val[1] }
+  | relationship DELETES assignment         { result = val[0].minus_set(val[2]); loc result, val[1] }
+
+assignments
+  : assignment                              { result = [val[0]] }
+  | assignments COMMA assignment            { result = val[0].push(val[2]) }
+
+relationship
+  : resource =LOW
+  | relationship IN_EDGE      resource      { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
+  | relationship IN_EDGE_SUB  resource      { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
+  | relationship OUT_EDGE     resource      { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
+  | relationship OUT_EDGE_SUB resource      { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
+
+#-- RESOURCE
+#
+resource
+  : expression = LOW
 
-any_expression
-  : relationship_expression
+    #---VIRTUAL
+  | AT resource {
+      result = val[1]
+      unless Factory.set_resource_form(result, :virtual)
+        # This is equivalent to a syntax error - additional semantic restrictions apply
+        error val[0], "Virtual (@) can only be applied to a Resource Expression"
+      end
+      # relocate the result
+      loc result, val[0], val[1]
+    }
 
-relationship_expression
-  : resource_expression                                     =LOW  { result = val[0] }
-  | relationship_expression IN_EDGE      relationship_expression  { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
-  | relationship_expression IN_EDGE_SUB  relationship_expression  { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
-  | relationship_expression OUT_EDGE     relationship_expression  { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
-  | relationship_expression OUT_EDGE_SUB relationship_expression  { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
+    #---EXPORTED
+  | ATAT resource {
+      result = val[1]
+      unless Factory.set_resource_form(result, :exported)
+        # This is equivalent to a syntax error - additional semantic restrictions apply
+        error val[0], "Exported (@@) can only be applied to a Resource Expression"
+      end
+      # relocate the result
+      loc result, val[0], val[1]
+    }
 
-#---EXPRESSION
+    #---RESOURCE TITLED 3x and 4x
+  | resource LBRACE expression COLON attribute_operations additional_resource_bodies RBRACE {
+      bodies = [Factory.RESOURCE_BODY(val[2], val[4])] + val[5]
+      result = Factory.RESOURCE(val[0], bodies)
+      loc result, val[0], val[6]
+    }
+
+    #---CLASS RESOURCE
+  | CLASS LBRACE resource_bodies endsemi RBRACE {
+        result = Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
+        loc result, val[0], val[4]
+    }
+
+    # --RESOURCE 3X Expression
+    #   Handles both 3x overrides and defaults (i.e. single resource_body without title colon)
+    #   Slated for possible deprecation since it requires transformation and mix static/evaluation check
+    #
+  | resource LBRACE attribute_operations endcomma RBRACE {
+       result = case Factory.resource_shape(val[0])
+       when :resource, :class
+        # This catches deprecated syntax.
+        # 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 should it be here at all
+        Factory.RESOURCE_OVERRIDE(val[0], val[2])
+      else
+        error val[0], "Expression is not valid as a resource, resource-default, or resource-override"
+      end
+     loc result, val[0], val[4]
+    }
+
+  resource_body
+    : expression COLON attribute_operations endcomma { result = Factory.RESOURCE_BODY(val[0], val[2]) }
+
+  resource_bodies
+    : resource_body                         =HIGH { result = [val[0]] }
+    | resource_bodies SEMIC resource_body   =HIGH { result = val[0].push val[2] }
+
+  # This is a rule for the intermediate state where RACC has seen enough tokens to understand that
+  # what is expressed is a Resource Expression, it now has to get to the finishing line
+  #
+  additional_resource_bodies
+    : endcomma                         { result = [] }
+    | endcomma SEMIC                   { result = [] }
+    | endcomma SEMIC resource_bodies endsemi { result = val[2] }
+
+#-- EXPRESSION
 #
-# Produces Model::Expression
 expression
-  : higher_precedence
+  : primary_expression
+  | call_function_expression
   | 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        expression                 { result = val[0] =~  val[2]       ; loc result, val[1] }
@@ -112,6 +204,7 @@ expression
   | expression LSHIFT       expression                 { result = val[0] <<  val[2]       ; loc result, val[1] }
   | expression RSHIFT       expression                 { result = val[0] >>  val[2]       ; loc result, val[1] }
   |            MINUS        expression         =UMINUS { result = val[1].minus()          ; loc result, val[0] }
+  |            TIMES        expression         =SPLAT  { result = val[1].unfold()         ; loc result, val[0] }
   | expression NOTEQUAL     expression                 { result = val[0].ne  val[2]       ; loc result, val[1] }
   | expression ISEQUAL      expression                 { result = val[0] ==  val[2]       ; loc result, val[1] }
   | expression GREATERTHAN  expression                 { result = val[0] >   val[2]       ; loc result, val[1] }
@@ -121,28 +214,22 @@ expression
   |            NOT          expression                 { result = val[1].not              ; loc result, val[0] }
   | expression AND          expression                 { result = val[0].and val[2]       ; loc result, val[1] }
   | 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] }
+  |            LPAREN       assignment RPAREN          { result = val[1].paren()          ; loc result, val[0] }
+
 
 #---EXPRESSIONS
-#   (e.g. argument list)
+#   (i.e. "argument list")
 #
 # This expression list can not contain function calls without parentheses around arguments
 # Produces Array<Model::Expression>
+#
 expressions
   : expression                   { result = [val[0]] }
   | expressions COMMA expression { result = val[0].push(val[2]) }
 
-# These go through a chain of left recursion, ending with primary_expression
-higher_precedence
-  : call_function_expression
-
 primary_expression
-  : literal_expression
-  | variable
+  : variable
   | call_method_with_lambda_expression
   | collection_expression
   | case_expression
@@ -152,61 +239,54 @@ primary_expression
   | hostclass_expression
   | node_definition_expression
   | epp_render_expression
-  | function_definition
-
-# Allways have the same value
-literal_expression
-  : array
-  | boolean
-  | default
+  | reserved_word
+  | array
   | hash
   | regex
-  | text_or_name
-  | number
+  | quotedtext
   | type
-  | undef
+  | NUMBER       { result = Factory.NUMBER(val[0][:value])          ; loc result, val[0] }
+  | BOOLEAN      { result = Factory.literal(val[0][:value])         ; loc result, val[0] }
+  | DEFAULT      { result = Factory.literal(:default)               ; loc result, val[0] }
+  | UNDEF        { result = Factory.literal(:undef)                 ; loc result, val[0] }
+  | NAME         { result = Factory.QNAME_OR_NUMBER(val[0][:value]) ; loc result, val[0] }
 
-text_or_name
-  : name       { result = val[0] }
-  | quotedtext { result = val[0] }
 
 #---CALL FUNCTION
 #
 # Produces Model::CallNamedFunction
 
 call_function_expression
-  : primary_expression LPAREN expressions endcomma RPAREN {
+  : expression LPAREN assignments endcomma RPAREN {
       result = Factory.CALL_NAMED(val[0], true, val[2])
       loc result, val[0], val[4]
     }
-  | primary_expression LPAREN RPAREN {
+  | expression LPAREN RPAREN {
       result = Factory.CALL_NAMED(val[0], true, [])
       loc result, val[0], val[2]
     }
-  | primary_expression LPAREN expressions endcomma RPAREN lambda {
+  | expression LPAREN assignments endcomma RPAREN lambda {
       result = Factory.CALL_NAMED(val[0], true, val[2])
       loc result, val[0], val[4]
       result.lambda = val[5]
     }
-  | primary_expression LPAREN RPAREN  lambda {
+  | expression LPAREN RPAREN  lambda {
       result = Factory.CALL_NAMED(val[0], true, [])
       loc result, val[0], val[2]
       result.lambda = val[3]
     }
-  | primary_expression = LOW { result = val[0] }
 
 #---CALL METHOD
 #
 call_method_with_lambda_expression
   : call_method_expression         =LOW { result = val[0] }
-  | call_method_expression lambda  { result = val[0]; val[0].lambda = val[1] }
+  | call_method_expression lambda       { result = val[0]; val[0].lambda = val[1] }
 
   call_method_expression
-    : named_access LPAREN expressions RPAREN { result = Factory.CALL_METHOD(val[0], val[2]); loc result, val[1], val[3] }
+    : named_access LPAREN assignments RPAREN { result = Factory.CALL_METHOD(val[0], val[2]); loc result, val[1], val[3] }
     | named_access LPAREN RPAREN             { result = Factory.CALL_METHOD(val[0], []); loc result, val[1], val[3] }
     | named_access =LOW                      { result = Factory.CALL_METHOD(val[0], []); loc result, val[0] }
 
-  # TODO: It may be of value to access named elements of types too
   named_access
     : expression DOT NAME {
         result = val[0].dot(Factory.fqn(val[2][:value]))
@@ -215,31 +295,25 @@ call_method_with_lambda_expression
 
 #---LAMBDA
 #
-# This is a temporary switch while experimenting with concrete syntax
-# One should be picked for inclusion in puppet.
-
-# Lambda with parameters to the left of the body
 lambda
   : lambda_parameter_list lambda_rest {
-      result = Factory.LAMBDA(val[0], val[1])
-#      loc result, val[1] # TODO
+      result = Factory.LAMBDA(val[0][:value], val[1][:value])
+      loc result, val[0][:start], val[1][:end]
     }
 
 lambda_rest
-  : LBRACE statements RBRACE { result = val[1] }
-  | LBRACE RBRACE { result = nil }
+  : LBRACE statements RBRACE  { result = {:end => val[2], :value =>val[1] } }
+  | LBRACE RBRACE             { result = {:end => val[1], :value => nil } }
+
 
-# Produces Array<Model::Parameter>
 lambda_parameter_list
-  : PIPE PIPE                     { result = [] }
-  | PIPE parameters endcomma PIPE { result = val[1] }
+  : PIPE PIPE                     { result = {:start => val[0], :value => [] } }
+  | PIPE parameters endcomma PIPE { result = {:start => val[0], :value => val[1] } }
 
 #---CONDITIONALS
-#
 
 #--IF
 #
-# Produces Model::IfExpression
 if_expression
   : IF if_part {
       result = val[1]
@@ -274,8 +348,6 @@ if_expression
 
 #--UNLESS
 #
-# Changed from Puppet 3x where there is no else part on unless
-#
 unless_expression
   : UNLESS expression LBRACE statements RBRACE unless_else {
       result = Factory.UNLESS(val[1], Factory.block_or_expression(*val[3]), val[5])
@@ -301,7 +373,6 @@ unless_expression
 
 #--- CASE EXPRESSION
 #
-# Produces Model::CaseExpression
 case_expression
   : CASE expression LBRACE case_options RBRACE {
       result = Factory.CASE(val[1], *val[3])
@@ -311,20 +382,17 @@ case_expression
   # Produces Array<Model::CaseOption>
   case_options
     : case_option               { result = [val[0]] }
-    | case_options case_option { result = val[0].push val[1] }
+    | case_options case_option  { result = val[0].push val[1] }
 
   # Produced Model::CaseOption (aka When)
   case_option
-    : expressions case_colon LBRACE statements RBRACE {
-        result = Factory.WHEN(val[0], val[3])
-        loc result, val[1], val[4]
-      }
-    | expressions case_colon LBRACE RBRACE = LOW {
-        result = Factory.WHEN(val[0], nil)
-        loc result, val[1], val[3]
+    : expressions COLON LBRACE options_statements RBRACE {
+        result = Factory.WHEN(val[0], val[3]); loc result, val[1], val[4]
       }
 
-  case_colon: COLON =CASE_COLON { result = val[0] }
+  options_statements
+    : nil
+    | statements
 
   # This special construct is required or racc will produce the wrong result when the selector entry
   # LHS is generalized to any expression (LBRACE looks like a hash). Thus it is not possible to write
@@ -348,108 +416,11 @@ case_expression
   selector_entry
     : expression FARROW expression { result = Factory.MAP(val[0], val[2]) ; loc result, val[1] }
 
-#---RESOURCE
-#
-# Produces [Model::ResourceExpression, Model::ResourceDefaultsExpression]
-
-# The resource expression parses a generalized syntax and then selects the correct
-# resulting model based on the combinatoin of the LHS and what follows.
-# It also handled exported and virtual resources, and the class case
-#
-resource_expression
-  : expression =LOW {
-      result = val[0]
-    }
-  | at expression LBRACE resourceinstances endsemi RBRACE {
-      result = case Factory.resource_shape(val[1])
-      when :resource, :class
-        tmp = Factory.RESOURCE(Factory.fqn(token_text(val[1])), val[3])
-        tmp.form = val[0]
-        tmp
-      when :defaults
-        error val[1], "A resource default can not be virtual or exported"
-      when :override
-        error val[1], "A resource override can not be virtual or exported"
-      else
-        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, :defaults, :override
-        error val[1], "Defaults are not virtualizable"
-      else
-        error val[1], "Expression is not valid as a resource, resource-default, or resource-override"
-      end
-    }
-  | expression LBRACE resourceinstances endsemi RBRACE {
-      result = case Factory.resource_shape(val[0])
-      when :resource, :class
-        Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
-      when :defaults
-        error val[1], "A resource default can not specify a resource name"
-      when :override
-        error val[1], "A resource override does not allow override of name of resource"
-      else
-        error val[1], "Expression is not valid as a resource, resource-default, or resource-override"
-      end
-      loc result, val[0], val[4]
-    }
-  | expression LBRACE attribute_operations endcomma RBRACE {
-      result = case Factory.resource_shape(val[0])
-      when :resource, :class
-        # This catches deprecated syntax.
-        # 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 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]
-    }
-
-  resourceinst
-    : expression title_colon attribute_operations endcomma { result = Factory.RESOURCE_BODY(val[0], val[2]) }
-
-  title_colon : COLON =TITLE_COLON { result = val[0] }
-
-  resourceinstances
-    : resourceinst                         { result = [val[0]] }
-    | resourceinstances SEMIC resourceinst { result = val[0].push val[2] }
-
-  # Produces Symbol corresponding to resource form
-  #
-  at
-    : AT    { result = :virtual  }
-    | AT AT { result = :exported }
-    | ATAT  { result = :exported }
-
 #---COLLECTION
 #
 # A Collection is a predicate applied to a set of objects with an implied context (used variables are
 # attributes of the object.
-# i.e. this is equivalent for source.select(QUERY).apply(ATTRIBUTE_OPERATIONS)
-#
-# Produces Model::CollectExpression
+# i.e. this is equivalent to source.select(QUERY).apply(ATTRIBUTE_OPERATIONS)
 #
 collection_expression
   : expression collect_query LBRACE attribute_operations endcomma RBRACE {
@@ -469,11 +440,7 @@ collection_expression
     : nil
     | expression
 
-#---ATTRIBUTE OPERATIONS
-#
-# (Not an expression)
-#
-# Produces Array<Model::AttributeOperation>
+#---ATTRIBUTE OPERATIONS (Not an expression)
 #
 attribute_operations
   :                                                { result = [] }
@@ -486,7 +453,7 @@ attribute_operations
   attribute_name
     : NAME
     | keyword
-    | BOOLEAN
+#    | BOOLEAN
 
   # In this version, illegal combinations are validated instead of producing syntax errors
   # (Can give nicer error message "+> is not applicable to...")
@@ -501,6 +468,9 @@ attribute_operations
         result = Factory.ATTRIBUTE_OP(val[0][:value], :'+>', val[2])
         loc result, val[0], val[2]
       }
+  | TIMES FARROW expression {
+      result = Factory.ATTRIBUTES_OP(val[2]) ; loc result, val[0], val[2]
+   }
 
 #---DEFINE
 #
@@ -557,13 +527,13 @@ hostclass_expression
 # Produces Model::NodeDefinition
 #
 node_definition_expression
-  : NODE hostnames nodeparent LBRACE statements RBRACE {
-      result = add_definition(Factory.NODE(val[1], val[2], val[4]))
-      loc result, val[0], val[5]
+  : NODE hostnames endcomma nodeparent LBRACE statements RBRACE {
+      result = add_definition(Factory.NODE(val[1], val[3], val[5]))
+      loc result, val[0], val[6]
     }
-  | NODE hostnames nodeparent LBRACE RBRACE {
-      result = add_definition(Factory.NODE(val[1], val[2], nil))
-      loc result, val[0], val[4]
+  | NODE hostnames endcomma nodeparent LBRACE RBRACE {
+      result = add_definition(Factory.NODE(val[1], val[3], nil))
+      loc result, val[0], val[5]
     }
 
   # Hostnames is not a list of names, it is a list of name matchers (including a Regexp).
@@ -578,14 +548,18 @@ node_definition_expression
   # Produces a LiteralExpression (string, :default, or regexp)
   # String with interpolation is validated for better error message
   hostname
-    : dotted_name { result = val[0] }
-    | quotedtext  { result = val[0] }
+    : dotted_name
+    | quotedtext
     | 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] }
+    : name_or_number   { result = Factory.literal(val[0][:value]); loc result, val[0] }
+    | dotted_name DOT name_or_number { result = Factory.concat(val[0], '.', val[2][:value]); loc result, val[0], val[2] }
+
+  name_or_number
+    : NAME
+    | NUMBER
 
   # Produces Expression, since hostname is an Expression
   nodeparent
@@ -594,8 +568,7 @@ node_definition_expression
 
 #---FUNCTION DEFINITION
 #
-function_definition
-  : FUNCTION { result = Factory.QNAME(val[0][:value]) ; loc result, val[0] }
+#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 {
@@ -607,7 +580,7 @@ function_definition
 #   Produces String
 #   TODO: The error that "class" is not a valid classname is bad - classname rule is also used for other things
 classname
-  : NAME  { result = val[0] }
+  : NAME
   | CLASS { error val[0], "'class' is not a valid classname" }
 
 # Produces Array<Model::Parameter>
@@ -623,32 +596,48 @@ parameters
 
 # Produces Model::Parameter
 parameter
+  : untyped_parameter
+  | typed_parameter
+
+untyped_parameter
+  : regular_parameter
+  | splat_parameter
+
+regular_parameter
   : VARIABLE EQUALS expression { result = Factory.PARAM(val[0][:value], val[2]) ; loc result, val[0] }
   | VARIABLE                   { result = Factory.PARAM(val[0][:value]); loc result, val[0] }
 
-#--RESTRICTED EXPRESSIONS
-#  i.e. where one could have expected an expression, but the set is limited
+splat_parameter
+  : TIMES regular_parameter { result = val[1]; val[1].captures_rest() }
 
-## What is allowed RHS of match operators (see expression)
-#match_rvalue
-#  : regex
-#  | text_or_name
+typed_parameter
+  : parameter_type untyped_parameter { val[1].type_expr(val[0]) ; result = val[1] }
+
+parameter_type
+  : type { result = val[0] }
+  | type LBRACK expressions RBRACK { result = val[0][*val[2]] ; loc result, val[0], val[3] }
 
 #--VARIABLE
 #
 variable
   : VARIABLE { result = Factory.fqn(val[0][:value]).var ; loc result, val[0] }
 
+#---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] }
+  | ATTR      { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
+
 #---LITERALS (dynamic and static)
 #
 
 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] }
+  : LISTSTART assignments endcomma  RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
+  | LISTSTART                       RBRACK { result = Factory.literal([]) ; loc result, val[0] }
+  | LBRACK    assignments endcomma  RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
+  | LBRACK                          RBRACK { result = Factory.literal([]) ; loc result, val[0] }
 
 hash
   : LBRACE hashpairs RBRACE       { result = Factory.HASH(val[1]); loc result, val[0], val[2] }
@@ -660,7 +649,7 @@ hash
     | hashpairs COMMA hashpair { result = val[0].push val[2] }
 
   hashpair
-    : expression FARROW expression { result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1] }
+    : assignment FARROW assignment { result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1] }
 
 quotedtext
   : string
@@ -676,7 +665,7 @@ dqpre           : DQPRE                  { result = Factory.literal(val[0][:valu
 dqpost          : DQPOST                 { result = Factory.literal(val[0][:value]); loc result, val[0] }
 dqmid           : DQMID                  { result = Factory.literal(val[0][:value]); loc result, val[0] }
 dqrval          : text_expression dqtail { result = [val[0]] + val[1] }
-text_expression : expression             { result = Factory.TEXT(val[0]) }
+text_expression : assignment             { result = Factory.TEXT(val[0]) }
 
 dqtail
   : dqpost        { result = [val[0]] }
@@ -690,7 +679,11 @@ sublocated_text
   | 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_START epp_parameters_list optional_statements { result = Factory.EPP(val[1], val[2]); loc result, val[0] }
+
+optional_statements
+  :
+  | statements
 
 epp_parameters_list
   :                                  =LOW{ result = nil }
@@ -706,16 +699,7 @@ 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] }
-default  : DEFAULT  { result = Factory.literal(:default); loc result, val[0] }
-
-          # Assumes lexer produces a Boolean value for booleans, or this will go wrong and produce a literal string
-          # with the text 'true'.
-          #TODO: could be changed to a specific boolean literal factory method to prevent this possible glitch.
-boolean  : BOOLEAN { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
 
 regex
   : REGEX { result = Factory.literal(val[0][:value]); loc result, val[0] }
@@ -745,6 +729,10 @@ keyword
   | OR
   | UNDEF
   | UNLESS
+  | TYPE
+  | ATTR
+  | FUNCTION
+  | PRIVATE
 
 nil
   : { result = nil}