Added the test results.

gbip · gbip · commit 2a6473a6eb02 · 2017-10-19T15:08:21.000-04:00
The regex test was modified, because rustfmt was run on regex.rs.
diff --git a/tests/ui/const_static_lifetime.stderr b/tests/ui/const_static_lifetime.stderr
@@ -0,0 +1,65 @@
+error: Constants have by default a `'static` lifetime
+ --> $DIR/const_static_lifetime.rs:6:17
+  |
+6 | const VAR_ONE: &'static str = "Test constant #1"; // ERROR Consider removing 'static.
+  |                 ^^^^^^^
+  |
+  = note: `-D const-static-lifetime` implied by `-D warnings`
+  = help: consider removing `'static`
+
+error: Constants have by default a `'static` lifetime
+  --> $DIR/const_static_lifetime.rs:10:21
+   |
+10 | const VAR_THREE: &[&'static str] = &["one", "two"]; // ERROR Consider removing 'static
+   |                     ^^^^^^^
+   |
+   = help: consider removing `'static`
+
+error: Constants have by default a `'static` lifetime
+  --> $DIR/const_static_lifetime.rs:12:32
+   |
+12 | const VAR_FOUR: (&str, (&str, &'static str), &'static str) = ("on", ("th", "th"), "on"); // ERROR Consider removing 'static
+   |                                ^^^^^^^
+   |
+   = help: consider removing `'static`
+
+error: Constants have by default a `'static` lifetime
+  --> $DIR/const_static_lifetime.rs:12:47
+   |
+12 | const VAR_FOUR: (&str, (&str, &'static str), &'static str) = ("on", ("th", "th"), "on"); // ERROR Consider removing 'static
+   |                                               ^^^^^^^
+   |
+   = help: consider removing `'static`
+
+error: Constants have by default a `'static` lifetime
+  --> $DIR/const_static_lifetime.rs:14:30
+   |
+14 | const VAR_FIVE: &'static [&[&'static str]] = &[&["test"], &["other one"]]; // ERROR Consider removing 'static
+   |                              ^^^^^^^
+   |
+   = help: consider removing `'static`
+
+error: Constants have by default a `'static` lifetime
+  --> $DIR/const_static_lifetime.rs:16:17
+   |
+16 | const VAR_SIX: &'static u8 = &5;
+   |                 ^^^^^^^
+   |
+   = help: consider removing `'static`
+
+error: Constants have by default a `'static` lifetime
+  --> $DIR/const_static_lifetime.rs:18:39
+   |
+18 | const VAR_SEVEN: &[&(&str, &'static [&'static str])] = &[&("one", &["other one"])];
+   |                                       ^^^^^^^
+   |
+   = help: consider removing `'static`
+
+error: Constants have by default a `'static` lifetime
+  --> $DIR/const_static_lifetime.rs:20:20
+   |
+20 | const VAR_HEIGHT: &'static Foo = &Foo {};
+   |                    ^^^^^^^
+   |
+   = help: consider removing `'static`
+
diff --git a/tests/ui/regex.stderr b/tests/ui/regex.stderr
@@ -49,102 +49,102 @@ error: regex syntax error on position 0: unclosed parenthesis
    |                                                        ^^^^^^^^^^^^^
 
 error: regex syntax error on position 0: unclosed parenthesis
-  --> $DIR/regex.rs:40:9
+  --> $DIR/regex.rs:33:37
    |
-40 |         OPENING_PAREN,
-   |         ^^^^^^^^^^^^^
+33 |     let set_error = RegexSet::new(&[OPENING_PAREN, r"[a-z]+/.(com|org|net)"]);
+   |                                     ^^^^^^^^^^^^^
 
 error: regex syntax error on position 0: unclosed parenthesis
-  --> $DIR/regex.rs:44:9
+  --> $DIR/regex.rs:34:39
    |
-44 |         OPENING_PAREN,
-   |         ^^^^^^^^^^^^^
+34 |     let bset_error = BRegexSet::new(&[OPENING_PAREN, r"[a-z]+/.(com|org|net)"]);
+   |                                       ^^^^^^^^^^^^^
 
 error: trivial regex
-  --> $DIR/regex.rs:50:33
+  --> $DIR/regex.rs:38:33
    |
-50 |     let trivial_eq = Regex::new("^foobar$");
+38 |     let trivial_eq = Regex::new("^foobar$");
    |                                 ^^^^^^^^^^
    |
    = note: `-D trivial-regex` implied by `-D warnings`
    = help: consider using consider using `==` on `str`s
 
 error: trivial regex
-  --> $DIR/regex.rs:52:48
+  --> $DIR/regex.rs:40:48
    |
-52 |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
+40 |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    |                                                ^^^^^^^^^^
    |
    = help: consider using consider using `==` on `str`s
 
 error: trivial regex
-  --> $DIR/regex.rs:54:42
+  --> $DIR/regex.rs:42:42
    |
-54 |     let trivial_starts_with = Regex::new("^foobar");
+42 |     let trivial_starts_with = Regex::new("^foobar");
    |                                          ^^^^^^^^^
    |
    = help: consider using consider using `str::starts_with`
 
 error: trivial regex
-  --> $DIR/regex.rs:56:40
+  --> $DIR/regex.rs:44:40
    |
-56 |     let trivial_ends_with = Regex::new("foobar$");
+44 |     let trivial_ends_with = Regex::new("foobar$");
    |                                        ^^^^^^^^^
    |
    = help: consider using consider using `str::ends_with`
 
 error: trivial regex
-  --> $DIR/regex.rs:58:39
+  --> $DIR/regex.rs:46:39
    |
-58 |     let trivial_contains = Regex::new("foobar");
+46 |     let trivial_contains = Regex::new("foobar");
    |                                       ^^^^^^^^
    |
    = help: consider using consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:60:39
+  --> $DIR/regex.rs:48:39
    |
-60 |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
+48 |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    |                                       ^^^^^^^^^^^^^^^^
    |
    = help: consider using consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:62:40
+  --> $DIR/regex.rs:50:40
    |
-62 |     let trivial_backslash = Regex::new("a//.b");
+50 |     let trivial_backslash = Regex::new("a//.b");
    |                                        ^^^^^^^
    |
    = help: consider using consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:65:36
+  --> $DIR/regex.rs:53:36
    |
-65 |     let trivial_empty = Regex::new("");
+53 |     let trivial_empty = Regex::new("");
    |                                    ^^
    |
    = help: consider using the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> $DIR/regex.rs:67:36
+  --> $DIR/regex.rs:55:36
    |
-67 |     let trivial_empty = Regex::new("^");
+55 |     let trivial_empty = Regex::new("^");
    |                                    ^^^
    |
    = help: consider using the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> $DIR/regex.rs:69:36
+  --> $DIR/regex.rs:57:36
    |
-69 |     let trivial_empty = Regex::new("^$");
+57 |     let trivial_empty = Regex::new("^$");
    |                                    ^^^^
    |
    = help: consider using consider using `str::is_empty`
 
 error: trivial regex
-  --> $DIR/regex.rs:71:44
+  --> $DIR/regex.rs:59:44
    |
-71 |     let binary_trivial_empty = BRegex::new("^$");
+59 |     let binary_trivial_empty = BRegex::new("^$");
    |                                            ^^^^
    |
    = help: consider using consider using `str::is_empty`

Original file line number	Diff line number	Diff line change
`@@ -49,102 +49,102 @@ error: regex syntax error on position 0: unclosed parenthesis`
`49`	`49`	`\| ^^^^^^^^^^^^^`
`50`	`50`
`51`	`51`	`error: regex syntax error on position 0: unclosed parenthesis`
`52`		`- --> $DIR/regex.rs:40:9`
	`52`	`+ --> $DIR/regex.rs:33:37`
`53`	`53`	`\|`
`54`		`-40 \| OPENING_PAREN,`
`55`		`- \| ^^^^^^^^^^^^^`
	`54`	`+33 \| let set_error = RegexSet::new(&[OPENING_PAREN, r"[a-z]+/.(com\|org\|net)"]);`
	`55`	`+ \| ^^^^^^^^^^^^^`
`56`	`56`
`57`	`57`	`error: regex syntax error on position 0: unclosed parenthesis`
`58`		`- --> $DIR/regex.rs:44:9`
	`58`	`+ --> $DIR/regex.rs:34:39`
`59`	`59`	`\|`
`60`		`-44 \| OPENING_PAREN,`
`61`		`- \| ^^^^^^^^^^^^^`
	`60`	`+34 \| let bset_error = BRegexSet::new(&[OPENING_PAREN, r"[a-z]+/.(com\|org\|net)"]);`
	`61`	`+ \| ^^^^^^^^^^^^^`
`62`	`62`
`63`	`63`	`error: trivial regex`
`64`		`- --> $DIR/regex.rs:50:33`
	`64`	`+ --> $DIR/regex.rs:38:33`
`65`	`65`	`\|`
`66`		`-50 \| let trivial_eq = Regex::new("^foobar$");`
	`66`	`+38 \| let trivial_eq = Regex::new("^foobar$");`
`67`	`67`	`\| ^^^^^^^^^^`
`68`	`68`	`\|`
`69`	`69`	= note: `-D trivial-regex` implied by `-D warnings`
`70`	`70`	= help: consider using consider using `==` on `str`s
`71`	`71`
`72`	`72`	`error: trivial regex`
`73`		`- --> $DIR/regex.rs:52:48`
	`73`	`+ --> $DIR/regex.rs:40:48`
`74`	`74`	`\|`
`75`		`-52 \| let trivial_eq_builder = RegexBuilder::new("^foobar$");`
	`75`	`+40 \| let trivial_eq_builder = RegexBuilder::new("^foobar$");`
