Update internal functions

codon/cir/types/types.cpp

@@ -101,12 +101,6 @@ std::vector<Type *> RecordType::doGetUsedTypes() const {
   return ret;
 }
 
-bool RecordType::doIsContentAtomic() const {
-  return !std::any_of(fields.begin(), fields.end(), [](auto &field) {
-    return field.getName().rfind(".__vtable__", 0) != 0 && !field.getType()->isAtomic();
-  });
-}
-
 Type *RecordType::getMemberType(const std::string &n) const {
   auto it = std::find_if(fields.begin(), fields.end(),
                          [n](auto &x) { return x.getName() == n; });
@@ -129,6 +123,13 @@ void RecordType::realize(std::vector<Type *> mTypes, std::vector<std::string> mN
 
 const char RefType::NodeId = 0;
 
+bool RefType::doIsContentAtomic() const {
+  auto *contents = getContents();
+  return !std::any_of(contents->begin(), contents->end(), [](auto &field) {
+    return field.getName().rfind(".__vtable__", 0) != 0 && !field.getType()->isAtomic();
+  });
+}
+
 Value *RefType::doConstruct(std::vector<Value *> args) {
   auto *module = getModule();
   auto *argsTuple = util::makeTuple(args, module);

codon/cir/types/types.h

@@ -291,8 +291,6 @@ private:
     return !std::any_of(fields.begin(), fields.end(),
                         [](auto &field) { return !field.getType()->isAtomic(); });
   }
-
-  bool doIsContentAtomic() const override;
 };
 
 /// Membered type that is passed by reference. Similar to Python classes.
@@ -337,6 +335,8 @@ private:
 
   bool doIsAtomic() const override { return false; }
 
+  bool doIsContentAtomic() const override;
+
   Value *doConstruct(std::vector<Value *> args) override;
 };
 

stdlib/internal/internal.codon

@@ -20,17 +20,16 @@ class __internal__:
     def class_raw(obj) -> Ptr[byte]:
         ret ptr %obj
 
-    def class_new_shared(T: type) -> T:
+    def class_alloc(T: type) -> T:
-        sz = tuple(T).__elemsize__
+        """Allocates a new reference (class) type"""
+        sz = sizeof(tuple(T))
         p = alloc_atomic(sz) if T.__contents_atomic__ else alloc(sz)
         register_finalizer(p)
         return __internal__.to_class_ptr(p, T)
 
-    @pure
-    @derives
     def class_new(T: type) -> T:
         """Create a new reference (class) type"""
-        pf = __internal__.class_new_shared(T)
+        pf = __internal__.class_alloc(T)
         __internal__.class_set_obj_vtable(pf)
         return pf
 
@@ -88,8 +87,8 @@ class __internal__:
         return 0
 
     def class_copy(obj: T, T: type) -> T:
-        p = __internal__.class_new_shared(T)
+        p = __internal__.class_alloc(T)
-        str.memcpy(p.__raw__(), obj.__raw__(), tuple(T).__elemsize__)
+        str.memcpy(p.__raw__(), obj.__raw__(), sizeof(tuple(T)))
         return p
 
     def class_super(obj: D, B: type, D: type) -> B: