[#4496]+[#4521]+[#4522] Add structures to the AST to represent type definitions (classes, definitions, and nodes).

Previously, type definitions were not represented directly in the AST.
Instead, the parser would instantiate types and insert them into
known_resource_types as soon as they were parsed.  This made it
difficult to distinguish which types had come from the file that was
just parsed and which types had been loaded previously, which led to
bug 4496.

A side-effect of this change is that the user is no longer allowed to
define types inside of conditional constructs (such as if/else).  This
was allowed before but had unexpected semantics (bugs 4521 and 4522).

It is still possible, however, to place an "include" statement inside
a conditional construct, and have that "include" statement trigger the
autoloading of a file that instantiates types.

14 files changed, 1666 insertions, 1517 deletions

diff --git a/lib/puppet/node/environment.rb b/lib/puppet/node/environment.rb
index ad11a0476..3d55ac1a0 100644
--- a/lib/puppet/node/environment.rb
+++ b/lib/puppet/node/environment.rb
@@ -81,7 +81,7 @@ class Puppet::Node::Environment
     Thread.current[:known_resource_types] ||= synchronize {
       if @known_resource_types.nil? or @known_resource_types.stale?
         @known_resource_types = Puppet::Resource::TypeCollection.new(self)
-        perform_initial_import
+        @known_resource_types.import_ast(perform_initial_import, '')
       end
       @known_resource_types
     }
@@ -146,13 +146,13 @@ class Puppet::Node::Environment
   private
 
   def perform_initial_import
-    return if Puppet.settings[:ignoreimport]
+    return empty_parse_result if Puppet.settings[:ignoreimport]
     parser = Puppet::Parser::Parser.new(self)
     if code = Puppet.settings.uninterpolated_value(:code, name.to_s) and code != ""
       parser.string = code
     else
       file = Puppet.settings.value(:manifest, name.to_s)
-      return unless File.exist?(file)
+      return empty_parse_result unless File.exist?(file)
       parser.file = file
     end
     parser.parse
@@ -163,5 +163,11 @@ class Puppet::Node::Environment
     raise error
   end
 
+  def empty_parse_result
+    # Return an empty toplevel hostclass to use as the result of
+    # perform_initial_import when no file was actually loaded.
+    return Puppet::Parser::AST::Hostclass.new('')
+  end
+
   @root = new(:'*root*')
 end
diff --git a/lib/puppet/parser/ast.rb b/lib/puppet/parser/ast.rb
index 54e034acb..0369a6d28 100644
--- a/lib/puppet/parser/ast.rb
+++ b/lib/puppet/parser/ast.rb
@@ -107,22 +107,26 @@ end
 require 'puppet/parser/ast/arithmetic_operator'
 require 'puppet/parser/ast/astarray'
 require 'puppet/parser/ast/asthash'
-require 'puppet/parser/ast/branch'
 require 'puppet/parser/ast/boolean_operator'
+require 'puppet/parser/ast/branch'
 require 'puppet/parser/ast/caseopt'
 require 'puppet/parser/ast/casestatement'
 require 'puppet/parser/ast/collection'
 require 'puppet/parser/ast/collexpr'
 require 'puppet/parser/ast/comparison_operator'
+require 'puppet/parser/ast/definition'
 require 'puppet/parser/ast/else'
 require 'puppet/parser/ast/function'
+require 'puppet/parser/ast/hostclass'
 require 'puppet/parser/ast/ifstatement'
 require 'puppet/parser/ast/in_operator'
 require 'puppet/parser/ast/leaf'
 require 'puppet/parser/ast/match_operator'
 require 'puppet/parser/ast/minus'
+require 'puppet/parser/ast/node'
 require 'puppet/parser/ast/nop'
 require 'puppet/parser/ast/not'
+require 'puppet/parser/ast/relationship'
 require 'puppet/parser/ast/resource'
 require 'puppet/parser/ast/resource_defaults'
 require 'puppet/parser/ast/resource_override'
@@ -131,4 +135,3 @@ require 'puppet/parser/ast/resourceparam'
 require 'puppet/parser/ast/selector'
 require 'puppet/parser/ast/tag'
 require 'puppet/parser/ast/vardef'
-require 'puppet/parser/ast/relationship'
diff --git a/lib/puppet/parser/ast/astarray.rb b/lib/puppet/parser/ast/astarray.rb
index 529998e3c..432300c7a 100644
--- a/lib/puppet/parser/ast/astarray.rb
+++ b/lib/puppet/parser/ast/astarray.rb
@@ -9,6 +9,11 @@ class Puppet::Parser::AST
   class ASTArray < Branch
     include Enumerable
 
+    # True if this ASTArray represents a list of statements in a
+    # context that defines a namespace.  Classes and definitions may
+    # only appear in such a context.
+    attr_accessor :is_a_namespace
+
     # Return a child by index.  Probably never used.
     def [](index)
       @children[index]
@@ -32,7 +37,19 @@ class Puppet::Parser::AST
       }
 
       rets = items.flatten.collect { |child|
-        child.safeevaluate(scope)
+        if child.respond_to? :instantiate
+          if is_a_namespace
+            # no problem, just don't evaluate it.
+          else
+            msg = "Classes, definitions, and nodes may only appear at toplevel or inside other classes"
+            error = Puppet::Error.new(msg)
+            error.line = child.line
+            error.file = child.file
+            raise error
+          end
+        else
+          child.safeevaluate(scope)
+        end
       }
       rets.reject { |o| o.nil? }
     end
diff --git a/lib/puppet/parser/ast/definition.rb b/lib/puppet/parser/ast/definition.rb
new file mode 100644
index 000000000..09f52b519
--- /dev/null
+++ b/lib/puppet/parser/ast/definition.rb
@@ -0,0 +1,12 @@
+require 'puppet/parser/ast/top_level_construct'
+
+class Puppet::Parser::AST::Definition < Puppet::Parser::AST::TopLevelConstruct
+  def initialize(name, context = {})
+    @name = name
+    @context = context
+  end
+
+  def instantiate(modname)
+    return [Puppet::Resource::Type.new(:definition, @name, @context.merge(:module_name => modname))]
+  end
+end
diff --git a/lib/puppet/parser/ast/hostclass.rb b/lib/puppet/parser/ast/hostclass.rb
new file mode 100644
index 000000000..d539e4deb
--- /dev/null
+++ b/lib/puppet/parser/ast/hostclass.rb
@@ -0,0 +1,26 @@
+require 'puppet/parser/ast/top_level_construct'
+
+class Puppet::Parser::AST::Hostclass < Puppet::Parser::AST::TopLevelConstruct
+  attr_accessor :name, :context
+
+  def initialize(name, context = {})
+    @context = context
+    @name = name
+  end
+
+  def instantiate(modname)
+    all_types = [Puppet::Resource::Type.new(:hostclass, @name, @context.merge(:module_name => modname))]
+    if code
+      code.each do |nested_ast_node|
+        if nested_ast_node.respond_to? :instantiate
+          all_types += nested_ast_node.instantiate(modname)
+        end
+      end
+    end
+    return all_types
+  end
+
+  def code()
+    @context[:code]
+  end
+end
diff --git a/lib/puppet/parser/ast/node.rb b/lib/puppet/parser/ast/node.rb
new file mode 100644
index 000000000..c19a24ce0
--- /dev/null
+++ b/lib/puppet/parser/ast/node.rb
@@ -0,0 +1,17 @@
+require 'puppet/parser/ast/top_level_construct'
+
+class Puppet::Parser::AST::Node < Puppet::Parser::AST::TopLevelConstruct
+  attr_accessor :names
+
+  def initialize(names, context = {})
+    raise ArgumentError, "names should be an array" unless names.is_a? Array
+    @names = names
+    @context = context
+  end
+
+  def instantiate(modname)
+    @names.collect do |name|
+      Puppet::Resource::Type.new(:node, name, @context.merge(:module_name => modname))
+    end
+  end
+end
diff --git a/lib/puppet/parser/ast/top_level_construct.rb b/lib/puppet/parser/ast/top_level_construct.rb
new file mode 100644
index 000000000..901a939c2
--- /dev/null
+++ b/lib/puppet/parser/ast/top_level_construct.rb
@@ -0,0 +1,4 @@
+# The base class for AST nodes representing top level things:
+# hostclasses, definitions, and nodes.
+class Puppet::Parser::AST::TopLevelConstruct < Puppet::Parser::AST
+end
diff --git a/lib/puppet/parser/grammar.ra b/lib/puppet/parser/grammar.ra
index 7a316d4d7..3185c435d 100644
--- a/lib/puppet/parser/grammar.ra
+++ b/lib/puppet/parser/grammar.ra
@@ -29,37 +29,18 @@ preclow
 
 rule
 program:    statements {
-  if val[0]
-    # Make sure we always return an array.
-    if val[0].is_a?(AST::ASTArray)
-      if val[0].children.empty?
-        result = nil
-      else
-        result = val[0]
-      end
-    else
-      result = aryfy(val[0])
-    end
-  else
-    result = nil
-  end
+  val[0].is_a_namespace = true
+  result = val[0]
 }
   | nil
 
-statements:   statement
+  statements:   statement {
+    result = ast AST::ASTArray, :children => [val[0]]
+  }
   | statements statement {
-    if val[0] and val[1]
-    if val[0].instance_of?(AST::ASTArray)
-      val[0].push(val[1])
-      result = val[0]
-    else
-      result = ast AST::ASTArray, :children => [val[0],val[1]]
-    end
-  elsif obj = (val[0] || val[1])
-    result = obj
-  else result = nil
-  end
-}
+    val[0].push(val[1])
+    result = val[0]
+  }
 
 # The main list of valid statements
 statement:    resource
