fix: unsound schema runtime check.

kclvm/compiler/src/codegen/llvm/node.rs

@@ -155,9 +155,11 @@ impl<'ctx> TypedResultWalker<'ctx> for LLVMCodeGenContext<'ctx> {
             .expect(kcl_error::COMPILE_ERROR_MSG);
         if let Some(type_annotation) = &assign_stmt.type_annotation {
             let type_annotation = self.native_global_string_value(&type_annotation.node);
+            let is_in_schema =
+                self.schema_stack.borrow().len() > 0 || self.schema_expr_stack.borrow().len() > 0;
             value = self.build_call(
                 &ApiFunc::kclvm_convert_collection_value.name(),
-                &[value, type_annotation],
+                &[value, type_annotation, self.bool_value(is_in_schema)],
             );
         }
         if assign_stmt.targets.len() == 1 {

kclvm/runtime/src/_kclvm.h

@@ -264,7 +264,7 @@ kclvm_size_t kclvm_context_symbol_num(kclvm_context_t* p);
 
 kclvm_value_t* kclvm_context_symbol_value(kclvm_context_t* p, kclvm_size_t i);
 
-kclvm_value_ref_t* kclvm_convert_collection_value(kclvm_value_ref_t* value, kclvm_char_t* tpe);
+kclvm_value_ref_t* kclvm_convert_collection_value(kclvm_value_ref_t* value, kclvm_char_t* tpe, kclvm_value_ref_t* is_in_schema);
 
 kclvm_value_ref_t* kclvm_crypto_md5(kclvm_context_t* _ctx, kclvm_value_ref_t* args, kclvm_value_ref_t* _kwargs);
 

kclvm/runtime/src/_kclvm.ll

@@ -212,7 +212,7 @@ declare %kclvm_size_t @kclvm_context_symbol_num(%kclvm_context_t* %p);
 
 declare %kclvm_value_t* @kclvm_context_symbol_value(%kclvm_context_t* %p, %kclvm_size_t %i);
 
-declare %kclvm_value_ref_t* @kclvm_convert_collection_value(%kclvm_value_ref_t* %value, %kclvm_char_t* %tpe);
+declare %kclvm_value_ref_t* @kclvm_convert_collection_value(%kclvm_value_ref_t* %value, %kclvm_char_t* %tpe, %kclvm_value_ref_t* %is_in_schema);
 
 declare %kclvm_value_ref_t* @kclvm_crypto_md5(%kclvm_context_t* %_ctx, %kclvm_value_ref_t* %args, %kclvm_value_ref_t* %_kwargs);
 

kclvm/runtime/src/_kclvm_api_spec.rs

@@ -787,8 +787,8 @@
 // api-spec(llvm): declare %kclvm_value_ref_t* @kclvm_schema_value_new(%kclvm_context_t* %ctx, %kclvm_value_ref_t* %args, %kclvm_value_ref_t* %kwargs, %kclvm_value_ref_t* %schema_value_or_func, %kclvm_value_ref_t* %config, %kclvm_value_ref_t* %config_meta, %kclvm_char_t* %pkgpath);
 
 // api-spec:       kclvm_convert_collection_value
-// api-spec(c):    kclvm_value_ref_t* kclvm_convert_collection_value(kclvm_value_ref_t* value, kclvm_char_t* tpe);
-// api-spec(llvm): declare %kclvm_value_ref_t* @kclvm_convert_collection_value(%kclvm_value_ref_t* %value, %kclvm_char_t* %tpe);
+// api-spec(c):    kclvm_value_ref_t* kclvm_convert_collection_value(kclvm_value_ref_t* value, kclvm_char_t* tpe, kclvm_value_ref_t* is_in_schema);
+// api-spec(llvm): declare %kclvm_value_ref_t* @kclvm_convert_collection_value(%kclvm_value_ref_t* %value, %kclvm_char_t* %tpe, %kclvm_value_ref_t* %is_in_schema);
 
 // api-spec:       kclvm_schema_get_value
 // api-spec(c):    kclvm_value_ref_t* kclvm_schema_get_value(kclvm_value_ref_t* p, kclvm_char_t* key, kclvm_value_ref_t* config, kclvm_value_ref_t* config_meta, kclvm_value_ref_t* cal_map, kclvm_char_t* target_attr, kclvm_value_ref_t* backtrack_level_map, kclvm_value_ref_t* backtrack_cache, kclvm_value_ref_t* args, kclvm_value_ref_t* kwargs);

kclvm/runtime/src/stdlib/builtin.rs

@@ -462,7 +462,7 @@ pub fn dict(iterable: Option<&ValueRef>) -> ValueRef {
                 let k = iter.cur_key.clone();
                 match &*k.rc.borrow() {
                     Value::str_value(str) => {
-                        result.dict_insert(str.as_str(), &elem, Default::default(), 0);
+                        result.dict_insert(str.as_str(), &elem, Default::default(), -1);
                     }
                     _ => {
                         let mut elem_iter = elem.iter();
@@ -471,7 +471,7 @@ pub fn dict(iterable: Option<&ValueRef>) -> ValueRef {
                         }
                         let k = elem_iter.next(val).unwrap().to_string();
                         let v = elem_iter.next(val).unwrap();
-                        result.dict_insert(k.as_str(), v, Default::default(), 0);
+                        result.dict_insert(k.as_str(), v, Default::default(), -1);
                     }
                 };
             }

kclvm/runtime/src/value/api.rs

@@ -1823,20 +1823,20 @@ pub unsafe extern "C" fn kclvm_value_union(
                 let mut entry = b.dict_get_entry(k).unwrap().deep_copy();
                 entry.dict_update_key_value(k, v);
                 result = a
-                    .union_entry(&entry, true, false, false, false)
+                    .union_entry(&entry, true, false, false, true)
                     .clone()
                     .into_raw();
             } else {
                 let entry = b.dict_get_entry(k).unwrap();
                 result = a
-                    .union_entry(&entry, true, false, false, false)
+                    .union_entry(&entry, true, false, false, true)
                     .clone()
                     .into_raw();
             }
         }
         result
     } else {
-        a.union_entry(b, true, false, false, false).into_raw()
+        a.union_entry(b, true, false, false, true).into_raw()
     }
 }
 
@@ -2203,7 +2203,7 @@ pub unsafe extern "C" fn kclvm_schema_value_check(
             }
         } else if !should_add_attr && is_not_in_schema {
             let schema_name = c2str(schema_name);
-            panic!("{key}: No such member in the schema '{schema_name}'");
+            panic!("No attribute named '{key}' in the schema '{schema_name}'");
         }
     }
 }
@@ -2408,10 +2408,15 @@ pub unsafe extern "C" fn kclvm_schema_value_new(
 pub unsafe extern "C" fn kclvm_convert_collection_value(
     value: *const kclvm_value_ref_t,
     tpe: *const kclvm_char_t,
+    is_in_schema: *const kclvm_value_ref_t,
 ) -> *const kclvm_value_ref_t {
     let value = ptr_as_ref(value);
     let tpe = c2str(tpe);
     let value = type_pack_and_check(value, vec![tpe]);
+    let is_in_schema = ptr_as_ref(is_in_schema);
+    if value.is_schema() && !is_in_schema.is_truthy() {
+        value.schema_check_attr_optional(true);
+    }
     value.into_raw()
 }
 

kclvm/runtime/src/value/val_json.rs

@@ -371,7 +371,7 @@ impl ValueRef {
                         name.as_ref(),
                         &Self::parse_json(value),
                         ConfigEntryOperationKind::Union,
-                        0,
+                        -1,
                     );
                 }
                 dict

kclvm/runtime/src/value/val_plan.rs

@@ -325,7 +325,7 @@ impl ValueRef {
                             key,
                             &val.filter_results(),
                             ConfigEntryOperationKind::Override,
-                            0,
+                            -1,
                         );
                     }
                 }
@@ -353,7 +353,7 @@ impl ValueRef {
                             key,
                             &val.filter_results(),
                             ConfigEntryOperationKind::Union,
-                            0,
+                            -1,
                         );
                     }
                 }

test/grammar/schema/optional_attr/fail_4/main.k

@@ -0,0 +1,4 @@
+schema Values:
+    a: int
+
+values: Values = {}

test/grammar/schema/optional_attr/fail_4/stderr.golden.py

@@ -0,0 +1,18 @@
+import sys
+import os
+
+import kclvm.kcl.error as kcl_error
+
+cwd = os.path.dirname(os.path.realpath(__file__))
+
+kcl_error.print_kcl_error_message(
+    kcl_error.get_exception(err_type=kcl_error.ErrType.EvaluationError_TYPE,
+                            file_msgs=[
+                                kcl_error.ErrFileMsg(
+                                    filename=os.path.join(cwd, "main.k"),
+                                    line_no=4,
+                                ),
+                            ],
+                            arg_msg="attribute 'a' of Version is required and can't be None or Undefined")
+    , file=sys.stdout
+)

