puppet 4.10.0 → 5.0.0

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

@@ -18,7 +18,7 @@ class ModelLabelProvider
     @@label_visitor.visit_this_0(self, o)
   end
 
-  def label_Factory o                     ; label(o.current)                    end
+  def label_Factory o                     ; label(o.model)                      end
   def label_Array o                       ; "Array"                             end
   def label_LiteralInteger o              ; "Literal Integer"                   end
   def label_LiteralFloat o                ; "Literal Float"                     end
@@ -122,7 +122,8 @@ class ModelLabelProvider
       simple_name = o.name.split('::').last
       simple_name[1..-5] + "-Type"
     else
-      o.name
+      n = o.name
+      n.nil? ? 'Anonymous Class' : n
     end
   end
 end

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

@@ -29,7 +29,8 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
   end
 
   def dump_Factory o
-    do_dump(o.current)
+    o['locator'] ||= Puppet::Pops::Parser::Locator.locator("<not from source>", nil)
+    do_dump(o.model)
   end
 
   def dump_Application o
@@ -280,8 +281,8 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
   end
 
   def dump_ResourceOverrideExpression o
-    form = o.form == :regular ? '' : o.form.to_s + "-"
-    result = [form+"override", do_dump(o.resources), :indent]
+    form = o.form == 'regular' ? '' : o.form + '-'
+    result = [form+'override', do_dump(o.resources), :indent]
     o.operations.each do |p|
       result << :break << do_dump(p)
     end
@@ -398,8 +399,8 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
   end
 
   def dump_ResourceDefaultsExpression o
-    form = o.form == :regular ? '' : o.form.to_s + "-"
-    result = [form+"resource-defaults", do_dump(o.type_ref), :indent]
+    form = o.form == 'regular' ? '' : o.form + '-'
+    result = [form+'resource-defaults', do_dump(o.type_ref), :indent]
     o.operations.each do |p|
       result << :break << do_dump(p)
     end
@@ -408,8 +409,8 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
   end
 
   def dump_ResourceExpression o
-    form = o.form == :regular ? '' : o.form.to_s + "-"
-    result = [form+"resource", do_dump(o.type_name), :indent]
+    form = o.form == 'regular' ? '' : o.form + '-'
+    result = [form+'resource', do_dump(o.type_name), :indent]
     o.bodies.each do |b|
       result << :break << do_dump(b)
     end

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

@@ -22,7 +22,6 @@ token RENDER_STRING RENDER_EXPR EPP_START EPP_END EPP_END_TRIM
 token FUNCTION
 token TYPE
 token PRIVATE ATTR
-token APPLICATION_R CONSUMES_R PRODUCES_R SITE_R
 token APPLICATION PRODUCES CONSUMES SITE
 token LOW
 
@@ -66,9 +65,9 @@ preclow
 rule
 # Produces [Model::Program] with a body containing what was parsed
 program
-  : statements     { result = create_program(Factory.block_or_expression(*val[0])) }
-  | epp_expression { result = create_program(Factory.block_or_expression(*val[0])) }
-  |                { result = create_empty_program() }
+  : statements     { result = create_program(Factory.block_or_expression(val[0])) }
+  | epp_expression { result = create_program(val[0]) }
+  |                { result = create_empty_program }
 
 # Produces a semantic model (non validated, but semantically adjusted).
 statements
@@ -117,7 +116,7 @@ resource
     #---VIRTUAL
   | AT resource {
       result = val[1]
-      unless Factory.set_resource_form(result, :virtual)
+      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
@@ -128,7 +127,7 @@ resource
     #---EXPORTED
   | ATAT resource {
       result = val[1]
-      unless Factory.set_resource_form(result, :exported)
+      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
@@ -207,10 +206,10 @@ expression
   | expression MODULO       expression                 { result = val[0] %   val[2]       ; loc result, val[1] }
   | 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] }
+  |            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 ISEQUAL      expression                 { result = val[0].eq  val[2]       ; loc result, val[1] }
   | expression GREATERTHAN  expression                 { result = val[0] >   val[2]       ; loc result, val[1] }
   | expression GREATEREQUAL expression                 { result = val[0] >=  val[2]       ; loc result, val[1] }
   | expression LESSTHAN     expression                 { result = val[0] <   val[2]       ; loc result, val[1] }
@@ -219,11 +218,11 @@ expression
   | 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 QMARK selector_entries                  { result = val[0].select(*val[2])  ; loc result, val[0] }
