Support @schema url

Cargo.toml

@@ -11,6 +11,7 @@ emmylua_code_analysis = { path = "crates/emmylua_code_analysis", version = "0.20
 emmylua_parser = { path = "crates/emmylua_parser", version = "0.23.0" }
 emmylua_parser_desc = { path = "crates/emmylua_parser_desc", version = "0.23.0" }
 emmylua_diagnostic_macro = { path = "crates/emmylua_diagnostic_macro", version = "0.5.0" }
+schema_to_emmylua = { path = "crates/schema_to_emmylua", version = "0.1.0" }
 
 # external
 lsp-server = "0.7.9"
@@ -54,6 +55,7 @@ mimalloc = { version = "0.1.48", features = ["v3"] }
 googletest = "0.14.2"
 unicode-general-category = "1.0.0"
 luars = { version = "0.1.0", features = ["serde"] }
+reqwest = "0.13.1"
 
 # Lint configuration for the entire workspace
 [workspace.lints.clippy]

crates/emmylua_code_analysis/Cargo.toml

@@ -50,6 +50,8 @@ include_dir.workspace = true
 emmylua_codestyle.workspace = true
 itertools.workspace = true
 luars.workspace = true
+reqwest.workspace = true
+schema_to_emmylua.workspace = true
 
 [package.metadata.i18n]
 available-locales = ["en", "zh_CN", "zh_HK"]

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

@@ -469,8 +469,8 @@ pub fn analyze_doc_tag_schema(analyzer: &mut DocAnalyzer, tag: LuaDocTagSchema)
 
     let schema_index = analyzer.db.get_json_schema_index_mut();
     if let Some(schema_file) = schema_index.get_schema_file(&url) {
-        if let JsonSchemaFile::Resolved(file_id) = schema_file {
-            let types = vec![LuaType::ModuleRef(*file_id)];
+        if let JsonSchemaFile::Resolved(type_id) = schema_file {
+            let types = vec![LuaType::Ref(type_id.clone())];
             bind_type_to_owner(analyzer, &tag, &types, None);
         }
     } else {

crates/emmylua_code_analysis/src/db_index/schema/mod.rs

@@ -49,6 +49,14 @@ impl JsonSchemaIndex {
             })
             .collect()
     }
+
+    pub fn reset_rest_schemas(&mut self) {
+        for schema_file in self.schema_files.values_mut() {
+            if let JsonSchemaFile::NeedResolve = schema_file {
+                *schema_file = JsonSchemaFile::BadUrl;
+            }
+        }
+    }
 }
 
 impl LuaIndex for JsonSchemaIndex {

crates/emmylua_code_analysis/src/db_index/schema/schema_file.rs

@@ -1,7 +1,38 @@
-use crate::FileId;
+use url::Url;
+
+use crate::LuaTypeDeclId;
 
 #[derive(Debug, Clone)]
 pub enum JsonSchemaFile {
     NeedResolve,
-    Resolved(FileId),
+    BadUrl,
+    Resolved(LuaTypeDeclId),
+}
+
+pub fn get_schema_short_name(url: &Url) -> String {
+    const MAX_LEN: usize = 64;
+
+    let url_str = url.as_str();
+    let mut new_name = String::new();
+    for c in url_str.chars().rev() {
+        if new_name.len() >= MAX_LEN {
+            break;
+        }
+
+        if c.is_alphanumeric() || c == '-' || c == '_' || c == '.' {
+            new_name.push(c);
+        } else if !c.is_control() && c != ' ' {
+            new_name.push('_');
+        }
+    }
+
+    let mut result: String = new_name.chars().rev().collect();
+
+    result = result.trim_matches(|c| c == '_' || c == '.').to_string();
+
+    if result.is_empty() {
+        return "schema".to_string();
+    }
+
+    result
 }

crates/emmylua_code_analysis/src/lib.rs

@@ -30,7 +30,9 @@ pub use profile::Profile;
 pub use resources::get_best_resources_dir;
 pub use resources::load_resource_from_include_dir;
 use resources::load_resource_std;
+use schema_to_emmylua::SchemaConverter;
 pub use semantic::*;
+use std::collections::HashMap;
 use std::{collections::HashSet, path::PathBuf, sync::Arc};
 pub use test_lib::VirtualWorkspace;
 use tokio_util::sync::CancellationToken;
@@ -260,6 +262,86 @@ impl EmmyLuaAnalysis {
             self.remove_file_by_uri(&uri);
         }
     }