@@ -664,16 +645,17 @@ import: IMPORT strings {
 #definition: DEFINE NAME argumentlist parent LBRACE statements RBRACE {
 definition: DEFINE classname argumentlist LBRACE statements RBRACE {
   @lexer.commentpop
-  newdefine classname(val[1]), :arguments => val[2], :code => val[4], :line => val[0][:line]
+  result = Puppet::Parser::AST::Definition.new(classname(val[1]),
+                                               ast_context(true).merge(:arguments => val[2], :code => val[4],
+                                                                       :line => val[0][:line]))
   @lexer.indefine = false
-  result = nil
 
 #}           | DEFINE NAME argumentlist parent LBRACE RBRACE {
 }           | DEFINE classname argumentlist LBRACE RBRACE {
   @lexer.commentpop
-  newdefine classname(val[1]), :arguments => val[2], :line => val[0][:line]
+  result = Puppet::Parser::AST::Definition.new(classname(val[1]),
+                                               ast_context(true).merge(:arguments => val[2], :line => val[0][:line]))
   @lexer.indefine = false
-  result = nil
 }
 
 #hostclass: CLASS NAME argumentlist parent LBRACE statements RBRACE {
@@ -681,24 +663,27 @@ hostclass: CLASS classname argumentlist classparent LBRACE statements RBRACE {
   @lexer.commentpop
   # Our class gets defined in the parent namespace, not our own.
   @lexer.namepop
-  newclass classname(val[1]), :arguments => val[2], :parent => val[3], :code => val[5], :line => val[0][:line]
-  result = nil
+  val[5].is_a_namespace = true
+  result = Puppet::Parser::AST::Hostclass.new(classname(val[1]),
+                                              ast_context(true).merge(:arguments => val[2], :parent => val[3],
+                                                                      :code => val[5], :line => val[0][:line]))
 }           | CLASS classname argumentlist classparent LBRACE RBRACE {
   @lexer.commentpop
   # Our class gets defined in the parent namespace, not our own.
   @lexer.namepop
-  newclass classname(val[1]), :arguments => val[2], :parent => val[3], :line => val[0][:line]
-  result = nil
+  result = Puppet::Parser::AST::Hostclass.new(classname(val[1]),
+                                              ast_context(true).merge(:arguments => val[2], :parent => val[3],
+                                                                      :line => val[0][:line]))
 }
 
 nodedef: NODE hostnames nodeparent LBRACE statements RBRACE {
   @lexer.commentpop
-  newnode val[1], :parent => val[2], :code => val[4], :line => val[0][:line]
-  result = nil
+  result = Puppet::Parser::AST::Node.new(val[1],
+                                         ast_context(true).merge(:parent => val[2], :code => val[4],
+                                                                 :line => val[0][:line]))
 }       |  NODE hostnames nodeparent LBRACE RBRACE {
   @lexer.commentpop
-  newnode val[1], :parent => val[2], :line => val[0][:line]
-  result = nil
+  result = Puppet::Parser::AST::Node.new(val[1], ast_context(true).merge(:parent => val[2], :line => val[0][:line]))
 }
 
 classref:       CLASSREF { result = val[0][:value] }
@@ -709,10 +694,11 @@ classname:       NAME { result = val[0][:value] }
 
 # Multiple hostnames, as used for node names.  These are all literal
 # strings, not AST objects.
-hostnames:    nodename
+hostnames:    nodename {
+    result = [result]
+}
   | hostnames COMMA nodename {
     result = val[0]
-    result = [result] unless result.is_a?(Array)
     result << val[2]
 }
 
diff --git a/lib/puppet/parser/parser.rb b/lib/puppet/parser/parser.rb
index 5be9e5a3f..e4f5149b9 100644
--- a/lib/puppet/parser/parser.rb
+++ b/lib/puppet/parser/parser.rb
@@ -1,11 +1,10 @@
 #
 # DO NOT MODIFY!!!!
-# This file is automatically generated by racc 1.4.5
-# from racc grammer file "grammar.ra".
+# This file is automatically generated by Racc 1.4.6
+# from Racc grammer file "".
 #
 
-require 'racc/parser'
-
+require 'racc/parser.rb'
 
 require 'puppet'
 require 'puppet/util/loadedfile'
@@ -13,19 +12,16 @@ require 'puppet/parser/lexer'
 require 'puppet/parser/ast'
 
 module Puppet
-    class ParseError < Puppet::Error; end
-    class ImportError < Racc::ParseError; end
-    class AlreadyImportedError < ImportError; end
+  class ParseError < Puppet::Error; end
+  class ImportError < Racc::ParseError; end
+  class AlreadyImportedError < ImportError; end
 end
 
-
 module Puppet
-
   module Parser
-
     class Parser < Racc::Parser
 
-module_eval <<'..end grammar.ra modeval..id7145220b1b', 'grammar.ra', 876
+module_eval(<<'...end grammar.ra/module_eval...', 'grammar.ra', 851)
 
 # It got too annoying having code in a file that needs to be compiled.
 require 'puppet/parser/parser_support'
@@ -36,249 +32,8 @@ require 'puppet/parser/parser_support'
 # End:
 
 # $Id$
-
-..end grammar.ra modeval..id7145220b1b
-
-##### racc 1.4.5 generates ###
-
-racc_reduce_table = [
- 0, 0, :racc_error,
- 1, 70, :_reduce_1,
- 1, 70, :_reduce_none,
- 1, 71, :_reduce_none,
- 2, 71, :_reduce_4,
- 1, 73, :_reduce_none,
- 1, 73, :_reduce_none,
- 1, 73, :_reduce_none,
- 1, 73, :_reduce_none,
- 1, 73, :_reduce_none,
- 1, 73, :_reduce_none,
- 1, 73, :_reduce_none,
- 1, 73, :_reduce_none,
- 1, 73, :_reduce_none,
- 1, 73, :_reduce_none,
- 1, 73, :_reduce_none,
- 1, 73, :_reduce_none,
- 1, 73, :_reduce_none,
- 1, 73, :_reduce_none,
- 3, 87, :_reduce_19,
- 3, 87, :_reduce_20,
- 1, 88, :_reduce_none,
- 1, 88, :_reduce_none,
- 1, 88, :_reduce_none,
- 1, 89, :_reduce_none,
- 1, 89, :_reduce_none,
- 1, 89, :_reduce_none,
- 1, 89, :_reduce_none,
- 4, 81, :_reduce_28,
- 5, 81, :_reduce_29,
- 3, 81, :_reduce_30,
- 2, 81, :_reduce_31,
- 1, 91, :_reduce_none,
- 1, 91, :_reduce_none,
- 3, 91, :_reduce_34,
- 3, 91, :_reduce_35,
- 1, 92, :_reduce_none,
- 1, 92, :_reduce_none,
- 1, 92, :_reduce_none,
- 1, 92, :_reduce_none,
- 1, 92, :_reduce_none,
- 1, 92, :_reduce_none,
- 1, 92, :_reduce_none,
- 1, 92, :_reduce_none,
- 1, 92, :_reduce_44,
- 5, 74, :_reduce_45,
- 5, 74, :_reduce_46,
- 5, 74, :_reduce_47,
- 5, 85, :_reduce_48,
- 2, 75, :_reduce_49,
- 1, 108, :_reduce_50,
- 2, 108, :_reduce_51,
- 6, 76, :_reduce_52,
- 2, 76, :_reduce_53,
- 3, 109, :_reduce_54,
- 3, 109, :_reduce_55,
- 1, 110, :_reduce_none,
- 1, 110, :_reduce_none,
- 3, 110, :_reduce_58,
- 1, 111, :_reduce_none,
- 3, 111, :_reduce_60,
- 1, 112, :_reduce_61,
- 1, 112, :_reduce_62,
- 3, 113, :_reduce_63,
- 3, 113, :_reduce_64,
- 1, 114, :_reduce_none,
- 1, 114, :_reduce_none,
- 4, 116, :_reduce_67,
- 1, 102, :_reduce_none,
- 3, 102, :_reduce_69,
- 0, 103, :_reduce_none,
- 1, 103, :_reduce_none,
- 1, 118, :_reduce_72,
- 1, 93, :_reduce_73,
- 1, 95, :_reduce_74,
- 1, 117, :_reduce_none,
- 1, 117, :_reduce_none,
- 1, 117, :_reduce_none,
- 1, 117, :_reduce_none,
- 1, 117, :_reduce_none,
- 1, 117, :_reduce_none,
- 1, 117, :_reduce_none,
- 3, 77, :_reduce_82,
- 3, 77, :_reduce_83,
- 3, 86, :_reduce_84,
- 0, 104, :_reduce_85,
- 1, 104, :_reduce_86,
- 3, 104, :_reduce_87,
- 3, 122, :_reduce_88,
- 3, 124, :_reduce_89,
- 1, 125, :_reduce_none,
- 1, 125, :_reduce_none,
- 0, 107, :_reduce_92,
- 1, 107, :_reduce_93,
- 3, 107, :_reduce_94,
- 1, 126, :_reduce_none,
- 3, 126, :_reduce_96,
- 1, 115, :_reduce_none,
- 1, 115, :_reduce_none,
- 1, 115, :_reduce_none,
- 1, 115, :_reduce_none,
- 1, 115, :_reduce_none,
- 1, 115, :_reduce_none,
- 1, 123, :_reduce_none,
- 1, 123, :_reduce_none,
- 1, 123, :_reduce_none,
- 1, 123, :_reduce_none,
- 1, 123, :_reduce_none,
- 1, 123, :_reduce_none,
- 1, 123, :_reduce_none,
- 1, 123, :_reduce_none,
- 1, 123, :_reduce_none,
- 1, 123, :_reduce_none,
- 1, 123, :_reduce_none,
- 1, 123, :_reduce_none,
- 4, 97, :_reduce_115,
- 3, 97, :_reduce_116,
- 1, 99, :_reduce_117,
- 2, 99, :_reduce_118,
- 2, 129, :_reduce_119,
- 1, 130, :_reduce_120,
- 2, 130, :_reduce_121,
- 1, 96, :_reduce_122,
- 4, 90, :_reduce_123,
- 4, 90, :_reduce_124,
- 2, 79, :_reduce_125,
- 5, 131, :_reduce_126,
- 4, 131, :_reduce_127,
- 0, 132, :_reduce_none,
- 2, 132, :_reduce_129,
- 4, 132, :_reduce_130,
- 3, 132, :_reduce_131,
- 1, 120, :_reduce_none,
- 3, 120, :_reduce_133,
- 3, 120, :_reduce_134,
- 3, 120, :_reduce_135,
- 3, 120, :_reduce_136,
- 3, 120, :_reduce_137,
- 3, 120, :_reduce_138,
- 3, 120, :_reduce_139,
- 3, 120, :_reduce_140,
- 3, 120, :_reduce_141,
- 2, 120, :_reduce_142,
- 3, 120, :_reduce_143,
- 3, 120, :_reduce_144,
- 3, 120, :_reduce_145,
- 3, 120, :_reduce_146,
- 3, 120, :_reduce_147,
- 3, 120, :_reduce_148,
- 2, 120, :_reduce_149,
- 3, 120, :_reduce_150,
- 3, 120, :_reduce_151,
- 3, 120, :_reduce_152,
- 5, 78, :_reduce_153,
- 1, 134, :_reduce_none,
- 2, 134, :_reduce_155,
- 5, 135, :_reduce_156,
- 4, 135, :_reduce_157,
- 1, 136, :_reduce_none,
- 3, 136, :_reduce_159,
- 3, 98, :_reduce_160,
- 1, 138, :_reduce_none,
- 4, 138, :_reduce_162,
- 1, 140, :_reduce_none,
- 3, 140, :_reduce_164,
- 3, 139, :_reduce_165,
- 1, 137, :_reduce_none,
- 1, 137, :_reduce_none,
- 1, 137, :_reduce_none,
- 1, 137, :_reduce_none,
- 1, 137, :_reduce_none,
- 1, 137, :_reduce_none,
- 1, 137, :_reduce_none,
- 1, 137, :_reduce_173,
- 1, 137, :_reduce_none,
- 1, 141, :_reduce_175,
- 1, 142, :_reduce_none,
- 3, 142, :_reduce_177,
- 2, 80, :_reduce_178,
- 6, 82, :_reduce_179,
- 5, 82, :_reduce_180,
- 7, 83, :_reduce_181,
- 6, 83, :_reduce_182,
- 6, 84, :_reduce_183,
- 5, 84, :_reduce_184,
- 1, 106, :_reduce_185,
- 1, 101, :_reduce_186,
- 1, 101, :_reduce_187,
- 1, 101, :_reduce_188,
- 1, 145, :_reduce_none,
- 3, 145, :_reduce_190,
- 1, 147, :_reduce_191,
- 1, 148, :_reduce_192,
- 1, 148, :_reduce_193,
- 1, 148, :_reduce_194,
- 1, 148, :_reduce_none,
- 0, 72, :_reduce_196,
- 0, 149, :_reduce_197,
- 1, 143, :_reduce_none,
- 3, 143, :_reduce_199,
- 3, 143, :_reduce_200,
- 1, 150, :_reduce_none,
- 3, 150, :_reduce_202,
- 3, 151, :_reduce_203,
- 1, 151, :_reduce_204,
- 3, 151, :_reduce_205,
- 1, 151, :_reduce_206,
- 1, 146, :_reduce_none,
- 2, 146, :_reduce_208,
- 1, 144, :_reduce_none,
- 2, 144, :_reduce_210,
- 1, 152, :_reduce_none,
- 1, 152, :_reduce_none,
- 1, 94, :_reduce_213,
- 3, 119, :_reduce_214,
- 4, 119, :_reduce_215,
- 2, 119, :_reduce_216,
- 1, 127, :_reduce_none,
- 1, 127, :_reduce_none,
- 0, 105, :_reduce_none,
- 1, 105, :_reduce_220,
- 1, 133, :_reduce_221,
- 3, 128, :_reduce_222,
- 4, 128, :_reduce_223,
- 2, 128, :_reduce_224,
- 1, 153, :_reduce_none,
- 3, 153, :_reduce_226,
- 3, 154, :_reduce_227,
- 1, 155, :_reduce_228,
- 1, 155, :_reduce_229,
- 4, 121, :_reduce_230,
- 1, 100, :_reduce_none,
- 4, 100, :_reduce_232 ]
-
-racc_reduce_n = 233
-
-racc_shift_n = 384
+...end grammar.ra/module_eval...
+##### State transition tables begin ###
 
 racc_action_table = [
    256,   257,   228,    82,    54,    72,    75,   181,   251,    48,
@@ -920,1683 +675,2015 @@ racc_goto_default = [
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    57,
    nil,   nil,   nil,   nil,   nil,   nil,   192 ]
 
-racc_token_table = {
- false => 0,
- Object.new => 1,
- :STRING => 2,
- :DQPRE => 3,
- :DQMID => 4,
- :DQPOST => 5,
- :LBRACK => 6,
- :RBRACK => 7,
- :LBRACE => 8,
- :RBRACE => 9,
- :SYMBOL => 10,
- :FARROW => 11,
- :COMMA => 12,
- :TRUE => 13,
- :FALSE => 14,
- :EQUALS => 15,
- :APPENDS => 16,
- :LESSEQUAL => 17,
- :NOTEQUAL => 18,
- :DOT => 19,
- :COLON => 20,
- :LLCOLLECT => 21,
- :RRCOLLECT => 22,
- :QMARK => 23,
- :LPAREN => 24,
- :RPAREN => 25,
- :ISEQUAL => 26,
- :GREATEREQUAL => 27,
- :GREATERTHAN => 28,
- :LESSTHAN => 29,
- :IF => 30,
- :ELSE => 31,
- :IMPORT => 32,
- :DEFINE => 33,
- :ELSIF => 34,
- :VARIABLE => 35,
- :CLASS => 36,
- :INHERITS => 37,
- :NODE => 38,
- :BOOLEAN => 39,
- :NAME => 40,
- :SEMIC => 41,
- :CASE => 42,
- :DEFAULT => 43,
- :AT => 44,
- :LCOLLECT => 45,
- :RCOLLECT => 46,
- :CLASSNAME => 47,
- :CLASSREF => 48,
- :NOT => 49,
- :OR => 50,
- :AND => 51,
- :UNDEF => 52,
- :PARROW => 53,
- :PLUS => 54,
- :MINUS => 55,
- :TIMES => 56,
- :DIV => 57,
- :LSHIFT => 58,
- :RSHIFT => 59,
- :UMINUS => 60,
- :MATCH => 61,
- :NOMATCH => 62,
- :REGEX => 63,
- :IN_EDGE => 64,
- :OUT_EDGE => 65,
- :IN_EDGE_SUB => 66,
- :OUT_EDGE_SUB => 67,
- :IN => 68 }
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 70, :_reduce_1,
+  1, 70, :_reduce_none,
+  1, 71, :_reduce_3,
+  2, 71, :_reduce_4,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  3, 87, :_reduce_19,
+  3, 87, :_reduce_20,
+  1, 88, :_reduce_none,
+  1, 88, :_reduce_none,
+  1, 88, :_reduce_none,
+  1, 89, :_reduce_none,
+  1, 89, :_reduce_none,
+  1, 89, :_reduce_none,
+  1, 89, :_reduce_none,
+  4, 81, :_reduce_28,
+  5, 81, :_reduce_29,
+  3, 81, :_reduce_30,
+  2, 81, :_reduce_31,
+  1, 91, :_reduce_none,
+  1, 91, :_reduce_none,
+  3, 91, :_reduce_34,
+  3, 91, :_reduce_35,
+  1, 92, :_reduce_none,
+  1, 92, :_reduce_none,
+  1, 92, :_reduce_none,
+  1, 92, :_reduce_none,
+  1, 92, :_reduce_none,
+  1, 92, :_reduce_none,
+  1, 92, :_reduce_none,
+  1, 92, :_reduce_none,
+  1, 92, :_reduce_44,
+  5, 74, :_reduce_45,
+  5, 74, :_reduce_46,
+  5, 74, :_reduce_47,
+  5, 85, :_reduce_48,
+  2, 75, :_reduce_49,
+  1, 108, :_reduce_50,
+  2, 108, :_reduce_51,
+  6, 76, :_reduce_52,
+  2, 76, :_reduce_53,
+  3, 109, :_reduce_54,
+  3, 109, :_reduce_55,
+  1, 110, :_reduce_none,
+  1, 110, :_reduce_none,
+  3, 110, :_reduce_58,
+  1, 111, :_reduce_none,
+  3, 111, :_reduce_60,
+  1, 112, :_reduce_61,
+  1, 112, :_reduce_62,
+  3, 113, :_reduce_63,
+  3, 113, :_reduce_64,
+  1, 114, :_reduce_none,
+  1, 114, :_reduce_none,
+  4, 116, :_reduce_67,
+  1, 102, :_reduce_none,
+  3, 102, :_reduce_69,
+  0, 103, :_reduce_none,
+  1, 103, :_reduce_none,
+  1, 118, :_reduce_72,
+  1, 93, :_reduce_73,
+  1, 95, :_reduce_74,
+  1, 117, :_reduce_none,
+  1, 117, :_reduce_none,
+  1, 117, :_reduce_none,
+  1, 117, :_reduce_none,
+  1, 117, :_reduce_none,
+  1, 117, :_reduce_none,
+  1, 117, :_reduce_none,
+  3, 77, :_reduce_82,
+  3, 77, :_reduce_83,
+  3, 86, :_reduce_84,
+  0, 104, :_reduce_85,
+  1, 104, :_reduce_86,
+  3, 104, :_reduce_87,
+  3, 122, :_reduce_88,
+  3, 124, :_reduce_89,
+  1, 125, :_reduce_none,
+  1, 125, :_reduce_none,
+  0, 107, :_reduce_92,
+  1, 107, :_reduce_93,
+  3, 107, :_reduce_94,
+  1, 126, :_reduce_none,
+  3, 126, :_reduce_96,
+  1, 115, :_reduce_none,
+  1, 115, :_reduce_none,
+  1, 115, :_reduce_none,
+  1, 115, :_reduce_none,
+  1, 115, :_reduce_none,
+  1, 115, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  4, 97, :_reduce_115,
+  3, 97, :_reduce_116,
+  1, 99, :_reduce_117,
+  2, 99, :_reduce_118,
+  2, 129, :_reduce_119,
+  1, 130, :_reduce_120,
+  2, 130, :_reduce_121,
+  1, 96, :_reduce_122,
+  4, 90, :_reduce_123,
+  4, 90, :_reduce_124,
+  2, 79, :_reduce_125,
+  5, 131, :_reduce_126,
+  4, 131, :_reduce_127,
+  0, 132, :_reduce_none,
+  2, 132, :_reduce_129,
+  4, 132, :_reduce_130,
+  3, 132, :_reduce_131,
+  1, 120, :_reduce_none,
+  3, 120, :_reduce_133,
+  3, 120, :_reduce_134,
+  3, 120, :_reduce_135,
+  3, 120, :_reduce_136,
+  3, 120, :_reduce_137,
+  3, 120, :_reduce_138,
+  3, 120, :_reduce_139,
+  3, 120, :_reduce_140,
+  3, 120, :_reduce_141,
+  2, 120, :_reduce_142,
+  3, 120, :_reduce_143,
+  3, 120, :_reduce_144,
+  3, 120, :_reduce_145,
+  3, 120, :_reduce_146,
+  3, 120, :_reduce_147,
+  3, 120, :_reduce_148,
+  2, 120, :_reduce_149,
+  3, 120, :_reduce_150,
+  3, 120, :_reduce_151,
+  3, 120, :_reduce_152,
+  5, 78, :_reduce_153,
+  1, 134, :_reduce_none,
+  2, 134, :_reduce_155,
+  5, 135, :_reduce_156,
+  4, 135, :_reduce_157,
+  1, 136, :_reduce_none,
+  3, 136, :_reduce_159,
+  3, 98, :_reduce_160,
+  1, 138, :_reduce_none,
+  4, 138, :_reduce_162,
+  1, 140, :_reduce_none,
+  3, 140, :_reduce_164,
+  3, 139, :_reduce_165,
+  1, 137, :_reduce_none,
+  1, 137, :_reduce_none,
+  1, 137, :_reduce_none,
+  1, 137, :_reduce_none,
+  1, 137, :_reduce_none,
+  1, 137, :_reduce_none,
+  1, 137, :_reduce_none,
+  1, 137, :_reduce_173,
+  1, 137, :_reduce_none,
+  1, 141, :_reduce_175,
+  1, 142, :_reduce_none,
+  3, 142, :_reduce_177,
+  2, 80, :_reduce_178,
+  6, 82, :_reduce_179,
+  5, 82, :_reduce_180,
+  7, 83, :_reduce_181,
+  6, 83, :_reduce_182,
+  6, 84, :_reduce_183,
+  5, 84, :_reduce_184,
+  1, 106, :_reduce_185,
+  1, 101, :_reduce_186,
+  1, 101, :_reduce_187,
+  1, 101, :_reduce_188,
+  1, 145, :_reduce_189,
+  3, 145, :_reduce_190,
+  1, 147, :_reduce_191,
+  1, 148, :_reduce_192,
+  1, 148, :_reduce_193,
+  1, 148, :_reduce_194,
+  1, 148, :_reduce_none,
+  0, 72, :_reduce_196,
+  0, 149, :_reduce_197,
+  1, 143, :_reduce_none,
+  3, 143, :_reduce_199,
+  3, 143, :_reduce_200,
+  1, 150, :_reduce_none,
+  3, 150, :_reduce_202,
+  3, 151, :_reduce_203,
+  1, 151, :_reduce_204,
+  3, 151, :_reduce_205,
+  1, 151, :_reduce_206,
+  1, 146, :_reduce_none,
+  2, 146, :_reduce_208,
+  1, 144, :_reduce_none,
+  2, 144, :_reduce_210,
+  1, 152, :_reduce_none,
+  1, 152, :_reduce_none,
+  1, 94, :_reduce_213,
+  3, 119, :_reduce_214,
+  4, 119, :_reduce_215,
+  2, 119, :_reduce_216,
+  1, 127, :_reduce_none,
+  1, 127, :_reduce_none,
+  0, 105, :_reduce_none,
+  1, 105, :_reduce_220,
+  1, 133, :_reduce_221,
+  3, 128, :_reduce_222,
+  4, 128, :_reduce_223,
+  2, 128, :_reduce_224,
+  1, 153, :_reduce_none,
+  3, 153, :_reduce_226,
+  3, 154, :_reduce_227,
+  1, 155, :_reduce_228,
+  1, 155, :_reduce_229,
+  4, 121, :_reduce_230,
+  1, 100, :_reduce_none,
+  4, 100, :_reduce_232 ]
 
-racc_use_result_var = true
+racc_reduce_n = 233
+
+racc_shift_n = 384
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :STRING => 2,
+  :DQPRE => 3,
+  :DQMID => 4,
+  :DQPOST => 5,
+  :LBRACK => 6,
+  :RBRACK => 7,
+  :LBRACE => 8,
+  :RBRACE => 9,
+  :SYMBOL => 10,
+  :FARROW => 11,
+  :COMMA => 12,
+  :TRUE => 13,
+  :FALSE => 14,
+  :EQUALS => 15,
+  :APPENDS => 16,
+  :LESSEQUAL => 17,
+  :NOTEQUAL => 18,
+  :DOT => 19,
+  :COLON => 20,
+  :LLCOLLECT => 21,
+  :RRCOLLECT => 22,
+  :QMARK => 23,
+  :LPAREN => 24,
+  :RPAREN => 25,
+  :ISEQUAL => 26,
+  :GREATEREQUAL => 27,
+  :GREATERTHAN => 28,
+  :LESSTHAN => 29,
+  :IF => 30,
+  :ELSE => 31,
+  :IMPORT => 32,
+  :DEFINE => 33,
+  :ELSIF => 34,
+  :VARIABLE => 35,
+  :CLASS => 36,
+  :INHERITS => 37,
+  :NODE => 38,
+  :BOOLEAN => 39,
+  :NAME => 40,
+  :SEMIC => 41,
+  :CASE => 42,
+  :DEFAULT => 43,
+  :AT => 44,
+  :LCOLLECT => 45,
+  :RCOLLECT => 46,
+  :CLASSNAME => 47,
+  :CLASSREF => 48,
+  :NOT => 49,
+  :OR => 50,
+  :AND => 51,
+  :UNDEF => 52,
+  :PARROW => 53,
+  :PLUS => 54,
+  :MINUS => 55,
+  :TIMES => 56,
+  :DIV => 57,
+  :LSHIFT => 58,
+  :RSHIFT => 59,
+  :UMINUS => 60,
+  :MATCH => 61,
+  :NOMATCH => 62,
+  :REGEX => 63,
+  :IN_EDGE => 64,
+  :OUT_EDGE => 65,
+  :IN_EDGE_SUB => 66,
+  :OUT_EDGE_SUB => 67,
+  :IN => 68 }
 
 racc_nt_base = 69
 
