diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 98a788954215..5a048e1ce43b 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -223,30 +223,32 @@ struct UseSelfVisitor<'a, 'tcx> {
 
 impl<'a, 'tcx> Visitor<'tcx> for UseSelfVisitor<'a, 'tcx> {
     fn visit_path(&mut self, path: &'tcx Path, _id: HirId) {
-        if path.segments.len() >= 2 {
-            let last_but_one = &path.segments[path.segments.len() - 2];
-            if last_but_one.ident.name != kw::SelfUpper {
-                let enum_def_id = match path.res {
-                    Res::Def(DefKind::Variant, variant_def_id) => self.cx.tcx.parent(variant_def_id),
-                    Res::Def(DefKind::Ctor(def::CtorOf::Variant, _), ctor_def_id) => {
-                        let variant_def_id = self.cx.tcx.parent(ctor_def_id);
-                        variant_def_id.and_then(|def_id| self.cx.tcx.parent(def_id))
-                    },
-                    _ => None,
-                };
+        if !path.segments.iter().any(|p| p.ident.span.is_dummy()) {
+            if path.segments.len() >= 2 {
+                let last_but_one = &path.segments[path.segments.len() - 2];
+                if last_but_one.ident.name != kw::SelfUpper {
+                    let enum_def_id = match path.res {
+                        Res::Def(DefKind::Variant, variant_def_id) => self.cx.tcx.parent(variant_def_id),
+                        Res::Def(DefKind::Ctor(def::CtorOf::Variant, _), ctor_def_id) => {
+                            let variant_def_id = self.cx.tcx.parent(ctor_def_id);
+                            variant_def_id.and_then(|def_id| self.cx.tcx.parent(def_id))
+                        },
+                        _ => None,
+                    };
 
-                if self.item_path.res.opt_def_id() == enum_def_id {
-                    span_use_self_lint(self.cx, path, Some(last_but_one));
+                    if self.item_path.res.opt_def_id() == enum_def_id {
+                        span_use_self_lint(self.cx, path, Some(last_but_one));
+                    }
                 }
             }
-        }
 
-        if path.segments.last().expect(SEGMENTS_MSG).ident.name != kw::SelfUpper {
-            if self.item_path.res == path.res {
-                span_use_self_lint(self.cx, path, None);
-            } else if let Res::Def(DefKind::Ctor(def::CtorOf::Struct, _), ctor_def_id) = path.res {
-                if self.item_path.res.opt_def_id() == self.cx.tcx.parent(ctor_def_id) {
+            if path.segments.last().expect(SEGMENTS_MSG).ident.name != kw::SelfUpper {
+                if self.item_path.res == path.res {
                     span_use_self_lint(self.cx, path, None);
+                } else if let Res::Def(DefKind::Ctor(def::CtorOf::Struct, _), ctor_def_id) = path.res {
+                    if self.item_path.res.opt_def_id() == self.cx.tcx.parent(ctor_def_id) {
+                        span_use_self_lint(self.cx, path, None);
+                    }
                 }
             }
         }
diff --git a/tests/ui/crashes/auxiliary/ice-4727-aux.rs b/tests/ui/crashes/auxiliary/ice-4727-aux.rs
new file mode 100644
index 000000000000..58a20caf6c67
--- /dev/null
+++ b/tests/ui/crashes/auxiliary/ice-4727-aux.rs
@@ -0,0 +1,9 @@
+pub trait Trait {
+    fn fun(par: &str) -> &str;
+}
+
+impl Trait for str {
+    fn fun(par: &str) -> &str {
+        &par[0..1]
+    }
+}
diff --git a/tests/ui/crashes/ice-4727.rs b/tests/ui/crashes/ice-4727.rs
new file mode 100644
index 000000000000..cdb59caec67e
--- /dev/null
+++ b/tests/ui/crashes/ice-4727.rs
@@ -0,0 +1,8 @@
+// run-pass
+
+#![warn(clippy::use_self)]
+
+#[path = "auxiliary/ice-4727-aux.rs"]
+mod aux;
+
+fn main() {}
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index 901337885260..55809116882d 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -1,4 +1,5 @@
 // run-rustfix
+// compile-flags: --edition 2018
 
 #![warn(clippy::use_self)]
 #![allow(dead_code)]
@@ -332,3 +333,32 @@ mod issue3567 {
         }
     }
 }
+
+mod paths_created_by_lowering {
+    use std::ops::Range;
+
+    struct S {}
+
+    impl S {
+        const A: usize = 0;
+        const B: usize = 1;
+
+        async fn g() -> Self {
+            Self {}
+        }
+
+        fn f<'a>(&self, p: &'a [u8]) -> &'a [u8] {
+            &p[Self::A..Self::B]
+        }
+    }
+
+    trait T {
+        fn f<'a>(&self, p: &'a [u8]) -> &'a [u8];
+    }
+
+    impl T for Range<u8> {
+        fn f<'a>(&self, p: &'a [u8]) -> &'a [u8] {
+            &p[0..1]
+        }
+    }
+}
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index e6900b915341..3bd89691875b 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -1,4 +1,5 @@
 // run-rustfix