+
+    pub fn check_schema_update(&self) -> bool {
+        self.compilation
+            .get_db()
+            .get_json_schema_index()
+            .has_need_resolve_schemas()
+    }
+
+    pub async fn update_schema(&mut self) {
+        let urls = self
+            .compilation
+            .get_db()
+            .get_json_schema_index()
+            .get_need_resolve_schemas();
+        let mut url_contents = HashMap::new();
+        for url in urls {
+            if url.scheme() == "file" {
+                if let Ok(path) = url.to_file_path() {
+                    if path.exists() {
+                        let result = read_file_with_encoding(&path, "utf-8");
+                        if let Some(content) = result {
+                            url_contents.insert(url.clone(), content);
+                        } else {
+                            log::error!("Failed to read schema file: {:?}", url);
+                        }
+                    }
+                }
+            } else {
+                let result = reqwest::get(url.as_str()).await;
+                if let Ok(response) = result {
+                    if let Ok(content) = response.text().await {
+                        url_contents.insert(url.clone(), content);
+                    } else {
+                        log::error!("Failed to read schema content from URL: {:?}", url);
+                    }
+                } else {
+                    log::error!("Failed to fetch schema from URL: {:?}", url);
+                }
+            }
+        }
+
+        if url_contents.is_empty() {
+            return;
+        }
+
+        let work_dir = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+        let converter = SchemaConverter::new(true);
+        for (url, json_content) in url_contents {
+            let short_name = get_schema_short_name(&url);
+            match converter.convert_from_str(&json_content) {
+                Ok(convert_result) => {
+                    let path = work_dir.join(short_name);
+                    let Some(file_id) =
+                        self.update_file_by_path(&path, Some(convert_result.annotation_text))
+                    else {
+                        continue;
+                    };
+                    if let Some(f) = self
+                        .compilation
+                        .get_db_mut()
+                        .get_json_schema_index_mut()
+                        .get_schema_file_mut(&url)
+                    {
+                        *f = JsonSchemaFile::Resolved(LuaTypeDeclId::local(
+                            file_id,
+                            &convert_result.root_type_name,
+                        ));
+                    }
+                }
+                Err(e) => {
+                    log::error!("Failed to convert schema from URL {:?}: {}", url, e);
+                }
+            }
+        }
+
+        self.compilation
+            .get_db_mut()
+            .get_json_schema_index_mut()
+            .reset_rest_schemas();
+    }
 }
 
 impl Default for EmmyLuaAnalysis {

crates/emmylua_code_analysis/src/semantic/infer/infer_index/mod.rs

@@ -568,6 +568,10 @@ fn infer_union_member(
         }
     }
 
+    if member_types.iter().all(|t| t.is_nil()) {
+        return Err(InferFailReason::FieldNotFound);
+    }
+
     Ok(LuaType::from_vec(member_types))
 }
 

crates/emmylua_code_analysis/src/semantic/infer/infer_table.rs