+racc_use_result_var = true
+
 Racc_arg = [
- racc_action_table,
- racc_action_check,
- racc_action_default,
- racc_action_pointer,
- racc_goto_table,
- racc_goto_check,
- racc_goto_default,
- racc_goto_pointer,
- racc_nt_base,
- racc_reduce_table,
- racc_token_table,
- racc_shift_n,
- racc_reduce_n,
- racc_use_result_var ]
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
 
 Racc_token_to_s_table = [
-'$end',
-'error',
-'STRING',
-'DQPRE',
-'DQMID',
-'DQPOST',
-'LBRACK',
-'RBRACK',
-'LBRACE',
-'RBRACE',
-'SYMBOL',
-'FARROW',
-'COMMA',
-'TRUE',
-'FALSE',
-'EQUALS',
-'APPENDS',
-'LESSEQUAL',
-'NOTEQUAL',
-'DOT',
-'COLON',
-'LLCOLLECT',
-'RRCOLLECT',
-'QMARK',
-'LPAREN',
-'RPAREN',
-'ISEQUAL',
-'GREATEREQUAL',
-'GREATERTHAN',
-'LESSTHAN',
-'IF',
-'ELSE',
-'IMPORT',
-'DEFINE',
-'ELSIF',
-'VARIABLE',
-'CLASS',
-'INHERITS',
-'NODE',
-'BOOLEAN',
-'NAME',
-'SEMIC',
-'CASE',
-'DEFAULT',
-'AT',
-'LCOLLECT',
-'RCOLLECT',
-'CLASSNAME',
-'CLASSREF',
-'NOT',
-'OR',
-'AND',
-'UNDEF',
-'PARROW',
-'PLUS',
-'MINUS',
-'TIMES',
-'DIV',
-'LSHIFT',
-'RSHIFT',
-'UMINUS',
-'MATCH',
-'NOMATCH',
-'REGEX',
-'IN_EDGE',
-'OUT_EDGE',
-'IN_EDGE_SUB',
-'OUT_EDGE_SUB',
-'IN',
-'$start',
-'program',
-'statements',
-'nil',
-'statement',
-'resource',
-'virtualresource',
-'collection',
-'assignment',
-'casestatement',
-'ifstatement_begin',
-'import',
-'fstatement',
-'definition',
-'hostclass',
-'nodedef',
-'resourceoverride',
-'append',
-'relationship',
-'relationship_side',
-'edge',
-'resourceref',
-'funcvalues',
-'namestring',
-'name',
-'variable',
-'type',
-'boolean',
-'funcrvalue',
-'selector',
-'quotedtext',
-'hasharrayaccesses',
-'classname',
-'resourceinstances',
-'endsemi',
-'params',
-'endcomma',
-'classref',
-'anyparams',
-'at',
-'collectrhand',
-'collstatements',
-'collstatement',
-'colljoin',
-'collexpr',
-'colllval',
-'simplervalue',
-'resourceinst',
-'resourcename',
-'undef',
-'array',
-'expression',
-'hasharrayaccess',
-'param',
-'rvalue',
-'addparam',
-'anyparam',
-'rvalues',
-'comma',
-'hash',
-'dqrval',
-'dqtail',
-'ifstatement',
-'else',
-'regex',
-'caseopts',
-'caseopt',
-'casevalues',
-'selectlhand',
-'svalues',
-'selectval',
-'sintvalues',
-'string',
-'strings',
-'argumentlist',
-'classparent',
-'hostnames',
-'nodeparent',
-'nodename',
-'hostname',
-'nothing',
-'arguments',
-'argument',
-'classnameordefault',
-'hashpairs',
-'hashpair',
-'key']
+  "$end",
+  "error",
+  "STRING",
+  "DQPRE",
+  "DQMID",
+  "DQPOST",
+  "LBRACK",
+  "RBRACK",
+  "LBRACE",
+  "RBRACE",
+  "SYMBOL",
+  "FARROW",
+  "COMMA",
+  "TRUE",
+  "FALSE",
+  "EQUALS",
+  "APPENDS",
+  "LESSEQUAL",
+  "NOTEQUAL",
+  "DOT",
+  "COLON",
+  "LLCOLLECT",
+  "RRCOLLECT",
+  "QMARK",
+  "LPAREN",
+  "RPAREN",
+  "ISEQUAL",
+  "GREATEREQUAL",
+  "GREATERTHAN",
+  "LESSTHAN",
+  "IF",
+  "ELSE",
+  "IMPORT",
+  "DEFINE",
+  "ELSIF",
+  "VARIABLE",
+  "CLASS",
+  "INHERITS",
+  "NODE",
+  "BOOLEAN",
+  "NAME",
+  "SEMIC",
+  "CASE",
+  "DEFAULT",
+  "AT",
+  "LCOLLECT",
+  "RCOLLECT",
+  "CLASSNAME",
+  "CLASSREF",
+  "NOT",
+  "OR",
+  "AND",
+  "UNDEF",
+  "PARROW",
+  "PLUS",
+  "MINUS",
+  "TIMES",
+  "DIV",
+  "LSHIFT",
+  "RSHIFT",
+  "UMINUS",
+  "MATCH",
+  "NOMATCH",
+  "REGEX",
+  "IN_EDGE",
+  "OUT_EDGE",
+  "IN_EDGE_SUB",
+  "OUT_EDGE_SUB",
+  "IN",
+  "$start",
+  "program",
+  "statements",
+  "nil",
+  "statement",
+  "resource",
+  "virtualresource",
+  "collection",
+  "assignment",
+  "casestatement",
+  "ifstatement_begin",
+  "import",
+  "fstatement",
+  "definition",
+  "hostclass",
+  "nodedef",
+  "resourceoverride",
+  "append",
+  "relationship",
+  "relationship_side",
+  "edge",
+  "resourceref",
+  "funcvalues",
+  "namestring",
+  "name",
+  "variable",
+  "type",
+  "boolean",
+  "funcrvalue",
+  "selector",
+  "quotedtext",
+  "hasharrayaccesses",
+  "classname",
+  "resourceinstances",
+  "endsemi",
+  "params",
+  "endcomma",
+  "classref",
+  "anyparams",
+  "at",
+  "collectrhand",
+  "collstatements",
+  "collstatement",
+  "colljoin",
+  "collexpr",
+  "colllval",
+  "simplervalue",
+  "resourceinst",
+  "resourcename",
+  "undef",
+  "array",
+  "expression",
+  "hasharrayaccess",
+  "param",
+  "rvalue",
+  "addparam",
+  "anyparam",
+  "rvalues",
+  "comma",
+  "hash",
+  "dqrval",
+  "dqtail",
+  "ifstatement",
+  "else",
+  "regex",
+  "caseopts",
+  "caseopt",
+  "casevalues",
+  "selectlhand",
+  "svalues",
+  "selectval",
+  "sintvalues",
+  "string",
+  "strings",
+  "argumentlist",
+  "classparent",
+  "hostnames",
+  "nodeparent",
+  "nodename",
+  "hostname",
+  "nothing",
+  "arguments",
+  "argument",
+  "classnameordefault",
+  "hashpairs",
+  "hashpair",
+  "key" ]
 
 Racc_debug_parser = false
 
