librustc_lint: In recursion warning, change 'recurring' to 'recursing'

brson · brson · commit f4d636251843 · 2018-08-20T23:09:15.000-07:00
diff --git a/src/doc/rustc/src/lints/listing/warn-by-default.md b/src/doc/rustc/src/lints/listing/warn-by-default.md
@@ -603,11 +603,11 @@ fn foo() {
 This will produce:
 
 ```text
-warning: function cannot return without recurring
+warning: function cannot return without recursing
  --> src/main.rs:1:1
   |
 1 | fn foo() {
-  | ^^^^^^^^ cannot return without recurring
+  | ^^^^^^^^ cannot return without recursing
 2 |     foo();
   |     ----- recursive call site
   |
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -901,7 +901,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnconditionalRecursion {
         // considers this to be an error for two reasons, (a) it is
         // easier to implement, and (b) it seems rare to actually want
         // to have behaviour like the above, rather than
-        // e.g. accidentally recurring after an assert.
+        // e.g. accidentally recursing after an assert.
 
         let cfg = cfg::CFG::new(cx.tcx, &body);
 
@@ -961,8 +961,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnconditionalRecursion {
             let sp = cx.tcx.sess.codemap().def_span(sp);
             let mut db = cx.struct_span_lint(UNCONDITIONAL_RECURSION,
                                              sp,
-                                             "function cannot return without recurring");
-            db.span_label(sp, "cannot return without recurring");
+                                             "function cannot return without recursing");
+            db.span_label(sp, "cannot return without recursing");
             // offer some help to the programmer.
             for call in &self_call_spans {
                 db.span_label(*call, "recursive call site");
@@ -1090,7 +1090,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnconditionalRecursion {
                             // a default method definition.
                             Ok(Some(traits::VtableParam(_))) => {
                                 let on_self = trait_ref.self_ty().is_self();
-                                // We can only be recurring in a default
+                                // We can only be recursing in a default
                                 // method if we're being called literally
                                 // on the `Self` type.
                                 on_self && callee_id == method.def_id
diff --git a/src/test/ui/issues/issue-8727.rs b/src/test/ui/issues/issue-8727.rs
@@ -15,7 +15,7 @@ fn generic<T>() {
     generic::<Option<T>>();
 }
 //~^^^ ERROR reached the recursion limit while instantiating `generic::<std::option::Option<
-//~| WARN function cannot return without recurring
+//~| WARN function cannot return without recursing
 
 
 
diff --git a/src/test/ui/issues/issue-8727.stderr b/src/test/ui/issues/issue-8727.stderr
@@ -1,8 +1,8 @@
-warning: function cannot return without recurring
+warning: function cannot return without recursing
   --> $DIR/issue-8727.rs:14:1
    |
 LL | fn generic<T>() {
-   | ^^^^^^^^^^^^^^^ cannot return without recurring
+   | ^^^^^^^^^^^^^^^ cannot return without recursing
 LL |     generic::<Option<T>>();
    |     ---------------------- recursive call site
    |
diff --git a/src/test/ui/lint/lint-unconditional-recursion.rs b/src/test/ui/lint/lint-unconditional-recursion.rs
@@ -11,7 +11,7 @@
 #![deny(unconditional_recursion)]
 
 #![allow(dead_code)]
-fn foo() { //~ ERROR function cannot return without recurring
+fn foo() { //~ ERROR function cannot return without recursing
     foo();
 }
 
@@ -21,7 +21,7 @@ fn bar() {
     }
 }
 
-fn baz() { //~ ERROR function cannot return without recurring
+fn baz() { //~ ERROR function cannot return without recursing
     if true {
         baz()
     } else {
@@ -33,7 +33,7 @@ fn qux() {
     loop {}
 }
 
-fn quz() -> bool { //~ ERROR function cannot return without recurring
+fn quz() -> bool { //~ ERROR function cannot return without recursing
     if true {
         while quz() {}
         true
@@ -44,13 +44,13 @@ fn quz() -> bool { //~ ERROR function cannot return without recurring
 
 // Trait method calls.
 trait Foo {
-    fn bar(&self) { //~ ERROR function cannot return without recurring
+    fn bar(&self) { //~ ERROR function cannot return without recursing
         self.bar()
     }
 }
 
 impl Foo for Box<Foo+'static> {
-    fn bar(&self) { //~ ERROR function cannot return without recurring
+    fn bar(&self) { //~ ERROR function cannot return without recursing
         loop {
             self.bar()
         }
@@ -59,7 +59,7 @@ impl Foo for Box<Foo+'static> {
 
 // Trait method call with integer fallback after method resolution.
 impl Foo for i32 {
-    fn bar(&self) { //~ ERROR function cannot return without recurring
+    fn bar(&self) { //~ ERROR function cannot return without recursing
         0.bar()
     }
 }
@@ -72,13 +72,13 @@ impl Foo for u32 {
 
 // Trait method calls via paths.
 trait Foo2 {
-    fn bar(&self) { //~ ERROR function cannot return without recurring
+    fn bar(&self) { //~ ERROR function cannot return without recursing
         Foo2::bar(self)
     }
 }
 
 impl Foo2 for Box<Foo2+'static> {
-    fn bar(&self) { //~ ERROR function cannot return without recurring
+    fn bar(&self) { //~ ERROR function cannot return without recursing
         loop {
             Foo2::bar(self)
         }
@@ -88,19 +88,19 @@ impl Foo2 for Box<Foo2+'static> {
 struct Baz;
 impl Baz {
     // Inherent method call.
-    fn qux(&self) { //~ ERROR function cannot return without recurring
+    fn qux(&self) { //~ ERROR function cannot return without recursing
         self.qux();
     }
 
     // Inherent method call via path.
-    fn as_ref(&self) -> &Self { //~ ERROR function cannot return without recurring
+    fn as_ref(&self) -> &Self { //~ ERROR function cannot return without recursing
         Baz::as_ref(self)
     }
 }
 
 // Trait method calls to impls via paths.
 impl Default for Baz {
-    fn default() -> Baz { //~ ERROR function cannot return without recurring
+    fn default() -> Baz { //~ ERROR function cannot return without recursing
         let x = Default::default();
         x
     }
@@ -109,14 +109,14 @@ impl Default for Baz {
 // Overloaded operators.
 impl std::ops::Deref for Baz {
     type Target = ();
-    fn deref(&self) -> &() { //~ ERROR function cannot return without recurring
+    fn deref(&self) -> &() { //~ ERROR function cannot return without recursing
         &**self
     }
 }
 
 impl std::ops::Index<usize> for Baz {
     type Output = Baz;
-    fn index(&self, x: usize) -> &Baz { //~ ERROR function cannot return without recurring
+    fn index(&self, x: usize) -> &Baz { //~ ERROR function cannot return without recursing
         &self[x]
     }
 }
@@ -125,7 +125,7 @@ impl std::ops::Index<usize> for Baz {
 struct Quux;
 impl std::ops::Deref for Quux {
     type Target = Baz;
-    fn deref(&self) -> &Baz { //~ ERROR function cannot return without recurring
+    fn deref(&self) -> &Baz { //~ ERROR function cannot return without recursing
         self.as_ref()
     }
 }
diff --git a/src/test/ui/lint/lint-unconditional-recursion.stderr b/src/test/ui/lint/lint-unconditional-recursion.stderr
@@ -1,8 +1,8 @@
-error: function cannot return without recurring
+error: function cannot return without recursing
   --> $DIR/lint-unconditional-recursion.rs:14:1
    |
-LL | fn foo() { //~ ERROR function cannot return without recurring
-   | ^^^^^^^^ cannot return without recurring
+LL | fn foo() { //~ ERROR function cannot return without recursing
+   | ^^^^^^^^ cannot return without recursing
 LL |     foo();
    |     ----- recursive call site
    |
@@ -13,11 +13,11 @@ LL | #![deny(unconditional_recursion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^
    = help: a `loop` may express intention better if this is on purpose
 
-error: function cannot return without recurring
+error: function cannot return without recursing
   --> $DIR/lint-unconditional-recursion.rs:24:1
    |
-LL | fn baz() { //~ ERROR function cannot return without recurring
-   | ^^^^^^^^ cannot return without recurring
+LL | fn baz() { //~ ERROR function cannot return without recursing
+   | ^^^^^^^^ cannot return without recursing
 LL |     if true {
 LL |         baz()
    |         ----- recursive call site
@@ -27,11 +27,11 @@ LL |         baz()
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: function cannot return without recurring
+error: function cannot return without recursing
   --> $DIR/lint-unconditional-recursion.rs:36:1
    |
-LL | fn quz() -> bool { //~ ERROR function cannot return without recurring
-   | ^^^^^^^^^^^^^^^^ cannot return without recurring
+LL | fn quz() -> bool { //~ ERROR function cannot return without recursing
+   | ^^^^^^^^^^^^^^^^ cannot return without recursing
 LL |     if true {
 LL |         while quz() {}
    |               ----- recursive call site
@@ -41,113 +41,113 @@ LL |         loop { quz(); }
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: function cannot return without recurring
+error: function cannot return without recursing
   --> $DIR/lint-unconditional-recursion.rs:47:5
    |
-LL |     fn bar(&self) { //~ ERROR function cannot return without recurring
-   |     ^^^^^^^^^^^^^ cannot return without recurring
+LL |     fn bar(&self) { //~ ERROR function cannot return without recursing
+   |     ^^^^^^^^^^^^^ cannot return without recursing
 LL |         self.bar()
    |         ---------- recursive call site
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: function cannot return without recurring
+error: function cannot return without recursing
   --> $DIR/lint-unconditional-recursion.rs:53:5
    |
-LL |     fn bar(&self) { //~ ERROR function cannot return without recurring
-   |     ^^^^^^^^^^^^^ cannot return without recurring
+LL |     fn bar(&self) { //~ ERROR function cannot return without recursing
+   |     ^^^^^^^^^^^^^ cannot return without recursing
 LL |         loop {
 LL |             self.bar()
    |             ---------- recursive call site
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: function cannot return without recurring
+error: function cannot return without recursing
   --> $DIR/lint-unconditional-recursion.rs:62:5
    |
-LL |     fn bar(&self) { //~ ERROR function cannot return without recurring
-   |     ^^^^^^^^^^^^^ cannot return without recurring
+LL |     fn bar(&self) { //~ ERROR function cannot return without recursing
+   |     ^^^^^^^^^^^^^ cannot return without recursing
 LL |         0.bar()
    |         ------- recursive call site
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: function cannot return without recurring
+error: function cannot return without recursing
   --> $DIR/lint-unconditional-recursion.rs:75:5
    |
-LL |     fn bar(&self) { //~ ERROR function cannot return without recurring
-   |     ^^^^^^^^^^^^^ cannot return without recurring
+LL |     fn bar(&self) { //~ ERROR function cannot return without recursing
+   |     ^^^^^^^^^^^^^ cannot return without recursing
 LL |         Foo2::bar(self)
    |         --------------- recursive call site
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: function cannot return without recurring
+error: function cannot return without recursing
   --> $DIR/lint-unconditional-recursion.rs:81:5
    |
-LL |     fn bar(&self) { //~ ERROR function cannot return without recurring
-   |     ^^^^^^^^^^^^^ cannot return without recurring
+LL |     fn bar(&self) { //~ ERROR function cannot return without recursing
+   |     ^^^^^^^^^^^^^ cannot return without recursing
 LL |         loop {
 LL |             Foo2::bar(self)
    |             --------------- recursive call site
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: function cannot return without recurring
+error: function cannot return without recursing
   --> $DIR/lint-unconditional-recursion.rs:91:5
    |
-LL |     fn qux(&self) { //~ ERROR function cannot return without recurring
-   |     ^^^^^^^^^^^^^ cannot return without recurring
+LL |     fn qux(&self) { //~ ERROR function cannot return without recursing
+   |     ^^^^^^^^^^^^^ cannot return without recursing
 LL |         self.qux();
    |         ---------- recursive call site
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: function cannot return without recurring
+error: function cannot return without recursing
   --> $DIR/lint-unconditional-recursion.rs:96:5
    |
-LL |     fn as_ref(&self) -> &Self { //~ ERROR function cannot return without recurring
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recurring
+LL |     fn as_ref(&self) -> &Self { //~ ERROR function cannot return without recursing
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
 LL |         Baz::as_ref(self)
    |         ----------------- recursive call site
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: function cannot return without recurring
+error: function cannot return without recursing
   --> $DIR/lint-unconditional-recursion.rs:103:5
    |
-LL |     fn default() -> Baz { //~ ERROR function cannot return without recurring
-   |     ^^^^^^^^^^^^^^^^^^^ cannot return without recurring
+LL |     fn default() -> Baz { //~ ERROR function cannot return without recursing
+   |     ^^^^^^^^^^^^^^^^^^^ cannot return without recursing
 LL |         let x = Default::default();
    |                 ------------------ recursive call site
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: function cannot return without recurring
+error: function cannot return without recursing
   --> $DIR/lint-unconditional-recursion.rs:112:5
    |
-LL |     fn deref(&self) -> &() { //~ ERROR function cannot return without recurring
-   |     ^^^^^^^^^^^^^^^^^^^^^^ cannot return without recurring
+LL |     fn deref(&self) -> &() { //~ ERROR function cannot return without recursing
+   |     ^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
 LL |         &**self
    |          ------ recursive call site
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: function cannot return without recurring
+error: function cannot return without recursing
   --> $DIR/lint-unconditional-recursion.rs:119:5
    |
-LL |     fn index(&self, x: usize) -> &Baz { //~ ERROR function cannot return without recurring
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recurring
+LL |     fn index(&self, x: usize) -> &Baz { //~ ERROR function cannot return without recursing
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
 LL |         &self[x]
    |          ------- recursive call site
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: function cannot return without recurring
+error: function cannot return without recursing
   --> $DIR/lint-unconditional-recursion.rs:128:5
    |
-LL |     fn deref(&self) -> &Baz { //~ ERROR function cannot return without recurring
-   |     ^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recurring
+LL |     fn deref(&self) -> &Baz { //~ ERROR function cannot return without recursing
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
 LL |         self.as_ref()
    |         ---- recursive call site
    |

Original file line number	Diff line number	Diff line change
`@@ -603,11 +603,11 @@ fn foo() {`
`603`	`603`	`This will produce:`
`604`	`604`
`605`	`605`	```text
`606`		`-warning: function cannot return without recurring`
	`606`	`+warning: function cannot return without recursing`
`607`	`607`	`--> src/main.rs:1:1`
`608`	`608`	`\|`
`609`	`609`	`1 \| fn foo() {`
`610`		`- \| ^^^^^^^^ cannot return without recurring`
	`610`	`+ \| ^^^^^^^^ cannot return without recursing`
`611`	`611`	`2 \| foo();`
`612`	`612`	`\| ----- recursive call site`
`613`	`613`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ fn generic<T>() {`
`15`	`15`	`generic::<Option<T>>();`
`16`	`16`	`}`
`17`	`17`	//~^^^ ERROR reached the recursion limit while instantiating `generic::<std::option::Option<
`18`		`-//~\| WARN function cannot return without recurring`
	`18`	`+//~\| WARN function cannot return without recursing`
`19`	`19`
`20`	`20`
`21`	`21`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,8 @@`
`1`		`-warning: function cannot return without recurring`
	`1`	`+warning: function cannot return without recursing`
`2`	`2`	`--> $DIR/issue-8727.rs:14:1`
`3`	`3`	`\|`
`4`	`4`	`LL \| fn generic<T>() {`
`5`		`- \| ^^^^^^^^^^^^^^^ cannot return without recurring`
	`5`	`+ \| ^^^^^^^^^^^^^^^ cannot return without recursing`
`6`	`6`	`LL \| generic::<Option<T>>();`
`7`	`7`	`\| ---------------------- recursive call site`
`8`	`8`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@`
`11`	`11`	`#![deny(unconditional_recursion)]`
`12`	`12`
`13`	`13`	`#![allow(dead_code)]`
`14`		`-fn foo() { //~ ERROR function cannot return without recurring`
	`14`	`+fn foo() { //~ ERROR function cannot return without recursing`
`15`	`15`	`foo();`
`16`	`16`	`}`
`17`	`17`
`@@ -21,7 +21,7 @@ fn bar() {`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`
`24`		`-fn baz() { //~ ERROR function cannot return without recurring`
	`24`	`+fn baz() { //~ ERROR function cannot return without recursing`
`25`	`25`	`if true {`
`26`	`26`	`baz()`
`27`	`27`	`} else {`
`@@ -33,7 +33,7 @@ fn qux() {`
`33`	`33`	`loop {}`
`34`	`34`	`}`
`35`	`35`
`36`		`-fn quz() -> bool { //~ ERROR function cannot return without recurring`
	`36`	`+fn quz() -> bool { //~ ERROR function cannot return without recursing`
`37`	`37`	`if true {`
`38`	`38`	`while quz() {}`
`39`	`39`	`true`
`@@ -44,13 +44,13 @@ fn quz() -> bool { //~ ERROR function cannot return without recurring`
`44`	`44`
`45`	`45`	`// Trait method calls.`
`46`	`46`	`trait Foo {`
`47`		`- fn bar(&self) { //~ ERROR function cannot return without recurring`
	`47`	`+ fn bar(&self) { //~ ERROR function cannot return without recursing`
`48`	`48`	`self.bar()`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`impl Foo for Box<Foo+'static> {`
`53`		`- fn bar(&self) { //~ ERROR function cannot return without recurring`
	`53`	`+ fn bar(&self) { //~ ERROR function cannot return without recursing`
`54`	`54`	`loop {`
`55`	`55`	`self.bar()`
`56`	`56`	`}`
`@@ -59,7 +59,7 @@ impl Foo for Box<Foo+'static> {`
`59`	`59`
`60`	`60`	`// Trait method call with integer fallback after method resolution.`
`61`	`61`	`impl Foo for i32 {`
`62`		`- fn bar(&self) { //~ ERROR function cannot return without recurring`
	`62`	`+ fn bar(&self) { //~ ERROR function cannot return without recursing`
`63`	`63`	`0.bar()`
`64`	`64`	`}`
`65`	`65`	`}`
`@@ -72,13 +72,13 @@ impl Foo for u32 {`
`72`	`72`
`73`	`73`	`// Trait method calls via paths.`
`74`	`74`	`trait Foo2 {`
`75`		`- fn bar(&self) { //~ ERROR function cannot return without recurring`
	`75`	`+ fn bar(&self) { //~ ERROR function cannot return without recursing`
`76`	`76`	`Foo2::bar(self)`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`impl Foo2 for Box<Foo2+'static> {`
`81`		`- fn bar(&self) { //~ ERROR function cannot return without recurring`
	`81`	`+ fn bar(&self) { //~ ERROR function cannot return without recursing`
`82`	`82`	`loop {`
`83`	`83`	`Foo2::bar(self)`
`84`	`84`	`}`
`@@ -88,19 +88,19 @@ impl Foo2 for Box<Foo2+'static> {`
`88`	`88`	`struct Baz;`
`89`	`89`	`impl Baz {`
`90`	`90`	`// Inherent method call.`
`91`		`- fn qux(&self) { //~ ERROR function cannot return without recurring`
	`91`	`+ fn qux(&self) { //~ ERROR function cannot return without recursing`
`92`	`92`	`self.qux();`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`// Inherent method call via path.`
`96`		`- fn as_ref(&self) -> &Self { //~ ERROR function cannot return without recurring`
	`96`	`+ fn as_ref(&self) -> &Self { //~ ERROR function cannot return without recursing`
`97`	`97`	`Baz::as_ref(self)`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`// Trait method calls to impls via paths.`
`102`	`102`	`impl Default for Baz {`
`103`		`- fn default() -> Baz { //~ ERROR function cannot return without recurring`
	`103`	`+ fn default() -> Baz { //~ ERROR function cannot return without recursing`
`104`	`104`	`let x = Default::default();`
`105`	`105`	`x`
`106`	`106`	`}`
`@@ -109,14 +109,14 @@ impl Default for Baz {`
`109`	`109`	`// Overloaded operators.`
`110`	`110`	`impl std::ops::Deref for Baz {`
`111`	`111`	`type Target = ();`
`112`		`- fn deref(&self) -> &() { //~ ERROR function cannot return without recurring`
	`112`	`+ fn deref(&self) -> &() { //~ ERROR function cannot return without recursing`
`113`	`113`	`&**self`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`impl std::ops::Index<usize> for Baz {`
`118`	`118`	`type Output = Baz;`
`119`		`- fn index(&self, x: usize) -> &Baz { //~ ERROR function cannot return without recurring`
	`119`	`+ fn index(&self, x: usize) -> &Baz { //~ ERROR function cannot return without recursing`
`120`	`120`	`&self[x]`
`121`	`121`	`}`
`122`	`122`	`}`
`@@ -125,7 +125,7 @@ impl std::ops::Index<usize> for Baz {`
`125`	`125`	`struct Quux;`
`126`	`126`	`impl std::ops::Deref for Quux {`
`127`	`127`	`type Target = Baz;`
`128`		`- fn deref(&self) -> &Baz { //~ ERROR function cannot return without recurring`
	`128`	`+ fn deref(&self) -> &Baz { //~ ERROR function cannot return without recursing`
`129`	`129`	`self.as_ref()`
`130`	`130`	`}`
`131`	`131`	`}`