On second thought, re-land pull request #1385 with backquotes; easier to grep, can change in the future.

graydon · graydon · commit 2ed1005bd73f · 2011-12-28T13:41:31.000-08:00
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
@@ -369,7 +369,7 @@ fn ast_ty_to_ty(tcx: ty::ctxt, mode: mode, &&ast_ty: @ast::ty) -> ty::t {
         alt mode {
           m_check_tyvar(fcx) { ret next_ty_var(fcx); }
           _ { tcx.sess.span_bug(ast_ty.span,
-                                "found 'ty_infer' in unexpected place"); }
+                                "found `ty_infer` in unexpected place"); }
         }
       }
     }
@@ -895,11 +895,11 @@ mod demand {
             let e_err = resolve_type_vars_if_possible(fcx, expected);
             let a_err = resolve_type_vars_if_possible(fcx, actual);
             fcx.ccx.tcx.sess.span_err(sp,
-                                      "mismatched types: expected '" +
+                                      "mismatched types: expected `" +
                                           ty_to_str(fcx.ccx.tcx, e_err) +
-                                          "' but found '" +
+                                          "` but found `" +
                                           ty_to_str(fcx.ccx.tcx, a_err) +
-                                          "' (" + ty::type_err_to_str(err) +
+                                          "` (" + ty::type_err_to_str(err) +
                                           ")");
             ret mk_result(fcx, expected, ty_param_subst_var_ids);
           }
@@ -1303,7 +1303,7 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,
             // can never tell.
             fcx.ccx.tcx.sess.span_fatal
                 (pat.span,
-                 #fmt["mismatched types: expected '%s' but found tag",
+                 #fmt["mismatched types: expected `%s` but found tag",
                       ty_to_str(fcx.ccx.tcx, expected)]);
           }
         }
@@ -1316,7 +1316,7 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,
           _ {
             fcx.ccx.tcx.sess.span_fatal
                 (pat.span,
-                #fmt["mismatched types: expected '%s' but found record",
+                #fmt["mismatched types: expected `%s` but found record",
                                 ty_to_str(fcx.ccx.tcx, expected)]);
           }
         }
@@ -1338,7 +1338,7 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,
               none. {
                 fcx.ccx.tcx.sess.span_fatal(pat.span,
                                             #fmt["mismatched types: did not \
-                                           expect a record with a field '%s'",
+                                           expect a record with a field `%s`",
                                                  f.ident]);
               }
             }
@@ -1352,7 +1352,7 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,
           _ {
             fcx.ccx.tcx.sess.span_fatal
                 (pat.span,
-                 #fmt["mismatched types: expected '%s', found tuple",
+                 #fmt["mismatched types: expected `%s`, found tuple",
                         ty_to_str(fcx.ccx.tcx, expected)]);
           }
         }
@@ -1375,9 +1375,9 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,
           }
           _ {
             fcx.ccx.tcx.sess.span_fatal(pat.span,
-                                        "mismatched types: expected '" +
+                                        "mismatched types: expected `" +
                                             ty_to_str(fcx.ccx.tcx, expected) +
-                                            "' found box");
+                                            "` found box");
           }
         }
       }
@@ -1389,9 +1389,9 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,
           }
           _ {
             fcx.ccx.tcx.sess.span_fatal(pat.span,
-                                        "mismatched types: expected '" +
+                                        "mismatched types: expected `" +
                                             ty_to_str(fcx.ccx.tcx, expected) +
-                                            "' found uniq");
+                                            "` found uniq");
           }
         }
       }
@@ -1793,8 +1793,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
             if !type_is_integral(fcx, oper.span, oper_t) &&
                    structure_of(fcx, oper.span, oper_t) != ty::ty_bool {
                 tcx.sess.span_err(expr.span,
-                                  #fmt["mismatched types: expected 'bool' \
-                          or 'integer' but found '%s'",
+                                  #fmt["mismatched types: expected `bool` \
+                          or `integer` but found `%s`",
                                        ty_to_str(tcx, oper_t)]);
             }
           }
