Remove redundant NULL-after-free, rename const_ files, fix stale comments

Post-refactor cleanup after the Constant→Parameter merge:
- Remove dead NULL assignments in free_type_data (quad_form, hstack, index, linear_op, left_matmul, scalar_mult, vector_mult)
- Rename const_scalar_mult/const_vector_mult source and test files to drop const_ prefix
- Rename test_variable_constant.h → test_variable_parameter.h and test_constant → test_fixed_parameter
- Update stale comments in multiply.c and bivariate.h
- Rename const_scalar_mult_expr/const_vector_mult_expr structs to scalar_mult_expr/vector_mult_expr
- Update left_matmul param_source comment

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Transurgeon

include/bivariate.h

@@ -33,7 +33,7 @@ expr *new_matmul(expr *x, expr *y);
 /* Left matrix multiplication: A @ f(x) where A comes from a parameter node */
 expr *new_left_matmul(expr *param_node, expr *child);
 
-/* Right matrix multiplication: f(x) @ A where A is a constant matrix */
+/* Right matrix multiplication: f(x) @ A where A is a fixed parameter matrix */
 expr *new_right_matmul(expr *u, const CSR_Matrix *A);
 
 /* Scalar multiplication: a * f(x) where a comes from a parameter node */

include/subexpr.h

@@ -126,7 +126,7 @@ typedef struct left_matmul_expr
     CSC_Matrix *Jchild_CSC;
     CSC_Matrix *J_CSC;
     int *csc_to_csr_workspace;
-    expr *param_source; /* if non-NULL, A/AT values come from this parameter */
+    expr *param_source; /* parameter node; A/AT values are refreshed from this */
     int src_m, src_n;   /* original matrix dimensions */
 } left_matmul_expr;
 
@@ -142,19 +142,19 @@ typedef struct right_matmul_expr
 } right_matmul_expr;
 
 /* Scalar multiplication: y = a * child where a comes from a parameter node */
-typedef struct const_scalar_mult_expr
+typedef struct scalar_mult_expr
 {
     expr base;
     expr *param_source; /* always set; read a from param_source->value[0] */
-} const_scalar_mult_expr;
+} scalar_mult_expr;
 
 /* Vector elementwise multiplication: y = a \circ child where a comes from a
  * parameter node */
-typedef struct const_vector_mult_expr
+typedef struct vector_mult_expr
 {
     expr base;
     expr *param_source; /* always set; read a from param_source->value */
-} const_vector_mult_expr;
+} vector_mult_expr;
 
 /* Index/slicing: y = child[indices] where indices is a list of flat positions */
 typedef struct index_expr

src/affine/hstack.c

@@ -165,13 +165,10 @@ static void free_type_data(expr *node)
     for (int i = 0; i < hnode->n_args; i++)
     {
         free_expr(hnode->args[i]);
-        hnode->args[i] = NULL;
     }
 
     free_csr_matrix(hnode->CSR_work);
-    hnode->CSR_work = NULL;
     free(hnode->args);
-    hnode->args = NULL;
 }
 
 expr *new_hstack(expr **args, int n_args, int n_vars)

src/affine/index.c

@@ -154,11 +154,7 @@ static bool is_affine(const expr *node)
 static void free_type_data(expr *node)
 {
     index_expr *idx = (index_expr *) node;
-    if (idx->indices)
-    {
-        free(idx->indices);
-        idx->indices = NULL;
-    }
+    free(idx->indices);
 }
 
 expr *new_index(expr *child, int d1, int d2, const int *indices, int n_idxs)

src/affine/linear_op.c

@@ -62,11 +62,7 @@ static void free_type_data(expr *node)
     if (lin_node->b != NULL)
     {
         free(lin_node->b);
-        lin_node->b = NULL;
     }
-
-    lin_node->A_csr = NULL;
-    lin_node->A_csc = NULL;
 }
 
 static void jacobian_init(expr *node)

src/bivariate/left_matmul.c

@@ -95,13 +95,7 @@ static void free_type_data(expr *node)
     free_csc_matrix(lin_node->Jchild_CSC);
     free_csc_matrix(lin_node->J_CSC);
     free(lin_node->csc_to_csr_workspace);
-    if (lin_node->param_source) free_expr(lin_node->param_source);
-    lin_node->A = NULL;
-    lin_node->AT = NULL;
-    lin_node->Jchild_CSC = NULL;
-    lin_node->J_CSC = NULL;
-    lin_node->csc_to_csr_workspace = NULL;
-    lin_node->param_source = NULL;
+    free_expr(lin_node->param_source);
 }
 
 static void jacobian_init(expr *node)

src/bivariate/multiply.c

@@ -27,7 +27,7 @@
 // ------------------------------------------------------------------------------
 // Implementation of elementwise multiplication when both arguments are vectors.
 // If one argument is a scalar variable, the broadcasting should be represented