@@ -185,7 +185,6 @@ pub fn infer_table_field_value_should_be(
         .get_parent::<LuaTableExpr>()
         .ok_or(InferFailReason::None)?;
     let parent_table_expr_type = infer_table_should_be(db, cache, parnet_table_expr)?;
-
     let index = LuaIndexMemberExpr::TableField(table_field.clone());
     let reason = match infer_member_by_member_key(
         db,
@@ -294,18 +293,20 @@ fn infer_table_field_type_by_parent(
 ) -> InferResult {
     let member_id = LuaMemberId::new(field.get_syntax_id(), cache.get_file_id());
     if let Some(type_cache) = db.get_type_index().get_type_cache(&member_id.into()) {
-        let typ = type_cache.as_type();
-        match typ {
-            LuaType::TableConst(_) => {}
-            LuaType::Tuple(tuple) => {
-                let types = tuple.get_types();
-                // 这种情况下缓存的类型可能是不精确的
-                if tuple.is_infer_resolve() && types.len() == 1 && types[0].is_unknown() {
-                } else {
-                    return Ok(typ.clone());
+        if type_cache.is_doc() {
+            let typ = type_cache.as_type();
+            match typ {
+                LuaType::TableConst(_) => {}
+                LuaType::Tuple(tuple) => {
+                    let types = tuple.get_types();
+                    // 这种情况下缓存的类型可能是不精确的
+                    if tuple.is_infer_resolve() && types.len() == 1 && types[0].is_unknown() {
+                    } else {
+                        return Ok(typ.clone());
+                    }
                 }
+                typ => return Ok(typ.clone()),
             }
-            typ => return Ok(typ.clone()),
         }
     } else if field.is_value_field() {
         return infer_table_field_value_should_be(db, cache, field);

crates/emmylua_ls/src/context/workspace_manager.rs

@@ -261,6 +261,15 @@ impl WorkspaceManager {
 
         is_workspace_file
     }
+
+    pub async fn check_schema_update(&self) {
+        let read_analysis = self.analysis.read().await;
+        if read_analysis.check_schema_update() {
+            drop(read_analysis);
+            let mut write_analysis = self.analysis.write().await;
+            write_analysis.update_schema().await;
+        }
+    }
 }
 
 pub fn load_emmy_config(config_root: Option<PathBuf>, client_config: ClientConfig) -> Arc<Emmyrc> {

crates/emmylua_ls/src/handlers/completion/providers/equality_provider.rs

@@ -21,6 +21,7 @@ pub fn add_completion(builder: &mut CompletionBuilder) -> Option<()> {
     for typ in &types {
         dispatch_type(builder, typ.clone(), &InferGuard::new());
     }
+
     if !types.is_empty() && !builder.is_invoked() {
         builder.stop_here();
     }
@@ -124,6 +125,10 @@ fn get_token_should_type(builder: &mut CompletionBuilder) -> Option<Vec<LuaType>
             }
         }
         LuaAst::LuaTableField(table_field) => {
+            if table_field.is_value_field() {
+                return None;
+            }
+
             let typ = infer_table_field_value_should_be(
                 builder.semantic_model.get_db(),
                 &mut builder.semantic_model.get_cache().borrow_mut(),

crates/emmylua_ls/src/handlers/completion/providers/table_field_provider.rs

@@ -1,6 +1,9 @@
 use std::collections::HashSet;
 
-use emmylua_code_analysis::{InferGuard, LuaMemberInfo, LuaMemberKey, LuaType, get_real_type};
+use emmylua_code_analysis::{
+    InferGuard, LuaMemberInfo, LuaMemberKey, LuaType, get_real_type,
+    infer_table_field_value_should_be,
+};
 use emmylua_parser::{LuaAst, LuaAstNode, LuaKind, LuaTableExpr, LuaTableField, LuaTokenKind};
 use lsp_types::{CompletionItem, InsertTextFormat, InsertTextMode};
 use rowan::NodeOrToken;
@@ -210,29 +213,45 @@ fn add_table_field_value_completion(builder: &mut CompletionBuilder) -> Option<(
         return None;
     }
     // 仅在 value 为空的时候触发
-    let parent = builder.trigger_token.prev_token()?.parent()?;
-    let node = LuaAst::cast(parent)?;
-    match node {
-        LuaAst::LuaTableField(field) => {
-            let table_expr = field.get_parent::<LuaTableExpr>()?;
-            let table_type = builder
-                .semantic_model
-                .infer_table_should_be(table_expr.clone())?;
-            let key = builder
-                .semantic_model
-                .get_member_key(&field.get_field_key()?)?;
-            let member_infos = builder.semantic_model.get_member_infos(&table_type)?;
-            let member_info = member_infos.iter().find(|m| m.key == key)?;
+    let mut parent = if builder.trigger_token.kind() == LuaTokenKind::TkWhitespace.into() {
+        builder.trigger_token.prev_token()?.parent()?
+    } else {
+        builder.trigger_token.parent()?
+    };
+    for _ in 0..3 {
+        match LuaAst::cast(parent.clone())? {
+            LuaAst::LuaTableField(field) => {
+                if field.is_assign_field() {
+                    let table_expr = field.get_parent::<LuaTableExpr>()?;
+                    let table_type = builder
+                        .semantic_model
+                        .infer_table_should_be(table_expr.clone())?;
+                    let key = builder
+                        .semantic_model
+                        .get_member_key(&field.get_field_key()?)?;
+                    let member_infos = builder.semantic_model.get_member_infos(&table_type)?;
+                    let member_info = member_infos.iter().find(|m| m.key == key)?;
 
-            if add_field_value_completion(builder, member_info.clone()).is_some() {
-                // 如果添加了补全项, 则停止
-                builder.stop_here();
+                    if add_field_value_completion(builder, member_info.clone()).is_some() {
+                        // 如果添加了补全项, 则停止
+                        builder.stop_here();
+                    }
+                } else {
+                    let table_field_should = infer_table_field_value_should_be(
+                        builder.semantic_model.get_db(),
+                        &mut builder.semantic_model.get_cache().borrow_mut(),
+                        field,
+                    )
+                    .ok()?;
+                    dispatch_type(builder, table_field_should, &InferGuard::new())?;
+                }
+                return Some(());
             }
-
-            Some(())
+            _ => parent = parent.parent()?,
         }
-        _ => None,
     }
+
+    Some(())
 }
 
 fn add_field_value_completion(

crates/emmylua_ls/src/handlers/initialized/mod.rs

@@ -201,6 +201,10 @@ pub async fn init_analysis(
         Some("Indexing complete".to_string()),
     );
 
+    if mut_analysis.check_schema_update() {
+        mut_analysis.update_schema().await;
+    }
+
     drop(mut_analysis);
 
     if !lsp_features.supports_workspace_diagnostic() {

crates/emmylua_ls/src/handlers/text_document/text_document_handler.rs

@@ -74,6 +74,7 @@ pub async fn on_did_save_text_document(
                 .await;
             let workspace_manager = context.workspace_manager().write().await;
             workspace_manager.update_workspace_version(WorkspaceDiagnosticLevel::Slow, true);
+            workspace_manager.check_schema_update().await;
         }
 
         return Some(());
@@ -88,6 +89,7 @@ pub async fn on_did_save_text_document(
     workspace
         .reindex_workspace(Duration::from_millis(duration))
         .await;
+    workspace.check_schema_update().await;
     Some(())
 }
 

crates/schema_to_emmylua/src/converter.rs

@@ -64,10 +64,10 @@ impl SchemaConverter {
             emitter.blank_line();
         }
 
-        let mut root_type_name = None;
+        let mut root_type_name = "schema.root".to_string();
         // Emit the root schema as a class
         if let Some(title) = walker.root_title() {
-            root_type_name = Some(format!("{}{}", self.type_prefix, title));
+            root_type_name = format!("{}{}", self.type_prefix, title);
             let root = walker.root_schema();
             if root.get("properties").is_some() {
                 let prefixed = format!("{}{}", self.type_prefix, title);

crates/schema_to_emmylua/src/lib.rs

@@ -7,5 +7,5 @@ pub use converter::SchemaConverter;
 
 pub struct ConvertResult {
     pub annotation_text: String,
-    pub root_type_name: Option<String>,
+    pub root_type_name: String,
 }