Remove multiplicity from rules.

ace-design · Sep 20, 2023 · 641d80c · 641d80c
1 parent 0e259f5
commit 641d80c
Show file tree

Hide file tree

Showing 5 changed files with 176 additions and 223 deletions.
diff --git a/ls_framework/src/features/completion.rs b/ls_framework/src/features/completion.rs
@@ -38,7 +38,6 @@ fn get_symbol_completion_type(symbol_kind: String) -> Option<CompletionItemKind>
 
 pub fn get_list(
     position: Position,
-    source_code: &str,
     ast_query: &Arc<Mutex<impl AstQuery>>,
     st_query: &Arc<Mutex<impl SymbolTableQuery>>,
     context: Option<CompletionContext>,

diff --git a/ls_framework/src/file.rs b/ls_framework/src/file.rs
@@ -102,7 +102,6 @@ impl File {
     ) -> Option<Vec<CompletionItem>> {
         completion::get_list(
             position,
-            &self.source_code,
             &self.ast_manager,
             &self.symbol_table_manager,
             context,

diff --git a/ls_framework/src/language_def.rs b/ls_framework/src/language_def.rs
@@ -16,22 +16,7 @@ pub struct Rule {
     #[serde(default)]
     pub is_scope: bool,
     #[serde(default)]
-    pub children: Vec<Multiplicity>,
-}
-
-#[derive(Debug, Deserialize, Clone)]
-pub enum Multiplicity {
-    One(Child),
-    Maybe(Child),
-    Many(Child),
-}
-
-impl Multiplicity {
-    pub fn get_child(&self) -> &Child {
-        match self {
-            Multiplicity::One(c) | Multiplicity::Maybe(c) | Multiplicity::Many(c) => c,
-        }
-    }
+    pub children: Vec<Child>,
 }
 
 #[derive(Debug, Deserialize, Clone)]
@@ -145,11 +130,7 @@ impl LanguageDefinition {
         symbol_types.insert(0, HighlightType::Keyword.get());
 
         for rule in &self.ast_rules {
-            for mult in &rule.children {
-                let child = match mult {
-                    Multiplicity::One(c) | Multiplicity::Maybe(c) | Multiplicity::Many(c) => c,
-                };
-
+            for child in &rule.children {
                 if let Some(semantic_token_type) = &child.highlight_type {
                     symbol_types.push(semantic_token_type.get());
                 }

diff --git a/ls_framework/src/metadata/ast/rules_translator.rs b/ls_framework/src/metadata/ast/rules_translator.rs
@@ -2,9 +2,7 @@ use indextree::{Arena, NodeId};
 
 use super::{tree::Translator, Ast, Node, NodeKind};
 use crate::{
-    language_def::{
-        DirectOrRule, LanguageDefinition, Multiplicity, Rule, Symbol, TreesitterNodeQuery,
-    },
+    language_def::{Child, DirectOrRule, LanguageDefinition, Rule, Symbol, TreesitterNodeQuery},
     lsp_mappings::HighlightType,
 };
 
@@ -51,21 +49,16 @@ impl RulesTranslator {
             None,
         );
         // TODO: has_error vs is_error
-        for error_ts_node in children.iter().filter(|node| node.has_error()) {
-            // current_node_id.append(self.new_error_node(error_ts_node, None), &mut self.arena);
-        }
+        // for error_ts_node in children.iter().filter(|node| node.has_error()) {
+        //     current_node_id.append(self.new_error_node(error_ts_node, None), &mut self.arena);
+        // }
 
         for child in current_rule.children.iter() {
             self.query_parse_child(&children, child, current_node_id, current_ts_node);
         }
 
         for child in &LanguageDefinition::get().global_ast_rules {
-            self.query_parse_child(
-                &children,
-                &Multiplicity::Many(child.clone()),
-                current_node_id,
-                current_ts_node,
-            );
+            self.query_parse_child(&children, &child, current_node_id, current_ts_node);
         }
 
         current_node_id
@@ -74,14 +67,12 @@ impl RulesTranslator {
     fn query_parse_child(
         &mut self,
         children: &[tree_sitter::Node],
-        multiplicity: &Multiplicity,
+        child: &Child,
         current_node_id: NodeId,
         current_ts_node: &tree_sitter::Node,
     ) {
-        let child = multiplicity.get_child();
         let (query, node_or_rule) = (&child.query, &child.rule);
 
-        let mut counter = 0;
         for (i, ts_node) in children.iter().enumerate() {
             let target_node = if let TreesitterNodeQuery::Path(path) = query {
                 if path.is_empty() {
@@ -158,25 +149,8 @@ impl RulesTranslator {
                         current_node_id.append(self.parse(&rule, &target_node), &mut self.arena);
                     }
                 }
-
-                counter += 1;
-            }
-
-            if matches!(multiplicity, Multiplicity::One(_) | Multiplicity::Maybe(_)) && counter > 1
-            {
-                // current_node_id.append(
-                //     self.new_error_node(ts_node, Some(format!("Too many '{:?}'.", query))),
-                //     &mut self.arena,
-                // );
             }
         }
-
-        if matches!(multiplicity, Multiplicity::One(_)) && counter == 0 {
-            // current_node_id.append(
-            //     self.new_error_node(current_ts_node, Some(format!("Missing '{:?}'.", query))),
-            //     &mut self.arena,
-            // );
-        }
     }
 
     fn new_node(