Tightened up the scoping for our various new operators, which should

make it harder to use the wrong one.

src/rt/memory.h

@@ -2,33 +2,42 @@
 #ifndef MEMORY_H
 #define MEMORY_H
 
-inline void *operator new(size_t size, void *mem) {
-    return mem;
-}
-
-inline void *operator new(size_t size, rust_kernel *kernel) {
-    return kernel->malloc(size);
-}
-
-inline void *operator new(size_t size, rust_task *task) {
-    return task->malloc(size);
-}
-
-inline void *operator new[](size_t size, rust_task *task) {
-    return task->malloc(size);
-}
-
-inline void *operator new(size_t size, rust_task &task) {
-    return task.malloc(size);
-}
-
-inline void *operator new[](size_t size, rust_task &task) {
-    return task.malloc(size);
-}
-
+#if 0
 inline void operator delete(void *mem, rust_task *task) {
     task->free(mem);
     return;
 }
+#endif
+
+// FIXME: It would be really nice to be able to get rid of this.
+inline void *operator new[](size_t size, rust_task *task) {
+    return task->malloc(size);
+}
+
+template <typename T>
+inline void *task_owned<T>::operator new(size_t size, rust_task *task) {
+    return task->malloc(size);
+}
+
+template <typename T>
+inline void *task_owned<T>::operator new[](size_t size, rust_task *task) {
+    return task->malloc(size);
+}
+
+template <typename T>
+inline void *task_owned<T>::operator new(size_t size, rust_task &task) {
+    return task.malloc(size);
+}
+
+template <typename T>
+inline void *task_owned<T>::operator new[](size_t size, rust_task &task) {
+    return task.malloc(size);
+}
+
+template <typename T>
+inline void *kernel_owned<T>::operator new(size_t size, rust_kernel *kernel) {
+    return kernel->malloc(size);
+}
+
 
 #endif /* MEMORY_H */

src/rt/rust_internal.h

@@ -115,12 +115,22 @@ template <typename T> struct rc_base {
 };
 
 template <typename T> struct task_owned {
+    inline void *operator new(size_t size, rust_task *task);
+
+    inline void *operator new[](size_t size, rust_task *task);
+
+    inline void *operator new(size_t size, rust_task &task);
+
+    inline void *operator new[](size_t size, rust_task &task);
+
     void operator delete(void *ptr) {
         ((T *)ptr)->task->free(ptr);
     }
 };
 
 template <typename T> struct kernel_owned {
+    inline void *operator new(size_t size, rust_kernel *kernel);
+
     void operator delete(void *ptr) {
         ((T *)ptr)->kernel->free(ptr);
     }

src/rt/rust_util.h

@@ -184,6 +184,10 @@ rust_vec : public rc_base<rust_vec>
             memcpy(&data[0], d, fill);
     }
     ~rust_vec() {}
+
+    inline void *operator new(size_t size, void *mem) {
+        return mem;
+    }
 };
 
 // Rust types vec and str look identical from our perspective.