+// compile-flags: --edition 2018
 
 #![warn(clippy::use_self)]
 #![allow(dead_code)]
@@ -332,3 +333,32 @@ mod issue3567 {
         }
     }
 }
+
+mod paths_created_by_lowering {
+    use std::ops::Range;
+
+    struct S {}
+
+    impl S {
+        const A: usize = 0;
+        const B: usize = 1;
+
+        async fn g() -> S {
+            S {}
+        }
+
+        fn f<'a>(&self, p: &'a [u8]) -> &'a [u8] {
+            &p[S::A..S::B]
+        }
+    }
+
+    trait T {
+        fn f<'a>(&self, p: &'a [u8]) -> &'a [u8];
+    }
+
+    impl T for Range<u8> {
+        fn f<'a>(&self, p: &'a [u8]) -> &'a [u8] {
+            &p[0..1]
+        }
+    }
+}
diff --git a/tests/ui/use_self.stderr b/tests/ui/use_self.stderr
index d1bfb0e230d8..664f91b1460d 100644
--- a/tests/ui/use_self.stderr
+++ b/tests/ui/use_self.stderr
@@ -1,5 +1,5 @@
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:13:21
+  --> $DIR/use_self.rs:14:21
    |
 LL |         fn new() -> Foo {
    |                     ^^^ help: use the applicable keyword: `Self`
@@ -7,139 +7,139 @@ LL |         fn new() -> Foo {
    = note: `-D clippy::use-self` implied by `-D warnings`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:14:13
+  --> $DIR/use_self.rs:15:13
    |
 LL |             Foo {}
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:16:22
+  --> $DIR/use_self.rs:17:22
    |
 LL |         fn test() -> Foo {
    |                      ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:17:13
+  --> $DIR/use_self.rs:18:13
    |
 LL |             Foo::new()
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:22:25
+  --> $DIR/use_self.rs:23:25
    |
 LL |         fn default() -> Foo {
    |                         ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:23:13
+  --> $DIR/use_self.rs:24:13
    |
 LL |             Foo::new()
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:88:22
+  --> $DIR/use_self.rs:89:22
    |
 LL |         fn refs(p1: &Bad) -> &Bad {
    |                      ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:88:31
+  --> $DIR/use_self.rs:89:31
    |
 LL |         fn refs(p1: &Bad) -> &Bad {
    |                               ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:92:37
+  --> $DIR/use_self.rs:93:37
    |
 LL |         fn ref_refs<'a>(p1: &'a &'a Bad) -> &'a &'a Bad {
    |                                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:92:53
+  --> $DIR/use_self.rs:93:53
    |
 LL |         fn ref_refs<'a>(p1: &'a &'a Bad) -> &'a &'a Bad {
    |                                                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:96:30
+  --> $DIR/use_self.rs:97:30
    |
 LL |         fn mut_refs(p1: &mut Bad) -> &mut Bad {
    |                              ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:96:43
+  --> $DIR/use_self.rs:97:43
    |
 LL |         fn mut_refs(p1: &mut Bad) -> &mut Bad {
    |                                           ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:100:28
+  --> $DIR/use_self.rs:101:28
    |
 LL |         fn nested(_p1: Box<Bad>, _p2: (&u8, &Bad)) {}
    |                            ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:100:46
+  --> $DIR/use_self.rs:101:46
    |
 LL |         fn nested(_p1: Box<Bad>, _p2: (&u8, &Bad)) {}
    |                                              ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:102:20
+  --> $DIR/use_self.rs:103:20
    |
 LL |         fn vals(_: Bad) -> Bad {
    |                    ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:102:28
+  --> $DIR/use_self.rs:103:28
    |
 LL |         fn vals(_: Bad) -> Bad {
    |                            ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:103:13
+  --> $DIR/use_self.rs:104:13
    |
 LL |             Bad::default()
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:108:23
+  --> $DIR/use_self.rs:109:23
    |
 LL |         type Output = Bad;
    |                       ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:110:27
+  --> $DIR/use_self.rs:111:27
    |
 LL |         fn mul(self, rhs: Bad) -> Bad {
    |                           ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:110:35
+  --> $DIR/use_self.rs:111:35
    |
 LL |         fn mul(self, rhs: Bad) -> Bad {
    |                                   ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:117:13
+  --> $DIR/use_self.rs:118:13
    |
 LL |             Bad
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:199:56
+  --> $DIR/use_self.rs:200:56
    |
 LL |         fn bad(foos: &[Self]) -> impl Iterator<Item = &Foo> {
    |                                                        ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:214:13
+  --> $DIR/use_self.rs:215:13
    |
 LL |             TS(0)
    |             ^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:222:25
+  --> $DIR/use_self.rs:223:25
    |
 LL |             fn new() -> Foo {
    |                         ^^^ help: use the applicable keyword: `Self`
@@ -148,7 +148,7 @@ LL |         use_self_expand!(); // Should lint in local macros
    |         ------------------- in this macro invocation
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:223:17
+  --> $DIR/use_self.rs:224:17
    |
 LL |                 Foo {}
    |                 ^^^ help: use the applicable keyword: `Self`
@@ -157,70 +157,94 @@ LL |         use_self_expand!(); // Should lint in local macros
    |         ------------------- in this macro invocation
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:258:21
+  --> $DIR/use_self.rs:259:21
    |
 LL |         fn baz() -> Foo {
    |                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:259:13
+  --> $DIR/use_self.rs:260:13
    |
 LL |             Foo {}
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:246:29
+  --> $DIR/use_self.rs:247:29
    |
 LL |                 fn bar() -> Bar {
    |                             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:247:21
+  --> $DIR/use_self.rs:248:21
    |
 LL |                     Bar { foo: Foo {} }
    |                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:276:21
+  --> $DIR/use_self.rs:277:21
    |
 LL |             let _ = Enum::B(42);
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:277:21
+  --> $DIR/use_self.rs:278:21
    |
 LL |             let _ = Enum::C { field: true };
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:278:21
+  --> $DIR/use_self.rs:279:21
    |
 LL |             let _ = Enum::A;
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:309:13
+  --> $DIR/use_self.rs:310:13
    |
 LL |             nested::A::fun_1();
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:310:13
+  --> $DIR/use_self.rs:311:13
    |
 LL |             nested::A::A;
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:312:13
+  --> $DIR/use_self.rs:313:13
    |
 LL |             nested::A {};
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:331:13
+  --> $DIR/use_self.rs:332:13
    |
 LL |             TestStruct::from_something()
    |             ^^^^^^^^^^ help: use the applicable keyword: `Self`
 
-error: aborting due to 36 previous errors
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:346:25
+   |
+LL |         async fn g() -> S {
+   |                         ^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:347:13
+   |
+LL |             S {}
+   |             ^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:351:16
+   |
+LL |             &p[S::A..S::B]
+   |                ^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:351:22
+   |
+LL |             &p[S::A..S::B]
+   |                      ^ help: use the applicable keyword: `Self`
+
+error: aborting due to 40 previous errors