-##### racc system variables end #####
-
- # reduce 0 omitted
-
-module_eval <<'.,.,', 'grammar.ra', 46
-  def _reduce_1( val, _values, result )
-    if val[0]
-        # Make sure we always return an array.
-        if val[0].is_a?(AST::ASTArray)
-            if val[0].children.empty?
-                result = nil
-            else
-                result = val[0]
-            end
-        else
-            result = aryfy(val[0])
-        end
-    else
-        result = nil
-    end
-   result
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+module_eval(<<'.,.,', 'grammar.ra', 31)
+  def _reduce_1(val, _values, result)
+      val[0].is_a_namespace = true
+  result = val[0]
+
+    result
   end
 .,.,
 
- # reduce 2 omitted
+# reduce 2 omitted
 
- # reduce 3 omitted
+module_eval(<<'.,.,', 'grammar.ra', 37)
+  def _reduce_3(val, _values, result)
+        result = ast AST::ASTArray, :children => [val[0]]
+  
+    result
+  end
+.,.,
 
-module_eval <<'.,.,', 'grammar.ra', 62
-  def _reduce_4( val, _values, result )
-    if val[0] and val[1]
-        if val[0].instance_of?(AST::ASTArray)
-            val[0].push(val[1])
-            result = val[0]
-        else
-            result = ast AST::ASTArray, :children => [val[0],val[1]]
-        end
-    elsif obj = (val[0] || val[1])
-        result = obj
-    else result = nil
-    end
-   result
+module_eval(<<'.,.,', 'grammar.ra', 40)
+  def _reduce_4(val, _values, result)
+        val[0].push(val[1])
+    result = val[0]
+  
+    result
   end
 .,.,
 
- # reduce 5 omitted
+# reduce 5 omitted
 
- # reduce 6 omitted
+# reduce 6 omitted
 
- # reduce 7 omitted
+# reduce 7 omitted
 
- # reduce 8 omitted
+# reduce 8 omitted
 
- # reduce 9 omitted
+# reduce 9 omitted
 
- # reduce 10 omitted
+# reduce 10 omitted
 
- # reduce 11 omitted
+# reduce 11 omitted
 
- # reduce 12 omitted
+# reduce 12 omitted
 
- # reduce 13 omitted
+# reduce 13 omitted
 
- # reduce 14 omitted
+# reduce 14 omitted
 
- # reduce 15 omitted
+# reduce 15 omitted
 
- # reduce 16 omitted
+# reduce 16 omitted
 
- # reduce 17 omitted
+# reduce 17 omitted
 
- # reduce 18 omitted
+# reduce 18 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 82
-  def _reduce_19( val, _values, result )
-    result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context)
-   result
+module_eval(<<'.,.,', 'grammar.ra', 61)
+  def _reduce_19(val, _values, result)
+      result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context)
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 85
-  def _reduce_20( val, _values, result )
-    result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context)
-   result
+module_eval(<<'.,.,', 'grammar.ra', 64)
+  def _reduce_20(val, _values, result)
+        result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context)
+
+    result
   end
 .,.,
 
- # reduce 21 omitted
+# reduce 21 omitted
 
- # reduce 22 omitted
+# reduce 22 omitted
 
- # reduce 23 omitted
+# reduce 23 omitted
 
- # reduce 24 omitted
+# reduce 24 omitted
 
- # reduce 25 omitted
+# reduce 25 omitted
 
- # reduce 26 omitted
+# reduce 26 omitted
 
- # reduce 27 omitted
+# reduce 27 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 98
-  def _reduce_28( val, _values, result )
-    args = aryfy(val[2])
-    result = ast AST::Function,
-        :name => val[0][:value],
-        :line => val[0][:line],
-        :arguments => args,
-        :ftype => :statement
-   result
+module_eval(<<'.,.,', 'grammar.ra', 72)
+  def _reduce_28(val, _values, result)
+      args = aryfy(val[2])
+  result = ast AST::Function,
+    :name => val[0][:value],
+    :line => val[0][:line],
+    :arguments => args,
+    :ftype => :statement
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 106
-  def _reduce_29( val, _values, result )
-    args = aryfy(val[2])
-    result = ast AST::Function,
-        :name => val[0][:value],
-        :line => val[0][:line],
-        :arguments => args,
-        :ftype => :statement
-   result
+module_eval(<<'.,.,', 'grammar.ra', 80)
+  def _reduce_29(val, _values, result)
+      args = aryfy(val[2])
+  result = ast AST::Function,
+    :name => val[0][:value],
+    :line => val[0][:line],
+    :arguments => args,
+    :ftype => :statement
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 112
-  def _reduce_30( val, _values, result )
-    result = ast AST::Function,
-        :name => val[0][:value],
-        :line => val[0][:line],
-        :arguments => AST::ASTArray.new({}),
-        :ftype => :statement
-   result
+module_eval(<<'.,.,', 'grammar.ra', 87)
+  def _reduce_30(val, _values, result)
+      result = ast AST::Function,
+    :name => val[0][:value],
+    :line => val[0][:line],
+    :arguments => AST::ASTArray.new({}),
+    :ftype => :statement
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 120
-  def _reduce_31( val, _values, result )
-    args = aryfy(val[1])
+module_eval(<<'.,.,', 'grammar.ra', 94)
+  def _reduce_31(val, _values, result)
+        args = aryfy(val[1])
     result = ast AST::Function,
-        :name => val[0][:value],
-        :line => val[0][:line],
-        :arguments => args,
-        :ftype => :statement
-   result
+    :name => val[0][:value],
+    :line => val[0][:line],
+    :arguments => args,
+    :ftype => :statement
+
+    result
   end
 .,.,
 
- # reduce 32 omitted
+# reduce 32 omitted
 
- # reduce 33 omitted
+# reduce 33 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 128
-  def _reduce_34( val, _values, result )
-    result = aryfy(val[0], val[2])
+module_eval(<<'.,.,', 'grammar.ra', 105)
+  def _reduce_34(val, _values, result)
+        result = aryfy(val[0], val[2])
     result.line = @lexer.line
     result.file = @lexer.file
-   result
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 137
-  def _reduce_35( val, _values, result )
-    unless val[0].is_a?(AST::ASTArray)
-        val[0] = aryfy(val[0])
-    end
+module_eval(<<'.,.,', 'grammar.ra', 110)
+  def _reduce_35(val, _values, result)
+        unless val[0].is_a?(AST::ASTArray)
+    val[0] = aryfy(val[0])
+  end
 
-    val[0].push(val[2])
+  val[0].push(val[2])
 
-    result = val[0]
-   result
+  result = val[0]
+
+    result
   end
 .,.,
 
- # reduce 36 omitted
+# reduce 36 omitted
 
- # reduce 37 omitted
+# reduce 37 omitted
 
- # reduce 38 omitted
+# reduce 38 omitted
 
- # reduce 39 omitted
+# reduce 39 omitted
 
- # reduce 40 omitted
+# reduce 40 omitted
 
- # reduce 41 omitted
+# reduce 41 omitted
 
- # reduce 42 omitted
+# reduce 42 omitted
 
- # reduce 43 omitted
+# reduce 43 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 151
-  def _reduce_44( val, _values, result )
-                    result = ast AST::Name, :value => val[0][:value]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 130)
+  def _reduce_44(val, _values, result)
+        result = ast AST::Name, :value => val[0][:value]
+      
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 173
-  def _reduce_45( val, _values, result )
-    @lexer.commentpop
-    array = val[2]
-    if array.instance_of?(AST::ResourceInstance)
-        array = [array]
-    end
-    result = ast AST::ASTArray
+module_eval(<<'.,.,', 'grammar.ra', 134)
+  def _reduce_45(val, _values, result)
+      @lexer.commentpop
+  array = val[2]
+  array = [array] if array.instance_of?(AST::ResourceInstance)
+  result = ast AST::ASTArray
+
+  # this iterates across each specified resourceinstance
+  array.each { |instance|
+    raise Puppet::Dev, "Got something that isn't an instance" unless instance.instance_of?(AST::ResourceInstance)
+    # now, i need to somehow differentiate between those things with
+    # arrays in their names, and normal things
+
+      result.push ast(
+        AST::Resource,
+      :type => val[0],
+      :title => instance[0],
+
+      :parameters => instance[1])
+  }
 
-    # this iterates across each specified resourceinstance
-    array.each { |instance|
-        unless instance.instance_of?(AST::ResourceInstance)
-            raise Puppet::Dev, "Got something that isn't an instance"
-        end
-        # now, i need to somehow differentiate between those things with
-        # arrays in their names, and normal things
-        result.push ast(AST::Resource,
-            :type => val[0],
-            :title => instance[0],
-            :parameters => instance[1])
-    }
-   result
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 176
-  def _reduce_46( val, _values, result )
-    # This is a deprecated syntax.
-    error "All resource specifications require names"
-   result
+module_eval(<<'.,.,', 'grammar.ra', 153)
+  def _reduce_46(val, _values, result)
+      # This is a deprecated syntax.
+  error "All resource specifications require names"
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 180
-  def _reduce_47( val, _values, result )
-    # a defaults setting for a type
-    @lexer.commentpop
-    result = ast(AST::ResourceDefaults, :type => val[0], :parameters => val[2])
-   result
+module_eval(<<'.,.,', 'grammar.ra', 156)
+  def _reduce_47(val, _values, result)
+      # a defaults setting for a type
+  @lexer.commentpop
+  result = ast(AST::ResourceDefaults, :type => val[0], :parameters => val[2])
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 186
-  def _reduce_48( val, _values, result )
-    @lexer.commentpop
-    result = ast AST::ResourceOverride, :object => val[0], :parameters => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 163)
+  def _reduce_48(val, _values, result)
+      @lexer.commentpop
+  result = ast AST::ResourceOverride, :object => val[0], :parameters => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 213
-  def _reduce_49( val, _values, result )
-    type = val[0]
+module_eval(<<'.,.,', 'grammar.ra', 170)
+  def _reduce_49(val, _values, result)
+      type = val[0]
 
-    if (type == :exported and ! Puppet[:storeconfigs]) and ! Puppet[:parseonly]
-        Puppet.warning addcontext("You cannot collect without storeconfigs being set")
-    end
+  if (type == :exported and ! Puppet[:storeconfigs]) and ! Puppet[:parseonly]
+    Puppet.warning addcontext("You cannot collect without storeconfigs being set")
+  end
 
