Support Type Language<T: string> as param for highlight token

CppCXY · CppCXY · commit ae176b2862f5 · 2025-08-20T16:34:16.000+08:00
diff --git a/crates/emmylua_code_analysis/resources/std/builtin.lua b/crates/emmylua_code_analysis/resources/std/builtin.lua
@@ -136,3 +136,5 @@
 ---@alias metatable std.metatable
 
 ---@alias TypeGuard<T> boolean
+
+---@alias Language<T: string> string
diff --git a/crates/emmylua_code_analysis/resources/std/global.lua b/crates/emmylua_code_analysis/resources/std/global.lua
@@ -151,7 +151,7 @@ function ipairs(t) end
 ---
 --- Lua does not check the consistency of binary chunks. Maliciously crafted
 --- binary chunks can crash the interpreter.
----@param chunk (fun(...:any):string) | string
+---@param chunk (fun(...:any):string) | Language<"Lua">
 ---@param chunkname? string
 ---@param mode? std.loadmode
 ---@param env? table
@@ -166,7 +166,7 @@ function load(chunk, chunkname, mode, env) end
 ---
 ---
 ---@version 5.1, JIT
----@param text       string
+---@param text       Language<"Lua">
 ---@param chunkname? string
 ---@return function? chunk
 ---@return string?   error_message
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/doc/infer_type.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/doc/infer_type.rs
@@ -317,6 +317,13 @@ fn infer_special_generic_type(
                 return Some(LuaType::ConstTplRef(tpl));
             }
         }
+        "Language" => {
+            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::DocStringConst(lang_str) = first_param {
+                return Some(LuaType::Language(lang_str));
+            }
+        }
         _ => {}
     }
 
diff --git a/crates/emmylua_code_analysis/src/db_index/type/humanize_type.rs b/crates/emmylua_code_analysis/src/db_index/type/humanize_type.rs
@@ -103,6 +103,7 @@ pub fn humanize_type(db: &DbIndex, ty: &LuaType, level: RenderLevel) -> String {
             format!("TypeGuard<{}>", type_str)
         }
         LuaType::ConstTplRef(const_tpl) => humanize_const_tpl_ref_type(const_tpl),
+        LuaType::Language(s) => s.to_string(),
         _ => "unknown".to_string(),
     }
 }
diff --git a/crates/emmylua_code_analysis/src/db_index/type/types.rs b/crates/emmylua_code_analysis/src/db_index/type/types.rs
@@ -61,6 +61,7 @@ pub enum LuaType {
     MultiLineUnion(Arc<LuaMultiLineUnion>),
     TypeGuard(Arc<LuaType>),
     ConstTplRef(Arc<GenericTpl>),
+    Language(ArcIntern<SmolStr>),
 }
 
 impl PartialEq for LuaType {
@@ -109,6 +110,7 @@ impl PartialEq for LuaType {
             (LuaType::TypeGuard(a), LuaType::TypeGuard(b)) => a == b,
             (LuaType::Never, LuaType::Never) => true,
             (LuaType::ConstTplRef(a), LuaType::ConstTplRef(b)) => a == b,
+            (LuaType::Language(a), LuaType::Language(b)) => a == b,
             _ => false, // 不同变体之间不相等
         }
     }
@@ -186,6 +188,7 @@ impl Hash for LuaType {
             }
             LuaType::Never => 45.hash(state),
             LuaType::ConstTplRef(a) => (46, a).hash(state),
+            LuaType::Language(a) => (47, a).hash(state),
         }
     }
 }
