Decouple functions from fields namespace

engine/src/scheme.rs

@@ -443,9 +443,17 @@
 
         let name = span(initial_input, input);
 
-        let field = scheme
-            .get(name)
-            .ok_or((LexErrorKind::UnknownIdentifier, name))?;
+        let field = if input.starts_with('(') {
+            scheme
+                .get_function(name)
+                .map(Identifier::Function)
+                .map_err(|_| (LexErrorKind::UnknownIdentifier, name))?
+        } else {
+            scheme
+                .get_field(name)
+                .map(Identifier::Field)
+                .map_err(|_| (LexErrorKind::UnknownIdentifier, name))?
+        };
 
         Ok((field, input))
     }
@@ -486,7 +494,7 @@
 }
 
 #[derive(Clone, Copy, Debug)]
 enum SchemeItem {
     Field(usize),
     Function(usize),
 }
@@ -628,7 +636,8 @@
 pub struct SchemeBuilder {
     fields: Vec<FieldDefinition>,
     functions: Vec<(IdentifierName, Box<dyn FunctionDefinition>)>,
-    items: HashMap<IdentifierName, SchemeItem, FnvBuildHasher>,
+    fields_map: HashMap<IdentifierName, usize, FnvBuildHasher>,
+    functions_map: HashMap<IdentifierName, usize, FnvBuildHasher>,
 
     list_types: HashMap<Type, usize, FnvBuildHasher>,
     lists: Vec<(Type, Box<dyn ListDefinition>)>,
@@ -648,23 +657,18 @@
         ty: Type,
         optional: bool,
     ) -> Result<(), IdentifierRedefinitionError> {
-        match self.items.entry(name) {
-            Entry::Occupied(entry) => match entry.get() {
-                SchemeItem::Field(_) => Err(IdentifierRedefinitionError::Field(
-                    FieldRedefinitionError(entry.key().to_string()),
-                )),
-                SchemeItem::Function(_) => Err(IdentifierRedefinitionError::Function(
-                    FunctionRedefinitionError(entry.key().to_string()),
-                )),
-            },
+        match self.fields_map.entry(name) {
+            Entry::Occupied(entry) => Err(IdentifierRedefinitionError::Field(
+                FieldRedefinitionError(entry.key().to_string()),
+            )),
             Entry::Vacant(entry) => {
                 let index = self.fields.len();
                 self.fields.push(FieldDefinition {
                     name: entry.key().clone(),
                     ty,
                     optional,
                 });
-                entry.insert(SchemeItem::Field(index));
+                entry.insert(index);
                 Ok(())
             }
         }
@@ -694,20 +698,15 @@
         name: N,
         function: impl FunctionDefinition + 'static,
     ) -> Result<(), IdentifierRedefinitionError> {
-        match self.items.entry(name.as_ref().into()) {
-            Entry::Occupied(entry) => match entry.get() {
-                SchemeItem::Field(_) => Err(IdentifierRedefinitionError::Field(
-                    FieldRedefinitionError(entry.key().to_string()),
-                )),
-                SchemeItem::Function(_) => Err(IdentifierRedefinitionError::Function(
-                    FunctionRedefinitionError(entry.key().to_string()),
-                )),
-            },
+        match self.functions_map.entry(name.as_ref().into()) {
+            Entry::Occupied(entry) => Err(IdentifierRedefinitionError::Function(
+                FunctionRedefinitionError(entry.key().to_string()),
+            )),
             Entry::Vacant(entry) => {
                 let index = self.functions.len();
                 self.functions
                     .push((entry.key().clone(), Box::new(function)));
-                entry.insert(SchemeItem::Function(index));
+                entry.insert(index);
                 Ok(())
             }
         }
@@ -851,26 +850,16 @@
 }
 
 impl<'s> Scheme {
-    /// Returns the [`identifier`](enum@Identifier) with the specified `name`.
-    pub(crate) fn get(&'s self, name: &str) -> Option<Identifier<'s>> {
-        self.inner.items.get(name).map(move |item| match *item {
-            SchemeItem::Field(index) => Identifier::Field(FieldRef {
-                scheme: self,
-                index,
-            }),
-            SchemeItem::Function(index) => Identifier::Function(FunctionRef {
-                scheme: self,
-                index,
-            }),
-        })
-    }
-
     /// Returns the [`field`](struct@Field) with the specified `name`.
     pub fn get_field(&'s self, name: &str) -> Result<FieldRef<'s>, UnknownFieldError> {
-        match self.get(name) {
-            Some(Identifier::Field(f)) => Ok(f),
-            _ => Err(UnknownFieldError),
-        }
+        self.inner
+            .fields_map
+            .get(name)
+            .map(move |item| FieldRef {
+                scheme: self,
+                index: *item,
+            })
+            .ok_or(UnknownFieldError)
     }
 
     /// Iterates over fields registered in the [`scheme`](struct@Scheme).
@@ -896,10 +885,14 @@
 
     /// Returns the [`function`](struct@Function) with the specified `name`.
     pub fn get_function(&'s self, name: &str) -> Result<FunctionRef<'s>, UnknownFunctionError> {
-        match self.get(name) {
-            Some(Identifier::Function(f)) => Ok(f),
-            _ => Err(UnknownFunctionError),
-        }
+        self.inner
+            .functions_map
+            .get(name)
+            .map(move |item| FunctionRef {
+                scheme: self,
+                index: *item,
+            })
+            .ok_or(UnknownFunctionError)
     }
 
     /// Iterates over functions registered in the [`scheme`](struct@Scheme).