-    if val[1].is_a? AST::ResourceDefaults
-        error "Defaults are not virtualizable"
-    end
+  error "Defaults are not virtualizable" if val[1].is_a? AST::ResourceDefaults
 
-    method = type.to_s + "="
+  method = type.to_s + "="
 
-    # Just mark our resources as exported and pass them through.
-    if val[1].instance_of?(AST::ASTArray)
-        val[1].each do |obj|
-            obj.send(method, true)
-        end
-    else
-        val[1].send(method, true)
+  # Just mark our resources as exported and pass them through.
+  if val[1].instance_of?(AST::ASTArray)
+    val[1].each do |obj|
+      obj.send(method, true)
     end
+  else
+    val[1].send(method, true)
+  end
 
-    result = val[1]
-   result
+  result = val[1]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 214
-  def _reduce_50( val, _values, result )
- result = :virtual
-   result
+module_eval(<<'.,.,', 'grammar.ra', 192)
+  def _reduce_50(val, _values, result)
+     result = :virtual 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 215
-  def _reduce_51( val, _values, result )
- result = :exported
-   result
+module_eval(<<'.,.,', 'grammar.ra', 193)
+  def _reduce_51(val, _values, result)
+     result = :exported 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 240
-  def _reduce_52( val, _values, result )
-    @lexer.commentpop
-    if val[0] =~ /^[a-z]/
-        Puppet.warning addcontext("Collection names must now be capitalized")
-    end
-    type = val[0].downcase
-    args = {:type => type}
-
-    if val[1].is_a?(AST::CollExpr)
-        args[:query] = val[1]
-        args[:query].type = type
-        args[:form] = args[:query].form
-    else
-        args[:form] = val[1]
-    end
-    if args[:form] == :exported and ! Puppet[:storeconfigs] and ! Puppet[:parseonly]
-        Puppet.warning addcontext("You cannot collect exported resources without storeconfigs being set; the collection will be ignored")
-    end
-    args[:override] = val[3]
-    result = ast AST::Collection, args
-   result
+module_eval(<<'.,.,', 'grammar.ra', 198)
+  def _reduce_52(val, _values, result)
+      @lexer.commentpop
+  Puppet.warning addcontext("Collection names must now be capitalized") if val[0] =~ /^[a-z]/
+  type = val[0].downcase
+  args = {:type => type}
+
+  if val[1].is_a?(AST::CollExpr)
+    args[:query] = val[1]
+    args[:query].type = type
+    args[:form] = args[:query].form
+  else
+    args[:form] = val[1]
+  end
+  if args[:form] == :exported and ! Puppet[:storeconfigs] and ! Puppet[:parseonly]
+    Puppet.warning addcontext("You cannot collect exported resources without storeconfigs being set; the collection will be ignored")
+  end
+  args[:override] = val[3]
+  result = ast AST::Collection, args
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 259
-  def _reduce_53( val, _values, result )
-    if val[0] =~ /^[a-z]/
-        Puppet.warning addcontext("Collection names must now be capitalized")
-    end
-    type = val[0].downcase
-    args = {:type => type }
-
-    if val[1].is_a?(AST::CollExpr)
-        args[:query] = val[1]
-        args[:query].type = type
-        args[:form] = args[:query].form
-    else
-        args[:form] = val[1]
-    end
-    if args[:form] == :exported and ! Puppet[:storeconfigs] and ! Puppet[:parseonly]
-        Puppet.warning addcontext("You cannot collect exported resources without storeconfigs being set; the collection will be ignored")
-    end
-    result = ast AST::Collection, args
-   result
+module_eval(<<'.,.,', 'grammar.ra', 217)
+  def _reduce_53(val, _values, result)
+        if val[0] =~ /^[a-z]/
+    Puppet.warning addcontext("Collection names must now be capitalized")
+  end
+  type = val[0].downcase
+  args = {:type => type }
+
+  if val[1].is_a?(AST::CollExpr)
+    args[:query] = val[1]
+    args[:query].type = type
+    args[:form] = args[:query].form
+  else
+    args[:form] = val[1]
+  end
+  if args[:form] == :exported and ! Puppet[:storeconfigs] and ! Puppet[:parseonly]
+    Puppet.warning addcontext("You cannot collect exported resources without storeconfigs being set; the collection will be ignored")
+  end
+  result = ast AST::Collection, args
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 269
-  def _reduce_54( val, _values, result )
-    if val[1]
-        result = val[1]
-        result.form = :virtual
-    else
-        result = :virtual
-    end
-   result
+module_eval(<<'.,.,', 'grammar.ra', 238)
+  def _reduce_54(val, _values, result)
+      if val[1]
+    result = val[1]
+    result.form = :virtual
+  else
+    result = :virtual
+  end
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 277
-  def _reduce_55( val, _values, result )
-    if val[1]
-        result = val[1]
-        result.form = :exported
-    else
-        result = :exported
-    end
-   result
+module_eval(<<'.,.,', 'grammar.ra', 246)
+  def _reduce_55(val, _values, result)
+        if val[1]
+    result = val[1]
+    result.form = :exported
+  else
+    result = :exported
+  end
+
+    result
   end
 .,.,
 
- # reduce 56 omitted
+# reduce 56 omitted
+
+# reduce 57 omitted
 
- # reduce 57 omitted
+module_eval(<<'.,.,', 'grammar.ra', 259)
+  def _reduce_58(val, _values, result)
+        result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2]
 
-module_eval <<'.,.,', 'grammar.ra', 285
-  def _reduce_58( val, _values, result )
-    result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2]
-   result
+    result
   end
 .,.,
 
- # reduce 59 omitted
+# reduce 59 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 291
-  def _reduce_60( val, _values, result )
-    result = val[1]
+module_eval(<<'.,.,', 'grammar.ra', 264)
+  def _reduce_60(val, _values, result)
+        result = val[1]
     result.parens = true
-   result
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 292
-  def _reduce_61( val, _values, result )
- result=val[0][:value]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 268)
+  def _reduce_61(val, _values, result)
+     result=val[0][:value] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 293
-  def _reduce_62( val, _values, result )
- result=val[0][:value]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 269)
+  def _reduce_62(val, _values, result)
+     result=val[0][:value] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 300
-  def _reduce_63( val, _values, result )
-    result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2]
-    #result = ast AST::CollExpr
-    #result.push *val
-   result
+module_eval(<<'.,.,', 'grammar.ra', 272)
+  def _reduce_63(val, _values, result)
+      result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2]
+  #result = ast AST::CollExpr
+  #result.push *val
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 305
-  def _reduce_64( val, _values, result )
-    result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2]
+module_eval(<<'.,.,', 'grammar.ra', 277)
+  def _reduce_64(val, _values, result)
+        result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2]
     #result = ast AST::CollExpr
     #result.push *val
-   result
+
+    result
   end
 .,.,
 
- # reduce 65 omitted
+# reduce 65 omitted
 
- # reduce 66 omitted
+# reduce 66 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 312
-  def _reduce_67( val, _values, result )
-    result = ast AST::ResourceInstance, :children => [val[0],val[2]]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 286)
+  def _reduce_67(val, _values, result)
+      result = ast AST::ResourceInstance, :children => [val[0],val[2]]
+
+    result
   end
 .,.,
 
- # reduce 68 omitted
+# reduce 68 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 322
-  def _reduce_69( val, _values, result )
-    if val[0].instance_of?(AST::ResourceInstance)
-        result = ast AST::ASTArray, :children => [val[0],val[2]]
-    else
-        val[0].push val[2]
-        result = val[0]
-    end
-   result
+module_eval(<<'.,.,', 'grammar.ra', 291)
+  def _reduce_69(val, _values, result)
+        if val[0].instance_of?(AST::ResourceInstance)
+    result = ast AST::ASTArray, :children => [val[0],val[2]]
+  else
+    val[0].push val[2]
+    result = val[0]
+  end
+
+    result
   end
 .,.,
 
- # reduce 70 omitted
+# reduce 70 omitted
 
- # reduce 71 omitted
+# reduce 71 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 329
-  def _reduce_72( val, _values, result )
-    result = ast AST::Undef, :value => :undef
-   result
+module_eval(<<'.,.,', 'grammar.ra', 303)
+  def _reduce_72(val, _values, result)
+      result = ast AST::Undef, :value => :undef
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 333
-  def _reduce_73( val, _values, result )
-    result = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 307)
+  def _reduce_73(val, _values, result)
+      result = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 337
-  def _reduce_74( val, _values, result )
-    result = ast AST::Type, :value => val[0][:value], :line => val[0][:line]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 311)
+  def _reduce_74(val, _values, result)
+      result = ast AST::Type, :value => val[0][:value], :line => val[0][:line]
+
+    result
   end
 .,.,
 
- # reduce 75 omitted
+# reduce 75 omitted
 
- # reduce 76 omitted
+# reduce 76 omitted
 
- # reduce 77 omitted
+# reduce 77 omitted
 
- # reduce 78 omitted
+# reduce 78 omitted
 
- # reduce 79 omitted
+# reduce 79 omitted
 
- # reduce 80 omitted
+# reduce 80 omitted
 
- # reduce 81 omitted
+# reduce 81 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 354
-  def _reduce_82( val, _values, result )
-    if val[0][:value] =~ /::/
-        raise Puppet::ParseError, "Cannot assign to variables in other namespaces"
-    end
-    # this is distinct from referencing a variable
-    variable = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
-    result = ast AST::VarDef, :name => variable, :value => val[2], :line => val[0][:line]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 323)
+  def _reduce_82(val, _values, result)
+      raise Puppet::ParseError, "Cannot assign to variables in other namespaces" if val[0][:value] =~ /::/
+  # this is distinct from referencing a variable
+  variable = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
+  result = ast AST::VarDef, :name => variable, :value => val[2], :line => val[0][:line]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 357
-  def _reduce_83( val, _values, result )
-    result = ast AST::VarDef, :name => val[0], :value => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 329)
+  def _reduce_83(val, _values, result)
+        result = ast AST::VarDef, :name => val[0], :value => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 362
-  def _reduce_84( val, _values, result )
-    variable = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
-    result = ast AST::VarDef, :name => variable, :value => val[2], :append => true, :line => val[0][:line]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 333)
+  def _reduce_84(val, _values, result)
+      variable = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
+  result = ast AST::VarDef, :name => variable, :value => val[2], :append => true, :line => val[0][:line]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 367
-  def _reduce_85( val, _values, result )
-    result = ast AST::ASTArray
-   result
+module_eval(<<'.,.,', 'grammar.ra', 339)
+  def _reduce_85(val, _values, result)
+      result = ast AST::ASTArray
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 367
-  def _reduce_86( val, _values, result )
- result = val[0]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 341)
+  def _reduce_86(val, _values, result)
+     result = val[0] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 376
-  def _reduce_87( val, _values, result )
-    if val[0].instance_of?(AST::ASTArray)
-        val[0].push(val[2])
-        result = val[0]
-    else
-        result = ast AST::ASTArray, :children => [val[0],val[2]]
-    end
-   result
+module_eval(<<'.,.,', 'grammar.ra', 343)
+  def _reduce_87(val, _values, result)
+        if val[0].instance_of?(AST::ASTArray)
+    val[0].push(val[2])
+    result = val[0]
+  else
+    result = ast AST::ASTArray, :children => [val[0],val[2]]
+  end
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 380
-  def _reduce_88( val, _values, result )
-    result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 352)
+  def _reduce_88(val, _values, result)
+      result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 385
-  def _reduce_89( val, _values, result )
-    result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2],
-                                     :add => true
-   result
+module_eval(<<'.,.,', 'grammar.ra', 356)
+  def _reduce_89(val, _values, result)
+      result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2],
+    :add => true
+
+    result
   end
 .,.,
 
- # reduce 90 omitted
+# reduce 90 omitted
 
- # reduce 91 omitted
+# reduce 91 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 393
-  def _reduce_92( val, _values, result )
-    result = ast AST::ASTArray
-   result
+module_eval(<<'.,.,', 'grammar.ra', 365)
+  def _reduce_92(val, _values, result)
+      result = ast AST::ASTArray
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 393
-  def _reduce_93( val, _values, result )
- result = val[0]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 367)
+  def _reduce_93(val, _values, result)
+     result = val[0] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 402
-  def _reduce_94( val, _values, result )
-    if val[0].instance_of?(AST::ASTArray)
-        val[0].push(val[2])
-        result = val[0]
-    else
-        result = ast AST::ASTArray, :children => [val[0],val[2]]
-    end
-   result
+module_eval(<<'.,.,', 'grammar.ra', 369)
+  def _reduce_94(val, _values, result)
+        if val[0].instance_of?(AST::ASTArray)
+    val[0].push(val[2])
+    result = val[0]
+  else
+    result = ast AST::ASTArray, :children => [val[0],val[2]]
+  end
+
+    result
   end
 .,.,
 
- # reduce 95 omitted
+# reduce 95 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 411
-  def _reduce_96( val, _values, result )
-    if val[0].instance_of?(AST::ASTArray)
-        result = val[0].push(val[2])
-    else
-        result = ast AST::ASTArray, :children => [val[0],val[2]]
-    end
-   result
+module_eval(<<'.,.,', 'grammar.ra', 379)
+  def _reduce_96(val, _values, result)
+        if val[0].instance_of?(AST::ASTArray)
+    result = val[0].push(val[2])
+  else
+    result = ast AST::ASTArray, :children => [val[0],val[2]]
+  end
+
+    result
   end
 .,.,
 
- # reduce 97 omitted
+# reduce 97 omitted
 
- # reduce 98 omitted
+# reduce 98 omitted
 
