Try to propagate an error earlier when there are circular references

The problematic file has circular references, and they are detected,
but the <use> element tries to just return an empty bbox rather than
propagate the error upstream.  The problem with this particular file
is not that it enters infinite recursion, but that the <g> are nested
so deep that we run out of stack.

So, propagate errors about circular references upstream as much as
possible, and stop propagating when we reach Node::draw().

The effect now is that rendering proceeds until the maximum number of
referenced elements is reached, and then we get a hard error that
makes the rendering terminate.

I'm not 100% satisfied with this approach; it fixes the stack
exhaustion, but we could try other things:

- Mark <use> elements as "has a circular reference" so they are not
re-rendered if referenced again.

- Mark all the elements involved in a circular reference chain as
tainted, so they can't get referenced again.

Part-of: <https://gitlab.gnome.org/GNOME/librsvg/-/merge_requests/988>

Author: federicomenaquintero

rsvg/src/api.rs

@@ -84,6 +84,9 @@ impl From<InternalRenderingError> for RenderingError {
             InternalRenderingError::InvalidTransform => {
                 RenderingError::Rendering("invalid transform".to_string())
             }
+            InternalRenderingError::CircularReference(c) => {
+                RenderingError::Rendering(format!("circular reference in node {c}"))
+            }
             InternalRenderingError::IdNotFound => RenderingError::IdNotFound,
             InternalRenderingError::InvalidId(s) => RenderingError::InvalidId(s),
             InternalRenderingError::OutOfMemory(s) => RenderingError::OutOfMemory(s),

rsvg/src/drawing_ctx.rs

@@ -1755,7 +1755,7 @@ impl DrawingCtx {
 
             Err(AcquireError::CircularReference(circular)) => {
                 rsvg_log!(self.session, "circular reference in element {}", circular);
-                return Ok(self.empty_bbox());
+                return Err(InternalRenderingError::CircularReference(circular));
             }
 
             _ => unreachable!(),
@@ -1765,8 +1765,13 @@ impl DrawingCtx {
             Ok(acquired) => acquired,
 
             Err(AcquireError::CircularReference(circular)) => {
-                rsvg_log!(self.session, "circular reference from {} to element {}", node, circular);
-                return Ok(self.empty_bbox());
+                rsvg_log!(
+                    self.session,
+                    "circular reference from {} to element {}",
+                    node,
+                    circular
+                );
+                return Err(InternalRenderingError::CircularReference(circular));
             }
 
             Err(AcquireError::MaxReferencesExceeded) => {

rsvg/src/error.rs

@@ -121,7 +121,7 @@ impl fmt::Display for DefsLookupErrorKind {
 ///   "If a transform function causes the current transformation matrix of an
 ///   object to be non-invertible, the object and its content do not get
 ///   displayed."
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub enum InternalRenderingError {
     /// An error from the rendering backend.
     Rendering(String),
@@ -135,6 +135,8 @@ pub enum InternalRenderingError {
     /// the problematic element.
     InvalidTransform,
 
+    CircularReference(Node),
+
     /// Tried to reference an SVG element that does not exist.
     IdNotFound,
 
@@ -169,6 +171,9 @@ impl fmt::Display for InternalRenderingError {
             InternalRenderingError::Rendering(ref s) => write!(f, "rendering error: {s}"),
             InternalRenderingError::LimitExceeded(ref l) => write!(f, "{l}"),
             InternalRenderingError::InvalidTransform => write!(f, "invalid transform"),
+            InternalRenderingError::CircularReference(ref c) => {
+                write!(f, "circular reference in element {c}")
+            }
             InternalRenderingError::IdNotFound => write!(f, "element id not found"),
             InternalRenderingError::InvalidId(ref s) => write!(f, "invalid id: {s:?}"),
             InternalRenderingError::OutOfMemory(ref s) => write!(f, "out of memory: {s}"),

rsvg/src/filters/error.rs

@@ -3,7 +3,7 @@ use std::fmt;
 use crate::error::InternalRenderingError;
 
 /// An enumeration of errors that can occur during filter primitive rendering.
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub enum FilterError {
     /// The filter was passed invalid input (the `in` attribute).
     InvalidInput,

rsvg/src/node.rs

@@ -348,6 +348,14 @@ impl NodeDraw for Node {
                     // displayed."
                     Err(InternalRenderingError::InvalidTransform) => Ok(draw_ctx.empty_bbox()),
 
+                    Err(InternalRenderingError::CircularReference(node)) => {
+                        if node != *self {
+                            return Ok(draw_ctx.empty_bbox());
+                        } else {
+                            return Err(InternalRenderingError::CircularReference(node));
+                        }
+                    }
+
                     Err(e) => Err(e),
                 };