WIP: support for multiline html attributes and attributes named <!--

Author: lolbinarycat

src/librustdoc/passes/lint/html_tags.rs

@@ -152,20 +152,27 @@ pub(crate) fn visit_item(cx: &DocContext<'_>, item: &Item, hir_id: HirId, dox: &
         }
     }
 
-    if !tagp.tag_name.is_empty() {
-        report_diag(format!("incomplete HTML tag `{}`", &tagp.tag_name), &(tagp.tag_start_pos..dox.len()), false);
-    }
-
-    for (tag, range) in tagp.tags.iter().filter(|(t, range)| {
-        let t = t.to_lowercase();
-        !is_implicitly_self_closing(&t, range.clone(), dox)
-    }) {
-        report_diag(format!("unclosed HTML tag `{tag}`"), range, true);
-    }
-
     if let Some(range) = is_in_comment {
         report_diag("Unclosed HTML comment".to_string(), &range, false);
+    } else if let &Some(quote_pos) = &tagp.quote_pos {
+        let qr = Range { start: quote_pos, end: quote_pos };
+        report_diag(
+            format!("unclosed quoted HTML attribute on tag `{}`", &tagp.tag_name),
+            &qr,
+            false,
+        );
+    } else {
+        if !tagp.tag_name.is_empty() {
+            report_diag(format!("incomplete HTML tag `{}`", &tagp.tag_name), &(tagp.tag_start_pos..dox.len()), false);
+        }
+        for (tag, range) in tagp.tags.iter().filter(|(t, range)| {
+            let t = t.to_lowercase();
+            !is_implicitly_self_closing(&t, range.clone(), dox)
+        }) {
+            report_diag(format!("unclosed HTML tag `{tag}`"), range, true);
+        }
     }
+
 }
 
 /// These tags are interpreted as self-closing if they lack an explict closing tag.
@@ -251,16 +258,25 @@ struct TagParser {
     is_closing: bool,
     /// `true` if we are within a tag, but not within its name.
     in_attrs: bool,
+    /// If we are in a quoted attribute, what quote char does it use?
+    ///
+    /// This needs to be stored in the struct since HTML5 allows newlines in quoted attrs.
+    quote: Option<char>,
+    quote_pos: Option<usize>,
+    after_eq: bool,
 }
 
 impl TagParser {
     fn new() -> Self {
         Self{
             tags: Vec::new(),
             tag_name: String::with_capacity(8),
-            is_closing: false,
             tag_start_pos: 0,
+            is_closing: false,
             in_attrs: false,
+            quote: None,
+            quote_pos: None,
+            after_eq:false,
         }
     }
 
@@ -375,39 +391,36 @@ impl TagParser {
                         self.drop_tag(r, dox, f);
                     } else {
                         let mut is_self_closing = false;
-                        let mut quote_pos = None;
                         if c != '>' {
-                            let mut quote = None;
-                            let mut after_eq = false;
                             'parse_til_gt: {
                                 for (i, c) in text[pos..].char_indices() {
                                     if !c.is_whitespace() {
-                                        if let Some(q) = quote {
+                                        if let Some(q) = self.quote {
                                             if c == q {
-                                                quote = None;
-                                                quote_pos = None;
-                                                after_eq = false;
+                                                self.quote = None;
+                                                self.quote_pos = None;
+                                                self.after_eq = false;
                                             }
                                         } else if c == '>' {
                                             // fall through and call `tag_parsed`.
                                             break 'parse_til_gt;
                                         } else if c == '<' {
                                             self.handle_lt_in_tag(range.clone(), pos + i, f);
-                                        } else if c == '/' && !after_eq {
+                                        } else if c == '/' && !self.after_eq {
                                             is_self_closing = true;
                                         } else {
                                             if is_self_closing {
                                                 is_self_closing = false;
                                             }
-                                            if (c == '"' || c == '\'') && after_eq {
-                                                quote = Some(c);
-                                                quote_pos = Some(pos + i);
+                                            if (c == '"' || c == '\'') && self.after_eq {
+                                                self.quote = Some(c);
+                                                self.quote_pos = Some(pos + i);
                                             } else if c == '=' {
-                                                after_eq = true;
+                                                self.after_eq = true;
                                             }
                                         }
-                                    } else if quote.is_none() {
-                                        after_eq = false;
+                                    } else if self.quote.is_none() {
+                                        self.after_eq = false;
                                     }
                                 }
                                 // if we've run out of text but still haven't found a `>`,
@@ -417,14 +430,6 @@ impl TagParser {
                                 break 'outer_loop;
                             }
                         }
-                        if let Some(quote_pos) = quote_pos {
-                            let qr = Range { start: quote_pos, end: quote_pos };
-                            f(
-                                format!("unclosed quoted HTML attribute on tag `{}`", &self.tag_name),
-                                &qr,
-                                false,
-                            );
-                        }
                         if is_self_closing {
                             // https://html.spec.whatwg.org/#parse-error-non-void-html-element-start-tag-with-trailing-solidus
                             let valid = ALLOWED_UNCLOSED.contains(&&self.tag_name[..])
@@ -470,7 +475,8 @@ impl TagParser {
                     *is_in_comment = None;
                 }
             } else if c == '<' {
-                if text[start_pos..].starts_with("<!--") {
+                // "<!--" is a valid attribute name under html5, so don't treat it as a comment if we're in a tag.
+                if self.tag_name.is_empty() && text[start_pos..].starts_with("<!--") {
                     // We skip the "!--" part. (Once `advance_by` is stable, might be nice to use it!)
                     iter.next();
                     iter.next();

tests/rustdoc-ui/lints/invalid-html-tags.rs

@@ -177,3 +177,23 @@ pub fn u() {}
 
 /// <a href=">" alt="<">html5 allows this</a>
 pub fn no_error_5() {}
+
+/// <img title="
+/// html5
+/// allows
+/// multiline
+/// attr
+/// values
+/// ">
+pub fn no_error_6() {}
+
+/// <a href="data:text/html,<!DOCTYPE>
+/// <html>
+/// <body><b>this is allowed for some reason</b></body>
+/// </html>
+/// ">what</a>'
+pub fn no_error_7() {}
+
+
+/// <p <!-->all of &gt;, !, and - are valid in attribute names</p>
+pub fn no_error_7() {}