Some rustups

.github/workflows/clippy_bors.yml

@@ -231,7 +231,8 @@ jobs:
       matrix:
         integration:
         - 'rust-lang/cargo'
-        - 'rust-lang/rls'
+        # FIXME: Re-enable once we can test with rls again.
+        # - 'rust-lang/rls'
         - 'rust-lang/chalk'
         - 'rust-lang/rustfmt'
         - 'Marwes/combine'

clippy_dev/src/new_lint.rs

@@ -13,7 +13,7 @@ pub fn create(pass: Option<&str>, lint_name: Option<&str>, category: Option<&str
     match open_files(lint_name) {
         Ok((mut test_file, mut lint_file)) => {
             let (pass_type, pass_lifetimes, pass_import, context_import) = match pass {
-                "early" => ("EarlyLintPass", "", "use syntax::ast::*;", "EarlyContext"),
+                "early" => ("EarlyLintPass", "", "use rustc_ast::ast::*;", "EarlyContext"),
                 "late" => ("LateLintPass", "<'_, '_>", "use rustc_hir::*;", "LateContext"),
                 _ => {
                     unreachable!("`pass_type` should only ever be `early` or `late`!");

clippy_lints/src/approx_const.rs

@@ -1,10 +1,10 @@
 use crate::utils::span_lint;
+use rustc_ast::ast::{FloatTy, LitFloatType, LitKind};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol;
 use std::f64::consts as f64;
-use syntax::ast::{FloatTy, LitFloatType, LitKind};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for floating point literals that approximate

clippy_lints/src/as_conversions.rs

@@ -1,7 +1,7 @@
 use rustc::lint::in_external_macro;
+use rustc_ast::ast::{Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use syntax::ast::{Expr, ExprKind};
 
 use crate::utils::span_lint_and_help;
 

clippy_lints/src/assertions_on_constants.rs

@@ -2,10 +2,10 @@ use crate::consts::{constant, Constant};
 use crate::utils::paths;
 use crate::utils::{is_direct_expn_of, is_expn_of, match_function_call, snippet_opt, span_lint_and_help};
 use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
 use rustc_hir::{Expr, ExprKind, PatKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use syntax::ast::LitKind;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `assert!(true)` and `assert!(false)` calls.

clippy_lints/src/attrs.rs

@@ -8,6 +8,8 @@ use crate::utils::{
 use if_chain::if_chain;
 use rustc::lint::in_external_macro;
 use rustc::ty;
+use rustc_ast::ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
+use rustc_ast::util::lev_distance::find_best_match_for_name;
 use rustc_errors::Applicability;
 use rustc_hir::{
     Block, Expr, ExprKind, ImplItem, ImplItemKind, Item, ItemKind, StmtKind, TraitItem, TraitItemKind, TraitMethod,
@@ -17,8 +19,6 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::Symbol;
 use semver::Version;
-use syntax::ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
-use syntax::util::lev_distance::find_best_match_for_name;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for items annotated with `#[inline(always)]`,

clippy_lints/src/bit_mask.rs

@@ -2,12 +2,12 @@ use crate::consts::{constant, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::{span_lint, span_lint_and_then};
 use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
-use syntax::ast::LitKind;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for incompatible bit masks in comparisons.

clippy_lints/src/booleans.rs

@@ -4,13 +4,13 @@ use crate::utils::{
 };
 use if_chain::if_chain;
 use rustc::hir::map::Map;
+use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use syntax::ast::LitKind;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for boolean expressions that can be written more

clippy_lints/src/bytecount.rs

@@ -4,11 +4,11 @@ use crate::utils::{
 };
 use if_chain::if_chain;
 use rustc::ty;
+use rustc_ast::ast::{Name, UintTy};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use syntax::ast::{Name, UintTy};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for naive byte counts

clippy_lints/src/cargo_common_metadata.rs

@@ -3,10 +3,10 @@
 use std::path::PathBuf;
 
 use crate::utils::span_lint;
+use rustc_ast::ast::Crate;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::DUMMY_SP;
-use syntax::ast::Crate;
 
 declare_clippy_lint! {
     /// **What it does:** Checks to see if all common metadata is defined in

clippy_lints/src/checked_conversions.rs

@@ -2,11 +2,11 @@
 
 use if_chain::if_chain;
 use rustc::lint::in_external_macro;
+use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use syntax::ast::LitKind;
 
 use crate::utils::{snippet_with_applicability, span_lint_and_sugg, SpanlessEq};
 

clippy_lints/src/cognitive_complexity.rs

@@ -1,13 +1,13 @@
 //! calculate cognitive complexity and warn about overly complex functions
 
 use rustc::hir::map::Map;
+use rustc_ast::ast::Attribute;
 use rustc_hir::intravisit::{walk_expr, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{Body, Expr, ExprKind, FnDecl, HirId};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::BytePos;
-use syntax::ast::Attribute;
 
 use crate::utils::{match_type, paths, snippet_opt, span_lint_and_help, LimitStack};
 

clippy_lints/src/collapsible_if.rs

@@ -13,9 +13,9 @@
 //! This lint is **warn** by default
 
 use if_chain::if_chain;
+use rustc_ast::ast;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use syntax::ast;
 
 use crate::utils::sugg::Sugg;
 use crate::utils::{snippet_block, snippet_block_with_applicability, span_lint_and_sugg, span_lint_and_then};

clippy_lints/src/consts.rs

@@ -5,6 +5,7 @@ use if_chain::if_chain;
 use rustc::ty::subst::{Subst, SubstsRef};
 use rustc::ty::{self, Ty, TyCtxt};
 use rustc::{bug, span_bug};
+use rustc_ast::ast::{FloatTy, LitFloatType, LitKind};
 use rustc_data_structures::sync::Lrc;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOp, BinOpKind, Block, Expr, ExprKind, HirId, QPath, UnOp};
@@ -13,7 +14,6 @@ use rustc_span::symbol::Symbol;
 use std::cmp::Ordering::{self, Equal};
 use std::convert::TryInto;
 use std::hash::{Hash, Hasher};
-use syntax::ast::{FloatTy, LitFloatType, LitKind};
 
 /// A `LitKind`-like enum to fold constant `Expr`s into.
 #[derive(Debug, Clone)]

clippy_lints/src/dbg_macro.rs

@@ -1,10 +1,10 @@
 use crate::utils::{snippet_opt, span_lint_and_help, span_lint_and_sugg};
+use rustc_ast::ast;
+use rustc_ast::tokenstream::TokenStream;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use syntax::ast;
-use syntax::tokenstream::TokenStream;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of dbg!() macro.

clippy_lints/src/doc.rs

@@ -3,14 +3,14 @@ use if_chain::if_chain;
 use itertools::Itertools;
 use rustc::lint::in_external_macro;
 use rustc::ty;
+use rustc_ast::ast::{AttrKind, Attribute};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{BytePos, MultiSpan, Span};
 use rustc_span::Pos;
 use std::ops::Range;
-use syntax::ast::{AttrKind, Attribute};
 use url::Url;
 
 declare_clippy_lint! {
@@ -251,8 +251,8 @@ fn lint_for_missing_headers<'a, 'tcx>(
 
 /// Cleanup documentation decoration (`///` and such).
 ///
-/// We can't use `syntax::attr::AttributeMethods::with_desugared_doc` or
-/// `syntax::parse::lexer::comments::strip_doc_comment_decoration` because we
+/// We can't use `rustc_ast::attr::AttributeMethods::with_desugared_doc` or
+/// `rustc_ast::parse::lexer::comments::strip_doc_comment_decoration` because we
 /// need to keep track of
 /// the spans but this function is inspired from the later.
 #[allow(clippy::cast_possible_truncation)]

clippy_lints/src/double_parens.rs

@@ -1,7 +1,7 @@
 use crate::utils::span_lint;
+use rustc_ast::ast::{Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use syntax::ast::{Expr, ExprKind};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for unnecessary double parentheses.

clippy_lints/src/else_if_without_else.rs

@@ -1,9 +1,9 @@
 //! Lint on if expressions with an else if, but without a final else branch.
 
 use rustc::lint::in_external_macro;
+use rustc_ast::ast::{Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use syntax::ast::{Expr, ExprKind};
 
 use crate::utils::span_lint_and_help;
 

clippy_lints/src/enum_clike.rs

@@ -5,11 +5,11 @@ use crate::consts::{miri_to_const, Constant};
 use crate::utils::span_lint;
 use rustc::ty;
 use rustc::ty::util::IntTypeExt;
+use rustc_ast::ast::{IntTy, UintTy};
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::convert::TryFrom;
-use syntax::ast::{IntTy, UintTy};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for C-like enumerations that are

clippy_lints/src/enum_variants.rs

@@ -2,11 +2,11 @@
 
 use crate::utils::{camel_case, is_present_in_source};
 use crate::utils::{span_lint, span_lint_and_help};
+use rustc_ast::ast::{EnumDef, Item, ItemKind, VisibilityKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, Lint};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::Symbol;
-use syntax::ast::{EnumDef, Item, ItemKind, VisibilityKind};
 
 declare_clippy_lint! {
     /// **What it does:** Detects enumeration variants that are prefixed or suffixed

clippy_lints/src/excessive_bools.rs

@@ -1,8 +1,8 @@
 use crate::utils::{attr_by_name, in_macro, match_path_ast, span_lint_and_help};
+use rustc_ast::ast::{AssocItemKind, Extern, FnSig, Item, ItemKind, Ty, TyKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
-use syntax::ast::{AssocItemKind, Extern, FnSig, Item, ItemKind, Ty, TyKind};
 
 use std::convert::TryInto;
 

clippy_lints/src/explicit_write.rs

@@ -1,10 +1,10 @@
 use crate::utils::{is_expn_of, match_function_call, paths, span_lint, span_lint_and_sugg};
 use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use syntax::ast::LitKind;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `write!()` / `writeln()!` which can be

clippy_lints/src/float_literal.rs

@@ -2,12 +2,12 @@ use crate::utils::span_lint_and_sugg;
 use crate::utils::sugg::format_numeric_literal;
 use if_chain::if_chain;
 use rustc::ty;
+use rustc_ast::ast::{FloatTy, LitFloatType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::{f32, f64, fmt};
-use syntax::ast::{FloatTy, LitFloatType, LitKind};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for float literals with a precision greater

clippy_lints/src/floating_point_arithmetic.rs

@@ -11,10 +11,10 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
 
+use rustc_ast::ast;
 use std::f32::consts as f32_consts;
 use std::f64::consts as f64_consts;
 use sugg::{format_numeric_literal, Sugg};
-use syntax::ast;
 
 declare_clippy_lint! {
     /// **What it does:** Looks for floating-point expressions that

clippy_lints/src/format.rs

@@ -4,12 +4,12 @@ use crate::utils::{
     walk_ptrs_ty,
 };
 use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, MatchSource, PatKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use syntax::ast::LitKind;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for the use of `format!("string literal with no

clippy_lints/src/formatting.rs

@@ -1,10 +1,10 @@
 use crate::utils::{differing_macro_contexts, snippet_opt, span_lint_and_help, span_lint_and_note};
 use if_chain::if_chain;
 use rustc::lint::in_external_macro;
+use rustc_ast::ast::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use syntax::ast::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for use of the non-existent `=*`, `=!` and `=-`

clippy_lints/src/functions.rs

@@ -6,6 +6,7 @@ use crate::utils::{
 use rustc::hir::map::Map;
 use rustc::lint::in_external_macro;
 use rustc::ty::{self, Ty};
+use rustc_ast::ast::Attribute;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -15,7 +16,6 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_target::spec::abi::Abi;
-use syntax::ast::Attribute;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for functions with too many parameters.

clippy_lints/src/get_last_with_len.rs

@@ -2,13 +2,13 @@
 
 use crate::utils::{is_type_diagnostic_item, snippet_with_applicability, span_lint_and_sugg, SpanlessEq};
 use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::Symbol;
-use syntax::ast::LitKind;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for using `x.get(x.len() - 1)` instead of

clippy_lints/src/if_not_else.rs

@@ -2,9 +2,9 @@
 //! on the condition
 
 use rustc::lint::in_external_macro;
+use rustc_ast::ast::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use syntax::ast::{BinOpKind, Expr, ExprKind, UnOp};
 
 use crate::utils::span_lint_and_help;
 

clippy_lints/src/indexing_slicing.rs

@@ -3,10 +3,10 @@
 use crate::consts::{constant, Constant};
 use crate::utils::{higher, span_lint, span_lint_and_help};
 use rustc::ty;
+use rustc_ast::ast::RangeLimits;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use syntax::ast::RangeLimits;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for out of bounds array indexing with a constant