Behavior difference using `|| {}` with `unknown`

[benjaminjkraft]

Steps to reproduce

function f() {
  const v: unknown = "lol";
  const acceptsRecord = (record: Record<string, string>) => {};
  acceptsRecord(v || {});
}

Behavior with typescript@5.8.3

src/record.ts:4:17 - error TS2345: Argument of type '{}' is not assignable to parameter of type 'Record<string, string>'.
  Index signature for type 'string' is missing in type '{}'.

4   acceptsRecord(v || {});
                  ~~~~~~~

Behavior with tsgo@7.0.0-dev.20250811.1

no error

Commentary

I think in principle tsc is correct here, because {} includes primitives, { asdf: 3 }, etc. But note that both tsc and tsgo allow this if we do const v: {} = "lol";! So maybe this is some intentional case of playing fast and loose with inexactness, and tsgo is more consistent about it?

[ahejlsberg]

This is yet another type ordering issue. In the example, we end up creating a union type from two {} types, one resulting from the truthy check of an unknown type and one resulting from the explicitly written {} object literal. For historical reasons, the {} that results from a truthy check of an unknown doesn't have an implicit index signature. Only explicitly written object types and object types resulting from object literals do. Since the two {} types are subtypes of each other, type ordering ends up deciding which one we pick. And the order differs between Strada and Corsa--specifically, Corsa orders the explicitly declared {} before the implicit one. It's pretty easy to change the order to match Strada. I'll put up a PR.