lint on statics that could be replaced by constants

Author: Oliver Schneider

src/etc/ziggurat_tables.py

@@ -87,7 +87,7 @@ def exp_f_inv(y):
 
 def render_static(name, type, value):
     # no space or
-    return 'pub static %s: %s =%s;\n' % (name, type, value)
+    return 'pub const %s: %s =%s;\n' % (name, type, value)
 
 # static `name`: [`type`, .. `len(values)`] =
 #     [values[0], ..., values[3],
@@ -101,7 +101,7 @@ def render_table(name, values):
         rows.append(', '.join('%.18f' % f for f in row))
 
     rendered = '\n    [%s]' % ',\n     '.join(rows)
-    return render_static(name, '[f64, .. %d]' % len(values), rendered)
+    return render_static(name, 'ZigTable' % len(values), rendered)
 
 
 with open('ziggurat_tables.rs', 'w') as f:

src/liballoc/boxed.rs

@@ -81,7 +81,7 @@ use core::raw::{TraitObject};
 #[lang = "exchange_heap"]
 #[unstable(feature = "alloc",
            reason = "may be renamed; uncertain about custom allocator design")]
-pub static HEAP: () = ();
+pub const HEAP: () = ();
 
 /// A pointer type for heap allocation.
 ///

src/libcollections/bit.rs

@@ -125,8 +125,8 @@ fn match_words <'a,'b>(a: &'a BitVec, b: &'b BitVec) -> (MatchWords<'a>, MatchWo
     }
 }
 
-static TRUE: bool = true;
-static FALSE: bool = false;
+const TRUE: &'static bool = &true;
+const FALSE: &'static bool = &false;
 
 /// The bitvector type.
 ///
@@ -172,9 +172,9 @@ impl Index<usize> for BitVec {
     #[inline]
     fn index(&self, i: usize) -> &bool {
         if self.get(i).expect("index out of bounds") {
-            &TRUE
+            TRUE
         } else {
-            &FALSE
+            FALSE
         }
     }
 }

src/libcollections/vec.rs

@@ -83,7 +83,7 @@ use borrow::{Cow, IntoCow};
 use super::range::RangeArgument;
 
 // FIXME- fix places which assume the max vector allowed has memory usize::MAX.
-static MAX_MEMORY_SIZE: usize = isize::MAX as usize;
+const MAX_MEMORY_SIZE: usize = isize::MAX as usize;
 
 /// A growable list type, written `Vec<T>` but pronounced 'vector.'
 ///

src/libcore/macros.rs

