Don't Panic!

benches/highlight_utils/mod.rs

@@ -1,4 +1,4 @@
-use syntect::easy::HighlightLines;
+use syntect::easy::{HighlightLines, HighlightOptions};
 use syntect::highlighting::Theme;
 use syntect::parsing::{SyntaxReference, SyntaxSet};
 
@@ -9,7 +9,7 @@ pub fn do_highlight(
     syntax: &SyntaxReference,
     theme: &Theme,
 ) -> usize {
-    let mut h = HighlightLines::new(syntax, theme);
+    let mut h = HighlightLines::new(syntax, theme, HighlightOptions::default());
     let mut count = 0;
     for line in s.lines() {
         let regions = h.highlight_line(line, syntax_set).unwrap();

benches/parsing.rs

@@ -5,7 +5,7 @@ use syntect::parsing::{ParseState, SyntaxReference, SyntaxSet};
 mod utils;
 
 fn do_parse(s: &str, ss: &SyntaxSet, syntax: &SyntaxReference) -> usize {
-    let mut state = ParseState::new(syntax);
+    let mut state = ParseState::new(syntax, false);
     let mut count = 0;
     for line in s.lines() {
         let ops = state.parse_line(line, ss).unwrap();

examples/latex-demo.rs

@@ -1,4 +1,4 @@
-use syntect::easy::HighlightLines;
+use syntect::easy::{HighlightLines, HighlightOptions};
 use syntect::highlighting::{Style, ThemeSet};
 use syntect::parsing::SyntaxSet;
 use syntect::util::{as_latex_escaped, LinesWithEndings};
@@ -11,7 +11,11 @@ fn main() {
     let syntax = ps.find_syntax_by_extension("rs").unwrap();
     let s = "pub struct Wow { hi: u64 }\nfn blah() -> u64 {}\n";
 
-    let mut h = HighlightLines::new(syntax, &ts.themes["InspiredGitHub"]);
+    let mut h = HighlightLines::new(
+        syntax,
+        &ts.themes["InspiredGitHub"],
+        HighlightOptions::default(),
+    );
     for line in LinesWithEndings::from(s) {
         // LinesWithEndings enables use of newlines mode
         let ranges: Vec<(Style, &str)> = h.highlight_line(line, &ps).unwrap();

examples/parsyncat.rs

@@ -2,7 +2,7 @@
 //! Prints the highlighted output to stdout.
 
 use rayon::prelude::*;
-use syntect::easy::HighlightFile;
+use syntect::easy::{HighlightFile, HighlightOptions};
 use syntect::highlighting::{Style, ThemeSet};
 use syntect::parsing::SyntaxSet;
 
@@ -44,7 +44,9 @@ fn main() {
         .map(|(filename, contents)| {
             let mut regions = Vec::new();
             let theme = &theme_set.themes["base16-ocean.dark"];
-            let mut highlighter = HighlightFile::new(filename, &syntax_set, theme).unwrap();
+            let mut highlighter =
+                HighlightFile::new(filename, &syntax_set, theme, HighlightOptions::default())
+                    .unwrap();
 
             for line in contents {
                 for region in highlighter

examples/syncat.rs

@@ -3,7 +3,7 @@ use std::borrow::Cow;
 use std::io::BufRead;
 use std::path::Path;
 use syntect::dumps::{dump_to_file, from_dump_file};
-use syntect::easy::HighlightFile;
+use syntect::easy::{HighlightFile, HighlightOptions};
 use syntect::highlighting::{Style, Theme, ThemeSet};
 use syntect::parsing::SyntaxSet;
 use syntect::util::as_24_bit_terminal_escaped;
@@ -111,7 +111,8 @@ fn main() {
                 println!("==> {} <==", src);
             }
 
-            let mut highlighter = HighlightFile::new(src, &ss, &theme).unwrap();
+            let mut highlighter =
+                HighlightFile::new(src, &ss, &theme, HighlightOptions::default()).unwrap();
 
             // We use read_line instead of `for line in highlighter.reader.lines()` because that
             // doesn't return strings with a `\n`, and including the `\n` gets us more robust highlighting.

examples/synstats.rs

@@ -183,7 +183,7 @@ fn count(ss: &SyntaxSet, path: &Path, stats: &mut Stats) {
         None => return,
     };
     stats.files += 1;
-    let mut state = ParseState::new(syntax);
+    let mut state = ParseState::new(syntax, false);
 
     let f = File::open(path).unwrap();
     let mut reader = BufReader::new(f);

examples/syntest.rs

@@ -212,7 +212,7 @@ fn test_file(
         .ok_or(SyntaxTestHeaderError::SyntaxDefinitionNotFound)?;
 
     // iterate over the lines of the file, testing them
-    let mut state = ParseState::new(syntax);
+    let mut state = ParseState::new(syntax, false);
     let mut stack = ScopeStack::new();
 
     let mut current_line_number = 1;

src/easy.rs

@@ -4,9 +4,9 @@
 
 use crate::highlighting::{HighlightIterator, HighlightState, Highlighter, Style, Theme};
 use crate::parsing::{ParseState, ScopeStack, ScopeStackOp, SyntaxReference, SyntaxSet};
-use crate::Error;
+use crate::{Error, LoadingError};
 use std::fs::File;
-use std::io::{self, BufReader};
+use std::io::BufReader;
 use std::path::Path;
 // use util::debug_print_ops;
 
@@ -46,13 +46,26 @@ pub struct HighlightLines<'a> {
     highlight_state: HighlightState,
 }
 
+/// Options for highlighting operations
+#[derive(Debug, Clone, Copy, Default)]
+pub struct HighlightOptions {
+    /// If true, errors in parsing the syntax will have the minimal possible impact,
+    /// highlighting will proceed as if the error did not occur.
+    /// If false, errors will be propagated as errors.
+    pub ignore_errors: bool,
+}
+
 impl<'a> HighlightLines<'a> {
-    pub fn new(syntax: &SyntaxReference, theme: &'a Theme) -> HighlightLines<'a> {
+    pub fn new(
+        syntax: &SyntaxReference,
+        theme: &'a Theme,
+        options: HighlightOptions,
+    ) -> HighlightLines<'a> {
         let highlighter = Highlighter::new(theme);
         let highlight_state = HighlightState::new(&highlighter, ScopeStack::new());
         HighlightLines {
             highlighter,
-            parse_state: ParseState::new(syntax),
+            parse_state: ParseState::new(syntax, options.ignore_errors),
             highlight_state,
         }
     }
@@ -158,7 +171,8 @@ impl<'a> HighlightFile<'a> {
         path_obj: P,
         ss: &SyntaxSet,
         theme: &'a Theme,
-    ) -> io::Result<HighlightFile<'a>> {
+        options: HighlightOptions,
+    ) -> Result<HighlightFile<'a>, LoadingError> {
         let path: &Path = path_obj.as_ref();
         let f = File::open(path)?;
         let syntax = ss
@@ -167,7 +181,7 @@ impl<'a> HighlightFile<'a> {
 
         Ok(HighlightFile {
             reader: BufReader::new(f),
-            highlight_lines: HighlightLines::new(syntax, theme),
+            highlight_lines: HighlightLines::new(syntax, theme, options),
         })
     }
 }
@@ -285,7 +299,11 @@ mod tests {
         let ss = SyntaxSet::load_defaults_nonewlines();
         let ts = ThemeSet::load_defaults();
         let syntax = ss.find_syntax_by_extension("rs").unwrap();
-        let mut h = HighlightLines::new(syntax, &ts.themes["base16-ocean.dark"]);
+        let mut h = HighlightLines::new(
+            syntax,
+            &ts.themes["base16-ocean.dark"],
+            HighlightOptions::default(),
+        );
         let ranges = h
             .highlight_line("pub struct Wow { hi: u64 }", &ss)
             .expect("#[cfg(test)]");
@@ -301,6 +319,7 @@ mod tests {
             "testdata/highlight_test.erb",
             &ss,
             &ts.themes["base16-ocean.dark"],
+            HighlightOptions::default(),
         )
         .unwrap();
     }
@@ -309,7 +328,7 @@ mod tests {
     #[test]
     fn can_find_regions() {
         let ss = SyntaxSet::load_defaults_nonewlines();
-        let mut state = ParseState::new(ss.find_syntax_by_extension("rb").unwrap());
+        let mut state = ParseState::new(ss.find_syntax_by_extension("rb").unwrap(), false);
         let line = "lol =5+2";
         let ops = state.parse_line(line, &ss).expect("#[cfg(test)]");
 
@@ -338,7 +357,7 @@ mod tests {
     #[test]
     fn can_find_regions_with_trailing_newline() {
         let ss = SyntaxSet::load_defaults_newlines();
-        let mut state = ParseState::new(ss.find_syntax_by_extension("rb").unwrap());
+        let mut state = ParseState::new(ss.find_syntax_by_extension("rb").unwrap(), false);
         let lines = ["# hello world\n", "lol=5+2\n"];
         let mut stack = ScopeStack::new();
 

src/highlighting/highlighter.rs

@@ -397,7 +397,7 @@ mod tests {
         let ps = SyntaxSet::load_from_folder("testdata/Packages").unwrap();
         let mut state = {
             let syntax = ps.find_syntax_by_name("Ruby on Rails").unwrap();
-            ParseState::new(syntax)
+            ParseState::new(syntax, false)
         };
         let ts = ThemeSet::load_defaults();
         let highlighter = Highlighter::new(&ts.themes["base16-ocean.dark"]);
@@ -438,7 +438,7 @@ mod tests {
             let syntax = ps
                 .find_syntax_by_scope(Scope::new("source.python").unwrap())
                 .unwrap();
-            ParseState::new(syntax)
+            ParseState::new(syntax, false)
         };
         let ts = ThemeSet::load_defaults();
         let highlighter = Highlighter::new(&ts.themes["base16-ocean.dark"]);
@@ -609,7 +609,7 @@ mod tests {
         let ps = SyntaxSet::load_from_folder("testdata/Packages").unwrap();
         let mut state = {
             let syntax = ps.find_syntax_by_name("Ruby on Rails").unwrap();
-            ParseState::new(syntax)
+            ParseState::new(syntax, false)
         };
         let ts = ThemeSet::load_defaults();
         let highlighter = Highlighter::new(&ts.themes["base16-ocean.dark"]);

src/html.rs

@@ -1,5 +1,5 @@
 //! Rendering highlighted code as HTML+CSS
-use crate::easy::{HighlightFile, HighlightLines};
+use crate::easy::{HighlightFile, HighlightLines, HighlightOptions};
 use crate::escape::Escape;
 use crate::highlighting::{Color, FontStyle, Style, Theme};
 use crate::parsing::{
@@ -72,7 +72,7 @@ impl<'a> ClassedHTMLGenerator<'a> {
         syntax_set: &'a SyntaxSet,
         style: ClassStyle,
     ) -> ClassedHTMLGenerator<'a> {
-        let parse_state = ParseState::new(syntax_reference);
+        let parse_state = ParseState::new(syntax_reference, true /* ignore errors */);
         let open_spans = 0;
         let html = String::new();
         let scope_stack = ScopeStack::new();
@@ -286,7 +286,7 @@ pub fn highlighted_html_for_string(
     syntax: &SyntaxReference,
     theme: &Theme,
 ) -> Result<String, Error> {
-    let mut highlighter = HighlightLines::new(syntax, theme);
+    let mut highlighter = HighlightLines::new(syntax, theme, HighlightOptions::default());
     let (mut output, bg) = start_highlighted_html_snippet(theme);
 
     for line in LinesWithEndings::from(s) {
@@ -312,7 +312,7 @@ pub fn highlighted_html_for_file<P: AsRef<Path>>(
     ss: &SyntaxSet,
     theme: &Theme,
 ) -> Result<String, Error> {
-    let mut highlighter = HighlightFile::new(path, ss, theme)?;
+    let mut highlighter = HighlightFile::new(path, ss, theme, HighlightOptions::default())?;
     let (mut output, bg) = start_highlighted_html_snippet(theme);
 
     let mut line = String::new();
@@ -562,7 +562,7 @@ mod tests {
     fn tokens() {
         let ss = SyntaxSet::load_defaults_newlines();
         let syntax = ss.find_syntax_by_name("Markdown").unwrap();
-        let mut state = ParseState::new(syntax);
+        let mut state = ParseState::new(syntax, false);
         let line = "[w](t.co) *hi* **five**";
         let ops = state.parse_line(line, &ss).expect("#[cfg(test)]");
         let mut stack = ScopeStack::new();