Class implementation ignores optionality of method parameter in interface

[maximgavrilov]

TypeScript Version: 3.2.0-dev.201xxxxx

Search Terms: interface, optional parameter

Code

interface IRunner {
    run(s?: string): void;
}

class Runner implements IRunner {
    run(s: string): void {
        console.log(s.length);
    }
}

const runner: IRunner = new Runner();
runner.run(undefined);

Expected behavior:

Compilation error once strictNullChecks like TS2416: Type '(s: string) => void' is not assignable to type '(s?: string | undefined) => void'.

Actual behavior:

No compilation errors.

Playground Link

[RyanCavanaugh]

Things declared with method syntax are subject to parameter bivariance (see FAQ) due to the prevalence of (yes, unsound) class hierarchies in the wild that float their parameter types in the "wrong" direction

[sharwell]

@RyanCavanaugh I'm assuming this is equivalent to the following example?

interface TestInterface {
	Method(text: string | undefined): void;
}

class TestClass implements TestInterface {
	public Method(text: string): void {
		console.log(text);
	}
}

I'm trying to find a way to validate these signatures at compile time. The implementation in my example has a bug; it should have been declared with the parameter text: string | undefined, but the omission of undefined can lead an implementer to make incorrect assumptions about the arguments.

[RyanCavanaugh]

@sharwell correct. Unfortunately there's not a way to enable strict checks here (doing so would be trivial from an implementation perspective, but would immediately create errors in the DOM lib)

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.