@@ -1804,8 +1804,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
                      ty::type_is_fp(tcx, oper_t)) {
                 tcx.sess.span_err(expr.span,
                                   "applying unary minus to \
-                   non-numeric type '"
-                                      + ty_to_str(tcx, oper_t) + "'");
+                   non-numeric type `"
+                                      + ty_to_str(tcx, oper_t) + "`");
             }
           }
         }
@@ -1921,7 +1921,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
           _ {
             tcx.sess.span_fatal(expr.span,
                                 "mismatched types: expected vector or string "
-                                + "but found '" + ty_to_str(tcx, ety) + "'");
+                                + "but found `" + ty_to_str(tcx, ety) + "`");
           }
         }
         bot |= check_for(fcx, decl, elt_ty, body, id);
@@ -2252,8 +2252,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
         if !type_is_integral(fcx, idx.span, idx_t) {
             tcx.sess.span_err(idx.span,
                               "mismatched types: expected \
-                               'integer' but found '"
-                                  + ty_to_str(tcx, idx_t) + "'");
+                               `integer` but found `"
+                                  + ty_to_str(tcx, idx_t) + "`");
         }
         alt structure_of(fcx, expr.span, base_t) {
           ty::ty_vec(mt) { write::ty_only_fixup(fcx, id, mt.ty); }
@@ -2690,13 +2690,13 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) {
                       some(m) {
                         if !ty::same_method(ccx.tcx, m, if_m) {
                             ccx.tcx.sess.span_err(
-                                ty.span, "method '" + if_m.ident +
-                                "' has the wrong type");
+                                ty.span, "method `" + if_m.ident +
+                                "` has the wrong type");
                         }
                       }
                       none. {
-                        ccx.tcx.sess.span_err(ty.span, "missing method '" +
-                                              if_m.ident + "'");
+                        ccx.tcx.sess.span_err(ty.span, "missing method `" +
+                                              if_m.ident + "`");
                       }
                     }
                 }
@@ -2740,15 +2740,15 @@ fn check_main_fn_ty(tcx: ty::ctxt, main_id: ast::node_id) {
         if !ok {
             let span = ast_map::node_span(tcx.items.get(main_id));
             tcx.sess.span_err(span,
-                              "wrong type in main function: found '" +
-                                  ty_to_str(tcx, main_t) + "'");
+                              "wrong type in main function: found `" +
+                                  ty_to_str(tcx, main_t) + "`");
         }
       }
       _ {
         let span = ast_map::node_span(tcx.items.get(main_id));
         tcx.sess.span_bug(span,
-                          "main has a non-function type: found '" +
-                              ty_to_str(tcx, main_t) + "'");
+                          "main has a non-function type: found `" +
+                              ty_to_str(tcx, main_t) + "`");
       }
     }
 }
diff --git a/src/test/compile-fail/bad-const-type.rs b/src/test/compile-fail/bad-const-type.rs
@@ -1,4 +1,4 @@
-// error-pattern:expected 'str' but found 'int'
+// error-pattern:expected `str` but found `int`
 
 const i: str = 10;
 fn main() { log(debug, i); }
diff --git a/src/test/compile-fail/bad-record-pat-2.rs b/src/test/compile-fail/bad-record-pat-2.rs
@@ -1,3 +1,3 @@
-// error-pattern:did not expect a record with a field 'q'
+// error-pattern:did not expect a record with a field `q`
 
 fn main() { alt {x: 1, y: 2} { {x: x, q: q} { } } }
diff --git a/src/test/compile-fail/fail-type-err.rs b/src/test/compile-fail/fail-type-err.rs
@@ -1,2 +1,2 @@
-// error-pattern:expected 'str' but found '[int]'
+// error-pattern:expected `str` but found `[int]`
 fn main() { fail [0]; }
