Function implementation name must be ... (2389) when abstract method is declared again later

[loucadufault]

🔎 Search Terms

duplicate abstract function declaration, abstract method, missing implementation, abstract method overload

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about abstract class

⏯ Playground Link

https://www.typescriptlang.org/play/?#code/IYIwzgLgTsDGEAJYBthjAgYge2wg3gFAIkKiQzwIBmArgHawAiApigIwAUAlAFwIA3bAEsAJgG5CxUnUasUAJh78Kw+gHMC00qSgsItKPQQByABbCT2hAF9r18tDiJZzNsi59BIiYTtA

💻 Code

abstract class Foo {
    abstract func1(): void;

    func2(): string {
    // ^? Function implementation name must be 'func1'.(2389)
        return 'hi'
    }
    
    abstract func1(): void;
}

🙁 Actual behavior

TS error reported for func2, which is valid.

🙂 Expected behavior

TS error reported for func1, which has duplicated abstract declaration.

Additional information about the issue

No response

[dbavisi]

Could it be that all duplicate method declarations are being interpreted as overloads?
The code below executes without errors, and both funcDecl1 and funcDecl2 appear as overloaded methods.

(method) Foo.funcDecl1(): void (+1 overload)
(method) Foo.funcDecl2(): string (+1 overload)

abstract class Foo {
    abstract funcDecl1(): void;
    abstract funcDecl1(): void;

    funcDecl2(): string;
    funcDecl2(): string;
    funcDecl2(): string {
        return "Hello";
    }
}

The issue described may not be restricted only to abstract methods.

In the example below, a similar error occurs for funcDecl2.
However, shouldn't an error also be expected for the duplicate method declaration for funcDecl1 in this case?

class Foo {
    funcDecl1(): string;

    funcDecl2(): string {
        return "hello";
    }

    funcDecl1(): string;

    // Adding this to avoid error "Function implementation is missing or not immediately following the declaration.(2391)" on above line
    funcDecl3(): string {
        return "hello";
    }
}

[scusc]

Indeed, the duplicate methods for both concrete and abstract methods are considered as overloads and its intentional that the implementation method has to be "immediately" followed/consective to the overloads to ensure consistency and avoid errors where overloads are declared separately from the implementations.

I feel this ordering would help compiler to easily identify which declaration serves as the implementaion.

Do you think this behaviour has to be modified to accept unordered declaration of implementation methods? If yes, ig that would hamper the checker flow and go more error proned. 🙂

[loucadufault]

The issue described may not be restricted only to abstract methods.

Correct. However, when we make the class non-abstract in my original example, we at least get the error on the second func1:

Function implementation is missing or not immediately following the declaration.(2391)

Which at least point in the direction of the root cause. The abstract case is the most extreme since there are not many clues.

Perhaps the issue is just about improving the error messaging in this specific case.