test/grammar/schema/optional_attr/fail_5/main.k

@@ -0,0 +1,4 @@
+schema Values:
+    a: int
+
+values: Values = Values {a = 1} | {a = Undefined}

test/grammar/schema/optional_attr/fail_5/stderr.golden.py

@@ -0,0 +1,18 @@
+import sys
+import os
+
+import kclvm.kcl.error as kcl_error
+
+cwd = os.path.dirname(os.path.realpath(__file__))
+
+kcl_error.print_kcl_error_message(
+    kcl_error.get_exception(err_type=kcl_error.ErrType.EvaluationError_TYPE,
+                            file_msgs=[
+                                kcl_error.ErrFileMsg(
+                                    filename=os.path.join(cwd, "main.k"),
+                                    line_no=4,
+                                ),
+                            ],
+                            arg_msg="attribute 'a' of Version is required and can't be None or Undefined")
+    , file=sys.stdout
+)

test/grammar/schema/optional_attr/fail_6/main.k

@@ -0,0 +1,4 @@
+schema Values:
+    a: int
+
+values: Values = Values {a = 1} | {a = 2} | {a = None}

test/grammar/schema/optional_attr/fail_6/stderr.golden.py

@@ -0,0 +1,18 @@
+import sys
+import os
+
+import kclvm.kcl.error as kcl_error
+
+cwd = os.path.dirname(os.path.realpath(__file__))
+
+kcl_error.print_kcl_error_message(
+    kcl_error.get_exception(err_type=kcl_error.ErrType.EvaluationError_TYPE,
+                            file_msgs=[
+                                kcl_error.ErrFileMsg(
+                                    filename=os.path.join(cwd, "main.k"),
+                                    line_no=4,
+                                ),
+                            ],
+                            arg_msg="attribute 'a' of Version is required and can't be None or Undefined")
+    , file=sys.stdout
+)

test/grammar/schema/relaxed/fail_0/main.k

@@ -0,0 +1,17 @@
+values = {
+    res.cpu = 2
+    res.no_such_attr = 2
+}
+
+schema Config:
+    res: Res
+
+schema Res:
+    cpu: int
+
+c: Config {
+    res: values.res
+    res: Res {
+        cpu = 1
+    }
+}

test/grammar/schema/relaxed/fail_0/stderr.golden.py

@@ -0,0 +1,18 @@
+import sys
+import os
+
+import kclvm.kcl.error as kcl_error
+
+cwd = os.path.dirname(os.path.realpath(__file__))
+
+kcl_error.print_kcl_error_message(
+    kcl_error.get_exception(err_type=kcl_error.ErrType.EvaluationError_TYPE,
+                            file_msgs=[
+                                kcl_error.ErrFileMsg(
+                                    filename=os.path.join(cwd, "main.k"),
+                                    line_no=10,
+                                ),
+                            ],
+                            arg_msg="No attribute named 'no_such_attr' in the schema 'Res'")
+    , file=sys.stdout
+)

test/grammar/schema/relaxed/fail_1/main.k

@@ -0,0 +1,17 @@
+values = {
+    res.cpu = 2
+    res.no_such_attr = 2
+}
+
+schema Config:
+    res: Res
+
+schema Res:
+    cpu: int
+
+c: Config {
+    res: Res {
+        cpu = 1
+    }
+    res: values.res
+}

test/grammar/schema/relaxed/fail_1/stderr.golden.py

@@ -0,0 +1,18 @@
+import sys
+import os
+
+import kclvm.kcl.error as kcl_error
+
+cwd = os.path.dirname(os.path.realpath(__file__))
+
+kcl_error.print_kcl_error_message(
+    kcl_error.get_exception(err_type=kcl_error.ErrType.EvaluationError_TYPE,
+                            file_msgs=[
+                                kcl_error.ErrFileMsg(
+                                    filename=os.path.join(cwd, "main.k"),
+                                    line_no=10,
+                                ),
+                            ],
+                            arg_msg="No attribute named 'no_such_attr' in the schema 'Res'")
+    , file=sys.stdout
+)