-  |            LPAREN       assignment RPAREN          { result = val[1].paren()          ; loc result, val[0] }
-  |            WSLPAREN     assignment RPAREN          { result = val[1].paren()          ; loc result, val[0] }
+  |            LPAREN       assignment RPAREN          { result = val[1].paren            ; loc result, val[0] }
+  |            WSLPAREN     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] }
+  : expression LBRACK       expressions endcomma RBRACK =LBRACK { result = val[0].access(val[2])         ; loc result, val[0], val[4] }
 
 #---EXPRESSIONS
 #   (i.e. "argument list")
@@ -345,7 +344,7 @@ if_expression
   # Produces Model::IfExpression
   if_part
     : expression LBRACE statements RBRACE else {
-        result = Factory.IF(val[0], Factory.block_or_expression(*val[2]), val[4])
+        result = Factory.IF(val[0], Factory.block_or_expression(val[2]), val[4])
         loc(result, val[0], (val[4] ? val[4] : val[3]))
       }
     | expression LBRACE RBRACE else {
@@ -361,7 +360,7 @@ if_expression
         loc(result, val[0], val[1])
       }
     | ELSE LBRACE statements RBRACE {
-        result = Factory.block_or_expression(*val[2])
+        result = Factory.block_or_expression(val[2])
         loc result, val[0], val[3]
       }
     | ELSE LBRACE RBRACE {
@@ -372,7 +371,7 @@ if_expression
 #
 unless_expression
   : UNLESS expression LBRACE statements RBRACE unless_else {
-      result = Factory.UNLESS(val[1], Factory.block_or_expression(*val[3]), val[5])
+      result = Factory.UNLESS(val[1], Factory.block_or_expression(val[3]), val[5])
       loc result, val[0], val[4]
     }
   | UNLESS expression LBRACE RBRACE unless_else {
@@ -386,7 +385,7 @@ unless_expression
   unless_else
     : # nothing
     | ELSE LBRACE statements RBRACE {
-        result = Factory.block_or_expression(*val[2])
+        result = Factory.block_or_expression(val[2])
         loc result, val[0], val[3]
       }
     | ELSE LBRACE RBRACE {
@@ -475,10 +474,6 @@ attribute_operations
   attribute_name
     : NAME
     | keyword
-    | 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,11 +481,11 @@ attribute_operations
   #
   attribute_operation
     : attribute_name FARROW expression {
-        result = Factory.ATTRIBUTE_OP(val[0][:value], :'=>', val[2])
+        result = Factory.ATTRIBUTE_OP(val[0][:value], '=>', val[2])
         loc result, val[0], val[2]
       }
     | attribute_name PARROW expression {
-        result = Factory.ATTRIBUTE_OP(val[0][:value], :'+>', val[2])
+        result = Factory.ATTRIBUTE_OP(val[0][:value], '+>', val[2])
         loc result, val[0], val[2]
       }
   | TIMES FARROW expression {
@@ -503,8 +498,9 @@ attribute_operations
 #
 definition_expression
   : 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]
+      definition = Factory.DEFINITION(classname(val[1][:value]), val[2], val[4])
+      loc(definition, val[0], val[5])
+      result = add_definition(definition)
       # New lexer does not keep track of this, this is done in validation
       if @lexer.respond_to?(:'indefine=')
         @lexer.indefine = false
@@ -514,8 +510,9 @@ definition_expression
 #---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]
+    definition = Factory.APPLICATION(classname(val[1][:value]), val[2], val[4])
+    loc(definition, val[0], val[5])
+    result = add_definition(definition)
   }
 
 capability_mapping
@@ -546,8 +543,9 @@ hostclass_expression
   : 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]
+      definition = Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), val[5])
+      loc(definition, val[0], val[6])
+      result = add_definition(definition)
     }
 
   # Record the classname so nested classes gets a fully qualified name at parse-time
@@ -580,12 +578,14 @@ hostclass_expression
 #
 site_definition_expression
   : SITE LBRACE statements RBRACE {
-    result = add_definition(Factory.SITE(val[2]))
-    loc result, val[0], val[3]
+    definition = Factory.SITE(val[2])
+    loc(definition, val[0], val[3])
+    result = add_definition(definition)
     }
   | SITE LBRACE RBRACE {
-    result = add_definition(Factory.SITE(nil))
-    loc result, val[0], val[2]
+    definition = Factory.SITE(nil)
+    loc(definition, val[0], val[2])
+    result = add_definition(definition)
     }
 
 #---NODE
