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

make it harder to use the wrong one.

Author: Eric Holk

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;
+#if 0
+inline void operator delete(void *mem, rust_task *task) {
+    task->free(mem);
+    return;
 }
+#endif
 
-inline void *operator new(size_t size, rust_kernel *kernel) {
-    return kernel->malloc(size);
+// 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);
 }
 
-inline void *operator new(size_t size, rust_task *task) {
+template <typename T>
+inline void *task_owned<T>::operator new(size_t size, rust_task *task) {
     return task->malloc(size);
 }
 
-inline void *operator new[](size_t size, rust_task *task) {
+template <typename T>
+inline void *task_owned<T>::operator new[](size_t size, rust_task *task) {
     return task->malloc(size);
 }
 
-inline void *operator new(size_t size, rust_task &task) {
+template <typename T>
+inline void *task_owned<T>::operator new(size_t size, rust_task &task) {
     return task.malloc(size);
 }
 
-inline void *operator new[](size_t size, rust_task &task) {
+template <typename T>
+inline void *task_owned<T>::operator new[](size_t size, rust_task &task) {
     return task.malloc(size);
 }
 
-inline void operator delete(void *mem, rust_task *task) {
-    task->free(mem);
-    return;
+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.