Enforce tuples for __ptr__

Author: inumanag

codon/compiler/error.h

@@ -419,7 +419,7 @@ template <class... TA> std::string Emsg(Error e, const TA &...args) {
   case Error::CALL_SUPER_PARENT:
     return fmt::format("no super methods found");
   case Error::CALL_PTR_VAR:
-    return fmt::format("__ptr__() only takes identifiers as arguments");
+    return fmt::format("__ptr__() only takes identifiers or tuple fields as arguments");
   case Error::EXPECTED_TUPLE:
     return fmt::format("expected tuple type");
   case Error::CALL_REALIZED_FN:

codon/parser/visitors/translate/translate.cpp

@@ -276,22 +276,28 @@ void TranslateVisitor::visit(CallExpr *expr) {
   auto ei = cast<IdExpr>(expr->getExpr());
   if (ei && ei->getValue() == getMangledFunc("std.internal.core", "__ptr__")) {
     auto head = expr->begin()->getExpr();
+    ir::FlowInstr *pre = cast<ir::FlowInstr>(transform(head));
     while (auto sexp = cast<StmtExpr>(head))
       head = sexp->getExpr();
 
-    std::string member;
-    if (auto id = cast<DotExpr>(head)) {
+    std::vector<std::string> members;
+    while (auto id = cast<DotExpr>(head)) {
+      members.emplace_back(id->getMember());
       head = id->getExpr();
-      member = id->getMember();
     }
+    std::ranges::reverse(members);
     auto id = cast<IdExpr>(head);
     seqassert(id, "expected IdExpr, got {}", *((*expr)[0].value));
     auto key = id->getValue();
     auto val = ctx->find(key);
     seqassert(val && val->getVar(), "{} is not a variable", key);
-    result = make<ir::PointerValue>(expr, val->getVar(),
-                                    member.empty() ? std::vector<std::string>{}
-                                                   : std::vector<std::string>{member});
+
+    auto pv = make<ir::PointerValue>(expr, val->getVar(), members);
+    if (pre) {
+      pre->setValue(pv);
+    } else {
+      result = pv;
+    }
     return;
   } else if (ei && ei->getValue() ==
                        getMangledMethod("std.internal.core", "__array__", "__new__")) {

codon/parser/visitors/typecheck/special.cpp

@@ -498,23 +498,40 @@ Expr *TypecheckVisitor::transformPtr(CallExpr *expr) {
   expr->begin()->value = transform(expr->begin()->getExpr());
 
   auto head = getHeadExpr(expr->begin()->getExpr());
-  auto id = cast<IdExpr>(head);
-  std::string member;
-  if (auto dot = cast<DotExpr>(head)) {
-    if (((id = cast<IdExpr>(dot->getExpr())))) {
-      member = dot->getMember();
+  std::vector<std::string> members;
+  for (bool last = true;; last = false) {
+    auto t = extractClassType(head);
+    if (!t)
+      return nullptr;
+    if (!t->isRecord())
+      E(Error::CALL_PTR_VAR, expr->begin()->getExpr());
+
+    if (auto id = cast<IdExpr>(head)) {
+      auto val = id ? ctx->find(id->getValue(), getTime()) : nullptr;
+      if (!val || !val->isVar()) {
+        E(Error::CALL_PTR_VAR, expr->begin()->getExpr());
+      }
+      break;
+    } else if (auto dot = cast<DotExpr>(head)) {
+      if (last && !t->isRecord()) {
+        E(Error::CALL_PTR_VAR, expr->begin()->getExpr());
+      } else if (!t->isRecord()) {
+        auto tmp = getTemporaryVar("ptr");
+        auto newDot = N<DotExpr>(N<IdExpr>(tmp), dot->getMember());
+        std::ranges::reverse(members);
+        for (auto &m : members)
+          newDot = N<DotExpr>(newDot, m);
+        return transform(N<StmtExpr>(
+            N<AssignStmt>(N<IdExpr>(tmp), dot->getExpr()),
+            N<CallExpr>(N<IdExpr>(getMangledFunc("std.internal.core", "__ptr__")),
+                        newDot)));
+      }
+      head = dot->getExpr();
     } else {
-      auto tmp = getTemporaryVar("ptr");
-      return transform(N<StmtExpr>(
-          N<AssignStmt>(N<IdExpr>(tmp), dot->getExpr()),
-          N<CallExpr>(N<IdExpr>(getMangledFunc("std.internal.core", "__ptr__")),
-                      N<DotExpr>(N<IdExpr>(tmp), dot->getMember()))));
+      E(Error::CALL_PTR_VAR, expr->begin()->getExpr());
+      break;
     }
   }
-  auto val = id ? ctx->find(id->getValue(), getTime()) : nullptr;
-  if (!val || !val->isVar()) {
-    E(Error::CALL_PTR_VAR, expr->begin()->getExpr());
-  }
 
   unify(expr->getType(),
         instantiateType(getStdLibType("Ptr"), {expr->begin()->getExpr()->getType()}));

test/parser/typecheck/test_call.codon

@@ -41,13 +41,65 @@ def test_class():
 # test_class()
 
 
+@tuple
+class A:
+    n: int
+
+@tuple
+class B:
+    a: A
+
+@tuple
+class C:
+    b: B
+
+x = C(B(A(1)))
+p = __ptr__(x.b.a.n)
+p[0] = 55
+print(x)  #: (b: (a: (n: 55)))
+
+
 #%% call_ptr_error,barebones
-__ptr__(1) #! __ptr__() only takes identifiers as arguments
+__ptr__(1) #! __ptr__() only takes identifiers or tuple fields as arguments
+
+#%% call_ptr_error_2,barebones
+__ptr__([1]) #! __ptr__() only takes identifiers or tuple fields as arguments
 
 #%% call_ptr_error_3,barebones
 v = 1
 __ptr__(v, 1) #! __ptr__() takes 1 arguments (2 given)
 
+#%% call_ptr_error_4,barebones
+@tuple
+class A:
+    n: int
+
+class B:
+    a: A
+
+@tuple
+class C:
+    b: B
+
+x = C(B(A(1)))
+print(__ptr__(x.b.a.n)) #! __ptr__() only takes identifiers or tuple fields as arguments
+
+#%% call_ptr_error_5,barebones
+@tuple
+class A:
+    n: int
+
+class B:
+    a: A
+
+@tuple
+class C:
+    b: B
+
+x = C(B(A(1)))
+print(__ptr__(A(1).n))   #! __ptr__() only takes identifiers or tuple fields as arguments
+
+
 #%% call_array,barebones
 a = __array__[int](2)
 a[0] = a[1] = 5