add missing required attribute in schema

Signed-off-by: Lior Franko <liorfr@monday.com>

Author: liorfr-monday

kclvm/tools/src/LSP/src/compile.rs

@@ -18,6 +18,7 @@ use std::collections::HashSet;
 use std::path::PathBuf;
 
 use crate::{
+    validator::validate_schema_attributes,
     state::{KCLGlobalStateCache, KCLVfs},
     util::load_files_code_from_vfs,
 };
@@ -126,7 +127,15 @@ pub fn compile(
         params.scope_cache.clone(),
     );
     let schema_map: IndexMap<String, Vec<SchemaType>> = filter_pkg_schemas(&prog_scope, None, None);
-    diags.extend(prog_scope.handler.diagnostics);
+    
+    // Clone diagnostics before moving prog_scope
+    let mut all_diags = IndexSet::new();
+    all_diags.extend(prog_scope.handler.diagnostics.clone());
+    
+    // Add schema validation
+    if let Err(validation_diags) = validate_schema_attributes(&program, &prog_scope) {
+        all_diags.extend(validation_diags);
+    }
 
     let mut default = GlobalState::default();
     let mut gs_ref;
@@ -158,8 +167,8 @@ pub fn compile(
     Namer::find_symbols(&program, gs);
 
     match AdvancedResolver::resolve_program(&program, gs, prog_scope.node_ty_map) {
-        Ok(_) => (diags, Ok((program, schema_map, gs.clone()))),
-        Err(e) => (diags, Err(anyhow::anyhow!("Resolve failed: {:?}", e))),
+        Ok(_) => (all_diags, Ok((program, schema_map, gs.clone()))),
+        Err(e) => (all_diags, Err(anyhow::anyhow!("Resolve failed: {:?}", e))),
     }
 }
 

kclvm/tools/src/LSP/src/lib.rs

@@ -25,3 +25,4 @@ mod tests;
 pub mod to_lsp;
 mod util;
 mod word_index;
+mod validator;

kclvm/tools/src/LSP/src/main.rs

@@ -21,7 +21,7 @@ mod state;
 mod to_lsp;
 mod util;
 mod word_index;
-
+mod validator;
 #[cfg(test)]
 mod tests;
 

kclvm/tools/src/LSP/src/test_data/schema_validation/validator_test.k

@@ -0,0 +1,34 @@
+# This file contains test cases for schema validation
+# Each instance below tests different validation scenarios
+
+schema Person:
+    name: str  # required
+    age: int   # required
+    address?: str  # optional
+
+# Test case 1: Valid instance - all required attributes present
+person1 = Person {
+    name: "John"
+    age: 30
+    address: "123 Main St"
+}
+
+# Test case 2: Invalid instance - missing required 'age' attribute
+# Expected error: Missing required attributes in Person instance: age
+# Expected error line: 20
+person2 = Person {
+    name: "Jane"
+}
+
+# Test case 3: Invalid instance - missing required 'name' attribute
+# Expected error: Missing required attributes in Person instance: name
+# Expected error line: 26
+person3 = Person {
+    age: 25
+}
+
+# Test case 4: Valid instance - optional attribute omitted
+person4 = Person {
+    name: "Bob"
+    age: 40
+} 

kclvm/tools/src/LSP/src/validator.rs

@@ -0,0 +1,108 @@
+use kclvm_ast::ast::{Program, Node, Stmt, AssignStmt, Expr};
+use kclvm_error::{Diagnostic, Level};
+use kclvm_error::diagnostic::Position;
+use kclvm_sema::resolver::scope::ProgramScope;
+use std::collections::HashMap;
+
+pub fn validate_schema_attributes(program: &Program, _scope: &ProgramScope) -> Result<(), Vec<Diagnostic>> {
+    let mut diagnostics = Vec::new();
+
+    // Process schemas and validate instances in a single pass
+    for (_, modules) in &program.pkgs {
+        for module_path in modules {
+            if let Ok(Some(module)) = program.get_module(module_path) {
+                let mut schema_attrs = HashMap::new();
+                
+                for stmt in &module.body {
+                    match &**stmt {
+                        Node { node: Stmt::Schema(schema), .. } => {
+                            let mut required_attrs = Vec::new();
+                            for attr in &schema.body {
+                                if let Node { node: Stmt::SchemaAttr(attr_stmt), .. } = &**attr {
+                                    if !attr_stmt.is_optional && attr_stmt.value.is_none() {
+                                        required_attrs.push(attr_stmt.name.node.clone());
+                                    }
+                                }
+                            }
+                            schema_attrs.insert(schema.name.node.clone(), required_attrs);
+                        },
+                        Node { node: Stmt::Assign(assign_stmt), filename, line, column, .. } => {
+                            if let Some(schema_name) = get_schema_name(assign_stmt) {
+                                if let Some(required_attrs) = schema_attrs.get(&schema_name) {
+                                    let missing_attrs = get_missing_attrs(assign_stmt, required_attrs);
+                                    if !missing_attrs.is_empty() {
+                                        diagnostics.push(Diagnostic::new(
+                                            Level::Error,
+                                            &format!(
+                                                "Missing required attributes in {} instance: {}",
+                                                schema_name,
+                                                missing_attrs.join(", ")
+                                            ),
+                                            (
+                                                Position {
+                                                    filename: filename.clone(),
+                                                    line: *line,
+                                                    column: Some(*column),
+                                                },
+                                                Position {
+                                                    filename: filename.clone(),
+                                                    line: *line,
+                                                    column: Some(*column + schema_name.len() as u64),
+                                                }
+                                            ),
+                                        ));
+                                    }
+                                }
+                            }
+                        },
+                        _ => {}
+                    }
+                }
+            }
+        }
+    }
+
+    if diagnostics.is_empty() {
+        Ok(())
+    } else {
+        Err(diagnostics)
+    }
+}
+
+fn get_schema_name(assign_stmt: &AssignStmt) -> Option<String> {
+    if let Node { node: Expr::Schema(schema_expr), .. } = &*assign_stmt.value {
+        schema_expr.name.node.names.last().map(|n| n.node.clone())
+    } else {
+        None
+    }
+}
+
+fn get_missing_attrs(assign_stmt: &AssignStmt, required_attrs: &[String]) -> Vec<String> {
+    if let Node { node: Expr::Schema(schema_expr), .. } = &*assign_stmt.value {
+        if let Node { node: Expr::Config(config_expr), .. } = &*schema_expr.config {
+            let provided_attrs: Vec<String> = config_expr
+                .items
+                .iter()
+                .filter_map(|item| {
+                    item.node.key.as_ref().and_then(|key| {
+                        if let Node { node: Expr::Identifier(ident), .. } = &**key {
+                            ident.names.last().map(|n| n.node.clone())
+                        } else {
+                            None
+                        }
+                    })
+                })
+                .collect();
+            
+            required_attrs
+                .iter()
+                .filter(|attr| !provided_attrs.contains(attr))
+                .cloned()
+                .collect()
+        } else {
+            required_attrs.to_vec()
+        }
+    } else {
+        Vec::new()
+    }
+}