1 files changed, 114 insertions, 195 deletions

diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 22e0bfc49..279a1354a 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -567,11 +567,11 @@ fn indexing_arrays() {
 fn infer_ops_index() {
     check_types(
         r#"
-//- /main.rs crate:main deps:std
+//- minicore: index
 struct Bar;
 struct Foo;
 
-impl std::ops::Index<u32> for Bar {
+impl core::ops::Index<u32> for Bar {
     type Output = Foo;
 }
 
@@ -580,15 +580,6 @@ fn test() {
     let b = a[1u32];
     b;
 } //^ Foo
-
-//- /std.rs crate:std
-#[prelude_import] use ops::*;
-mod ops {
-    #[lang = "index"]
-    pub trait Index<Idx> {
-        type Output;
-    }
-}
 "#,
     );
 }
@@ -597,16 +588,16 @@ mod ops {
 fn infer_ops_index_int() {
     check_types(
         r#"
-//- /main.rs crate:main deps:std
+//- minicore: index
 struct Bar;
 struct Foo;
 
-impl std::ops::Index<u32> for Bar {
+impl core::ops::Index<u32> for Bar {
     type Output = Foo;
 }
 
 struct Range;
-impl std::ops::Index<Range> for Bar {
+impl core::ops::Index<Range> for Bar {
     type Output = Bar;
 }
 
@@ -616,15 +607,6 @@ fn test() {
     b;
   //^ Foo
 }
-
-//- /std.rs crate:std
-#[prelude_import] use ops::*;
-mod ops {
-    #[lang = "index"]
-    pub trait Index<Idx> {
-        type Output;
-    }
-}
 "#,
     );
 }
@@ -633,25 +615,12 @@ mod ops {
 fn infer_ops_index_autoderef() {
     check_types(
         r#"
-//- /main.rs crate:main deps:std
+//- minicore: index, slice
 fn test() {
     let a = &[1u32, 2, 3];
-    let b = a[1u32];
+    let b = a[1];
     b;
 } //^ u32
-
-//- /std.rs crate:std
-impl<T> ops::Index<u32> for [T] {
-    type Output = T;
-}
-
-#[prelude_import] use ops::*;
-mod ops {
-    #[lang = "index"]
-    pub trait Index<Idx> {
-        type Output;
-    }
-}
 "#,
     );
 }
@@ -884,12 +853,9 @@ fn test<T>(t: T) { t.foo(); }
 fn generic_param_env_deref() {
     check_types(
         r#"
-#[lang = "deref"]
-trait Deref {
-    type Target;
-}
+//- minicore: deref
 trait Trait {}
-impl<T> Deref for T where T: Trait {
+impl<T> core::ops::Deref for T where T: Trait {
     type Target = i128;
 }
 fn test<T: Trait>(t: T) { (*t); }
@@ -1758,20 +1724,7 @@ fn test() {
 fn fn_trait_deref_with_ty_default() {
     check_infer(
         r#"
-#[lang = "deref"]
-trait Deref {
-    type Target;
-
-    fn deref(&self) -> &Self::Target;
-}
-
-#[lang="fn_once"]
-trait FnOnce<Args> {
-    type Output;
-
-    fn call_once(self, args: Args) -> Self::Output;
-}
-
+//- minicore: deref, fn
 struct Foo;
 
 impl Foo {
@@ -1784,7 +1737,7 @@ impl<T, F> Lazy<T, F> {
     pub fn new(f: F) -> Lazy<T, F> {}
 }
 
-impl<T, F: FnOnce() -> T> Deref for Lazy<T, F> {
+impl<T, F: FnOnce() -> T> core::ops::Deref for Lazy<T, F> {
     type Target = T;
 }
 
@@ -1798,32 +1751,29 @@ fn test() {
     let r2 = lazy2.foo();
 }"#,
         expect![[r#"
-            64..68 'self': &Self
-            165..169 'self': Self
-            171..175 'args': Args
-            239..243 'self': &Foo
-            254..256 '{}': ()
-            334..335 'f': F
-            354..356 '{}': ()
-            443..689 '{     ...o(); }': ()
-            453..458 'lazy1': Lazy<Foo, || -> Foo>
-            475..484 'Lazy::new': fn new<Foo, || -> Foo>(|| -> Foo) -> Lazy<Foo, || -> Foo>
-            475..492 'Lazy::...| Foo)': Lazy<Foo, || -> Foo>
-            485..491 '|| Foo': || -> Foo
-            488..491 'Foo': Foo
-            502..504 'r1': usize
-            507..512 'lazy1': Lazy<Foo, || -> Foo>
-            507..518 'lazy1.foo()': usize
-            560..575 'make_foo_fn_ptr': fn() -> Foo
-            591..602 'make_foo_fn': fn make_foo_fn() -> Foo
-            612..617 'lazy2': Lazy<Foo, fn() -> Foo>
-            634..643 'Lazy::new': fn new<Foo, fn() -> Foo>(fn() -> Foo) -> Lazy<Foo, fn() -> Foo>
-            634..660 'Lazy::...n_ptr)': Lazy<Foo, fn() -> Foo>
-            644..659 'make_foo_fn_ptr': fn() -> Foo
-            670..672 'r2': usize
-            675..680 'lazy2': Lazy<Foo, fn() -> Foo>
-            675..686 'lazy2.foo()': usize
-            549..551 '{}': ()
+            36..40 'self': &Foo
+            51..53 '{}': ()
+            131..132 'f': F
+            151..153 '{}': ()
+            251..497 '{     ...o(); }': ()
+            261..266 'lazy1': Lazy<Foo, || -> Foo>
+            283..292 'Lazy::new': fn new<Foo, || -> Foo>(|| -> Foo) -> Lazy<Foo, || -> Foo>
+            283..300 'Lazy::...| Foo)': Lazy<Foo, || -> Foo>
+            293..299 '|| Foo': || -> Foo
+            296..299 'Foo': Foo
+            310..312 'r1': usize
+            315..320 'lazy1': Lazy<Foo, || -> Foo>
+            315..326 'lazy1.foo()': usize
+            368..383 'make_foo_fn_ptr': fn() -> Foo
+            399..410 'make_foo_fn': fn make_foo_fn() -> Foo
+            420..425 'lazy2': Lazy<Foo, fn() -> Foo>
+            442..451 'Lazy::new': fn new<Foo, fn() -> Foo>(fn() -> Foo) -> Lazy<Foo, fn() -> Foo>
+            442..468 'Lazy::...n_ptr)': Lazy<Foo, fn() -> Foo>
+            452..467 'make_foo_fn_ptr': fn() -> Foo
+            478..480 'r2': usize
+            483..488 'lazy2': Lazy<Foo, fn() -> Foo>
+            483..494 'lazy2.foo()': usize
+            357..359 '{}': ()
         "#]],
     );
 }
@@ -2731,9 +2681,7 @@ fn test(x: &dyn Foo) {
 fn builtin_copy() {
     check_infer_with_mismatches(
         r#"
-#[lang = "copy"]
-trait Copy {}
-
+//- minicore: copy
 struct IsCopy;
 impl Copy for IsCopy {}
 struct NotCopy;
@@ -2748,20 +2696,20 @@ fn test() {
     (IsCopy, NotCopy).test();
 }"#,
         expect![[r#"
-            110..114 'self': &Self
-            166..267 '{     ...t(); }': ()
-            172..178 'IsCopy': IsCopy
-            172..185 'IsCopy.test()': bool
-            191..198 'NotCopy': NotCopy
-            191..205 'NotCopy.test()': {unknown}
-            211..227 '(IsCop...sCopy)': (IsCopy, IsCopy)
-            211..234 '(IsCop...test()': bool
-            212..218 'IsCopy': IsCopy
-            220..226 'IsCopy': IsCopy
-            240..257 '(IsCop...tCopy)': (IsCopy, NotCopy)
-            240..264 '(IsCop...test()': {unknown}
-            241..247 'IsCopy': IsCopy
-            249..256 'NotCopy': NotCopy
+            78..82 'self': &Self
+            134..235 '{     ...t(); }': ()
+            140..146 'IsCopy': IsCopy
+            140..153 'IsCopy.test()': bool
+            159..166 'NotCopy': NotCopy
+            159..173 'NotCopy.test()': {unknown}
+            179..195 '(IsCop...sCopy)': (IsCopy, IsCopy)
+            179..202 '(IsCop...test()': bool
+            180..186 'IsCopy': IsCopy
+            188..194 'IsCopy': IsCopy
+            208..225 '(IsCop...tCopy)': (IsCopy, NotCopy)
+            208..232 '(IsCop...test()': {unknown}
+            209..215 'IsCopy': IsCopy
+            217..224 'NotCopy': NotCopy
         "#]],
     );
 }
@@ -2770,9 +2718,7 @@ fn test() {
 fn builtin_fn_def_copy() {
     check_infer_with_mismatches(
         r#"
-#[lang = "copy"]
-trait Copy {}
-
+//- minicore: copy
 fn foo() {}
 fn bar<T: Copy>(T) -> T {}
 struct Struct(usize);
@@ -2788,20 +2734,20 @@ fn test() {
     Enum::Variant.test();
 }"#,
         expect![[r#"
-            41..43 '{}': ()
-            60..61 'T': {unknown}
-            68..70 '{}': ()
-            68..70: expected T, got ()
-            145..149 'self': &Self
-            201..281 '{     ...t(); }': ()
-            207..210 'foo': fn foo()
-            207..217 'foo.test()': bool
-            223..226 'bar': fn bar<{unknown}>({unknown}) -> {unknown}
-            223..233 'bar.test()': bool
-            239..245 'Struct': Struct(usize) -> Struct
-            239..252 'Struct.test()': bool
-            258..271 'Enum::Variant': Variant(usize) -> Enum
-            258..278 'Enum::...test()': bool
+            9..11 '{}': ()
+            28..29 'T': {unknown}
+            36..38 '{}': ()
+            36..38: expected T, got ()
+            113..117 'self': &Self
+            169..249 '{     ...t(); }': ()
+            175..178 'foo': fn foo()
+            175..185 'foo.test()': bool
+            191..194 'bar': fn bar<{unknown}>({unknown}) -> {unknown}
+            191..201 'bar.test()': bool
+            207..213 'Struct': Struct(usize) -> Struct
+            207..220 'Struct.test()': bool
+            226..239 'Enum::Variant': Variant(usize) -> Enum
+            226..246 'Enum::...test()': bool
         "#]],
     );
 }
@@ -2810,9 +2756,7 @@ fn test() {
 fn builtin_fn_ptr_copy() {
     check_infer_with_mismatches(
         r#"
-#[lang = "copy"]
-trait Copy {}
-
+//- minicore: copy
 trait Test { fn test(&self) -> bool; }
 impl<T: Copy> Test for T {}
 
@@ -2822,17 +2766,17 @@ fn test(f1: fn(), f2: fn(usize) -> u8, f3: fn(u8, u8) -> &u8) {
     f3.test();
 }"#,
         expect![[r#"
-            54..58 'self': &Self
-            108..110 'f1': fn()
-            118..120 'f2': fn(usize) -> u8
-            139..141 'f3': fn(u8, u8) -> &u8
-            162..210 '{     ...t(); }': ()
-            168..170 'f1': fn()
-            168..177 'f1.test()': bool
-            183..185 'f2': fn(usize) -> u8
-            183..192 'f2.test()': bool
-            198..200 'f3': fn(u8, u8) -> &u8
-            198..207 'f3.test()': bool
+            22..26 'self': &Self
+            76..78 'f1': fn()
+            86..88 'f2': fn(usize) -> u8
+            107..109 'f3': fn(u8, u8) -> &u8
+            130..178 '{     ...t(); }': ()
+            136..138 'f1': fn()
+            136..145 'f1.test()': bool
+            151..153 'f2': fn(usize) -> u8
+            151..160 'f2.test()': bool
+            166..168 'f3': fn(u8, u8) -> &u8
+            166..175 'f3.test()': bool
         "#]],
     );
 }
@@ -2841,9 +2785,7 @@ fn test(f1: fn(), f2: fn(usize) -> u8, f3: fn(u8, u8) -> &u8) {
 fn builtin_sized() {
     check_infer_with_mismatches(
         r#"
-#[lang = "sized"]
-trait Sized {}
-
+//- minicore: sized
 trait Test { fn test(&self) -> bool; }
 impl<T: Sized> Test for T {}
 
@@ -2854,22 +2796,22 @@ fn test() {
     (1u8, *"foo").test(); // not Sized
 }"#,
         expect![[r#"
-            56..60 'self': &Self
-            113..228 '{     ...ized }': ()
-            119..122 '1u8': u8
-            119..129 '1u8.test()': bool
-            135..150 '(*"foo").test()': {unknown}
-            136..142 '*"foo"': str
-            137..142 '"foo"': &str
-            169..179 '(1u8, 1u8)': (u8, u8)
-            169..186 '(1u8, ...test()': bool
-            170..173 '1u8': u8
-            175..178 '1u8': u8
-            192..205 '(1u8, *"foo")': (u8, str)
-            192..212 '(1u8, ...test()': {unknown}
-            193..196 '1u8': u8
-            198..204 '*"foo"': str
-            199..204 '"foo"': &str
+            22..26 'self': &Self
+            79..194 '{     ...ized }': ()
+            85..88 '1u8': u8
+            85..95 '1u8.test()': bool
+            101..116 '(*"foo").test()': {unknown}
+            102..108 '*"foo"': str
+            103..108 '"foo"': &str
+            135..145 '(1u8, 1u8)': (u8, u8)
+            135..152 '(1u8, ...test()': bool
+            136..139 '1u8': u8
+            141..144 '1u8': u8
+            158..171 '(1u8, *"foo")': (u8, str)
+            158..178 '(1u8, ...test()': {unknown}
+            159..162 '1u8': u8
+            164..170 '*"foo"': str
+            165..170 '"foo"': &str
         "#]],
     );
 }
@@ -2980,28 +2922,13 @@ fn infer_box_fn_arg() {
     // The type mismatch is because we don't define Unsize and CoerceUnsized
     check_infer_with_mismatches(
         r#"
-//- /lib.rs deps:std
-
-#[lang = "fn_once"]
-pub trait FnOnce<Args> {
-    type Output;
-
-    extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
-}
-
-#[lang = "deref"]
-pub trait Deref {
-    type Target: ?Sized;
-
-    fn deref(&self) -> &Self::Target;
-}
-
+//- minicore: fn, deref, option
 #[lang = "owned_box"]
 pub struct Box<T: ?Sized> {
     inner: *mut T,
 }
 
-impl<T: ?Sized> Deref for Box<T> {
+impl<T: ?Sized> core::ops::Deref for Box<T> {
     type Target = T;
 
     fn deref(&self) -> &T {
@@ -3009,38 +2936,30 @@ impl<T: ?Sized> Deref for Box<T> {
     }
 }
 
-enum Option<T> {
-    None,
-    Some(T)
-}
-
 fn foo() {
-    let s = Option::None;
+    let s = None;
     let f: Box<dyn FnOnce(&Option<i32>)> = box (|ps| {});
     f(&s);
 }"#,
         expect![[r#"
-            100..104 'self': Self
-            106..110 'args': Args
-            214..218 'self': &Self
-            384..388 'self': &Box<T>
-            396..423 '{     ...     }': &T
-            406..417 '&self.inner': &*mut T
-            407..411 'self': &Box<T>
-            407..417 'self.inner': *mut T
-            478..576 '{     ...&s); }': ()
-            488..489 's': Option<i32>
-            492..504 'Option::None': Option<i32>
-            514..515 'f': Box<dyn FnOnce(&Option<i32>)>
-            549..562 'box (|ps| {})': Box<|{unknown}| -> ()>
-            554..561 '|ps| {}': |{unknown}| -> ()
-            555..557 'ps': {unknown}
-            559..561 '{}': ()
-            568..569 'f': Box<dyn FnOnce(&Option<i32>)>
-            568..573 'f(&s)': ()
-            570..572 '&s': &Option<i32>
-            571..572 's': Option<i32>
-            549..562: expected Box<dyn FnOnce(&Option<i32>)>, got Box<|{unknown}| -> ()>
+            154..158 'self': &Box<T>
+            166..193 '{     ...     }': &T
+            176..187 '&self.inner': &*mut T
+            177..181 'self': &Box<T>
+            177..187 'self.inner': *mut T
+            206..296 '{     ...&s); }': ()
+            216..217 's': Option<i32>
+            220..224 'None': Option<i32>
+            234..235 'f': Box<dyn FnOnce(&Option<i32>)>
+            269..282 'box (|ps| {})': Box<|{unknown}| -> ()>
+            274..281 '|ps| {}': |{unknown}| -> ()
+            275..277 'ps': {unknown}
+            279..281 '{}': ()
+            288..289 'f': Box<dyn FnOnce(&Option<i32>)>
+            288..293 'f(&s)': ()
+            290..292 '&s': &Option<i32>
+            291..292 's': Option<i32>
+            269..282: expected Box<dyn FnOnce(&Option<i32>)>, got Box<|{unknown}| -> ()>
         "#]],
     );
 }