Cleanup: Use references in node editor, other improvements

This helps to tell when a pointer is expected to be null, and avoid
overly verbose code when dereferencing. This commit also includes
a few other cleanups in this area:
 - Use const in a few places
 - Use `float2` instead of `float[2]`
 - Remove some unnecessary includes and old code
The change can be continued further in the future.

1 files changed, 275 insertions, 275 deletions

diff --git a/source/blender/editors/space_node/node_relationships.cc b/source/blender/editors/space_node/node_relationships.cc
index fa84ada0af0..fa147f56345 100644
--- a/source/blender/editors/space_node/node_relationships.cc
+++ b/source/blender/editors/space_node/node_relationships.cc
@@ -63,34 +63,35 @@
 #include "node_intern.hh" /* own include */
 
 using namespace blender::nodes::node_tree_ref_types;
+using blender::float2;
 using blender::Vector;
 
 /* -------------------------------------------------------------------- */
 /** \name Relations Helpers
  * \{ */
 
-static bool ntree_has_drivers(bNodeTree *ntree)
+static bool ntree_has_drivers(bNodeTree &ntree)
 {
-  const AnimData *adt = BKE_animdata_from_id(&ntree->id);
+  const AnimData *adt = BKE_animdata_from_id(&ntree.id);
   if (adt == nullptr) {
     return false;
   }
   return !BLI_listbase_is_empty(&adt->drivers);
 }
 