@@ -15,15 +15,15 @@ macro_rules! panic {
         panic!("explicit panic")
     );
     ($msg:expr) => ({
-        static _MSG_FILE_LINE: (&'static str, &'static str, u32) = ($msg, file!(), line!());
+        const _MSG_FILE_LINE: (&'static str, &'static str, u32) = ($msg, file!(), line!());
         ::core::panicking::panic(&_MSG_FILE_LINE)
     });
     ($fmt:expr, $($arg:tt)*) => ({
         // The leading _'s are to avoid dead code warnings if this is
         // used inside a dead function. Just `#[allow(dead_code)]` is
         // insufficient, since the user may have
         // `#[forbid(dead_code)]` and which cannot be overridden.
-        static _FILE_LINE: (&'static str, u32) = (file!(), line!());
+        const _FILE_LINE: (&'static str, u32) = (file!(), line!());
         ::core::panicking::panic_fmt(format_args!($fmt, $($arg)*), &_FILE_LINE)
     });
 }

src/libcore/num/flt2dec/strategy/dragon.rs

@@ -24,20 +24,19 @@ use num::flt2dec::estimator::estimate_scaling_factor;
 use num::flt2dec::bignum::Digit32 as Digit;
 use num::flt2dec::bignum::Big32x36 as Big;
 
-// FIXME(#22540) const ref to static array seems to ICE
-static POW10: [Digit; 10] = [1, 10, 100, 1000, 10000, 100000,
-                             1000000, 10000000, 100000000, 1000000000];
-static TWOPOW10: [Digit; 10] = [2, 20, 200, 2000, 20000, 200000,
-                                2000000, 20000000, 200000000, 2000000000];
+const POW10: [Digit; 10] = [1, 10, 100, 1000, 10000, 100000,
+                            1000000, 10000000, 100000000, 1000000000];
+const TWOPOW10: [Digit; 10] = [2, 20, 200, 2000, 20000, 200000,
+                               2000000, 20000000, 200000000, 2000000000];
 
 // precalculated arrays of `Digit`s for 10^(2^n)
-static POW10TO16: [Digit; 2] = [0x6fc10000, 0x2386f2];
-static POW10TO32: [Digit; 4] = [0, 0x85acef81, 0x2d6d415b, 0x4ee];
-static POW10TO64: [Digit; 7] = [0, 0, 0xbf6a1f01, 0x6e38ed64, 0xdaa797ed, 0xe93ff9f4, 0x184f03];
-static POW10TO128: [Digit; 14] =
+const POW10TO16: [Digit; 2] = [0x6fc10000, 0x2386f2];
+const POW10TO32: [Digit; 4] = [0, 0x85acef81, 0x2d6d415b, 0x4ee];
+const POW10TO64: [Digit; 7] = [0, 0, 0xbf6a1f01, 0x6e38ed64, 0xdaa797ed, 0xe93ff9f4, 0x184f03];
+const POW10TO128: [Digit; 14] =
     [0, 0, 0, 0, 0x2e953e01, 0x3df9909, 0xf1538fd, 0x2374e42f, 0xd3cff5ec, 0xc404dc08,
      0xbccdb0da, 0xa6337f19, 0xe91f2603, 0x24e];
-static POW10TO256: [Digit; 27] =
+const POW10TO256: [Digit; 27] =
     [0, 0, 0, 0, 0, 0, 0, 0, 0x982e7c01, 0xbed3875b, 0xd8d99f72, 0x12152f87, 0x6bde50c6,
      0xcf4a6e70, 0xd595d80f, 0x26b2716e, 0xadc666b0, 0x1d153624, 0x3c42d35a, 0x63ff540e,
      0xcc5573c0, 0x65f9ef17, 0x55bc28f2, 0x80dcc7f7, 0xf46eeddc, 0x5fdcefce, 0x553f7];
@@ -328,4 +327,3 @@ pub fn format_exact(d: &Decoded, buf: &mut [u8], limit: i16) -> (/*#digits*/ usi
 
     (len, k)
 }
-

src/libcore/num/flt2dec/strategy/grisu.rs

@@ -87,9 +87,9 @@ for i in xrange(-308, 333, 8):
     f = ((f << 64 >> (l-1)) + 1) >> 1; e += l - 64
     print '    (%#018x, %5d, %4d),' % (f, e, i)
 */
-// FIXME(#22540) const ref to static array seems to ICE
+
 #[doc(hidden)]
-pub static CACHED_POW10: [(u64, i16, i16); 81] = [ // (f, e, k)
+pub const CACHED_POW10: [(u64, i16, i16); 81] = [ // (f, e, k)
     (0xe61acf033d1a45df, -1087, -308),
     (0xab70fe17c79ac6ca, -1060, -300),
     (0xff77b1fcbebcdc4f, -1034, -292),
@@ -746,4 +746,3 @@ pub fn format_exact(d: &Decoded, buf: &mut [u8], limit: i16) -> (/*#digits*/ usi
         None => fallback(d, buf, limit),
     }
 }
-

src/libcore/str/mod.rs

@@ -1282,7 +1282,7 @@ fn run_utf8_validation_iterator(iter: &mut slice::Iter<u8>)
 }
 
 // https://tools.ietf.org/html/rfc3629
-static UTF8_CHAR_WIDTH: [u8; 256] = [
+const UTF8_CHAR_WIDTH: [u8; 256] = [
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x1F
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

src/liblog/directive.rs

@@ -17,7 +17,7 @@ pub struct LogDirective {
     pub level: u32,
 }
 
-pub static LOG_LEVEL_NAMES: [&'static str; 4] = ["ERROR", "WARN", "INFO",
+pub const LOG_LEVEL_NAMES: [&'static str; 4] = ["ERROR", "WARN", "INFO",
                                                "DEBUG"];
 
 /// Parse an individual log level that is either a number or a symbolic log level

src/liblog/macros.rs

@@ -50,14 +50,14 @@
 #[macro_export]
 macro_rules! log {
     ($lvl:expr, $($arg:tt)+) => ({
-        static LOC: ::log::LogLocation = ::log::LogLocation {
+        const LOC: &'static ::log::LogLocation = &::log::LogLocation {
             line: line!(),
             file: file!(),
             module_path: module_path!(),
         };
         let lvl = $lvl;
         if log_enabled!(lvl) {
-            ::log::log(lvl, &LOC, format_args!($($arg)+))
+            ::log::log(lvl, LOC, format_args!($($arg)+))
         }
     })
 }

src/librand/chacha.rs

@@ -33,7 +33,7 @@ pub struct ChaChaRng {
     index:   usize,                 // Index into state
 }
 
-static EMPTY: ChaChaRng = ChaChaRng {
+const EMPTY: ChaChaRng = ChaChaRng {
     buffer:  [0; STATE_WORDS],
     state:   [0; STATE_WORDS],
     index:   STATE_WORDS

src/librand/distributions/exponential.rs

@@ -46,8 +46,8 @@ impl Rand for Exp1 {
         }
 
         Exp1(ziggurat(rng, false,
-                      &ziggurat_tables::ZIG_EXP_X,
-                      &ziggurat_tables::ZIG_EXP_F,
+                      ziggurat_tables::ZIG_EXP_X,
+                      ziggurat_tables::ZIG_EXP_F,
                       pdf, zero_case))
     }
 }

src/librand/distributions/normal.rs

@@ -62,8 +62,8 @@ impl Rand for StandardNormal {
         StandardNormal(ziggurat(
             rng,
             true, // this is symmetric
-            &ziggurat_tables::ZIG_NORM_X,
-            &ziggurat_tables::ZIG_NORM_F,
+            ziggurat_tables::ZIG_NORM_X,
+            ziggurat_tables::ZIG_NORM_F,
             pdf, zero_case))
     }
 }

src/librand/distributions/ziggurat_tables.rs

@@ -12,8 +12,8 @@
 // algorithm. Autogenerated by `ziggurat_tables.py`.
 
 pub type ZigTable = &'static [f64; 257];
-pub static ZIG_NORM_R: f64 = 3.654152885361008796;
-pub static ZIG_NORM_X: [f64; 257] =
+pub const ZIG_NORM_R: f64 = 3.654152885361008796;
+pub const ZIG_NORM_X: ZigTable = &
     [3.910757959537090045, 3.654152885361008796, 3.449278298560964462, 3.320244733839166074,
      3.224575052047029100, 3.147889289517149969, 3.083526132001233044, 3.027837791768635434,
      2.978603279880844834, 2.934366867207854224, 2.894121053612348060, 2.857138730872132548,
@@ -79,7 +79,7 @@ pub static ZIG_NORM_X: [f64; 257] =
      0.487443966121754335, 0.463634336771763245, 0.437518402186662658, 0.408389134588000746,
      0.375121332850465727, 0.335737519180459465, 0.286174591747260509, 0.215241895913273806,
      0.000000000000000000];
-pub static ZIG_NORM_F: [f64; 257] =
+pub const ZIG_NORM_F: ZigTable = &
     [0.000477467764586655, 0.001260285930498598, 0.002609072746106363, 0.004037972593371872,
      0.005522403299264754, 0.007050875471392110, 0.008616582769422917, 0.010214971439731100,
      0.011842757857943104, 0.013497450601780807, 0.015177088307982072, 0.016880083152595839,
@@ -145,8 +145,8 @@ pub static ZIG_NORM_F: [f64; 257] =
      0.887984660763399880, 0.898095921906304051, 0.908726440060562912, 0.919991505048360247,
      0.932060075968990209, 0.945198953453078028, 0.959879091812415930, 0.977101701282731328,
      1.000000000000000000];
-pub static ZIG_EXP_R: f64 = 7.697117470131050077;
-pub static ZIG_EXP_X: [f64; 257] =
+pub const ZIG_EXP_R: f64 = 7.697117470131050077;
+pub const ZIG_EXP_X: ZigTable = &
     [8.697117470131052741, 7.697117470131050077, 6.941033629377212577, 6.478378493832569696,
      6.144164665772472667, 5.882144315795399869, 5.666410167454033697, 5.482890627526062488,
      5.323090505754398016, 5.181487281301500047, 5.054288489981304089, 4.938777085901250530,
@@ -212,7 +212,7 @@ pub static ZIG_EXP_X: [f64; 257] =
      0.253658363385912022, 0.233790483059674731, 0.212671510630966620, 0.189958689622431842,
      0.165127622564187282, 0.137304980940012589, 0.104838507565818778, 0.063852163815001570,
      0.000000000000000000];
-pub static ZIG_EXP_F: [f64; 257] =
+pub const ZIG_EXP_F: ZigTable = &
     [0.000167066692307963, 0.000454134353841497, 0.000967269282327174, 0.001536299780301573,
      0.002145967743718907, 0.002788798793574076, 0.003460264777836904, 0.004157295120833797,
      0.004877655983542396, 0.005619642207205489, 0.006381905937319183, 0.007163353183634991,

src/librand/isaac.rs

@@ -45,7 +45,7 @@ pub struct IsaacRng {
     c: w32,
 }
 
-static EMPTY: IsaacRng = IsaacRng {
+const EMPTY: IsaacRng = IsaacRng {
     cnt: 0,
     rsl: [w(0); RAND_SIZE_USIZE],
     mem: [w(0); RAND_SIZE_USIZE],
@@ -288,7 +288,7 @@ pub struct Isaac64Rng {
     c: w64,
 }
 
-static EMPTY_64: Isaac64Rng = Isaac64Rng {
+const EMPTY_64: Isaac64Rng = Isaac64Rng {
     cnt: 0,
     rsl: [w(0); RAND_SIZE_64],
     mem: [w(0); RAND_SIZE_64],

src/librbml/lib.rs

@@ -209,7 +209,7 @@ pub enum EbmlEncoderTag {
 const NUM_TAGS: usize = 0x1000;
 const NUM_IMPLICIT_TAGS: usize = 0x0e;
 
-static TAG_IMPLICIT_LEN: [i8; NUM_IMPLICIT_TAGS] = [
+const TAG_IMPLICIT_LEN: [i8; NUM_IMPLICIT_TAGS] = [
     1, 2, 4, 8, // EsU*
     1, 2, 4, 8, // ESI*
     1, // EsBool
@@ -334,7 +334,7 @@ pub mod reader {
         // most significant bit is set etc. we can replace up to three
         // "and+branch" with a single table lookup which gives us a measured
         // speedup of around 2x on x86_64.
-        static SHIFT_MASK_TABLE: [(usize, u32); 16] = [
+        const SHIFT_MASK_TABLE: [(usize, u32); 16] = [
             (0, 0x0), (0, 0x0fffffff),
             (8, 0x1fffff), (8, 0x1fffff),
             (16, 0x3fff), (16, 0x3fff), (16, 0x3fff), (16, 0x3fff),

src/librustc/lint/mod.rs

@@ -88,10 +88,14 @@ macro_rules! lint_initializer {
 macro_rules! declare_lint {
     // FIXME(#14660): deduplicate
     (pub $name:ident, $level:ident, $desc:expr) => (
+        // cannot be const, otherwise random lints fail to lint
+        #[cfg_attr(not(stage0), allow(static_could_be_const))]
         pub static $name: &'static ::rustc::lint::Lint
             = &lint_initializer!($name, $level, $desc);
     );
     ($name:ident, $level:ident, $desc:expr) => (
+        // cannot be const, otherwise random lints fail to lint
+        #[cfg_attr(not(stage0), allow(static_could_be_const))]
         static $name: &'static ::rustc::lint::Lint
             = &lint_initializer!($name, $level, $desc);
     );
@@ -101,9 +105,9 @@ macro_rules! declare_lint {
 #[macro_export]
 macro_rules! lint_array { ($( $lint:expr ),*) => (
     {
-        #[allow(non_upper_case_globals)]
-        static array: LintArray = &[ $( &$lint ),* ];
-        array
+        #[cfg_attr(not(stage0), allow(static_could_be_const))]
+        static ARRAY: LintArray = &[ $( &$lint ),* ];
+        ARRAY
     }
 ) }
 

src/librustc/middle/resolve_lifetime.rs

@@ -91,14 +91,14 @@ enum ScopeChain<'a> {
 
 type Scope<'a> = &'a ScopeChain<'a>;
 
-static ROOT_SCOPE: ScopeChain<'static> = RootScope;
+const ROOT_SCOPE: &'static ScopeChain<'static> = &RootScope;
 
 pub fn krate(sess: &Session, krate: &ast::Crate, def_map: &DefMap) -> NamedRegionMap {
     let mut named_region_map = NodeMap();
     visit::walk_crate(&mut LifetimeContext {
         sess: sess,
         named_region_map: &mut named_region_map,
-        scope: &ROOT_SCOPE,
+        scope: ROOT_SCOPE,
         def_map: def_map,
         trait_ref_hack: false,
         labels_in_fn: vec![],

src/librustc_back/sha2.rs

@@ -407,7 +407,7 @@ impl Engine256State {
     }
 }
 
-static K32: [u32; 64] = [
+const K32: [u32; 64] = [
     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
     0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
@@ -514,7 +514,7 @@ impl Digest for Sha256 {
     fn output_bits(&self) -> usize { 256 }
 }
 
-static H256: [u32; 8] = [
+const H256: [u32; 8] = [
     0x6a09e667,
     0xbb67ae85,
     0x3c6ef372,

src/librustc_lint/builtin.rs

@@ -34,7 +34,7 @@ use middle::subst::Substs;
 use middle::ty::{self, Ty};
 use middle::{def, pat_util, stability};
 use middle::const_eval::{eval_const_expr_partial, const_int, const_uint};
-use middle::cfg;
+use middle::{cfg, check_const};
 use util::ppaux::ty_to_string;
 use util::nodemap::{FnvHashMap, NodeSet};
 use lint::{Level, Context, LintPass, LintArray, Lint};
@@ -107,6 +107,33 @@ declare_lint! {
     "shift exceeds the type's number of bits"
 }
 
+declare_lint! {
+    STATIC_COULD_BE_CONST,
+    Warn,
+    "static declaration could be replaced by a const declaration"
+}
+
+#[derive(Copy, Clone)]
+pub struct StaticCouldBeConst;
+
+impl LintPass for StaticCouldBeConst {
+    fn get_lints(&self) -> LintArray {
+        lint_array!(STATIC_COULD_BE_CONST)
+    }
+
+    fn check_item(&mut self, cx: &Context, it: &ast::Item) {
+        let expr = match it.node {
+            ast::ItemStatic(_, ast::MutImmutable, ref expr) => expr,
+            _ => return,
+        };
+        let const_qualif = cx.tcx.const_qualif_map.borrow()[&expr.id];
+        if const_qualif.contains(check_const::ConstQualif::MUTABLE_MEM) {
+            return;
+        }
+        cx.span_lint(STATIC_COULD_BE_CONST, it.span, "static could be replaced by a const");
+    }
+}
+
 #[derive(Copy, Clone)]
 pub struct TypeLimits {
     /// Id of the last visited negated expression

src/librustc_lint/lib.rs

@@ -110,6 +110,7 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
                  PluginAsLibrary,
                  DropWithReprExtern,
                  MutableTransmutes,
+                 StaticCouldBeConst,
                  );
 
     add_builtin_with_new!(sess,

src/librustc_trans/trans/builder.rs

@@ -33,8 +33,8 @@ pub struct Builder<'a, 'tcx: 'a> {
 // This is a really awful way to get a zero-length c-string, but better (and a
 // lot more efficient) than doing str::as_c_str("", ...) every time.
 pub fn noname() -> *const c_char {
-    static CNULL: c_char = 0;
-    &CNULL
+    const CNULL: &'static c_char = &0;
+    CNULL
 }
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {