diff --git a/src/doc/complement-cheatsheet.md b/src/doc/complement-cheatsheet.md
index e3848fba0a1fa..5ad0e82658d1a 100644
--- a/src/doc/complement-cheatsheet.md
+++ b/src/doc/complement-cheatsheet.md
@@ -255,7 +255,7 @@ Note: The Rust signatures should be wrapped in an `extern "ABI" { ... }` block.
 
 You might see things like this in C APIs:
 
-~~~ {.notrust}
+~~~c
 typedef struct Window Window;
 Window* createWindow(int width, int height);
 ~~~
diff --git a/src/doc/complement-lang-faq.md b/src/doc/complement-lang-faq.md
index c03c72ca35fd1..12176102ec64f 100644
--- a/src/doc/complement-lang-faq.md
+++ b/src/doc/complement-lang-faq.md
@@ -135,7 +135,7 @@ For simplicity, we do not plan to do so. Implementing automatic semicolon insert
 
 **Short answer** set the RUST_LOG environment variable to the name of your source file, sans extension.
 
-```notrust,sh
+```sh
 rustc hello.rs
 export RUST_LOG=hello
 ./hello
diff --git a/src/doc/guide-ffi.md b/src/doc/guide-ffi.md
index a7aca9246108c..13e44765d59eb 100644
--- a/src/doc/guide-ffi.md
+++ b/src/doc/guide-ffi.md
@@ -229,7 +229,7 @@ fn main() {
 
 C code:
 
-~~~~ {.notrust}
+~~~~c
 typedef void (*rust_callback)(int32_t);
 rust_callback cb;
 
@@ -296,7 +296,7 @@ fn main() {
 
 C code:
 
-~~~~ {.notrust}
+~~~~c
 typedef void (*rust_callback)(int32_t);
 void* cb_target;
 rust_callback cb;
diff --git a/src/doc/guide-lifetimes.md b/src/doc/guide-lifetimes.md
index e92a24f8b9431..2f519306dfd08 100644
--- a/src/doc/guide-lifetimes.md
+++ b/src/doc/guide-lifetimes.md
@@ -218,7 +218,7 @@ fn example3() -> int {
 To make this clearer, consider this diagram showing the state of
 memory immediately before the re-assignment of `x`:
 
-~~~ {.notrust}
+~~~ {.text}
     Stack               Exchange Heap
 
   x +-------------+
@@ -232,7 +232,7 @@ memory immediately before the re-assignment of `x`:
 
 Once the reassignment occurs, the memory will look like this:
 
-~~~ {.notrust}
+~~~ {.text}
     Stack               Exchange Heap
 
   x +-------------+          +---------+
@@ -329,7 +329,7 @@ to a pointer of type `&size` into the _interior of the enum_.
 To make this more clear, let's look at a diagram of memory layout in
 the case where `shape` points at a rectangle:
 
-~~~ {.notrust}
+~~~ {.text}
 Stack             Memory
 
 +-------+         +---------------+
@@ -354,7 +354,7 @@ to store that shape value would still be valid, _it would have a
 different type_! The following diagram shows what memory would look
 like if code overwrote `shape` with a circle:
 
-~~~ {.notrust}
+~~~ {.text}
 Stack             Memory
 
 +-------+         +---------------+
diff --git a/src/doc/guide-pointers.md b/src/doc/guide-pointers.md
index 97dd78234267d..5161dbc6bbb60 100644
--- a/src/doc/guide-pointers.md
+++ b/src/doc/guide-pointers.md
@@ -31,7 +31,7 @@ fn main() {
 
 And now I get an error:
 
-~~~ {.notrust}
+~~~text
 error: mismatched types: expected `&int` but found `<generic integer #0>` (expected &-ptr but found integral variable)
 ~~~
 
@@ -201,7 +201,7 @@ fn main() {
 
 This prints:
 
-~~~ {.notrust}
+~~~text
 Cons(1, box Cons(2, box Cons(3, box Nil)))
 ~~~
 
@@ -347,7 +347,7 @@ fn main() {
 
 It gives this error:
 
-~~~ {.notrust}
+~~~text
 test.rs:5:8: 5:10 error: cannot assign to `*x` because it is borrowed
 test.rs:5         *x -= 1;
                   ^~
diff --git a/src/doc/guide-testing.md b/src/doc/guide-testing.md
index 057849f1bca73..a1d89961840e2 100644
--- a/src/doc/guide-testing.md
+++ b/src/doc/guide-testing.md
@@ -19,7 +19,7 @@ fn return_two_test() {
 To run these tests, compile with `rustc --test` and run the resulting
 binary:
 
-~~~ {.notrust}
+~~~console
 $ rustc --test foo.rs
 $ ./foo
 running 1 test
@@ -111,7 +111,7 @@ sequentially.
 
 ### Typical test run
 
-~~~ {.notrust}
+~~~console
 $ mytests
 
 running 30 tests
@@ -125,7 +125,7 @@ result: ok. 28 passed; 0 failed; 2 ignored
 
 ### Test run with failures
 
-~~~ {.notrust}
+~~~console
 $ mytests
 
 running 30 tests
@@ -139,7 +139,7 @@ result: FAILED. 27 passed; 1 failed; 2 ignored
 
 ### Running ignored tests
 
-~~~ {.notrust}
+~~~console
 $ mytests --ignored
 
 running 2 tests
@@ -153,7 +153,7 @@ result: FAILED. 1 passed; 1 failed; 0 ignored
 
 Using a plain string:
 
-~~~ {.notrust}
+~~~console
 $ mytests mytest23
 
 running 1 tests
@@ -164,7 +164,7 @@ result: ok. 1 passed; 0 failed; 0 ignored
 
 Using some regular expression features:
 
-~~~ {.notrust}
+~~~console
 $ mytests 'mytest[145]'
 
 running 13 tests
@@ -247,7 +247,7 @@ Advice on writing benchmarks:
 To run benchmarks, pass the `--bench` flag to the compiled
 test-runner. Benchmarks are compiled-in but not executed by default.
 
-~~~ {.notrust}
+~~~console
 $ rustc mytests.rs -O --test
 $ mytests --bench
 
@@ -283,7 +283,7 @@ fn bench_xor_1000_ints(b: &mut Bencher) {
 
 gives the following results
 
-~~~ {.notrust}
+~~~console
 running 1 test
 test bench_xor_1000_ints ... bench:         0 ns/iter (+/- 0)
 
@@ -323,7 +323,7 @@ overhead (e.g. `black_box(&huge_struct)`).
 Performing either of the above changes gives the following
 benchmarking results
 
-~~~ {.notrust}
+~~~console
 running 1 test
 test bench_xor_1000_ints ... bench:       375 ns/iter (+/- 148)
 
diff --git a/src/doc/intro.md b/src/doc/intro.md
index 0e9114d7b7632..50f57aca12f1f 100644
--- a/src/doc/intro.md
+++ b/src/doc/intro.md
@@ -22,7 +22,7 @@ and is the feature from which many of Rust's powerful capabilities are derived.
 write, and ultimately release, memory.
 Let's start by looking at some C++ code:
 
-```notrust
+```cpp
 int* dangling(void)
 {
     int i = 1234;
@@ -74,7 +74,7 @@ fn main() {
 
 Save this program as `dangling.rs`. When you try to compile this program with `rustc dangling.rs`, you'll get an interesting (and long) error message:
 
-```notrust
+```text
 dangling.rs:3:12: 3:14 error: `i` does not live long enough
 dangling.rs:3     return &i;
                          ^~
@@ -155,7 +155,7 @@ You can roughly compare these two lines:
 let i = box 1234;
 ```
 
-```notrust
+```cpp
 // C++
 int *i = new int;
 *i = 1234;
@@ -254,7 +254,7 @@ fn main() {
 
 This will result an error indicating that the value is no longer in scope:
 
-```notrust
+```text
 concurrency.rs:12:20: 12:27 error: use of moved value: 'numbers'
 concurrency.rs:12     println!("{}", numbers.get(0));
                                      ^~~~~~~
diff --git a/src/doc/po/ja/tutorial.md.po b/src/doc/po/ja/tutorial.md.po
index 966d39b29f7de..00ec1bc36709d 100644
--- a/src/doc/po/ja/tutorial.md.po
+++ b/src/doc/po/ja/tutorial.md.po
@@ -356,15 +356,15 @@ msgstr "上記条件を満たしていれば、以下のような手順でビル
 #: src/doc/tutorial.md:112
 #, fuzzy
 #| msgid ""
-#| "~~~~ {.notrust} $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar."
+#| "~~~~console $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar."
 #| "gz $ tar -xzf rust-nightly.tar.gz $ cd rust-nightly $ ./configure $ make && make "
 #| "install ~~~~"
 msgid ""
-"~~~~ {.notrust} $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz $ "
+"~~~~console $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz $ "
 "tar -xzf rust-nightly.tar.gz $ cd rust-nightly $ ./configure $ make && make install "
 "~~~~"
 msgstr ""
-"~~~~ {.notrust}\n"
+"~~~~console\n"
 "$ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz\n"
 "$ tar -xzf rust-nightly.tar.gz $ cd rust-nightly $ ./configure\n"
 "$ make && make install\n"
@@ -4610,7 +4610,7 @@ msgstr ""
 #: src/doc/tutorial.md:2761 src/doc/tutorial.md:2793
 #, fuzzy
 #| msgid "~~~~ {.ignore} let foo = 10;"
-msgid "~~~ {.notrust} src/plants.rs src/plants/mod.rs"
+msgid "~~~text src/plants.rs src/plants/mod.rs"
 msgstr ""
 "~~~~ {.ignore}\n"
 "let foo = 10;"
@@ -4927,24 +4927,24 @@ msgstr ""
 #: src/doc/tutorial.md:3168
 #, fuzzy, no-wrap
 #| msgid ""
-#| "~~~~ {.notrust}\n"
-#| "> rustc --lib world.rs  # compiles libworld-94839cbfe144198-1.0.so\n"
-#| "> rustc main.rs -L .    # compiles main\n"
-#| "> ./main\n"
+#| "~~~~console\n"
+#| "$ rustc --lib world.rs  # compiles libworld-94839cbfe144198-1.0.so\n"
+#| "$ rustc main.rs -L .    # compiles main\n"
+#| "$ ./main\n"
 #| "\"hello world\"\n"
 #| "~~~~\n"
 msgid ""
-"~~~~ {.notrust}\n"
-"> rustc --lib world.rs  # compiles libworld-<HASH>-0.42.so\n"
-"> rustc main.rs -L .    # compiles main\n"
-"> ./main\n"
+"~~~~console\n"
+"$ rustc --crate-type=lib world.rs  # compiles libworld-<HASH>-0.42.so\n"
+"$ rustc main.rs -L .               # compiles main\n"
+"$ ./main\n"
 "\"hello world\"\n"
 "~~~~\n"
 msgstr ""
-"~~~~ {.notrust}\n"
-"> rustc --lib world.rs  # libworld-94839cbfe144198-1.0.so が生成される\n"
-"> rustc main.rs -L .    # main が生成される\n"
-"> ./main\n"
+"~~~~console\n"
+"$ rustc --lib world.rs  # libworld-94839cbfe144198-1.0.so が生成される\n"
+"$ rustc main.rs -L .    # main が生成される\n"
+"$ ./main\n"
 "\"hello world\"\n"
 "~~~~\n"
 
diff --git a/src/doc/rust.md b/src/doc/rust.md
index cde26bd881335..8935e84c78bb6 100644
--- a/src/doc/rust.md
+++ b/src/doc/rust.md
@@ -59,7 +59,7 @@ dialect of EBNF supported by common automated LL(k) parsing tools such as
 `llgen`, rather than the dialect given in ISO 14977. The dialect can be
 defined self-referentially as follows:
 
-~~~~ {.notrust .ebnf .notation}
+~~~~ {.ebnf .notation}
 grammar : rule + ;
 rule    : nonterminal ':' productionrule ';' ;
 productionrule : production [ '|' production ] * ;
@@ -153,7 +153,7 @@ Some productions are defined by exclusion of particular Unicode characters:
 
 ## Comments
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 comment : block_comment | line_comment ;
 block_comment : "/*" block_comment_body * '*' + '/' ;
 block_comment_body : [block_comment | character] * ;
@@ -174,7 +174,7 @@ Non-doc comments are interpreted as a form of whitespace.
 
 ## Whitespace
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 whitespace_char : '\x20' | '\x09' | '\x0a' | '\x0d' ;
 whitespace : [ whitespace_char | comment ] + ;
 ~~~~
@@ -191,7 +191,7 @@ with any other legal whitespace element, such as a single space character.
 
 ## Tokens
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 simple_token : keyword | unop | binop ;
 token : simple_token | ident | literal | symbol | whitespace token ;
 ~~~~
@@ -205,7 +205,7 @@ grammar as double-quoted strings. Other tokens have exact rules given.
 
 The keywords are the following strings:
 
-~~~~ {.notrust .keyword}
+~~~~ {.text .keyword}
 as
 box break
 continue crate
@@ -233,13 +233,13 @@ evaluates to, rather than referring to it by name or some other evaluation
 rule. A literal is a form of constant expression, so is evaluated (primarily)
 at compile time.
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 literal : string_lit | char_lit | num_lit ;
 ~~~~
 
 #### Character and string literals
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 char_lit : '\x27' char_body '\x27' ;
 string_lit : '"' string_body * '"' | 'r' raw_string ;
 
@@ -321,7 +321,7 @@ r##"foo #"# bar"##;                // foo #"# bar
 
 #### Number literals
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 num_lit : nonzero_dec [ dec_digit | '_' ] * num_suffix ?
         | '0' [       [ dec_digit | '_' ] * num_suffix ?
               | 'b'   [ '1' | '0' | '_' ] + int_suffix ?
@@ -419,7 +419,7 @@ The two values of the boolean type are written `true` and `false`.
 
 ### Symbols
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 symbol : "::" "->"
        | '#' | '[' | ']' | '(' | ')' | '{' | '}'
        | ',' | ';' ;
@@ -434,7 +434,7 @@ operators](#binary-operator-expressions), or [keywords](#keywords).
 
 ## Paths
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 expr_path : [ "::" ] ident [ "::" expr_path_tail ] + ;
 expr_path_tail : '<' type_expr [ ',' type_expr ] + '>'
                | expr_path ;
@@ -543,7 +543,7 @@ All of the above extensions are expressions with values.
 
 ## Macros
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 expr_macro_rules : "macro_rules" '!' ident '(' macro_rule * ')' ;
 macro_rule : '(' matcher * ')' "=>" '(' transcriber * ')' ';' ;
 matcher : '(' matcher * ')' | '[' matcher * ']'
@@ -687,7 +687,7 @@ each of which may have some number of [attributes](#attributes) attached to it.
 
 ## Items
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 item : mod_item | fn_item | type_item | struct_item | enum_item
      | static_item | trait_item | impl_item | extern_block ;
 ~~~~
@@ -735,7 +735,7 @@ That is, Rust has no notion of type abstraction: there are no first-class "foral
 
 ### Modules
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 mod_item : "mod" ident ( ';' | '{' mod '}' );
 mod : [ view_item | item ] * ;
 ~~~~
@@ -803,7 +803,7 @@ mod task {
 
 #### View items
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 view_item : extern_crate_decl | use_decl ;
 ~~~~
 
@@ -816,7 +816,7 @@ There are several kinds of view item:
 
 ##### Extern crate declarations
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 extern_crate_decl : "extern" "crate" ident [ '(' link_attrs ')' ] ? [ '=' string_lit ] ? ;
 link_attrs : link_attr [ ',' link_attrs ] + ;
 link_attr : ident '=' literal ;
@@ -848,7 +848,7 @@ extern crate foo = "some/where/rust-foo#foo:1.0"; // a full crate ID for externa
 
 ##### Use declarations
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 use_decl : "pub" ? "use" [ ident '=' path
                           | path_glob ] ;
 
@@ -1274,7 +1274,7 @@ whereas `Dog` is simply called an enum variant.
 
 ### Static items
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 static_item : "static" ident ':' type '=' expr ';' ;
 ~~~~
 
@@ -1519,7 +1519,7 @@ impl Seq<bool> for u32 {
 
 ### External blocks
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 extern_block_item : "extern" '{' extern_block '}' ;
 extern_block : [ foreign_fn ] * ;
 ~~~~
@@ -1741,7 +1741,7 @@ import public items from their destination, not private items.
 
 ## Attributes
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 attribute : '#' '!' ? '[' meta_item ']' ;
 meta_item : ident [ '=' literal
                   | '(' meta_seq ')' ] ? ;
@@ -2383,7 +2383,7 @@ declaring a function-local item.
 
 #### Slot declarations
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 let_decl : "let" pat [':' type ] ? [ init ] ? ';' ;
 init : [ '=' ] expr ;
 ~~~~
@@ -2483,7 +2483,7 @@ values.
 
 ### Structure expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 struct_expr : expr_path '{' ident ':' expr
                       [ ',' ident ':' expr ] *
                       [ ".." expr ] '}' |
@@ -2537,7 +2537,7 @@ Point3d {y: 0, z: 10, .. base};
 
 ### Block expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 block_expr : '{' [ view_item ] *
                  [ stmt ';' | item ] *
                  [ expr ] '}' ;
@@ -2555,7 +2555,7 @@ of the block are that of the expression itself.
 
 ### Method-call expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 method_call_expr : expr '.' ident paren_expr_list ;
 ~~~~
 
@@ -2566,7 +2566,7 @@ or dynamically dispatching if the left-hand-side expression is an indirect [obje
 
 ### Field expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 field_expr : expr '.' ident ;
 ~~~~
 
@@ -2588,7 +2588,7 @@ it is automatically dereferenced to make the field access possible.
 
 ### Vector expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 vec_expr : '[' "mut" ? vec_elems? ']' ;
 
 vec_elems : [expr [',' expr]*] | [expr ',' ".." expr] ;
@@ -2610,7 +2610,7 @@ as a [literal](#literals) or a [static item](#static-items).
 
 ### Index expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 idx_expr : expr '[' expr ']' ;
 ~~~~
 
@@ -2662,7 +2662,7 @@ before the expression they apply to.
 
 ### Binary operator expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 binop_expr : expr binop expr ;
 ~~~~
 
@@ -2803,7 +2803,7 @@ Any such expression always has the [`unit`](#primitive-types) type.
 The precedence of Rust binary operators is ordered as follows, going
 from strong to weak:
 
-~~~~ {.notrust .precedence}
+~~~~ {.text .precedence}
 * / %
 as
 + -
@@ -2827,7 +2827,7 @@ An expression enclosed in parentheses evaluates to the result of the enclosed
 expression.  Parentheses can be used to explicitly specify evaluation order
 within an expression.
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 paren_expr : '(' expr ')' ;
 ~~~~
 
@@ -2840,7 +2840,7 @@ let x = (2 + 3) * 4;
 
 ### Call expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 expr_list : [ expr [ ',' expr ]* ] ? ;
 paren_expr_list : '(' expr_list ')' ;
 call_expr : expr paren_expr_list ;
@@ -2863,7 +2863,7 @@ let pi: Option<f32> = FromStr::from_str("3.14");
 
 ### Lambda expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 ident_list : [ ident [ ',' ident ]* ] ? ;
 lambda_expr : '|' ident_list '|' expr ;
 ~~~~
@@ -2906,7 +2906,7 @@ ten_times(|j| println!("hello, {}", j));
 
 ### While loops
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 while_expr : "while" expr '{' block '}' ;
 ~~~~
 
@@ -2930,7 +2930,7 @@ while i < 10 {
 
 A `loop` expression denotes an infinite loop.
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 loop_expr : [ lifetime ':' ] "loop" '{' block '}';
 ~~~~
 
@@ -2941,7 +2941,7 @@ See [Break expressions](#break-expressions) and [Continue expressions](#continue
 
 ### Break expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 break_expr : "break" [ lifetime ];
 ~~~~
 
@@ -2954,7 +2954,7 @@ but must enclose it.
 
 ### Continue expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 continue_expr : "continue" [ lifetime ];
 ~~~~
 
@@ -2973,7 +2973,7 @@ A `continue` expression is only permitted in the body of a loop.
 
 ### For expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 for_expr : "for" pat "in" expr '{' block '}' ;
 ~~~~
 
@@ -3007,7 +3007,7 @@ for i in range(0u, 256) {
 
 ### If expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 if_expr : "if" expr '{' block '}'
           else_tail ? ;
 
@@ -3028,7 +3028,7 @@ then any `else` block is executed.
 
 ### Match expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 match_expr : "match" expr '{' match_arm * '}' ;
 
 match_arm : attribute * match_pat "=>" [ expr "," | '{' block '}' ] ;
@@ -3219,7 +3219,7 @@ let message = match maybe_digit {
 
 ### Return expressions
 
-~~~~ {.notrust .ebnf .gram}
+~~~~ {.ebnf .gram}
 return_expr : "return" expr ? ;
 ~~~~
 
@@ -3496,7 +3496,7 @@ x = bo(5,7);
 
 ### Closure types
 
-~~~~ {.notrust .ebnf .notation}
+~~~~ {.ebnf .notation}
 closure_type := [ 'unsafe' ] [ '<' lifetime-list '>' ] '|' arg-list '|'
                 [ ':' bound-list ] [ '->' type ]
 procedure_type := 'proc' [ '<' lifetime-list '>' ] '(' arg-list ')'
@@ -4107,7 +4107,7 @@ fn main() {
 
 These four log levels correspond to levels 1-4, as controlled by `RUST_LOG`:
 
-```notrust,bash
+```sh
 $ RUST_LOG=rust=3 ./rust
 This is an error log
 This is a warn log
diff --git a/src/doc/rustdoc.md b/src/doc/rustdoc.md
index 1034c776ea6dd..af69c6c1f7f15 100644
--- a/src/doc/rustdoc.md
+++ b/src/doc/rustdoc.md
@@ -122,33 +122,41 @@ source code.
 
 To test documentation, the `--test` argument is passed to rustdoc:
 
-~~~ {.notrust}
+~~~ {.sh}
 rustdoc --test crate.rs
 ~~~
 
 ## Defining tests
 
 Rust documentation currently uses the markdown format, and rustdoc treats all
-code blocks as testable-by-default. In order to not run a test over a block of
-code, the `ignore` string can be added to the three-backtick form of markdown
-code block.
+code blocks as testable-by-default unless they carry a language tag of another
+language. In order to not run a test over a block of code, the `ignore` string
+can be added to the three-backtick form of markdown code block.
 
-~~~notrust
+~~~md
 ```
 // This is a testable code block
 ```
 
+```rust{.example}
+// This is rust and also testable
+```
+
 ```ignore
 // This is not a testable code block
 ```
 
     // This is a testable code block (4-space indent)
+
+```sh
+# this is shell code and not tested
+```
 ~~~
 
 You can specify that the test's execution should fail with the `should_fail`
 directive.
 
-~~~notrust
+~~~md
 ```should_fail
 // This code block is expected to generate a failure when run
 ```
@@ -157,7 +165,7 @@ directive.
 You can specify that the code block should be compiled but not run with the
 `no_run` directive.
 
-~~~notrust
+~~~md
 ```no_run
 // This code will be compiled but not executed
 ```
@@ -169,7 +177,7 @@ 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)]`).
 
-~~~notrust
+~~~md
 ```
 # /!\ The three following lines are comments, which are usually stripped off by
 # the doc-generating tool.  In order to display them anyway in this particular
@@ -194,7 +202,7 @@ uses is build on crate `test`, which is also used when you compile crates with
 rustc's `--test` flag. Extra arguments can be passed to rustdoc's test harness
 with the `--test-args` flag.
 
-~~~ {.notrust}
+~~~console
 # Only run tests containing 'foo' in their name
 $ rustdoc --test lib.rs --test-args 'foo'
 
diff --git a/src/doc/tutorial.md b/src/doc/tutorial.md
index d75071b76ed45..4ee76952f0c9d 100644
--- a/src/doc/tutorial.md
+++ b/src/doc/tutorial.md
@@ -106,7 +106,7 @@ packages:
 If you've fulfilled those prerequisites, something along these lines
 should work.
 
-~~~~ {.notrust}
+~~~~console
 $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz
 $ tar -xzf rust-nightly.tar.gz
 $ cd rust-nightly
@@ -151,7 +151,7 @@ error. If you introduce an error into the program (for example, by changing
 `println!` to some nonexistent macro), and then compile it, you'll see
 an error message like this:
 
-~~~~ {.notrust}
+~~~~text
 hello.rs:2:5: 2:24 error: macro undefined: 'print_with_unicorns'
 hello.rs:2     print_with_unicorns!("hello?");
                ^~~~~~~~~~~~~~~~~~~
@@ -1066,7 +1066,7 @@ being destroyed along with the owner. Since the `list` variable above is
 immutable, the whole list is immutable. The memory allocation itself is the
 box, while the owner holds onto a pointer to it:
 
-~~~ {.notrust}
+~~~text
             List box            List box            List box          List box
         +--------------+    +--------------+    +--------------+    +----------+
 list -> | Cons | 1 |   | -> | Cons | 2 |   | -> | Cons | 3 |   | -> | Nil      |
@@ -2841,7 +2841,7 @@ mod animals {
 
 The compiler will look for these files, in this order:
 
-~~~ {.notrust}
+~~~text
 src/plants.rs
 src/plants/mod.rs
 
@@ -2872,7 +2872,7 @@ mod mammals {
 
 ...then the source files of `mod animals`'s submodules can either be in the same directory as the animals source file or in a subdirectory of its directory. If the animals file is `src/animals.rs`, `rustc` will look for:
 
-~~~ {.notrust}
+~~~text
 src/animals.rs
     src/fish.rs
     src/fish/mod.rs
@@ -2883,7 +2883,7 @@ src/animals.rs
 
 If the animals file is `src/animals/mod.rs`, `rustc` will look for:
 
-~~~ {.notrust}
+~~~text
 src/animals/mod.rs
     src/animals/fish.rs
     src/animals/fish/mod.rs
@@ -3244,10 +3244,10 @@ fn main() { println!("hello {}", world::explore()); }
 
 Now compile and run like this (adjust to your platform if necessary):
 
-~~~~ {.notrust}
-> rustc --crate-type=lib world.rs  # compiles libworld-<HASH>-0.42.so
-> rustc main.rs -L .               # compiles main
-> ./main
+~~~~console
+$ rustc --crate-type=lib world.rs  # compiles libworld-<HASH>-0.42.so
+$ rustc main.rs -L .               # compiles main
+$ ./main
 "hello world"
 ~~~~
 
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index a80b20775de4b..3a847004df909 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -59,7 +59,7 @@ pub trait Zero: Add<Self, Self> {
     ///
     /// # Laws
     ///
-    /// ~~~notrust
+    /// ~~~text
     /// a + 0 = a       ∀ a ∈ Self
     /// 0 + a = a       ∀ a ∈ Self
     /// ~~~
@@ -123,7 +123,7 @@ pub trait One: Mul<Self, Self> {
     ///
     /// # Laws
     ///
-    /// ~~~notrust
+    /// ~~~text
     /// a * 1 = a       ∀ a ∈ Self
     /// 1 * a = a       ∀ a ∈ Self
     /// ~~~
diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs
index 11df847122b3f..ff5805599690d 100644
--- a/src/liblog/lib.rs
+++ b/src/liblog/lib.rs
@@ -57,7 +57,7 @@ disabled except for `error!` (a log level of 1). Logging is controlled via the
 `RUST_LOG` environment variable. The value of this environment variable is a
 comma-separated list of logging directives. A logging directive is of the form:
 
-```notrust
+```text
 path::to::module=log_level
 ```
 
@@ -80,7 +80,7 @@ all modules is set to this value.
 
 Some examples of valid values of `RUST_LOG` are:
 
-```notrust
+```text
 hello                // turns on all logging for the 'hello' module
 info                 // turns on all info logging
 hello=debug          // turns on debug logging for 'hello'
diff --git a/src/librand/distributions/gamma.rs b/src/librand/distributions/gamma.rs
index 445fe9acbeca0..cfabf2b08e2e8 100644
--- a/src/librand/distributions/gamma.rs
+++ b/src/librand/distributions/gamma.rs
@@ -20,7 +20,7 @@ use super::{IndependentSample, Sample, Exp};
 ///
 /// The density function of this distribution is
 ///
-/// ```notrust
+/// ```text
 /// f(x) =  x^(k - 1) * exp(-x / θ) / (Γ(k) * θ^k)
 /// ```
 ///
diff --git a/src/librustc/middle/borrowck/doc.rs b/src/librustc/middle/borrowck/doc.rs
index c65501b535557..74faf7cf17c0c 100644
--- a/src/librustc/middle/borrowck/doc.rs
+++ b/src/librustc/middle/borrowck/doc.rs
@@ -56,7 +56,7 @@ it is safe with respect to the in-scope loans.
 Throughout the docs we'll consider a simple subset of Rust in which
 you can only borrow from lvalues, defined like so:
 
-```notrust
+```text
 LV = x | LV.f | *LV
 ```
 
@@ -64,7 +64,7 @@ Here `x` represents some variable, `LV.f` is a field reference,
 and `*LV` is a pointer dereference. There is no auto-deref or other
 niceties. This means that if you have a type like:
 
-```notrust
+```text
 struct S { f: uint }
 ```
 
@@ -73,7 +73,7 @@ to an `LV` of `(*a).f`.
 
 Here is the formal grammar for the types we'll consider:
 
-```notrust
+```text
 TY = () | S<'LT...> | Box<TY> | & 'LT MQ TY | @ MQ TY
 MQ = mut | imm | const
 ```
@@ -81,7 +81,7 @@ MQ = mut | imm | const
 Most of these types should be pretty self explanatory. Here `S` is a
 struct name and we assume structs are declared like so:
 
-```notrust
+```text
 SD = struct S<'LT...> { (f: TY)... }
 ```
 
@@ -93,7 +93,7 @@ SD = struct S<'LT...> { (f: TY)... }
 
 Now, imagine we had a program like this:
 
-```notrust
+```text
 struct Foo { f: uint, g: uint }
 ...
 'a: {
@@ -118,7 +118,7 @@ the borrow, and (3) a set of restrictions. In the code, `Loan` is a
 struct defined in `middle::borrowck`. Formally, we define `LOAN` as
 follows:
 
-```notrust
+```text
 LOAN = (LV, LT, MQ, RESTRICTION*)
 RESTRICTION = (LV, ACTION*)
 ACTION = MUTATE | CLAIM | FREEZE
@@ -151,7 +151,7 @@ To give you a better feeling for what kind of restrictions derived
 from a loan, let's look at the loan `L` that would be issued as a
 result of the borrow `&mut (*x).f` in the example above:
 
-```notrust
+```text
 L = ((*x).f, 'a, mut, RS) where
     RS = [((*x).f, [MUTATE, CLAIM, FREEZE]),
           (*x, [MUTATE, CLAIM, FREEZE]),
@@ -214,7 +214,7 @@ conditions that it uses. For simplicity I will ignore const loans.
 I will present the rules in a modified form of standard inference
 rules, which looks as follows:
 
-```notrust
+```text
 PREDICATE(X, Y, Z)                  // Rule-Name
   Condition 1
   Condition 2
@@ -290,7 +290,7 @@ Let's begin with the rules for variables, which state that if a
 variable is declared as mutable, it may be borrowed any which way, but
 otherwise the variable must be borrowed as immutable or const:
 
-```notrust
+```text
 MUTABILITY(X, MQ)                   // M-Var-Mut
   DECL(X) = mut
 
@@ -305,7 +305,7 @@ Fields and owned pointers inherit their mutability from
 their base expressions, so both of their rules basically
 delegate the check to the base expression `LV`:
 
-```notrust
+```text
 MUTABILITY(LV.f, MQ)                // M-Field
   MUTABILITY(LV, MQ)
 
@@ -319,7 +319,7 @@ MUTABILITY(*LV, MQ)                 // M-Deref-Unique
 Immutable pointer types like `&T` and `@T` can only
 be borrowed if MQ is immutable or const:
 
-```notrust
+```text
 MUTABILITY(*LV, MQ)                // M-Deref-Borrowed-Imm
   TYPE(LV) = &Ty
   MQ == imm | const
@@ -333,7 +333,7 @@ MUTABILITY(*LV, MQ)                // M-Deref-Managed-Imm
 
 `&mut T` can be frozen, so it is acceptable to borrow it as either imm or mut:
 
-```notrust
+```text
 MUTABILITY(*LV, MQ)                 // M-Deref-Borrowed-Mut
   TYPE(LV) = &mut Ty
 ```
@@ -352,7 +352,7 @@ Rust code corresponding to this predicate is the function
 Local variables are never aliasable as they are accessible only within
 the stack frame.
 
-```notrust
+```text
     ALIASABLE(X, MQ)                   // M-Var-Mut
 ```
 
@@ -360,7 +360,7 @@ the stack frame.
 
 Owned content is aliasable if it is found in an aliasable location:
 
-```notrust
+```text
 ALIASABLE(LV.f, MQ)                // M-Field
   ALIASABLE(LV, MQ)
 
@@ -373,7 +373,7 @@ ALIASABLE(*LV, MQ)                 // M-Deref-Unique
 Immutable pointer types like `&T` are aliasable, and hence can only be
 borrowed immutably:
 
-```notrust
+```text
 ALIASABLE(*LV, imm)                // M-Deref-Borrowed-Imm
   TYPE(LV) = &Ty
 ```
@@ -382,7 +382,7 @@ ALIASABLE(*LV, imm)                // M-Deref-Borrowed-Imm
 
 `&mut T` can be frozen, so it is acceptable to borrow it as either imm or mut:
 
-```notrust
+```text
 ALIASABLE(*LV, MQ)                 // M-Deref-Borrowed-Mut
   TYPE(LV) = &mut Ty
 ```
@@ -405,13 +405,13 @@ guaranteed to exist, presuming that no mutations occur.
 
 The scope of a local variable is the block where it is declared:
 
-```notrust
+```text
   SCOPE(X) = block where X is declared
 ```
 
 The scope of a field is the scope of the struct:
 
-```notrust
+```text
   SCOPE(LV.f) = SCOPE(LV)
 ```
 
@@ -419,7 +419,7 @@ The scope of a unique referent is the scope of the pointer, since
 (barring mutation or moves) the pointer will not be freed until
 the pointer itself `LV` goes out of scope:
 
-```notrust
+```text
   SCOPE(*LV) = SCOPE(LV) if LV has type Box<T>
 ```
 
@@ -427,7 +427,7 @@ The scope of a managed referent is also the scope of the pointer.  This
 is a conservative approximation, since there may be other aliases for
 that same managed box that would cause it to live longer:
 
-```notrust
+```text
   SCOPE(*LV) = SCOPE(LV) if LV has type @T
 ```
 
@@ -435,7 +435,7 @@ The scope of a borrowed referent is the scope associated with the
 pointer.  This is a conservative approximation, since the data that
 the pointer points at may actually live longer:
 
-```notrust
+```text
   SCOPE(*LV) = LT if LV has type &'LT T or &'LT mut T
 ```
 
@@ -444,7 +444,7 @@ the pointer points at may actually live longer:
 The rule for variables states that a variable can only be borrowed a
 lifetime `LT` that is a subregion of the variable's scope:
 
-```notrust
+```text
 LIFETIME(X, LT, MQ)                 // L-Local
   LT <= SCOPE(X)
 ```
@@ -454,7 +454,7 @@ LIFETIME(X, LT, MQ)                 // L-Local
 The lifetime of a field or owned pointer is the same as the lifetime
 of its owner:
 
-```notrust
+```text
 LIFETIME(LV.f, LT, MQ)              // L-Field
   LIFETIME(LV, LT, MQ)
 
@@ -471,7 +471,7 @@ lifetime. Therefore, the borrow is valid so long as the lifetime `LT`
 of the borrow is shorter than the lifetime `LT'` of the pointer
 itself:
 
-```notrust
+```text
 LIFETIME(*LV, LT, MQ)               // L-Deref-Borrowed
   TYPE(LV) = &LT' Ty OR &LT' mut Ty
   LT <= LT'
@@ -484,7 +484,7 @@ Managed pointers are valid so long as the data within them is
 when the user guarantees such a root will exist. For this to be true,
 three conditions must be met:
 
-```notrust
+```text
 LIFETIME(*LV, LT, MQ)               // L-Deref-Managed-Imm-User-Root
   TYPE(LV) = @Ty
   LT <= SCOPE(LV)                   // (1)
@@ -518,7 +518,7 @@ borrow without crossing the exit from the scope `LT`.
 
 The rule for compiler rooting is as follows:
 
-```notrust
+```text
 LIFETIME(*LV, LT, MQ)               // L-Deref-Managed-Imm-Compiler-Root
   TYPE(LV) = @Ty
   LT <= innermost enclosing loop/func
@@ -542,7 +542,7 @@ for the lifetime of the loan".
 Note that there is an initial set of restrictions: these restrictions
 are computed based on the kind of borrow:
 
-```notrust
+```text
 &mut LV =>   RESTRICTIONS(LV, LT, MUTATE|CLAIM|FREEZE)
 &LV =>       RESTRICTIONS(LV, LT, MUTATE|CLAIM)
 &const LV => RESTRICTIONS(LV, LT, [])
@@ -559,7 +559,7 @@ moved out from under it, so no actions are forbidden.
 
 The simplest case is a borrow of a local variable `X`:
 
-```notrust
+```text
 RESTRICTIONS(X, LT, ACTIONS) = (X, ACTIONS)            // R-Variable
 ```
 
@@ -570,7 +570,7 @@ In such cases we just record the actions that are not permitted.
 Restricting a field is the same as restricting the owner of that
 field:
 
-```notrust
+```text
 RESTRICTIONS(LV.f, LT, ACTIONS) = RS, (LV.f, ACTIONS)  // R-Field
   RESTRICTIONS(LV, LT, ACTIONS) = RS
 ```
@@ -593,7 +593,7 @@ must prevent the owned pointer `LV` from being mutated, which means
 that we always add `MUTATE` and `CLAIM` to the restriction set imposed
 on `LV`:
 
-```notrust
+```text
 RESTRICTIONS(*LV, LT, ACTIONS) = RS, (*LV, ACTIONS)    // R-Deref-Send-Pointer
   TYPE(LV) = Box<Ty>
   RESTRICTIONS(LV, LT, ACTIONS|MUTATE|CLAIM) = RS
@@ -610,7 +610,7 @@ restricting that path. Therefore, the rule for `&Ty` and `@Ty`
 pointers always returns an empty set of restrictions, and it only
 permits restricting `MUTATE` and `CLAIM` actions:
 
-```notrust
+```text
 RESTRICTIONS(*LV, LT, ACTIONS) = []                    // R-Deref-Imm-Managed
   TYPE(LV) = @Ty
   ACTIONS subset of [MUTATE, CLAIM]
@@ -733,7 +733,7 @@ Because moves from a `&const` or `@const` lvalue are never legal, it
 is not necessary to add any restrictions at all to the final
 result.
 
-```notrust
+```text
     RESTRICTIONS(*LV, LT, []) = []                         // R-Deref-Freeze-Borrowed
       TYPE(LV) = &const Ty or @const Ty
 ```
@@ -749,7 +749,7 @@ while the new claimant is live.
 
 The rule for mutable borrowed pointers is as follows:
 
-```notrust
+```text
 RESTRICTIONS(*LV, LT, ACTIONS) = RS, (*LV, ACTIONS)    // R-Deref-Mut-Borrowed
   TYPE(LV) = &LT' mut Ty
   LT <= LT'                                            // (1)
diff --git a/src/librustc/middle/typeck/infer/doc.rs b/src/librustc/middle/typeck/infer/doc.rs
index 8befb1639c122..886550a3b2461 100644
--- a/src/librustc/middle/typeck/infer/doc.rs
+++ b/src/librustc/middle/typeck/infer/doc.rs
@@ -45,7 +45,7 @@ There are several critical invariants which we maintain:
 > types lie in between.  The bottom type is then the Null type.
 > So the tree looks like:
 >
-> ```notrust
+> ```text
 >         Object
 >         /    \
 >     String   Other
@@ -106,7 +106,7 @@ Pictorally, what this does is to take two distinct variables with
 (hopefully not completely) distinct type ranges and produce one with
 the intersection.
 
-```notrust
+```text
                   B.ub                  B.ub
                    /\                    /
            A.ub   /  \           A.ub   /
@@ -129,7 +129,7 @@ bounds in such a way that, whatever happens, we know that A <: B will hold.
 This can be achieved by ensuring that A.ub <: B.lb.  In practice there
 are two ways to do that, depicted pictorally here:
 
-```notrust
+```text
     Before                Option #1            Option #2
 
              B.ub                B.ub                B.ub
@@ -164,7 +164,7 @@ course, it depends on the program.
 
 The main case which fails today that I would like to support is:
 
-```notrust
+```text
 fn foo<T>(x: T, y: T) { ... }
 
 fn bar() {
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index 48393db3b7d86..406bdc48af3b2 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -168,7 +168,8 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
                     slice::raw::buf_as_slice((*lang).data,
                                            (*lang).size as uint, |rlang| {
                         let rlang = str::from_utf8(rlang).unwrap();
-                        if rlang.contains("notrust") {
+                        let (_,_,_,notrust) = parse_lang_string(rlang);
+                        if notrust {
                             (my_opaque.dfltblk)(ob, &buf, lang,
                                                 opaque as *mut libc::c_void);
                             true
diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs
index 8dc2dd4bdb6e1..fd3df63ebd412 100644
--- a/src/libstd/fmt.rs
+++ b/src/libstd/fmt.rs
@@ -85,7 +85,7 @@ function, but the `format!` macro is a syntax extension which allows it to
 leverage named parameters. Named parameters are listed at the end of the
 argument list and have the syntax:
 
-```notrust
+```text
 identifier '=' expression
 ```
 
@@ -110,7 +110,7 @@ Each argument's type is dictated by the format string. It is a requirement that
 every argument is only ever referred to by one type. For example, this is an
 invalid format string:
 
-```notrust
+```text
 {0:d} {0:s}
 ```
 
@@ -126,7 +126,7 @@ must have the type `uint`. Although a `uint` can be printed with `{:u}`, it is
 illegal to reference an argument as such. For example, this is another invalid
 format string:
 
-```notrust
+```text
 {:.*s} {0:u}
 ```
 
@@ -347,7 +347,7 @@ This example is the equivalent of `{0:s}` essentially.
 The select method is a switch over a `&str` parameter, and the parameter *must*
 be of the type `&str`. An example of the syntax is:
 
-```notrust
+```text
 {0, select, male{...} female{...} other{...}}
 ```
 
@@ -366,7 +366,7 @@ The plural method is a switch statement over a `uint` parameter, and the
 parameter *must* be a `uint`. A plural method in its full glory can be specified
 as:
 
-```notrust
+```text
 {0, plural, offset=1 =1{...} two{...} many{...} other{...}}
 ```
 
@@ -394,7 +394,7 @@ should not be too alien. Arguments are formatted with python-like syntax,
 meaning that arguments are surrounded by `{}` instead of the C-like `%`. The
 actual grammar for the formatting syntax is:
 
-```notrust
+```text
 format_string := <text> [ format <text> ] *
 format := '{' [ argument ] [ ':' format_spec ] [ ',' function_spec ] '}'
 argument := integer | identifier
diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs
index 7bf4df357f433..101a9c7e3a3c4 100644
--- a/src/libsyntax/ext/deriving/generic/mod.rs
+++ b/src/libsyntax/ext/deriving/generic/mod.rs
@@ -102,7 +102,7 @@ above `PartialEq`, `A`, `B` and `C`.
 
 When generating the `expr` for the `A` impl, the `SubstructureFields` is
 
-~~~notrust
+~~~text
 Struct(~[FieldInfo {
            span: <span of x>
            name: Some(<ident of x>),
@@ -113,7 +113,7 @@ Struct(~[FieldInfo {
 
 For the `B` impl, called with `B(a)` and `B(b)`,
 
-~~~notrust
+~~~text
 Struct(~[FieldInfo {
           span: <span of `int`>,
           name: None,
@@ -127,7 +127,7 @@ Struct(~[FieldInfo {
 When generating the `expr` for a call with `self == C0(a)` and `other
 == C0(b)`, the SubstructureFields is
 
-~~~notrust
+~~~text
 EnumMatching(0, <ast::Variant for C0>,
              ~[FieldInfo {
                 span: <span of int>
@@ -139,7 +139,7 @@ EnumMatching(0, <ast::Variant for C0>,
 
 For `C1 {x}` and `C1 {x}`,
 
-~~~notrust
+~~~text
 EnumMatching(1, <ast::Variant for C1>,
              ~[FieldInfo {
                 span: <span of x>
@@ -151,7 +151,7 @@ EnumMatching(1, <ast::Variant for C1>,
 
 For `C0(a)` and `C1 {x}` ,
 
-~~~notrust
+~~~text
 EnumNonMatching(~[(0, <ast::Variant for B0>,
                    ~[(<span of int>, None, <expr for &a>)]),
                   (1, <ast::Variant for B1>,
@@ -165,7 +165,7 @@ EnumNonMatching(~[(0, <ast::Variant for B0>,
 
 A static method on the above would result in,
 
-~~~~notrust
+~~~text
 StaticStruct(<ast::StructDef of A>, Named(~[(<ident of x>, <span of x>)]))
 
 StaticStruct(<ast::StructDef of B>, Unnamed(~[<span of x>]))
@@ -792,7 +792,7 @@ impl<'a> MethodDef<'a> {
     /**
     Creates the nested matches for an enum definition recursively, i.e.
 
-   ~~~notrust
+   ~~~text
     match self {
        Variant1 => match other { Variant1 => matching, Variant2 => nonmatching, ... },
        Variant2 => match other { Variant1 => nonmatching, Variant2 => matching, ... },