- # reduce 99 omitted
+# reduce 99 omitted
 
- # reduce 100 omitted
+# reduce 100 omitted
 
- # reduce 101 omitted
+# reduce 101 omitted
 
- # reduce 102 omitted
+# reduce 102 omitted
 
- # reduce 103 omitted
+# reduce 103 omitted
 
- # reduce 104 omitted
+# reduce 104 omitted
 
- # reduce 105 omitted
+# reduce 105 omitted
 
- # reduce 106 omitted
+# reduce 106 omitted
 
- # reduce 107 omitted
+# reduce 107 omitted
 
- # reduce 108 omitted
+# reduce 108 omitted
 
- # reduce 109 omitted
+# reduce 109 omitted
 
- # reduce 110 omitted
+# reduce 110 omitted
 
- # reduce 111 omitted
+# reduce 111 omitted
 
- # reduce 112 omitted
+# reduce 112 omitted
 
- # reduce 113 omitted
+# reduce 113 omitted
 
- # reduce 114 omitted
+# reduce 114 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 440
-  def _reduce_115( val, _values, result )
-    args = aryfy(val[2])
-    result = ast AST::Function,
-        :name => val[0][:value], :line => val[0][:line],
-        :arguments => args,
-        :ftype => :rvalue
-   result
+module_eval(<<'.,.,', 'grammar.ra', 408)
+  def _reduce_115(val, _values, result)
+      args = aryfy(val[2])
+  result = ast AST::Function,
+    :name => val[0][:value], :line => val[0][:line],
+    :arguments => args,
+    :ftype => :rvalue
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 445
-  def _reduce_116( val, _values, result )
-    result = ast AST::Function,
-        :name => val[0][:value], :line => val[0][:line],
-        :arguments => AST::ASTArray.new({}),
-        :ftype => :rvalue
-   result
+module_eval(<<'.,.,', 'grammar.ra', 414)
+  def _reduce_116(val, _values, result)
+      result = ast AST::Function,
+    :name => val[0][:value], :line => val[0][:line],
+    :arguments => AST::ASTArray.new({}),
+    :ftype => :rvalue
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 446
-  def _reduce_117( val, _values, result )
- result = ast AST::String, :value => val[0][:value],                  :line => val[0][:line]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 420)
+  def _reduce_117(val, _values, result)
+     result = ast AST::String, :value => val[0][:value],                  :line => val[0][:line] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 447
-  def _reduce_118( val, _values, result )
- result = ast AST::Concat, :value => [ast(AST::String,val[0])]+val[1], :line => val[0][:line]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 421)
+  def _reduce_118(val, _values, result)
+     result = ast AST::Concat, :value => [ast(AST::String,val[0])]+val[1], :line => val[0][:line] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 449
-  def _reduce_119( val, _values, result )
- result = [val[0]] + val[1]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 423)
+  def _reduce_119(val, _values, result)
+     result = [val[0]] + val[1] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 451
-  def _reduce_120( val, _values, result )
- result = [ast(AST::String,val[0])]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 425)
+  def _reduce_120(val, _values, result)
+     result = [ast(AST::String,val[0])]          
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 452
-  def _reduce_121( val, _values, result )
- result = [ast(AST::String,val[0])] + val[1]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 426)
+  def _reduce_121(val, _values, result)
+     result = [ast(AST::String,val[0])] + val[1] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 457
-  def _reduce_122( val, _values, result )
-    result = ast AST::Boolean, :value => val[0][:value], :line => val[0][:line]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 429)
+  def _reduce_122(val, _values, result)
+      result = ast AST::Boolean, :value => val[0][:value], :line => val[0][:line]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 462
-  def _reduce_123( val, _values, result )
-    Puppet.warning addcontext("Deprecation notice:  Resource references should now be capitalized")
-    result = ast AST::ResourceReference, :type => val[0][:value], :line => val[0][:line], :title => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 433)
+  def _reduce_123(val, _values, result)
+      Puppet.warning addcontext("Deprecation notice:  Resource references should now be capitalized")
+  result = ast AST::ResourceReference, :type => val[0][:value], :line => val[0][:line], :title => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 464
-  def _reduce_124( val, _values, result )
-    result = ast AST::ResourceReference, :type => val[0], :title => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 436)
+  def _reduce_124(val, _values, result)
+      result = ast AST::ResourceReference, :type => val[0], :title => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 468
-  def _reduce_125( val, _values, result )
-    result = val[1]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 440)
+  def _reduce_125(val, _values, result)
+      result = val[1]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 482
-  def _reduce_126( val, _values, result )
-    @lexer.commentpop
-    args = {
-        :test => val[0],
-        :statements => val[2]
-    }
+module_eval(<<'.,.,', 'grammar.ra', 444)
+  def _reduce_126(val, _values, result)
+      @lexer.commentpop
+  args = {
+    :test => val[0],
+    :statements => val[2]
+  }
 
-    if val[4]
-        args[:else] = val[4]
-    end
+  args[:else] = val[4] if val[4]
 
-    result = ast AST::IfStatement, args
-   result
+  result = ast AST::IfStatement, args
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 495
-  def _reduce_127( val, _values, result )
-    @lexer.commentpop
+module_eval(<<'.,.,', 'grammar.ra', 455)
+  def _reduce_127(val, _values, result)
+        @lexer.commentpop
     args = {
-        :test => val[0],
-        :statements => ast(AST::Nop)
-    }
+      :test => val[0],
+      :statements => ast(AST::Nop)
+  }
 
-    if val[3]
-        args[:else] = val[3]
-    end
+  args[:else] = val[3] if val[3]
 
-    result = ast AST::IfStatement, args
-   result
+  result = ast AST::IfStatement, args
+
+    result
   end
 .,.,
 
- # reduce 128 omitted
+# reduce 128 omitted
+
+module_eval(<<'.,.,', 'grammar.ra', 468)
+  def _reduce_129(val, _values, result)
+        result = ast AST::Else, :statements => val[1]
 
-module_eval <<'.,.,', 'grammar.ra', 501
-  def _reduce_129( val, _values, result )
-                #@lexer.commentpop
-    result = ast AST::Else, :statements => val[1]
-   result
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 505
-  def _reduce_130( val, _values, result )
-    @lexer.commentpop
+module_eval(<<'.,.,', 'grammar.ra', 471)
+  def _reduce_130(val, _values, result)
+        @lexer.commentpop
     result = ast AST::Else, :statements => val[2]
-   result
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 509
-  def _reduce_131( val, _values, result )
-    @lexer.commentpop
+module_eval(<<'.,.,', 'grammar.ra', 475)
+  def _reduce_131(val, _values, result)
+        @lexer.commentpop
     result = ast AST::Else, :statements => ast(AST::Nop)
-   result
+
+    result
   end
 .,.,
 
- # reduce 132 omitted
+# reduce 132 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 526
-  def _reduce_133( val, _values, result )
-    result = ast AST::InOperator, :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 493)
+  def _reduce_133(val, _values, result)
+        result = ast AST::InOperator, :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 529
-  def _reduce_134( val, _values, result )
-    result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 496)
+  def _reduce_134(val, _values, result)
+        result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 532
-  def _reduce_135( val, _values, result )
-    result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 499)
+  def _reduce_135(val, _values, result)
+        result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 535
-  def _reduce_136( val, _values, result )
-    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 502)
+  def _reduce_136(val, _values, result)
+        result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 538
-  def _reduce_137( val, _values, result )
-    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 505)
+  def _reduce_137(val, _values, result)
+        result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 541
-  def _reduce_138( val, _values, result )
-    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 508)
+  def _reduce_138(val, _values, result)
+        result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 544
-  def _reduce_139( val, _values, result )
-    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 511)
+  def _reduce_139(val, _values, result)
+        result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 547
-  def _reduce_140( val, _values, result )
-    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 514)
+  def _reduce_140(val, _values, result)
+        result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 550
-  def _reduce_141( val, _values, result )
-    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 517)
+  def _reduce_141(val, _values, result)
+        result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 553
-  def _reduce_142( val, _values, result )
-    result = ast AST::Minus, :value => val[1]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 520)
+  def _reduce_142(val, _values, result)
+        result = ast AST::Minus, :value => val[1]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 556
-  def _reduce_143( val, _values, result )
-    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 523)
+  def _reduce_143(val, _values, result)
+        result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 559
-  def _reduce_144( val, _values, result )
-    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 526)
+  def _reduce_144(val, _values, result)
+        result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 562
-  def _reduce_145( val, _values, result )
-    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 529)
+  def _reduce_145(val, _values, result)
+        result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 565
-  def _reduce_146( val, _values, result )
-    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 532)
+  def _reduce_146(val, _values, result)
+        result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 568
-  def _reduce_147( val, _values, result )
-    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 535)
+  def _reduce_147(val, _values, result)
+        result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 571
-  def _reduce_148( val, _values, result )
-    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 538)
+  def _reduce_148(val, _values, result)
+        result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 574
-  def _reduce_149( val, _values, result )
-    result = ast AST::Not, :value => val[1]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 541)
+  def _reduce_149(val, _values, result)
+        result = ast AST::Not, :value => val[1]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 577
-  def _reduce_150( val, _values, result )
-    result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 544)
+  def _reduce_150(val, _values, result)
+        result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 580
-  def _reduce_151( val, _values, result )
-    result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 547)
+  def _reduce_151(val, _values, result)
+        result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 583
-  def _reduce_152( val, _values, result )
-    result = val[1]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 550)
+  def _reduce_152(val, _values, result)
+        result = val[1]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 592
-  def _reduce_153( val, _values, result )
-    @lexer.commentpop
-    options = val[3]
-    unless options.instance_of?(AST::ASTArray)
-        options = ast AST::ASTArray, :children => [val[3]]
-    end
-    result = ast AST::CaseStatement, :test => val[1], :options => options
-   result
+module_eval(<<'.,.,', 'grammar.ra', 554)
+  def _reduce_153(val, _values, result)
+      @lexer.commentpop
+  options = val[3]
+  options = ast AST::ASTArray, :children => [val[3]] unless options.instance_of?(AST::ASTArray)
+  result = ast AST::CaseStatement, :test => val[1], :options => options
+
+    result
   end
 .,.,
 
- # reduce 154 omitted
+# reduce 154 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 602
-  def _reduce_155( val, _values, result )
-    if val[0].instance_of?(AST::ASTArray)
-        val[0].push val[1]
-        result = val[0]
-    else
-        result = ast AST::ASTArray, :children => [val[0], val[1]]
-    end
-   result
+module_eval(<<'.,.,', 'grammar.ra', 562)
+  def _reduce_155(val, _values, result)
+        if val[0].instance_of?(AST::ASTArray)
+    val[0].push val[1]
+    result = val[0]
+  else
+    result = ast AST::ASTArray, :children => [val[0], val[1]]
+  end
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 607
-  def _reduce_156( val, _values, result )
-    @lexer.commentpop
-    result = ast AST::CaseOpt, :value => val[0], :statements => val[3]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 571)
+  def _reduce_156(val, _values, result)
+      @lexer.commentpop
+  result = ast AST::CaseOpt, :value => val[0], :statements => val[3]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 613
-  def _reduce_157( val, _values, result )
-    @lexer.commentpop
-    result = ast(AST::CaseOpt,
-        :value => val[0],
-        :statements => ast(AST::ASTArray)
-    )
-   result
+module_eval(<<'.,.,', 'grammar.ra', 574)
+  def _reduce_157(val, _values, result)
+      @lexer.commentpop
+
+    result = ast(
+    AST::CaseOpt,
+    :value => val[0],
+
+    :statements => ast(AST::ASTArray)
+  )
+
+    result
   end
 .,.,
 
- # reduce 158 omitted
+# reduce 158 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 623
-  def _reduce_159( val, _values, result )
-    if val[0].instance_of?(AST::ASTArray)
-        val[0].push(val[2])
-        result = val[0]
-    else
-        result = ast AST::ASTArray, :children => [val[0],val[2]]
-    end
-   result
+module_eval(<<'.,.,', 'grammar.ra', 586)
+  def _reduce_159(val, _values, result)
+        if val[0].instance_of?(AST::ASTArray)
+    val[0].push(val[2])
+    result = val[0]
+  else
+    result = ast AST::ASTArray, :children => [val[0],val[2]]
+  end
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 627
-  def _reduce_160( val, _values, result )
-    result = ast AST::Selector, :param => val[0], :values => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 595)
+  def _reduce_160(val, _values, result)
+      result = ast AST::Selector, :param => val[0], :values => val[2]
+
+    result
   end
 .,.,
 
- # reduce 161 omitted
+# reduce 161 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 633
-  def _reduce_162( val, _values, result )
-    @lexer.commentpop
+module_eval(<<'.,.,', 'grammar.ra', 600)
+  def _reduce_162(val, _values, result)
+        @lexer.commentpop
     result = val[1]
-   result
+
+    result
   end
 .,.,
 
- # reduce 163 omitted
+# reduce 163 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 643
-  def _reduce_164( val, _values, result )
-    if val[0].instance_of?(AST::ASTArray)
-        val[0].push(val[2])
-        result = val[0]
-    else
-        result = ast AST::ASTArray, :children => [val[0],val[2]]
-    end
-   result
+module_eval(<<'.,.,', 'grammar.ra', 606)
+  def _reduce_164(val, _values, result)
+        if val[0].instance_of?(AST::ASTArray)
+    val[0].push(val[2])
+    result = val[0]
+  else
+    result = ast AST::ASTArray, :children => [val[0],val[2]]
+  end
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 647
-  def _reduce_165( val, _values, result )
-    result = ast AST::ResourceParam, :param => val[0], :value => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 615)
+  def _reduce_165(val, _values, result)
+      result = ast AST::ResourceParam, :param => val[0], :value => val[2]
+
+    result
   end
 .,.,
 