-static bool ntree_check_nodes_connected_dfs(bNodeTree *ntree, bNode *from, bNode *to)
+static bool ntree_check_nodes_connected_dfs(bNodeTree &ntree, bNode &from, bNode &to)
 {
-  if (from->flag & NODE_TEST) {
+  if (from.flag & NODE_TEST) {
     return false;
   }
-  from->flag |= NODE_TEST;
-  LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
-    if (link->fromnode == from) {
-      if (link->tonode == to) {
+  from.flag |= NODE_TEST;
+  LISTBASE_FOREACH (bNodeLink *, link, &ntree.links) {
+    if (link->fromnode == &from) {
+      if (link->tonode == &to) {
         return true;
       }
 
-      if (ntree_check_nodes_connected_dfs(ntree, link->tonode, to)) {
+      if (ntree_check_nodes_connected_dfs(ntree, *link->tonode, to)) {
         return true;
       }
     }
@@ -98,26 +99,25 @@ static bool ntree_check_nodes_connected_dfs(bNodeTree *ntree, bNode *from, bNode
   return false;
 }
 
-static bool ntree_check_nodes_connected(bNodeTree *ntree, bNode *from, bNode *to)
+static bool ntree_check_nodes_connected(bNodeTree &ntree, bNode &from, bNode &to)
 {
-  if (from == to) {
+  if (&from == &to) {
     return true;
   }
-  ntreeNodeFlagSet(ntree, NODE_TEST, false);
+  ntreeNodeFlagSet(&ntree, NODE_TEST, false);
   return ntree_check_nodes_connected_dfs(ntree, from, to);
 }
 
-static bool node_group_has_output_dfs(bNode *node)
+static bool node_group_has_output_dfs(bNode &node)
 {
-  bNodeTree *ntree = (bNodeTree *)node->id;
+  bNodeTree *ntree = (bNodeTree *)node.id;
   if (ntree->id.tag & LIB_TAG_DOIT) {
     return false;
   }
   ntree->id.tag |= LIB_TAG_DOIT;
-  for (bNode *current_node = (bNode *)ntree->nodes.first; current_node != nullptr;
-       current_node = current_node->next) {
+  LISTBASE_FOREACH (bNode *, current_node, &ntree->nodes) {
     if (current_node->type == NODE_GROUP) {
-      if (current_node->id && node_group_has_output_dfs(current_node)) {
+      if (current_node->id && node_group_has_output_dfs(*current_node)) {
         return true;
       }
     }
@@ -128,18 +128,18 @@ static bool node_group_has_output_dfs(bNode *node)
   return false;
 }
 
-static bool node_group_has_output(Main *bmain, bNode *node)
+static bool node_group_has_output(Main &bmain, bNode &node)
 {
-  BLI_assert(ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP));
-  bNodeTree *ntree = (bNodeTree *)node->id;
+  BLI_assert(ELEM(node.type, NODE_GROUP, NODE_CUSTOM_GROUP));
+  bNodeTree *ntree = (bNodeTree *)node.id;
   if (ntree == nullptr) {
     return false;
   }
-  BKE_main_id_tag_listbase(&bmain->nodetrees, LIB_TAG_DOIT, false);
+  BKE_main_id_tag_listbase(&bmain.nodetrees, LIB_TAG_DOIT, false);
   return node_group_has_output_dfs(node);
 }
 
-bool node_connected_to_output(Main *bmain, bNodeTree *ntree, bNode *node)
+bool node_connected_to_output(Main &bmain, bNodeTree &ntree, bNode &node)
 {
   /* Special case for drivers: if node tree has any drivers we assume it is
    * always to be tagged for update when node changes. Otherwise we will be
@@ -149,7 +149,7 @@ bool node_connected_to_output(Main *bmain, bNodeTree *ntree, bNode *node)
   if (ntree_has_drivers(ntree)) {
     return true;
   }
-  LISTBASE_FOREACH (bNode *, current_node, &ntree->nodes) {
+  LISTBASE_FOREACH (bNode *, current_node, &ntree.nodes) {
     /* Special case for group nodes -- if modified node connected to a group
      * with active output inside we consider refresh is needed.
      *
@@ -157,21 +157,21 @@ bool node_connected_to_output(Main *bmain, bNodeTree *ntree, bNode *node)
      * is connected to and so eventually.
      */
     if (ELEM(current_node->type, NODE_GROUP, NODE_CUSTOM_GROUP)) {
-      if (current_node->id != nullptr && ntree_has_drivers((bNodeTree *)current_node->id)) {
+      if (current_node->id != nullptr && ntree_has_drivers((bNodeTree &)current_node->id)) {
         return true;
       }
-      if (ntree_check_nodes_connected(ntree, node, current_node) &&
-          node_group_has_output(bmain, current_node)) {
+      if (ntree_check_nodes_connected(ntree, node, *current_node) &&
+          node_group_has_output(bmain, *current_node)) {
         return true;
       }
     }
     if (current_node->flag & NODE_DO_OUTPUT) {
-      if (ntree_check_nodes_connected(ntree, node, current_node)) {
+      if (ntree_check_nodes_connected(ntree, node, *current_node)) {
         return true;
       }
     }
     if (current_node->type == GEO_NODE_VIEWER) {
-      if (ntree_check_nodes_connected(ntree, node, current_node)) {
+      if (ntree_check_nodes_connected(ntree, node, *current_node)) {
         return true;
       }
     }
@@ -208,46 +208,47 @@ static void clear_picking_highlight(ListBase *links)
   }
 }
 
-static bNodeLink *create_drag_link(Main *bmain, SpaceNode *snode, bNode *node, bNodeSocket *sock)
+static bNodeLink *create_drag_link(Main &bmain, SpaceNode &snode, bNode &node, bNodeSocket &sock)
 {
-  bNodeLink *oplink = (bNodeLink *)MEM_callocN(sizeof(bNodeLink), "drag link op link");
-  if (sock->in_out == SOCK_OUT) {
-    oplink->fromnode = node;
-    oplink->fromsock = sock;
+  bNodeLink *oplink = (bNodeLink *)MEM_callocN(sizeof(bNodeLink), __func__);
+  if (sock.in_out == SOCK_OUT) {
+    oplink->fromnode = &node;
+    oplink->fromsock = &sock;
   }
   else {
-    oplink->tonode = node;
-    oplink->tosock = sock;
+    oplink->tonode = &node;
+    oplink->tosock = &sock;
   }
   oplink->flag |= NODE_LINK_VALID;
   oplink->flag &= ~NODE_LINK_TEST;
-  if (node_connected_to_output(bmain, snode->edittree, node)) {
+  if (node_connected_to_output(bmain, *snode.edittree, node)) {
     oplink->flag |= NODE_LINK_TEST;
   }
   oplink->flag |= NODE_LINK_DRAGGED;
   return oplink;
 }
 
-static void pick_link(const bContext *C,
-                      wmOperator *op,
-                      bNodeLinkDrag *nldrag,
-                      SpaceNode *snode,
+static void pick_link(const bContext &C,
+                      wmOperator &op,
+                      bNodeLinkDrag &nldrag,
+                      SpaceNode &snode,
                       bNode *node,
-                      bNodeLink *link_to_pick)
+                      bNodeLink &link_to_pick)
 {
-  clear_picking_highlight(&snode->edittree->links);
-  RNA_boolean_set(op->ptr, "has_link_picked", true);
+  clear_picking_highlight(&snode.edittree->links);
+  RNA_boolean_set(op.ptr, "has_link_picked", true);
 
-  Main *bmain = CTX_data_main(C);
-  bNodeLink *link = create_drag_link(bmain, snode, link_to_pick->fromnode, link_to_pick->fromsock);
+  Main *bmain = CTX_data_main(&C);
+  bNodeLink *link = create_drag_link(
+      *bmain, snode, *link_to_pick.fromnode, *link_to_pick.fromsock);
 
-  nldrag->links.append(link);
-  nodeRemLink(snode->edittree, link_to_pick);
+  nldrag.links.append(link);
+  nodeRemLink(snode.edittree, &link_to_pick);
 
-  BLI_assert(nldrag->last_node_hovered_while_dragging_a_link != nullptr);
+  BLI_assert(nldrag.last_node_hovered_while_dragging_a_link != nullptr);
 
   sort_multi_input_socket_links(
-      snode, nldrag->last_node_hovered_while_dragging_a_link, nullptr, nullptr);
+      snode, *nldrag.last_node_hovered_while_dragging_a_link, nullptr, nullptr);
 
   /* Send changed event to original link->tonode. */
   if (node) {
@@ -255,20 +256,20 @@ static void pick_link(const bContext *C,
   }
 }
 
-static void pick_input_link_by_link_intersect(const bContext *C,
-                                              wmOperator *op,
-                                              bNodeLinkDrag *nldrag,
-                                              const float *cursor)
+static void pick_input_link_by_link_intersect(const bContext &C,
+                                              wmOperator &op,
+                                              bNodeLinkDrag &nldrag,
+                                              const float2 &cursor)
 {
-  SpaceNode *snode = CTX_wm_space_node(C);
-  const ARegion *region = CTX_wm_region(C);
+  SpaceNode *snode = CTX_wm_space_node(&C);
+  const ARegion *region = CTX_wm_region(&C);
   const View2D *v2d = &region->v2d;
 
   float drag_start[2];
-  RNA_float_get_array(op->ptr, "drag_start", drag_start);
+  RNA_float_get_array(op.ptr, "drag_start", drag_start);
   bNode *node;
   bNodeSocket *socket;
-  node_find_indicated_socket(snode, &node, &socket, drag_start, SOCK_IN);
+  node_find_indicated_socket(*snode, &node, &socket, drag_start, SOCK_IN);
 
   /* Distance to test overlapping of cursor on link. */
   const float cursor_link_touch_distance = 12.5f * UI_DPI_FAC;
@@ -281,7 +282,7 @@ static void pick_input_link_by_link_intersect(const bContext *C,
     if (link->tosock == socket) {
       /* Test if the cursor is near a link. */
       float vec[4][2];
-      node_link_bezier_handles(v2d, snode, link, vec);
+      node_link_bezier_handles(v2d, snode, *link, vec);
 
       float data[NODE_LINK_RESOL * 2 + 2];
       BKE_curve_forward_diff_bezier(
@@ -295,7 +296,7 @@ static void pick_input_link_by_link_intersect(const bContext *C,
         float distance = dist_squared_to_line_segment_v2(cursor, l1, l2);
         if (distance < cursor_link_touch_distance) {
           link_to_pick = link;
-          nldrag->last_picked_multi_input_socket_link = link_to_pick;
+          nldrag.last_picked_multi_input_socket_link = link_to_pick;
         }
       }
     }
@@ -305,7 +306,7 @@ static void pick_input_link_by_link_intersect(const bContext *C,
    * Not essential for the basic behavior, but can make interaction feel a bit better if
    * the mouse moves to the right and loses the "selection." */
   if (!link_to_pick) {
-    bNodeLink *last_picked_link = nldrag->last_picked_multi_input_socket_link;
+    bNodeLink *last_picked_link = nldrag.last_picked_multi_input_socket_link;
     if (last_picked_link) {
       link_to_pick = last_picked_link;
     }
@@ -314,10 +315,10 @@ static void pick_input_link_by_link_intersect(const bContext *C,
   if (link_to_pick) {
     /* Highlight is set here and cleared in the next iteration or if the operation finishes. */
     link_to_pick->flag |= NODE_LINK_TEMP_HIGHLIGHT;
-    ED_area_tag_redraw(CTX_wm_area(C));
+    ED_area_tag_redraw(CTX_wm_area(&C));
 
-    if (!node_find_indicated_socket(snode, &node, &socket, cursor, SOCK_IN)) {
-      pick_link(C, op, nldrag, snode, node, link_to_pick);
+    if (!node_find_indicated_socket(*snode, &node, &socket, cursor, SOCK_IN)) {
+      pick_link(C, op, nldrag, *snode, node, *link_to_pick);
     }
   }
 }
@@ -418,14 +419,14 @@ static bNodeSocket *best_socket_input(bNodeTree *ntree, bNode *node, int num, in
   return nullptr;
 }
 
-static bool snode_autoconnect_input(SpaceNode *snode,
+static bool snode_autoconnect_input(SpaceNode &snode,
                                     bNode *node_fr,
                                     bNodeSocket *sock_fr,
                                     bNode *node_to,
                                     bNodeSocket *sock_to,
                                     int replace)
 {
-  bNodeTree *ntree = snode->edittree;
+  bNodeTree *ntree = snode.edittree;
 
   /* then we can connect */
   if (replace) {
@@ -437,8 +438,8 @@ static bool snode_autoconnect_input(SpaceNode *snode,
 }
 
 struct LinkAndPosition {
-  struct bNodeLink *link;
-  float multi_socket_position[2];
+  bNodeLink *link;
+  float2 multi_socket_position;
 };
 
 static int compare_link_by_y_position(const void *a, const void *b)
@@ -452,12 +453,12 @@ static int compare_link_by_y_position(const void *a, const void *b)
   return link_a_y > link_b_y ? 1 : -1;
 }
 
-void sort_multi_input_socket_links(SpaceNode *snode,
-                                   bNode *node,
+void sort_multi_input_socket_links(SpaceNode &snode,
+                                   bNode &node,
                                    bNodeLink *drag_link,
-                                   float cursor[2])
+                                   const float2 *cursor)
 {
-  LISTBASE_FOREACH (bNodeSocket *, socket, &node->inputs) {
+  LISTBASE_FOREACH (bNodeSocket *, socket, &node.inputs) {
     if (!(socket->flag & SOCK_MULTI_INPUT)) {
       continue;
     }
@@ -467,7 +468,7 @@ void sort_multi_input_socket_links(SpaceNode *snode,
         total_inputs, sizeof(LinkAndPosition *), __func__);
 
     int index = 0;
-    LISTBASE_FOREACH (bNodeLink *, link, &snode->edittree->links) {
+    LISTBASE_FOREACH (bNodeLink *, link, &snode.edittree->links) {
       if (link->tosock == socket) {
         struct LinkAndPosition *link_and_position = (LinkAndPosition *)MEM_callocN(
             sizeof(struct LinkAndPosition), __func__);
@@ -486,7 +487,9 @@ void sort_multi_input_socket_links(SpaceNode *snode,
       LinkAndPosition *link_and_position = (LinkAndPosition *)MEM_callocN(sizeof(LinkAndPosition),
                                                                           __func__);
       link_and_position->link = drag_link;
-      copy_v2_v2(link_and_position->multi_socket_position, cursor);
+      if (cursor) {
+        link_and_position->multi_socket_position = *cursor;
+      }
       input_links[index] = link_and_position;
       index++;
     }
@@ -506,12 +509,12 @@ void sort_multi_input_socket_links(SpaceNode *snode,
   }
 }
 
-static void snode_autoconnect(Main *bmain,
-                              SpaceNode *snode,
+static void snode_autoconnect(Main &bmain,
+                              SpaceNode &snode,
                               const bool allow_multiple,
                               const bool replace)
 {
-  bNodeTree *ntree = snode->edittree;
+  bNodeTree *ntree = snode.edittree;
   Vector<bNode *> sorted_nodes;
 
   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
@@ -584,7 +587,7 @@ static void snode_autoconnect(Main *bmain,
   }
 
   if (numlinks > 0) {
-    ntreeUpdateTree(bmain, ntree);
+    ntreeUpdateTree(&bmain, ntree);
   }
 }
 
@@ -639,26 +642,26 @@ static CustomDataType socket_type_to_custom_data_type(const eNodeSocketDatatype
 /**
  * Find the socket to link to in a viewer node.
  */
-static bNodeSocket *node_link_viewer_get_socket(bNodeTree *ntree,
-                                                bNode *viewer_node,
-                                                bNodeSocket *src_socket)
+static bNodeSocket *node_link_viewer_get_socket(bNodeTree &ntree,
+                                                bNode &viewer_node,
+                                                bNodeSocket &src_socket)
 {
-  if (viewer_node->type != GEO_NODE_VIEWER) {
+  if (viewer_node.type != GEO_NODE_VIEWER) {
     /* In viewer nodes in the compositor, only the first input should be linked to. */
-    return (bNodeSocket *)viewer_node->inputs.first;
+    return (bNodeSocket *)viewer_node.inputs.first;
   }
   /* For the geometry nodes viewer, find the socket with the correct type. */
-  LISTBASE_FOREACH (bNodeSocket *, viewer_socket, &viewer_node->inputs) {
-    if (viewer_socket->type == src_socket->type) {
+  LISTBASE_FOREACH (bNodeSocket *, viewer_socket, &viewer_node.inputs) {
+    if (viewer_socket->type == src_socket.type) {
       if (viewer_socket->type == SOCK_GEOMETRY) {
         return viewer_socket;
       }
-      NodeGeometryViewer *storage = (NodeGeometryViewer *)viewer_node->storage;
+      NodeGeometryViewer *storage = (NodeGeometryViewer *)viewer_node.storage;
       const CustomDataType data_type = socket_type_to_custom_data_type(
-          (eNodeSocketDatatype)src_socket->type);
+          (eNodeSocketDatatype)src_socket.type);
       BLI_assert(data_type != CD_AUTO_FROM_NAME);
       storage->data_type = data_type;
-      nodeUpdate(ntree, viewer_node);
+      nodeUpdate(&ntree, &viewer_node);
       return viewer_socket;
     }
   }
@@ -791,31 +794,31 @@ static const OutputSocketRef *find_output_socket_to_be_viewed(const NodeRef *act
   return nullptr;
 }
 
-static int link_socket_to_viewer(const bContext *C,
+static int link_socket_to_viewer(const bContext &C,
                                  bNode *viewer_bnode,
-                                 bNode *bnode_to_view,
-                                 bNodeSocket *bsocket_to_view)
+                                 bNode &bnode_to_view,
+                                 bNodeSocket &bsocket_to_view)
 {
-  SpaceNode *snode = CTX_wm_space_node(C);
-  bNodeTree *btree = snode->edittree;
+  SpaceNode &snode = *CTX_wm_space_node(&C);
+  bNodeTree &btree = *snode.edittree;
 
   if (viewer_bnode == nullptr) {
     /* Create a new viewer node if none exists. */
-    const int viewer_type = get_default_viewer_type(C);
+    const int viewer_type = get_default_viewer_type(&C);
     viewer_bnode = node_add_node(
-        C, nullptr, viewer_type, bsocket_to_view->locx + 100, bsocket_to_view->locy);
+        C, nullptr, viewer_type, bsocket_to_view.locx + 100, bsocket_to_view.locy);
     if (viewer_bnode == nullptr) {
       return OPERATOR_CANCELLED;
     }
   }
 
-  bNodeSocket *viewer_bsocket = node_link_viewer_get_socket(btree, viewer_bnode, bsocket_to_view);
+  bNodeSocket *viewer_bsocket = node_link_viewer_get_socket(btree, *viewer_bnode, bsocket_to_view);
   if (viewer_bsocket == nullptr) {
     return OPERATOR_CANCELLED;
   }
 
   bNodeLink *link_to_change = nullptr;
-  LISTBASE_FOREACH (bNodeLink *, link, &btree->links) {
+  LISTBASE_FOREACH (bNodeLink *, link, &btree.links) {
     if (link->tosock == viewer_bsocket) {
       link_to_change = link;
       break;
@@ -823,38 +826,34 @@ static int link_socket_to_viewer(const bContext *C,
   }
 
   if (link_to_change == nullptr) {
-    nodeAddLink(btree, bnode_to_view, bsocket_to_view, viewer_bnode, viewer_bsocket);
+    nodeAddLink(&btree, &bnode_to_view, &bsocket_to_view, viewer_bnode, viewer_bsocket);
   }
   else {
-    link_to_change->fromnode = bnode_to_view;
-    link_to_change->fromsock = bsocket_to_view;
-    btree->update |= NTREE_UPDATE_LINKS;
+    link_to_change->fromnode = &bnode_to_view;
+    link_to_change->fromsock = &bsocket_to_view;
+    btree.update |= NTREE_UPDATE_LINKS;
   }
 
-  remove_links_to_unavailable_viewer_sockets(*btree, *viewer_bnode);
+  remove_links_to_unavailable_viewer_sockets(btree, *viewer_bnode);
 
-  if (btree->type == NTREE_GEOMETRY) {
-    ED_spreadsheet_context_paths_set_geometry_node(CTX_data_main(C), snode, viewer_bnode);
+  if (btree.type == NTREE_GEOMETRY) {
+    ED_spreadsheet_context_paths_set_geometry_node(CTX_data_main(&C), &snode, viewer_bnode);
   }
 
-  ntreeUpdateTree(CTX_data_main(C), btree);
+  ntreeUpdateTree(CTX_data_main(&C), &btree);
   snode_update(snode, viewer_bnode);
-  DEG_id_tag_update(&btree->id, 0);
+  DEG_id_tag_update(&btree.id, 0);
 
   return OPERATOR_FINISHED;
 }
 
-static int node_link_viewer(const bContext *C, bNode *bnode_to_view)
+static int node_link_viewer(const bContext &C, bNode &bnode_to_view)
 {
-  if (bnode_to_view == nullptr) {
-    return OPERATOR_CANCELLED;
-  }
-
-  SpaceNode *snode = CTX_wm_space_node(C);
-  bNodeTree *btree = snode->edittree;
+  SpaceNode &snode = *CTX_wm_space_node(&C);
+  bNodeTree *btree = snode.edittree;
 
   const NodeTreeRef tree{btree};
-  const NodeRef &node_to_view = *tree.find_node(*bnode_to_view);
+  const NodeRef &node_to_view = *tree.find_node(bnode_to_view);
   const NodeRef *active_viewer_node = get_existing_viewer(tree);
 
   const OutputSocketRef *socket_to_view = find_output_socket_to_be_viewed(active_viewer_node,
@@ -863,7 +862,7 @@ static int node_link_viewer(const bContext *C, bNode *bnode_to_view)
     return OPERATOR_FINISHED;
   }
 
-  bNodeSocket *bsocket_to_view = socket_to_view->bsocket();
+  bNodeSocket &bsocket_to_view = *socket_to_view->bsocket();
   bNode *viewer_bnode = active_viewer_node ? active_viewer_node->bnode() : nullptr;
   return link_socket_to_viewer(C, viewer_bnode, bnode_to_view, bsocket_to_view);
 }
@@ -872,8 +871,8 @@ static int node_link_viewer(const bContext *C, bNode *bnode_to_view)
 
 static int node_active_link_viewer_exec(bContext *C, wmOperator *UNUSED(op))
 {
-  SpaceNode *snode = CTX_wm_space_node(C);
-  bNode *node = nodeGetActive(snode->edittree);
+  SpaceNode &snode = *CTX_wm_space_node(C);
+  bNode *node = nodeGetActive(snode.edittree);
 
   if (!node) {
     return OPERATOR_CANCELLED;
@@ -881,11 +880,11 @@ static int node_active_link_viewer_exec(bContext *C, wmOperator *UNUSED(op))
 
   ED_preview_kill_jobs(CTX_wm_manager(C), CTX_data_main(C));
 
-  if (blender::ed::nodes::viewer_linking::node_link_viewer(C, node) == OPERATOR_CANCELLED) {
+  if (blender::ed::nodes::viewer_linking::node_link_viewer(*C, *node) == OPERATOR_CANCELLED) {
     return OPERATOR_CANCELLED;
   }
 
-  snode_notify(C, snode);
+  snode_notify(*C, snode);
 
   return OPERATOR_FINISHED;
 }
@@ -928,48 +927,49 @@ static void node_link_update_header(bContext *C, bNodeLinkDrag *UNUSED(nldrag))
   ED_workspace_status_text(C, header);
 }
 
-static int node_count_links(const bNodeTree *ntree, const bNodeSocket *socket)
+static int node_count_links(const bNodeTree &ntree, const bNodeSocket &socket)
 {
   int count = 0;
-  LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
-    if (ELEM(socket, link->fromsock, link->tosock)) {
+  LISTBASE_FOREACH (bNodeLink *, link, &ntree.links) {
+    if (ELEM(&socket, link->fromsock, link->tosock)) {
       count++;
     }
   }
   return count;
 }
 
-static void node_remove_extra_links(SpaceNode *snode, bNodeLink *link)
+static void node_remove_extra_links(SpaceNode &snode, bNodeLink &link)
 {
-  bNodeTree *ntree = snode->edittree;
-  bNodeSocket *from = link->fromsock, *to = link->tosock;
+  bNodeTree &ntree = *snode.edittree;
+  bNodeSocket &from = *link.fromsock;
+  bNodeSocket &to = *link.tosock;
   int to_count = node_count_links(ntree, to);
   int from_count = node_count_links(ntree, from);
-  int to_link_limit = nodeSocketLinkLimit(to);
-  int from_link_limit = nodeSocketLinkLimit(from);
+  int to_link_limit = nodeSocketLinkLimit(&to);
+  int from_link_limit = nodeSocketLinkLimit(&from);
 
-  LISTBASE_FOREACH_MUTABLE (bNodeLink *, tlink, &ntree->links) {
-    if (tlink == link) {
+  LISTBASE_FOREACH_MUTABLE (bNodeLink *, tlink, &ntree.links) {
+    if (tlink == &link) {
       continue;
     }
 
-    if (tlink && tlink->fromsock == from) {
+    if (tlink && tlink->fromsock == &from) {
       if (from_count > from_link_limit) {
-        nodeRemLink(ntree, tlink);
+        nodeRemLink(&ntree, tlink);
         tlink = nullptr;
         from_count--;
       }
     }
 
-    if (tlink && tlink->tosock == to) {
+    if (tlink && tlink->tosock == &to) {
       if (to_count > to_link_limit) {
-        nodeRemLink(ntree, tlink);
+        nodeRemLink(&ntree, tlink);
         tlink = nullptr;
         to_count--;
       }
-      else if (tlink->fromsock == from) {
+      else if (tlink->fromsock == &from) {
         /* Also remove link if it comes from the same output. */
-        nodeRemLink(ntree, tlink);
+        nodeRemLink(&ntree, tlink);
         tlink = nullptr;
         to_count--;
         from_count--;
@@ -978,18 +978,18 @@ static void node_remove_extra_links(SpaceNode *snode, bNodeLink *link)
   }
 }
 
-static void node_link_exit(bContext *C, wmOperator *op, bool apply_links)
+static void node_link_exit(bContext &C, wmOperator &op, const bool apply_links)
 {
-  Main *bmain = CTX_data_main(C);
-  SpaceNode *snode = CTX_wm_space_node(C);
-  bNodeTree *ntree = snode->edittree;
-  bNodeLinkDrag *nldrag = (bNodeLinkDrag *)op->customdata;
+  Main *bmain = CTX_data_main(&C);
+  SpaceNode &snode = *CTX_wm_space_node(&C);
+  bNodeTree &ntree = *snode.edittree;
+  bNodeLinkDrag *nldrag = (bNodeLinkDrag *)op.customdata;
   bool do_tag_update = false;
   /* View will be reset if no links connect. */
   bool reset_view = true;
 
   /* avoid updates while applying links */
-  ntree->is_updating = true;
+  ntree.is_updating = true;
   for (bNodeLink *link : nldrag->links) {
     /* See note below, but basically TEST flag means that the link
      * was connected to output (or to a node which affects the
@@ -1004,52 +1004,52 @@ static void node_link_exit(bContext *C, wmOperator *op, bool apply_links)
        * let nodes perform special link insertion handling
        */
       if (link->fromnode->typeinfo->insert_link) {
-        link->fromnode->typeinfo->insert_link(ntree, link->fromnode, link);
+        link->fromnode->typeinfo->insert_link(&ntree, link->fromnode, link);
       }
       if (link->tonode->typeinfo->insert_link) {
-        link->tonode->typeinfo->insert_link(ntree, link->tonode, link);
+        link->tonode->typeinfo->insert_link(&ntree, link->tonode, link);
       }
 
       /* add link to the node tree */
-      BLI_addtail(&ntree->links, link);
+      BLI_addtail(&ntree.links, link);
 
-      ntree->update |= NTREE_UPDATE_LINKS;
+      ntree.update |= NTREE_UPDATE_LINKS;
 
       /* tag tonode for update */
       link->tonode->update |= NODE_UPDATE;
 
       /* we might need to remove a link */
-      node_remove_extra_links(snode, link);
+      node_remove_extra_links(snode, *link);
 
       if (link->tonode) {
-        do_tag_update |= (do_tag_update || node_connected_to_output(bmain, ntree, link->tonode));
+        do_tag_update |= (do_tag_update || node_connected_to_output(*bmain, ntree, *link->tonode));
       }
 
       reset_view = false;
     }
     else {
-      nodeRemLink(ntree, link);
+      nodeRemLink(&ntree, link);
     }
   }
-  ntree->is_updating = false;
+  ntree.is_updating = false;
 
-  ntreeUpdateTree(bmain, ntree);
+  ntreeUpdateTree(bmain, &ntree);
   snode_notify(C, snode);
   if (do_tag_update) {
     snode_dag_update(C, snode);
   }
 
   if (reset_view) {
-    UI_view2d_edge_pan_cancel(C, &nldrag->pan_data);
+    UI_view2d_edge_pan_cancel(&C, &nldrag->pan_data);
   }
 
-  snode->runtime->linkdrag.reset();
+  snode.runtime->linkdrag.reset();
 }
 
-static void node_link_find_socket(bContext *C, wmOperator *op, float cursor[2])
+static void node_link_find_socket(bContext &C, wmOperator &op, const float2 &cursor)
 {
-  SpaceNode *snode = CTX_wm_space_node(C);
-  bNodeLinkDrag *nldrag = (bNodeLinkDrag *)op->customdata;
+  SpaceNode &snode = *CTX_wm_space_node(&C);
+  bNodeLinkDrag *nldrag = (bNodeLinkDrag *)op.customdata;
 
   if (nldrag->in_out == SOCK_OUT) {
     bNode *tnode;
@@ -1063,7 +1063,7 @@ static void node_link_find_socket(bContext *C, wmOperator *op, float cursor[2])
 
         /* Skip if tsock is already linked with this output. */
         bNodeLink *existing_link_connected_to_fromsock = nullptr;
-        LISTBASE_FOREACH (bNodeLink *, existing_link, &snode->edittree->links) {
+        LISTBASE_FOREACH (bNodeLink *, existing_link, &snode.edittree->links) {
           if (existing_link->fromsock == link->fromsock && existing_link->tosock == tsock) {
             existing_link_connected_to_fromsock = existing_link;
             break;
@@ -1080,7 +1080,7 @@ static void node_link_find_socket(bContext *C, wmOperator *op, float cursor[2])
           continue;
         }
         if (link->tosock && link->tosock->flag & SOCK_MULTI_INPUT) {
-          sort_multi_input_socket_links(snode, tnode, link, cursor);
+          sort_multi_input_socket_links(snode, *tnode, link, &cursor);
         }
       }
     }
@@ -1088,7 +1088,7 @@ static void node_link_find_socket(bContext *C, wmOperator *op, float cursor[2])
       for (bNodeLink *link : nldrag->links) {
         if (nldrag->last_node_hovered_while_dragging_a_link) {
           sort_multi_input_socket_links(
-              snode, nldrag->last_node_hovered_while_dragging_a_link, nullptr, cursor);
+              snode, *nldrag->last_node_hovered_while_dragging_a_link, nullptr, &cursor);
         }
         link->tonode = nullptr;
         link->tosock = nullptr;
@@ -1129,19 +1129,19 @@ static int node_link_modal(bContext *C, wmOperator *op, const wmEvent *event)
 {
   bNodeLinkDrag *nldrag = (bNodeLinkDrag *)op->customdata;
   ARegion *region = CTX_wm_region(C);
-  float cursor[2];
 
   UI_view2d_edge_pan_apply_event(C, &nldrag->pan_data, event);
 
-  UI_view2d_region_to_view(&region->v2d, event->mval[0], event->mval[1], &cursor[0], &cursor[1]);
+  float2 cursor;
+  UI_view2d_region_to_view(&region->v2d, event->mval[0], event->mval[1], &cursor.x, &cursor.y);
 
   switch (event->type) {
     case MOUSEMOVE:
       if (nldrag->from_multi_input_socket && !RNA_boolean_get(op->ptr, "has_link_picked")) {
-        pick_input_link_by_link_intersect(C, op, nldrag, cursor);
+        pick_input_link_by_link_intersect(*C, *op, *nldrag, cursor);
       }
       else {
-        node_link_find_socket(C, op, cursor);
+        node_link_find_socket(*C, *op, cursor);
 
         node_link_update_header(C, nldrag);
         ED_region_tag_redraw(region);
@@ -1152,12 +1152,12 @@ static int node_link_modal(bContext *C, wmOperator *op, const wmEvent *event)
     case RIGHTMOUSE:
     case MIDDLEMOUSE: {
       if (event->val == KM_RELEASE) {
-        node_link_exit(C, op, true);
+        node_link_exit(*C, *op, true);
 
         ED_workspace_status_text(C, nullptr);
         ED_region_tag_redraw(region);
-        SpaceNode *snode = CTX_wm_space_node(C);
-        clear_picking_highlight(&snode->edittree->links);
+        SpaceNode &snode = *CTX_wm_space_node(C);
+        clear_picking_highlight(&snode.edittree->links);
         return OPERATOR_FINISHED;
       }
       break;
@@ -1167,10 +1167,10 @@ static int node_link_modal(bContext *C, wmOperator *op, const wmEvent *event)
   return OPERATOR_RUNNING_MODAL;
 }
 
-static std::unique_ptr<bNodeLinkDrag> node_link_init(Main *bmain,
-                                                     SpaceNode *snode,
-                                                     float cursor[2],
-                                                     bool detach)
+static std::unique_ptr<bNodeLinkDrag> node_link_init(Main &bmain,
+                                                     SpaceNode &snode,
+                                                     float2 cursor,
+                                                     const bool detach)
 {
   /* output indicated? */
   bNode *node;
@@ -1178,13 +1178,13 @@ static std::unique_ptr<bNodeLinkDrag> node_link_init(Main *bmain,
   if (node_find_indicated_socket(snode, &node, &sock, cursor, SOCK_OUT)) {
     std::unique_ptr<bNodeLinkDrag> nldrag = std::make_unique<bNodeLinkDrag>();
 
-    const int num_links = nodeCountSocketLinks(snode->edittree, sock);
+    const int num_links = nodeCountSocketLinks(snode.edittree, sock);
     int link_limit = nodeSocketLinkLimit(sock);
     if (num_links > 0 && (num_links >= link_limit || detach)) {
       /* dragged links are fixed on input side */
       nldrag->in_out = SOCK_IN;
       /* detach current links and store them in the operator data */
-      LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &snode->edittree->links) {
+      LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &snode.edittree->links) {
         if (link->fromsock == sock) {
           bNodeLink *oplink = (bNodeLink *)MEM_callocN(sizeof(bNodeLink), "drag link op link");
           *oplink = *link;
@@ -1199,12 +1199,12 @@ static std::unique_ptr<bNodeLinkDrag> node_link_init(Main *bmain,
            * using TEST flag.
            */
           oplink->flag &= ~NODE_LINK_TEST;
-          if (node_connected_to_output(bmain, snode->edittree, link->tonode)) {
+          if (node_connected_to_output(bmain, *snode.edittree, *link->tonode)) {
             oplink->flag |= NODE_LINK_TEST;
           }
 
           nldrag->links.append(oplink);
-          nodeRemLink(snode->edittree, link);
+          nodeRemLink(snode.edittree, link);
         }
       }
     }
@@ -1212,7 +1212,7 @@ static std::unique_ptr<bNodeLinkDrag> node_link_init(Main *bmain,
       /* dragged links are fixed on output side */
       nldrag->in_out = SOCK_OUT;
       /* create a new link */
-      nldrag->links.append(create_drag_link(bmain, snode, node, sock));
+      nldrag->links.append(create_drag_link(bmain, snode, *node, *sock));
     }
     return nldrag;
   }
@@ -1222,13 +1222,13 @@ static std::unique_ptr<bNodeLinkDrag> node_link_init(Main *bmain,
     std::unique_ptr<bNodeLinkDrag> nldrag = std::make_unique<bNodeLinkDrag>();
     nldrag->last_node_hovered_while_dragging_a_link = node;
 
-    const int num_links = nodeCountSocketLinks(snode->edittree, sock);
+    const int num_links = nodeCountSocketLinks(snode.edittree, sock);
     if (num_links > 0) {
       /* dragged links are fixed on output side */
       nldrag->in_out = SOCK_OUT;
       /* detach current links and store them in the operator data */
       bNodeLink *link_to_pick;
-      LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &snode->edittree->links) {
+      LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &snode.edittree->links) {
         if (link->tosock == sock) {
           if (sock->flag & SOCK_MULTI_INPUT) {
             nldrag->from_multi_input_socket = true;
@@ -1244,12 +1244,12 @@ static std::unique_ptr<bNodeLinkDrag> node_link_init(Main *bmain,
         oplink->flag |= NODE_LINK_VALID;
         oplink->flag |= NODE_LINK_DRAGGED;
         oplink->flag &= ~NODE_LINK_TEST;
-        if (node_connected_to_output(bmain, snode->edittree, link_to_pick->tonode)) {
+        if (node_connected_to_output(bmain, *snode.edittree, *link_to_pick->tonode)) {
           oplink->flag |= NODE_LINK_TEST;
         }
 
         nldrag->links.append(oplink);
-        nodeRemLink(snode->edittree, link_to_pick);
+        nodeRemLink(snode.edittree, link_to_pick);
 
         /* send changed event to original link->tonode */
         if (node) {
@@ -1261,7 +1261,7 @@ static std::unique_ptr<bNodeLinkDrag> node_link_init(Main *bmain,
       /* dragged links are fixed on input side */
       nldrag->in_out = SOCK_IN;
       /* create a new link */
-      nldrag->links.append(create_drag_link(bmain, snode, node, sock));
+      nldrag->links.append(create_drag_link(bmain, snode, *node, *sock));
     }
     return nldrag;
   }
@@ -1271,26 +1271,26 @@ static std::unique_ptr<bNodeLinkDrag> node_link_init(Main *bmain,
 
 static int node_link_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 {
-  Main *bmain = CTX_data_main(C);
-  SpaceNode *snode = CTX_wm_space_node(C);
-  ARegion *region = CTX_wm_region(C);
+  Main &bmain = *CTX_data_main(C);
+  SpaceNode &snode = *CTX_wm_space_node(C);
+  ARegion &region = *CTX_wm_region(C);
 
   bool detach = RNA_boolean_get(op->ptr, "detach");
 
-  float cursor[2];
-  UI_view2d_region_to_view(&region->v2d, event->mval[0], event->mval[1], &cursor[0], &cursor[1]);
+  float2 cursor;
+  UI_view2d_region_to_view(&region.v2d, event->mval[0], event->mval[1], &cursor[0], &cursor[1]);
   RNA_float_set_array(op->ptr, "drag_start", cursor);
   RNA_boolean_set(op->ptr, "has_link_picked", false);
 
-  ED_preview_kill_jobs(CTX_wm_manager(C), bmain);
+  ED_preview_kill_jobs(CTX_wm_manager(C), &bmain);
 
   std::unique_ptr<bNodeLinkDrag> nldrag = node_link_init(bmain, snode, cursor, detach);
 
   if (nldrag) {
     UI_view2d_edge_pan_operator_init(C, &nldrag->pan_data, op);
 
-    snode->runtime->linkdrag = std::move(nldrag);
-    op->customdata = snode->runtime->linkdrag.get();
+    snode.runtime->linkdrag = std::move(nldrag);
+    op->customdata = snode.runtime->linkdrag.get();
 
     /* add modal handler */
     WM_event_add_modal_handler(C, op);
@@ -1371,11 +1371,11 @@ void NODE_OT_link(wmOperatorType *ot)
 /* makes a link between selected output and input sockets */
 static int node_make_link_exec(bContext *C, wmOperator *op)
 {
-  Main *bmain = CTX_data_main(C);
-  SpaceNode *snode = CTX_wm_space_node(C);
+  Main &bmain = *CTX_data_main(C);
+  SpaceNode &snode = *CTX_wm_space_node(C);
   const bool replace = RNA_boolean_get(op->ptr, "replace");
 
-  ED_preview_kill_jobs(CTX_wm_manager(C), bmain);
+  ED_preview_kill_jobs(CTX_wm_manager(C), &bmain);
 
   snode_autoconnect(bmain, snode, true, replace);
 
@@ -1383,9 +1383,9 @@ static int node_make_link_exec(bContext *C, wmOperator *op)
   node_deselect_all_input_sockets(snode, false);
   node_deselect_all_output_sockets(snode, false);
 
-  ntreeUpdateTree(CTX_data_main(C), snode->edittree);
-  snode_notify(C, snode);
-  snode_dag_update(C, snode);
+  ntreeUpdateTree(CTX_data_main(C), snode.edittree);
+  snode_notify(*C, snode);
+  snode_dag_update(*C, snode);
 
   return OPERATOR_FINISHED;
 }
@@ -1415,7 +1415,7 @@ void NODE_OT_link_make(wmOperatorType *ot)
 /** \name Node Link Intersect
  * \{ */
 
-static bool node_links_intersect(bNodeLink *link, const float mcoords[][2], int tot)
+static bool node_links_intersect(bNodeLink &link, const float mcoords[][2], int tot)
 {
   float coord_array[NODE_LINK_RESOL + 1][2];
 
@@ -1439,9 +1439,9 @@ static bool node_links_intersect(bNodeLink *link, const float mcoords[][2], int
 
 static int cut_links_exec(bContext *C, wmOperator *op)
 {
-  Main *bmain = CTX_data_main(C);
-  SpaceNode *snode = CTX_wm_space_node(C);
-  ARegion *region = CTX_wm_region(C);
+  Main &bmain = *CTX_data_main(C);
+  SpaceNode &snode = *CTX_wm_space_node(C);
+  ARegion &region = *CTX_wm_region(C);
   bool do_tag_update = false;
 
   int i = 0;
@@ -1451,7 +1451,7 @@ static int cut_links_exec(bContext *C, wmOperator *op)
 
     RNA_float_get_array(&itemptr, "loc", loc);
     UI_view2d_region_to_view(
-        &region->v2d, (int)loc[0], (int)loc[1], &mcoords[i][0], &mcoords[i][1]);
+        &region.v2d, (int)loc[0], (int)loc[1], &mcoords[i][0], &mcoords[i][1]);
     i++;
     if (i >= 256) {
       break;
@@ -1462,36 +1462,36 @@ static int cut_links_exec(bContext *C, wmOperator *op)
   if (i > 1) {
     bool found = false;
 
-    ED_preview_kill_jobs(CTX_wm_manager(C), bmain);
+    ED_preview_kill_jobs(CTX_wm_manager(C), &bmain);
 
-    LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &snode->edittree->links) {
-      if (node_link_is_hidden_or_dimmed(&region->v2d, link)) {
+    LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &snode.edittree->links) {
+      if (node_link_is_hidden_or_dimmed(region.v2d, *link)) {
         continue;
       }
 
-      if (node_links_intersect(link, mcoords, i)) {
+      if (node_links_intersect(*link, mcoords, i)) {
 
         if (found == false) {
           /* TODO(sergey): Why did we kill jobs twice? */
-          ED_preview_kill_jobs(CTX_wm_manager(C), bmain);
+          ED_preview_kill_jobs(CTX_wm_manager(C), &bmain);
           found = true;
         }
 
         do_tag_update |= (do_tag_update ||
-                          node_connected_to_output(bmain, snode->edittree, link->tonode));
+                          node_connected_to_output(bmain, *snode.edittree, *link->tonode));
 
         snode_update(snode, link->tonode);
         bNode *to_node = link->tonode;
-        nodeRemLink(snode->edittree, link);
-        sort_multi_input_socket_links(snode, to_node, nullptr, nullptr);
+        nodeRemLink(snode.edittree, link);
+        sort_multi_input_socket_links(snode, *to_node, nullptr, nullptr);
       }
     }
 
     if (found) {
-      ntreeUpdateTree(CTX_data_main(C), snode->edittree);
-      snode_notify(C, snode);
+      ntreeUpdateTree(CTX_data_main(C), snode.edittree);
+      snode_notify(*C, snode);
       if (do_tag_update) {
-        snode_dag_update(C, snode);
+        snode_dag_update(*C, snode);
       }
 
       return OPERATOR_FINISHED;
@@ -1536,9 +1536,9 @@ void NODE_OT_links_cut(wmOperatorType *ot)
 
 static int mute_links_exec(bContext *C, wmOperator *op)
 {
-  Main *bmain = CTX_data_main(C);
-  SpaceNode *snode = CTX_wm_space_node(C);
-  ARegion *region = CTX_wm_region(C);
+  Main &bmain = *CTX_data_main(C);
+  SpaceNode &snode = *CTX_wm_space_node(C);
+  ARegion &region = *CTX_wm_region(C);
   bool do_tag_update = false;
 
   int i = 0;
@@ -1548,7 +1548,7 @@ static int mute_links_exec(bContext *C, wmOperator *op)
 
     RNA_float_get_array(&itemptr, "loc", loc);
     UI_view2d_region_to_view(
-        &region->v2d, (int)loc[0], (int)loc[1], &mcoords[i][0], &mcoords[i][1]);
+        &region.v2d, (int)loc[0], (int)loc[1], &mcoords[i][0], &mcoords[i][1]);
     i++;
     if (i >= 256) {
       break;
@@ -1557,16 +1557,16 @@ static int mute_links_exec(bContext *C, wmOperator *op)
   RNA_END;
 
   if (i > 1) {
-    ED_preview_kill_jobs(CTX_wm_manager(C), bmain);
+    ED_preview_kill_jobs(CTX_wm_manager(C), &bmain);
 
     /* Count intersected links and clear test flag. */
     int tot = 0;
-    LISTBASE_FOREACH (bNodeLink *, link, &snode->edittree->links) {
-      if (node_link_is_hidden_or_dimmed(&region->v2d, link)) {
+    LISTBASE_FOREACH (bNodeLink *, link, &snode.edittree->links) {
+      if (node_link_is_hidden_or_dimmed(region.v2d, *link)) {
         continue;
       }
       link->flag &= ~NODE_LINK_TEST;
-      if (node_links_intersect(link, mcoords, i)) {
+      if (node_links_intersect(*link, mcoords, i)) {
         tot++;
       }
     }
@@ -1575,32 +1575,32 @@ static int mute_links_exec(bContext *C, wmOperator *op)
     }
 
     /* Mute links. */
-    LISTBASE_FOREACH (bNodeLink *, link, &snode->edittree->links) {
-      if (node_link_is_hidden_or_dimmed(&region->v2d, link) || (link->flag & NODE_LINK_TEST)) {
+    LISTBASE_FOREACH (bNodeLink *, link, &snode.edittree->links) {
+      if (node_link_is_hidden_or_dimmed(region.v2d, *link) || (link->flag & NODE_LINK_TEST)) {
         continue;
       }
 
-      if (node_links_intersect(link, mcoords, i)) {
+      if (node_links_intersect(*link, mcoords, i)) {
         do_tag_update |= (do_tag_update ||
-                          node_connected_to_output(bmain, snode->edittree, link->tonode));
+                          node_connected_to_output(bmain, *snode.edittree, *link->tonode));
 
         snode_update(snode, link->tonode);
-        nodeMuteLinkToggle(snode->edittree, link);
+        nodeMuteLinkToggle(snode.edittree, link);
       }
     }
 
     /* Clear remaining test flags. */
-    LISTBASE_FOREACH (bNodeLink *, link, &snode->edittree->links) {
-      if (node_link_is_hidden_or_dimmed(&region->v2d, link)) {
+    LISTBASE_FOREACH (bNodeLink *, link, &snode.edittree->links) {
+      if (node_link_is_hidden_or_dimmed(region.v2d, *link)) {
         continue;
       }
       link->flag &= ~NODE_LINK_TEST;
     }
 
-    ntreeUpdateTree(CTX_data_main(C), snode->edittree);
-    snode_notify(C, snode);
+    ntreeUpdateTree(CTX_data_main(C), snode.edittree);
+    snode_notify(*C, snode);
     if (do_tag_update) {
-      snode_dag_update(C, snode);
+      snode_dag_update(*C, snode);
     }
 
     return OPERATOR_FINISHED;
@@ -1642,21 +1642,21 @@ void NODE_OT_links_mute(wmOperatorType *ot)
 
 static int detach_links_exec(bContext *C, wmOperator *UNUSED(op))
 {
-  SpaceNode *snode = CTX_wm_space_node(C);
-  bNodeTree *ntree = snode->edittree;
+  SpaceNode &snode = *CTX_wm_space_node(C);
+  bNodeTree &ntree = *snode.edittree;
 
   ED_preview_kill_jobs(CTX_wm_manager(C), CTX_data_main(C));
 
-  LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
+  LISTBASE_FOREACH (bNode *, node, &ntree.nodes) {
     if (node->flag & SELECT) {
-      nodeInternalRelink(ntree, node);
+      nodeInternalRelink(&ntree, node);
     }
   }
 
-  ntreeUpdateTree(CTX_data_main(C), ntree);
+  ntreeUpdateTree(CTX_data_main(C), &ntree);
 
-  snode_notify(C, snode);
-  snode_dag_update(C, snode);
+  snode_notify(*C, snode);
+  snode_dag_update(*C, snode);
 
   return OPERATOR_FINISHED;
 }
@@ -1763,12 +1763,12 @@ static void node_join_attach_recursive(bNode *node, bNode *frame)
 
 static int node_join_exec(bContext *C, wmOperator *UNUSED(op))
 {
-  SpaceNode *snode = CTX_wm_space_node(C);
-  bNodeTree *ntree = snode->edittree;
+  SpaceNode &snode = *CTX_wm_space_node(C);
+  bNodeTree &ntree = *snode.edittree;
 
   /* XXX save selection: node_add_node call below sets the new frame as single
    * active+selected node */
-  LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
+  LISTBASE_FOREACH (bNode *, node, &ntree.nodes) {
     if (node->flag & NODE_SELECT) {
       node->flag |= NODE_TEST;
     }
@@ -1777,27 +1777,27 @@ static int node_join_exec(bContext *C, wmOperator *UNUSED(op))
     }
   }
 
-  bNode *frame = node_add_node(C, nullptr, NODE_FRAME, 0.0f, 0.0f);
+  bNode *frame = node_add_node(*C, nullptr, NODE_FRAME, 0.0f, 0.0f);
 
   /* reset tags */
-  LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
+  LISTBASE_FOREACH (bNode *, node, &ntree.nodes) {
     node->done = 0;
   }
 
-  LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
+  LISTBASE_FOREACH (bNode *, node, &ntree.nodes) {
     if (!(node->done & NODE_JOIN_DONE)) {
       node_join_attach_recursive(node, frame);
     }
   }
 
   /* restore selection */
-  LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
+  LISTBASE_FOREACH (bNode *, node, &ntree.nodes) {
     if (node->flag & NODE_TEST) {
       node->flag |= NODE_SELECT;
     }
   }
 
-  ED_node_sort(ntree);
+  ED_node_sort(&ntree);
   WM_event_add_notifier(C, NC_NODE | ND_DISPLAY, nullptr);
 
   return OPERATOR_FINISHED;
@@ -2031,7 +2031,7 @@ static bool ed_node_link_conditions(ScrArea *area,
 
   /* test node for links */
   LISTBASE_FOREACH (bNodeLink *, link, &snode->edittree->links) {
-    if (node_link_is_hidden_or_dimmed(&region->v2d, link)) {
+    if (node_link_is_hidden_or_dimmed(region->v2d, *link)) {
       continue;
     }
 
@@ -2070,11 +2070,11 @@ void ED_node_link_intersect_test(ScrArea *area, int test)
   LISTBASE_FOREACH (bNodeLink *, link, &snode->edittree->links) {
     float coord_array[NODE_LINK_RESOL + 1][2];
 
-    if (node_link_is_hidden_or_dimmed(&region->v2d, link)) {
+    if (node_link_is_hidden_or_dimmed(region->v2d, *link)) {
       continue;
     }
 
-    if (node_link_bezier_points(nullptr, nullptr, link, coord_array, NODE_LINK_RESOL)) {
+    if (node_link_bezier_points(nullptr, nullptr, *link, coord_array, NODE_LINK_RESOL)) {
       float dist = FLT_MAX;
 
       /* loop over link coords to find shortest dist to
@@ -2210,19 +2210,19 @@ static bool node_parents_offset_flag_enable_cb(bNode *parent, void *UNUSED(userd
   return true;
 }
 
-static void node_offset_apply(bNode *node, const float offset_x)
+static void node_offset_apply(bNode &node, const float offset_x)
 {
   /* NODE_TEST is used to flag nodes that shouldn't be offset (again) */
-  if ((node->flag & NODE_TEST) == 0) {
-    node->anim_init_locx = node->locx;
-    node->anim_ofsx = (offset_x / UI_DPI_FAC);
-    node->flag |= NODE_TEST;
+  if ((node.flag & NODE_TEST) == 0) {
+    node.anim_init_locx = node.locx;
+    node.anim_ofsx = (offset_x / UI_DPI_FAC);
+    node.flag |= NODE_TEST;
   }
 }
 
 static void node_parent_offset_apply(NodeInsertOfsData *data, bNode *parent, const float offset_x)
 {
-  node_offset_apply(parent, offset_x);
+  node_offset_apply(*parent, offset_x);
 
   /* Flag all children as offset to prevent them from being offset
    * separately (they've already moved with the parent). */
@@ -2249,10 +2249,10 @@ static bool node_link_insert_offset_frame_chain_cb(bNode *fromnode,
   bNode *ofs_node = reversed ? fromnode : tonode;
 
   if (ofs_node->parent && ofs_node->parent != data->insert_parent) {
-    node_offset_apply(ofs_node->parent, data->offset_x);
+    node_offset_apply(*ofs_node->parent, data->offset_x);
   }
   else {
-    node_offset_apply(ofs_node, data->offset_x);
+    node_offset_apply(*ofs_node, data->offset_x);
   }
 
   return true;
@@ -2291,7 +2291,7 @@ static bool node_link_insert_offset_chain_cb(bNode *fromnode,
       node_link_insert_offset_frame_chains(data->ntree, ofs_node->parent, data, reversed);
     }
     else {
-      node_offset_apply(ofs_node, data->offset_x);
+      node_offset_apply(*ofs_node, data->offset_x);
     }
 
     if (nodeIsChildOf(data->insert_parent, ofs_node) == false) {
@@ -2300,10 +2300,10 @@ static bool node_link_insert_offset_chain_cb(bNode *fromnode,
   }
   else if (ofs_node->parent) {
     bNode *node = nodeFindRootParent(ofs_node);
-    node_offset_apply(node, data->offset_x);
+    node_offset_apply(*node, data->offset_x);
   }
   else {
-    node_offset_apply(ofs_node, data->offset_x);
+    node_offset_apply(*ofs_node, data->offset_x);
   }
 
   return true;
@@ -2315,9 +2315,9 @@ static void node_link_insert_offset_ntree(NodeInsertOfsData *iofsd,
                                           const bool right_alignment)
 {
   bNodeTree *ntree = iofsd->ntree;
-  bNode *insert = iofsd->insert;
+  bNode &insert = *iofsd->insert;
   bNode *prev = iofsd->prev, *next = iofsd->next;
-  bNode *init_parent = insert->parent; /* store old insert->parent for restoring later */
+  bNode *init_parent = insert.parent; /* store old insert.parent for restoring later */
 
   const float min_margin = U.node_margin * UI_DPI_FAC;
   const float width = NODE_WIDTH(insert);
@@ -2328,20 +2328,20 @@ static void node_link_insert_offset_ntree(NodeInsertOfsData *iofsd,
   /* NODE_TEST will be used later, so disable for all nodes */
   ntreeNodeFlagSet(ntree, NODE_TEST, false);
 
-  /* `insert->totr` isn't updated yet,
+  /* `insert.totr` isn't updated yet,
    * so `totr_insert` is used to get the correct world-space coords. */
   rctf totr_insert;
-  node_to_updated_rect(insert, &totr_insert);
+  node_to_updated_rect(insert, totr_insert);
 
   /* frame attachment wasn't handled yet
    * so we search the frame that the node will be attached to later */
-  insert->parent = node_find_frame_to_attach(region, ntree, mouse_xy);
+  insert.parent = node_find_frame_to_attach(region, ntree, mouse_xy);
 
   /* this makes sure nodes are also correctly offset when inserting a node on top of a frame
    * without actually making it a part of the frame (because mouse isn't intersecting it)
    * - logic here is similar to node_find_frame_to_attach */
-  if (!insert->parent ||
-      (prev->parent && (prev->parent == next->parent) && (prev->parent != insert->parent))) {
+  if (!insert.parent ||
+      (prev->parent && (prev->parent == next->parent) && (prev->parent != insert.parent))) {
     bNode *frame;
     rctf totr_frame;
 
@@ -2353,15 +2353,15 @@ static void node_link_insert_offset_ntree(NodeInsertOfsData *iofsd,
       }
 
       /* for some reason frame y coords aren't correct yet */
-      node_to_updated_rect(frame, &totr_frame);
+      node_to_updated_rect(*frame, totr_frame);
 
       if (BLI_rctf_isect_x(&totr_frame, totr_insert.xmin) &&
           BLI_rctf_isect_x(&totr_frame, totr_insert.xmax)) {
         if (BLI_rctf_isect_y(&totr_frame, totr_insert.ymin) ||
             BLI_rctf_isect_y(&totr_frame, totr_insert.ymax)) {
-          /* frame isn't insert->parent actually, but this is needed to make offsetting
+          /* frame isn't insert.parent actually, but this is needed to make offsetting
            * nodes work correctly for above checked cases (it is restored later) */
-          insert->parent = frame;
+          insert.parent = frame;
           break;
         }
       }
@@ -2391,12 +2391,12 @@ static void node_link_insert_offset_ntree(NodeInsertOfsData *iofsd,
     const float addval = (min_margin - dist) * (right_alignment ? 1.0f : -1.0f);
     if (needs_alignment) {
       bNode *offs_node = right_alignment ? next : prev;
-      if (!offs_node->parent || offs_node->parent == insert->parent ||
-          nodeIsChildOf(offs_node->parent, insert)) {
-        node_offset_apply(offs_node, addval);
+      if (!offs_node->parent || offs_node->parent == insert.parent ||
+          nodeIsChildOf(offs_node->parent, &insert)) {
+        node_offset_apply(*offs_node, addval);
       }
-      else if (!insert->parent && offs_node->parent) {
-        node_offset_apply(nodeFindRootParent(offs_node), addval);
+      else if (!insert.parent && offs_node->parent) {
+        node_offset_apply(*nodeFindRootParent(offs_node), addval);
       }
       margin = addval;
     }
@@ -2408,11 +2408,11 @@ static void node_link_insert_offset_ntree(NodeInsertOfsData *iofsd,
   }
 
   if (needs_alignment) {
-    iofsd->insert_parent = insert->parent;
+    iofsd->insert_parent = insert.parent;
     iofsd->offset_x = margin;
 
     /* flag all parents of insert as offset to prevent them from being offset */
-    nodeParentsIter(insert, node_parents_offset_flag_enable_cb, nullptr);
+    nodeParentsIter(&insert, node_parents_offset_flag_enable_cb, nullptr);
     /* iterate over entire chain and apply offsets */
     nodeChainIter(ntree,
                   right_alignment ? next : prev,
@@ -2421,7 +2421,7 @@ static void node_link_insert_offset_ntree(NodeInsertOfsData *iofsd,
                   !right_alignment);
   }
 
-  insert->parent = init_parent;
+  insert.parent = init_parent;
 }
 
 /**
@@ -2553,7 +2553,7 @@ void ED_node_link_insert(Main *bmain, ScrArea *area)
 
       link->tonode = select;
       link->tosock = best_input;
-      node_remove_extra_links(snode, link);
+      node_remove_extra_links(*snode, *link);
       link->flag &= ~NODE_LINKFLAG_HILITE;
 
       bNodeLink *new_link = nodeAddLink(snode->edittree, select, best_output, node, sockto);
@@ -2576,7 +2576,7 @@ void ED_node_link_insert(Main *bmain, ScrArea *area)
       }
 
       ntreeUpdateTree(bmain, snode->edittree); /* needed for pointers */
-      snode_update(snode, select);
+      snode_update(*snode, select);
       ED_node_tag_update_id((ID *)snode->edittree);
       ED_node_tag_update_id(snode->id);
     }