compact luals runtime.special config

Author: CppCXY

crates/emmylua_code_analysis/resources/schema.json

@@ -118,6 +118,7 @@
         "nonstandardSymbol": [],
         "requireLikeFunction": [],
         "requirePattern": [],
+        "special": {},
         "version": "LuaLatest"
       }
     },
@@ -954,6 +955,14 @@
             "type": "string"
           }
         },
+        "special": {
+          "description": "Special symbols.",
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/EmmyrcSpecialSymbol"
+          },
+          "default": {}
+        },
         "version": {
           "description": "Lua version.",
           "$ref": "#/$defs/EmmyrcLuaVersion",
@@ -988,6 +997,17 @@
         }
       }
     },
+    "EmmyrcSpecialSymbol": {
+      "type": "string",
+      "enum": [
+        "None",
+        "Require",
+        "Error",
+        "Assert",
+        "Type",
+        "Setmetatable"
+      ]
+    },
     "EmmyrcStrict": {
       "type": "object",
       "properties": {

crates/emmylua_code_analysis/src/config/configs/runtime.rs

@@ -1,5 +1,8 @@
-use emmylua_parser::{LuaNonStdSymbol, LuaVersionNumber};
+use std::collections::HashMap;
+
+use emmylua_parser::{LuaNonStdSymbol, LuaVersionNumber, SpecialFunction};
 use schemars::JsonSchema;
+use serde::de::Deserializer;
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug, JsonSchema, Clone)]
@@ -26,6 +29,9 @@ pub struct EmmyrcRuntime {
     /// Non-standard symbols.
     #[serde(default)]
     pub nonstandard_symbol: Vec<EmmyrcNonStdSymbol>,
+    /// Special symbols.
+    #[serde(default)]
+    pub special: HashMap<String, EmmyrcSpecialSymbol>,
 }
 
 impl Default for EmmyrcRuntime {
@@ -38,6 +44,7 @@ impl Default for EmmyrcRuntime {
             require_pattern: Default::default(),
             class_default_call: Default::default(),
             nonstandard_symbol: Default::default(),
+            special: Default::default(),
         }
     }
 }
@@ -173,6 +180,63 @@ impl From<EmmyrcNonStdSymbol> for LuaNonStdSymbol {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, JsonSchema)]
+pub enum EmmyrcSpecialSymbol {
+    None,
+    Require,
+    Error,
+    Assert,
+    Type,
+    Setmetatable,
+}
+
+impl<'de> Deserialize<'de> for EmmyrcSpecialSymbol {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        match s.as_str() {
+            "require" => Ok(EmmyrcSpecialSymbol::Require),
+            "error" => Ok(EmmyrcSpecialSymbol::Error),
+            "assert" => Ok(EmmyrcSpecialSymbol::Assert),
+            "type" => Ok(EmmyrcSpecialSymbol::Type),
+            "setmetatable" => Ok(EmmyrcSpecialSymbol::Setmetatable),
+            _ => Ok(EmmyrcSpecialSymbol::None),
+        }
+    }
+}
+
+impl<'serialize> Serialize for EmmyrcSpecialSymbol {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let s = match self {
+            EmmyrcSpecialSymbol::None => "none",
+            EmmyrcSpecialSymbol::Require => "require",
+            EmmyrcSpecialSymbol::Error => "error",
+            EmmyrcSpecialSymbol::Assert => "assert",
+            EmmyrcSpecialSymbol::Type => "type",
+            EmmyrcSpecialSymbol::Setmetatable => "setmetatable",
+        };
+        serializer.serialize_str(s)
+    }
+}
+
+impl From<EmmyrcSpecialSymbol> for Option<SpecialFunction> {
+    fn from(symbol: EmmyrcSpecialSymbol) -> Self {
+        match symbol {
+            EmmyrcSpecialSymbol::None => None,
+            EmmyrcSpecialSymbol::Require => Some(SpecialFunction::Require),
+            EmmyrcSpecialSymbol::Error => Some(SpecialFunction::Error),
+            EmmyrcSpecialSymbol::Assert => Some(SpecialFunction::Assert),
+            EmmyrcSpecialSymbol::Type => Some(SpecialFunction::Type),
+            EmmyrcSpecialSymbol::Setmetatable => Some(SpecialFunction::Setmetaatable),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/emmylua_code_analysis/src/config/mod.rs

@@ -71,6 +71,11 @@ impl Emmyrc {
     ) -> ParserConfig<'cache> {
         let lua_language_level = self.get_language_level();
         let mut special_like = HashMap::new();
+        for (name, func) in self.runtime.special.iter() {
+            if let Some(func) = func.clone().into() {
+                special_like.insert(name.clone(), func);
+            }
+        }
         for name in self.runtime.require_like_function.iter() {
             special_like.insert(name.clone(), SpecialFunction::Require);
         }

crates/emmylua_parser/src/grammar/lua/expr.rs

@@ -372,7 +372,7 @@ fn parse_name_or_special_function(p: &mut LuaParser) -> ParseResult {
         SpecialFunction::Assert => LuaSyntaxKind::AssertCallExpr,
         SpecialFunction::Error => LuaSyntaxKind::ErrorCallExpr,
         SpecialFunction::Type => LuaSyntaxKind::TypeCallExpr,
-        SpecialFunction::Setmatable => LuaSyntaxKind::SetmetatableCallExpr,
+        SpecialFunction::Setmetaatable => LuaSyntaxKind::SetmetatableCallExpr,
         _ => LuaSyntaxKind::None,
     };
     p.bump();

crates/emmylua_parser/src/parser/parser_config.rs

@@ -47,7 +47,7 @@ impl<'cache> ParserConfig<'cache> {
             "error" => SpecialFunction::Error,
             "assert" => SpecialFunction::Assert,
             "type" => SpecialFunction::Type,
-            "setmetatable" => SpecialFunction::Setmatable,
+            "setmetatable" => SpecialFunction::Setmetaatable,
             _ => *self
                 .special_like
                 .get(name)
@@ -89,5 +89,5 @@ pub enum SpecialFunction {
     Error,
     Assert,
     Type,
-    Setmatable,
+    Setmetaatable,
 }