diff --git a/src/test/compile-fail/fn-bare-bind.rs b/src/test/compile-fail/fn-bare-bind.rs
@@ -1,4 +1,4 @@
-// error-pattern:mismatched types: expected 'fn()' but found 'fn@()'
+// error-pattern:mismatched types: expected `fn()` but found `fn@()`
 
 fn f() {
 }
diff --git a/src/test/compile-fail/fn-compare-mismatch.rs b/src/test/compile-fail/fn-compare-mismatch.rs
@@ -1,4 +1,4 @@
-// error-pattern:expected 'fn()' but found 'fn(++int)'
+// error-pattern:expected `fn()` but found `fn(++int)`
 
 fn main() {
     fn f() { }
diff --git a/src/test/compile-fail/main-wrong-type-2.rs b/src/test/compile-fail/main-wrong-type-2.rs
@@ -1,2 +1,2 @@
-// error-pattern:wrong type in main function: found 'fn() -> char'
+// error-pattern:wrong type in main function: found `fn() -> char`
 fn main() -> char { }
diff --git a/src/test/compile-fail/main-wrong-type.rs b/src/test/compile-fail/main-wrong-type.rs
@@ -1,2 +1,2 @@
-// error-pattern:wrong type in main function: found 'fn(&&{x: int,y: int})'
+// error-pattern:wrong type in main function: found `fn(&&{x: int,y: int})`
 fn main(foo: {x: int, y: int}) { }
diff --git a/src/test/compile-fail/minus-string.rs b/src/test/compile-fail/minus-string.rs
@@ -1,3 +1,3 @@
-// error-pattern:applying unary minus to non-numeric type 'str'
+// error-pattern:applying unary minus to non-numeric type `str`
 
 fn main() { -"foo"; }
diff --git a/src/test/compile-fail/native-type-mismatch.rs b/src/test/compile-fail/native-type-mismatch.rs
@@ -1,4 +1,4 @@
-// error-pattern:expected '*Mb' but found 'native'
+// error-pattern:expected `*Mb` but found `native`
 use std;
 
 fn main() unsafe {
diff --git a/src/test/compile-fail/nonsense-constraints.rs b/src/test/compile-fail/nonsense-constraints.rs
@@ -1,5 +1,5 @@
 // Tests that the typechecker checks constraints
-// error-pattern:mismatched types: expected 'uint' but found 'u8'
+// error-pattern:mismatched types: expected `uint` but found `u8`
 use std;
 import uint;
 
diff --git a/src/test/compile-fail/rec-extend.rs b/src/test/compile-fail/rec-extend.rs
@@ -1,4 +1,4 @@
-// error-pattern:expected 'int' but found 'bool'
+// error-pattern:expected `int` but found `bool`
 
 fn main() {
 
diff --git a/src/test/compile-fail/sendfn-is-not-a-lambda.rs b/src/test/compile-fail/sendfn-is-not-a-lambda.rs
@@ -1,4 +1,4 @@
-// error-pattern: mismatched types: expected 'lambda(++uint) -> uint'
+// error-pattern: mismatched types: expected `lambda(++uint) -> uint`
 
 fn test(f: lambda(uint) -> uint) -> uint {
     ret f(22u);
diff --git a/src/test/compile-fail/type-mismatch-multiple.rs b/src/test/compile-fail/type-mismatch-multiple.rs
@@ -1,5 +1,5 @@
 // Checking that the compiler reports multiple type errors at once
-// error-pattern:mismatched types: expected 'bool'
-// error-pattern:mismatched types: expected 'int'
+// error-pattern:mismatched types: expected `bool`
+// error-pattern:mismatched types: expected `int`
 
 fn main() { let a: bool = 1; let b: int = true; }
diff --git a/src/test/compile-fail/type-mismatch.rs b/src/test/compile-fail/type-mismatch.rs
@@ -1,4 +1,4 @@
-// error-pattern:expected 'bool' but found 'int'
+// error-pattern:expected `bool` but found `int`
 // issue #516
 
 fn main() { let x = true; let y = 1; let z = x + y; }

Original file line number	Diff line number	Diff line change
`@@ -369,7 +369,7 @@ fn ast_ty_to_ty(tcx: ty::ctxt, mode: mode, &&ast_ty: @ast::ty) -> ty::t {`
`369`	`369`	`alt mode {`
`370`	`370`	`m_check_tyvar(fcx) { ret next_ty_var(fcx); }`
`371`	`371`	`_ { tcx.sess.span_bug(ast_ty.span,`
`372`		`- "found 'ty_infer' in unexpected place"); }`
	`372`	+ "found `ty_infer` in unexpected place"); }
`373`	`373`	`}`
`374`	`374`	`}`
`375`	`375`	`}`
`@@ -895,11 +895,11 @@ mod demand {`
`895`	`895`	`let e_err = resolve_type_vars_if_possible(fcx, expected);`
`896`	`896`	`let a_err = resolve_type_vars_if_possible(fcx, actual);`
`897`	`897`	`fcx.ccx.tcx.sess.span_err(sp,`
`898`		`- "mismatched types: expected '" +`
	`898`	+ "mismatched types: expected `" +
`899`	`899`	`ty_to_str(fcx.ccx.tcx, e_err) +`
`900`		`- "' but found '" +`
	`900`	+ "` but found `" +
`901`	`901`	`ty_to_str(fcx.ccx.tcx, a_err) +`
`902`		`- "' (" + ty::type_err_to_str(err) +`
	`902`	+ "` (" + ty::type_err_to_str(err) +
`903`	`903`	`")");`
`904`	`904`	`ret mk_result(fcx, expected, ty_param_subst_var_ids);`
`905`	`905`	`}`
`@@ -1303,7 +1303,7 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,`
`1303`	`1303`	`// can never tell.`
`1304`	`1304`	`fcx.ccx.tcx.sess.span_fatal`
`1305`	`1305`	`(pat.span,`
`1306`		`- #fmt["mismatched types: expected '%s' but found tag",`
	`1306`	+ #fmt["mismatched types: expected `%s` but found tag",
`1307`	`1307`	`ty_to_str(fcx.ccx.tcx, expected)]);`
`1308`	`1308`	`}`
`1309`	`1309`	`}`
`@@ -1316,7 +1316,7 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,`
`1316`	`1316`	`_ {`
`1317`	`1317`	`fcx.ccx.tcx.sess.span_fatal`
`1318`	`1318`	`(pat.span,`
`1319`		`- #fmt["mismatched types: expected '%s' but found record",`
	`1319`	+ #fmt["mismatched types: expected `%s` but found record",
`1320`	`1320`	`ty_to_str(fcx.ccx.tcx, expected)]);`
`1321`	`1321`	`}`
`1322`	`1322`	`}`
`@@ -1338,7 +1338,7 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,`
`1338`	`1338`	`none. {`
`1339`	`1339`	`fcx.ccx.tcx.sess.span_fatal(pat.span,`
`1340`	`1340`	`#fmt["mismatched types: did not \`
`1341`		`- expect a record with a field '%s'",`
	`1341`	+ expect a record with a field `%s`",
`1342`	`1342`	`f.ident]);`
`1343`	`1343`	`}`
`1344`	`1344`	`}`
`@@ -1352,7 +1352,7 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,`
`1352`	`1352`	`_ {`
`1353`	`1353`	`fcx.ccx.tcx.sess.span_fatal`
`1354`	`1354`	`(pat.span,`
`1355`		`- #fmt["mismatched types: expected '%s', found tuple",`
	`1355`	+ #fmt["mismatched types: expected `%s`, found tuple",
`1356`	`1356`	`ty_to_str(fcx.ccx.tcx, expected)]);`
`1357`	`1357`	`}`
`1358`	`1358`	`}`
`@@ -1375,9 +1375,9 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,`
`1375`	`1375`	`}`
`1376`	`1376`	`_ {`
`1377`	`1377`	`fcx.ccx.tcx.sess.span_fatal(pat.span,`
`1378`		`- "mismatched types: expected '" +`
	`1378`	+ "mismatched types: expected `" +
`1379`	`1379`	`ty_to_str(fcx.ccx.tcx, expected) +`
`1380`		`- "' found box");`
	`1380`	+ "` found box");
`1381`	`1381`	`}`
`1382`	`1382`	`}`
`1383`	`1383`	`}`
`@@ -1389,9 +1389,9 @@ fn check_pat(fcx: @fn_ctxt, map: ast_util::pat_id_map, pat: @ast::pat,`
`1389`	`1389`	`}`
`1390`	`1390`	`_ {`
`1391`	`1391`	`fcx.ccx.tcx.sess.span_fatal(pat.span,`
`1392`		`- "mismatched types: expected '" +`
	`1392`	+ "mismatched types: expected `" +
`1393`	`1393`	`ty_to_str(fcx.ccx.tcx, expected) +`
`1394`		`- "' found uniq");`
	`1394`	+ "` found uniq");