-// as a linear operator child node? How to treat if one variable is a constant?
+// as a linear operator child node.
 // ------------------------------------------------------------------------------
 static void forward(expr *node, const double *u)
 {

src/bivariate/const_scalar_mult.c src/bivariate/scalar_mult.csrc/bivariate/const_scalar_mult.c renamed to src/bivariate/scalar_mult.c

@@ -32,7 +32,7 @@ static void forward(expr *node, const double *u)
     child->forward(child, u);
 
     /* local forward pass: multiply each element by scalar a */
-    const_scalar_mult_expr *sn = (const_scalar_mult_expr *) node;
+    scalar_mult_expr *sn = (scalar_mult_expr *) node;
     double a = sn->param_source->value[0];
     for (int i = 0; i < node->size; i++)
     {
@@ -56,7 +56,7 @@ static void jacobian_init(expr *node)
 static void eval_jacobian(expr *node)
 {
     expr *child = node->left;
-    const_scalar_mult_expr *sn = (const_scalar_mult_expr *) node;
+    scalar_mult_expr *sn = (scalar_mult_expr *) node;
     double a = sn->param_source->value[0];
 
     /* evaluate child */
@@ -87,7 +87,7 @@ static void eval_wsum_hess(expr *node, const double *w)
     expr *x = node->left;
     x->eval_wsum_hess(x, w);
 
-    const_scalar_mult_expr *sn = (const_scalar_mult_expr *) node;
+    scalar_mult_expr *sn = (scalar_mult_expr *) node;
     double a = sn->param_source->value[0];
     for (int j = 0; j < x->wsum_hess->nnz; j++)
     {
@@ -103,17 +103,14 @@ static bool is_affine(const expr *node)
 
 static void free_type_data(expr *node)
 {
-    const_scalar_mult_expr *sn = (const_scalar_mult_expr *) node;
-    if (sn->param_source)
-    {
-        free_expr(sn->param_source);
-    }
+    scalar_mult_expr *sn = (scalar_mult_expr *) node;
+    free_expr(sn->param_source);
 }
 
 expr *new_scalar_mult(expr *param_node, expr *child)
 {
-    const_scalar_mult_expr *mult_node =
-        (const_scalar_mult_expr *) calloc(1, sizeof(const_scalar_mult_expr));
+    scalar_mult_expr *mult_node =
+        (scalar_mult_expr *) calloc(1, sizeof(scalar_mult_expr));
     expr *node = &mult_node->base;
 
     init_expr(node, child->d1, child->d2, child->n_vars, forward, jacobian_init,

src/bivariate/const_vector_mult.c src/bivariate/vector_mult.csrc/bivariate/const_vector_mult.c renamed to src/bivariate/vector_mult.c

@@ -27,7 +27,7 @@
 static void forward(expr *node, const double *u)
 {
     expr *child = node->left;
-    const_vector_mult_expr *vn = (const_vector_mult_expr *) node;
+    vector_mult_expr *vn = (vector_mult_expr *) node;
     const double *a = vn->param_source->value;
 
     /* child's forward pass */
@@ -56,7 +56,7 @@ static void jacobian_init(expr *node)
 static void eval_jacobian(expr *node)
 {
     expr *x = node->left;
-    const_vector_mult_expr *vn = (const_vector_mult_expr *) node;
+    vector_mult_expr *vn = (vector_mult_expr *) node;
     const double *a = vn->param_source->value;
 
     /* evaluate x */
@@ -90,7 +90,7 @@ static void wsum_hess_init(expr *node)
 static void eval_wsum_hess(expr *node, const double *w)
 {
     expr *x = node->left;
-    const_vector_mult_expr *vn = (const_vector_mult_expr *) node;
+    vector_mult_expr *vn = (vector_mult_expr *) node;
     const double *a = vn->param_source->value;
 
     /* scale weights w by a */
@@ -113,17 +113,14 @@ static bool is_affine(const expr *node)
 
 static void free_type_data(expr *node)
 {
-    const_vector_mult_expr *vnode = (const_vector_mult_expr *) node;
-    if (vnode->param_source)
-    {
-        free_expr(vnode->param_source);
-    }
+    vector_mult_expr *vnode = (vector_mult_expr *) node;
+    free_expr(vnode->param_source);
 }
 
 expr *new_vector_mult(expr *param_node, expr *child)
 {
-    const_vector_mult_expr *vnode =
-        (const_vector_mult_expr *) calloc(1, sizeof(const_vector_mult_expr));
+    vector_mult_expr *vnode =
+        (vector_mult_expr *) calloc(1, sizeof(vector_mult_expr));
     expr *node = &vnode->base;
 
     init_expr(node, child->d1, child->d2, child->n_vars, forward, jacobian_init,

src/other/quad_form.c

@@ -174,7 +174,6 @@ static void free_type_data(expr *node)
 {
     quad_form_expr *qnode = (quad_form_expr *) node;
     free_csr_matrix(qnode->Q);
-    qnode->Q = NULL;
 }
 
 static bool is_affine(const expr *node)