[4638] Cleanup of plurals and inheritance relationships in AST

Changed the grammar so that the following "plural" constructs always
parse as an ASTArray:

- funcvalues
- rvalues
- resourceinstances
- anyparams
- params
- caseopts
- casevalues

And the following "singluar" construct never parses as an ASTArray:

- statement

The previous behavior was for these constructs to parse as a scalar
when they represented a single item and an ASTArray when they
contained zero or multiple items.  ("Statement" could sometimes
represent a single item because a single resource declaration could
represent multiple resources).  This complicated other grammar rules
and caused ambiguous handling of nested arrays.

Also made these changes to the AST class hierarchy:

- ResourceInstance no longer derives from ASTArray.  This relationship
  was not meaningful because a ResourceInstance is a (title,
  parameters) pair, not an array, and it produced complications when
  we wanted to represent an array of ResourceInstance objects.

- Resource no longer derives from ResourceReference.  No significant
  functionality was being inherited and the relationship doesn't make
  sense in an AST context.

- ResourceOverride no longer derives from Resource.  No significant
  functionality was being inherited and the relationship doesn't make
  sense in an AST context.

- Resource can now represent a compound resource instance such as
  "notify { foo: ; bar: }".  This saves the parser from having to
  use represent a statement as an array of objects.

- ASTArray's evaluate method never flattens out arrays of arrays.

1 files changed, 9 insertions, 25 deletions

diff --git a/lib/puppet/parser/ast/astarray.rb b/lib/puppet/parser/ast/astarray.rb
index 432300c7a..b62c820ca 100644
--- a/lib/puppet/parser/ast/astarray.rb
+++ b/lib/puppet/parser/ast/astarray.rb
@@ -21,22 +21,8 @@ class Puppet::Parser::AST
 
     # Evaluate our children.
     def evaluate(scope)
-      # Make a new array, so we don't have to deal with the details of
-      # flattening and such
-      items = []
-
-      # First clean out any AST::ASTArrays
-      @children.each { |child|
-        if child.instance_of?(AST::ASTArray)
-          child.each do |ac|
-            items << ac
-          end
-        else
-          items << child
-        end
-      }
-
-      rets = items.flatten.collect { |child|
+      result = []
+      @children.each do |child|
         if child.respond_to? :instantiate
           if is_a_namespace
             # no problem, just don't evaluate it.
@@ -48,10 +34,14 @@ class Puppet::Parser::AST
             raise error
           end
         else
-          child.safeevaluate(scope)
+          item = child.safeevaluate(scope)
+          if !item.nil?
+            # nil values are implicitly removed.
+            result.push(item)
+          end
         end
-      }
-      rets.reject { |o| o.nil? }
+      end
+      result
     end
 
     def push(*ary)
@@ -69,10 +59,4 @@ class Puppet::Parser::AST
       "[" + @children.collect { |c| c.to_s }.join(', ') + "]"
     end
   end
-
-  # A simple container class, containing the parameters for an object.
-  # Used for abstracting the grammar declarations.  Basically unnecessary
-  # except that I kept finding bugs because I had too many arrays that
-  # meant completely different things.
-  class ResourceInstance < ASTArray; end
 end