Auto merge of #106193 - compiler-errors:rollup-0l54wka, r=compiler-errors

Rollup of 9 pull requests

Successful merges:

 - #103718 (More inference-friendly API for lazy)
 - #105765 (Detect likely `.` -> `..` typo in method calls)
 - #105852 (Suggest rewriting a malformed hex literal if we expect a float)
 - #105965 (Provide local extern function arg names)
 - #106064 (Partially fix `explicit_outlives_requirements` lint in macros)
 - #106179 (Fix a formatting error in Iterator::for_each docs)
 - #106181 (Fix doc comment parsing description in book)
 - #106187 (Update the documentation of `Vec` to use `extend(array)` instead of `extend(array.iter().copied())`)
 - #106189 (Fix UnsafeCell Documentation Spelling Error)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

10 files changed, 526 insertions, 10 deletions

diff --git a/src/doc/rustdoc/src/write-documentation/the-doc-attribute.md b/src/doc/rustdoc/src/write-documentation/the-doc-attribute.md
index e3b08648999..8ecf05f0e12 100644
--- a/src/doc/rustdoc/src/write-documentation/the-doc-attribute.md
+++ b/src/doc/rustdoc/src/write-documentation/the-doc-attribute.md
@@ -9,11 +9,11 @@ are the same:
 
 ```rust,no_run
 /// This is a doc comment.
-#[doc = " This is a doc comment."]
+#[doc = r" This is a doc comment."]
 # fn f() {}
 ```
 
-(Note the leading space in the attribute version.)
+(Note the leading space and the raw string literal in the attribute version.)
 
 In most cases, `///` is easier to use than `#[doc]`. One case where the latter is easier is
 when generating documentation in macros; the `collapse-docs` pass will combine multiple
