pub(crate) struct GlobalState {     req_queue: ReqQueue,     pub(crate) task_pool: Handle<TaskPool<Task>, Receiver<Task>>,     pub(crate) loader: Handle<Box<dyn vfs::loader::Handle>, Receiver<vfs::loader::Message>>,-    pub(crate) flycheck: Option<FlycheckHandle>,+    pub(crate) flycheck: Vec<FlycheckHandle>,

 impl ItemScope {     pub(crate) fn collect_legacy_macros(&self) -> FxHashMap<Name, MacroDefId> {         self.legacy_macros.clone()     }++    /// Marks everything that is not a procedural macro as private to `this_module`.+    pub(crate) fn censor_non_proc_macros(&mut self, this_module: ModuleId) {+        for vis in self+            .types+            .values_mut()+            .chain(self.values.values_mut())+            .map(|(_, v)| v)+            .chain(self.unnamed_trait_imports.values_mut())+        {+            *vis = Visibility::Module(this_module);+        }

 impl DefCollector<'_> {         }         self.unresolved_imports = unresolved_imports; -        // Record proc-macros-        self.collect_proc_macro();+        // FIXME: This condition should instead check if this is a `proc-macro` type crate.+        if self.exports_proc_macros {+            // A crate exporting procedural macros is not allowed to export anything else.+            //+            // Additionally, while the proc macro entry points must be `pub`, they are not publicly+            // exported in type/value namespace. This function reduces the visibility of all items+            // in the crate root that aren't proc macros.+            let root = self.def_map.root;+            let root = &mut self.def_map.modules[root];+            root.scope.censor_non_proc_macros(ModuleId {+                krate: self.def_map.krate,+                local_id: self.def_map.root,+            });+        }     } -    fn collect_proc_macro(&mut self) {-        let proc_macros = std::mem::take(&mut self.proc_macros);-        for (name, expander) in proc_macros {-            let krate = self.def_map.krate;--            let macro_id = MacroDefId {+    fn resolve_proc_macro(&mut self, name: &Name) {+        self.exports_proc_macros = true;+        let macro_def = match self.proc_macros.iter().find(|(n, _)| n == name) {+            Some((_, expander)) => MacroDefId {

 pub(crate) fn trait_datum_query( }  fn well_known_trait_from_lang_attr(name: &str) -> Option<WellKnownTrait> {+    use chalk_solve::rust_ir::WellKnownTrait::*;+     Some(match name {-        "sized" => WellKnownTrait::Sized,-        "copy" => WellKnownTrait::Copy,-        "clone" => WellKnownTrait::Clone,-        "drop" => WellKnownTrait::Drop,-        "fn_once" => WellKnownTrait::FnOnce,-        "fn_mut" => WellKnownTrait::FnMut,-        "fn" => WellKnownTrait::Fn,-        "unsize" => WellKnownTrait::Unsize,+        "sized" => Sized,+        "copy" => Copy,+        "clone" => Clone,+        "drop" => Drop,+        "fn_once" => FnOnce,+        "fn_mut" => FnMut,+        "fn" => Fn,+        "unsize" => Unsize,+        "coerce_unsized" => CoerceUnsized,         _ => return None,     }) } -fn lang_attr_from_well_known_trait(attr: WellKnownTrait) -> &'static str {+const fn lang_attr_from_well_known_trait(attr: WellKnownTrait) -> &'static str {+    use chalk_solve::rust_ir::WellKnownTrait::*;

 impl<'a> TreeSink for TtTreeSink<'a> {                     // Mark the range if needed                     let (text, id) = match leaf {                         tt::Leaf::Ident(ident) => (ident.text.clone(), ident.id),-                        tt::Leaf::Punct(punct) => {-                            (SmolStr::new_inline_from_ascii(1, &[punct.char as u8]), punct.id)-                        }+                        tt::Leaf::Punct(punct) => (+                            std::iter::FromIterator::from_iter(std::iter::once(punct.char)),

 fn box_clone_from_ptr_stability() {         assert_eq!(copy.as_ptr() as usize, copy_raw);     } }++#[test]+fn box_deref_lval() {+    use std::cell::Cell;

 fn test_is_sorted() {     assert!(!["c", "bb", "aaa"].is_sorted());     assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len())); }++#[test]+fn test_slice_run_destructors() {+    use core::cell::Cell;

-use std::fmt;+#![deny(warnings)]+#![allow(unused_must_use)]++use std::cell::RefCell;+use std::fmt::{self, Write};  #[test] fn test_format() {     let s = fmt::format(format_args!("Hello, {}!", "world"));     assert_eq!(s, "Hello, world!"); }++struct A;+struct B;+struct C;+struct D;++impl fmt::LowerHex for A {+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+        f.write_str("aloha")+    }+}+impl fmt::UpperHex for B {+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+        f.write_str("adios")+    }+}+impl fmt::Display for C {+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+        f.pad_integral(true, "☃", "123")+    }+}+impl fmt::Binary for D {+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+        f.write_str("aa")?;+        f.write_char('☃')?;+        f.write_str("bb")+    }+}++macro_rules! t {+    ($a:expr, $b:expr) => {+        assert_eq!($a, $b)+    };+}++#[test]+fn test_format_macro_interface() {+    // Various edge cases without formats+    t!(format!(""), "");+    t!(format!("hello"), "hello");+    t!(format!("hello {{"), "hello {");++    // default formatters should work+    t!(format!("{}", 1.0f32), "1");+    t!(format!("{}", 1.0f64), "1");+    t!(format!("{}", "a"), "a");+    t!(format!("{}", "a".to_string()), "a");+    t!(format!("{}", false), "false");+    t!(format!("{}", 'a'), "a");++    // At least exercise all the formats+    t!(format!("{}", true), "true");+    t!(format!("{}", '☃'), "☃");+    t!(format!("{}", 10), "10");+    t!(format!("{}", 10_usize), "10");+    t!(format!("{:?}", '☃'), "'☃'");+    t!(format!("{:?}", 10), "10");+    t!(format!("{:?}", 10_usize), "10");+    t!(format!("{:?}", "true"), "\"true\"");+    t!(format!("{:?}", "foo\nbar"), "\"foo\\nbar\"");+    t!(+        format!("{:?}", "foo\n\"bar\"\r\n\'baz\'\t\\qux\\"),+        r#""foo\n\"bar\"\r\n\'baz\'\t\\qux\\""#+    );+    t!(format!("{:?}", "foo\0bar\x01baz\u{7f}q\u{75}x"), r#""foo\u{0}bar\u{1}baz\u{7f}qux""#);+    t!(format!("{:o}", 10_usize), "12");+    t!(format!("{:x}", 10_usize), "a");+    t!(format!("{:X}", 10_usize), "A");+    t!(format!("{}", "foo"), "foo");+    t!(format!("{}", "foo".to_string()), "foo");+    if cfg!(target_pointer_width = "32") {+        t!(format!("{:#p}", 0x1234 as *const isize), "0x00001234");+        t!(format!("{:#p}", 0x1234 as *mut isize), "0x00001234");+    } else {+        t!(format!("{:#p}", 0x1234 as *const isize), "0x0000000000001234");+        t!(format!("{:#p}", 0x1234 as *mut isize), "0x0000000000001234");+    }+    t!(format!("{:p}", 0x1234 as *const isize), "0x1234");+    t!(format!("{:p}", 0x1234 as *mut isize), "0x1234");+    t!(format!("{:x}", A), "aloha");+    t!(format!("{:X}", B), "adios");+    t!(format!("foo {} ☃☃☃☃☃☃", "bar"), "foo bar ☃☃☃☃☃☃");+    t!(format!("{1} {0}", 0, 1), "1 0");+    t!(format!("{foo} {bar}", foo = 0, bar = 1), "0 1");+    t!(format!("{foo} {1} {bar} {0}", 0, 1, foo = 2, bar = 3), "2 1 3 0");+    t!(format!("{} {0}", "a"), "a a");+    t!(format!("{_foo}", _foo = 6usize), "6");+    t!(format!("{foo_bar}", foo_bar = 1), "1");+    t!(format!("{}", 5 + 5), "10");+    t!(format!("{:#4}", C), "☃123");+    t!(format!("{:b}", D), "aa☃bb");++    let a: &dyn fmt::Debug = &1;+    t!(format!("{:?}", a), "1");++    // Formatting strings and their arguments+    t!(format!("{}", "a"), "a");+    t!(format!("{:4}", "a"), "a   ");+    t!(format!("{:4}", "☃"), "☃   ");+    t!(format!("{:>4}", "a"), "   a");+    t!(format!("{:<4}", "a"), "a   ");+    t!(format!("{:^5}", "a"), "  a  ");+    t!(format!("{:^5}", "aa"), " aa  ");+    t!(format!("{:^4}", "a"), " a  ");+    t!(format!("{:^4}", "aa"), " aa ");+    t!(format!("{:.4}", "a"), "a");+    t!(format!("{:4.4}", "a"), "a   ");+    t!(format!("{:4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");+    t!(format!("{:<4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");+    t!(format!("{:>4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");+    t!(format!("{:^4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");+    t!(format!("{:>10.4}", "aaaaaaaaaaaaaaaaaa"), "      aaaa");+    t!(format!("{:2.4}", "aaaaa"), "aaaa");+    t!(format!("{:2.4}", "aaaa"), "aaaa");+    t!(format!("{:2.4}", "aaa"), "aaa");+    t!(format!("{:2.4}", "aa"), "aa");+    t!(format!("{:2.4}", "a"), "a ");+    t!(format!("{:0>2}", "a"), "0a");+    t!(format!("{:.*}", 4, "aaaaaaaaaaaaaaaaaa"), "aaaa");+    t!(format!("{:.1$}", "aaaaaaaaaaaaaaaaaa", 4), "aaaa");+    t!(format!("{:.a$}", "aaaaaaaaaaaaaaaaaa", a = 4), "aaaa");+    t!(format!("{:._a$}", "aaaaaaaaaaaaaaaaaa", _a = 4), "aaaa");+    t!(format!("{:1$}", "a", 4), "a   ");+    t!(format!("{1:0$}", 4, "a"), "a   ");+    t!(format!("{:a$}", "a", a = 4), "a   ");+    t!(format!("{:-#}", "a"), "a");+    t!(format!("{:+#}", "a"), "a");+    t!(format!("{:/^10.8}", "1234567890"), "/12345678/");++    // Some float stuff+    t!(format!("{:}", 1.0f32), "1");+    t!(format!("{:}", 1.0f64), "1");+    t!(format!("{:.3}", 1.0f64), "1.000");+    t!(format!("{:10.3}", 1.0f64), "     1.000");+    t!(format!("{:+10.3}", 1.0f64), "    +1.000");+    t!(format!("{:+10.3}", -1.0f64), "    -1.000");++    t!(format!("{:e}", 1.2345e6f32), "1.2345e6");+    t!(format!("{:e}", 1.2345e6f64), "1.2345e6");+    t!(format!("{:E}", 1.2345e6f64), "1.2345E6");+    t!(format!("{:.3e}", 1.2345e6f64), "1.234e6");+    t!(format!("{:10.3e}", 1.2345e6f64), "   1.234e6");+    t!(format!("{:+10.3e}", 1.2345e6f64), "  +1.234e6");+    t!(format!("{:+10.3e}", -1.2345e6f64), "  -1.234e6");++    // Float edge cases+    t!(format!("{}", -0.0), "0");+    t!(format!("{:?}", -0.0), "-0.0");+    t!(format!("{:?}", 0.0), "0.0");++    // sign aware zero padding+    t!(format!("{:<3}", 1), "1  ");+    t!(format!("{:>3}", 1), "  1");+    t!(format!("{:^3}", 1), " 1 ");+    t!(format!("{:03}", 1), "001");+    t!(format!("{:<03}", 1), "001");+    t!(format!("{:>03}", 1), "001");+    t!(format!("{:^03}", 1), "001");+    t!(format!("{:+03}", 1), "+01");+    t!(format!("{:<+03}", 1), "+01");+    t!(format!("{:>+03}", 1), "+01");+    t!(format!("{:^+03}", 1), "+01");+    t!(format!("{:#05x}", 1), "0x001");+    t!(format!("{:<#05x}", 1), "0x001");+    t!(format!("{:>#05x}", 1), "0x001");+    t!(format!("{:^#05x}", 1), "0x001");+    t!(format!("{:05}", 1.2), "001.2");+    t!(format!("{:<05}", 1.2), "001.2");+    t!(format!("{:>05}", 1.2), "001.2");+    t!(format!("{:^05}", 1.2), "001.2");+    t!(format!("{:05}", -1.2), "-01.2");+    t!(format!("{:<05}", -1.2), "-01.2");+    t!(format!("{:>05}", -1.2), "-01.2");+    t!(format!("{:^05}", -1.2), "-01.2");+    t!(format!("{:+05}", 1.2), "+01.2");+    t!(format!("{:<+05}", 1.2), "+01.2");+    t!(format!("{:>+05}", 1.2), "+01.2");+    t!(format!("{:^+05}", 1.2), "+01.2");++    // Ergonomic format_args!+    t!(format!("{0:x} {0:X}", 15), "f F");+    t!(format!("{0:x} {0:X} {}", 15), "f F 15");+    t!(format!("{:x}{0:X}{a:x}{:X}{1:x}{a:X}", 13, 14, a = 15), "dDfEeF");+    t!(format!("{a:x} {a:X}", a = 15), "f F");++    // And its edge cases+    t!(+        format!(+            "{a:.0$} {b:.0$} {0:.0$}\n{a:.c$} {b:.c$} {c:.c$}",+            4,+            a = "abcdefg",+            b = "hijklmn",+            c = 3+        ),+        "abcd hijk 4\nabc hij 3"+    );+    t!(format!("{a:.*} {0} {:.*}", 4, 3, "efgh", a = "abcdef"), "abcd 4 efg");+    t!(format!("{:.a$} {a} {a:#x}", "aaaaaa", a = 2), "aa 2 0x2");++    // Test that pointers don't get truncated.+    {+        let val = usize::MAX;+        let exp = format!("{:#x}", val);+        t!(format!("{:p}", val as *const isize), exp);+    }++    // Escaping+    t!(format!("{{"), "{");+    t!(format!("}}"), "}");++    // make sure that format! doesn't move out of local variables+    let a = Box::new(3);+    format!("{}", a);+    format!("{}", a);++    // make sure that format! doesn't cause spurious unused-unsafe warnings when+    // it's inside of an outer unsafe block+    unsafe {+        let a: isize = ::std::mem::transmute(3_usize);+        format!("{}", a);+    }++    // test that trailing commas are acceptable+    format!("{}", "test",);+    format!("{foo}", foo = "test",);+}++// Basic test to make sure that we can invoke the `write!` macro with an+// fmt::Write instance.+#[test]+fn test_write() {+    let mut buf = String::new();+    write!(&mut buf, "{}", 3);+    {+        let w = &mut buf;+        write!(w, "{foo}", foo = 4);+        write!(w, "{}", "hello");+        writeln!(w, "{}", "line");+        writeln!(w, "{foo}", foo = "bar");+        w.write_char('☃');+        w.write_str("str");+    }++    t!(buf, "34helloline\nbar\n☃str");+}++// Just make sure that the macros are defined, there's not really a lot that we+// can do with them just yet (to test the output)+#[test]+fn test_print() {+    print!("hi");+    print!("{:?}", vec![0u8]);+    println!("hello");+    println!("this is a {}", "test");+    println!("{foo}", foo = "bar");+}++// Just make sure that the macros are defined, there's not really a lot that we+// can do with them just yet (to test the output)+#[test]+fn test_format_args() {+    let mut buf = String::new();+    {+        let w = &mut buf;+        write!(w, "{}", format_args!("{}", 1));+        write!(w, "{}", format_args!("test"));+        write!(w, "{}", format_args!("{test}", test = 3));+    }+    let s = buf;+    t!(s, "1test3");++    let s = fmt::format(format_args!("hello {}", "world"));+    t!(s, "hello world");+    let s = format!("{}: {}", "args were", format_args!("hello {}", "world"));+    t!(s, "args were: hello world");+}++#[test]+fn test_order() {+    // Make sure format!() arguments are always evaluated in a left-to-right+    // ordering+    fn foo() -> isize {+        static mut FOO: isize = 0;+        unsafe {+            FOO += 1;+            FOO+        }+    }+    assert_eq!(+        format!("{} {} {a} {b} {} {c}", foo(), foo(), foo(), a = foo(), b = foo(), c = foo()),+        "1 2 4 5 3 6".to_string()+    );+}++#[test]+fn test_once() {+    // Make sure each argument are evaluated only once even though it may be+    // formatted multiple times+    fn foo() -> isize {+        static mut FOO: isize = 0;+        unsafe {+            FOO += 1;+            FOO+        }+    }+    assert_eq!(format!("{0} {0} {0} {a} {a} {a}", foo(), a = foo()), "1 1 1 2 2 2".to_string());+}++#[test]+fn test_refcell() {+    let refcell = RefCell::new(5);+    assert_eq!(format!("{:?}", refcell), "RefCell { value: 5 }");+    let borrow = refcell.borrow_mut();+    assert_eq!(format!("{:?}", refcell), "RefCell { value: <borrowed> }");+    drop(borrow);+    assert_eq!(format!("{:?}", refcell), "RefCell { value: 5 }");+}

 fn option_const() {     const IS_NONE: bool = OPTION.is_none();     assert!(!IS_NONE); }++#[test]+fn test_unwrap_drop() {+    use std::cell::Cell;

 mod nonzero; mod num; mod ops; mod option;+mod panic_safe;

-// run-pass--#![allow(non_camel_case_types)]-use std::cell::Cell;--struct dtor<'a> {-    x: &'a Cell<isize>,-}--impl<'a> Drop for dtor<'a> {-    fn drop(&mut self) {-        self.x.set(self.x.get() - 1);-    }-}--fn unwrap<T>(o: Option<T>) -> T {-    match o {-      Some(v) => v,-      None => panic!()-    }-}--pub fn main() {-    let x = &Cell::new(1);--    {-        let b = Some(dtor { x:x });-        let _c = unwrap(b);-    }--    assert_eq!(x.get(), 0);-}

-use std::fmt;+#![deny(warnings)]+#![allow(unused_must_use)]

+// check-pass++// Check that `const_assume` feature allow `assume` intrinsic+// to be used in const contexts.++#![feature(core_intrinsics, const_assume)]++extern crate core;++use core::intrinsics::assume;++pub const unsafe fn foo(x: usize, y: usize) -> usize {+    assume(y != 0);+    x / y+}

 pub struct Function {     pub visibility: RawVisibilityId,     pub generic_params: GenericParamsId,     pub has_self_param: bool,+    pub has_body: bool,

 fn rewrite_url_link(db: &RootDatabase, def: ModuleDef, target: &str) -> Option<S         .map(|url| url.into_string()) } -// Rewrites a markdown document, resolving links using `callback` and additionally striping prefixes/suffixes on link titles.+/// Retrieve a link to documentation for the given symbol.+pub fn external_docs(db: &RootDatabase, position: &FilePosition) -> Option<DocumentationLink> {

 impl Function {     pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {         hir_ty::diagnostics::validate_body(db, self.id.into(), sink)     }++    /// Whether this function declaration has a definition.+    ///+    /// This is false in the case of required (not provided) trait methods.+    pub fn has_body(self, db: &dyn HirDatabase) -> bool {+        db.function_data(self.id).has_body+    }++    /// If this function is a method, the trait or type where it is declared.+    pub fn method_owner(self, db: &dyn HirDatabase) -> Option<MethodOwner> {+        match self.as_assoc_item(db).map(|assoc| assoc.container(db)) {+            Some(AssocItemContainer::Trait(t)) => Some(t.into()),+            Some(AssocItemContainer::ImplDef(imp)) => {+                let resolver = ModuleId::from(imp.module(db)).resolver(db.upcast());+                let ctx = TyLoweringContext::new(db, &resolver);+                let adt = Ty::from_hir(+                    &ctx,+                    &imp.target_trait(db).unwrap_or_else(|| imp.target_type(db)),+                )+                .as_adt()+                .map(|t| t.0)+                .unwrap();+                Some(Adt::from(adt).into())+            }+            None => None,+        }+    } } +#[derive(Debug)]+pub enum MethodOwner {+    Trait(Trait),+    Adt(Adt),

 impl Function {     pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {         hir_ty::diagnostics::validate_body(db, self.id.into(), sink)     }++    /// Whether this function declaration has a definition.+    ///+    /// This is false in the case of required (not provided) trait methods.+    pub fn has_body(self, db: &dyn HirDatabase) -> bool {+        db.function_data(self.id).has_body+    }++    /// If this function is a method, the trait or type where it is declared.+    pub fn method_owner(self, db: &dyn HirDatabase) -> Option<MethodOwner> {