[librsvg: 6/10] node: rename NodeType to ElementType

[Federico Mena Quintero <federico src gnome org>]

commit 97ea4934e451100cd08815de9cd0ec0d439a9285
Author: Paolo Borelli <pborelli gnome org>
Date:   Mon Mar 16 08:43:51 2020 +0100

    node: rename NodeType to ElementType
    
    Also drop the Chars type

 rsvg_internals/src/create_node.rs                |  6 ++---
 rsvg_internals/src/css.rs                        | 12 ++++-----
 rsvg_internals/src/document.rs                   | 24 +++++++++---------
 rsvg_internals/src/drawing_ctx.rs                | 29 +++++++++++++---------
 rsvg_internals/src/filters/component_transfer.rs | 18 ++++++++------
 rsvg_internals/src/filters/light/lighting.rs     | 12 +++++----
 rsvg_internals/src/filters/merge.rs              |  6 ++---
 rsvg_internals/src/filters/mod.rs                |  6 ++---
 rsvg_internals/src/gradient.rs                   | 31 +++++++++++++-----------
 rsvg_internals/src/marker.rs                     |  2 +-
 rsvg_internals/src/node.rs                       | 13 +++++-----
 rsvg_internals/src/pattern.rs                    |  6 ++---
 rsvg_internals/src/text.rs                       |  6 ++---
 rsvg_internals/src/xml.rs                        |  4 +--
 14 files changed, 94 insertions(+), 81 deletions(-)