diff --git a/src/test/ui/argument-suggestions/extern-fn-arg-names.rs b/src/test/ui/argument-suggestions/extern-fn-arg-names.rs
new file mode 100644
index 00000000000..6c925a3d653
--- /dev/null
+++ b/src/test/ui/argument-suggestions/extern-fn-arg-names.rs
@@ -0,0 +1,9 @@
+extern "Rust" {
+    fn dstfn(src: i32, dst: err);
+    //~^ ERROR cannot find type `err` in this scope
+}
+
+fn main() {
+    dstfn(1);
+    //~^ ERROR this function takes 2 arguments but 1 argument was supplied
+}
diff --git a/src/test/ui/argument-suggestions/extern-fn-arg-names.stderr b/src/test/ui/argument-suggestions/extern-fn-arg-names.stderr
new file mode 100644
index 00000000000..f6bc84c1203
--- /dev/null
+++ b/src/test/ui/argument-suggestions/extern-fn-arg-names.stderr
@@ -0,0 +1,26 @@
+error[E0412]: cannot find type `err` in this scope
+  --> $DIR/extern-fn-arg-names.rs:2:29
+   |
+LL |     fn dstfn(src: i32, dst: err);
+   |                             ^^^ not found in this scope
+
+error[E0061]: this function takes 2 arguments but 1 argument was supplied
+  --> $DIR/extern-fn-arg-names.rs:7:5
+   |
+LL |     dstfn(1);
+   |     ^^^^^--- an argument is missing
+   |
+note: function defined here
+  --> $DIR/extern-fn-arg-names.rs:2:8
+   |
+LL |     fn dstfn(src: i32, dst: err);
+   |        ^^^^^
+help: provide the argument
+   |
+LL |     dstfn(1, /* dst */);
+   |          ~~~~~~~~~~~~~~
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0061, E0412.
+For more information about an error, try `rustc --explain E0061`.
diff --git a/src/test/ui/rust-2018/edition-lint-infer-outlives-macro.fixed b/src/test/ui/rust-2018/edition-lint-infer-outlives-macro.fixed
new file mode 100644
index 00000000000..8cdb08e81b9
--- /dev/null
+++ b/src/test/ui/rust-2018/edition-lint-infer-outlives-macro.fixed
@@ -0,0 +1,137 @@
+// edition:2018
+// aux-build:edition-lint-infer-outlives-macro.rs
+// run-rustfix
+
+#![deny(explicit_outlives_requirements)]
+#![allow(dead_code)]
+
+#[macro_use]
+extern crate edition_lint_infer_outlives_macro;
+
+// Test that the lint does not fire if the predicate is from the local crate,
+// but all the bounds are from an external macro.
+macro_rules! make_foo {
+    ($a:tt) => {
+        struct Foo<$a, 'b: $a> {
+            foo: &$a &'b (),
+        }
+
+        struct FooWhere<$a, 'b> where 'b: $a {
+            foo: &$a &'b (),
+        }
+    }
+}
+
+gimme_a! {make_foo!}
+
+struct Bar<'a, 'b> {
+    //~^ ERROR: outlives requirements can be inferred
+    bar: &'a &'b (),
+}
+
+struct BarWhere<'a, 'b> {
+    //~^ ERROR: outlives requirements can be inferred
+    bar: &'a &'b (),
+}
+
+// Test that the lint *does* fire if the predicate is contained in a local macro.
+mod everything_inside {
+    macro_rules! m {
+        ('b: 'a) => {
+            struct Foo<'a, 'b>(&'a &'b ());
+            //~^ ERROR: outlives requirements can be inferred
+            struct Bar<'a, 'b>(&'a &'b ()) ;
+            //~^ ERROR: outlives requirements can be inferred
+            struct Baz<'a, 'b>(&'a &'b ()) where (): Sized, ;
+            //~^ ERROR: outlives requirements can be inferred
+        };
+    }
+    m!('b: 'a);
+}
+
+mod inner_lifetime_outside_colon_inside {
+    macro_rules! m {
+        ($b:lifetime: 'a) => {
+            struct Foo<'a, $b>(&'a &$b ());
+            //~^ ERROR: outlives requirements can be inferred
+            struct Bar<'a, $b>(&'a &$b ()) ;
+            //~^ ERROR: outlives requirements can be inferred
+            struct Baz<'a, $b>(&'a &$b ()) where (): Sized, ;
+            //~^ ERROR: outlives requirements can be inferred
+        }
+    }
+    m!('b: 'a);
+}
+
+mod outer_lifetime_outside_colon_inside {
+    macro_rules! m {
+        ('b: $a:lifetime) => {
+            struct Foo<$a, 'b: $a>(&$a &'b ());
+            struct Bar<$a, 'b>(&$a &'b ()) where 'b: $a;
+            struct Baz<$a, 'b>(&$a &'b ()) where (): Sized, 'b: $a;
+        }
+    }
+    m!('b: 'a);
+}
+
+mod both_lifetimes_outside_colon_inside {
+    macro_rules! m {
+        ($b:lifetime: $a:lifetime) => {
+            struct Foo<$a, $b: $a>(&$a &$b ());
+            struct Bar<$a, $b>(&$a &$b ()) where $b: $a;
+            struct Baz<$a, $b>(&$a &$b ()) where (): Sized, $b: $a;
+        }
+    }
+    m!('b: 'a);
+}
+
+mod everything_outside {
+    macro_rules! m {
+        ($b:lifetime $colon:tt $a:lifetime) => {
+            struct Foo<$a, $b $colon $a>(&$a &$b ());
+            struct Bar<$a, $b>(&$a &$b ()) where $b $colon $a;
+            struct Baz<$a, $b>(&$a &$b ()) where (): Sized, $b $colon $a;
+        }
+    }
+    m!('b: 'a);
+}
+
+mod everything_outside_with_tt_inner {
+    macro_rules! m {
+        ($b:tt $colon:tt $a:lifetime) => {
+            struct Foo<$a, $b $colon $a>(&$a &$b ());
+            struct Bar<$a, $b>(&$a &$b ()) where $b $colon $a;
+            struct Baz<$a, $b>(&$a &$b ()) where (): Sized, $b $colon $a;
+        }
+    }
+    m!('b: 'a);
+}
+
+// FIXME: These should be consistent.
+mod everything_outside_with_tt_outer {
+    macro_rules! m {
+        ($b:lifetime $colon:tt $a:tt) => {
+            struct Foo<$a, $b >(&$a &$b ());
+            //~^ ERROR: outlives requirements can be inferred
+            struct Bar<$a, $b>(&$a &$b ()) where $b $colon $a;
+            struct Baz<$a, $b>(&$a &$b ()) where (): Sized, $b $colon $a;
+        }
+    }
+    m!('b: 'a);
+}
+
+mod everything_outside_with_tt_both {
+    macro_rules! m {
+        ($b:tt $colon:tt $a:tt) => {
+            struct Foo<$a, $b >(&$a &$b ());
+            //~^ ERROR: outlives requirements can be inferred
+            struct Bar<$a, $b>(&$a &$b ()) where ;
+            //~^ ERROR: outlives requirements can be inferred
+            struct Baz<$a, $b>(&$a &$b ()) where (): Sized, ;
+            //~^ ERROR: outlives requirements can be inferred
+        }
+    }
+    m!('b: 'a);
+}
+
+fn main() {}
diff --git a/src/test/ui/rust-2018/edition-lint-infer-outlives-macro.rs b/src/test/ui/rust-2018/edition-lint-infer-outlives-macro.rs
index d7a832831c1..647906c2dc2 100644
--- a/src/test/ui/rust-2018/edition-lint-infer-outlives-macro.rs
+++ b/src/test/ui/rust-2018/edition-lint-infer-outlives-macro.rs
@@ -1,18 +1,22 @@
 // edition:2018
 // aux-build:edition-lint-infer-outlives-macro.rs
