submodules: update clippy from 9897442 to 8c0e038

Changes:
````
Rustup for rust-lang/rust#59042
Update pulldown_cmark to 0.5
Only run AppVeyor on r+, try and the master branch
Remove approx_constant known problems
Suppress let_and_return if let has attributes
Add test for or_fun_call macro suggestion
UI test cleanup: Extract needless_range_loop tests
Change "if types change" to "if you later change the type"
````

Author: matthiaskrgr

appveyor.yml

@@ -8,11 +8,11 @@ environment:
         - TARGET: x86_64-pc-windows-msvc
 
 branches:
-    # Don't build these branches
-    except:
-        # Used by bors
-        - trying.tmp
-        - staging.tmp
+    # Only build AppVeyor on r+, try and the master branch
+    only:
+      - auto
+      - try
+      - master
 
 install:
     - curl -sSf -o rustup-init.exe https://win.rustup.rs/

clippy_lints/Cargo.toml

@@ -28,7 +28,7 @@ serde = "1.0"
 serde_derive = "1.0"
 toml = "0.4"
 unicode-normalization = "0.1"
-pulldown-cmark = "0.2"
+pulldown-cmark = "0.5.0"
 url = "1.7.0"
 if_chain = "0.1.3"
 smallvec = { version = "0.6.5", features = ["union"] }

clippy_lints/src/approx_const.rs

@@ -19,10 +19,7 @@ declare_clippy_lint! {
     /// actually more precise, please [file a Rust
     /// issue](https://github.com/rust-lang/rust/issues).
     ///
-    /// **Known problems:** If you happen to have a value that is within 1/8192 of a
-    /// known constant, but is not *and should not* be the same, this lint will
-    /// report your value anyway. We have not yet noticed any false positives in
-    /// code we tested clippy with (this includes servo), but YMMV.
+    /// **Known problems:** None.
     ///
     /// **Example:**
     /// ```rust

clippy_lints/src/doc.rs

@@ -4,6 +4,7 @@ use pulldown_cmark;
 use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass};
 use rustc::{declare_tool_lint, impl_lint_pass};
 use rustc_data_structures::fx::FxHashSet;
+use std::ops::Range;
 use syntax::ast;
 use syntax::source_map::{BytePos, Span};
 use syntax_pos::Pos;
@@ -57,25 +58,6 @@ impl EarlyLintPass for DocMarkdown {
     }
 }
 
-struct Parser<'a> {
-    parser: pulldown_cmark::Parser<'a>,
-}
-
-impl<'a> Parser<'a> {
-    fn new(parser: pulldown_cmark::Parser<'a>) -> Self {
-        Self { parser }
-    }
-}
-
-impl<'a> Iterator for Parser<'a> {
-    type Item = (usize, pulldown_cmark::Event<'a>);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let offset = self.parser.get_offset();
-        self.parser.next().map(|event| (offset, event))
-    }
-}
-
 /// Cleanup documentation decoration (`///` and such).
 ///
 /// We can't use `syntax::attr::AttributeMethods::with_desugared_doc` or