@@ -594,12 +594,14 @@ site_definition_expression
 #
 node_definition_expression
   : NODE hostnames endcomma nodeparent LBRACE statements RBRACE {
-      result = add_definition(Factory.NODE(val[1], val[3], val[5]))
-      loc result, val[0], val[6]
+      definition = Factory.NODE(val[1], val[3], val[5])
+      loc(definition, val[0], val[6])
+      result = add_definition(definition)
     }
   | NODE hostnames endcomma nodeparent LBRACE RBRACE {
-      result = add_definition(Factory.NODE(val[1], val[3], nil))
-      loc result, val[0], val[5]
+      definition = Factory.NODE(val[1], val[3], nil)
+      loc(definition, val[0], val[5])
+      result = add_definition(definition)
     }
 
   # Hostnames is not a list of names, it is a list of name matchers (including a Regexp).
@@ -636,13 +638,14 @@ node_definition_expression
 #
 function_definition
   : FUNCTION classname parameter_list opt_return_type LBRACE opt_statements RBRACE {
-      result = add_definition(Factory.FUNCTION(val[1][:value], val[2], val[5], val[3]))
-      loc result, val[0], val[6]
+      definition = Factory.FUNCTION(val[1][:value], val[2], val[5], val[3])
+      loc(definition, val[0], val[6])
+      result = add_definition(definition)
     }
 
 opt_return_type
-  : RSHIFT type { result = val[1] ; loc result, val[0], val[1] }
-  | RSHIFT type LBRACK expressions RBRACK { result = val[1][*val[3]] ; loc result, val[0], val[4] }
+  : RSHIFT type { result = val[1] }
+  | RSHIFT type LBRACK expressions RBRACK { result = val[1].access(val[3]) ; loc result, val[1], val[4] }
   | nil
 
 #---NAMES AND PARAMETERS COMMON TO SEVERAL RULES
@@ -652,11 +655,8 @@ classname
   : NAME
   | WORD
   | CLASSREF
-  | APPLICATION_R
-  | CONSUMES_R
-  | PRODUCES_R
-  | SITE_R
-  | CLASS { error val[0], "'class' is not a valid classname" }
+  | CLASS { error val[0], "'class' keyword not allowed at this location" }
+  | STRING { error val[0], "A quoted string is not valid as a name here" }
 
 # Produces Array<Model::Parameter>
 parameter_list
@@ -685,48 +685,54 @@ regular_parameter
   | VARIABLE                   { result = Factory.PARAM(val[0][:value]); loc result, val[0] }
 
 splat_parameter
-  : TIMES regular_parameter { result = val[1]; val[1].captures_rest() }
+  : TIMES regular_parameter { result = val[1]; val[1].captures_rest }
 
 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] }
+  | type LBRACK expressions RBRACK { result = val[0].access(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])
+      definition = Factory.TYPE_ASSIGNMENT(val[1], val[3])
+      loc(definition, val[0], val[3])
+      result = add_definition(definition)
     }
 
 #--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])
+        definition = Factory.TYPE_DEFINITION(val[1][:value], nil, val[3])
+        loc(definition, val[0], val[4])
+        result = add_definition(definition)
       }
   | 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])
+        definition = Factory.TYPE_DEFINITION(val[1][:value], val[3][:value], val[5])
+        loc(definition, val[0], val[6])
+        result = add_definition(definition)
       }
 
 #--VARIABLE
 #
 variable
-  : VARIABLE { result = Factory.fqn(val[0][:value]).var ; loc result, val[0] }
+  : VARIABLE {
+     fqn = Factory.fqn(val[0][:value])
+     loc(fqn, val[0])
+     fqn['offset'] += 1
+     fqn['length'] -= 1
+     result = fqn.var
+     loc(result, val[0])
+  }
 
 #---RESERVED WORDS
 #
 reserved_word
   : 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)
 #
@@ -775,7 +781,7 @@ string
   : STRING  { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
   | WORD    { 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] }
+dq_string       : dqpre dqrval           { result = Factory.STRING(val[0], *val[1]) ; loc result, val[0], val[1][-1] }
 dqpre           : DQPRE                  { result = Factory.literal(val[0][:value]); loc result, val[0] }
 dqpost          : DQPOST                 { result = Factory.literal(val[0][:value]); loc result, val[0] }
 dqmid           : DQMID                  { result = Factory.literal(val[0][:value]); loc result, val[0] }
@@ -808,7 +814,7 @@ epp_parameters_list
 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] }
+  | 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