-
-// Test that the lint does not fire if the where predicate
-// is from the local crate, but all the bounds are from an
-// external macro.
+// run-rustfix
 
 #![deny(explicit_outlives_requirements)]
+#![allow(dead_code)]
 
 #[macro_use]
 extern crate edition_lint_infer_outlives_macro;
 
+// Test that the lint does not fire if the predicate is from the local crate,
+// but all the bounds are from an external macro.
 macro_rules! make_foo {
     ($a:tt) => {
-        struct Foo<$a, 'b> where 'b: $a {
+        struct Foo<$a, 'b: $a> {
+            foo: &$a &'b (),
+        }
+
+        struct FooWhere<$a, 'b> where 'b: $a {
             foo: &$a &'b (),
         }
     }
@@ -25,4 +29,109 @@ struct Bar<'a, 'b: 'a> {
     bar: &'a &'b (),
 }
 
+struct BarWhere<'a, 'b> where 'b: 'a {
+    //~^ ERROR: outlives requirements can be inferred
+    bar: &'a &'b (),
+}
+
+// Test that the lint *does* fire if the predicate is contained in a local macro.
+mod everything_inside {
+    macro_rules! m {
+        ('b: 'a) => {
+            struct Foo<'a, 'b: 'a>(&'a &'b ());
+            //~^ ERROR: outlives requirements can be inferred
+            struct Bar<'a, 'b>(&'a &'b ()) where 'b: 'a;
+            //~^ ERROR: outlives requirements can be inferred
+            struct Baz<'a, 'b>(&'a &'b ()) where (): Sized, 'b: 'a;
+            //~^ ERROR: outlives requirements can be inferred
+        };
+    }
+    m!('b: 'a);
+}
+
+mod inner_lifetime_outside_colon_inside {
+    macro_rules! m {
+        ($b:lifetime: 'a) => {
+            struct Foo<'a, $b: 'a>(&'a &$b ());
+            //~^ ERROR: outlives requirements can be inferred
+            struct Bar<'a, $b>(&'a &$b ()) where $b: 'a;
+            //~^ ERROR: outlives requirements can be inferred
+            struct Baz<'a, $b>(&'a &$b ()) where (): Sized, $b: 'a;
+            //~^ ERROR: outlives requirements can be inferred
+        }
+    }
+    m!('b: 'a);
+}
+
+mod outer_lifetime_outside_colon_inside {
+    macro_rules! m {
+        ('b: $a:lifetime) => {
+            struct Foo<$a, 'b: $a>(&$a &'b ());
+            struct Bar<$a, 'b>(&$a &'b ()) where 'b: $a;
+            struct Baz<$a, 'b>(&$a &'b ()) where (): Sized, 'b: $a;
+        }
+    }
+    m!('b: 'a);
+}
+
+mod both_lifetimes_outside_colon_inside {
+    macro_rules! m {
+        ($b:lifetime: $a:lifetime) => {
+            struct Foo<$a, $b: $a>(&$a &$b ());
+            struct Bar<$a, $b>(&$a &$b ()) where $b: $a;
+            struct Baz<$a, $b>(&$a &$b ()) where (): Sized, $b: $a;
+        }
+    }
+    m!('b: 'a);
+}
+
+mod everything_outside {
+    macro_rules! m {
+        ($b:lifetime $colon:tt $a:lifetime) => {
+            struct Foo<$a, $b $colon $a>(&$a &$b ());
+            struct Bar<$a, $b>(&$a &$b ()) where $b $colon $a;
+            struct Baz<$a, $b>(&$a &$b ()) where (): Sized, $b $colon $a;
+        }
+    }
+    m!('b: 'a);
+}
+
+mod everything_outside_with_tt_inner {
+    macro_rules! m {
+        ($b:tt $colon:tt $a:lifetime) => {
+            struct Foo<$a, $b $colon $a>(&$a &$b ());
+            struct Bar<$a, $b>(&$a &$b ()) where $b $colon $a;
+            struct Baz<$a, $b>(&$a &$b ()) where (): Sized, $b $colon $a;
+        }
+    }
+    m!('b: 'a);
+}
+
+// FIXME: These should be consistent.
+mod everything_outside_with_tt_outer {
+    macro_rules! m {
+        ($b:lifetime $colon:tt $a:tt) => {
+            struct Foo<$a, $b $colon $a>(&$a &$b ());
+            //~^ ERROR: outlives requirements can be inferred
+            struct Bar<$a, $b>(&$a &$b ()) where $b $colon $a;
+            struct Baz<$a, $b>(&$a &$b ()) where (): Sized, $b $colon $a;
+        }
+    }
+    m!('b: 'a);
+}
+
+mod everything_outside_with_tt_both {
+    macro_rules! m {
+        ($b:tt $colon:tt $a:tt) => {
+            struct Foo<$a, $b $colon $a>(&$a &$b ());
+            //~^ ERROR: outlives requirements can be inferred
+            struct Bar<$a, $b>(&$a &$b ()) where $b $colon $a;
+            //~^ ERROR: outlives requirements can be inferred
+            struct Baz<$a, $b>(&$a &$b ()) where (): Sized, $b $colon $a;
+            //~^ ERROR: outlives requirements can be inferred
+        }
+    }
+    m!('b: 'a);
+}
+
 fn main() {}
