Remove syntax and syntax_pos thread locals

src/Cargo.lock

@@ -2432,6 +2432,7 @@ dependencies = [
  "rustc_cratesio_shim 0.0.0",
  "rustc_data_structures 0.0.0",
  "rustc_errors 0.0.0",
+ "scoped-tls 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "serialize 0.0.0",
  "syntax_pos 0.0.0",
 ]
@@ -2453,6 +2454,7 @@ name = "syntax_pos"
 version = "0.0.0"
 dependencies = [
  "rustc_data_structures 0.0.0",
+ "scoped-tls 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "serialize 0.0.0",
  "unicode-width 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

src/librustc/session/config.rs

@@ -2391,6 +2391,7 @@ mod tests {
     use super::{Externs, OutputType, OutputTypes};
     use rustc_back::{PanicStrategy, RelroLevel};
     use syntax::symbol::Symbol;
+    use syntax;
 
     fn optgroups() -> getopts::Options {
         let mut opts = getopts::Options::new();
@@ -2411,6 +2412,7 @@ mod tests {
     // When the user supplies --test we should implicitly supply --cfg test
     #[test]
     fn test_switch_implies_cfg_test() {
+        syntax::with_globals(|| {
             let matches = &match optgroups().parse(&["--test".to_string()]) {
                 Ok(m) => m,
                 Err(f) => panic!("test_switch_implies_cfg_test: {}", f),
@@ -2420,13 +2422,16 @@ mod tests {
             let sess = build_session(sessopts, None, registry);
             let cfg = build_configuration(&sess, cfg);
             assert!(cfg.contains(&(Symbol::intern("test"), None)));
+        });
     }
 
     // When the user supplies --test and --cfg test, don't implicitly add
     // another --cfg test
     #[test]
     fn test_switch_implies_cfg_test_unless_cfg_test() {
-        let matches = &match optgroups().parse(&["--test".to_string(), "--cfg=test".to_string()]) {
+        syntax::with_globals(|| {
+            let matches = &match optgroups().parse(&["--test".to_string(),
+                                                     "--cfg=test".to_string()]) {
                 Ok(m) => m,
                 Err(f) => panic!("test_switch_implies_cfg_test_unless_cfg_test: {}", f),
             };
@@ -2437,19 +2442,20 @@ mod tests {
             let mut test_items = cfg.iter().filter(|&&(name, _)| name == "test");
             assert!(test_items.next().is_some());
             assert!(test_items.next().is_none());
+        });
     }
 
     #[test]
     fn test_can_print_warnings() {
-        {
+        syntax::with_globals(|| {
             let matches = optgroups().parse(&["-Awarnings".to_string()]).unwrap();
             let registry = errors::registry::Registry::new(&[]);
             let (sessopts, _) = build_session_options_and_crate_config(&matches);
             let sess = build_session(sessopts, None, registry);
             assert!(!sess.diagnostic().flags.can_emit_warnings);
-        }
+        });
 
-        {
+        syntax::with_globals(|| {
             let matches = optgroups()
                 .parse(&["-Awarnings".to_string(), "-Dwarnings".to_string()])
                 .unwrap();
@@ -2457,15 +2463,15 @@ mod tests {
             let (sessopts, _) = build_session_options_and_crate_config(&matches);
             let sess = build_session(sessopts, None, registry);
             assert!(sess.diagnostic().flags.can_emit_warnings);
-        }
+        });
 
-        {
+        syntax::with_globals(|| {
             let matches = optgroups().parse(&["-Adead_code".to_string()]).unwrap();
             let registry = errors::registry::Registry::new(&[]);
             let (sessopts, _) = build_session_options_and_crate_config(&matches);
             let sess = build_session(sessopts, None, registry);
             assert!(sess.diagnostic().flags.can_emit_warnings);
-        }
+        });
     }
 
     #[test]

src/librustc_driver/lib.rs

@@ -447,6 +447,17 @@ pub fn run_compiler<'a>(args: &[String],
                         file_loader: Option<Box<FileLoader + 'static>>,
                         emitter_dest: Option<Box<Write + Send>>)
                         -> (CompileResult, Option<Session>)
+{
+    syntax::with_globals(|| {
+        run_compiler_impl(args, callbacks, file_loader, emitter_dest)
+    })
+}
+
+fn run_compiler_impl<'a>(args: &[String],
+                         callbacks: &mut CompilerCalls<'a>,
+                         file_loader: Option<Box<FileLoader + 'static>>,
+                         emitter_dest: Option<Box<Write + Send>>)
+                         -> (CompileResult, Option<Session>)
 {
     macro_rules! do_or_return {($expr: expr, $sess: expr) => {
         match $expr {

src/librustc_driver/test.rs

@@ -29,6 +29,7 @@ use rustc::hir::map as hir_map;
 use rustc::session::{self, config};
 use rustc::session::config::{OutputFilenames, OutputTypes};
 use rustc_data_structures::sync::Lrc;
+use syntax;
 use syntax::ast;
 use syntax::abi::Abi;
 use syntax::codemap::{CodeMap, FilePathMapping, FileName};
@@ -93,6 +94,16 @@ fn errors(msgs: &[&str]) -> (Box<Emitter + Send>, usize) {
 }
 
 fn test_env<F>(source_string: &str,
+               args: (Box<Emitter + Send>, usize),
+               body: F)
+    where F: FnOnce(Env)
+{
+    syntax::with_globals(|| {
+        test_env_impl(source_string, args, body)
+    });
+}
+
+fn test_env_impl<F>(source_string: &str,
                     (emitter, expected_err_count): (Box<Emitter + Send>, usize),
                     body: F)
     where F: FnOnce(Env)

src/librustdoc/clean/cfg.rs

@@ -398,6 +398,7 @@ mod test {
     use syntax::ast::*;
     use syntax::codemap::dummy_spanned;
     use syntax_pos::DUMMY_SP;
+    use syntax::with_globals;
 
     fn word_cfg(s: &str) -> Cfg {
         Cfg::Cfg(Symbol::intern(s), None)
@@ -409,6 +410,7 @@ mod test {
 
     #[test]
     fn test_cfg_not() {
+        with_globals(|| {
             assert_eq!(!Cfg::False, Cfg::True);
             assert_eq!(!Cfg::True, Cfg::False);
             assert_eq!(!word_cfg("test"), Cfg::Not(Box::new(word_cfg("test"))));
@@ -421,10 +423,12 @@ mod test {
                 Cfg::Not(Box::new(Cfg::Any(vec![word_cfg("a"), word_cfg("b")])))
             );
             assert_eq!(!Cfg::Not(Box::new(word_cfg("test"))), word_cfg("test"));
+        })
     }
 
     #[test]
     fn test_cfg_and() {
+        with_globals(|| {
             let mut x = Cfg::False;
             x &= Cfg::True;
             assert_eq!(x, Cfg::False);
@@ -471,10 +475,12 @@ mod test {
                 word_cfg("a") & word_cfg("b") & word_cfg("c"),
                 Cfg::All(vec![word_cfg("a"), word_cfg("b"), word_cfg("c")])
             );
+        })
     }
 
     #[test]
     fn test_cfg_or() {
+        with_globals(|| {
             let mut x = Cfg::True;
             x |= Cfg::False;
             assert_eq!(x, Cfg::True);
@@ -521,10 +527,12 @@ mod test {
                 word_cfg("a") | word_cfg("b") | word_cfg("c"),
                 Cfg::Any(vec![word_cfg("a"), word_cfg("b"), word_cfg("c")])
             );
+        })
     }
 
     #[test]
     fn test_parse_ok() {
+        with_globals(|| {
             let mi = MetaItem {
                 name: Symbol::intern("all"),
                 node: MetaItemKind::Word,
@@ -648,10 +656,12 @@ mod test {
                 span: DUMMY_SP,
             };
             assert_eq!(Cfg::parse(&mi), Ok(word_cfg("a") & word_cfg("b") & word_cfg("c")));
+        })
     }
 
     #[test]
     fn test_parse_err() {
+        with_globals(|| {
             let mi = MetaItem {
                 name: Symbol::intern("foo"),
                 node: MetaItemKind::NameValue(dummy_spanned(LitKind::Bool(false))),
@@ -745,10 +755,12 @@ mod test {
                 span: DUMMY_SP,
             };
             assert!(Cfg::parse(&mi).is_err());
+        })
     }
 
     #[test]
     fn test_render_short_html() {
+        with_globals(|| {
             assert_eq!(
                 word_cfg("unix").render_short_html(),
                 "Unix"
@@ -812,10 +824,12 @@ mod test {
                 ).render_short_html(),
                 "(Debug-assertions enabled or Windows) and Unix"
             );
+        })
     }
 
     #[test]
     fn test_render_long_html() {
+        with_globals(|| {
             assert_eq!(
                 word_cfg("unix").render_long_html(),
                 "This is supported on <strong>Unix</strong> only."
@@ -848,15 +862,15 @@ mod test {
                 (
                     word_cfg("unix") & word_cfg("windows") & word_cfg("debug_assertions")
                 ).render_long_html(),
-            "This is supported on <strong>Unix and Windows and debug-assertions enabled</strong> \
+                "This is supported on <strong>Unix and Windows and debug-assertions enabled\
-                only."
+                 </strong> only."
             );
             assert_eq!(
                 (
                     word_cfg("unix") | word_cfg("windows") | word_cfg("debug_assertions")
                 ).render_long_html(),
-            "This is supported on <strong>Unix or Windows or debug-assertions enabled</strong> \
+                "This is supported on <strong>Unix or Windows or debug-assertions enabled\
-                only."
+                 </strong> only."
             );
             assert_eq!(
                 (
@@ -870,7 +884,8 @@ mod test {
                     (word_cfg("unix") & name_value_cfg("target_arch", "x86_64")) |
                     (word_cfg("windows") & name_value_cfg("target_pointer_width", "64"))
                 ).render_long_html(),
-            "This is supported on <strong>Unix and x86-64, or Windows and 64-bit</strong> only."
+                "This is supported on <strong>Unix and x86-64, or Windows and 64-bit</strong> \
+                 only."
             );
             assert_eq!(
                 (!(word_cfg("unix") & word_cfg("windows"))).render_long_html(),
@@ -880,8 +895,9 @@ mod test {
                 (
                     (word_cfg("debug_assertions") | word_cfg("windows")) & word_cfg("unix")
                 ).render_long_html(),
-            "This is supported on <strong>(debug-assertions enabled or Windows) and Unix</strong> \
+                "This is supported on <strong>(debug-assertions enabled or Windows) and Unix\
-                only."
+                </strong> only."
             );
+        })
     }
 }

src/librustdoc/lib.rs

@@ -102,7 +102,9 @@ pub fn main() {
     const STACK_SIZE: usize = 32_000_000; // 32MB
     env_logger::init();
     let res = std::thread::Builder::new().stack_size(STACK_SIZE).spawn(move || {
+        syntax::with_globals(move || {
             get_args().map(|args| main_args(&args)).unwrap_or(1)
+        })
     }).unwrap().join().unwrap_or(101);
     process::exit(res as i32);
 }
@@ -554,7 +556,8 @@ where R: 'static + Send, F: 'static + Send + FnOnce(Output) -> R {
     });
 
     let (tx, rx) = channel();
-    rustc_driver::monitor(move || {
+
+    rustc_driver::monitor(move || syntax::with_globals(move || {
         use rustc::session::config::Input;
 
         let (mut krate, renderinfo) =
@@ -623,7 +626,7 @@ where R: 'static + Send, F: 'static + Send + FnOnce(Output) -> R {
         let krate = pm.run_plugins(krate);
 
         tx.send(f(Output { krate: krate, renderinfo: renderinfo, passes: passes })).unwrap();
-    });
+    }));
     rx.recv().unwrap()
 }
 

src/librustdoc/test.rs

@@ -35,6 +35,7 @@ use rustc_resolve::MakeGlobMap;
 use syntax::ast;
 use syntax::codemap::CodeMap;
 use syntax::feature_gate::UnstableFeatures;
+use syntax::with_globals;
 use syntax_pos::{BytePos, DUMMY_SP, Pos, Span, FileName};
 use errors;
 use errors::emitter::ColorConfig;
@@ -518,7 +519,7 @@ impl Collector {
                 let panic = io::set_panic(None);
                 let print = io::set_print(None);
                 match {
-                    rustc_driver::in_rustc_thread(move || {
+                    rustc_driver::in_rustc_thread(move || with_globals(move || {
                         io::set_panic(panic);
                         io::set_print(print);
                         run_test(&test,
@@ -536,7 +537,7 @@ impl Collector {
                                  &opts,
                                  maybe_sysroot,
                                  linker)
-                    })
+                    }))
                 } {
                     Ok(()) => (),
                     Err(err) => panic::resume_unwind(err),

src/libsyntax/Cargo.toml

@@ -12,6 +12,7 @@ crate-type = ["dylib"]
 bitflags = "1.0"
 serialize = { path = "../libserialize" }
 log = "0.4"
+scoped-tls = "0.1"
 syntax_pos = { path = "../libsyntax_pos" }
 rustc_cratesio_shim = { path = "../librustc_cratesio_shim" }
 rustc_errors = { path = "../librustc_errors" }

src/libsyntax/attr.rs

@@ -30,15 +30,10 @@ use ptr::P;
 use symbol::Symbol;
 use tokenstream::{TokenStream, TokenTree, Delimited};
 use util::ThinVec;
+use GLOBALS;
 
-use std::cell::RefCell;
 use std::iter;
 
-thread_local! {
-    static USED_ATTRS: RefCell<Vec<u64>> = RefCell::new(Vec::new());
-    static KNOWN_ATTRS: RefCell<Vec<u64>> = RefCell::new(Vec::new());
-}
-
 enum AttrError {
     MultipleItem(Name),
     UnknownMetaItem(Name),
@@ -65,22 +60,24 @@ fn handle_errors(diag: &Handler, span: Span, error: AttrError) {
 pub fn mark_used(attr: &Attribute) {
     debug!("Marking {:?} as used.", attr);
     let AttrId(id) = attr.id;
-    USED_ATTRS.with(|slot| {
+    GLOBALS.with(|globals| {
+        let mut slot = globals.used_attrs.lock();
         let idx = (id / 64) as usize;
         let shift = id % 64;
-        if slot.borrow().len() <= idx {
+        if slot.len() <= idx {
-            slot.borrow_mut().resize(idx + 1, 0);
+            slot.resize(idx + 1, 0);
         }
-        slot.borrow_mut()[idx] |= 1 << shift;
+        slot[idx] |= 1 << shift;
     });
 }
 
 pub fn is_used(attr: &Attribute) -> bool {
     let AttrId(id) = attr.id;
-    USED_ATTRS.with(|slot| {
+    GLOBALS.with(|globals| {
+        let slot = globals.used_attrs.lock();
         let idx = (id / 64) as usize;
         let shift = id % 64;
-        slot.borrow().get(idx).map(|bits| bits & (1 << shift) != 0)
+        slot.get(idx).map(|bits| bits & (1 << shift) != 0)
             .unwrap_or(false)
     })
 }
@@ -88,22 +85,24 @@ pub fn is_used(attr: &Attribute) -> bool {
 pub fn mark_known(attr: &Attribute) {
     debug!("Marking {:?} as known.", attr);
     let AttrId(id) = attr.id;
-    KNOWN_ATTRS.with(|slot| {
+    GLOBALS.with(|globals| {
+        let mut slot = globals.known_attrs.lock();
         let idx = (id / 64) as usize;
         let shift = id % 64;
-        if slot.borrow().len() <= idx {
+        if slot.len() <= idx {
-            slot.borrow_mut().resize(idx + 1, 0);
+            slot.resize(idx + 1, 0);
         }
-        slot.borrow_mut()[idx] |= 1 << shift;
+        slot[idx] |= 1 << shift;
     });
 }
 
 pub fn is_known(attr: &Attribute) -> bool {
     let AttrId(id) = attr.id;
-    KNOWN_ATTRS.with(|slot| {
+    GLOBALS.with(|globals| {
+        let slot = globals.known_attrs.lock();
         let idx = (id / 64) as usize;
         let shift = id % 64;
-        slot.borrow().get(idx).map(|bits| bits & (1 << shift) != 0)
+        slot.get(idx).map(|bits| bits & (1 << shift) != 0)
             .unwrap_or(false)
     })
 }

src/libsyntax/fold.rs

@@ -1386,6 +1386,7 @@ mod tests {
     use util::parser_testing::{string_to_crate, matches_codepattern};
     use print::pprust;
     use fold;
+    use with_globals;
     use super::*;
 
     // this version doesn't care about getting comments or docstrings in.
@@ -1423,6 +1424,7 @@ mod tests {
 
     // make sure idents get transformed everywhere
     #[test] fn ident_transformation () {
+        with_globals(|| {
             let mut zz_fold = ToZzIdentFolder;
             let ast = string_to_crate(
                 "#[a] mod b {fn c (d : e, f : g) {h!(i,j,k);l;m}}".to_string());
@@ -1432,10 +1434,12 @@ mod tests {
                 "matches_codepattern",
                 pprust::to_string(|s| fake_print_crate(s, &folded_crate)),
                 "#[zz]mod zz{fn zz(zz:zz,zz:zz){zz!(zz,zz,zz);zz;zz}}".to_string());
+        })
     }
 
     // even inside macro defs....
     #[test] fn ident_transformation_in_defs () {
+        with_globals(|| {
             let mut zz_fold = ToZzIdentFolder;
             let ast = string_to_crate(
                 "macro_rules! a {(b $c:expr $(d $e:token)f+ => \
@@ -1446,5 +1450,6 @@ mod tests {
                 "matches_codepattern",
                 pprust::to_string(|s| fake_print_crate(s, &folded_crate)),
                 "macro_rules! zz((zz$zz:zz$(zz $zz:zz)zz+=>(zz$(zz$zz$zz)+)));".to_string());
+        })
     }
 }

src/libsyntax/lib.rs

@@ -39,9 +39,12 @@ extern crate std_unicode;
 pub extern crate rustc_errors as errors;
 extern crate syntax_pos;
 extern crate rustc_data_structures;
+#[macro_use] extern crate scoped_tls;
 
 extern crate serialize as rustc_serialize; // used by deriving
 
+use rustc_data_structures::sync::Lock;
+
 // A variant of 'try!' that panics on an Err. This is used as a crutch on the
 // way towards a non-panic!-prone parser. It should be used for fatal parsing
 // errors; eventually we plan to convert all code using panictry to just use
@@ -72,6 +75,33 @@ macro_rules! unwrap_or {
     }
 }
 
+struct Globals {
+    used_attrs: Lock<Vec<u64>>,
+    known_attrs: Lock<Vec<u64>>,
+    syntax_pos_globals: syntax_pos::Globals,
+}
+
+impl Globals {
+    fn new() -> Globals {
+        Globals {
+            used_attrs: Lock::new(Vec::new()),
+            known_attrs: Lock::new(Vec::new()),
+            syntax_pos_globals: syntax_pos::Globals::new(),
+        }
+    }
+}
+
+pub fn with_globals<F, R>(f: F) -> R
+    where F: FnOnce() -> R
+{
+    let globals = Globals::new();
+    GLOBALS.set(&globals, || {
+        syntax_pos::GLOBALS.set(&globals.syntax_pos_globals, f)
+    })
+}
+
+scoped_thread_local!(static GLOBALS: Globals);
+
 #[macro_use]
 pub mod diagnostics {
     #[macro_use]

src/libsyntax/parse/lexer/mod.rs

@@ -1766,6 +1766,7 @@ mod tests {
     use std::path::PathBuf;
     use diagnostics::plugin::ErrorMap;
     use rustc_data_structures::sync::Lock;
+    use with_globals;
     fn mk_sess(cm: Lrc<CodeMap>) -> ParseSess {
         let emitter = errors::emitter::EmitterWriter::new(Box::new(io::sink()),
                                                           Some(cm.clone()),
@@ -1794,6 +1795,7 @@ mod tests {
 
     #[test]
     fn t1() {
+        with_globals(|| {
             let cm = Lrc::new(CodeMap::new(FilePathMapping::empty()));
             let sh = mk_sess(cm.clone());
             let mut string_reader = setup(&cm,
@@ -1821,6 +1823,7 @@ mod tests {
             assert_eq!(tok3, tok4);
             // the lparen is already read:
             assert_eq!(string_reader.pos.clone(), BytePos(29))
+        })
     }
 
     // check that the given reader produces the desired stream
@@ -1838,80 +1841,99 @@ mod tests {
 
     #[test]
     fn doublecolonparsing() {
+        with_globals(|| {
             let cm = Lrc::new(CodeMap::new(FilePathMapping::empty()));
             let sh = mk_sess(cm.clone());
             check_tokenization(setup(&cm, &sh, "a b".to_string()),
                             vec![mk_ident("a"), token::Whitespace, mk_ident("b")]);
+        })
     }
 
     #[test]
     fn dcparsing_2() {
+        with_globals(|| {
             let cm = Lrc::new(CodeMap::new(FilePathMapping::empty()));
             let sh = mk_sess(cm.clone());
             check_tokenization(setup(&cm, &sh, "a::b".to_string()),
                             vec![mk_ident("a"), token::ModSep, mk_ident("b")]);
+        })
     }
 
     #[test]
     fn dcparsing_3() {
+        with_globals(|| {
             let cm = Lrc::new(CodeMap::new(FilePathMapping::empty()));
             let sh = mk_sess(cm.clone());
             check_tokenization(setup(&cm, &sh, "a ::b".to_string()),
                             vec![mk_ident("a"), token::Whitespace, token::ModSep, mk_ident("b")]);
+        })
     }
 
     #[test]
     fn dcparsing_4() {
+        with_globals(|| {
             let cm = Lrc::new(CodeMap::new(FilePathMapping::empty()));
             let sh = mk_sess(cm.clone());
             check_tokenization(setup(&cm, &sh, "a:: b".to_string()),
                             vec![mk_ident("a"), token::ModSep, token::Whitespace, mk_ident("b")]);
+        })
     }
 
     #[test]
     fn character_a() {
+        with_globals(|| {
             let cm = Lrc::new(CodeMap::new(FilePathMapping::empty()));
             let sh = mk_sess(cm.clone());
             assert_eq!(setup(&cm, &sh, "'a'".to_string()).next_token().tok,
                     token::Literal(token::Char(Symbol::intern("a")), None));
+        })
     }
 
     #[test]
     fn character_space() {
+        with_globals(|| {
             let cm = Lrc::new(CodeMap::new(FilePathMapping::empty()));
             let sh = mk_sess(cm.clone());
             assert_eq!(setup(&cm, &sh, "' '".to_string()).next_token().tok,
                     token::Literal(token::Char(Symbol::intern(" ")), None));
+        })
     }
 
     #[test]
     fn character_escaped() {
+        with_globals(|| {
             let cm = Lrc::new(CodeMap::new(FilePathMapping::empty()));
             let sh = mk_sess(cm.clone());
             assert_eq!(setup(&cm, &sh, "'\\n'".to_string()).next_token().tok,
                     token::Literal(token::Char(Symbol::intern("\\n")), None));
+        })
     }
 
     #[test]
     fn lifetime_name() {
+        with_globals(|| {
             let cm = Lrc::new(CodeMap::new(FilePathMapping::empty()));
             let sh = mk_sess(cm.clone());
             assert_eq!(setup(&cm, &sh, "'abc".to_string()).next_token().tok,
                     token::Lifetime(Ident::from_str("'abc")));
+        })
     }
 
     #[test]
     fn raw_string() {
+        with_globals(|| {
             let cm = Lrc::new(CodeMap::new(FilePathMapping::empty()));
             let sh = mk_sess(cm.clone());
             assert_eq!(setup(&cm, &sh, "r###\"\"#a\\b\x00c\"\"###".to_string())
                         .next_token()
                         .tok,
                     token::Literal(token::StrRaw(Symbol::intern("\"#a\\b\x00c\""), 3), None));
+        })
     }
 
     #[test]
     fn literal_suffixes() {
+        with_globals(|| {
             let cm = Lrc::new(CodeMap::new(FilePathMapping::empty()));
             let sh = mk_sess(cm.clone());
             macro_rules! test {
@@ -1945,6 +1967,7 @@ mod tests {
             assert_eq!(setup(&cm, &sh, "br###\"raw\"###suffix".to_string()).next_token().tok,
                     token::Literal(token::ByteStrRaw(Symbol::intern("raw"), 3),
                                     Some(Symbol::intern("suffix"))));
+        })
     }
 
     #[test]
@@ -1956,6 +1979,7 @@ mod tests {
 
     #[test]
     fn nested_block_comments() {
+        with_globals(|| {
             let cm = Lrc::new(CodeMap::new(FilePathMapping::empty()));
             let sh = mk_sess(cm.clone());
             let mut lexer = setup(&cm, &sh, "/* /* */ */'a'".to_string());
@@ -1965,10 +1989,12 @@ mod tests {
             }
             assert_eq!(lexer.next_token().tok,
                     token::Literal(token::Char(Symbol::intern("a")), None));
+        })
     }
 
     #[test]
     fn crlf_comments() {
+        with_globals(|| {
             let cm = Lrc::new(CodeMap::new(FilePathMapping::empty()));
             let sh = mk_sess(cm.clone());
             let mut lexer = setup(&cm, &sh, "// test\r\n/// test\r\n".to_string());
@@ -1978,5 +2004,6 @@ mod tests {
             assert_eq!(lexer.next_token().tok, token::Whitespace);
             assert_eq!(lexer.next_token().tok,
                     token::DocComment(Symbol::intern("/// test")));
+        })
     }
 }

src/libsyntax/parse/mod.rs

@@ -680,6 +680,7 @@ mod tests {
     use util::parser_testing::{string_to_stream, string_to_parser};
     use util::parser_testing::{string_to_expr, string_to_item, string_to_stmt};
     use util::ThinVec;
+    use with_globals;
 
     // produce a syntax_pos::span
     fn sp(a: u32, b: u32) -> Span {
@@ -691,6 +692,7 @@ mod tests {
     }
 
     #[test] fn path_exprs_1() {
+        with_globals(|| {
             assert!(string_to_expr("a".to_string()) ==
                     P(ast::Expr{
                         id: ast::DUMMY_NODE_ID,
@@ -701,9 +703,11 @@ mod tests {
                         span: sp(0, 1),
                         attrs: ThinVec::new(),
                     }))
+        })
     }
 
     #[test] fn path_exprs_2 () {
+        with_globals(|| {
             assert!(string_to_expr("::a::b".to_string()) ==
                     P(ast::Expr {
                         id: ast::DUMMY_NODE_ID,
@@ -716,16 +720,20 @@ mod tests {
                         span: sp(0, 6),
                         attrs: ThinVec::new(),
                     }))
+        })
     }
 
     #[should_panic]
     #[test] fn bad_path_expr_1() {
+        with_globals(|| {
             string_to_expr("::abc::def::return".to_string());
+        })
     }
 
     // check the token-tree-ization of macros
     #[test]
     fn string_to_tts_macro () {
+        with_globals(|| {
             let tts: Vec<_> =
                 string_to_stream("macro_rules! zip (($a)=>($a))".to_string()).trees().collect();
             let tts: &[TokenTree] = &tts[..];
@@ -776,10 +784,12 @@ mod tests {
                 },
                 _ => panic!("value: {:?}",tts),
             }
+        })
     }
 
     #[test]
     fn string_to_tts_1() {
+        with_globals(|| {
             let tts = string_to_stream("fn a (b : i32) { b; }".to_string());
 
             let expected = TokenStream::concat(vec![
@@ -792,7 +802,8 @@ mod tests {
                         tts: TokenStream::concat(vec![
                             TokenTree::Token(sp(6, 7), token::Ident(Ident::from_str("b"))).into(),
                             TokenTree::Token(sp(8, 9), token::Colon).into(),
-                        TokenTree::Token(sp(10, 13), token::Ident(Ident::from_str("i32"))).into(),
+                            TokenTree::Token(sp(10, 13),
+                                             token::Ident(Ident::from_str("i32"))).into(),
                         ]).into(),
                     }).into(),
                 TokenTree::Delimited(
@@ -807,9 +818,11 @@ mod tests {
             ]);
 
             assert_eq!(tts, expected);
+        })
     }
 
     #[test] fn ret_expr() {
+        with_globals(|| {
             assert!(string_to_expr("return d".to_string()) ==
                     P(ast::Expr{
                         id: ast::DUMMY_NODE_ID,
@@ -825,9 +838,11 @@ mod tests {
                         span:sp(0,8),
                         attrs: ThinVec::new(),
                     }))
+        })
     }
 
     #[test] fn parse_stmt_1 () {
+        with_globals(|| {
             assert!(string_to_stmt("b;".to_string()) ==
                     Some(ast::Stmt {
                         node: ast::StmtKind::Expr(P(ast::Expr {
@@ -840,7 +855,7 @@ mod tests {
                             attrs: ThinVec::new()})),
                         id: ast::DUMMY_NODE_ID,
                         span: sp(0,1)}))
-
+        })
     }
 
     fn parser_done(p: Parser){
@@ -848,6 +863,7 @@ mod tests {
     }
 
     #[test] fn parse_ident_pat () {
+        with_globals(|| {
             let sess = ParseSess::new(FilePathMapping::empty());
             let mut parser = string_to_parser(&sess, "b".to_string());
             assert!(panictry!(parser.parse_pat())
@@ -860,10 +876,12 @@ mod tests {
                                         None),
                     span: sp(0,1)}));
             parser_done(parser);
+        })
     }
 
     // check the contents of the tt manually:
     #[test] fn parse_fundecl () {
+        with_globals(|| {
             // this test depends on the intern order of "fn" and "i32"
             let item = string_to_item("fn a (b : i32) { b; }".to_string()).map(|m| {
                 m.map(|mut m| {
@@ -938,9 +956,11 @@ mod tests {
                                         })),
                                 vis: respan(sp(0, 0), ast::VisibilityKind::Inherited),
                                 span: sp(0,21)})));
+        })
     }
 
     #[test] fn parse_use() {
+        with_globals(|| {
             let use_s = "use foo::bar::baz;";
             let vitem = string_to_item(use_s.to_string()).unwrap();
             let vitem_s = item_to_string(&vitem);
@@ -950,9 +970,11 @@ mod tests {
             let vitem = string_to_item(use_s.to_string()).unwrap();
             let vitem_s = item_to_string(&vitem);
             assert_eq!(&vitem_s[..], use_s);
+        })
     }
 
     #[test] fn parse_extern_crate() {
+        with_globals(|| {
             let ex_s = "extern crate foo;";
             let vitem = string_to_item(ex_s.to_string()).unwrap();
             let vitem_s = item_to_string(&vitem);
@@ -962,6 +984,7 @@ mod tests {
             let vitem = string_to_item(ex_s.to_string()).unwrap();
             let vitem_s = item_to_string(&vitem);
             assert_eq!(&vitem_s[..], ex_s);
+        })
     }
 
     fn get_spans_of_pat_idents(src: &str) -> Vec<Span> {
@@ -988,6 +1011,7 @@ mod tests {
     }
 
     #[test] fn span_of_self_arg_pat_idents_are_correct() {
+        with_globals(|| {
 
             let srcs = ["impl z { fn a (&self, &myarg: i32) {} }",
                         "impl z { fn a (&mut self, &myarg: i32) {} }",
@@ -1003,15 +1027,19 @@ mod tests {
                         "\"{}\" != \"self\". src=\"{}\"",
                         &src[lo.to_usize()..hi.to_usize()], src)
             }
+        })
     }
 
     #[test] fn parse_exprs () {
+        with_globals(|| {
             // just make sure that they parse....
             string_to_expr("3 + 4".to_string());
             string_to_expr("a::z.froob(b,&(987+3))".to_string());
+        })
     }
 
     #[test] fn attrs_fix_bug () {
+        with_globals(|| {
             string_to_item("pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
                    -> Result<Box<Writer>, String> {
     #[cfg(windows)]
@@ -1024,9 +1052,11 @@ mod tests {
 
     let mut fflags: c_int = wb();
 }".to_string());
+        })
     }
 
     #[test] fn crlf_doc_comments() {
+        with_globals(|| {
             let sess = ParseSess::new(FilePathMapping::empty());
 
             let name = FileName::Custom("source".to_string());
@@ -1048,10 +1078,12 @@ mod tests {
             let item = parse_item_from_source_str(name, source, &sess).unwrap().unwrap();
             let doc = first_attr_value_str_by_name(&item.attrs, "doc").unwrap();
             assert_eq!(doc, "/** doc comment\n *  with CRLF */");
+        });
     }
 
     #[test]
     fn ttdelim_span() {
+        with_globals(|| {
             let sess = ParseSess::new(FilePathMapping::empty());
             let expr = parse::parse_expr_from_source_str(PathBuf::from("foo").into(),
                 "foo!( fn main() { body } )".to_string(), &sess).unwrap();
@@ -1067,6 +1099,7 @@ mod tests {
                 Ok(s) => assert_eq!(&s[..], "{ body }"),
                 Err(_) => panic!("could not get snippet"),
             }
+        });
     }
 
     // This tests that when parsing a string (rather than a file) we don't try
@@ -1074,6 +1107,7 @@ mod tests {
     // See `recurse_into_file_modules` in the parser.
     #[test]
     fn out_of_line_mod() {
+        with_globals(|| {
             let sess = ParseSess::new(FilePathMapping::empty());
             let item = parse_item_from_source_str(
                 PathBuf::from("foo").into(),
@@ -1086,5 +1120,6 @@ mod tests {
             } else {
                 panic!();
             }
+        });
     }
 }

src/libsyntax/print/pprust.rs

@@ -3178,9 +3178,11 @@ mod tests {
     use ast;
     use codemap;
     use syntax_pos;
+    use with_globals;
 
     #[test]
     fn test_fun_to_string() {
+        with_globals(|| {
             let abba_ident = ast::Ident::from_str("abba");
 
             let decl = ast::FnDecl {
@@ -3193,10 +3195,12 @@ mod tests {
                                     ast::Constness::NotConst,
                                     abba_ident, &generics),
                     "fn abba()");
+        })
     }
 
     #[test]
     fn test_variant_to_string() {
+        with_globals(|| {
             let ident = ast::Ident::from_str("principal_skinner");
 
             let var = codemap::respan(syntax_pos::DUMMY_SP, ast::Variant_ {
@@ -3209,5 +3213,6 @@ mod tests {
 
             let varstr = variant_to_string(&var);
             assert_eq!(varstr, "principal_skinner");
+        })
     }
 }

src/libsyntax/test_snippet.rs

@@ -18,6 +18,7 @@ use std::str;
 use std::sync::{Arc, Mutex};
 use std::path::Path;
 use syntax_pos::{BytePos, NO_EXPANSION, Span, MultiSpan};
+use with_globals;
 
 /// Identify a position in the text by the Nth occurrence of a string.
 struct Position {
@@ -46,6 +47,7 @@ impl<T: Write> Write for Shared<T> {
 }
 
 fn test_harness(file_text: &str, span_labels: Vec<SpanLabel>, expected_output: &str) {
+    with_globals(|| {
         let output = Arc::new(Mutex::new(Vec::new()));
 
         let code_map = Lrc::new(CodeMap::new(FilePathMapping::empty()));
@@ -77,6 +79,7 @@ fn test_harness(file_text: &str, span_labels: Vec<SpanLabel>, expected_output: &
         println!("actual output:\n------\n{}------", actual_output);
 
         assert!(expected_output == actual_output)
+    })
 }
 
 fn make_span(file_text: &str, start: &Position, end: &Position) -> Span {

src/libsyntax/tokenstream.rs

@@ -599,6 +599,7 @@ impl Hash for ThinTokenStream {
 mod tests {
     use super::*;
     use syntax::ast::Ident;
+    use with_globals;
     use syntax_pos::{Span, BytePos, NO_EXPANSION};
     use parse::token::Token;
     use util::parser_testing::string_to_stream;
@@ -613,6 +614,7 @@ mod tests {
 
     #[test]
     fn test_concat() {
+        with_globals(|| {
             let test_res = string_to_ts("foo::bar::baz");
             let test_fst = string_to_ts("foo::bar");
             let test_snd = string_to_ts("::baz");
@@ -620,52 +622,66 @@ mod tests {
             assert_eq!(test_res.trees().count(), 5);
             assert_eq!(eq_res.trees().count(), 5);
             assert_eq!(test_res.eq_unspanned(&eq_res), true);
+        })
     }
 
     #[test]
     fn test_to_from_bijection() {
+        with_globals(|| {
             let test_start = string_to_ts("foo::bar(baz)");
             let test_end = test_start.trees().collect();
             assert_eq!(test_start, test_end)
+        })
     }
 
     #[test]
     fn test_eq_0() {
+        with_globals(|| {
             let test_res = string_to_ts("foo");
             let test_eqs = string_to_ts("foo");
             assert_eq!(test_res, test_eqs)
+        })
     }
 
     #[test]
     fn test_eq_1() {
+        with_globals(|| {
             let test_res = string_to_ts("::bar::baz");
             let test_eqs = string_to_ts("::bar::baz");
             assert_eq!(test_res, test_eqs)
+        })
     }
 
     #[test]
     fn test_eq_3() {
+        with_globals(|| {
             let test_res = string_to_ts("");
             let test_eqs = string_to_ts("");
             assert_eq!(test_res, test_eqs)
+        })
     }
 
     #[test]
     fn test_diseq_0() {
+        with_globals(|| {
             let test_res = string_to_ts("::bar::baz");
             let test_eqs = string_to_ts("bar::baz");
             assert_eq!(test_res == test_eqs, false)
+        })
     }
 
     #[test]
     fn test_diseq_1() {
+        with_globals(|| {
             let test_res = string_to_ts("(bar,baz)");
             let test_eqs = string_to_ts("bar,baz");
             assert_eq!(test_res == test_eqs, false)
+        })
     }
 
     #[test]
     fn test_is_empty() {
+        with_globals(|| {
             let test0: TokenStream = Vec::<TokenTree>::new().into_iter().collect();
             let test1: TokenStream =
                 TokenTree::Token(sp(0, 1), Token::Ident(Ident::from_str("a"))).into();
@@ -674,6 +690,7 @@ mod tests {
             assert_eq!(test0.is_empty(), true);
             assert_eq!(test1.is_empty(), false);
             assert_eq!(test2.is_empty(), false);
+        })
     }
 
     #[test]

src/libsyntax_pos/Cargo.toml

@@ -11,4 +11,5 @@ crate-type = ["dylib"]
 [dependencies]
 serialize = { path = "../libserialize" }
 rustc_data_structures = { path = "../librustc_data_structures" }
+scoped-tls = { version = "0.1.1", features = ["nightly"] }
 unicode-width = "0.1.4"

src/libsyntax_pos/hygiene.rs

@@ -15,11 +15,11 @@
 //! and definition contexts*. J. Funct. Program. 22, 2 (March 2012), 181-216.
 //! DOI=10.1017/S0956796812000093 <http://dx.doi.org/10.1017/S0956796812000093>
 
+use GLOBALS;
 use Span;
 use symbol::{Ident, Symbol};
 
 use serialize::{Encodable, Decodable, Encoder, Decoder};
-use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt;
 
@@ -119,7 +119,7 @@ impl Mark {
     }
 }
 
-struct HygieneData {
+pub struct HygieneData {
     marks: Vec<MarkData>,
     syntax_contexts: Vec<SyntaxContextData>,
     markings: HashMap<(SyntaxContext, Mark), SyntaxContext>,
@@ -127,7 +127,7 @@ struct HygieneData {
 }
 
 impl HygieneData {
-    fn new() -> Self {
+    pub fn new() -> Self {
         HygieneData {
             marks: vec![MarkData {
                 parent: Mark::root(),
@@ -145,10 +145,7 @@ impl HygieneData {
     }
 
     fn with<T, F: FnOnce(&mut HygieneData) -> T>(f: F) -> T {
-        thread_local! {
+        GLOBALS.with(|globals| f(&mut *globals.hygiene_data.borrow_mut()))
-            static HYGIENE_DATA: RefCell<HygieneData> = RefCell::new(HygieneData::new());
-        }
-        HYGIENE_DATA.with(|data| f(&mut *data.borrow_mut()))
     }
 }
 

src/libsyntax_pos/lib.rs

@@ -35,10 +35,13 @@ use std::ops::{Add, Sub};
 use std::path::PathBuf;
 
 use rustc_data_structures::stable_hasher::StableHasher;
-use rustc_data_structures::sync::Lrc;
+use rustc_data_structures::sync::{Lrc, Lock};
 
 extern crate rustc_data_structures;
 
+#[macro_use]
+extern crate scoped_tls;
+
 use serialize::{Encodable, Decodable, Encoder, Decoder};
 
 extern crate serialize;
@@ -54,6 +57,24 @@ pub use span_encoding::{Span, DUMMY_SP};
 
 pub mod symbol;
 
+pub struct Globals {
+    symbol_interner: Lock<symbol::Interner>,
+    span_interner: Lock<span_encoding::SpanInterner>,
+    hygiene_data: Lock<hygiene::HygieneData>,
+}
+
+impl Globals {
+    pub fn new() -> Globals {
+        Globals {
+            symbol_interner: Lock::new(symbol::Interner::fresh()),
+            span_interner: Lock::new(span_encoding::SpanInterner::default()),
+            hygiene_data: Lock::new(hygiene::HygieneData::new()),
+        }
+    }
+}
+
+scoped_thread_local!(pub static GLOBALS: Globals);
+
 /// Differentiates between real files and common virtual files
 #[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash, RustcDecodable, RustcEncodable)]
 pub enum FileName {

src/libsyntax_pos/span_encoding.rs

@@ -14,11 +14,11 @@
 // The encoding format for inline spans were obtained by optimizing over crates in rustc/libstd.
 // See https://internals.rust-lang.org/t/rfc-compiler-refactoring-spans/1357/28
 
+use GLOBALS;
 use {BytePos, SpanData};
 use hygiene::SyntaxContext;
 
 use rustc_data_structures::fx::FxHashMap;
-use std::cell::RefCell;
 use std::hash::{Hash, Hasher};
 
 /// A compressed span.
@@ -133,7 +133,7 @@ fn decode(span: Span) -> SpanData {
 }
 
 #[derive(Default)]
-struct SpanInterner {
+pub struct SpanInterner {
     spans: FxHashMap<SpanData, u32>,
     span_data: Vec<SpanData>,
 }
@@ -156,11 +156,8 @@ impl SpanInterner {
     }
 }
 
-// If an interner exists in TLS, return it. Otherwise, prepare a fresh one.
+// If an interner exists, return it. Otherwise, prepare a fresh one.
 #[inline]
 fn with_span_interner<T, F: FnOnce(&mut SpanInterner) -> T>(f: F) -> T {
-    thread_local!(static INTERNER: RefCell<SpanInterner> = {
+    GLOBALS.with(|globals| f(&mut *globals.span_interner.lock()))
-        RefCell::new(SpanInterner::default())
-    });
-    INTERNER.with(|interner| f(&mut *interner.borrow_mut()))
 }

src/libsyntax_pos/symbol.rs

@@ -13,9 +13,9 @@
 //! type, and vice versa.
 
 use hygiene::SyntaxContext;
+use GLOBALS;
 
 use serialize::{Decodable, Decoder, Encodable, Encoder};
-use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt;
 
@@ -247,7 +247,7 @@ macro_rules! declare_keywords {(
     }
 
     impl Interner {
-        fn fresh() -> Self {
+        pub fn fresh() -> Self {
             Interner::prefill(&[$($string,)*])
         }
     }
@@ -330,12 +330,10 @@ declare_keywords! {
     (60, Union,          "union")
 }
 
-// If an interner exists in TLS, return it. Otherwise, prepare a fresh one.
+// If an interner exists, return it. Otherwise, prepare a fresh one.
+#[inline]
 fn with_interner<T, F: FnOnce(&mut Interner) -> T>(f: F) -> T {
-    thread_local!(static INTERNER: RefCell<Interner> = {
+    GLOBALS.with(|globals| f(&mut *globals.symbol_interner.lock()))
-        RefCell::new(Interner::fresh())
-    });
-    INTERNER.with(|interner| f(&mut *interner.borrow_mut()))
 }
 
 /// Represents a string stored in the thread-local interner. Because the
@@ -422,6 +420,7 @@ impl Encodable for InternedString {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use Globals;
 
     #[test]
     fn interner_tests() {
@@ -444,7 +443,9 @@ mod tests {
 
     #[test]
     fn without_first_quote_test() {
+        GLOBALS.set(&Globals::new(), || {
             let i = Ident::from_str("'break");
             assert_eq!(i.without_first_quote().name, keywords::Break.name());
+        });
     }
 }

src/test/run-fail-fulldeps/qquote.rs

@@ -24,6 +24,10 @@ use syntax::symbol::Symbol;
 use syntax_pos::DUMMY_SP;
 
 fn main() {
+    syntax::with_globals(|| run());
+}
+
+fn run() {
     let ps = syntax::parse::ParseSess::new(codemap::FilePathMapping::empty());
     let mut resolver = syntax::ext::base::DummyResolver;
     let mut cx = syntax::ext::base::ExtCtxt::new(

src/test/run-make/issue-19371/foo.rs

@@ -69,6 +69,7 @@ fn basic_sess(sysroot: PathBuf) -> (Session, Rc<CStore>, Box<TransCrate>) {
 }
 
 fn compile(code: String, output: PathBuf, sysroot: PathBuf) {
+    syntax::with_globals(|| {
         let (sess, cstore, trans) = basic_sess(sysroot);
         let control = CompileController::basic();
         let input = Input::Str { name: FileName::Anon, input: code };
@@ -83,4 +84,5 @@ fn compile(code: String, output: PathBuf, sysroot: PathBuf) {
             None,
             &control
         );
+    });
 }

src/test/run-pass-fulldeps/ast_stmt_expr_attr.rs

@@ -115,6 +115,10 @@ fn reject_stmt_parse(es: &str) {
 }
 
 fn main() {
+    syntax::with_globals(|| run());
+}
+
+fn run() {
     let both = &["#[attr]", "#![attr]"];
     let outer = &["#[attr]"];
     let none = &[];

src/test/run-pass-fulldeps/issue-35829.rs

@@ -27,6 +27,10 @@ use syntax::ptr::P;
 use rustc_data_structures::sync::Lrc;
 
 fn main() {
+    syntax::with_globals(|| run());
+}
+
+fn run() {
     let parse_sess = ParseSess::new(FilePathMapping::empty());
     let exp_cfg = ExpansionConfig::default("issue_35829".to_owned());
     let mut resolver = DummyResolver;

src/test/run-pass-fulldeps/pprust-expr-roundtrip.rs

@@ -221,8 +221,11 @@ impl Folder for AddParens {
     }
 }
 
-
 fn main() {
+    syntax::with_globals(|| run());
+}
+
+fn run() {
     let ps = ParseSess::new(FilePathMapping::empty());
 
     iter_exprs(2, &mut |e| {

src/test/run-pass-fulldeps/qquote.rs

@@ -21,6 +21,10 @@ use syntax::symbol::Symbol;
 use syntax_pos::DUMMY_SP;
 
 fn main() {
+    syntax::with_globals(|| run());
+}
+
+fn run() {
     let ps = syntax::parse::ParseSess::new(FilePathMapping::empty());
     let mut resolver = syntax::ext::base::DummyResolver;
     let mut cx = syntax::ext::base::ExtCtxt::new(

src/tools/error_index_generator/main.rs

@@ -263,7 +263,10 @@ fn main() {
         *slot.borrow_mut() = Some((None, String::from("https://play.rust-lang.org/")));
     });
     let (format, dst) = parse_args();
-    if let Err(e) = main_with_result(format, &dst) {
+    let result = syntax::with_globals(move || {
+        main_with_result(format, &dst)
+    });
+    if let Err(e) = result {
         panic!("{}", e.description());
     }
 }

src/tools/tidy/src/deps.rs

@@ -93,6 +93,7 @@ static WHITELIST: &'static [Crate] = &[
     Crate("regex-syntax"),
     Crate("remove_dir_all"),
     Crate("rustc-demangle"),
+    Crate("scoped-tls"),
     Crate("smallvec"),
     Crate("stable_deref_trait"),
     Crate("tempdir"),