Impl built-in generic Partial

Author: xuhuanzy

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

@@ -715,11 +715,17 @@ fn infer_mapped_type(
     let position = mapped_type.get_range().start();
     let id = analyzer.generic_index.find_generic(position, name)?.0;
 
-    let index_access = mapped_type.get_index_access()?;
-    let value_type = infer_index_access_type(analyzer, &index_access);
+    let doc_type = mapped_type.get_value_type()?;
+    let value_type = infer_type(analyzer, doc_type);
 
     Some(LuaType::Mapped(
-        LuaMappedType::new((id, param), value_type).into(),
+        LuaMappedType::new(
+            (id, param),
+            value_type,
+            mapped_type.is_readonly(),
+            mapped_type.is_optional(),
+        )
+        .into(),
     ))
 }
 

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

@@ -358,12 +358,12 @@ mod test {
     }
 
     #[test]
-    fn test_type_mapped_base() {
+    fn test_type_mapped_pick() {
         let mut ws = VirtualWorkspace::new();
 
         ws.def(
             r#"
-            ---@alias Pick1<T, K extends keyof T> { [P in K]: T[P]; }
+            ---@alias Pick<T, K extends keyof T> { [P in K]: T[P]; }
 
             ---@param v {name: string, age: number}
             function accept(v)
@@ -373,7 +373,30 @@ mod test {
         assert!(ws.check_code_for(
             DiagnosticCode::ParamTypeNotMatch,
             r#"
-            ---@type Pick1<{name: string, age: number, email: string}, "name" | "age">
+            ---@type Pick<{name: string, age: number, email: string}, "name" | "age">
+            local m
+            accept(m)
+            "#,
+        ));
+    }
+
+    #[test]
+    fn test_type_partial() {
+        let mut ws = VirtualWorkspace::new();
+
+        ws.def(
+            r#"
+            ---@alias Partial<T> { [P in keyof T]?: T[P]; }
+
+            ---@param v {name?: string, age?: number}
+            function accept(v)
+            end
+            "#,
+        );
+        assert!(ws.check_code_for(
+            DiagnosticCode::ParamTypeNotMatch,
+            r#"
+            ---@type Partial<{name: string, age: number}>
             local m
             accept(m)
             "#,

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

@@ -1535,13 +1535,22 @@ impl From<LuaConditionalType> for LuaType {
 pub struct LuaMappedType {
     pub param: (GenericTplId, GenericParam),
     pub value: LuaType,
+    pub is_readonly: bool,
+    pub is_optional: bool,
 }
 
 impl LuaMappedType {
-    pub fn new(param: (GenericTplId, GenericParam), value_type: LuaType) -> Self {
+    pub fn new(
+        param: (GenericTplId, GenericParam),
+        value: LuaType,
+        is_readonly: bool,
+        is_optional: bool,
+    ) -> Self {
         Self {
             param,
-            value: value_type,
+            value,
+            is_readonly,
+            is_optional,
         }
     }
 }

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

@@ -5,7 +5,7 @@ use std::{
 
 use crate::{
     DbIndex, GenericTpl, GenericTplId, LuaArrayType, LuaMemberKey, LuaSignatureId, LuaTupleStatus,
-    check_type_compact,
+    TypeOps, check_type_compact,
     db_index::{
         LuaAliasCallKind, LuaConditionalType, LuaFunctionType, LuaGenericType, LuaIntersectionType,
         LuaMappedType, LuaObjectType, LuaTupleType, LuaType, LuaUnionType, VariadicType,
@@ -738,7 +738,7 @@ fn instantiate_mapped_type(
             }
 
             let value_ty =
-                instantiate_mapped_value(db, substitutor, &mapped.value, mapped.param.0, &key_ty);
+                instantiate_mapped_value(db, substitutor, &mapped, mapped.param.0, &key_ty);
 
             if let Some(member_key) = key_type_to_member_key(&key_ty) {
                 match fields.entry(member_key) {
@@ -766,14 +766,20 @@ fn instantiate_mapped_type(
 fn instantiate_mapped_value(
     db: &DbIndex,
     substitutor: &TypeSubstitutor,
-    value: &LuaType,
+    mapped: &LuaMappedType,
     tpl_id: GenericTplId,
     replacement: &LuaType,
 ) -> LuaType {
     let mut local_substitutor = substitutor.clone();
     local_substitutor.insert_type(tpl_id, replacement.clone());
+    let mut result = instantiate_type_generic(db, &mapped.value, &local_substitutor);
+    // 根据 readonly 和 optional 属性进行处理
+    if mapped.is_optional {
+        result = TypeOps::Union.apply(db, &result, &LuaType::Nil);
+    }
+    // TODO: 处理 readonly, 但目前 readonly 的实现存在问题, 这里我们先跳过
 
-    instantiate_type_generic(db, value, &local_substitutor)
+    result
 }
 
 pub(super) fn key_type_to_member_key(key_ty: &LuaType) -> Option<LuaMemberKey> {

crates/emmylua_parser/src/syntax/node/doc/types.rs

@@ -4,6 +4,8 @@ use crate::{
     LuaTokenKind,
 };
 
+use rowan::SyntaxElement;
+
 use super::{LuaDocGenericDecl, LuaDocObjectField, LuaDocTypeList};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -835,9 +837,65 @@ impl LuaDocMappedType {
         self.child()
     }
 
-    pub fn get_index_access(&self) -> Option<LuaDocIndexAccessType> {
+    pub fn get_value_type(&self) -> Option<LuaDocType> {
         self.child()
     }
+
+    pub fn is_readonly(&self) -> bool {
+        let mut modifier: Option<bool> = None;
+
+        for element in self.syntax().children_with_tokens() {
+            match element {
+                SyntaxElement::Node(node) => {
+                    if node.kind() == LuaSyntaxKind::DocMappedKey.into() {
+                        break;
+                    }
+                }
+                SyntaxElement::Token(token) => {
+                    let kind: LuaTokenKind = token.kind().into();
+                    match kind {
+                        LuaTokenKind::TkPlus => modifier = Some(true),
+                        LuaTokenKind::TkMinus => modifier = Some(false),
+                        LuaTokenKind::TkDocReadonly => return modifier.unwrap_or(true),
+                        _ => {}
+                    }
+                }
+            }
+        }
+
+        false
+    }
+
+    pub fn is_optional(&self) -> bool {
+        let mut seen_key = false;
+        let mut modifier: Option<bool> = None;
+
+        for element in self.syntax().children_with_tokens() {
+            match element {
+                SyntaxElement::Node(node) => {
+                    if node.kind() == LuaSyntaxKind::DocMappedKey.into() {
+                        seen_key = true;
+                    }
+                }
+                SyntaxElement::Token(token) => {
+                    if !seen_key {
+                        continue;
+                    }
+
+                    let kind: LuaTokenKind = token.kind().into();
+                    match kind {
+                        LuaTokenKind::TkPlus => modifier = Some(true),
+                        LuaTokenKind::TkMinus => modifier = Some(false),
+                        LuaTokenKind::TkDocQuestion => return modifier.unwrap_or(true),
+                        LuaTokenKind::TkColon => break,
+                        _ => {}
+                    }
+                }
+            }
+        }
+
+        false
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]