diff --git a/src/test/ui/rust-2018/edition-lint-infer-outlives-macro.stderr b/src/test/ui/rust-2018/edition-lint-infer-outlives-macro.stderr
index 553b1cd976a..734ae687978 100644
--- a/src/test/ui/rust-2018/edition-lint-infer-outlives-macro.stderr
+++ b/src/test/ui/rust-2018/edition-lint-infer-outlives-macro.stderr
@@ -1,14 +1,110 @@
 error: outlives requirements can be inferred
-  --> $DIR/edition-lint-infer-outlives-macro.rs:23:18
+  --> $DIR/edition-lint-infer-outlives-macro.rs:27:18
    |
 LL | struct Bar<'a, 'b: 'a> {
    |                  ^^^^ help: remove this bound
    |
 note: the lint level is defined here
-  --> $DIR/edition-lint-infer-outlives-macro.rs:8:9
+  --> $DIR/edition-lint-infer-outlives-macro.rs:5:9
    |
 LL | #![deny(explicit_outlives_requirements)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: outlives requirements can be inferred
+  --> $DIR/edition-lint-infer-outlives-macro.rs:32:24
+   |
+LL | struct BarWhere<'a, 'b> where 'b: 'a {
+   |                        ^^^^^^^^^^^^^ help: remove this bound
+
+error: outlives requirements can be inferred
+  --> $DIR/edition-lint-infer-outlives-macro.rs:41:30
+   |
+LL |             struct Foo<'a, 'b: 'a>(&'a &'b ());
+   |                              ^^^^ help: remove this bound
+...
+LL |     m!('b: 'a);
+   |     ---------- in this macro invocation
+   |
+   = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: outlives requirements can be inferred
+  --> $DIR/edition-lint-infer-outlives-macro.rs:43:44
+   |
+LL |             struct Bar<'a, 'b>(&'a &'b ()) where 'b: 'a;
+   |                                            ^^^^^^^^^^^^ help: remove this bound
+...
+LL |     m!('b: 'a);
+   |     ---------- in this macro invocation
+   |
+   = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: outlives requirements can be inferred
+  --> $DIR/edition-lint-infer-outlives-macro.rs:45:61
+   |
+LL |             struct Baz<'a, 'b>(&'a &'b ()) where (): Sized, 'b: 'a;
+   |                                                             ^^^^^^ help: remove this bound
+...
+LL |     m!('b: 'a);
+   |     ---------- in this macro invocation
+   |
+   = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: outlives requirements can be inferred
+  --> $DIR/edition-lint-infer-outlives-macro.rs:55:30
+   |
+LL |             struct Foo<'a, $b: 'a>(&'a &$b ());
+   |                              ^^^^ help: remove this bound
+...
+LL |     m!('b: 'a);
+   |     ---------- in this macro invocation
+   |
+   = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: outlives requirements can be inferred
+  --> $DIR/edition-lint-infer-outlives-macro.rs:57:44
+   |
+LL |             struct Bar<'a, $b>(&'a &$b ()) where $b: 'a;
+   |                                            ^^^^^^^^^^^^ help: remove this bound
+...
+LL |     m!('b: 'a);
+   |     ---------- in this macro invocation
+   |
+   = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: outlives requirements can be inferred
+  --> $DIR/edition-lint-infer-outlives-macro.rs:59:61
+   |
+LL |             struct Baz<'a, $b>(&'a &$b ()) where (): Sized, $b: 'a;
+   |                                                             ^^^^^^ help: remove this bound
+...
+LL |     m!('b: 'a);
+   |     ---------- in this macro invocation
+   |
+   = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: outlives requirements can be inferred
+  --> $DIR/edition-lint-infer-outlives-macro.rs:114:31
+   |
+LL |             struct Foo<$a, $b $colon $a>(&$a &$b ());
+   |                               ^^^^^^^^^ help: remove this bound
+
+error: outlives requirements can be inferred
+  --> $DIR/edition-lint-infer-outlives-macro.rs:126:31
+   |
+LL |             struct Foo<$a, $b $colon $a>(&$a &$b ());
+   |                               ^^^^^^^^^ help: remove this bound
+
+error: outlives requirements can be inferred
+  --> $DIR/edition-lint-infer-outlives-macro.rs:128:50
+   |
+LL |             struct Bar<$a, $b>(&$a &$b ()) where $b $colon $a;
+   |                                                  ^^^^^^^^^^^^ help: remove this bound
+
+error: outlives requirements can be inferred
+  --> $DIR/edition-lint-infer-outlives-macro.rs:130:61
+   |
+LL |             struct Baz<$a, $b>(&$a &$b ()) where (): Sized, $b $colon $a;
+   |                                                             ^^^^^^^^^^^^ help: remove this bound
+
+error: aborting due to 12 previous errors
 