- # reduce 166 omitted
+# reduce 166 omitted
+
+# reduce 167 omitted
 
- # reduce 167 omitted
+# reduce 168 omitted
 
- # reduce 168 omitted
+# reduce 169 omitted
 
- # reduce 169 omitted
+# reduce 170 omitted
 
- # reduce 170 omitted
+# reduce 171 omitted
 
- # reduce 171 omitted
+# reduce 172 omitted
 
- # reduce 172 omitted
+module_eval(<<'.,.,', 'grammar.ra', 626)
+  def _reduce_173(val, _values, result)
+        result = ast AST::Default, :value => val[0][:value], :line => val[0][:line]
 
-module_eval <<'.,.,', 'grammar.ra', 658
-  def _reduce_173( val, _values, result )
-    result = ast AST::Default, :value => val[0][:value], :line => val[0][:line]
-   result
+    result
   end
 .,.,
 
- # reduce 174 omitted
+# reduce 174 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 661
-  def _reduce_175( val, _values, result )
- result = [val[0][:value]]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 631)
+  def _reduce_175(val, _values, result)
+     result = [val[0][:value]] 
+    result
   end
 .,.,
 
- # reduce 176 omitted
+# reduce 176 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 663
-  def _reduce_177( val, _values, result )
- result = val[0] += val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 633)
+  def _reduce_177(val, _values, result)
+     result = val[0] += val[2] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 672
-  def _reduce_178( val, _values, result )
-    val[1].each do |file|
-        import(file)
-    end
+module_eval(<<'.,.,', 'grammar.ra', 636)
+  def _reduce_178(val, _values, result)
+      val[1].each do |file|
+    import(file)
+  end
 
-    result = AST::ASTArray.new(:children => [])
-   result
+  result = AST::ASTArray.new(:children => [])
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 683
-  def _reduce_179( val, _values, result )
-    @lexer.commentpop
-    newdefine classname(val[1]), :arguments => val[2], :code => val[4], :line => val[0][:line]
-    @lexer.indefine = false
-    result = nil
+module_eval(<<'.,.,', 'grammar.ra', 646)
+  def _reduce_179(val, _values, result)
+      @lexer.commentpop
+  result = Puppet::Parser::AST::Definition.new(classname(val[1]),
+                                               ast_context(true).merge(:arguments => val[2], :code => val[4],
+                                                                       :line => val[0][:line]))
+  @lexer.indefine = false
 
 #}           | DEFINE NAME argumentlist parent LBRACE RBRACE {
-   result
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 688
-  def _reduce_180( val, _values, result )
-    @lexer.commentpop
-    newdefine classname(val[1]), :arguments => val[2], :line => val[0][:line]
-    @lexer.indefine = false
-    result = nil
-   result
+module_eval(<<'.,.,', 'grammar.ra', 654)
+  def _reduce_180(val, _values, result)
+      @lexer.commentpop
+  result = Puppet::Parser::AST::Definition.new(classname(val[1]),
+                                               ast_context(true).merge(:arguments => val[2], :line => val[0][:line]))
+  @lexer.indefine = false
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 697
-  def _reduce_181( val, _values, result )
-    @lexer.commentpop
-    # Our class gets defined in the parent namespace, not our own.
-    @lexer.namepop
-    newclass classname(val[1]), :arguments => val[2], :parent => val[3], :code => val[5], :line => val[0][:line]
-    result = nil
-   result
+module_eval(<<'.,.,', 'grammar.ra', 662)
+  def _reduce_181(val, _values, result)
+      @lexer.commentpop
+  # Our class gets defined in the parent namespace, not our own.
+  @lexer.namepop
+  val[5].is_a_namespace = true
+  result = Puppet::Parser::AST::Hostclass.new(classname(val[1]),
+                                              ast_context(true).merge(:arguments => val[2], :parent => val[3],
+                                                                      :code => val[5], :line => val[0][:line]))
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 703
-  def _reduce_182( val, _values, result )
-    @lexer.commentpop
-    # Our class gets defined in the parent namespace, not our own.
-    @lexer.namepop
-    newclass classname(val[1]), :arguments => val[2], :parent => val[3], :line => val[0][:line]
-    result = nil
-   result
+module_eval(<<'.,.,', 'grammar.ra', 670)
+  def _reduce_182(val, _values, result)
+      @lexer.commentpop
+  # Our class gets defined in the parent namespace, not our own.
+  @lexer.namepop
+  result = Puppet::Parser::AST::Hostclass.new(classname(val[1]),
+                                              ast_context(true).merge(:arguments => val[2], :parent => val[3],
+                                                                      :line => val[0][:line]))
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 709
-  def _reduce_183( val, _values, result )
-    @lexer.commentpop
-    newnode val[1], :parent => val[2], :code => val[4], :line => val[0][:line]
-    result = nil
-   result
+module_eval(<<'.,.,', 'grammar.ra', 679)
+  def _reduce_183(val, _values, result)
+      @lexer.commentpop
+  result = Puppet::Parser::AST::Node.new(val[1],
+                                         ast_context(true).merge(:parent => val[2], :code => val[4],
+                                                                 :line => val[0][:line]))
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 713
-  def _reduce_184( val, _values, result )
-    @lexer.commentpop
-    newnode val[1], :parent => val[2], :line => val[0][:line]
-    result = nil
-   result
+module_eval(<<'.,.,', 'grammar.ra', 684)
+  def _reduce_184(val, _values, result)
+      @lexer.commentpop
+  result = Puppet::Parser::AST::Node.new(val[1], ast_context(true).merge(:parent => val[2], :line => val[0][:line]))
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 714
-  def _reduce_185( val, _values, result )
- result = val[0][:value]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 688)
+  def _reduce_185(val, _values, result)
+     result = val[0][:value] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 716
-  def _reduce_186( val, _values, result )
- result = val[0][:value]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 690)
+  def _reduce_186(val, _values, result)
+     result = val[0][:value] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 717
-  def _reduce_187( val, _values, result )
- result = val[0][:value]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 691)
+  def _reduce_187(val, _values, result)
+     result = val[0][:value] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 718
-  def _reduce_188( val, _values, result )
- result = "class"
-   result
+module_eval(<<'.,.,', 'grammar.ra', 692)
+  def _reduce_188(val, _values, result)
+     result = "class" 
+    result
   end
 .,.,
 
- # reduce 189 omitted
+module_eval(<<'.,.,', 'grammar.ra', 697)
+  def _reduce_189(val, _values, result)
+        result = [result]
 
-module_eval <<'.,.,', 'grammar.ra', 728
-  def _reduce_190( val, _values, result )
-    result = val[0]
-    result = [result] unless result.is_a?(Array)
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.ra', 700)
+  def _reduce_190(val, _values, result)
+        result = val[0]
     result << val[2]
-   result
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 732
-  def _reduce_191( val, _values, result )
-    result = ast AST::HostName, :value => val[0]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 705)
+  def _reduce_191(val, _values, result)
+      result = ast AST::HostName, :value => val[0]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 733
-  def _reduce_192( val, _values, result )
- result = val[0][:value]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 708)
+  def _reduce_192(val, _values, result)
+     result = val[0][:value] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 734
-  def _reduce_193( val, _values, result )
- result = val[0][:value]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 709)
+  def _reduce_193(val, _values, result)
+     result = val[0][:value] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 735
-  def _reduce_194( val, _values, result )
- result = val[0][:value]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 710)
+  def _reduce_194(val, _values, result)
+     result = val[0][:value] 
+    result
   end
 .,.,
 
- # reduce 195 omitted
+# reduce 195 omitted
+
+module_eval(<<'.,.,', 'grammar.ra', 714)
+  def _reduce_196(val, _values, result)
+      result = nil
 
-module_eval <<'.,.,', 'grammar.ra', 741
-  def _reduce_196( val, _values, result )
-    result = nil
-   result
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 745
-  def _reduce_197( val, _values, result )
-    result = ast AST::ASTArray, :children => []
-   result
+module_eval(<<'.,.,', 'grammar.ra', 718)
+  def _reduce_197(val, _values, result)
+      result = ast AST::ASTArray, :children => []
+
+    result
   end
 .,.,
 
- # reduce 198 omitted
+# reduce 198 omitted
+
+module_eval(<<'.,.,', 'grammar.ra', 723)
+  def _reduce_199(val, _values, result)
+        result = nil
 
-module_eval <<'.,.,', 'grammar.ra', 750
-  def _reduce_199( val, _values, result )
-    result = nil
-   result
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 754
-  def _reduce_200( val, _values, result )
-    result = val[1]
+module_eval(<<'.,.,', 'grammar.ra', 726)
+  def _reduce_200(val, _values, result)
+        result = val[1]
     result = [result] unless result[0].is_a?(Array)
-   result
+
+    result
   end
 .,.,
 
- # reduce 201 omitted
+# reduce 201 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 761
-  def _reduce_202( val, _values, result )
-    result = val[0]
+module_eval(<<'.,.,', 'grammar.ra', 732)
+  def _reduce_202(val, _values, result)
+        result = val[0]
     result = [result] unless result[0].is_a?(Array)
     result << val[2]
-   result
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 766
-  def _reduce_203( val, _values, result )
-    Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype")
-    result = [val[0][:value], val[2]]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 738)
+  def _reduce_203(val, _values, result)
+      Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype")
+  result = [val[0][:value], val[2]]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 770
-  def _reduce_204( val, _values, result )
-    Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype")
+module_eval(<<'.,.,', 'grammar.ra', 742)
+  def _reduce_204(val, _values, result)
+        Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype")
     result = [val[0][:value]]
-   result
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 772
-  def _reduce_205( val, _values, result )
-    result = [val[0][:value], val[2]]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 745)
+  def _reduce_205(val, _values, result)
+      result = [val[0][:value], val[2]]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 774
-  def _reduce_206( val, _values, result )
-    result = [val[0][:value]]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 747)
+  def _reduce_206(val, _values, result)
+      result = [val[0][:value]]
+
+    result
   end
 .,.,
 
- # reduce 207 omitted
+# reduce 207 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 779
-  def _reduce_208( val, _values, result )
-    result = val[1]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 752)
+  def _reduce_208(val, _values, result)
+        result = val[1]
+
+    result
   end
 .,.,
 
- # reduce 209 omitted
+# reduce 209 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 784
-  def _reduce_210( val, _values, result )
-    result = val[1]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 757)
+  def _reduce_210(val, _values, result)
+        result = val[1]
+
+    result
   end
 .,.,
 
- # reduce 211 omitted
+# reduce 211 omitted
 
- # reduce 212 omitted
+# reduce 212 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 790
-  def _reduce_213( val, _values, result )
-    result = ast AST::Variable, :value => val[0][:value], :line => val[0][:line]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 763)
+  def _reduce_213(val, _values, result)
+      result = ast AST::Variable, :value => val[0][:value], :line => val[0][:line]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 798
-  def _reduce_214( val, _values, result )
-    if val[1].instance_of?(AST::ASTArray)
-        result = val[1]
-    else
-        result = ast AST::ASTArray, :children => [val[1]]
-    end
-   result
+module_eval(<<'.,.,', 'grammar.ra', 767)
+  def _reduce_214(val, _values, result)
+      if val[1].instance_of?(AST::ASTArray)
+    result = val[1]
+  else
+    result = ast AST::ASTArray, :children => [val[1]]
+  end
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 805
-  def _reduce_215( val, _values, result )
-    if val[1].instance_of?(AST::ASTArray)
-        result = val[1]
-    else
-        result = ast AST::ASTArray, :children => [val[1]]
-    end
-   result
+module_eval(<<'.,.,', 'grammar.ra', 774)
+  def _reduce_215(val, _values, result)
+        if val[1].instance_of?(AST::ASTArray)
+    result = val[1]
+  else
+    result = ast AST::ASTArray, :children => [val[1]]
+  end
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 807
-  def _reduce_216( val, _values, result )
-    result = ast AST::ASTArray
-   result
+module_eval(<<'.,.,', 'grammar.ra', 780)
+  def _reduce_216(val, _values, result)
+      result = ast AST::ASTArray
+
+    result
   end
 .,.,
 
- # reduce 217 omitted
+# reduce 217 omitted
 
- # reduce 218 omitted
+# reduce 218 omitted
 
- # reduce 219 omitted
+# reduce 219 omitted
 
-module_eval <<'.,.,', 'grammar.ra', 812
-  def _reduce_220( val, _values, result )
- result = nil
-   result
+module_eval(<<'.,.,', 'grammar.ra', 787)
+  def _reduce_220(val, _values, result)
+     result = nil 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 817
-  def _reduce_221( val, _values, result )
-    result = ast AST::Regex, :value => val[0][:value]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 790)
+  def _reduce_221(val, _values, result)
+      result = ast AST::Regex, :value => val[0][:value]
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 825
-  def _reduce_222( val, _values, result )
-    if val[1].instance_of?(AST::ASTHash)
-        result = val[1]
-    else
-        result = ast AST::ASTHash, { :value => val[1] }
-    end
-   result
+module_eval(<<'.,.,', 'grammar.ra', 794)
+  def _reduce_222(val, _values, result)
+      if val[1].instance_of?(AST::ASTHash)
+    result = val[1]
+  else
+    result = ast AST::ASTHash, { :value => val[1] }
   end
-.,.,
 
