starkware-libs
diff --git a/‎corelib/src/test/language_features/const_test.cairo‎
Lines changed: 16 additions & 0 deletions b/‎corelib/src/test/language_features/const_test.cairo‎
Lines changed: 16 additions & 0 deletions
diff --git a/‎crates/cairo-lang-semantic/src/items/constant.rs‎
Lines changed: 19 additions & 4 deletions b/‎crates/cairo-lang-semantic/src/items/constant.rs‎
Lines changed: 19 additions & 4 deletions
@@ -203,6 +203,22 @@ fn test_const_generic_enum_return() {
     assert_eq!(RESULT, Either::Left(7));
 }
 
+#[derive(Copy, Drop, PartialEq, Debug)]
+struct Point {
+    x: felt252,
+    y: felt252,
+    z: felt252,
+}
+
+#[test]
+fn test_const_struct_update() {
+    const BASE: Point = Point { x: 1, y: 2, z: 3 };
+    const UPDATED: Point = Point { y: 20, ..BASE };
+    assert_eq!(UPDATED, Point { x: 1, y: 20, z: 3 });
+    const FROM_UPDATED: Point = Point { x: 10, z: 30, ..UPDATED };
+    assert_eq!(FROM_UPDATED, Point { x: 10, y: 20, z: 30 });
+}
+
 #[test]
 fn test_const_casts_from_felt252() {
     const _U8_UNDER_RANGE: () = assert((-1_felt252).try_into() == None::<u8>, 'U8 under range');
 
@@ -589,10 +589,13 @@ impl<'a, 'r, 'mt> ConstantEvaluateContext<'a, 'r, 'mt> {
                     self.validate(*item);
                 }
             }
-            Expr::StructCtor(ExprStructCtor { members, base_struct: None, .. }) => {
+            Expr::StructCtor(ExprStructCtor { members, base_struct, .. }) => {
                 for (expr_id, _) in members {
                     self.validate(*expr_id);
                 }
+                if let Some(base) = base_struct {
+                    self.validate(*base);
+                }
             }
             Expr::EnumVariantCtor(expr) => self.validate(expr.value_expr),
             Expr::MemberAccess(expr) => self.validate(expr.expr),
@@ -729,27 +732,39 @@ impl<'a, 'r, 'mt> ConstantEvaluateContext<'a, 'r, 'mt> {
             .intern(db),
             Expr::StructCtor(ExprStructCtor {
                 members,
-                base_struct: None,
+                base_struct,
                 ty,
                 concrete_struct_id,
                 ..
             }) => {
                 let member_order =
                     or_return!(db.concrete_struct_members(*concrete_struct_id).map_err(to_missing));
+                let ty = or_return!(self.substitute(*ty).map_err(to_missing));
+                let base_members = match base_struct {
+                    Some(base) => match self.evaluate(*base).long(db) {
+                        ConstValue::Struct(values, base_ty) if *base_ty == ty => {
+                            Some(values.as_slice())
+                        }
+                        _ => return to_missing(skip_diagnostic()),
+                    },
+                    None => None,
+                };
                 ConstValue::Struct(
                     member_order
                         .values()
-                        .map(|m| {
+                        .enumerate()
+                        .map(|(index, m)| {
                             members
                                 .iter()
                                 .find(|(_, member_id)| m.id == *member_id)
                                 .map(|(expr_id, _)| self.evaluate(*expr_id))
+                                .or_else(|| Some(base_members?[index]))
                                 // Semantic validation already reported an error, suppress cascading
                                 // errors from const evaluation.
                                 .unwrap_or_else(|| to_missing(skip_diagnostic()))
                         })
                         .collect(),
-                    or_return!(self.substitute(*ty).map_err(to_missing)),
+                    ty,
                 )
                 .intern(db)
             }