---
diff --git a/rsvg_internals/src/create_node.rs b/rsvg_internals/src/create_node.rs
index e3096c60..6399fb44 100644
--- a/rsvg_internals/src/create_node.rs
+++ b/rsvg_internals/src/create_node.rs
@@ -44,14 +44,14 @@ use crate::style::Style;
 use crate::text::{TRef, TSpan, Text};
 
 macro_rules! n {
-    ($name:ident, $node_type:ident) => {
+    ($name:ident, $element_type:ident) => {
         pub fn $name(element_name: &QualName, id: Option<&str>, class: Option<&str>) -> RsvgNode {
             RsvgNode::new(NodeData::new_element(
-                NodeType::$node_type,
+                ElementType::$element_type,
                 element_name,
                 id,
                 class,
-                Box::new(<$node_type>::default()),
+                Box::new(<$element_type>::default()),
             ))
         }
     };
diff --git a/rsvg_internals/src/css.rs b/rsvg_internals/src/css.rs
index 2fe174ce..4af35e72 100644
--- a/rsvg_internals/src/css.rs
+++ b/rsvg_internals/src/css.rs
@@ -92,7 +92,7 @@ use url::Url;
 use crate::allowed_url::AllowedUrl;
 use crate::error::*;
 use crate::io::{self, BinaryData};
-use crate::node::{NodeBorrow, NodeCascade, NodeType, RsvgNode};
+use crate::node::{ElementType, NodeBorrow, NodeCascade, RsvgNode};
 use crate::properties::{parse_property, ComputedValues, ParsedProperty};
 
 /// A parsed CSS declaration
@@ -498,7 +498,7 @@ impl selectors::Element for RsvgElement {
     /// Whether this element is a `link`.
     fn is_link(&self) -> bool {
         // FIXME: is this correct for SVG <a>, not HTML <a>?
-        self.0.is_element() && self.0.borrow_element().get_type() == NodeType::Link
+        self.0.is_element() && self.0.borrow_element().get_type() == ElementType::Link
     }
 
     /// Returns whether the element is an HTML <slot> element.
@@ -815,10 +815,10 @@ mod tests {
 
         // Node types
 
-        assert!(a.borrow_element().get_type() == NodeType::Svg);
-        assert!(b.borrow_element().get_type() == NodeType::Rect);
-        assert!(c.borrow_element().get_type() == NodeType::Circle);
-        assert!(d.borrow_element().get_type() == NodeType::Rect);
+        assert!(a.borrow_element().get_type() == ElementType::Svg);
+        assert!(b.borrow_element().get_type() == ElementType::Rect);
+        assert!(c.borrow_element().get_type() == ElementType::Circle);
+        assert!(d.borrow_element().get_type() == ElementType::Rect);
 
         let a = RsvgElement(a);
         let b = RsvgElement(b);
diff --git a/rsvg_internals/src/document.rs b/rsvg_internals/src/document.rs
index 77ef7aa8..018eb0bd 100644
--- a/rsvg_internals/src/document.rs
+++ b/rsvg_internals/src/document.rs
@@ -14,7 +14,7 @@ use crate::error::{AcquireError, LoadingError};
 use crate::handle::LoadOptions;
 use crate::io::{self, BinaryData};
 use crate::limits;
-use crate::node::{NodeBorrow, NodeData, NodeType, RsvgNode};
+use crate::node::{ElementType, NodeBorrow, NodeData, RsvgNode};
 use crate::property_bag::PropertyBag;
 use crate::structure::{IntrinsicDimensions, Svg};
 use crate::surface_utils::shared_surface::SharedImageSurface;
@@ -97,7 +97,7 @@ impl Document {
         let root = self.root();
         let elt = root.borrow_element();
 
-        assert!(elt.get_type() == NodeType::Svg);
+        assert!(elt.get_type() == ElementType::Svg);
         elt.get_impl::<Svg>().get_intrinsic_dimensions()
     }
 
@@ -277,7 +277,7 @@ impl<'i> AcquiredNodes<'i> {
     pub fn lookup_node(
         &self,
         fragment: &Fragment,
-        node_types: &[NodeType],
+        element_types: &[ElementType],
     ) -> Result<RsvgNode, AcquireError> {
         let node = self.document.lookup(fragment).map_err(|_| {
             // FIXME: callers shouldn't have to know that get_node() can initiate a file load.
@@ -291,11 +291,11 @@ impl<'i> AcquiredNodes<'i> {
             AcquireError::LinkNotFound(fragment.clone())
         })?;
 
-        if node_types.is_empty() {
+        if element_types.is_empty() {
             Ok(node)
         } else if node.is_element() {
-            let node_type = node.borrow_element().get_type();
-            if node_types.iter().find(|&&t| t == node_type).is_some() {
+            let element_type = node.borrow_element().get_type();
+            if element_types.iter().find(|&&t| t == element_type).is_some() {
                 Ok(node)
             } else {
                 Err(AcquireError::InvalidLinkType(fragment.clone()))
@@ -310,13 +310,13 @@ impl<'i> AcquiredNodes<'i> {
     }
 
     /// Acquires a node.
-    /// Specify `node_types` when expecting the node to be of a particular type,
-    /// or use an empty slice for `node_types` if you want a node of any type.
+    /// Specify `element_types` when expecting the node to be of a particular type,
+    /// or use an empty slice for `element_types` if you want a node of any type.
     /// Nodes acquired by this function must be released in reverse acquiring order.
     pub fn acquire(
         &mut self,
         fragment: &Fragment,
-        node_types: &[NodeType],
+        element_types: &[ElementType],
     ) -> Result<AcquiredNode, AcquireError> {
         self.num_elements_acquired += 1;
 
@@ -326,7 +326,7 @@ impl<'i> AcquiredNodes<'i> {
             return Err(AcquireError::MaxReferencesExceeded);
         }
 
-        let node = self.lookup_node(fragment, node_types)?;
+        let node = self.lookup_node(fragment, element_types)?;
 
         if node_is_accessed_by_reference(&node) {
             self.acquire_ref(&node)
@@ -355,7 +355,7 @@ impl<'i> AcquiredNodes<'i> {
 // from other nodes' atributes.  The node could in turn cause other nodes
 // to get referenced, potentially causing reference cycles.
 fn node_is_accessed_by_reference(node: &RsvgNode) -> bool {
-    use NodeType::*;
+    use ElementType::*;
 
     if !node.is_element() {
         return false;
@@ -508,7 +508,7 @@ impl DocumentBuilder {
 
         match tree {
             Some(root) if root.is_element() => {
-                if root.borrow_element().get_type() == NodeType::Svg {
+                if root.borrow_element().get_type() == ElementType::Svg {
                     let mut document = Document {
                         tree: root,
                         ids,
diff --git a/rsvg_internals/src/drawing_ctx.rs b/rsvg_internals/src/drawing_ctx.rs
index 0b38dd81..126f1c8b 100644
--- a/rsvg_internals/src/drawing_ctx.rs
+++ b/rsvg_internals/src/drawing_ctx.rs
@@ -18,7 +18,7 @@ use crate::error::{AcquireError, RenderingError};
 use crate::filters;
 use crate::gradient::{LinearGradient, RadialGradient};
 use crate::marker;
-use crate::node::{CascadedValues, NodeBorrow, NodeDraw, NodeType, RsvgNode};
+use crate::node::{CascadedValues, ElementType, NodeBorrow, NodeDraw, RsvgNode};
 use crate::paint_server::{PaintServer, PaintSource};
 use crate::path_builder::*;
 use crate::pattern::Pattern;
@@ -476,7 +476,7 @@ impl DrawingCtx {
 
                 // The `filter` property does not apply to masks.
                 let filter =
-                    if node.is_element() && node.borrow_element().get_type() == NodeType::Mask {
+                    if node.is_element() && node.borrow_element().get_type() == ElementType::Mask {
                         None
                     } else {
                         values.filter.0.get()
@@ -572,7 +572,8 @@ impl DrawingCtx {
                     // Mask
 
                     if let Some(fragment) = mask {
-                        if let Ok(acquired) = acquired_nodes.acquire(fragment, &[NodeType::Mask]) {
+                        if let Ok(acquired) = acquired_nodes.acquire(fragment, &[ElementType::Mask])
+                        {
                             let mask_node = acquired.get();
 
                             res = res.and_then(|bbox| {
@@ -739,7 +740,7 @@ impl DrawingCtx {
         child_surface: SharedImageSurface,
         node_bbox: BoundingBox,
     ) -> Result<SharedImageSurface, RenderingError> {
-        match acquired_nodes.acquire(filter_uri, &[NodeType::Filter]) {
+        match acquired_nodes.acquire(filter_uri, &[ElementType::Filter]) {
             Ok(acquired) => {
                 let filter_node = acquired.get();
 
@@ -818,7 +819,7 @@ impl DrawingCtx {
                         assert!(node.is_element());
 
                         had_paint_server = match node.borrow_element().get_type() {
-                            NodeType::LinearGradient => node
+                            ElementType::LinearGradient => node
                                 .borrow_element()
                                 .get_impl::<LinearGradient>()
                                 .resolve_fallbacks_and_set_pattern(
@@ -828,7 +829,7 @@ impl DrawingCtx {
                                     opacity,
                                     bbox,
                                 )?,
-                            NodeType::RadialGradient => node
+                            ElementType::RadialGradient => node
                                 .borrow_element()
                                 .get_impl::<RadialGradient>()
                                 .resolve_fallbacks_and_set_pattern(
@@ -838,7 +839,7 @@ impl DrawingCtx {
                                     opacity,
                                     bbox,
                                 )?,
-                            NodeType::Pattern => node
+                            ElementType::Pattern => node
                                 .borrow_element()
                                 .get_impl::<Pattern>()
                                 .resolve_fallbacks_and_set_pattern(
@@ -1171,7 +1172,7 @@ impl DrawingCtx {
 
         let child = acquired.get();
 
-        if child.is_element() && child.borrow_element().get_type() == NodeType::Symbol {
+        if child.is_element() && child.borrow_element().get_type() == ElementType::Symbol {
             let elt = child.borrow_element();
             let symbol = elt.get_impl::<Symbol>();
 
@@ -1269,7 +1270,11 @@ fn get_clip_in_user_and_object_space(
     clip_uri: Option<&Fragment>,
 ) -> (Option<RsvgNode>, Option<RsvgNode>) {
     clip_uri
-        .and_then(|fragment| acquired_nodes.acquire(fragment, &[NodeType::ClipPath]).ok())
+        .and_then(|fragment| {
+            acquired_nodes
+                .acquire(fragment, &[ElementType::ClipPath])
+                .ok()
+        })
         .and_then(|acquired| {
             let clip_node = acquired.get().clone();
 
@@ -1293,9 +1298,9 @@ fn acquire_paint_server(
     acquired_nodes.acquire(
         fragment,
         &[
-            NodeType::LinearGradient,
-            NodeType::RadialGradient,
-            NodeType::Pattern,
+            ElementType::LinearGradient,
+            ElementType::RadialGradient,
+            ElementType::Pattern,
         ],
     )
 }
diff --git a/rsvg_internals/src/filters/component_transfer.rs 
b/rsvg_internals/src/filters/component_transfer.rs
index 03378731..f0848657 100644
--- a/rsvg_internals/src/filters/component_transfer.rs
+++ b/rsvg_internals/src/filters/component_transfer.rs
@@ -6,7 +6,7 @@ use markup5ever::{expanded_name, local_name, namespace_url, ns};
 use crate::document::AcquiredNodes;
 use crate::drawing_ctx::DrawingCtx;
 use crate::error::*;
-use crate::node::{NodeBorrow, NodeResult, NodeTrait, NodeType, RsvgNode};
+use crate::node::{ElementType, NodeBorrow, NodeResult, NodeTrait, RsvgNode};
 use crate::number_list::{NumberList, NumberListLength};
 use crate::parsers::{Parse, ParseValue};
 use crate::property_bag::PropertyBag;
@@ -288,20 +288,24 @@ impl FilterEffect for FeComponentTransfer {
         )?;
 
         // Get a node for every pixel component.
-        fn get_node<F>(node: &RsvgNode, node_type: NodeType, channel: Channel) -> Option<RsvgNode>
+        fn get_node<F>(
+            node: &RsvgNode,
+            element_type: ElementType,
+            channel: Channel,
+        ) -> Option<RsvgNode>
         where
             F: FeComponentTransferFunc + NodeTrait,
         {
             node.children()
                 .rev()
-                .filter(|c| c.is_element() && c.borrow_element().get_type() == node_type)
+                .filter(|c| c.is_element() && c.borrow_element().get_type() == element_type)
                 .find(|c| c.borrow_element().get_impl::<F>().channel() == channel)
         };
 
-        let func_r_node = get_node::<FeFuncR>(node, NodeType::FeFuncR, Channel::R);
-        let func_g_node = get_node::<FeFuncG>(node, NodeType::FeFuncG, Channel::G);
-        let func_b_node = get_node::<FeFuncB>(node, NodeType::FeFuncB, Channel::B);
-        let func_a_node = get_node::<FeFuncA>(node, NodeType::FeFuncA, Channel::A);
+        let func_r_node = get_node::<FeFuncR>(node, ElementType::FeFuncR, Channel::R);
+        let func_g_node = get_node::<FeFuncG>(node, ElementType::FeFuncG, Channel::G);
+        let func_b_node = get_node::<FeFuncB>(node, ElementType::FeFuncB, Channel::B);
+        let func_a_node = get_node::<FeFuncA>(node, ElementType::FeFuncA, Channel::A);
 
         for node in [&func_r_node, &func_g_node, &func_b_node, &func_a_node]
             .iter()
diff --git a/rsvg_internals/src/filters/light/lighting.rs b/rsvg_internals/src/filters/light/lighting.rs
index b8dd67b5..071d0067 100644
--- a/rsvg_internals/src/filters/light/lighting.rs
+++ b/rsvg_internals/src/filters/light/lighting.rs
@@ -18,7 +18,7 @@ use crate::filters::{
     },
     FilterEffect, FilterError, PrimitiveWithInput,
 };
-use crate::node::{CascadedValues, NodeBorrow, NodeResult, NodeTrait, NodeType, RsvgNode};
+use crate::node::{CascadedValues, ElementType, NodeBorrow, NodeResult, NodeTrait, RsvgNode};
 use crate::parsers::{NumberOptionalNumber, ParseValue};
 use crate::property_bag::PropertyBag;
 use crate::surface_utils::{
@@ -493,7 +493,9 @@ fn find_light_source(node: &RsvgNode, ctx: &FilterContext) -> Result<LightSource
     let mut light_sources = node.children().rev().filter(|c| {
         c.is_element()
             && match c.borrow_element().get_type() {
-                NodeType::FeDistantLight | NodeType::FePointLight | NodeType::FeSpotLight => true,
+                ElementType::FeDistantLight
+                | ElementType::FePointLight
+                | ElementType::FeSpotLight => true,
                 _ => false,
             }
     });
@@ -511,9 +513,9 @@ fn find_light_source(node: &RsvgNode, ctx: &FilterContext) -> Result<LightSource
     }
 
     let light_source = match elt.get_type() {
-        NodeType::FeDistantLight => elt.get_impl::<FeDistantLight>().transform(ctx),
-        NodeType::FePointLight => elt.get_impl::<FePointLight>().transform(ctx),
-        NodeType::FeSpotLight => elt.get_impl::<FeSpotLight>().transform(ctx),
+        ElementType::FeDistantLight => elt.get_impl::<FeDistantLight>().transform(ctx),
+        ElementType::FePointLight => elt.get_impl::<FePointLight>().transform(ctx),
+        ElementType::FeSpotLight => elt.get_impl::<FeSpotLight>().transform(ctx),
         _ => unreachable!(),
     };
 
diff --git a/rsvg_internals/src/filters/merge.rs b/rsvg_internals/src/filters/merge.rs
index 0cd26ee6..d1949bd3 100644
--- a/rsvg_internals/src/filters/merge.rs
+++ b/rsvg_internals/src/filters/merge.rs
@@ -2,7 +2,7 @@ use markup5ever::{expanded_name, local_name, namespace_url, ns};
 
 use crate::document::AcquiredNodes;
 use crate::drawing_ctx::DrawingCtx;
-use crate::node::{NodeBorrow, NodeResult, NodeTrait, NodeType, RsvgNode};
+use crate::node::{ElementType, NodeBorrow, NodeResult, NodeTrait, RsvgNode};
 use crate::parsers::ParseValue;
 use crate::property_bag::PropertyBag;
 use crate::rect::IRect;
@@ -90,7 +90,7 @@ impl FilterEffect for FeMerge {
         let mut bounds = self.base.get_bounds(ctx);
         for child in node
             .children()
-            .filter(|c| c.is_element() && c.borrow_element().get_type() == NodeType::FeMergeNode)
+            .filter(|c| c.is_element() && c.borrow_element().get_type() == ElementType::FeMergeNode)
         {
             let elt = child.borrow_element();
 
@@ -111,7 +111,7 @@ impl FilterEffect for FeMerge {
         let mut output_surface = None;
         for child in node
             .children()
-            .filter(|c| c.is_element() && c.borrow_element().get_type() == NodeType::FeMergeNode)
+            .filter(|c| c.is_element() && c.borrow_element().get_type() == ElementType::FeMergeNode)
         {
             output_surface = Some(child.borrow_element().get_impl::<FeMergeNode>().render(
                 ctx,
diff --git a/rsvg_internals/src/filters/mod.rs b/rsvg_internals/src/filters/mod.rs
index cd2d975c..61d93fa6 100644
--- a/rsvg_internals/src/filters/mod.rs
+++ b/rsvg_internals/src/filters/mod.rs
@@ -12,7 +12,7 @@ use crate::drawing_ctx::DrawingCtx;
 use crate::error::{RenderingError, ValueErrorKind};
 use crate::filter::Filter;
 use crate::length::*;
-use crate::node::{CascadedValues, NodeBorrow, NodeResult, NodeTrait, NodeType, RsvgNode};
+use crate::node::{CascadedValues, ElementType, NodeBorrow, NodeResult, NodeTrait, RsvgNode};
 use crate::parsers::ParseValue;
 use crate::properties::ComputedValues;
 use crate::property_bag::PropertyBag;
@@ -120,7 +120,7 @@ impl NodeTrait for Primitive {
                 assert!(parent.is_element());
                 let parent_elt = parent.borrow_element();
 
-                if parent_elt.get_type() == NodeType::Filter {
+                if parent_elt.get_type() == ElementType::Filter {
                     Some(parent_elt.get_impl::<Filter>().get_primitive_units())
                 } else {
                     None
@@ -251,7 +251,7 @@ pub fn render(
     node_bbox: BoundingBox,
 ) -> Result<SharedImageSurface, RenderingError> {
     let filter_node = &*filter_node;
-    assert_eq!(filter_node.borrow_element().get_type(), NodeType::Filter);
+    assert_eq!(filter_node.borrow_element().get_type(), ElementType::Filter);
     assert!(!filter_node.borrow_element().is_in_error());
 
     let mut filter_ctx = FilterContext::new(
diff --git a/rsvg_internals/src/gradient.rs b/rsvg_internals/src/gradient.rs
index cba6a955..ff08efdf 100644
--- a/rsvg_internals/src/gradient.rs
+++ b/rsvg_internals/src/gradient.rs
@@ -11,7 +11,7 @@ use crate::document::{AcquiredNode, AcquiredNodes, NodeStack};
 use crate::drawing_ctx::{DrawingCtx, ViewParams};
 use crate::error::*;
 use crate::length::*;
-use crate::node::{CascadedValues, NodeBorrow, NodeResult, NodeTrait, NodeType, RsvgNode};
+use crate::node::{CascadedValues, ElementType, NodeBorrow, NodeResult, NodeTrait, RsvgNode};
 use crate::paint_server::{AsPaintSource, PaintSource};
 use crate::parsers::{Parse, ParseValue};
 use crate::properties::ComputedValues;
@@ -444,14 +444,17 @@ impl UnresolvedGradient {
     /// Looks for <stop> children inside a linearGradient or radialGradient node,
     /// and adds their info to the UnresolvedGradient &self.
     fn add_color_stops_from_node(&mut self, node: &RsvgNode) {
-        let node_type = node.borrow_element().get_type();
+        let element_type = node.borrow_element().get_type();
 
-        assert!(node_type == NodeType::LinearGradient || node_type == NodeType::RadialGradient);
+        assert!(
+            element_type == ElementType::LinearGradient
+                || element_type == ElementType::RadialGradient
+        );
 
         for child_node in node.children().filter(|c| c.is_element()) {
             let child = child_node.borrow_element();
 
-            if child.get_type() != NodeType::Stop {
+            if child.get_type() != ElementType::Stop {
                 continue;
             }
 
@@ -631,7 +634,7 @@ impl NodeTrait for RadialGradient {
 }
 
 macro_rules! impl_paint_source {
-    ($gradient:ty, $node_type:pat, $other_gradient:ty, $other_type:pat,) => {
+    ($gradient:ty, $element_type:pat, $other_gradient:ty, $other_type:pat,) => {
         impl PaintSource for $gradient {
             type Resolved = Gradient;
 
@@ -663,7 +666,7 @@ macro_rules! impl_paint_source {
 
                         let borrowed_node = acquired_node.borrow_element();
                         let unresolved = match borrowed_node.get_type() {
-                            $node_type => {
+                            $element_type => {
                                 let a_gradient = borrowed_node.get_impl::<$gradient>();
                                 a_gradient.get_unresolved(&acquired_node)
                             }
@@ -698,16 +701,16 @@ macro_rules! impl_paint_source {
 
 impl_paint_source!(
     LinearGradient,
-    NodeType::LinearGradient,
+    ElementType::LinearGradient,
     RadialGradient,
-    NodeType::RadialGradient,
+    ElementType::RadialGradient,
 );
 
 impl_paint_source!(
     RadialGradient,
-    NodeType::RadialGradient,
+    ElementType::RadialGradient,
     LinearGradient,
-    NodeType::LinearGradient,
+    ElementType::LinearGradient,
 );
 
 impl AsPaintSource for Gradient {
@@ -802,7 +805,7 @@ fn acquire_gradient(
 ) -> Result<AcquiredNode, AcquireError> {
     acquired_nodes.acquire(
         fragment,
-        &[NodeType::LinearGradient, NodeType::RadialGradient],
+        &[ElementType::LinearGradient, ElementType::RadialGradient],
     )
 }
 
@@ -810,7 +813,7 @@ fn acquire_gradient(
 mod tests {
     use super::*;
     use crate::float_eq_cairo::ApproxEqCairo;
-    use crate::node::{NodeData, NodeType, RsvgNode};
+    use crate::node::{ElementType, NodeData, RsvgNode};
     use markup5ever::{namespace_url, ns, QualName};
 
     #[test]
@@ -844,7 +847,7 @@ mod tests {
     #[test]
     fn gradient_resolved_from_defaults_is_really_resolved() {
         let node = RsvgNode::new(NodeData::new_element(
-            NodeType::LinearGradient,
+            ElementType::LinearGradient,
             &QualName::new(None, ns!(svg), local_name!("linearGradient")),
             None,
             None,
@@ -858,7 +861,7 @@ mod tests {
         assert!(gradient.is_resolved());
 
         let node = RsvgNode::new(NodeData::new_element(
-            NodeType::RadialGradient,
+            ElementType::RadialGradient,
             &QualName::new(None, ns!(svg), local_name!("radialGradient")),
             None,
             None,
diff --git a/rsvg_internals/src/marker.rs b/rsvg_internals/src/marker.rs
index 5f716c24..55065077 100644
--- a/rsvg_internals/src/marker.rs
+++ b/rsvg_internals/src/marker.rs
@@ -570,7 +570,7 @@ fn emit_marker_by_name(
     line_width: f64,
     clipping: bool,
 ) -> Result<BoundingBox, RenderingError> {
-    if let Ok(acquired) = acquired_nodes.acquire(name, &[NodeType::Marker]) {
+    if let Ok(acquired) = acquired_nodes.acquire(name, &[ElementType::Marker]) {
         let node = acquired.get();
 
         node.borrow_element().get_impl::<Marker>().render(
diff --git a/rsvg_internals/src/node.rs b/rsvg_internals/src/node.rs
index 2d9a80a2..009dbb82 100644
--- a/rsvg_internals/src/node.rs
+++ b/rsvg_internals/src/node.rs
@@ -84,7 +84,7 @@ pub enum NodeData {
 
 /// Contents of an element node in the DOM
 pub struct Element {
-    node_type: NodeType,
+    element_type: ElementType,
     element_name: QualName,
     id: Option<String>,    // id attribute from XML element
     class: Option<String>, // class attribute from XML element
@@ -100,14 +100,14 @@ pub struct Element {
 
 impl NodeData {
     pub fn new_element(
-        node_type: NodeType,
+        element_type: ElementType,
         element_name: &QualName,
         id: Option<&str>,
         class: Option<&str>,
         node_impl: Box<dyn NodeTrait>,
     ) -> NodeData {
         NodeData::Element(Box::new(Element {
-            node_type,
+            element_type,
             element_name: element_name.clone(),
             id: id.map(str::to_string),
             class: class.map(str::to_string),
@@ -128,8 +128,8 @@ impl NodeData {
 }
 
 impl Element {
-    pub fn get_type(&self) -> NodeType {
-        self.node_type
+    pub fn get_type(&self) -> ElementType {
+        self.element_type
     }
 
     pub fn get_node_trait(&self) -> &dyn NodeTrait {
@@ -462,8 +462,7 @@ impl_downcast!(NodeTrait);
 pub type NodeResult = Result<(), NodeError>;
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
-pub enum NodeType {
-    Chars,
+pub enum ElementType {
     Circle,
     ClipPath,
     Ellipse,
diff --git a/rsvg_internals/src/pattern.rs b/rsvg_internals/src/pattern.rs
index beaa484e..24ff7992 100644
--- a/rsvg_internals/src/pattern.rs
+++ b/rsvg_internals/src/pattern.rs
@@ -180,7 +180,7 @@ impl PaintSource for Pattern {
 
         while !pattern.is_resolved() {
             if let Some(ref fragment) = fallback {
-                match acquired_nodes.acquire(&fragment, &[NodeType::Pattern]) {
+                match acquired_nodes.acquire(&fragment, &[ElementType::Pattern]) {
                     Ok(acquired) => {
                         let acquired_node = acquired.get();
 
@@ -562,13 +562,13 @@ impl Pattern {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::node::{NodeData, NodeType, RsvgNode};
+    use crate::node::{ElementType, NodeData, RsvgNode};
     use markup5ever::{namespace_url, ns, QualName};
 
     #[test]
     fn pattern_resolved_from_defaults_is_really_resolved() {
         let node = RsvgNode::new(NodeData::new_element(
-            NodeType::Pattern,
+            ElementType::Pattern,
             &QualName::new(None, ns!(svg), local_name!("pattern")),
             None,
             None,
diff --git a/rsvg_internals/src/text.rs b/rsvg_internals/src/text.rs
index fcf25cef..3db1bc34 100644
--- a/rsvg_internals/src/text.rs
+++ b/rsvg_internals/src/text.rs
@@ -12,7 +12,7 @@ use crate::error::*;
 use crate::float_eq_cairo::ApproxEqCairo;
 use crate::font_props::FontWeightSpec;
 use crate::length::*;
-use crate::node::{CascadedValues, NodeBorrow, NodeResult, NodeTrait, NodeType, RsvgNode};
+use crate::node::{CascadedValues, ElementType, NodeBorrow, NodeResult, NodeTrait, RsvgNode};
 use crate::parsers::ParseValue;
 use crate::properties::ComputedValues;
 use crate::property_bag::PropertyBag;
@@ -439,7 +439,7 @@ fn children_to_chunks(
             let elt = child.borrow_element();
 
             match elt.get_type() {
-                NodeType::TSpan => {
+                ElementType::TSpan => {
                     let cascaded = CascadedValues::new(cascaded, &child);
                     elt.get_impl::<TSpan>().to_chunks(
                         &child,
@@ -451,7 +451,7 @@ fn children_to_chunks(
                     );
                 }
 
-                NodeType::TRef => {
+                ElementType::TRef => {
                     let cascaded = CascadedValues::new(cascaded, &child);
                     elt.get_impl::<TRef>().to_chunks(
                         &child,
diff --git a/rsvg_internals/src/xml.rs b/rsvg_internals/src/xml.rs
index fdc60053..91c1a7fa 100644
--- a/rsvg_internals/src/xml.rs
+++ b/rsvg_internals/src/xml.rs
@@ -16,7 +16,7 @@ use crate::document::{Document, DocumentBuilder};
 use crate::error::LoadingError;
 use crate::io::{self, get_input_stream_for_loading};
 use crate::limits::MAX_LOADED_ELEMENTS;
-use crate::node::{NodeBorrow, NodeType, RsvgNode};
+use crate::node::{ElementType, NodeBorrow, RsvgNode};
 use crate::property_bag::PropertyBag;
 use crate::style::{Style, StyleType};
 use crate::xml2_load::Xml2Parser;
@@ -358,7 +358,7 @@ impl XmlState {
         let mut inner = self.inner.borrow_mut();
         let current_node = inner.current_node.as_ref().unwrap();
 
-        assert!(current_node.borrow_element().get_type() == NodeType::Style);
+        assert!(current_node.borrow_element().get_type() == ElementType::Style);
 
         let style_type = current_node
             .borrow_element()