Paralellize creation of LaTeX symbol table

Cargo.toml

@@ -29,6 +29,7 @@ lsp-types = { version = "0.61.0", features = ["proposed"] }
 nom = "5.1"
 once_cell = "1.3"
 petgraph = { version = "0.5", features = ["serde-1"] }
+rayon = "1.3"
 relative-path = { version = "1.0", features = ["serde"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

src/syntax/latex/analysis.rs

@@ -63,49 +63,70 @@ impl SymbolTable {
             cwd,
         };
 
-        let environments = Environment::parse(ctx);
-        let is_standalone = environments.iter().any(|env| env.is_root(&tree));
+        let mut environments = None;
+        let mut includes = None;
+        let mut citations = None;
+        let mut command_definitions = None;
+        let mut glossary_entries = None;
+        let mut equations = None;
+        let mut inlines = None;
+        let mut math_operators = None;
+        let mut theorem_definitions = None;
+        let mut sections = None;
+        let mut labels = None;
+        let mut label_numberings = None;
+        let mut captions = None;
+        let mut items = None;
+
+        rayon::scope(|s| {
+            s.spawn(|_| environments = Some(Environment::parse(ctx)));
+            s.spawn(|_| includes = Some(Include::parse(ctx)));
+            s.spawn(|_| citations = Some(Citation::parse(ctx)));
+            s.spawn(|_| command_definitions = Some(CommandDefinition::parse(ctx)));
+            s.spawn(|_| glossary_entries = Some(GlossaryEntry::parse(ctx)));
+            s.spawn(|_| equations = Some(Equation::parse(ctx)));
+            s.spawn(|_| inlines = Some(Inline::parse(ctx)));
+            s.spawn(|_| math_operators = Some(MathOperator::parse(ctx)));
+            s.spawn(|_| theorem_definitions = Some(TheoremDefinition::parse(ctx)));
+            s.spawn(|_| sections = Some(Section::parse(ctx)));
+            s.spawn(|_| labels = Some(Label::parse(ctx)));
+            s.spawn(|_| label_numberings = Some(LabelNumbering::parse(ctx)));
+            s.spawn(|_| captions = Some(Caption::parse(ctx)));
+            s.spawn(|_| items = Some(Item::parse(ctx)));
+        });
+
+        let is_standalone = environments
+            .as_ref()
+            .unwrap()
+            .iter()
+            .any(|env| env.is_root(&tree));
 
-        let includes = Include::parse(ctx);
         let components = includes
+            .as_ref()
+            .unwrap()
             .iter()
             .flat_map(|include| include.components(&tree))
             .collect();
 
-        let citations = Citation::parse(ctx);
-        let command_definitions = CommandDefinition::parse(ctx);
-        let glossary_entries = GlossaryEntry::parse(ctx);
-
-        let equations = Equation::parse(ctx);
-        let inlines = Inline::parse(ctx);
-        let math_operators = MathOperator::parse(ctx);
-        let theorem_definitions = TheoremDefinition::parse(ctx);
-
-        let sections = Section::parse(ctx);
-        let labels = Label::parse(ctx);
-        let label_numberings = LabelNumbering::parse(ctx);
-        let captions = Caption::parse(ctx);
-        let items = Item::parse(ctx);
-
         Self {
             tree,
             commands,
-            environments,
+            environments: environments.unwrap(),
             is_standalone,
-            includes,
+            includes: includes.unwrap(),
             components,
-            citations,
-            command_definitions,
-            glossary_entries,
-            equations,
-            inlines,
-            math_operators,
-            theorem_definitions,
-            sections,
-            labels,
-            label_numberings,
-            captions,
-            items,
+            citations: citations.unwrap(),
+            command_definitions: command_definitions.unwrap(),
+            glossary_entries: glossary_entries.unwrap(),
+            equations: equations.unwrap(),
+            inlines: inlines.unwrap(),
+            math_operators: math_operators.unwrap(),
+            theorem_definitions: theorem_definitions.unwrap(),
+            sections: sections.unwrap(),
+            labels: labels.unwrap(),
+            label_numberings: label_numberings.unwrap(),
+            captions: captions.unwrap(),
+            items: items.unwrap(),
         }
     }
 }

src/syntax/latex/ast.rs

@@ -163,7 +163,7 @@ impl Tree {
     pub fn children(&self, parent: NodeIndex) -> impl Iterator<Item = NodeIndex> {
         self.graph
             .neighbors(parent)
-            .sorted_by_key(|child| self.graph.node_weight(*child).unwrap().start())
+            .sorted_by_key(|child| self.graph[*child].start())
     }
 
     pub fn walk<V: Visitor>(&self, visitor: &mut V, parent: NodeIndex) {
@@ -179,7 +179,7 @@ impl Tree {
     }
 
     pub fn print(&self, node: NodeIndex) -> String {
-        let start_position = self.graph.node_weight(node).unwrap().start();
+        let start_position = self.graph[node].start();
         let mut printer = Printer::new(start_position);
         printer.visit(self, node);
         printer.output
@@ -193,31 +193,31 @@ impl Tree {
     }
 
     pub fn as_group(&self, node: NodeIndex) -> Option<&Group> {
-        if let Node::Group(group) = self.graph.node_weight(node)? {
+        if let Node::Group(group) = &self.graph[node] {
             Some(group)
         } else {
             None
         }
     }
 
     pub fn as_command(&self, node: NodeIndex) -> Option<&Command> {
-        if let Node::Command(cmd) = self.graph.node_weight(node)? {
+        if let Node::Command(cmd) = &self.graph[node] {
             Some(cmd)
         } else {
             None
         }
     }
 
     pub fn as_text(&self, node: NodeIndex) -> Option<&Text> {
-        if let Node::Text(text) = self.graph.node_weight(node)? {
+        if let Node::Text(text) = &self.graph[node] {
             Some(text)
         } else {
             None
         }
     }
 
     pub fn as_math(&self, node: NodeIndex) -> Option<&Math> {
-        if let Node::Math(math) = self.graph.node_weight(node)? {
+        if let Node::Math(math) = &self.graph[node] {
             Some(math)
         } else {
             None
@@ -278,7 +278,7 @@ impl Tree {
         let group = self.extract_group(parent, group_kind, index)?;
         let mut words = Vec::new();
         for child in self.children(group) {
-            match self.graph.node_weight(child)? {
+            match &self.graph[child] {
                 Node::Root(_) | Node::Group(_) | Node::Command(_) | Node::Math(_) => return None,
                 Node::Text(text) => {
                     for word in &text.words {
@@ -313,13 +313,7 @@ impl Finder {
 
 impl Visitor for Finder {
     fn visit(&mut self, tree: &Tree, node: NodeIndex) {
-        if tree
-            .graph
-            .node_weight(node)
-            .unwrap()
-            .range()
-            .contains(self.position)
-        {
+        if tree.graph[node].range().contains(self.position) {
             self.results.push(node);
             tree.walk(self, node);
         }
@@ -365,7 +359,7 @@ impl Printer {
 
 impl Visitor for Printer {
     fn visit(&mut self, tree: &Tree, node: NodeIndex) {
-        match tree.graph.node_weight(node).unwrap() {
+        match &tree.graph[node] {
             Node::Root(_) => tree.walk(self, node),
             Node::Group(group) => {
                 self.print_token(&group.left);