feat(types): add check if overridden functions have super function

Fixes #1022

src/types/resolveDescriptors.ts

@@ -1,38 +1,38 @@
 import {
+    AstAsmFunctionDef,
+    AstConstantDecl,
     AstConstantDef,
-    AstFieldDecl,
     AstContractInit,
+    AstExpression,
+    AstFieldDecl,
+    AstFunctionDecl,
+    AstFunctionDef,
+    AstId,
+    AstMapType,
     AstNativeFunctionDecl,
     AstNode,
     AstType,
-    idText,
-    AstId,
+    AstTypeId,
     eqNames,
-    AstFunctionDef,
+    FactoryAst,
+    idText,
     isSelfId,
     isSlice,
-    AstFunctionDecl,
-    AstConstantDecl,
-    AstExpression,
-    AstMapType,
-    AstTypeId,
-    AstAsmFunctionDef,
-    FactoryAst,
 } from "../grammar/ast";
 import { traverse } from "../grammar/iterators";
 import {
     idTextErr,
     throwCompilationError,
     throwInternalCompilerError,
 } from "../errors";
-import { CompilerContext, Store, createContextStore } from "../context";
+import { CompilerContext, createContextStore, Store } from "../context";
 import {
     ConstantDescription,
     FieldDescription,
-    FunctionParameter,
     FunctionDescription,
-    InitParameter,
+    FunctionParameter,
     InitDescription,
+    InitParameter,
     printTypeRef,
     ReceiverSelector,
     receiverSelectorName,
@@ -46,9 +46,9 @@ import { crc16 } from "../utils/crc16";
 import { isSubsetOf } from "../utils/isSubsetOf";
 import { evalConstantExpression } from "../constEval";
 import {
-    resolveABIType,
     intMapKeyFormats,
     intMapValFormats,
+    resolveABIType,
 } from "./resolveABITypeRef";
 import { enabledExternals } from "../config/features";
 import { isRuntimeType } from "./isRuntimeType";
@@ -1562,6 +1562,33 @@ export function resolveDescriptors(ctx: CompilerContext, Ast: FactoryAst) {
     //
 
     function copyTraits(contractOrTrait: TypeDescription) {
+        const inheritOnlyBaseTrait = contractOrTrait.traits.length === 1;
+
+        // Check that "override" functions have a super function
+        for (const funInContractOrTrait of contractOrTrait.functions.values()) {
+            if (!funInContractOrTrait.isOverride) {
+                continue;
+            }
+
+            const foundOverriddenFunction = contractOrTrait.traits.some(
+                (inheritedTrait) => {
+                    return (
+                        inheritedTrait.functions.get(
+                            funInContractOrTrait.name,
+                        ) !== undefined
+                    );
+                },
+            );
+
+            if (!foundOverriddenFunction) {
+                const msg = inheritOnlyBaseTrait
+                    ? `Function "${funInContractOrTrait.name}" overrides nothing, remove "override" modifier or inherit any traits with this function`
+                    : `Function "${funInContractOrTrait.name}" overrides nothing, remove "override" modifier`;
+
+                throwCompilationError(msg, funInContractOrTrait.ast.loc);
+            }
+        }
+
         for (const inheritedTrait of contractOrTrait.traits) {
             // Copy functions
             for (const traitFunction of inheritedTrait.functions.values()) {

src/types/test-failed/override-for-non-existing-function-in-contract-from-base-trait.tact

@@ -0,0 +1,7 @@
+trait BaseTrait {
+    fun bar() {}
+}
+
+trait Test {
+    override fun foo() {}
+}

src/types/test-failed/override-for-non-existing-function-in-contract-with-multi-inheritance.tact

@@ -0,0 +1,12 @@
+trait BaseTrait {}
+trait T {
+    fun bar() {}
+}
+
+trait T2 {
+    fun baz() {}
+}
+
+contract Test with T, T2 {
+    override fun foo() {}
+}

src/types/test-failed/override-for-non-existing-function-in-contract-without-inheritance.tact

@@ -0,0 +1,5 @@
+trait BaseTrait {}
+
+trait Test {
+    override fun foo() {}
+}

src/types/test-failed/override-for-non-existing-function-in-contract.tact

@@ -0,0 +1,6 @@
+trait BaseTrait {}
+trait T {}
+
+trait Test with T {
+    override fun foo() {}
+}

src/types/test-failed/override-for-non-existing-function-in-trait-from-base-trait.tact

@@ -0,0 +1,7 @@
+trait BaseTrait {
+    fun bar() {}
+}
+
+contract Test {
+    override fun foo() {}
+}

src/types/test-failed/override-for-non-existing-function-in-trait-with-multi-inheritance.tact

@@ -0,0 +1,12 @@
+trait BaseTrait {}
+trait T {
+    fun bar() {}
+}
+
+trait T2 {
+    fun baz() {}
+}
+
+trait Test with T, T2 {
+    override fun foo() {}
+}

src/types/test-failed/override-for-non-existing-function-in-trait-without-inheritance.tact

@@ -0,0 +1,5 @@
+trait BaseTrait {}
+
+contract Test {
+    override fun foo() {}
+}

src/types/test-failed/override-for-non-existing-function-in-trait.tact

@@ -0,0 +1,6 @@
+trait BaseTrait {}
+trait T {}
+
+contract Test with T {
+    override fun foo() {}
+}

src/types/test/override-for-non-existing-function-in-contract-from-base-trait.tact

@@ -0,0 +1,7 @@
+trait BaseTrait {
+    fun foo() {}
+}
+
+trait Test {
+    override fun foo() {}
+}

src/types/test/override-for-non-existing-function-in-contract-with-multi-inheritance-from-base-trait.tact

@@ -0,0 +1,14 @@
+trait BaseTrait {
+    fun foo() {}
+}
+trait T {
+    fun bar() {}
+}
+
+trait T2 {
+    fun baz() {}
+}
+
+contract Test with T, T2 {
+    override fun foo() {}
+}

src/types/test/override-for-non-existing-function-in-contract-with-multi-inheritance.tact

@@ -0,0 +1,10 @@
+trait BaseTrait {}
+trait T {}
+
+trait T2 {
+    fun foo() {}
+}
+
+contract Test with T, T2 {
+    override fun foo() {}
+}

src/types/test/override-for-non-existing-function-in-contract-without-inheritance.tact

@@ -0,0 +1,5 @@
+trait BaseTrait {}
+
+trait Test {
+    fun foo() {}
+}

src/types/test/override-for-non-existing-function-in-contract.tact

@@ -0,0 +1,8 @@
+trait BaseTrait {}
+trait T {
+    fun foo() {}
+}
+
+trait Test with T {
+    override fun foo() {}
+}

src/types/test/override-for-non-existing-function-in-trait-from-base-trait.tact

@@ -0,0 +1,7 @@
+trait BaseTrait {
+    fun foo() {}
+}
+
+contract Test {
+    override fun foo() {}
+}

src/types/test/override-for-non-existing-function-in-trait-with-multi-inheritance-from-base-trait.tact

@@ -0,0 +1,14 @@
+trait BaseTrait {
+    fun foo() {}
+}
+trait T {
+    fun bar() {}
+}
+
+trait T2 {
+    fun baz() {}
+}
+
+trait Test with T, T2 {
+    override fun foo() {}
+}

src/types/test/override-for-non-existing-function-in-trait-with-multi-inheritance.tact

@@ -0,0 +1,10 @@
+trait BaseTrait {}
+trait T {}
+
+trait T2 {
+    fun foo() {}
+}
+
+trait Test with T, T2 {
+    override fun foo() {}
+}

src/types/test/override-for-non-existing-function-in-trait-without-inheritance.tact

@@ -0,0 +1,5 @@
+trait BaseTrait {}
+
+contract Test {
+    fun foo() {}
+}

src/types/test/override-for-non-existing-function-in-trait.tact

@@ -0,0 +1,8 @@
+trait BaseTrait {}
+trait T {
+    fun foo() {}
+}
+
+contract Test with T {
+    override fun foo() {}
+}