-module_eval <<'.,.,', 'grammar.ra', 832
-  def _reduce_223( val, _values, result )
-    if val[1].instance_of?(AST::ASTHash)
-        result = val[1]
-    else
-        result = ast AST::ASTHash, { :value => val[1] }
-    end
-   result
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 834
-  def _reduce_224( val, _values, result )
-    result = ast AST::ASTHash
-   result
+module_eval(<<'.,.,', 'grammar.ra', 801)
+  def _reduce_223(val, _values, result)
+        if val[1].instance_of?(AST::ASTHash)
+    result = val[1]
+  else
+    result = ast AST::ASTHash, { :value => val[1] }
+  end
+
+    result
   end
 .,.,
 
- # reduce 225 omitted
+module_eval(<<'.,.,', 'grammar.ra', 807)
+  def _reduce_224(val, _values, result)
+      result = ast AST::ASTHash
 
-module_eval <<'.,.,', 'grammar.ra', 844
-  def _reduce_226( val, _values, result )
-    if val[0].instance_of?(AST::ASTHash)
-        result = val[0].merge(val[2])
-    else
-        result = ast AST::ASTHash, :value => val[0]
-        result.merge(val[2])
-    end
-   result
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 848
-  def _reduce_227( val, _values, result )
-    result = ast AST::ASTHash, { :value => { val[0] => val[2] } }
-   result
+# reduce 225 omitted
+
+module_eval(<<'.,.,', 'grammar.ra', 812)
+  def _reduce_226(val, _values, result)
+        if val[0].instance_of?(AST::ASTHash)
+    result = val[0].merge(val[2])
+  else
+    result = ast AST::ASTHash, :value => val[0]
+    result.merge(val[2])
+  end
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 849
-  def _reduce_228( val, _values, result )
- result = val[0][:value]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 821)
+  def _reduce_227(val, _values, result)
+      result = ast AST::ASTHash, { :value => { val[0] => val[2] } }
+
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 850
-  def _reduce_229( val, _values, result )
- result = val[0]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 824)
+  def _reduce_228(val, _values, result)
+     result = val[0][:value] 
+    result
   end
 .,.,
 
-module_eval <<'.,.,', 'grammar.ra', 855
-  def _reduce_230( val, _values, result )
-    result = ast AST::HashOrArrayAccess, :variable => val[0][:value], :key => val[2]
-   result
+module_eval(<<'.,.,', 'grammar.ra', 825)
+  def _reduce_229(val, _values, result)
+     result = val[0] 
+    result
   end
 .,.,
 
- # reduce 231 omitted
+module_eval(<<'.,.,', 'grammar.ra', 828)
+  def _reduce_230(val, _values, result)
+      result = ast AST::HashOrArrayAccess, :variable => val[0][:value], :key => val[2]
 
-module_eval <<'.,.,', 'grammar.ra', 860
-  def _reduce_232( val, _values, result )
-    result = ast AST::HashOrArrayAccess, :variable => val[0], :key => val[2]
-   result
+    result
   end
 .,.,
 
- def _reduce_none( val, _values, result )
-  result
- end
+# reduce 231 omitted
 
-    end   # class Parser
+module_eval(<<'.,.,', 'grammar.ra', 833)
+  def _reduce_232(val, _values, result)
+        result = ast AST::HashOrArrayAccess, :variable => val[0], :key => val[2]
+
+    result
+  end
+.,.,
 
-  end   # module Parser
+def _reduce_none(val, _values, result)
+  val[0]
+end
 
-end   # module Puppet
+    end   # class Parser
+    end   # module Parser
+  end   # module Puppet
diff --git a/lib/puppet/parser/parser_support.rb b/lib/puppet/parser/parser_support.rb
index 97d985cfb..859897a16 100644
--- a/lib/puppet/parser/parser_support.rb
+++ b/lib/puppet/parser/parser_support.rb
@@ -133,26 +133,6 @@ class Puppet::Parser::Parser
     return ns, n
   end
 
-  # Create a new class, or merge with an existing class.
-  def newclass(name, options = {})
-    known_resource_types.add Puppet::Resource::Type.new(:hostclass, name, ast_context(true).merge(options))
-  end
-
-  # Create a new definition.
-  def newdefine(name, options = {})
-    known_resource_types.add Puppet::Resource::Type.new(:definition, name, ast_context(true).merge(options))
-  end
-
-  # Create a new node.  Nodes are special, because they're stored in a global
-  # table, not according to namespaces.
-  def newnode(names, options = {})
-    names = [names] unless names.instance_of?(Array)
-    context = ast_context(true)
-    names.collect do |name|
-      known_resource_types.add(Puppet::Resource::Type.new(:node, name, context.merge(options)))
-    end
-  end
-
   def on_error(token,value,stack)
     if token == 0 # denotes end of file
       value = 'end of file'
@@ -174,42 +154,43 @@ class Puppet::Parser::Parser
 
   # how should I do error handling here?
   def parse(string = nil)
-    return parse_ruby_file if self.file =~ /\.rb$/
-    self.string = string if string
-    begin
-      @yydebug = false
-      main = yyparse(@lexer,:scan)
-    rescue Racc::ParseError => except
-      error = Puppet::ParseError.new(except)
-      error.line = @lexer.line
-      error.file = @lexer.file
-      error.set_backtrace except.backtrace
-      raise error
-    rescue Puppet::ParseError => except
-      except.line ||= @lexer.line
-      except.file ||= @lexer.file
-      raise except
-    rescue Puppet::Error => except
-      # and this is a framework error
-      except.line ||= @lexer.line
-      except.file ||= @lexer.file
-      raise except
-    rescue Puppet::DevError => except
-      except.line ||= @lexer.line
-      except.file ||= @lexer.file
-      raise except
-    rescue => except
-      error = Puppet::DevError.new(except.message)
-      error.line = @lexer.line
-      error.file = @lexer.file
-      error.set_backtrace except.backtrace
-      raise error
-    end
-    if main
-      # Store the results as the top-level class.
-      newclass("", :code => main)
+    if self.file =~ /\.rb$/
+      parse_ruby_file
+      main = nil
+    else
+      self.string = string if string
+      begin
+        @yydebug = false
+        main = yyparse(@lexer,:scan)
+      rescue Racc::ParseError => except
+        error = Puppet::ParseError.new(except)
+        error.line = @lexer.line
+        error.file = @lexer.file
+        error.set_backtrace except.backtrace
+        raise error
+      rescue Puppet::ParseError => except
+        except.line ||= @lexer.line
+        except.file ||= @lexer.file
+        raise except
+      rescue Puppet::Error => except
+        # and this is a framework error
+        except.line ||= @lexer.line
+        except.file ||= @lexer.file
+        raise except
+      rescue Puppet::DevError => except
+        except.line ||= @lexer.line
+        except.file ||= @lexer.file
+        raise except
+      rescue => except
+        error = Puppet::DevError.new(except.message)
+        error.line = @lexer.line
+        error.file = @lexer.file
+        error.set_backtrace except.backtrace
+        raise error
+      end
     end
-    return known_resource_types
+    # Store the results as the top-level class.
+    return Puppet::Parser::AST::Hostclass.new('', :code => main)
   ensure
     @lexer.clear
   end
diff --git a/lib/puppet/parser/type_loader.rb b/lib/puppet/parser/type_loader.rb
index 516c1e32b..8a183f493 100644
--- a/lib/puppet/parser/type_loader.rb
+++ b/lib/puppet/parser/type_loader.rb
@@ -47,17 +47,19 @@ class Puppet::Parser::TypeLoader
       raise Puppet::ImportError.new("No file(s) found for import of '#{pat}'")
     end
 
+    loaded_asts = []
     files.each do |file|
       unless file =~ /^#{File::SEPARATOR}/
         file = File.join(dir, file)
       end
       unless imported? file
         @imported[file] = true
-        parse_file(file)
+        loaded_asts << parse_file(file)
       end
     end
-
-    modname
+    loaded_asts.inject([]) do |loaded_types, ast|
+      loaded_types + known_resource_types.import_ast(ast, modname)
+    end
   end
 
   def imported?(file)
@@ -76,23 +78,26 @@ class Puppet::Parser::TypeLoader
     @imported = {}
   end
 
-  # Try to load the object with the given fully qualified name.  For
-  # each file that was actually loaded, yield(filename, modname).
-  def try_load_fqname(fqname)
+  # Try to load the object with the given fully qualified name.
+  def try_load_fqname(type, fqname)
     return nil if fqname == "" # special-case main.
     name2files(fqname).each do |filename|
       if not loaded?(filename)
-        modname = begin
-          import_if_possible(filename)
+        begin
+          imported_types = import_if_possible(filename)
+          if result = imported_types.find { |t| t.type == type and t.name == fqname }
+            Puppet.debug "Automatically imported #{fqname} from #{filename} into #{environment}"
+            return result
+          end
         rescue Puppet::ImportError => detail
           # We couldn't load the item
           # I'm not convienced we should just drop these errors, but this
           # preserves existing behaviours.
-          nil
         end
-        yield(filename, modname)
       end
     end
+    # Nothing found.
+    return nil
   end
 
   def loaded?(name)
@@ -103,7 +108,7 @@ class Puppet::Parser::TypeLoader
     Puppet.debug("importing '#{file}' in environment #{environment}")
     parser = Puppet::Parser::Parser.new(environment)
     parser.file = file
-    parser.parse
+    return parser.parse
   end
 
   # Utility method factored out of load for handling thread-safety.
diff --git a/lib/puppet/resource/type.rb b/lib/puppet/resource/type.rb
index 6296d26e5..57ccba58b 100644
--- a/lib/puppet/resource/type.rb
+++ b/lib/puppet/resource/type.rb
@@ -13,8 +13,8 @@ class Puppet::Resource::Type
 
   RESOURCE_SUPERTYPES = [:hostclass, :node, :definition]
 
-  attr_accessor :file, :line, :doc, :code, :ruby_code, :parent, :resource_type_collection, :module_name
-  attr_reader :type, :namespace, :arguments, :behaves_like
+  attr_accessor :file, :line, :doc, :code, :ruby_code, :parent, :resource_type_collection
+  attr_reader :type, :namespace, :arguments, :behaves_like, :module_name
 
   RESOURCE_SUPERTYPES.each do |t|
     define_method("#{t}?") { self.type == t }
@@ -91,6 +91,8 @@ class Puppet::Resource::Type
     end
 
     set_arguments(options[:arguments])
+
+    @module_name = options[:module_name]
   end
 
   # This is only used for node names, and really only when the node name
diff --git a/lib/puppet/resource/type_collection.rb b/lib/puppet/resource/type_collection.rb
index 4254b037e..a96927613 100644
--- a/lib/puppet/resource/type_collection.rb
+++ b/lib/puppet/resource/type_collection.rb
@@ -19,6 +19,12 @@ class Puppet::Resource::TypeCollection
     @watched_files = {}
   end
 
+  def import_ast(ast, modname)
+    ast.instantiate(modname).each do |instance|
+      add(instance)
+    end
+  end
+
   def <<(thing)
     add(thing)
     self
@@ -177,16 +183,9 @@ class Puppet::Resource::TypeCollection
   # necessary.
   def find_or_load(namespaces, name, type)
     resolve_namespaces(namespaces, name).each do |fqname|
-      if result = send(type, fqname)
+      if result = send(type, fqname) || loader.try_load_fqname(type, fqname)
         return result
       end
-      loader.try_load_fqname(fqname) do |filename, modname|
-        if result = send(type, fqname)
-          Puppet.debug "Automatically imported #{name} from #{filename} into #{environment}"
-          result.module_name = modname if modname and result.respond_to?(:module_name=)
-          return result
-        end
-      end
     end
 
     # Nothing found.
diff --git a/lib/puppet/util/rdoc/parser.rb b/lib/puppet/util/rdoc/parser.rb
index 63df38ab9..30da607d9 100644
--- a/lib/puppet/util/rdoc/parser.rb
+++ b/lib/puppet/util/rdoc/parser.rb
@@ -17,7 +17,7 @@ class Parser
 
   SITE = "__site__"
 
-  attr_accessor :ast, :input_file_name, :top_level
+  attr_accessor :input_file_name, :top_level
 
   # parser registration into RDoc
   parse_files_matching(/\.(rb|pp)$/)
@@ -36,8 +36,12 @@ class Parser
     Puppet.info "rdoc: scanning #{@input_file_name}"
     if @input_file_name =~ /\.pp$/
       @parser = Puppet::Parser::Parser.new(Puppet[:environment])
+      environment = @parser.environment
       @parser.file = @input_file_name
-      @ast = @parser.parse
+      @known_resource_types = environment.known_resource_types
+      @parser.parse.instantiate('').each do |type|
+        @known_resource_types.add type
+      end
     end
     scan_top_level(@top_level)
     @top_level
@@ -334,7 +338,7 @@ class Parser
   # that contains the documentation
   def parse_elements(container)
     Puppet.debug "rdoc: scanning manifest"
-    @ast.hostclasses.values.sort { |a,b| a.name <=> b.name }.each do |klass|
+    @known_resource_types.hostclasses.values.sort { |a,b| a.name <=> b.name }.each do |klass|
       name = klass.name
       if klass.file == @input_file_name
         unless name.empty?
@@ -347,13 +351,13 @@ class Parser
       end
     end
 
-    @ast.definitions.each do |name, define|
+    @known_resource_types.definitions.each do |name, define|
       if define.file == @input_file_name
         document_define(name,define,container)
       end
     end
 
-    @ast.nodes.each do |name, node|
+    @known_resource_types.nodes.each do |name, node|
       if node.file == @input_file_name
         document_node(name.to_s,node,container)
       end