`1395`	`1395`	`}`
`1396`	`1396`	`}`
`1397`	`1397`	`}`
`@@ -1793,8 +1793,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,`
`1793`	`1793`	`if !type_is_integral(fcx, oper.span, oper_t) &&`
`1794`	`1794`	`structure_of(fcx, oper.span, oper_t) != ty::ty_bool {`
`1795`	`1795`	`tcx.sess.span_err(expr.span,`
`1796`		`- #fmt["mismatched types: expected 'bool' \`
`1797`		`- or 'integer' but found '%s'",`
	`1796`	+ #fmt["mismatched types: expected `bool` \
	`1797`	+ or `integer` but found `%s`",
`1798`	`1798`	`ty_to_str(tcx, oper_t)]);`
`1799`	`1799`	`}`
`1800`	`1800`	`}`
`@@ -1804,8 +1804,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,`
`1804`	`1804`	`ty::type_is_fp(tcx, oper_t)) {`
`1805`	`1805`	`tcx.sess.span_err(expr.span,`
`1806`	`1806`	`"applying unary minus to \`
`1807`		`- non-numeric type '"`
`1808`		`- + ty_to_str(tcx, oper_t) + "'");`
	`1807`	+ non-numeric type `"
	`1808`	+ + ty_to_str(tcx, oper_t) + "`");
`1809`	`1809`	`}`
`1810`	`1810`	`}`
`1811`	`1811`	`}`
`@@ -1921,7 +1921,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,`
`1921`	`1921`	`_ {`
`1922`	`1922`	`tcx.sess.span_fatal(expr.span,`
`1923`	`1923`	`"mismatched types: expected vector or string "`
`1924`		`- + "but found '" + ty_to_str(tcx, ety) + "'");`
	`1924`	+ + "but found `" + ty_to_str(tcx, ety) + "`");
`1925`	`1925`	`}`
`1926`	`1926`	`}`
`1927`	`1927`	`bot \|= check_for(fcx, decl, elt_ty, body, id);`
`@@ -2252,8 +2252,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,`
`2252`	`2252`	`if !type_is_integral(fcx, idx.span, idx_t) {`
`2253`	`2253`	`tcx.sess.span_err(idx.span,`
`2254`	`2254`	`"mismatched types: expected \`
`2255`		`- 'integer' but found '"`
`2256`		`- + ty_to_str(tcx, idx_t) + "'");`
	`2255`	+ `integer` but found `"
	`2256`	+ + ty_to_str(tcx, idx_t) + "`");
`2257`	`2257`	`}`
`2258`	`2258`	`alt structure_of(fcx, expr.span, base_t) {`
`2259`	`2259`	`ty::ty_vec(mt) { write::ty_only_fixup(fcx, id, mt.ty); }`
`@@ -2690,13 +2690,13 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) {`
`2690`	`2690`	`some(m) {`
`2691`	`2691`	`if !ty::same_method(ccx.tcx, m, if_m) {`
`2692`	`2692`	`ccx.tcx.sess.span_err(`
`2693`		`- ty.span, "method '" + if_m.ident +`
`2694`		`- "' has the wrong type");`
	`2693`	+ ty.span, "method `" + if_m.ident +
	`2694`	+ "` has the wrong type");
`2695`	`2695`	`}`
`2696`	`2696`	`}`
`2697`	`2697`	`none. {`
`2698`		`- ccx.tcx.sess.span_err(ty.span, "missing method '" +`
`2699`		`- if_m.ident + "'");`
	`2698`	+ ccx.tcx.sess.span_err(ty.span, "missing method `" +
	`2699`	+ if_m.ident + "`");
`2700`	`2700`	`}`
`2701`	`2701`	`}`
`2702`	`2702`	`}`
`@@ -2740,15 +2740,15 @@ fn check_main_fn_ty(tcx: ty::ctxt, main_id: ast::node_id) {`
`2740`	`2740`	`if !ok {`
`2741`	`2741`	`let span = ast_map::node_span(tcx.items.get(main_id));`
`2742`	`2742`	`tcx.sess.span_err(span,`
`2743`		`- "wrong type in main function: found '" +`
`2744`		`- ty_to_str(tcx, main_t) + "'");`
	`2743`	+ "wrong type in main function: found `" +
	`2744`	+ ty_to_str(tcx, main_t) + "`");
`2745`	`2745`	`}`
`2746`	`2746`	`}`
`2747`	`2747`	`_ {`
`2748`	`2748`	`let span = ast_map::node_span(tcx.items.get(main_id));`
`2749`	`2749`	`tcx.sess.span_bug(span,`
`2750`		`- "main has a non-function type: found '" +`
`2751`		`- ty_to_str(tcx, main_t) + "'");`
	`2750`	+ "main has a non-function type: found `" +
	`2751`	+ ty_to_str(tcx, main_t) + "`");
`2752`	`2752`	`}`
`2753`	`2753`	`}`
`2754`	`2754`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`		`-// error-pattern:did not expect a record with a field 'q'`
	`1`	+// error-pattern:did not expect a record with a field `q`
`2`	`2`
`3`	`3`	`fn main() { alt {x: 1, y: 2} { {x: x, q: q} { } } }`
Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`		`-// error-pattern:expected 'str' but found '[int]'`
	`1`	+// error-pattern:expected `str` but found `[int]`
`2`	`2`	`fn main() { fail [0]; }`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// error-pattern:mismatched types: expected 'fn()' but found 'fn@()'`
	`1`	+// error-pattern:mismatched types: expected `fn()` but found `fn@()`
`2`	`2`
`3`	`3`	`fn f() {`
`4`	`4`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// error-pattern:expected 'fn()' but found 'fn(++int)'`
	`1`	+// error-pattern:expected `fn()` but found `fn(++int)`
`2`	`2`
`3`	`3`	`fn main() {`
`4`	`4`	`fn f() { }`
Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`		`-// error-pattern:wrong type in main function: found 'fn() -> char'`
	`1`	+// error-pattern:wrong type in main function: found `fn() -> char`
`2`	`2`	`fn main() -> char { }`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`		`-// error-pattern:applying unary minus to non-numeric type 'str'`
	`1`	+// error-pattern:applying unary minus to non-numeric type `str`
`2`	`2`
`3`	`3`	`fn main() { -"foo"; }`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// error-pattern:expected '*Mb' but found 'native'`
	`1`	+// error-pattern:expected `*Mb` but found `native`
`2`	`2`	`use std;`
`3`	`3`
`4`	`4`	`fn main() unsafe {`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// error-pattern:expected 'int' but found 'bool'`
	`1`	+// error-pattern:expected `int` but found `bool`
`2`	`2`
`3`	`3`	`fn main() {`
`4`	`4`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// error-pattern: mismatched types: expected 'lambda(++uint) -> uint'`
	`1`	+// error-pattern: mismatched types: expected `lambda(++uint) -> uint`
`2`	`2`
`3`	`3`	`fn test(f: lambda(uint) -> uint) -> uint {`
`4`	`4`	`ret f(22u);`