Allowing subsequent property declarations of compatible types

Search Terms

TS2717, subsequent property declarations

Suggestion

Let's assume following code:

Library typings:

interface Dictionary<T> {
   [key: string]: T;
}
interface Foo {
   methods: Dictionary<Function>;
}

User extension:

declare module "@awesome/library" {
     interface BagOfFunctions extends Dictionary<Function> {
         wellKnownFunction(foo: number): number;
     }
     
     interface Foo {
           methods: BagOfFunctions;
      }
}

Currently, it results in TS2717. After this change, such code will be allowed.

Use Cases

Use case: Hapi allow user to define global functions with shared cache (server.method).

Unfortunely, server.methods is currently defined as Dictionary<ServerMethod> and end users aren't able to get type safety when calling them.

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Start with the TS2717 diagnostic and the declaration-merging behavior shown in the examples. Compare the current rejection of Foo.methods with the requested acceptance of BagOfFunctions, then define coverage for compatible and incompatible redeclarations. Done means the sample extension is accepted without weakening incompatible-property errors.