WIP: use symbols instead of strings

Author: oli-obk

clippy_lints/src/approx_const.rs

@@ -1,10 +1,13 @@
 use crate::utils::span_lint;
+use crate::utils::sym;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use rustc::{declare_lint_pass, declare_tool_lint};
 use std::f64::consts as f64;
-use syntax::ast::{FloatTy, Lit, LitKind};
+use syntax::ast::{FloatTy, LitKind};
 use syntax::symbol;
+use syntax::symbol::Symbol;
+use lazy_static::lazy_static;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for floating point literals that approximate
@@ -30,25 +33,27 @@ declare_clippy_lint! {
     "the approximate of a known float constant (in `std::fXX::consts`)"
 }
 
+lazy_static! {
 // Tuples are of the form (constant, name, min_digits)
-const KNOWN_CONSTS: &[(f64, &str, usize)] = &[
-    (f64::E, "E", 4),
-    (f64::FRAC_1_PI, "FRAC_1_PI", 4),
-    (f64::FRAC_1_SQRT_2, "FRAC_1_SQRT_2", 5),
-    (f64::FRAC_2_PI, "FRAC_2_PI", 5),
-    (f64::FRAC_2_SQRT_PI, "FRAC_2_SQRT_PI", 5),
-    (f64::FRAC_PI_2, "FRAC_PI_2", 5),
-    (f64::FRAC_PI_3, "FRAC_PI_3", 5),
-    (f64::FRAC_PI_4, "FRAC_PI_4", 5),
-    (f64::FRAC_PI_6, "FRAC_PI_6", 5),
-    (f64::FRAC_PI_8, "FRAC_PI_8", 5),
-    (f64::LN_10, "LN_10", 5),
-    (f64::LN_2, "LN_2", 5),
-    (f64::LOG10_E, "LOG10_E", 5),
-    (f64::LOG2_E, "LOG2_E", 5),
-    (f64::PI, "PI", 3),
-    (f64::SQRT_2, "SQRT_2", 5),
+static ref KNOWN_CONSTS: [(f64, Symbol, usize); 16] = [
+    (f64::E, *sym::E, 4),
+    (f64::FRAC_1_PI, *sym::FRAC_1_PI, 4),
+    (f64::FRAC_1_SQRT_2, *sym::FRAC_1_SQRT_2, 5),
+    (f64::FRAC_2_PI, *sym::FRAC_2_PI, 5),
+    (f64::FRAC_2_SQRT_PI, *sym::FRAC_2_SQRT_PI, 5),
+    (f64::FRAC_PI_2, *sym::FRAC_PI_2, 5),
+    (f64::FRAC_PI_3, *sym::FRAC_PI_3, 5),
+    (f64::FRAC_PI_4, *sym::FRAC_PI_4, 5),
+    (f64::FRAC_PI_6, *sym::FRAC_PI_6, 5),
+    (f64::FRAC_PI_8, *sym::FRAC_PI_8, 5),
+    (f64::LN_10, *sym::LN_10, 5),
+    (f64::LN_2, *sym::LN_2, 5),
+    (f64::LOG10_E, *sym::LOG10_E, 5),
+    (f64::LOG2_E, *sym::LOG2_E, 5),
+    (f64::PI, *sym::PI, 3),
+    (f64::SQRT_2, *sym::SQRT_2, 5),
 ];
+}
 
 declare_lint_pass!(ApproxConstant => [APPROX_CONSTANT]);
 
@@ -72,7 +77,7 @@ fn check_lit(cx: &LateContext<'_, '_>, lit: &LitKind, e: &Expr) {
 fn check_known_consts(cx: &LateContext<'_, '_>, e: &Expr, s: symbol::Symbol, module: &str) {
     let s = s.as_str();
     if s.parse::<f64>().is_ok() {
-        for &(constant, name, min_digits) in KNOWN_CONSTS {
+        for &(constant, name, min_digits) in KNOWN_CONSTS.iter() {
             if is_approx_const(constant, &s, min_digits) {
                 span_lint(
                     cx,

clippy_lints/src/assertions_on_constants.rs

@@ -6,6 +6,7 @@ use syntax_pos::Span;
 
 use crate::consts::{constant, Constant};
 use crate::utils::{in_macro_or_desugar, is_direct_expn_of, span_help_and_lint};
+use crate::utils::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `assert!(true)` and `assert!(false)` calls.
@@ -40,9 +41,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssertionsOnConstants {
             !in_macro_or_desugar(span)
         };
         if_chain! {
-            if let Some(assert_span) = is_direct_expn_of(e.span, "assert");
+            if let Some(assert_span) = is_direct_expn_of(e.span, *sym::assert);
             if !in_macro_or_desugar(assert_span)
-                || is_direct_expn_of(assert_span, "debug_assert")
+                || is_direct_expn_of(assert_span, *sym::debug_assert)
                     .map_or(false, debug_assert_not_in_macro_or_desugar);
             if let ExprKind::Unary(_, ref lit) = e.node;
             if let Some(bool_const) = constant(cx, cx.tables, lit);

clippy_lints/src/assign_ops.rs

@@ -9,6 +9,7 @@ use crate::utils::{
     get_trait_def_id, implements_trait, snippet_opt, span_lint_and_then, trait_ref_of_method, SpanlessEq,
 };
 use crate::utils::{higher, sugg};
+use syntax::symbol::Symbol;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `a = a op b` or `a = b commutative_op a`
@@ -88,8 +89,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
                              $($trait_name:ident),+) => {
                                 match $op {
                                     $(hir::BinOpKind::$trait_name => {
-                                        let [krate, module] = crate::utils::paths::OPS_MODULE;
-                                        let path = [krate, module, concat!(stringify!($trait_name), "Assign")];
+                                        let [krate, module] = *crate::utils::paths::OPS_MODULE;
+                                        let ident = {
+                                            *crate::utils::sym::assign::$trait_name
+                                        };
+                                        let path: [Symbol; 3] = [krate, module, ident];
                                         let trait_id = if let Some(trait_id) = get_trait_def_id($cx, &path) {
                                             trait_id
                                         } else {

clippy_lints/src/attrs.rs

@@ -3,8 +3,9 @@
 use crate::reexport::*;
 use crate::utils::{
     in_macro_or_desugar, is_present_in_source, last_line_of_span, paths, snippet_opt, span_lint, span_lint_and_sugg,
-    span_lint_and_then, without_block_comments,
+    span_lint_and_then, without_block_comments, match_def_path
 };
+use crate::utils::sym;
 use if_chain::if_chain;
 use rustc::hir::*;
 use rustc::lint::{
@@ -17,6 +18,7 @@ use rustc_errors::Applicability;
 use semver::Version;
 use syntax::ast::{AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
 use syntax::source_map::Span;
+use syntax::symbol::Symbol;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for items annotated with `#[inline(always)]`,
@@ -205,14 +207,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Attributes {
                     },
                     _ => {},
                 }
-                if items.is_empty() || !attr.check_name("deprecated") {
+                if items.is_empty() || !attr.check_name(*sym::deprecated) {
                     return;
                 }
                 for item in items {
                     if_chain! {
                         if let NestedMetaItem::MetaItem(mi) = &item;
                         if let MetaItemKind::NameValue(lit) = &mi.node;
-                        if mi.check_name("since");
+                        if mi.check_name(*sym::since);
                         then {
                             check_semver(cx, item.span(), lit);
                         }
@@ -228,7 +230,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Attributes {
         }
         match item.node {
             ItemKind::ExternCrate(..) | ItemKind::Use(..) => {
-                let skip_unused_imports = item.attrs.iter().any(|attr| attr.check_name("macro_use"));
+                let skip_unused_imports = item.attrs.iter().any(|attr| attr.check_name(*sym::macro_use));
 
                 for attr in &item.attrs {
                     if in_external_macro(cx.sess(), attr.span) {
@@ -243,15 +245,15 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Attributes {
                                     for lint in lint_list {
                                         match item.node {
                                             ItemKind::Use(..) => {
-                                                if is_word(lint, "unused_imports") || is_word(lint, "deprecated") {
+                                                if is_word(lint, *sym::unused_imports) || is_word(lint, *sym::deprecated) {
                                                     return;
                                                 }
                                             },
                                             ItemKind::ExternCrate(..) => {
-                                                if is_word(lint, "unused_imports") && skip_unused_imports {
+                                                if is_word(lint, *sym::unused_imports) && skip_unused_imports {
                                                     return;
                                                 }
-                                                if is_word(lint, "unused_extern_crates") {
+                                                if is_word(lint, *sym::unused_extern_crates) {
                                                     return;
                                                 }
                                             },
@@ -395,7 +397,7 @@ fn is_relevant_expr(cx: &LateContext<'_, '_>, tables: &ty::TypeckTables<'_>, exp
         ExprKind::Call(path_expr, _) => {
             if let ExprKind::Path(qpath) = &path_expr.node {
                 if let Some(fun_id) = tables.qpath_res(qpath, path_expr.hir_id).opt_def_id() {
-                    !cx.match_def_path(fun_id, &paths::BEGIN_PANIC)
+                    !match_def_path(cx, fun_id, &*paths::BEGIN_PANIC)
                 } else {
                     true
                 }
@@ -441,10 +443,10 @@ fn check_attrs(cx: &LateContext<'_, '_>, span: Span, name: Name, attrs: &[Attrib
         }
 
         if let Some(values) = attr.meta_item_list() {
-            if values.len() != 1 || !attr.check_name("inline") {
+            if values.len() != 1 || !attr.check_name(*sym::inline) {
                 continue;
             }
-            if is_word(&values[0], "always") {
+            if is_word(&values[0], *sym::always) {
                 span_lint(
                     cx,
                     INLINE_ALWAYS,
@@ -473,7 +475,7 @@ fn check_semver(cx: &LateContext<'_, '_>, span: Span, lit: &Lit) {
     );
 }
 
-fn is_word(nmi: &NestedMetaItem, expected: &str) -> bool {
+fn is_word(nmi: &NestedMetaItem, expected: Symbol) -> bool {
     if let NestedMetaItem::MetaItem(mi) = &nmi {
         mi.is_word() && mi.check_name(expected)
     } else {
@@ -487,16 +489,16 @@ impl EarlyLintPass for DeprecatedCfgAttribute {
     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) {
         if_chain! {
             // check cfg_attr
-            if attr.check_name("cfg_attr");
+            if attr.check_name(*sym::cfg_attr);
             if let Some(items) = attr.meta_item_list();
             if items.len() == 2;
             // check for `rustfmt`
             if let Some(feature_item) = items[0].meta_item();
-            if feature_item.check_name("rustfmt");
+            if feature_item.check_name(*sym::rustfmt);
             // check for `rustfmt_skip` and `rustfmt::skip`
             if let Some(skip_item) = &items[1].meta_item();
-            if skip_item.check_name("rustfmt_skip") ||
-                skip_item.path.segments.last().expect("empty path in attribute").ident.name == "skip";
+            if skip_item.check_name(*sym::rustfmt_skip) ||
+                skip_item.path.segments.last().expect("empty path in attribute").ident.name == *sym::skip;
             // Only lint outer attributes, because custom inner attributes are unstable
             // Tracking issue: https://github.com/rust-lang/rust/issues/54726
             if let AttrStyle::Outer = attr.style;

clippy_lints/src/booleans.rs

@@ -2,6 +2,7 @@ use crate::utils::{
     get_trait_def_id, implements_trait, in_macro, in_macro_or_desugar, match_type, paths, snippet_opt,
     span_lint_and_then, SpanlessEq,
 };
+use crate::utils::sym;
 use rustc::hir::intravisit::*;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
@@ -10,6 +11,8 @@ use rustc_data_structures::thin_vec::ThinVec;
 use rustc_errors::Applicability;
 use syntax::ast::LitKind;
 use syntax::source_map::{dummy_spanned, Span, DUMMY_SP};
+use syntax::symbol::Symbol;
+use lazy_static::lazy_static;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for boolean expressions that can be written more
@@ -49,8 +52,13 @@ declare_clippy_lint! {
     "boolean expressions that contain terminals which can be eliminated"
 }
 
+lazy_static! {
 // For each pairs, both orders are considered.
-const METHODS_WITH_NEGATION: [(&str, &str); 2] = [("is_some", "is_none"), ("is_err", "is_ok")];
+static ref METHODS_WITH_NEGATION: [(Symbol, Symbol); 2] = [
+    (*sym::is_some, *sym::is_none),
+    (*sym::is_err, *sym::is_ok),
+];
+}
 
 declare_lint_pass!(NonminimalBool => [NONMINIMAL_BOOL, LOGIC_BUG]);
 
@@ -187,16 +195,16 @@ impl<'a, 'tcx, 'v> SuggestContext<'a, 'tcx, 'v> {
             },
             ExprKind::MethodCall(path, _, args) if args.len() == 1 => {
                 let type_of_receiver = self.cx.tables.expr_ty(&args[0]);
-                if !match_type(self.cx, type_of_receiver, &paths::OPTION)
-                    && !match_type(self.cx, type_of_receiver, &paths::RESULT)
+                if !match_type(self.cx, type_of_receiver, &*paths::OPTION)
+                    && !match_type(self.cx, type_of_receiver, &*paths::RESULT)
                 {
                     return None;
                 }
                 METHODS_WITH_NEGATION
                     .iter()
                     .cloned()
                     .flat_map(|(a, b)| vec![(a, b), (b, a)])
-                    .find(|&(a, _)| a == path.ident.as_str())
+                    .find(|&(a, _)| a == path.ident.name)
                     .and_then(|(_, neg_method)| Some(format!("{}.{}()", self.snip(&args[0])?, neg_method)))
             },
             _ => None,
@@ -466,5 +474,5 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> {
 
 fn implements_ord<'a, 'tcx>(cx: &'a LateContext<'a, 'tcx>, expr: &Expr) -> bool {
     let ty = cx.tables.expr_ty(expr);
-    get_trait_def_id(cx, &paths::ORD).map_or(false, |id| implements_trait(cx, ty, id, &[]))
+    get_trait_def_id(cx, &*paths::ORD).map_or(false, |id| implements_trait(cx, ty, id, &[]))
 }

clippy_lints/src/bytecount.rs

@@ -2,6 +2,7 @@ use crate::utils::{
     contains_name, get_pat_name, match_type, paths, single_segment_path, snippet_with_applicability,
     span_lint_and_sugg, walk_ptrs_ty,
 };
+use crate::utils::sym;
 use if_chain::if_chain;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
@@ -37,10 +38,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {
     fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &Expr) {
         if_chain! {
             if let ExprKind::MethodCall(ref count, _, ref count_args) = expr.node;
-            if count.ident.name == "count";
+            if count.ident.name == *sym::count;
             if count_args.len() == 1;
             if let ExprKind::MethodCall(ref filter, _, ref filter_args) = count_args[0].node;
-            if filter.ident.name == "filter";
+            if filter.ident.name == *sym::filter;
             if filter_args.len() == 2;
             if let ExprKind::Closure(_, _, body_id, _, _) = filter_args[1].node;
             then {
@@ -52,7 +53,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {
                     if op.node == BinOpKind::Eq;
                     if match_type(cx,
                                walk_ptrs_ty(cx.tables.expr_ty(&filter_args[0])),
-                               &paths::SLICE_ITER);
+                               &*paths::SLICE_ITER);
                     then {
                         let needle = match get_path_name(l) {
                             Some(name) if check_arg(name, argname, r) => r,
@@ -67,7 +68,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {
                         let haystack = if let ExprKind::MethodCall(ref path, _, ref args) =
                                 filter_args[0].node {
                             let p = path.ident.name;
-                            if (p == "iter" || p == "iter_mut") && args.len() == 1 {
+                            if (p == *sym::iter || p == *sym::iter_mut) && args.len() == 1 {
                                 &args[0]
                             } else {
                                 &filter_args[0]

clippy_lints/src/cognitive_complexity.rs

@@ -9,6 +9,7 @@ use rustc::{declare_tool_lint, impl_lint_pass};
 use syntax::ast::Attribute;
 use syntax::source_map::Span;
 
+use crate::utils::sym;
 use crate::utils::{in_macro_or_desugar, is_allowed, match_type, paths, span_help_and_lint, LimitStack};
 
 declare_clippy_lint! {
@@ -71,7 +72,7 @@ impl CognitiveComplexity {
             ..
         } = helper;
         let ret_ty = cx.tables.node_type(expr.hir_id);
-        let ret_adjust = if match_type(cx, ret_ty, &paths::RESULT) {
+        let ret_adjust = if match_type(cx, ret_ty, &*paths::RESULT) {
             returns
         } else {
             returns / 2
@@ -118,7 +119,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CognitiveComplexity {
         hir_id: HirId,
     ) {
         let def_id = cx.tcx.hir().local_def_id_from_hir_id(hir_id);
-        if !cx.tcx.has_attr(def_id, "test") {
+        if !cx.tcx.has_attr(def_id, *sym::test) {
             self.check(cx, body, span);
         }
     }

clippy_lints/src/const_static_lifetime.rs

@@ -47,7 +47,7 @@ impl StaticConst {
                 if let Some(lifetime) = *optional_lifetime {
                     match borrow_type.ty.node {
                         TyKind::Path(..) | TyKind::Slice(..) | TyKind::Array(..) | TyKind::Tup(..) => {
-                            if lifetime.ident.name == "'static" {
+                            if lifetime.ident.name == syntax::symbol::keywords::StaticLifetime.name() {
                                 let snip = snippet(cx, borrow_type.ty.span, "<type>");
                                 let sugg = format!("&{}", snip);
                                 span_lint_and_then(

clippy_lints/src/copy_iterator.rs

@@ -36,7 +36,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CopyIterator {
         if let ItemKind::Impl(_, _, _, _, Some(ref trait_ref), _, _) = item.node {
             let ty = cx.tcx.type_of(cx.tcx.hir().local_def_id_from_hir_id(item.hir_id));
 
-            if is_copy(cx, ty) && match_path(&trait_ref.path, &paths::ITERATOR) {
+            if is_copy(cx, ty) && match_path(&trait_ref.path, &*paths::ITERATOR) {
                 span_note_and_lint(
                     cx,
                     COPY_ITERATOR,

clippy_lints/src/dbg_macro.rs

@@ -1,4 +1,5 @@
 use crate::utils::{snippet_opt, span_help_and_lint, span_lint_and_sugg};
+use crate::utils::sym;
 use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass};
 use rustc::{declare_lint_pass, declare_tool_lint};
 use rustc_errors::Applicability;
@@ -31,7 +32,7 @@ declare_lint_pass!(DbgMacro => [DBG_MACRO]);
 
 impl EarlyLintPass for DbgMacro {
     fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &ast::Mac) {
-        if mac.node.path == "dbg" {
+        if mac.node.path == *sym::dbg {
             if let Some(sugg) = tts_span(mac.node.tts.clone()).and_then(|span| snippet_opt(cx, span)) {
                 span_lint_and_sugg(
                     cx,