diff --git a/src/test/ui/suggestions/bad-hex-float-lit.rs b/src/test/ui/suggestions/bad-hex-float-lit.rs
new file mode 100644
index 00000000000..cd6fdbde96c
--- /dev/null
+++ b/src/test/ui/suggestions/bad-hex-float-lit.rs
@@ -0,0 +1,13 @@
+fn main() {
+    let _f: f32 = 0xAAf32;
+    //~^ ERROR mismatched types
+    //~| HELP rewrite this
+
+    let _f: f32 = 0xAB_f32;
+    //~^ ERROR mismatched types
+    //~| HELP rewrite this
+
+    let _f: f64 = 0xFF_f64;
+    //~^ ERROR mismatched types
+    //~| HELP rewrite this
+}
diff --git a/src/test/ui/suggestions/bad-hex-float-lit.stderr b/src/test/ui/suggestions/bad-hex-float-lit.stderr
new file mode 100644
index 00000000000..bc09abb1a56
--- /dev/null
+++ b/src/test/ui/suggestions/bad-hex-float-lit.stderr
@@ -0,0 +1,48 @@
+error[E0308]: mismatched types
+  --> $DIR/bad-hex-float-lit.rs:2:19
+   |
+LL |     let _f: f32 = 0xAAf32;
+   |             ---   ^^^^^^^ expected `f32`, found integer
+   |             |
+   |             expected due to this
+   |
+help: rewrite this as a decimal floating point literal, or use `as` to turn a hex literal into a float
+   |
+LL |     let _f: f32 = 0xAA as f32;
+   |                   ~~~~~~~~~~~
+LL |     let _f: f32 = 170_f32;
+   |                   ~~~~~~~
+
+error[E0308]: mismatched types
+  --> $DIR/bad-hex-float-lit.rs:6:19
+   |
+LL |     let _f: f32 = 0xAB_f32;
+   |             ---   ^^^^^^^^ expected `f32`, found integer
+   |             |
+   |             expected due to this
+   |
+help: rewrite this as a decimal floating point literal, or use `as` to turn a hex literal into a float
+   |
+LL |     let _f: f32 = 0xAB as f32;
+   |                   ~~~~~~~~~~~
+LL |     let _f: f32 = 171_f32;
+   |                   ~~~~~~~
+
+error[E0308]: mismatched types
+  --> $DIR/bad-hex-float-lit.rs:10:19
+   |
+LL |     let _f: f64 = 0xFF_f64;
+   |             ---   ^^^^^^^^ expected `f64`, found integer
+   |             |
+   |             expected due to this
+   |
+help: rewrite this as a decimal floating point literal, or use `as` to turn a hex literal into a float
+   |
+LL |     let _f: f64 = 0xFF as f64;
+   |                   ~~~~~~~~~~~
+LL |     let _f: f64 = 255_f64;
+   |                   ~~~~~~~
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/src/test/ui/suggestions/method-access-to-range-literal-typo.rs b/src/test/ui/suggestions/method-access-to-range-literal-typo.rs
new file mode 100644
index 00000000000..ac662edafe6
--- /dev/null
+++ b/src/test/ui/suggestions/method-access-to-range-literal-typo.rs
@@ -0,0 +1,30 @@
+fn as_ref() -> Option<Vec<u8>> {
+    None
+}
+struct Type {
+    option: Option<Vec<u8>>
+}
+trait Trait {
+    fn foo(&self) -> Vec<u8>;
+}
+impl Trait for Option<Vec<u8>> {
+    fn foo(&self) -> Vec<u8> {
+        vec![1, 2, 3]
+    }
+}
+
+impl Type {
+    fn method(&self) -> Option<Vec<u8>> {
+        self.option..as_ref().map(|x| x)
+        //~^ ERROR E0308
+    }
+    fn method2(&self) -> &u8 {
+        self.option..foo().get(0)
+        //~^ ERROR E0425
+        //~| ERROR E0308
+    }
+}
+
+fn main() {
+    let _ = Type { option: None }.method();
+}
diff --git a/src/test/ui/suggestions/method-access-to-range-literal-typo.stderr b/src/test/ui/suggestions/method-access-to-range-literal-typo.stderr
new file mode 100644
index 00000000000..c84f9467891
--- /dev/null
+++ b/src/test/ui/suggestions/method-access-to-range-literal-typo.stderr
@@ -0,0 +1,48 @@
+error[E0425]: cannot find function `foo` in this scope
+  --> $DIR/method-access-to-range-literal-typo.rs:22:22
+   |
+LL |         self.option..foo().get(0)
+   |                      ^^^ not found in this scope
+   |
+help: you might have meant to write `.` instead of `..`
+   |
+LL -         self.option..foo().get(0)
+LL +         self.option.foo().get(0)
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/method-access-to-range-literal-typo.rs:18:9
+   |
+LL |     fn method(&self) -> Option<Vec<u8>> {
+   |                         --------------- expected `Option<Vec<u8>>` because of return type
+LL |         self.option..as_ref().map(|x| x)
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected enum `Option`, found struct `Range`
+   |
+   = note: expected enum `Option<_>`
+            found struct `std::ops::Range<Option<_>>`
+help: you likely meant to write a method call instead of a range
+   |
+LL -         self.option..as_ref().map(|x| x)
+LL +         self.option.as_ref().map(|x| x)
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/method-access-to-range-literal-typo.rs:22:9
+   |
+LL |     fn method2(&self) -> &u8 {
+   |                          --- expected `&u8` because of return type
+LL |         self.option..foo().get(0)
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&u8`, found struct `Range`
+   |
+   = note: expected reference `&u8`
+                 found struct `std::ops::Range<Option<Vec<u8>>>`
+help: you likely meant to write a method call instead of a range
+   |
+LL -         self.option..foo().get(0)
+LL +         self.option.foo().get(0)
+   |
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0308, E0425.
+For more information about an error, try `rustc --explain E0308`.