@@ -159,30 +141,31 @@ pub fn check_attrs<'a>(cx: &EarlyContext<'_>, valid_idents: &FxHashSet<String>,
     }
 
     if !doc.is_empty() {
-        let parser = Parser::new(pulldown_cmark::Parser::new(&doc));
-        let parser = parser.coalesce(|x, y| {
+        let parser = pulldown_cmark::Parser::new(&doc).into_offset_iter();
+        // Iterate over all `Events` and combine consecutive events into one
+        let events = parser.coalesce(|previous, current| {
             use pulldown_cmark::Event::*;
 
-            let x_offset = x.0;
-            let y_offset = y.0;
+            let previous_range = previous.1;
+            let current_range = current.1;
 
-            match (x.1, y.1) {
-                (Text(x), Text(y)) => {
-                    let mut x = x.into_owned();
-                    x.push_str(&y);
-                    Ok((x_offset, Text(x.into())))
+            match (previous.0, current.0) {
+                (Text(previous), Text(current)) => {
+                    let mut previous = previous.to_string();
+                    previous.push_str(&current);
+                    Ok((Text(previous.into()), previous_range))
                 },
-                (x, y) => Err(((x_offset, x), (y_offset, y))),
+                (previous, current) => Err(((previous, previous_range), (current, current_range))),
             }
         });
-        check_doc(cx, valid_idents, parser, &spans);
+        check_doc(cx, valid_idents, events, &spans);
     }
 }
 
-fn check_doc<'a, Events: Iterator<Item = (usize, pulldown_cmark::Event<'a>)>>(
+fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize>)>>(
     cx: &EarlyContext<'_>,
     valid_idents: &FxHashSet<String>,
-    docs: Events,
+    events: Events,
     spans: &[(usize, Span)],
 ) {
     use pulldown_cmark::Event::*;
@@ -191,15 +174,15 @@ fn check_doc<'a, Events: Iterator<Item = (usize, pulldown_cmark::Event<'a>)>>(
     let mut in_code = false;
     let mut in_link = None;
 
-    for (offset, event) in docs {
+    for (event, range) in events {
         match event {
-            Start(CodeBlock(_)) | Start(Code) => in_code = true,
-            End(CodeBlock(_)) | End(Code) => in_code = false,
-            Start(Link(link, _)) => in_link = Some(link),
-            End(Link(_, _)) => in_link = None,
+            Start(CodeBlock(_)) => in_code = true,
+            End(CodeBlock(_)) => in_code = false,
+            Start(Link(_, url, _)) => in_link = Some(url),
+            End(Link(..)) => in_link = None,
             Start(_tag) | End(_tag) => (),         // We don't care about other tags
             Html(_html) | InlineHtml(_html) => (), // HTML is weird, just ignore it
-            SoftBreak | HardBreak => (),
+            SoftBreak | HardBreak | TaskListMarker(_) | Code(_) => (),
             FootnoteReference(text) | Text(text) => {
                 if Some(&text) == in_link.as_ref() {
                     // Probably a link of the form `<http://example.com>`
@@ -209,15 +192,15 @@ fn check_doc<'a, Events: Iterator<Item = (usize, pulldown_cmark::Event<'a>)>>(
                 }
 
                 if !in_code {
-                    let index = match spans.binary_search_by(|c| c.0.cmp(&offset)) {
+                    let index = match spans.binary_search_by(|c| c.0.cmp(&range.start)) {
                         Ok(o) => o,
                         Err(e) => e - 1,
                     };
 
                     let (begin, span) = spans[index];
 
                     // Adjust for the beginning of the current `Event`
-                    let span = span.with_lo(span.lo() + BytePos::from_usize(offset - begin));
+                    let span = span.with_lo(span.lo() + BytePos::from_usize(range.start - begin));
 
                     check_text(cx, valid_idents, &text, span);
                 }

clippy_lints/src/loops.rs

@@ -1459,12 +1459,12 @@ fn check_for_loop_explicit_counter<'a, 'tcx>(
     // For each candidate, check the parent block to see if
     // it's initialized to zero at the start of the loop.
     let map = &cx.tcx.hir();
-    let expr_node_id = map.hir_to_node_id(expr.hir_id);
+    let expr_node_id = expr.hir_id;
     let parent_scope = map
         .get_enclosing_scope(expr_node_id)
         .and_then(|id| map.get_enclosing_scope(id));
     if let Some(parent_id) = parent_scope {
-        if let Node::Block(block) = map.get(parent_id) {
+        if let Node::Block(block) = map.get_by_hir_id(parent_id) {
             for (id, _) in visitor.states.iter().filter(|&(_, v)| *v == VarState::IncrOnce) {
                 let mut visitor2 = InitializeVisitor {
                     cx,

clippy_lints/src/returns.rs

@@ -157,7 +157,7 @@ impl Return {
             if let ast::StmtKind::Local(ref local) = stmt.node;
             // don't lint in the presence of type inference
             if local.ty.is_none();
-            if !local.attrs.iter().any(attr_is_cfg);
+            if local.attrs.is_empty();
             if let Some(ref initexpr) = local.init;
             if let ast::PatKind::Ident(_, ident, _) = local.pat.node;
             if let ast::ExprKind::Path(_, ref path) = retexpr.node;

clippy_lints/src/types.rs

@@ -949,7 +949,7 @@ fn span_lossless_lint(cx: &LateContext<'_, '_>, expr: &Expr, op: &Expr, cast_fro
         CAST_LOSSLESS,
         expr.span,
         &format!(
-            "casting {} to {} may become silently lossy if types change",
+            "casting {} to {} may become silently lossy if you later change the type",
             cast_from, cast_to
         ),
         "try",

clippy_lints/src/utils/mod.rs

@@ -591,12 +591,11 @@ pub fn get_parent_expr<'c>(cx: &'c LateContext<'_, '_>, e: &Expr) -> Option<&'c
     })
 }
 
-pub fn get_enclosing_block<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, node: HirId) -> Option<&'tcx Block> {
+pub fn get_enclosing_block<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, hir_id: HirId) -> Option<&'tcx Block> {
     let map = &cx.tcx.hir();
-    let node_id = map.hir_to_node_id(node);
     let enclosing_node = map
-        .get_enclosing_scope(node_id)
-        .and_then(|enclosing_id| map.find(enclosing_id));
+        .get_enclosing_scope(hir_id)
+        .and_then(|enclosing_id| map.find_by_hir_id(enclosing_id));
     if let Some(node) = enclosing_node {
         match node {
             Node::Block(block) => Some(block),

tests/ui/cast_lossless_float.stderr

@@ -1,66 +1,66 @@
-error: casting i8 to f32 may become silently lossy if types change
+error: casting i8 to f32 may become silently lossy if you later change the type
   --> $DIR/cast_lossless_float.rs:9:5
    |
 LL |     x0 as f32;
    |     ^^^^^^^^^ help: try: `f32::from(x0)`
    |
    = note: `-D clippy::cast-lossless` implied by `-D warnings`
 
-error: casting i8 to f64 may become silently lossy if types change
+error: casting i8 to f64 may become silently lossy if you later change the type
   --> $DIR/cast_lossless_float.rs:10:5
    |
 LL |     x0 as f64;
    |     ^^^^^^^^^ help: try: `f64::from(x0)`
 
-error: casting u8 to f32 may become silently lossy if types change
+error: casting u8 to f32 may become silently lossy if you later change the type
   --> $DIR/cast_lossless_float.rs:12:5
    |
 LL |     x1 as f32;
    |     ^^^^^^^^^ help: try: `f32::from(x1)`
 
-error: casting u8 to f64 may become silently lossy if types change
+error: casting u8 to f64 may become silently lossy if you later change the type
   --> $DIR/cast_lossless_float.rs:13:5
    |
 LL |     x1 as f64;
    |     ^^^^^^^^^ help: try: `f64::from(x1)`
 
-error: casting i16 to f32 may become silently lossy if types change
+error: casting i16 to f32 may become silently lossy if you later change the type
   --> $DIR/cast_lossless_float.rs:15:5
    |
 LL |     x2 as f32;
    |     ^^^^^^^^^ help: try: `f32::from(x2)`
 
-error: casting i16 to f64 may become silently lossy if types change
+error: casting i16 to f64 may become silently lossy if you later change the type
   --> $DIR/cast_lossless_float.rs:16:5
    |
 LL |     x2 as f64;
    |     ^^^^^^^^^ help: try: `f64::from(x2)`
 
-error: casting u16 to f32 may become silently lossy if types change
+error: casting u16 to f32 may become silently lossy if you later change the type
   --> $DIR/cast_lossless_float.rs:18:5
    |
 LL |     x3 as f32;
    |     ^^^^^^^^^ help: try: `f32::from(x3)`
 
-error: casting u16 to f64 may become silently lossy if types change
+error: casting u16 to f64 may become silently lossy if you later change the type
   --> $DIR/cast_lossless_float.rs:19:5
    |
 LL |     x3 as f64;
    |     ^^^^^^^^^ help: try: `f64::from(x3)`
 
-error: casting i32 to f64 may become silently lossy if types change
+error: casting i32 to f64 may become silently lossy if you later change the type
   --> $DIR/cast_lossless_float.rs:21:5
    |
 LL |     x4 as f64;
    |     ^^^^^^^^^ help: try: `f64::from(x4)`
 
-error: casting u32 to f64 may become silently lossy if types change
+error: casting u32 to f64 may become silently lossy if you later change the type
   --> $DIR/cast_lossless_float.rs:23:5
    |
 LL |     x5 as f64;
    |     ^^^^^^^^^ help: try: `f64::from(x5)`
 
-error: casting f32 to f64 may become silently lossy if types change
+error: casting f32 to f64 may become silently lossy if you later change the type
   --> $DIR/cast_lossless_float.rs:26:5
    |
 LL |     1.0f32 as f64;