diff --git a/doc/rustdoc.md b/doc/rustdoc.md
index 39fc03bca0d..16bcf8d6dd8 100644
--- a/doc/rustdoc.md
+++ b/doc/rustdoc.md
@@ -132,9 +132,10 @@ specifiers that can be used to dictate how a code block is tested:
 ~~~
 
 Rustdoc also supplies some extra sugar for helping with some tedious
-documentation examples. If a line is prefixed with a `#` character, then the
-line will not show up in the HTML documentation, but it will be used when
-testing the code block.
+documentation examples. If a line is prefixed with `# `, then the line
+will not show up in the HTML documentation, but it will be used when
+testing the code block (NB. the space after the `#` is required, so
+that one can still write things like `#[deriving(Eq)]`).
 
 ~~~
 ```rust
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index 6fd83af3b2e..f445e11aa02 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -101,7 +101,7 @@ pub fn render(w: &mut io::Writer, s: &str) {
             vec::raw::buf_as_slice((*text).data, (*text).size as uint, |text| {
                 let text = str::from_utf8(text);
                 let mut lines = text.lines().filter(|l| {
-                    !l.trim().starts_with("#")
+                    !l.trim().starts_with("# ")
                 });
                 let text = lines.to_owned_vec().connect("\n");
 
@@ -169,7 +169,9 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) {
             vec::raw::buf_as_slice((*text).data, (*text).size as uint, |text| {
                 let tests: &mut ::test::Collector = intrinsics::transmute(opaque);
                 let text = str::from_utf8(text);
-                let mut lines = text.lines().map(|l| l.trim_chars(&'#'));
+                let mut lines = text.lines().map(|l| {
+                            if l.starts_with("# ") {l.slice_from(2)} else {l}
+                        });
                 let text = lines.to_owned_vec().connect("\n");
                 tests.add_test(text, ignore, shouldfail);
             })
diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs
index 9462f8118ba..60e46439910 100644
--- a/src/librustdoc/test.rs
+++ b/src/librustdoc/test.rs
@@ -171,6 +171,7 @@ impl Collector {
         self.cnt += 1;
         let libs = (*self.libs).clone();
         let cratename = self.cratename.to_owned();
+        debug!("Creating test {}: {}", name, test);
         self.tests.push(test::TestDescAndFn {
             desc: test::TestDesc {
                 name: test::DynTestName(name),
diff --git a/src/test/run-make/rustdoc-hidden-line/Makefile b/src/test/run-make/rustdoc-hidden-line/Makefile
new file mode 100644
index 00000000000..7e6f8fe105e
--- /dev/null
+++ b/src/test/run-make/rustdoc-hidden-line/Makefile
@@ -0,0 +1,7 @@
+-include ../tools.mk
+
+all:
+	$(RUSTDOC) --test foo.rs
+	$(RUSTDOC) -w html -o $(TMPDIR)/doc foo.rs
+	cp verify.sh $(TMPDIR)
+	$(call RUN,verify.sh) $(TMPDIR)
diff --git a/src/test/run-make/rustdoc-hidden-line/foo.rs b/src/test/run-make/rustdoc-hidden-line/foo.rs
new file mode 100644
index 00000000000..69c7683780b
--- /dev/null
+++ b/src/test/run-make/rustdoc-hidden-line/foo.rs
@@ -0,0 +1,22 @@
+#[crate_id="foo#0.1"];
+
+/// The '# ' lines should be removed from the output, but the #[deriving] should be
+/// retained.
+///
+/// ```rust
+/// mod to_make_deriving_work { // FIXME #4913
+///
+/// # #[deriving(Eq)] // invisible
+/// # struct Foo; // invisible
+///
+/// #[deriving(Eq)] // Bar
+/// struct Bar(Foo);
+///
+/// fn test() {
+///     let x = Bar(Foo);
+///     assert!(x == x); // check that the derivings worked
+/// }
+///
+/// }
+/// ```
+pub fn foo() {}
diff --git a/src/test/run-make/rustdoc-hidden-line/verify.sh b/src/test/run-make/rustdoc-hidden-line/verify.sh
new file mode 100755
index 00000000000..c1d817c998d
--- /dev/null
+++ b/src/test/run-make/rustdoc-hidden-line/verify.sh
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+file="$1/doc/foo/fn.foo.html"
+
+grep -v 'invisible' $file &&
+grep '#\[deriving(Eq)\] // Bar' $file
+
+exit $?