Function copied from math_rotation.c.
Renamed to eul_to_mat4.

This is taken from eul_to_mat4 in math_rotation.c

It works. Matches the names in nodes.cpp.

this is different because transform_point doesn't work the same in cycles as it does in glsl

This was copied from the Combine nodes that use the same code. Not sure I understand this.

Crashes if this is changed to stack_assign_if_linked

Function copied from math_rotation.c.
Renamed to eul_to_mat4.

C code is different from OSL and GLSL code, I think we should just return the matrix directly, no need to use output parameters.

I don't think there is a code convention here, so just do what you think is more readable. You don't have to stick to ijh.

Sure, but that still doesn't mean it should be done this way.

This line basically says that if all inputs are constants, that is, not linked to other sockets, then we can reduce the node to a constant value. You compute this value as make_float3(x, y, z), which is obviously not correct. To correct this, simply rotate the point just as you did in the SVM code.

If you don't assign if linked then the second node will be useless since the inputs will always be stack assigned. Find out why Blender crashes and try to fix it.

Well there is also a eul_to_mat3 function in the same file, not sure what the reasoning here is.

node_type_storage is not needed in this case.

I've made this a return function and changed name to eul_to_matrix

Because the code is copied I think it's better to keep the variable names as this helps if the codebase is searched.

Simplified to match OSL and GLSL code. Remove call to transform_translate.

I've removed the constant folding. I've noticed a lot of nodes do not have this.

This is unclear to me why this crashes. Take a look at the CombineXYZNode and VectorTransformNode, they are coded the same way.

Simplified glsl to use mat3 and eul_to_mat3 which is identical to eul_to_mat4 but without the additional two lines at the end. Also used return function.

I like passing the uints of the node directly like:
svm_node_vector_rotate(kg, sd, stack, node.y, node.z, &offset);
The reason I like this is because we can use explicit names in the function parameters like:

ccl_device void svm_node_vector_rotate(KernelGlobals *kg,
                                       ShaderData *sd,
                                       float *stack,
                                       uint inputs_stack_offsets,
                                       uint result_stack_offset,
                                       int *offset)

A naming convention I like to use is *_stack_offset, for instance, vector_stack_offset, origin_stack_offset, rotation_stack_offset, and result_stack_offset. This helps distinguishing sockets, stack offsets, and global offsets.

I think you should create a new variable instead of overwriting the input this many times:
float3 result = transform_point(&rmat, vector - origin) + origin;
The same goes for other backends.

No need to encode the output using compiler.encode_uchar4, just pass it directly.

I think it is better to call this Rotation, like in the rest of Blender.