diff --git a/lib/puppet/application/parser.rb b/lib/puppet/application/parser.rb
new file mode 100644
index 000000000..b6ec3c185
--- /dev/null
+++ b/lib/puppet/application/parser.rb
@@ -0,0 +1,5 @@
+require 'puppet/application/face_base'
+require 'puppet/face'
+
+class Puppet::Application::Parser < Puppet::Application::FaceBase
+end
diff --git a/lib/puppet/face/parser.rb b/lib/puppet/face/parser.rb
new file mode 100644
index 000000000..c44810b99
--- /dev/null
+++ b/lib/puppet/face/parser.rb
@@ -0,0 +1,17 @@
+require 'puppet/face'
+require 'puppet/parser'
+
+Puppet::Face.define(:parser, '0.0.1') do
+ action :validate do
+   when_invoked do |*args|
+     args.pop
+     files = args
+     files << Puppet[:manifest] if files.empty?
+     files.each do |file|
+       Puppet[:manifest] = file
+       Puppet::Node::Environment.new(Puppet[:environment]).known_resource_types.clear
+     end
+     nil
+   end
+ end
+end
diff --git a/lib/puppet/resource/type_collection.rb b/lib/puppet/resource/type_collection.rb
index 9fe7cdd06..89b0a16ed 100644
--- a/lib/puppet/resource/type_collection.rb
+++ b/lib/puppet/resource/type_collection.rb
@@ -1,213 +1,214 @@
 class Puppet::Resource::TypeCollection
   attr_reader :environment
   attr_accessor :parse_failed
 
   def clear
     @hostclasses.clear
     @definitions.clear
     @nodes.clear
