Auto merge of #44700 - arielb1:mir-effectck, r=nikomatsakis

Move effect-checking to MIR

This allows emitting lints from MIR and moves the effect-checking pass to work on it.

I'll make `repr(packed)` misuse unsafe in a separate PR.

r? @eddyb

src/librustc/dep_graph/dep_node.rs

@@ -445,6 +445,7 @@ define_dep_nodes!( <'tcx>
     [] BorrowCheckKrate,
     [] BorrowCheck(DefId),
     [] MirBorrowCheck(DefId),
+    [] UnsafetyViolations(DefId),
 
     [] RvalueCheck(DefId),
     [] Reachability,

src/librustc/diagnostics.rs

@@ -479,40 +479,6 @@ fn main() {
 ```
 "##,
 
-E0133: r##"
-Unsafe code was used outside of an unsafe function or block.
-
-Erroneous code example:
-
-```compile_fail,E0133
-unsafe fn f() { return; } // This is the unsafe code
-
-fn main() {
-    f(); // error: call to unsafe function requires unsafe function or block
-}
-```
-
-Using unsafe functionality is potentially dangerous and disallowed by safety
-checks. Examples:
-
-* Dereferencing raw pointers
-* Calling functions via FFI
-* Calling functions marked unsafe
-
-These safety checks can be relaxed for a section of the code by wrapping the
-unsafe instructions with an `unsafe` block. For instance:
-
-```
-unsafe fn f() { return; }
-
-fn main() {
-    unsafe { f(); } // ok!
-}
-```
-
-See also https://doc.rust-lang.org/book/first-edition/unsafe.html
-"##,
-
 // This shouldn't really ever trigger since the repeated value error comes first
 E0136: r##"
 A binary can only have one entry point, and by default that entry point is the

src/librustc/ich/impls_mir.rs

@@ -28,10 +28,12 @@ impl_stable_hash_for!(struct mir::LocalDecl<'tcx> {
     name,
     source_info,
     internal,
+    lexical_scope,
     is_user_variable
 });
 impl_stable_hash_for!(struct mir::UpvarDecl { debug_name, by_ref });
 impl_stable_hash_for!(struct mir::BasicBlockData<'tcx> { statements, terminator, is_cleanup });
+impl_stable_hash_for!(struct mir::UnsafetyViolation { source_info, description, lint_node_id });
 
 impl<'gcx> HashStable<StableHashingContext<'gcx>>
 for mir::Terminator<'gcx> {
@@ -75,6 +77,22 @@ for mir::Terminator<'gcx> {
     }
 }
 
+impl<'gcx, T> HashStable<StableHashingContext<'gcx>> for mir::ClearOnDecode<T>
+    where T: HashStable<StableHashingContext<'gcx>>
+{
+    #[inline]
+    fn hash_stable<W: StableHasherResult>(&self,
+                                          hcx: &mut StableHashingContext<'gcx>,
+                                          hasher: &mut StableHasher<W>) {
+        mem::discriminant(self).hash_stable(hcx, hasher);
+        match *self {
+            mir::ClearOnDecode::Clear => {}
+            mir::ClearOnDecode::Set(ref value) => {
+                value.hash_stable(hcx, hasher);
+            }
+        }
+    }
+}
 
 impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::Local {
     #[inline]
@@ -347,6 +365,26 @@ for mir::ProjectionElem<'gcx, V, T>
 }
 
 impl_stable_hash_for!(struct mir::VisibilityScopeData { span, parent_scope });
+impl_stable_hash_for!(struct mir::VisibilityScopeInfo {
+    lint_root, safety
+});
+
+impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::Safety {
+    fn hash_stable<W: StableHasherResult>(&self,
+                                          hcx: &mut StableHashingContext<'gcx>,
+                                          hasher: &mut StableHasher<W>) {
+        mem::discriminant(self).hash_stable(hcx, hasher);
+
+        match *self {
+            mir::Safety::Safe |
+            mir::Safety::BuiltinUnsafe |
+            mir::Safety::FnUnsafe => {}
+            mir::Safety::ExplicitUnsafe(node_id) => {
+                node_id.hash_stable(hcx, hasher);
+            }
+        }
+    }
+}
 
 impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::Operand<'gcx> {
     fn hash_stable<W: StableHasherResult>(&self,

src/librustc/lib.rs

@@ -111,7 +111,6 @@ pub mod middle {
     pub mod dataflow;
     pub mod dead;
     pub mod dependency_format;
-    pub mod effect;
     pub mod entry;
     pub mod exported_symbols;
     pub mod free_region;

src/librustc/lint/levels.rs

@@ -384,6 +384,11 @@ impl LintLevelMap {
             self.sets.get_lint_level(lint, *idx, None)
         })
     }
+
+    /// Returns if this `id` has lint level information.
+    pub fn lint_level_set(&self, id: HirId) -> Option<u32> {
+        self.id_to_set.get(&id).cloned()
+    }
 }
 
 impl<'gcx> HashStable<StableHashingContext<'gcx>> for LintLevelMap {