`76`	`76`	`\| ^^^^^^^^^^`
`77`	`77`	`\|`
`78`	`78`	= help: consider using consider using `==` on `str`s
`79`	`79`
`80`	`80`	`error: trivial regex`
`81`		`- --> $DIR/regex.rs:54:42`
	`81`	`+ --> $DIR/regex.rs:42:42`
`82`	`82`	`\|`
`83`		`-54 \| let trivial_starts_with = Regex::new("^foobar");`
	`83`	`+42 \| let trivial_starts_with = Regex::new("^foobar");`
`84`	`84`	`\| ^^^^^^^^^`
`85`	`85`	`\|`
`86`	`86`	= help: consider using consider using `str::starts_with`
`87`	`87`
`88`	`88`	`error: trivial regex`
`89`		`- --> $DIR/regex.rs:56:40`
	`89`	`+ --> $DIR/regex.rs:44:40`
`90`	`90`	`\|`
`91`		`-56 \| let trivial_ends_with = Regex::new("foobar$");`
	`91`	`+44 \| let trivial_ends_with = Regex::new("foobar$");`
`92`	`92`	`\| ^^^^^^^^^`
`93`	`93`	`\|`
`94`	`94`	= help: consider using consider using `str::ends_with`
`95`	`95`
`96`	`96`	`error: trivial regex`
`97`		`- --> $DIR/regex.rs:58:39`
	`97`	`+ --> $DIR/regex.rs:46:39`
`98`	`98`	`\|`
`99`		`-58 \| let trivial_contains = Regex::new("foobar");`
	`99`	`+46 \| let trivial_contains = Regex::new("foobar");`
`100`	`100`	`\| ^^^^^^^^`
`101`	`101`	`\|`
`102`	`102`	= help: consider using consider using `str::contains`
`103`	`103`
`104`	`104`	`error: trivial regex`
`105`		`- --> $DIR/regex.rs:60:39`
	`105`	`+ --> $DIR/regex.rs:48:39`
`106`	`106`	`\|`
`107`		`-60 \| let trivial_contains = Regex::new(NOT_A_REAL_REGEX);`
	`107`	`+48 \| let trivial_contains = Regex::new(NOT_A_REAL_REGEX);`
`108`	`108`	`\| ^^^^^^^^^^^^^^^^`
`109`	`109`	`\|`
`110`	`110`	= help: consider using consider using `str::contains`
`111`	`111`
`112`	`112`	`error: trivial regex`
`113`		`- --> $DIR/regex.rs:62:40`
	`113`	`+ --> $DIR/regex.rs:50:40`
`114`	`114`	`\|`
`115`		`-62 \| let trivial_backslash = Regex::new("a//.b");`
	`115`	`+50 \| let trivial_backslash = Regex::new("a//.b");`
`116`	`116`	`\| ^^^^^^^`
`117`	`117`	`\|`
`118`	`118`	= help: consider using consider using `str::contains`
`119`	`119`
`120`	`120`	`error: trivial regex`
`121`		`- --> $DIR/regex.rs:65:36`
	`121`	`+ --> $DIR/regex.rs:53:36`
`122`	`122`	`\|`
`123`		`-65 \| let trivial_empty = Regex::new("");`
	`123`	`+53 \| let trivial_empty = Regex::new("");`
`124`	`124`	`\| ^^`
`125`	`125`	`\|`
`126`	`126`	`= help: consider using the regex is unlikely to be useful as it is`
`127`	`127`
`128`	`128`	`error: trivial regex`
`129`		`- --> $DIR/regex.rs:67:36`
	`129`	`+ --> $DIR/regex.rs:55:36`
`130`	`130`	`\|`
`131`		`-67 \| let trivial_empty = Regex::new("^");`
	`131`	`+55 \| let trivial_empty = Regex::new("^");`
`132`	`132`	`\| ^^^`
`133`	`133`	`\|`
`134`	`134`	`= help: consider using the regex is unlikely to be useful as it is`
`135`	`135`
`136`	`136`	`error: trivial regex`
`137`		`- --> $DIR/regex.rs:69:36`
	`137`	`+ --> $DIR/regex.rs:57:36`
`138`	`138`	`\|`
`139`		`-69 \| let trivial_empty = Regex::new("^$");`
	`139`	`+57 \| let trivial_empty = Regex::new("^$");`
`140`	`140`	`\| ^^^^`
`141`	`141`	`\|`
`142`	`142`	= help: consider using consider using `str::is_empty`
`143`	`143`
`144`	`144`	`error: trivial regex`
`145`		`- --> $DIR/regex.rs:71:44`
	`145`	`+ --> $DIR/regex.rs:59:44`
`146`	`146`	`\|`
`147`		`-71 \| let binary_trivial_empty = BRegex::new("^$");`
	`147`	`+59 \| let binary_trivial_empty = BRegex::new("^$");`
`148`	`148`	`\| ^^^^`
`149`	`149`	`\|`
`150`	`150`	= help: consider using consider using `str::is_empty`