use * for pointer type instead of &

See #770

To help automatically translate code, see the
zig-fmt-pointer-reform-2 branch.

This will convert all & into *. Due to the syntax
ambiguity (which is why we are making this change),
even address-of & will turn into *, so you'll have
to manually fix thes instances. You will be guaranteed
to get compile errors for them - expected 'type', found 'foo'

1 files changed, 16 insertions, 15 deletions

diff --git a/src/ast_render.cpp b/src/ast_render.cpp
index 5a1e81b36d..f356f406b0 100644
--- a/src/ast_render.cpp
+++ b/src/ast_render.cpp
@@ -68,6 +68,7 @@ static const char *prefix_op_str(PrefixOp prefix_op) {
         case PrefixOpBinNot: return "~";
         case PrefixOpMaybe: return "?";
         case PrefixOpUnwrapMaybe: return "??";
+        case PrefixOpAddrOf: return "&";
     }
     zig_unreachable();
 }
@@ -185,8 +186,6 @@ static const char *node_type_str(NodeType node_type) {
             return "Symbol";
         case NodeTypePrefixOpExpr:
             return "PrefixOpExpr";
-        case NodeTypeAddrOfExpr:
-            return "AddrOfExpr";
         case NodeTypeUse:
             return "Use";
         case NodeTypeBoolLiteral:
@@ -251,6 +250,8 @@ static const char *node_type_str(NodeType node_type) {
             return "Suspend";
         case NodeTypePromiseType:
             return "PromiseType";
+        case NodeTypePointerType:
+            return "PointerType";
     }
     zig_unreachable();
 }
@@ -616,41 +617,41 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
                 fprintf(ar->f, "%s", prefix_op_str(op));
 
                 AstNode *child_node = node->data.prefix_op_expr.primary_expr;
-                bool new_grouped = child_node->type == NodeTypePrefixOpExpr || child_node->type == NodeTypeAddrOfExpr;
+                bool new_grouped = child_node->type == NodeTypePrefixOpExpr || child_node->type == NodeTypePointerType;
                 render_node_extra(ar, child_node, new_grouped);
                 if (!grouped) fprintf(ar->f, ")");
                 break;
             }
-        case NodeTypeAddrOfExpr:
+        case NodeTypePointerType:
             {
                 if (!grouped) fprintf(ar->f, "(");
-                fprintf(ar->f, "&");
-                if (node->data.addr_of_expr.align_expr != nullptr) {
+                fprintf(ar->f, "*");
+                if (node->data.pointer_type.align_expr != nullptr) {
                     fprintf(ar->f, "align(");
-                    render_node_grouped(ar, node->data.addr_of_expr.align_expr);
-                    if (node->data.addr_of_expr.bit_offset_start != nullptr) {
-                        assert(node->data.addr_of_expr.bit_offset_end != nullptr);
+                    render_node_grouped(ar, node->data.pointer_type.align_expr);
+                    if (node->data.pointer_type.bit_offset_start != nullptr) {
+                        assert(node->data.pointer_type.bit_offset_end != nullptr);
 
                         Buf offset_start_buf = BUF_INIT;
                         buf_resize(&offset_start_buf, 0);
-                        bigint_append_buf(&offset_start_buf, node->data.addr_of_expr.bit_offset_start, 10);
+                        bigint_append_buf(&offset_start_buf, node->data.pointer_type.bit_offset_start, 10);
 
                         Buf offset_end_buf = BUF_INIT;
                         buf_resize(&offset_end_buf, 0);
-                        bigint_append_buf(&offset_end_buf, node->data.addr_of_expr.bit_offset_end, 10);
+                        bigint_append_buf(&offset_end_buf, node->data.pointer_type.bit_offset_end, 10);
 
                         fprintf(ar->f, ":%s:%s ", buf_ptr(&offset_start_buf), buf_ptr(&offset_end_buf));
                     }
                     fprintf(ar->f, ") ");
                 }
-                if (node->data.addr_of_expr.is_const) {
+                if (node->data.pointer_type.is_const) {
                     fprintf(ar->f, "const ");
                 }
-                if (node->data.addr_of_expr.is_volatile) {
+                if (node->data.pointer_type.is_volatile) {
                     fprintf(ar->f, "volatile ");
                 }
 
-                render_node_ungrouped(ar, node->data.addr_of_expr.op_expr);
+                render_node_ungrouped(ar, node->data.pointer_type.op_expr);
                 if (!grouped) fprintf(ar->f, ")");
                 break;
             }
@@ -669,7 +670,7 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
                     fprintf(ar->f, " ");
                 }
                 AstNode *fn_ref_node = node->data.fn_call_expr.fn_ref_expr;
-                bool grouped = (fn_ref_node->type != NodeTypePrefixOpExpr && fn_ref_node->type != NodeTypeAddrOfExpr);
+                bool grouped = (fn_ref_node->type != NodeTypePrefixOpExpr && fn_ref_node->type != NodeTypePointerType);
                 render_node_extra(ar, fn_ref_node, grouped);
                 fprintf(ar->f, "(");
                 for (size_t i = 0; i < node->data.fn_call_expr.params.length; i += 1) {