@@ -234,7 +237,10 @@ impl LuaType {
     pub fn is_string(&self) -> bool {
         matches!(
             self,
-            LuaType::StringConst(_) | LuaType::String | LuaType::DocStringConst(_)
+            LuaType::StringConst(_)
+                | LuaType::String
+                | LuaType::DocStringConst(_)
+                | LuaType::Language(_)
         )
     }
 
diff --git a/crates/emmylua_code_analysis/src/semantic/infer/infer_index.rs b/crates/emmylua_code_analysis/src/semantic/infer/infer_index.rs
@@ -150,7 +150,11 @@ pub fn infer_member_by_member_key(
     match &prefix_type {
         LuaType::Table | LuaType::Any | LuaType::Unknown => Ok(LuaType::Any),
         LuaType::TableConst(id) => infer_table_member(db, cache, id.clone(), index_expr),
-        LuaType::String | LuaType::Io | LuaType::StringConst(_) | LuaType::DocStringConst(_) => {
+        LuaType::String
+        | LuaType::Io
+        | LuaType::StringConst(_)
+        | LuaType::DocStringConst(_)
+        | LuaType::Language(_) => {
             let decl_id =
                 get_buildin_type_map_type_id(&prefix_type).ok_or(InferFailReason::None)?;
             infer_custom_type_member(db, cache, decl_id, index_expr, infer_guard)
diff --git a/crates/emmylua_code_analysis/src/semantic/member/find_members.rs b/crates/emmylua_code_analysis/src/semantic/member/find_members.rs
@@ -65,7 +65,11 @@ fn find_members_guard(
             find_normal_members(db, member_owner, filter)
         }
         LuaType::TableGeneric(table_type) => find_table_generic_members(table_type, filter),
-        LuaType::String | LuaType::Io | LuaType::StringConst(_) => {
+        LuaType::String
+        | LuaType::Io
+        | LuaType::StringConst(_)
+        | LuaType::DocStringConst(_)
+        | LuaType::Language(_) => {
             let type_decl_id = get_buildin_type_map_type_id(&prefix_type)?;
             find_custom_type_members(db, &type_decl_id, infer_guard, filter)
         }
diff --git a/crates/emmylua_code_analysis/src/semantic/member/infer_raw_member.rs b/crates/emmylua_code_analysis/src/semantic/member/infer_raw_member.rs
@@ -30,7 +30,11 @@ fn infer_raw_member_type_guard(
             let owner = LuaMemberOwner::Element(id.clone());
             infer_owner_raw_member_type(db, owner, member_key)
         }
-        LuaType::String | LuaType::Io | LuaType::StringConst(_) | LuaType::DocStringConst(_) => {
+        LuaType::String
+        | LuaType::Io
+        | LuaType::StringConst(_)
+        | LuaType::DocStringConst(_)
+        | LuaType::Language(_) => {
             let decl_id =
                 get_buildin_type_map_type_id(&prefix_type).ok_or(InferFailReason::None)?;
             let owner = LuaMemberOwner::Type(decl_id);
diff --git a/crates/emmylua_code_analysis/src/semantic/type_check/mod.rs b/crates/emmylua_code_analysis/src/semantic/type_check/mod.rs
@@ -68,7 +68,8 @@ fn check_general_type_compact(
         | LuaType::StrTplRef(_)
         | LuaType::ConstTplRef(_)
         | LuaType::Namespace(_)
-        | LuaType::Variadic(_) => check_simple_type_compact(db, source, compact_type, check_guard),
+        | LuaType::Variadic(_)
+        | LuaType::Language(_) => check_simple_type_compact(db, source, compact_type, check_guard),
 
         // type ref
         LuaType::Ref(type_decl_id) => {
diff --git a/crates/emmylua_code_analysis/src/semantic/type_check/simple_type.rs b/crates/emmylua_code_analysis/src/semantic/type_check/simple_type.rs
@@ -70,7 +70,8 @@ pub fn check_simple_type_compact(
             LuaType::String
             | LuaType::StringConst(_)
             | LuaType::DocStringConst(_)
-            | LuaType::StrTplRef(_) => {
+            | LuaType::StrTplRef(_)
+            | LuaType::Language(_) => {
                 return Ok(());
             }
             LuaType::Ref(_) => {
@@ -215,6 +216,17 @@ pub fn check_simple_type_compact(
         LuaType::Variadic(source_type) => {
             return check_variadic_type_compact(db, source_type, compact_type, check_guard);
         }
+        LuaType::Language(lang_str) => match compact_type {
+            LuaType::Language(compact_lang_str) => {
+                if lang_str == compact_lang_str {
+                    return Ok(());
+                }
+            }
+            LuaType::DocStringConst(_) | LuaType::String | LuaType::StringConst(_) => {
+                return Ok(());
+            }
+            _ => {}
+        },
         _ => {}
     }
 
diff --git a/crates/emmylua_ls/src/handlers/semantic_token/build_semantic_tokens.rs b/crates/emmylua_ls/src/handlers/semantic_token/build_semantic_tokens.rs
@@ -1,6 +1,7 @@
 use super::{
     SEMANTIC_TOKEN_MODIFIERS, SEMANTIC_TOKEN_TYPES, semantic_token_builder::SemanticBuilder,
 };
+use crate::handlers::semantic_token::function_string_highlight::fun_string_highlight;
 use crate::util::parse_desc;
 use crate::{context::ClientId, handlers::semantic_token::language_injector::inject_language};
 use emmylua_code_analysis::{
@@ -9,9 +10,9 @@ use emmylua_code_analysis::{
     parse_require_module_info,
 };
 use emmylua_parser::{
-    LuaAst, LuaAstNode, LuaAstToken, LuaComment, LuaDocFieldKey, LuaDocObjectFieldKey, LuaExpr,
-    LuaGeneralToken, LuaKind, LuaLiteralToken, LuaNameToken, LuaSyntaxKind, LuaSyntaxNode,
-    LuaSyntaxToken, LuaTokenKind, LuaVarExpr,
+    LuaAst, LuaAstNode, LuaAstToken, LuaCallArgList, LuaCallExpr, LuaComment, LuaDocFieldKey,
+    LuaDocObjectFieldKey, LuaExpr, LuaGeneralToken, LuaKind, LuaLiteralToken, LuaNameToken,
+    LuaSyntaxKind, LuaSyntaxNode, LuaSyntaxToken, LuaTokenKind, LuaVarExpr,
 };
 use emmylua_parser_desc::{CodeBlockHighlightKind, DescItem, DescItemKind};
 use lsp_types::{SemanticToken, SemanticTokenModifier, SemanticTokenType};
@@ -61,7 +62,7 @@ fn build_tokens_semantic_token(
 ) {
     match token.kind().into() {
         LuaTokenKind::TkLongString | LuaTokenKind::TkString => {
-            if !builder.is_lang_inject_range(&token.text_range()) {
+            if !builder.is_special_string_range(&token.text_range()) {
                 builder.push(token, SemanticTokenType::STRING);
             }
         }
@@ -634,6 +635,20 @@ fn build_node_semantic_token(
 
             inject_language(builder, language_text, comment);
         }
+        LuaAst::LuaLiteralExpr(literal_expr) => {
+            let call_expr = literal_expr
+                .get_parent::<LuaCallArgList>()?
+                .get_parent::<LuaCallExpr>()?;
+            let literal_token = literal_expr.get_literal()?;
+            match literal_token {
+                LuaLiteralToken::String(string_token) => {
+                    if !builder.is_special_string_range(&string_token.get_range()) {
+                        fun_string_highlight(builder, semantic_model, call_expr, &string_token);
+                    }
+                }
+                _ => {}
+            }
+        }
         _ => {}
     }
 
diff --git a/crates/emmylua_ls/src/handlers/semantic_token/function_string_highlight.rs b/crates/emmylua_ls/src/handlers/semantic_token/function_string_highlight.rs
@@ -0,0 +1,65 @@
+use emmylua_code_analysis::{LuaType, SemanticModel};
+use emmylua_parser::{LuaAstNode, LuaAstToken, LuaCallExpr, LuaStringToken};
+use emmylua_parser_desc::CodeBlockLang;
+
+use crate::handlers::semantic_token::{
+    language_injector::process_inject_lang_string_token, semantic_token_builder::SemanticBuilder,
+};
+
+pub fn fun_string_highlight(
+    builder: &mut SemanticBuilder,
+    semantic_model: &SemanticModel,
+    call_expr: LuaCallExpr,
+    string_token: &LuaStringToken,
+) -> Option<()> {
+    let func = semantic_model.infer_call_expr_func(call_expr.clone(), None)?;
+    let params = func.get_params();
+    let mut param_idx = call_expr
+        .get_args_list()?
+        .get_args()
+        .position(|arg| arg.get_position() == string_token.get_position())?;
+
+    let colon_define = func.is_colon_define();
+    let colon_call = call_expr.is_colon_call();
+
+    match (colon_define, colon_call) {
+        (true, false) => {
+            if param_idx > 0 {
+                param_idx -= 1
+            }
+        }
+        (false, true) => {
+            param_idx += 1;
+        }
+        _ => {}
+    }
+
+    let (_, opt_typ) = params.get(param_idx)?;
+    let param_type = opt_typ.as_ref()?;
+    let lang_name = get_lang_str_from_type(param_type)?;
+    match CodeBlockLang::try_parse(&lang_name) {
+        Some(lang) => {
+            process_inject_lang_string_token(builder, lang, &string_token);
+        }
+        None => {
+            // TODO
+        }
+    }
+    Some(())
+}
+
+fn get_lang_str_from_type(typ: &LuaType) -> Option<String> {
+    match typ {
+        LuaType::Language(s) => return Some(s.to_string()),
+        LuaType::Union(u) => {
+            for sub_type in u.into_vec() {
+                if let LuaType::Language(s) = sub_type {
+                    return Some(s.to_string());
+                }
+            }
+        }
+        _ => {}
+    }
+
+    None
+}
diff --git a/crates/emmylua_ls/src/handlers/semantic_token/language_injector.rs b/crates/emmylua_ls/src/handlers/semantic_token/language_injector.rs
@@ -20,58 +20,68 @@ pub fn inject_language(
     let lang = CodeBlockLang::try_parse(lang_name)?;
     for literal in owner.descendants::<LuaLiteralExpr>() {
         if let Some(LuaLiteralToken::String(str_token)) = literal.get_literal() {
-            let code_block_info = divide_into_quote_and_code_block(&str_token)?;
-            let code_block_range = code_block_info.code_block;
-            let code_block_source = SourceRange::from_start_end(
-                u32::from(code_block_range.start()) as usize,
-                u32::from(code_block_range.end()) as usize,
-            );
-            let code_block_str = str_token.slice(code_block_range)?;
-            let reader = Reader::new(code_block_str);
-            let mut result = InjectResult::new();
-            process_code(
-                &mut result,
-                code_block_source,
-                reader,
-                LexerState::Normal,
-                lang,
-            );
+            process_inject_lang_string_token(builder, lang, &str_token);
+        }
+    }
 
-            for desc_item in result.results() {
-                if let DescItemKind::CodeBlockHl(highlight_kind) = desc_item.kind {
-                    let token_type = match highlight_kind {
-                        CodeBlockHighlightKind::Keyword => SemanticTokenType::KEYWORD,
-                        CodeBlockHighlightKind::String => SemanticTokenType::STRING,
-                        CodeBlockHighlightKind::Number => SemanticTokenType::NUMBER,
-                        CodeBlockHighlightKind::Comment => SemanticTokenType::COMMENT,
-                        CodeBlockHighlightKind::Function => SemanticTokenType::FUNCTION,
-                        CodeBlockHighlightKind::Class => SemanticTokenType::CLASS,
-                        CodeBlockHighlightKind::Enum => SemanticTokenType::ENUM,
-                        CodeBlockHighlightKind::Variable => SemanticTokenType::VARIABLE,
-                        CodeBlockHighlightKind::Property => SemanticTokenType::PROPERTY,
-                        CodeBlockHighlightKind::Decorator => SemanticTokenType::DECORATOR,
-                        CodeBlockHighlightKind::Operators => SemanticTokenType::OPERATOR,
-                        _ => continue, // Fallback for other kinds
-                    };
-
-                    let sub_token_range = TextRange::new(
-                        desc_item.range.start() + code_block_range.start(),
-                        desc_item.range.end() + code_block_range.start(),
-                    );
-                    if let Some(token_text) = str_token.slice(sub_token_range) {
-                        builder.push_at_range(token_text, sub_token_range, token_type, &[]);
-                    }
-                }
-            }
+    Some(())
+}
 
-            for quote_range in code_block_info.quote_ranges {
-                let len = u32::from(quote_range.end() - quote_range.start());
-                builder.push_at_position(quote_range.start(), len, SemanticTokenType::STRING, None);
+pub fn process_inject_lang_string_token(
+    builder: &mut SemanticBuilder,
+    lang: CodeBlockLang,
+    str_token: &LuaStringToken,
+) -> Option<()> {
+    let code_block_info = divide_into_quote_and_code_block(&str_token)?;
+    let code_block_range = code_block_info.code_block;
+    let code_block_source = SourceRange::from_start_end(
+        u32::from(code_block_range.start()) as usize,
+        u32::from(code_block_range.end()) as usize,
+    );
+    let code_block_str = str_token.slice(code_block_range)?;
+    let reader = Reader::new(code_block_str);
+    let mut result = InjectResult::new();
+    process_code(
+        &mut result,
+        code_block_source,
+        reader,
+        LexerState::Normal,
+        lang,
+    );
+
+    for desc_item in result.results() {
+        if let DescItemKind::CodeBlockHl(highlight_kind) = desc_item.kind {
+            let token_type = match highlight_kind {
+                CodeBlockHighlightKind::Keyword => SemanticTokenType::KEYWORD,
+                CodeBlockHighlightKind::String => SemanticTokenType::STRING,
+                CodeBlockHighlightKind::Number => SemanticTokenType::NUMBER,
+                CodeBlockHighlightKind::Comment => SemanticTokenType::COMMENT,
+                CodeBlockHighlightKind::Function => SemanticTokenType::FUNCTION,
+                CodeBlockHighlightKind::Class => SemanticTokenType::CLASS,
+                CodeBlockHighlightKind::Enum => SemanticTokenType::ENUM,
+                CodeBlockHighlightKind::Variable => SemanticTokenType::VARIABLE,
+                CodeBlockHighlightKind::Property => SemanticTokenType::PROPERTY,
+                CodeBlockHighlightKind::Decorator => SemanticTokenType::DECORATOR,
+                CodeBlockHighlightKind::Operators => SemanticTokenType::OPERATOR,
+                _ => continue, // Fallback for other kinds
+            };
+
+            let sub_token_range = TextRange::new(
+                desc_item.range.start() + code_block_range.start(),
+                desc_item.range.end() + code_block_range.start(),
+            );
+            if let Some(token_text) = str_token.slice(sub_token_range) {
+                builder.push_at_range(token_text, sub_token_range, token_type, &[]);
             }
-            builder.add_lang_inject_range(str_token.get_range());
         }
     }
 
+    for quote_range in code_block_info.quote_ranges {
+        let len = u32::from(quote_range.end() - quote_range.start());
+        builder.push_at_position(quote_range.start(), len, SemanticTokenType::STRING, None);
+    }
+    builder.add_special_string_range(str_token.get_range());
+
     Some(())
 }
 
diff --git a/crates/emmylua_ls/src/handlers/semantic_token/mod.rs b/crates/emmylua_ls/src/handlers/semantic_token/mod.rs
@@ -1,4 +1,5 @@
 mod build_semantic_tokens;
+mod function_string_highlight;
 mod language_injector;
 mod semantic_token_builder;
 
diff --git a/crates/emmylua_ls/src/handlers/semantic_token/semantic_token_builder.rs b/crates/emmylua_ls/src/handlers/semantic_token/semantic_token_builder.rs

Original file line number	Diff line number	Diff line change
`@@ -317,6 +317,13 @@ fn infer_special_generic_type(`
`317`	`317`	`return Some(LuaType::ConstTplRef(tpl));`
`318`	`318`	`}`
`319`	`319`	`}`
	`320`	`+ "Language" => {`
	`321`	`+ let first_doc_param_type = generic_type.get_generic_types()?.get_types().next()?;`
	`322`	`+ let first_param = infer_type(analyzer, first_doc_param_type);`
	`323`	`+ if let LuaType::DocStringConst(lang_str) = first_param {`
	`324`	`+ return Some(LuaType::Language(lang_str));`
	`325`	`+ }`
	`326`	`+ }`
`320`	`327`	`_ => {}`
`321`	`328`	`}`
`322`	`329`
Original file line number	Diff line number	Diff line change
`@@ -103,6 +103,7 @@ pub fn humanize_type(db: &DbIndex, ty: &LuaType, level: RenderLevel) -> String {`
`103`	`103`	`format!("TypeGuard<{}>", type_str)`
`104`	`104`	`}`
`105`	`105`	`LuaType::ConstTplRef(const_tpl) => humanize_const_tpl_ref_type(const_tpl),`
	`106`	`+ LuaType::Language(s) => s.to_string(),`
`106`	`107`	`_ => "unknown".to_string(),`
`107`	`108`	`}`
`108`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,6 +61,7 @@ pub enum LuaType {`
`61`	`61`	`MultiLineUnion(Arc<LuaMultiLineUnion>),`
`62`	`62`	`TypeGuard(Arc<LuaType>),`
`63`	`63`	`ConstTplRef(Arc<GenericTpl>),`
	`64`	`+ Language(ArcIntern<SmolStr>),`
`64`	`65`	`}`
`65`	`66`
`66`	`67`	`impl PartialEq for LuaType {`
`@@ -109,6 +110,7 @@ impl PartialEq for LuaType {`
`109`	`110`	`(LuaType::TypeGuard(a), LuaType::TypeGuard(b)) => a == b,`
`110`	`111`	`(LuaType::Never, LuaType::Never) => true,`
`111`	`112`	`(LuaType::ConstTplRef(a), LuaType::ConstTplRef(b)) => a == b,`
	`113`	`+ (LuaType::Language(a), LuaType::Language(b)) => a == b,`
`112`	`114`	`_ => false, // 不同变体之间不相等`
`113`	`115`	`}`
`114`	`116`	`}`
`@@ -186,6 +188,7 @@ impl Hash for LuaType {`
`186`	`188`	`}`
`187`	`189`	`LuaType::Never => 45.hash(state),`
`188`	`190`	`LuaType::ConstTplRef(a) => (46, a).hash(state),`
	`191`	`+ LuaType::Language(a) => (47, a).hash(state),`
`189`	`192`	`}`
`190`	`193`	`}`
`191`	`194`	`}`
`@@ -234,7 +237,10 @@ impl LuaType {`
`234`	`237`	`pub fn is_string(&self) -> bool {`
`235`	`238`	`matches!(`
`236`	`239`	`self,`
`237`		`- LuaType::StringConst(_) \| LuaType::String \| LuaType::DocStringConst(_)`
	`240`	`+ LuaType::StringConst(_)`
	`241`	`+ \| LuaType::String`
	`242`	`+ \| LuaType::DocStringConst(_)`
	`243`	`+ \| LuaType::Language(_)`
`238`	`244`	`)`
`239`	`245`	`}`
`240`	`246`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,11 @@ fn find_members_guard(`
`65`	`65`	`find_normal_members(db, member_owner, filter)`
`66`	`66`	`}`
`67`	`67`	`LuaType::TableGeneric(table_type) => find_table_generic_members(table_type, filter),`
`68`		`- LuaType::String \| LuaType::Io \| LuaType::StringConst(_) => {`
	`68`	`+ LuaType::String`
	`69`	`+ \| LuaType::Io`
	`70`	`+ \| LuaType::StringConst(_)`
	`71`	`+ \| LuaType::DocStringConst(_)`
	`72`	`+ \| LuaType::Language(_) => {`
`69`	`73`	`let type_decl_id = get_buildin_type_map_type_id(&prefix_type)?;`
`70`	`74`	`find_custom_type_members(db, &type_decl_id, infer_guard, filter)`
`71`	`75`	`}`