Don't import xml5ever enums into the global namespace

This is mostly the same as servo#593 but for xml5ever.

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

Author: simonwuelker

rcdom/tests/xml-tokenizer.rs

@@ -23,7 +23,7 @@ use markup5ever::buffer_queue::BufferQueue;
 use xml5ever::tendril::{SliceExt, StrTendril};
 use xml5ever::tokenizer::{CharacterTokens, Token, TokenSink};
 use xml5ever::tokenizer::{CommentToken, EmptyTag, EndTag, ShortTag, StartTag, Tag};
-use xml5ever::tokenizer::{Doctype, DoctypeToken, PIToken, Pi};
+use xml5ever::tokenizer::{Doctype, DoctypeToken, PIToken, ProcessingInstruction};
 use xml5ever::tokenizer::{EOFToken, XmlTokenizer, XmlTokenizerOpts};
 use xml5ever::tokenizer::{NullCharacterToken, ParseError, TagToken};
 use xml5ever::{namespace_url, ns, Attribute, LocalName, QualName};
@@ -253,7 +253,7 @@ fn json_to_token(js: &Value) -> Token {
 
         "Character" => CharacterTokens(args[0].get_tendril()),
 
-        "PI" => PIToken(Pi {
+        "PI" => PIToken(ProcessingInstruction {
             target: args[0].get_tendril(),
             data: args[1].get_tendril(),
         }),

xml5ever/examples/simple_xml_tokenizer.rs

@@ -17,7 +17,7 @@ use std::io;
 use markup5ever::buffer_queue::BufferQueue;
 use xml5ever::tendril::{ByteTendril, ReadExt};
 use xml5ever::tokenizer::{CharacterTokens, NullCharacterToken, ProcessResult, TagToken};
-use xml5ever::tokenizer::{CommentToken, PIToken, Pi};
+use xml5ever::tokenizer::{CommentToken, PIToken, ProcessingInstruction};
 use xml5ever::tokenizer::{Doctype, DoctypeToken, EOFToken};
 use xml5ever::tokenizer::{ParseError, Token, TokenSink, XmlTokenizer};
 
@@ -38,7 +38,7 @@ impl TokenSink for SimpleTokenPrinter {
             ParseError(err) => {
                 println!("ERROR: {err}");
             },
-            PIToken(Pi {
+            PIToken(ProcessingInstruction {
                 ref target,
                 ref data,
             }) => {

xml5ever/examples/xml_tokenizer.rs

@@ -19,7 +19,7 @@ use markup5ever::buffer_queue::BufferQueue;
 use xml5ever::tendril::{ByteTendril, ReadExt};
 use xml5ever::tokenizer::{CharacterTokens, NullCharacterToken, ProcessResult, TagToken};
 use xml5ever::tokenizer::{EmptyTag, EndTag, ShortTag, StartTag};
-use xml5ever::tokenizer::{PIToken, Pi};
+use xml5ever::tokenizer::{PIToken, ProcessingInstruction};
 use xml5ever::tokenizer::{ParseError, Token, TokenSink, XmlTokenizer, XmlTokenizerOpts};
 
 #[derive(Clone)]
@@ -78,7 +78,7 @@ impl TokenSink for TokenPrinter {
                 self.is_char(false);
                 println!("ERROR: {err}");
             },
-            PIToken(Pi { target, data }) => {
+            PIToken(ProcessingInstruction { target, data }) => {
                 self.is_char(false);
                 println!("PI : <?{target:?} {data:?}?>");
             },

xml5ever/src/tokenizer/interface.rs

@@ -75,7 +75,7 @@ pub struct Doctype {
 
 /// A ProcessingInstruction token.
 #[derive(PartialEq, Eq, Clone, Debug)]
-pub struct Pi {
+pub struct ProcessingInstruction {
     /// What is the name of processing instruction.
     pub target: StrTendril,
 
@@ -92,7 +92,7 @@ pub enum Token {
     /// possible kinds of tags (like start, end, empty tag, etc.).
     TagToken(Tag),
     /// Processing Instruction token
-    PIToken(Pi),
+    PIToken(ProcessingInstruction),
     /// Comment token.
     CommentToken(StrTendril),
     /// Token that represents a series of characters.

xml5ever/src/tokenizer/mod.rs

@@ -14,7 +14,7 @@ pub mod states;
 
 pub use self::interface::{CharacterTokens, EOFToken, NullCharacterToken};
 pub use self::interface::{CommentToken, DoctypeToken, PIToken, TagToken};
-pub use self::interface::{Doctype, Pi};
+pub use self::interface::{Doctype, ProcessingInstruction};
 pub use self::interface::{EmptyTag, EndTag, ShortTag, StartTag};
 pub use self::interface::{ParseError, Tag, TagKind, Token, TokenSink};
 pub use crate::{LocalName, Namespace, Prefix};
@@ -463,7 +463,7 @@ impl<Sink: TokenSink> XmlTokenizer<Sink> {
 
     // Emits the current Processing Instruction
     fn emit_pi(&self) -> ProcessResult<<Sink as TokenSink>::Handle> {
-        let token = PIToken(Pi {
+        let token = PIToken(ProcessingInstruction {
             target: replace(&mut *self.current_pi_target.borrow_mut(), StrTendril::new()),
             data: replace(&mut *self.current_pi_data.borrow_mut(), StrTendril::new()),
         });

xml5ever/src/tree_builder/mod.rs

@@ -25,7 +25,7 @@ use self::types::*;
 use crate::interface::{self, create_element, AppendNode, Attribute, QualName};
 use crate::interface::{AppendText, ExpandedName};
 use crate::tokenizer::{self, EndTag, ProcessResult, StartTag, Tag, TokenSink};
-use crate::tokenizer::{Doctype, EmptyTag, Pi, ShortTag};
+use crate::tokenizer::{Doctype, EmptyTag, ProcessingInstruction, ShortTag};
 use crate::{LocalName, Namespace, Prefix};
 
 use crate::tendril::{StrTendril, Tendril};
@@ -214,7 +214,7 @@ where
             curr_elem: RefCell::new(None),
             namespace_stack: RefCell::new(NamespaceMapStack::new()),
             current_namespace: RefCell::new(NamespaceMap::empty()),
-            phase: Cell::new(Start),
+            phase: Cell::new(XmlPhase::Start),
         }
     }
 
@@ -415,13 +415,13 @@ where
                 return ProcessResult::Done;
             },
 
-            tokenizer::DoctypeToken(d) => Doctype(d),
-            tokenizer::PIToken(x) => Pi(x),
-            tokenizer::TagToken(x) => Tag(x),
-            tokenizer::CommentToken(x) => Comment(x),
-            tokenizer::NullCharacterToken => NullCharacter,
-            tokenizer::EOFToken => Eof,
-            tokenizer::CharacterTokens(x) => Characters(x),
+            tokenizer::DoctypeToken(d) => Token::Doctype(d),
+            tokenizer::PIToken(instruction) => Token::ProcessingInstruction(instruction),
+            tokenizer::TagToken(x) => Token::Tag(x),
+            tokenizer::CommentToken(x) => Token::Comment(x),
+            tokenizer::NullCharacterToken => Token::NullCharacter,
+            tokenizer::EOFToken => Token::Eof,
+            tokenizer::CharacterTokens(x) => Token::Characters(x),
         };
 
         self.process_to_completion(token)
@@ -466,7 +466,7 @@ where
         let child = create_element(&self.sink, tag.name, tag.attrs);
         self.insert_appropriately(AppendNode(child.clone()));
         self.sink.pop(&child);
-        Done
+        XmlProcessResult::Done
     }
 
     fn append_tag_to_doc(&self, tag: Tag) -> Handle {
@@ -480,21 +480,21 @@ where
     fn add_to_open_elems(&self, el: Handle) -> XmlProcessResult<Handle> {
         self.open_elems.borrow_mut().push(el);
 
-        Done
+        XmlProcessResult::Done
     }
 
     fn append_comment_to_doc(&self, text: StrTendril) -> XmlProcessResult<Handle> {
         let comment = self.sink.create_comment(text);
         self.sink.append(&self.doc_handle, AppendNode(comment));
-        Done
+        XmlProcessResult::Done
     }
 
     fn append_comment_to_tag(&self, text: StrTendril) -> XmlProcessResult<Handle> {
         let open_elems = self.open_elems.borrow();
         let target = current_node(&open_elems);
         let comment = self.sink.create_comment(text);
         self.sink.append(target, AppendNode(comment));
-        Done
+        XmlProcessResult::Done
     }
 
     fn append_doctype_to_doc(&self, doctype: Doctype) -> XmlProcessResult<Handle> {
@@ -509,26 +509,26 @@ where
             get_tendril(doctype.public_id),
             get_tendril(doctype.system_id),
         );
-        Done
+        XmlProcessResult::Done
     }
 
-    fn append_pi_to_doc(&self, pi: Pi) -> XmlProcessResult<Handle> {
+    fn append_pi_to_doc(&self, pi: ProcessingInstruction) -> XmlProcessResult<Handle> {
         let pi = self.sink.create_pi(pi.target, pi.data);
         self.sink.append(&self.doc_handle, AppendNode(pi));
-        Done
+        XmlProcessResult::Done
     }
 
-    fn append_pi_to_tag(&self, pi: Pi) -> XmlProcessResult<Handle> {
+    fn append_pi_to_tag(&self, pi: ProcessingInstruction) -> XmlProcessResult<Handle> {
         let open_elems = self.open_elems.borrow();
         let target = current_node(&open_elems);
         let pi = self.sink.create_pi(pi.target, pi.data);
         self.sink.append(target, AppendNode(pi));
-        Done
+        XmlProcessResult::Done
     }
 
     fn append_text(&self, chars: StrTendril) -> XmlProcessResult<Handle> {
         self.insert_appropriately(AppendText(chars));
-        Done
+        XmlProcessResult::Done
     }
 
     fn tag_in_open_elems(&self, tag: &Tag) -> bool {
@@ -578,7 +578,7 @@ where
             self.pop();
         }
 
-        Done
+        XmlProcessResult::Done
     }
 
     fn no_open_elems(&self) -> bool {
@@ -598,7 +598,7 @@ where
 
     fn stop_parsing(&self) -> XmlProcessResult<Handle> {
         warn!("stop_parsing for XML5 not implemented, full speed ahead!");
-        Done
+        XmlProcessResult::Done
     }
 }
 
@@ -617,8 +617,8 @@ where
         self.debug_step(mode, &token);
 
         match mode {
-            Start => match token {
-                Tag(Tag {
+            XmlPhase::Start => match token {
+                Token::Tag(Tag {
                     kind: StartTag,
                     name,
                     attrs,
@@ -632,11 +632,11 @@ where
                         self.process_namespaces(&mut tag);
                         tag
                     };
-                    self.phase.set(Main);
+                    self.phase.set(XmlPhase::Main);
                     let handle = self.append_tag_to_doc(tag);
                     self.add_to_open_elems(handle)
                 },
-                Tag(Tag {
+                Token::Tag(Tag {
                     kind: EmptyTag,
                     name,
                     attrs,
@@ -650,32 +650,34 @@ where
                         self.process_namespaces(&mut tag);
                         tag
                     };
-                    self.phase.set(End);
+                    self.phase.set(XmlPhase::End);
                     let handle = self.append_tag_to_doc(tag);
                     self.sink.pop(&handle);
-                    Done
+                    XmlProcessResult::Done
                 },
-                Comment(comment) => self.append_comment_to_doc(comment),
-                Pi(pi) => self.append_pi_to_doc(pi),
-                Characters(ref chars) if !any_not_whitespace(chars) => Done,
-                Eof => {
+                Token::Comment(comment) => self.append_comment_to_doc(comment),
+                Token::ProcessingInstruction(pi) => self.append_pi_to_doc(pi),
+                Token::Characters(ref chars) if !any_not_whitespace(chars) => {
+                    XmlProcessResult::Done
+                },
+                Token::Eof => {
                     self.sink
                         .parse_error(Borrowed("Unexpected EOF in start phase"));
-                    Reprocess(End, Eof)
+                    XmlProcessResult::Reprocess(XmlPhase::End, Token::Eof)
                 },
-                Doctype(d) => {
+                Token::Doctype(d) => {
                     self.append_doctype_to_doc(d);
-                    Done
+                    XmlProcessResult::Done
                 },
                 _ => {
                     self.sink
                         .parse_error(Borrowed("Unexpected element in start phase"));
-                    Done
+                    XmlProcessResult::Done
                 },
             },
-            Main => match token {
-                Characters(chs) => self.append_text(chs),
-                Tag(Tag {
+            XmlPhase::Main => match token {
+                Token::Characters(chs) => self.append_text(chs),
+                Token::Tag(Tag {
                     kind: StartTag,
                     name,
                     attrs,
@@ -691,7 +693,7 @@ where
                     };
                     self.insert_tag(tag)
                 },
-                Tag(Tag {
+                Token::Tag(Tag {
                     kind: EmptyTag,
                     name,
                     attrs,
@@ -714,7 +716,7 @@ where
                         self.append_tag(tag)
                     }
                 },
-                Tag(Tag {
+                Token::Tag(Tag {
                     kind: EndTag,
                     name,
                     attrs,
@@ -732,41 +734,45 @@ where
                         let script = current_node(&self.open_elems.borrow()).clone();
                         self.close_tag(tag);
                         if self.no_open_elems() {
-                            self.phase.set(End);
+                            self.phase.set(XmlPhase::End);
                         }
                         return XmlProcessResult::Script(script);
                     }
                     let retval = self.close_tag(tag);
                     if self.no_open_elems() {
-                        self.phase.set(End);
+                        self.phase.set(XmlPhase::End);
                     }
                     retval
                 },
-                Tag(Tag { kind: ShortTag, .. }) => {
+                Token::Tag(Tag { kind: ShortTag, .. }) => {
                     self.pop();
                     if self.no_open_elems() {
-                        self.phase.set(End);
+                        self.phase.set(XmlPhase::End);
                     }
-                    Done
+                    XmlProcessResult::Done
+                },
+                Token::Comment(comment) => self.append_comment_to_tag(comment),
+                Token::ProcessingInstruction(pi) => self.append_pi_to_tag(pi),
+                Token::Eof | Token::NullCharacter => {
+                    XmlProcessResult::Reprocess(XmlPhase::End, Token::Eof)
                 },
-                Comment(comment) => self.append_comment_to_tag(comment),
-                Pi(pi) => self.append_pi_to_tag(pi),
-                Eof | NullCharacter => Reprocess(End, Eof),
-                Doctype(_) => {
+                Token::Doctype(_) => {
                     self.sink
                         .parse_error(Borrowed("Unexpected element in main phase"));
-                    Done
+                    XmlProcessResult::Done
                 },
             },
-            End => match token {
-                Comment(comment) => self.append_comment_to_doc(comment),
-                Pi(pi) => self.append_pi_to_doc(pi),
-                Characters(ref chars) if !any_not_whitespace(chars) => Done,
-                Eof => self.stop_parsing(),
+            XmlPhase::End => match token {
+                Token::Comment(comment) => self.append_comment_to_doc(comment),
+                Token::ProcessingInstruction(pi) => self.append_pi_to_doc(pi),
+                Token::Characters(ref chars) if !any_not_whitespace(chars) => {
+                    XmlProcessResult::Done
+                },
+                Token::Eof => self.stop_parsing(),
                 _ => {
                     self.sink
                         .parse_error(Borrowed("Unexpected element in end phase"));
-                    Done
+                    XmlProcessResult::Done
                 },
             },
         }

xml5ever/src/tree_builder/types.rs

@@ -7,12 +7,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub use self::Token::*;
-pub use self::XmlPhase::*;
-pub use self::XmlProcessResult::*;
-
 use crate::tendril::StrTendril;
-use crate::tokenizer::{Doctype, Pi, Tag};
+use crate::tokenizer::{Doctype, ProcessingInstruction, Tag};
 
 #[derive(PartialEq, Eq, Copy, Clone, Debug)]
 pub enum XmlPhase {
@@ -29,7 +25,7 @@ pub enum Token {
     Doctype(Doctype),
     Comment(StrTendril),
     Characters(StrTendril),
-    Pi(Pi),
+    ProcessingInstruction(ProcessingInstruction),
     NullCharacter,
     Eof,
 }