Fixed problem with unrooted interior.

components/script_plugins/unrooted_must_root.rs

@@ -123,7 +123,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnrootedPass {
         let mut visitor = MirFnVisitor {
             unrooted_cx: unrooted_cx,
             in_new_function: in_new_function,
-            in_derive_expn: in_derive_expn(span),  // why? shouldn't it be improper usage anyway?
+            in_derive_expn: in_derive_expn(span),  // TODO replace with whitelist
             mir: mir,
         };
 
@@ -196,6 +196,21 @@ impl<'a, 'b, 'tcx> UnrootedCx<'a, 'b, 'tcx> {
     fn has_unrooted_generic_substs(&self, did: hir::def_id::DefId, substs: &ty::subst::Substs) -> bool {
         let cx = self.late_cx;
 
+        if cx.tcx.has_attr(did, "allow_unrooted_interior") {
+            return false;
+        }
+        // TODO we'll see what's necessary and what is not
+        else if match_def_path(cx, did, &["core", "cell", "Ref"])
+             || match_def_path(cx, did, &["core", "cell", "RefMut"])
+             || match_def_path(cx, did, &["core", "slice", "Iter"])
+             || match_def_path(cx, did, &["std", "collections", "hash", "map", "Entry"])
+             || match_def_path(cx, did, &["std", "collections", "hash", "map", "OccupiedEntry"])
+             || match_def_path(cx, did, &["std", "collections", "hash", "map", "VacantEntry"])
+             || match_def_path(cx, did, &["std", "collections", "hash", "map", "Iter"])
+             || match_def_path(cx, did, &["std", "collections", "hash", "set", "Iter"]) {
+            return false;
+        }
+
         let generics = cx.tcx.generics_of(did);
         for ty_param_def in &generics.types {
             // If type has `#[must_root]`, then it is ok to
@@ -255,14 +270,18 @@ impl<'a, 'b, 'tcx> MirVisitor<'tcx> for MirFnVisitor<'a, 'b, 'tcx> {
         match constant.ty.sty {
             ty::TyFnDef(callee_def_id, callee_substs) => {
                 let def_path = get_def_path(cx, callee_def_id);
+                // TODO remove following commented code
                 // cx.span_lint(UNROOTED_MUST_ROOT, constant.span, &def_path.join("::")); // tmp auxiliary call
                 if self.in_new_function && (// match_def_path(cx, callee_def_id, &["alloc", "boxed", "{{impl}}", "new"]) ||
                   def_path.last().unwrap().starts_with("new_") || def_path.last().unwrap() == "new") {
-                    // ^ need more checks / currently some dirty / proof of work code
-                    // some explanation
+                      // "new"-like (constructors) functions are allowed
                 }
                 else if ur_cx.has_unrooted_generic_substs(callee_def_id, callee_substs) {
-                    cx.span_lint(UNROOTED_MUST_ROOT, constant.span, "Callee generic type must be rooted.")
+                    // TODO tmp code - delete later
+                    let mut msg = "Callee generic type must be rooted.".to_string();
+                    msg.push_str(&def_path.join("::"));
+                    cx.span_lint(UNROOTED_MUST_ROOT, constant.span, &msg);
+                    //cx.span_lint(UNROOTED_MUST_ROOT, constant.span, "Callee generic type must be rooted.")
                 }
             },
             _ => {},

tests/unit/script_plugins/lib.rs

@@ -194,23 +194,6 @@ pub mod unrooted_must_root {
     */
     pub fn ban_box() {}
 
-    /* *
-    ```
-    #![feature(plugin)]
-    #![plugin(script_plugins)]
-
-    #[must_root] struct Foo(i32);
-
-    fn foo(x: &Foo) -> i32 {
-        let y = &Box::new(Foo(x.0 + 3));
-        y.0
-    }
-
-    fn main() {}
-    ```
-    */
-    // pub fn allow_box_ref() {} // is it a correct usage? I guess it isn't.
-
     /**
     ```compile_fail
     #![feature(plugin)]
@@ -272,6 +255,31 @@ pub mod unrooted_must_root {
     */
     pub fn generic_impl() {}
 
+    /**
+    ```
+    #![feature(plugin)]
+    #![plugin(script_plugins)]
+    #![feature(generic_param_attrs)]
+
+    #[must_root] struct Foo(i32);
+    #[allow_unrooted_interior] struct SomeContainer<T>(T);
+
+    impl<#[must_root] T> SomeContainer<T> {
+        fn foo(val: &T) {
+            SomeContainer(val);
+        }
+    }
+
+    fn test() {
+        SomeContainer(Foo(3));
+        SomeContainer::foo(&Foo(3));
+    }
+
+    fn main() {}
+    ```
+    */
+    pub fn allowing_unrooted_interior() {}
+
     /* *
     ```
     #![feature(plugin)]