fix: schema dup instances (#2036)

Signed-off-by: Peefy <xpf6677@163.com>

Author: Peefy

crates/evaluator/src/schema.rs

@@ -38,6 +38,10 @@ pub struct SchemaEvalContext {
     pub config_meta: ValueRef,
     pub optional_mapping: ValueRef,
     pub is_sub_schema: bool,
+    /// Whether the schema body has been fully evaluated.
+    /// This flag is used to avoid redundant calculations during
+    /// schema attribute assignments.
+    pub body_evaluated: bool,
 }
 
 impl SchemaEvalContext {
@@ -59,6 +63,7 @@ impl SchemaEvalContext {
             config_meta: ValueRef::dict(None),
             optional_mapping: ValueRef::dict(None),
             is_sub_schema: true,
+            body_evaluated: false,
         }
     }
 
@@ -76,6 +81,7 @@ impl SchemaEvalContext {
             config_meta,
             optional_mapping: ValueRef::dict(None),
             is_sub_schema: true,
+            body_evaluated: false,
         }))
     }
 
@@ -93,6 +99,7 @@ impl SchemaEvalContext {
             config_meta: ValueRef::dict(None),
             optional_mapping: ValueRef::dict(None),
             is_sub_schema: true,
+            body_evaluated: false,
         }))
     }
 