+    @watched_files.clear
   end
 
   def initialize(env)
     @environment = env.is_a?(String) ? Puppet::Node::Environment.new(env) : env
     @hostclasses = {}
     @definitions = {}
     @nodes = {}
 
     # So we can keep a list and match the first-defined regex
     @node_list = []
 
     @watched_files = {}
   end
 
   def import_ast(ast, modname)
     ast.instantiate(modname).each do |instance|
       add(instance)
     end
   end
 
   def inspect
     "TypeCollection" + { :hostclasses => @hostclasses.keys, :definitions => @definitions.keys, :nodes => @nodes.keys }.inspect
   end
 
   def <<(thing)
     add(thing)
     self
   end
 
   def add(instance)
     if instance.type == :hostclass and other = @hostclasses[instance.name] and other.type == :hostclass
       other.merge(instance)
       return other
     end
     method = "add_#{instance.type}"
     send(method, instance)
     instance.resource_type_collection = self
     instance
   end
 
   def add_hostclass(instance)
     dupe_check(instance, @hostclasses) { |dupe| "Class '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
     dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined as a class" }
 
     @hostclasses[instance.name] = instance
     instance
   end
 
   def hostclass(name)
     @hostclasses[munge_name(name)]
   end
 
   def add_node(instance)
     dupe_check(instance, @nodes) { |dupe| "Node '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
 
     @node_list << instance
     @nodes[instance.name] = instance
     instance
   end
 
   def loader
     require 'puppet/parser/type_loader'
     @loader ||= Puppet::Parser::TypeLoader.new(environment)
   end
 
   def node(name)
     name = munge_name(name)
 
     if node = @nodes[name]
       return node
     end
 
     @node_list.each do |node|
       next unless node.name_is_regex?
       return node if node.match(name)
     end
     nil
   end
 
   def node_exists?(name)
     @nodes[munge_name(name)]
   end
 
   def nodes?
     @nodes.length > 0
   end
 
   def add_definition(instance)
     dupe_check(instance, @hostclasses) { |dupe| "'#{instance.name}' is already defined#{dupe.error_context} as a class; cannot redefine as a definition" }
     dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined" }
     @definitions[instance.name] = instance
   end
 
   def definition(name)
     @definitions[munge_name(name)]
   end
 
   def find_node(namespaces, name)
     @nodes[munge_name(name)]
   end
 
   def find_hostclass(namespaces, name)
     find_or_load(namespaces, name, :hostclass)
   end
 
   def find_definition(namespaces, name)
     find_or_load(namespaces, name, :definition)
   end
 
   [:hostclasses, :nodes, :definitions].each do |m|
     define_method(m) do
       instance_variable_get("@#{m}").dup
     end
   end
 
   def require_reparse?
     @parse_failed || stale?
   end
 
   def stale?
     @watched_files.values.detect { |file| file.changed? }
   end
 
   def version
     return @version if defined?(@version)
 
     if environment[:config_version] == ""
       @version = Time.now.to_i
       return @version
     end
 
     @version = Puppet::Util.execute([environment[:config_version]]).strip
 
   rescue Puppet::ExecutionFailure => e
     raise Puppet::ParseError, "Unable to set config_version: #{e.message}"
   end
 
   def watch_file(file)
     @watched_files[file] = Puppet::Util::LoadedFile.new(file)
   end
 
   def watching_file?(file)
     @watched_files.include?(file)
   end
 
   private
 
   # Return a list of all possible fully-qualified names that might be
   # meant by the given name, in the context of namespaces.
   def resolve_namespaces(namespaces, name)
     name      = name.downcase
     if name =~ /^::/
       # name is explicitly fully qualified, so just return it, sans
       # initial "::".
       return [name.sub(/^::/, '')]
     end
     if name == ""
       # The name "" has special meaning--it always refers to a "main"
       # hostclass which contains all toplevel resources.
       return [""]
     end
 
     namespaces = [namespaces] unless namespaces.is_a?(Array)
     namespaces = namespaces.collect { |ns| ns.downcase }
 
     result = []
     namespaces.each do |namespace|
       ary = namespace.split("::")
 
       # Search each namespace nesting in innermost-to-outermost order.
       while ary.length > 0
         result << "#{ary.join("::")}::#{name}"
         ary.pop
       end
 
       # Finally, search the toplevel namespace.
       result << name
     end
 
     return result.uniq
   end
 
   # Resolve namespaces and find the given object.  Autoload it if
   # necessary.
   def find_or_load(namespaces, name, type)
     resolve_namespaces(namespaces, name).each do |fqname|
       if result = send(type, fqname) || loader.try_load_fqname(type, fqname)
         return result
       end
     end
 
     # Nothing found.
     return nil
   end
 
   def munge_name(name)
     name.to_s.downcase
   end
 
   def dupe_check(instance, hash)
     return unless dupe = hash[instance.name]
     message = yield dupe
     instance.fail Puppet::ParseError, message
   end
 end
diff --git a/spec/unit/resource/type_collection_spec.rb b/spec/unit/resource/type_collection_spec.rb
index b5f0a0ec7..0c997c2ad 100755
--- a/spec/unit/resource/type_collection_spec.rb
+++ b/spec/unit/resource/type_collection_spec.rb
@@ -1,446 +1,451 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/resource/type_collection'
 require 'puppet/resource/type'
 
 describe Puppet::Resource::TypeCollection do
+  include PuppetSpec::Files
+
   before do
     @instance = Puppet::Resource::Type.new(:hostclass, "foo")
     @code = Puppet::Resource::TypeCollection.new("env")
   end
 
   it "should require an environment at initialization" do
     env = Puppet::Node::Environment.new("testing")
     Puppet::Resource::TypeCollection.new(env).environment.should equal(env)
   end
 
   it "should convert the environment into an environment instance if a string is provided" do
     env = Puppet::Node::Environment.new("testing")
     Puppet::Resource::TypeCollection.new("testing").environment.should equal(env)
   end
 
   it "should create a 'loader' at initialization" do
     Puppet::Resource::TypeCollection.new("testing").loader.should be_instance_of(Puppet::Parser::TypeLoader)
   end
 
   it "should be able to add a resource type" do
     Puppet::Resource::TypeCollection.new("env").should respond_to(:add)
   end
 
   it "should consider '<<' to be an alias to 'add' but should return self" do
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.expects(:add).with "foo"
     loader.expects(:add).with "bar"
     loader << "foo" << "bar"
   end
 
   it "should set itself as the code collection for added resource types" do
     loader = Puppet::Resource::TypeCollection.new("env")
 
     node = Puppet::Resource::Type.new(:node, "foo")
 
     @code.add(node)
     @code.node("foo").should equal(node)
 
     node.resource_type_collection.should equal(@code)
   end
 
   it "should store node resource types as nodes" do
     node = Puppet::Resource::Type.new(:node, "foo")
 
     @code.add(node)
     @code.node("foo").should equal(node)
   end
 
   it "should store hostclasses as hostclasses" do
     klass = Puppet::Resource::Type.new(:hostclass, "foo")
 
     @code.add(klass)
     @code.hostclass("foo").should equal(klass)
   end
 
   it "should store definitions as definitions" do
     define = Puppet::Resource::Type.new(:definition, "foo")
 
     @code.add(define)
     @code.definition("foo").should equal(define)
   end
 
   it "should merge new classes with existing classes of the same name" do
     loader = Puppet::Resource::TypeCollection.new("env")
     first = Puppet::Resource::Type.new(:hostclass, "foo")
     second = Puppet::Resource::Type.new(:hostclass, "foo")
     loader.add first
     first.expects(:merge).with(second)
     loader.add(second)
   end
 
   it "should remove all nodes, classes, and definitions when cleared" do
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.add Puppet::Resource::Type.new(:hostclass, "class")
     loader.add Puppet::Resource::Type.new(:definition, "define")
     loader.add Puppet::Resource::Type.new(:node, "node")
+    watched_file = tmpfile('watched_file')
+    loader.watch_file(watched_file)
 
     loader.clear
     loader.hostclass("class").should be_nil
     loader.definition("define").should be_nil
     loader.node("node").should be_nil
+    loader.should_not be_watching_file(watched_file)
   end
 
   describe "when resolving namespaces" do
     [ ['',               '::foo', ['foo']],
       ['a',              '::foo', ['foo']],
       ['a::b',           '::foo', ['foo']],
       [['a::b'],         '::foo', ['foo']],
       [['a::b', 'c'],    '::foo', ['foo']],
       [['A::B', 'C'],    '::Foo', ['foo']],
       ['',               '',      ['']],
       ['a',              '',      ['']],
       ['a::b',           '',      ['']],
       [['a::b'],         '',      ['']],
       [['a::b', 'c'],    '',      ['']],
       [['A::B', 'C'],    '',      ['']],
       ['',               'foo',   ['foo']],
       ['a',              'foo',   ['a::foo', 'foo']],
       ['a::b',           'foo',   ['a::b::foo', 'a::foo', 'foo']],
       ['A::B',           'Foo',   ['a::b::foo', 'a::foo', 'foo']],
       [['a::b'],         'foo',   ['a::b::foo', 'a::foo', 'foo']],
       [['a', 'b'],       'foo',   ['a::foo', 'foo', 'b::foo']],
       [['a::b', 'c::d'], 'foo',   ['a::b::foo', 'a::foo', 'foo', 'c::d::foo', 'c::foo']],
       [['a::b', 'a::c'], 'foo',   ['a::b::foo', 'a::foo', 'foo', 'a::c::foo']],
     ].each do |namespaces, name, expected_result|
       it "should resolve #{name.inspect} in namespaces #{namespaces.inspect} correctly" do
         @code.instance_eval { resolve_namespaces(namespaces, name) }.should == expected_result
       end
     end
   end
 
   describe "when looking up names" do
     before do
       @type = Puppet::Resource::Type.new(:hostclass, "ns::klass")
     end
 
     it "should support looking up with multiple namespaces" do
       @code.add @type
       @code.find_hostclass(%w{boo baz ns}, "klass").should equal(@type)
     end
 
     it "should not attempt to import anything when the type is already defined" do
       @code.add @type
       @code.loader.expects(:import).never
       @code.find_hostclass(%w{ns}, "klass").should equal(@type)
     end
 
     describe "that need to be loaded" do
       it "should use the loader to load the files" do
         @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
         @code.loader.expects(:try_load_fqname).with(:hostclass, "klass")
         @code.find_hostclass(["ns"], "klass")
       end
 
       it "should downcase the name and downcase and array-fy the namespaces before passing to the loader" do
         @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
         @code.loader.expects(:try_load_fqname).with(:hostclass, "klass")
         @code.find_hostclass("Ns", "Klass")
       end
 
       it "should use the class returned by the loader" do
         @code.loader.expects(:try_load_fqname).returns(:klass)
         @code.expects(:hostclass).with("ns::klass").returns(false)
         @code.find_hostclass("ns", "klass").should == :klass
       end
 
       it "should return nil if the name isn't found" do
         @code.stubs(:try_load_fqname).returns(nil)
         @code.find_hostclass("Ns", "Klass").should be_nil
       end
 
       it "already-loaded names at broader scopes should not shadow autoloaded names" do
         @code.add Puppet::Resource::Type.new(:hostclass, "bar")
         @code.loader.expects(:try_load_fqname).with(:hostclass, "foo::bar").returns(:foobar)
         @code.find_hostclass("foo", "bar").should == :foobar
       end
     end
   end
 
   %w{hostclass node definition}.each do |data|
     before do
       @instance = Puppet::Resource::Type.new(data, "foo")
     end
 
     it "should have a method for adding a #{data}" do
       Puppet::Resource::TypeCollection.new("env").should respond_to("add_#{data}")
     end
 
     it "should use the name of the instance to add it" do
       loader = Puppet::Resource::TypeCollection.new("env")
       loader.send("add_#{data}", @instance)
       loader.send(data, @instance.name).should equal(@instance)
     end
 
     unless data == "hostclass"
       it "should fail to add a #{data} when one already exists" do
         loader = Puppet::Resource::TypeCollection.new("env")
         loader.add @instance
         lambda { loader.add(@instance) }.should raise_error(Puppet::ParseError)
       end
     end
 
     it "should return the added #{data}" do
       loader = Puppet::Resource::TypeCollection.new("env")
 
       loader.add(@instance).should equal(@instance)
     end
 
     it "should be able to retrieve #{data} by name" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(data, "bar")
       loader.add instance
       loader.send(data, "bar").should equal(instance)
     end
 
     it "should retrieve #{data} insensitive to case" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(data, "Bar")
       loader.add instance
       loader.send(data, "bAr").should equal(instance)
     end
 
     it "should return nil when asked for a #{data} that has not been added" do
       Puppet::Resource::TypeCollection.new("env").send(data, "foo").should be_nil
     end
 
     it "should be able to retrieve all #{data}s" do
       plurals = { "hostclass" => "hostclasses", "node" => "nodes", "definition" => "definitions" }
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(data, "foo")
       loader.add instance
       loader.send(plurals[data]).should == { "foo" => instance }
     end
   end
 
   describe "when finding a qualified instance" do
     it "should return any found instance if the instance name is fully qualified" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
       loader.find_hostclass("namespace", "::foo::bar").should equal(instance)
     end
 
     it "should return nil if the instance name is fully qualified and no such instance exists" do
       loader = Puppet::Resource::TypeCollection.new("env")
       loader.find_hostclass("namespace", "::foo::bar").should be_nil
     end
 
     it "should be able to find classes in the base namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo")
       loader.add instance
       loader.find_hostclass("", "foo").should equal(instance)
     end
 
     it "should return the partially qualified object if it exists in a provided namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass("foo", "bar::baz").should equal(instance)
     end
 
     it "should be able to find partially qualified objects in any of the provided namespaces" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass(["nons", "foo", "otherns"], "bar::baz").should equal(instance)
     end
 
     it "should return the unqualified object if it exists in a provided namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
       loader.find_hostclass("foo", "bar").should equal(instance)
     end
 
     it "should return the unqualified object if it exists in the parent namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
       loader.find_hostclass("foo::bar::baz", "bar").should equal(instance)
     end
 
     it "should should return the partially qualified object if it exists in the parent namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass("foo::bar", "bar::baz").should equal(instance)
     end
 
     it "should return the qualified object if it exists in the root namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass("foo::bar", "foo::bar::baz").should equal(instance)
     end
 
     it "should return nil if the object cannot be found" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass("foo::bar", "eh").should be_nil
     end
 
     describe "when topscope has a class that has the same name as a local class" do
       before do
         @loader = Puppet::Resource::TypeCollection.new("env")
         [ "foo::bar", "bar" ].each do |name|
           @loader.add Puppet::Resource::Type.new(:hostclass, name)
         end
       end
 
       it "should favor the local class, if the name is unqualified" do
         @loader.find_hostclass("foo", "bar").name.should == 'foo::bar'
       end
 
       it "should only look in the topclass, if the name is qualified" do
         @loader.find_hostclass("foo", "::bar").name.should == 'bar'
       end
 
     end
     
     it "should not look in the local scope for classes when the name is qualified" do
         @loader = Puppet::Resource::TypeCollection.new("env")
         @loader.add Puppet::Resource::Type.new(:hostclass, "foo::bar")
 
         @loader.find_hostclass("foo", "::bar").should == nil
     end
 
   end
 
   it "should be able to find nodes" do
     node = Puppet::Resource::Type.new(:node, "bar")
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.add(node)
     loader.find_node(stub("ignored"), "bar").should == node
   end
 
   it "should use the 'find_or_load' method to find hostclasses" do
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.expects(:find_or_load).with("foo", "bar", :hostclass)
     loader.find_hostclass("foo", "bar")
   end
 
   it "should use the 'find_or_load' method to find definitions" do
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.expects(:find_or_load).with("foo", "bar", :definition)
     loader.find_definition("foo", "bar")
   end
 
   it "should indicate whether any nodes are defined" do
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.add_node(Puppet::Resource::Type.new(:node, "foo"))
     loader.should be_nodes
   end
 
   it "should indicate whether no nodes are defined" do
     Puppet::Resource::TypeCollection.new("env").should_not be_nodes
   end
 
   describe "when finding nodes" do
     before :each do
       @loader = Puppet::Resource::TypeCollection.new("env")
     end
 
     it "should return any node whose name exactly matches the provided node name" do
       node = Puppet::Resource::Type.new(:node, "foo")
       @loader << node
 
       @loader.node("foo").should equal(node)
     end
 
     it "should return the first regex node whose regex matches the provided node name" do
       node1 = Puppet::Resource::Type.new(:node, /\w/)
       node2 = Puppet::Resource::Type.new(:node, /\d/)
       @loader << node1 << node2
 
       @loader.node("foo10").should equal(node1)
     end
 
     it "should preferentially return a node whose name is string-equal over returning a node whose regex matches a provided name" do
       node1 = Puppet::Resource::Type.new(:node, /\w/)
       node2 = Puppet::Resource::Type.new(:node, "foo")
       @loader << node1 << node2
 
       @loader.node("foo").should equal(node2)
     end
   end
 
   describe "when managing files" do
     before do
       @loader = Puppet::Resource::TypeCollection.new("env")
       Puppet::Util::LoadedFile.stubs(:new).returns stub("watched_file")
     end
 
     it "should have a method for specifying a file should be watched" do
       @loader.should respond_to(:watch_file)
     end
 
     it "should have a method for determining if a file is being watched" do
       @loader.watch_file("/foo/bar")
       @loader.should be_watching_file("/foo/bar")
     end
 
     it "should use LoadedFile to watch files" do
       Puppet::Util::LoadedFile.expects(:new).with("/foo/bar").returns stub("watched_file")
       @loader.watch_file("/foo/bar")
     end
 
     it "should be considered stale if any files have changed" do
       file1 = stub 'file1', :changed? => false
       file2 = stub 'file2', :changed? => true
       Puppet::Util::LoadedFile.expects(:new).times(2).returns(file1).then.returns(file2)
       @loader.watch_file("/foo/bar")
       @loader.watch_file("/other/bar")
 
       @loader.should be_stale
     end
 
     it "should not be considered stable if no files have changed" do
       file1 = stub 'file1', :changed? => false
       file2 = stub 'file2', :changed? => false
       Puppet::Util::LoadedFile.expects(:new).times(2).returns(file1).then.returns(file2)
       @loader.watch_file("/foo/bar")
       @loader.watch_file("/other/bar")
 
       @loader.should_not be_stale
     end
   end
 
   describe "when determining the configuration version" do
     before do
       @code = Puppet::Resource::TypeCollection.new("env")
     end
 
     it "should default to the current time" do
       time = Time.now
 
       Time.stubs(:now).returns time
       @code.version.should == time.to_i
     end
 
     it "should use the output of the environment's config_version setting if one is provided" do
       @code.environment.stubs(:[]).with(:config_version).returns("/my/foo")
 
       Puppet::Util.expects(:execute).with(["/my/foo"]).returns "output\n"
       @code.version.should == "output"
     end
 
     it "should raise a puppet parser error if executing config_version fails" do
       @code.environment.stubs(:[]).with(:config_version).returns("test")
       Puppet::Util.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
 
       lambda { @code.version }.should raise_error(Puppet::ParseError)
     end
 
   end
 
 end