generic match will decay const type

Author: CppCXY

crates/emmylua_code_analysis/resources/std/builtin.lua

@@ -123,6 +123,10 @@
 --- built-in type for Rawget
 ---@alias std.Rawget<T, K> unknown
 
+---
+--- built-in type for generic template, for match integer const and true/false
+---@alias std.ConstTpl<T> unknown
+
 --- compact luals
 
 ---@alias type std.type
@@ -132,3 +136,4 @@
 ---@alias metatable std.metatable
 
 ---@alias TypeGuard<T> boolean
+

crates/emmylua_code_analysis/resources/std/global.lua

@@ -271,7 +271,7 @@ function rawequal(v1, v2) end
 --- must be a table; `index` may be any value.
 ---@generic T, K
 ---@param table T
----@param index K
+---@param index std.ConstTpl<K>
 ---@return std.RawGet<T, K>
 function rawget(table, index) end
 
@@ -332,7 +332,7 @@ function require(modname) end
 --- Otherwise, `index` must be the string "#", and `select` returns
 --- the total number of extra arguments it received.
 ---@generic T, Num: integer | '#'
----@param index Num
+---@param index std.ConstTpl<Num>
 ---@param ... T...
 ---@return std.Select<T..., Num>
 function select(index, ...) end
@@ -451,8 +451,8 @@ function xpcall(f, msgh, ...) end
 
 ---@version 5.1, JIT
 ---@generic T, Start: integer, End: integer
----@param i? Start
----@param j? End
+---@param i? std.ConstTpl<Start>
+---@param j? std.ConstTpl<End>
 ---@param list T
 ---@return std.Unpack<T, Start, End>
 function unpack(list, i, j) end

crates/emmylua_code_analysis/resources/std/table.lua

@@ -108,8 +108,8 @@ function table.sort(list, comp) end
 --- return `list[i]`, `list[i+1]`, `···`, `list[j]`
 --- By default, i is 1 and j is #list.
 ---@generic T, Start: integer, End: integer
----@param i? Start
----@param j? End
+---@param i? std.ConstTpl<Start>
+---@param j? std.ConstTpl<End>
 ---@param list T
 ---@return std.Unpack<T, Start, End>
 function table.unpack(list, i, j) end

crates/emmylua_code_analysis/src/compilation/analyzer/doc/infer_type.rs

@@ -310,6 +310,13 @@ fn infer_special_generic_type(
 
             return Some(LuaType::TypeGuard(first_param.into()));
         }
+        "std.ConstTpl" => {
+            let first_doc_param_type = generic_type.get_generic_types()?.get_types().next()?;
+            let first_param = infer_type(analyzer, first_doc_param_type);
+            if let LuaType::TplRef(tpl) = first_param {
+                return Some(LuaType::ConstTplRef(tpl));
+            }
+        }
         _ => {}
     }
 

crates/emmylua_code_analysis/src/compilation/test/array_test.rs

@@ -30,4 +30,24 @@ mod test {
         "#,
         ));
     }
+
+    #[test]
+    fn test_create_array() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            ---@generic T
+            ---@param ... T
+            ---@return T[]
+            local function new_array(...)
+            end
+
+            t = new_array(1, 2, 3, 4, 5)
+        "#,
+        );
+
+        let t = ws.expr_ty("t");
+        let t_expected = ws.ty("integer[]");
+        assert_eq!(t, t_expected)
+    }
 }

crates/emmylua_code_analysis/src/db_index/type/types.rs

@@ -60,6 +60,7 @@ pub enum LuaType {
     Call(Arc<LuaAliasCallType>),
     MultiLineUnion(Arc<LuaMultiLineUnion>),
     TypeGuard(Arc<LuaType>),
+    ConstTplRef(Arc<GenericTpl>),
 }
 
 impl PartialEq for LuaType {
@@ -107,6 +108,7 @@ impl PartialEq for LuaType {
             (LuaType::MultiLineUnion(a), LuaType::MultiLineUnion(b)) => a == b,
             (LuaType::TypeGuard(a), LuaType::TypeGuard(b)) => a == b,
             (LuaType::Never, LuaType::Never) => true,
+            (LuaType::ConstTplRef(a), LuaType::ConstTplRef(b)) => a == b,
             _ => false, // 不同变体之间不相等
         }
     }
@@ -183,6 +185,7 @@ impl Hash for LuaType {
                 (44, ptr).hash(state)
             }
             LuaType::Never => 45.hash(state),
+            LuaType::ConstTplRef(a) => (46, a).hash(state),
         }
     }
 }

crates/emmylua_code_analysis/src/semantic/generic/tpl_pattern.rs

@@ -132,6 +132,11 @@ fn tpl_pattern_match(
 
     match pattern {
         LuaType::TplRef(tpl) => {
+            if tpl.get_tpl_id().is_func() {
+                substitutor.insert_type(tpl.get_tpl_id(), constant_decay(target));
+            }
+        }
+        LuaType::ConstTplRef(tpl) => {
             if tpl.get_tpl_id().is_func() {
                 substitutor.insert_type(tpl.get_tpl_id(), target);
             }
@@ -179,6 +184,16 @@ fn tpl_pattern_match(
     Ok(())
 }
 
+fn constant_decay(typ: LuaType) -> LuaType {
+    match &typ {
+        LuaType::FloatConst(_) => LuaType::Number,
+        LuaType::DocIntegerConst(_) | LuaType::IntegerConst(_) => LuaType::Integer,
+        LuaType::DocStringConst(_) | LuaType::StringConst(_) => LuaType::String,
+        LuaType::DocBooleanConst(_) | LuaType::BooleanConst(_) => LuaType::Boolean,
+        _ => typ,
+    }
+}
+
 fn object_tpl_pattern_match(
     db: &DbIndex,
     cache: &mut LuaInferCache,

crates/emmylua_code_analysis/src/semantic/type_check/mod.rs

@@ -66,6 +66,7 @@ fn check_general_type_compact(
         | LuaType::DocBooleanConst(_)
         | LuaType::TplRef(_)
         | LuaType::StrTplRef(_)
+        | LuaType::ConstTplRef(_)
         | LuaType::Namespace(_)
         | LuaType::Variadic(_) => check_simple_type_compact(db, source, compact_type, check_guard),
 

crates/emmylua_code_analysis/src/semantic/type_check/simple_type.rs

@@ -204,7 +204,7 @@ pub fn check_simple_type_compact(
                 return Ok(());
             }
         }
-        LuaType::TplRef(_) => return Ok(()),
+        LuaType::TplRef(_) | LuaType::ConstTplRef(_) => return Ok(()),
         LuaType::Namespace(source_namespace) => {
             if let LuaType::Namespace(compact_namespace) = compact_type {
                 if source_namespace == compact_namespace {