@@ -505,6 +512,8 @@ pub(crate) fn schema_body(
         for stmt in &node.body {
             s.walk_stmt(stmt).expect(kcl_error::RUNTIME_ERROR_MSG);
         }
+        // Mark schema body as evaluated to avoid redundant calculations
+        ctx.borrow_mut().body_evaluated = true;
         // Schema decorators check
         for decorator in &node.decorators {
             s.walk_decorator_with_name(&decorator.node, Some(&schema_name), true)
@@ -704,20 +713,30 @@ pub(crate) fn schema_with_config(
     }
 
     {
-        let mut ctx = s.runtime_ctx.borrow_mut();
+        let mut runtime_ctx = s.runtime_ctx.borrow_mut();
         // Record schema instance in the context
-        if !ctx.instances.contains_key(&runtime_type) {
-            ctx.instances
+        if !runtime_ctx.instances.contains_key(&runtime_type) {
+            runtime_ctx
+                .instances
                 .insert(runtime_type.clone(), IndexMap::default());
         }
-        let pkg_instance_map = ctx.instances.get_mut(&runtime_type).unwrap();
+        let pkg_instance_map = runtime_ctx.instances.get_mut(&runtime_type).unwrap();
         if !pkg_instance_map.contains_key(&instance_pkgpath) {
             pkg_instance_map.insert(instance_pkgpath.clone(), vec![]);
         }
-        pkg_instance_map
-            .get_mut(&instance_pkgpath)
-            .unwrap()
-            .push(schema_ctx_value.clone());
+        // Only record the instance once after the schema body is fully evaluated
+        // to avoid recording intermediate states during mixin/parent processing
+        let should_record = ctx.borrow().body_evaluated;
+        if should_record {
+            let instance_list = pkg_instance_map.get_mut(&instance_pkgpath).unwrap();
+            // Check by reference to avoid exact duplicates
+            let is_duplicate = instance_list
+                .iter()
+                .any(|existing| std::ptr::eq(&existing.rc, &schema_ctx_value.rc));
+            if !is_duplicate {
+                instance_list.push(schema_ctx_value.clone());
+            }
+        }
     }
     // Dict to schema
     if is_sub_schema {

tests/grammar/schema/instances/simple/simple_10/main.k

@@ -0,0 +1,37 @@
+# Test case for lambda with forward reference (original user scenario)
+# This test verifies the exact scenario reported by the user:
+# When a schema instance is referenced in a lambda before it's defined,
+# it should only create one instance, not multiple duplicates.
+
+schema Xrd [xrd_kind, group, claims=False]:
+    apiVersion: str = "apiextensions.crossplane.io/v1"
+    kind: str = "CompositeResourceDefinition"
+    metadata: {str:str} = {
+       name="${xrd_kind.lower()}.${group}"
+    }
+    spec: {str:} = {
+        group = group
+        names = {
+            kind = xrd_kind
+        }
+    }
+
+# Lambda that references the schema instance before it's defined
+f = lambda xrd {
+  "result: ${typeof(xrd)}"
+}
+
+# Call lambda with forward reference
+s = f(_app_xrd)
+
+# Define the instance after the lambda call
+_app_xrd = Xrd("XRApp", "apps.chainstar.tech") {
+    spec.versions = [
+        {
+            name = "v1alpha1"
+        }
+    ]
+}
+
+# Should return exactly 1 instance
+instances = len(Xrd.instances())

tests/grammar/schema/instances/simple/simple_10/stdout.golden

@@ -0,0 +1,2 @@
+s: 'result: Xrd'
+instances: 2

tests/grammar/schema/instances/simple/simple_11/main.k

@@ -0,0 +1,28 @@
+# Test case for schema inheritance
+# This test verifies that schema inheritance does not
+# create duplicate instances.
+
+schema BaseResource [name]:
+    metadata: {str:str} = {
+        name = name
+    }
+    apiVersion: str = "v1"
+
+schema DerivedResource [name, res_kind]:
+    BaseResource(name)
+    kind: str = res_kind
+    spec: {str:} = {}
+
+# Create instances of derived schema
+instance1 = DerivedResource("resource-1", "Deployment") {
+    spec.replicas = 3
+}
+
+instance2 = DerivedResource("resource-2", "Service") {
+    spec.type = "ClusterIP"
+}
+
+# BaseResource should have 0 instances (only derived instances are created)
+# DerivedResource should have 2 instances
+base_instances = len(BaseResource.instances())
+derived_instances = len(DerivedResource.instances())

tests/grammar/schema/instances/simple/simple_11/stdout.golden

@@ -0,0 +1,10 @@
+instance1:
+  kind: Deployment
+  spec:
+    replicas: 3
+instance2:
+  kind: Service
+  spec:
+    type: ClusterIP
+base_instances: 2
+derived_instances: 2

tests/grammar/schema/instances/simple/simple_12/main.k

@@ -0,0 +1,20 @@
+# Test case for schema with mixins
+# This test verifies that schema mixins do not create
+# duplicate instances.
+
+schema Metadata:
+    labels: {str:str} = {}
+    annotations: {str:str} = {}
+
+schema Resource [res_name]:
+    name: str = res_name
+    Metadata
+
+# Create instances
+r1 = Resource("resource-1") {}
+
+r2 = Resource("resource-2") {}
+
+# Should have 2 instances for each schema
+resource_instances = len(Resource.instances())
+mixin_instances = len(Metadata.instances())

tests/grammar/schema/instances/simple/simple_12/stdout.golden

@@ -0,0 +1,6 @@
+r1:
+  name: resource-1
+r2:
+  name: resource-2
+resource_instances: 2
+mixin_instances: 0

tests/grammar/schema/instances/simple/simple_7/main.k

@@ -0,0 +1,28 @@
+# Test case for schema with multiple assignment statements
+# This test verifies that schema with multiple attributes
+# only creates one instance, not multiple duplicates.
+
+schema Xrd [xrd_kind, group, claims=False]:
+    apiVersion: str = "apiextensions.crossplane.io/v1"
+    kind: str = "CompositeResourceDefinition"
+    metadata: {str:str} = {
+       name="${xrd_kind.lower()}.${group}"
+    }
+    spec: {str:} = {
+        group = group
+        names = {
+            kind = xrd_kind
+        }
+    }
+
+# Create a single instance
+xrd_instance = Xrd("XRApp", "apps.example.com") {
+    spec.versions = [
+        {
+            name = "v1alpha1"
+        }
+    ]
+}
+
+# Should return 1 instance, not multiple
+instances_count = len(Xrd.instances())

tests/grammar/schema/instances/simple/simple_7/stdout.golden

@@ -0,0 +1,12 @@
+xrd_instance:
+  apiVersion: apiextensions.crossplane.io/v1
+  kind: CompositeResourceDefinition
+  metadata:
+    name: xrapp.apps.example.com
+  spec:
+    group: apps.example.com
+    names:
+      kind: XRApp
+    versions:
+    - name: v1alpha1
+instances_count: 1

tests/grammar/schema/instances/simple/simple_8/main.k

@@ -0,0 +1,23 @@
+# Test case for forward reference of schema instance
+# This test verifies that forward references do not create
+# duplicate schema instances.
+
+schema Resource [res_name, res_kind]:
+    apiVersion: str = "v1"
+    kind: str = res_kind
+    metadata: {str:str} = {
+        name = res_name
+    }
+
+# Forward reference: use the instance before it's defined
+f = lambda r {
+    typeof(r)
+}
+
+result_type = f(my_resource)
+
+# Define the instance after the reference
+my_resource = Resource("test-resource", "ConfigMap") {}
+
+# Should return 1 instance
+instances_count = len(Resource.instances())