fix: various bugs in traits

dev-docs/CHANGELOG.md

@@ -73,6 +73,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Forbid read and write to self in contract init function: PR [#1482](https://github.com/tact-lang/tact/pull/1482)
 - Support for using a constant within another constant and for the default value of a struct field before constant declaration: PR [#1478](https://github.com/tact-lang/tact/pull/1478)
 - Incorrect call generation to a mutation function: PR [#1608](https://github.com/tact-lang/tact/pull/1608)
+- Support overriding constants and methods of BaseTrait: PR [#1591](https://github.com/tact-lang/tact/pull/1591)
 - Allow constant/trait constants depend on each other: PR [#1622](https://github.com/tact-lang/tact/pull/1622)
 
 ### Docs

src/test/e2e-emulated/base-trait-constant-override-1.spec.ts

@@ -0,0 +1,36 @@
+import { toNano } from "@ton/core";
+import { Blockchain, SandboxContract, TreasuryContract } from "@ton/sandbox";
+import { TraitsConstantContract } from "./contracts/output/base-trait-constant-override-1_TraitsConstantContract";
+import "@ton/test-utils";
+
+describe("base-trait-constant-override-1", () => {
+    let blockchain: Blockchain;
+    let treasure: SandboxContract<TreasuryContract>;
+    let contract: SandboxContract<TraitsConstantContract>;
+
+    beforeEach(async () => {
+        blockchain = await Blockchain.create();
+        treasure = await blockchain.treasury("treasure");
+
+        contract = blockchain.openContract(
+            await TraitsConstantContract.fromInit(),
+        );
+
+        const deployResult = await contract.send(
+            treasure.getSender(),
+            { value: toNano("0.5") },
+            null,
+        );
+
+        expect(deployResult.transactions).toHaveTransaction({
+            from: treasure.address,
+            to: contract.address,
+            success: true,
+            deploy: true,
+        });
+    });
+
+    it("should override constant correctly", async () => {
+        expect(await contract.getConstant()).toEqual(100n);
+    });
+});

src/test/e2e-emulated/base-trait-constant-override-2.spec.ts

@@ -0,0 +1,36 @@
+import { toNano } from "@ton/core";
+import { Blockchain, SandboxContract, TreasuryContract } from "@ton/sandbox";
+import { TraitsConstantContract } from "./contracts/output/base-trait-constant-override-2_TraitsConstantContract";
+import "@ton/test-utils";
+
+describe("base-trait-constant-override-2", () => {
+    let blockchain: Blockchain;
+    let treasure: SandboxContract<TreasuryContract>;
+    let contract: SandboxContract<TraitsConstantContract>;
+
+    beforeEach(async () => {
+        blockchain = await Blockchain.create();
+        treasure = await blockchain.treasury("treasure");
+
+        contract = blockchain.openContract(
+            await TraitsConstantContract.fromInit(),
+        );
+
+        const deployResult = await contract.send(
+            treasure.getSender(),
+            { value: toNano("0.5") },
+            null,
+        );
+
+        expect(deployResult.transactions).toHaveTransaction({
+            from: treasure.address,
+            to: contract.address,
+            success: true,
+            deploy: true,
+        });
+    });
+
+    it("should override constant correctly", async () => {
+        expect(await contract.getConstant()).toEqual(10000n);
+    });
+});

src/test/e2e-emulated/base-trait-function-override.spec.ts

@@ -0,0 +1,36 @@
+import { toNano } from "@ton/core";
+import { Blockchain, SandboxContract, TreasuryContract } from "@ton/sandbox";
+import { BaseTraitsFunctionContract } from "./contracts/output/base-trait-function-override_BaseTraitsFunctionContract";
+import "@ton/test-utils";
+
+describe("base-trait-function-override", () => {
+    let blockchain: Blockchain;
+    let treasure: SandboxContract<TreasuryContract>;
+    let contract: SandboxContract<BaseTraitsFunctionContract>;
+
+    beforeEach(async () => {
+        blockchain = await Blockchain.create();
+        treasure = await blockchain.treasury("treasure");
+
+        contract = blockchain.openContract(
+            await BaseTraitsFunctionContract.fromInit(),
+        );
+
+        const deployResult = await contract.send(
+            treasure.getSender(),
+            { value: toNano("10") },
+            null,
+        );
+
+        expect(deployResult.transactions).toHaveTransaction({
+            from: treasure.address,
+            to: contract.address,
+            success: true,
+            deploy: true,
+        });
+    });
+
+    it("should override function correctly", async () => {
+        expect(await contract.getValue()).toEqual(1000n);
+    });
+});

src/test/e2e-emulated/contracts/base-trait-constant-override-1.tact

@@ -0,0 +1,13 @@
+trait OverrideBaseTraitConstant {
+    override const storageReserve: Int = 100;
+}
+
+contract TraitsConstantContract with OverrideBaseTraitConstant {
+    receive() {
+        // deploy
+    }
+
+    get fun constant(): Int {
+        return self.storageReserve;
+    }
+}

src/test/e2e-emulated/contracts/base-trait-constant-override-2.tact

@@ -0,0 +1,21 @@
+trait OverrideBaseTraitConstant {
+    override const storageReserve: Int = 100;
+}
+
+trait OverrideBaseTraitConstantWithVirtual {
+    override virtual const storageReserve: Int = 100;
+}
+
+trait OverrideOverridden with OverrideBaseTraitConstantWithVirtual {
+    override const storageReserve: Int = 10000;
+}
+
+contract TraitsConstantContract with OverrideOverridden {
+    receive() {
+        // deploy
+    }
+
+    get fun constant(): Int {
+        return self.storageReserve;
+    }
+}

src/test/e2e-emulated/contracts/base-trait-function-override.tact

@@ -0,0 +1,20 @@
+trait OverrideBaseTraitFunction {
+    value: Int;
+
+    override fun notify(body: Cell?) {
+        self.value = 1000;
+    }
+}
+
+contract BaseTraitsFunctionContract with OverrideBaseTraitFunction {
+    value: Int = 0;
+
+    receive() {
+        // deploy
+    }
+
+    get fun value(): Int {
+        self.notify(null);
+        return self.value;
+    }
+}

src/test/e2e-emulated/contracts/traits.tact

@@ -33,7 +33,16 @@ trait Laika with Dog {
     }
 }
 
-contract LaikaContract with Laika {
-    // empty contract, we just inherit everything from the traits
+trait WithConstant {
+    virtual const foo: Int = 10;
 }
 
+trait IWantToOverrideConstant with WithConstant {
+    override const foo: Int = 100;
+}
+
+contract LaikaContract with Laika, IWantToOverrideConstant {
+    get fun fooConstant(): Int {
+        return self.foo;
+    }
+}

src/test/e2e-emulated/traits.spec.ts

@@ -33,4 +33,9 @@ describe("traits", () => {
         // Check the contract's behavior after deployment
         expect(await contract.getSay()).toBe("I am a Laika and I say Woof");
     });
+
+    it("should override constant correctly", async () => {
+        // Check the contract's behavior after deployment
+        expect(await contract.getFooConstant()).toBe(100n);
+    });
 });

src/types/resolveDescriptors.ts

@@ -588,14 +588,6 @@ export function resolveDescriptors(ctx: CompilerContext, Ast: FactoryAst) {
                             traitDecl.loc,
                         );
                     }
-                    if (
-                        traitDecl.attributes.find((v) => v.type === "override")
-                    ) {
-                        throwCompilationError(
-                            `Trait constant cannot be overridden`,
-                            traitDecl.loc,
-                        );
-                    }
                     types
                         .get(idText(a.name))!
                         .constants.push(buildConstantDescription(traitDecl));
@@ -1689,10 +1681,17 @@ export function resolveDescriptors(ctx: CompilerContext, Ast: FactoryAst) {
                             funInContractOrTrait.ast.loc,
                         );
                     }
-                    throwCompilationError(
-                        `Function "${traitFunction.name}" is already defined in trait "${inheritedTrait.name}"`,
-                        funInContractOrTrait.ast.loc,
-                    );
+
+                    if (
+                        traitFunction.ast.attributes.find(
+                            (v) => v.type === "override",
+                        ) === undefined
+                    ) {
+                        throwCompilationError(
+                            `Function "${traitFunction.name}" is already defined in trait "${inheritedTrait.name}"`,
+                            funInContractOrTrait.ast.loc,
+                        );
+                    }
                 }
 
                 // Register function
@@ -1755,10 +1754,17 @@ export function resolveDescriptors(ctx: CompilerContext, Ast: FactoryAst) {
                             constInContractOrTrait.ast.loc,
                         );
                     }
-                    throwCompilationError(
-                        `Constant "${traitConstant.name}" is already defined in trait "${inheritedTrait.name}"`,
-                        constInContractOrTrait.ast.loc,
-                    );
+
+                    if (
+                        traitConstant.ast.attributes.find(
+                            (v) => v.type === "override",
+                        ) === undefined
+                    ) {
+                        throwCompilationError(
+                            `Constant "${traitConstant.name}" is already defined in trait "${inheritedTrait.name}"`,
+                            constInContractOrTrait.ast.loc,
+                        );
+                    }
                 }
                 const contractField = contractOrTrait.fields.find(
                     (v) => v.name === traitConstant.name,
@@ -1771,6 +1777,18 @@ export function resolveDescriptors(ctx: CompilerContext, Ast: FactoryAst) {
                     );
                 }
 
+                if (
+                    traitConstant.ast.attributes.find(
+                        (v) => v.type === "override",
+                    )
+                ) {
+                    // remove overridden constant
+                    contractOrTrait.constants =
+                        contractOrTrait.constants.filter(
+                            (c) => c.name !== traitConstant.name,
+                        );
+                }
+
                 // Register constant
                 contractOrTrait.constants.push({
                     ...traitConstant,