Why doesn't Typescript give an error on this discriminating union return type

I'm curious why typescript is not giving an error for the return type of the test1 function, whereas for the test2 function it is.

I would assume typescript is capable of determining the wrong return value for test1 as it can for test2.

interface A {
  status: 'a'
  data: {
    value: string
  }
}

interface B {
  status: 'b'
}

type AB = A | B

function test1(arg: 'foo' | 'bar'): AB {
  // this doesn't give a TS error, where it is actually wrong  
  return {
    status: arg === 'foo' ? 'b' : 'a',
    data: {
      value: 'hello'
    }
  }
}

function test2(arg: 'foo' | 'bar'): AB {
  if(arg === 'foo') {
    return {
      status: 'a',
      data: {
        value: 'hello`'
      }
    }
  }
  // This does give an error (which I would expect)
  return {
    status: 'b',
    data: {
      value: 'hello'
    }
  }
}

Link to TS Playground example

Update:
If this is "by design" as @wonderflame mentions in the comment would there be an alternative way where you don't have to explicitly return each type?

TypeScript's object types are open and extendible, not sealed or exact (using Flow terminology, and as requested in microsoft/TypeScript#12936). Since B's definition makes no mention whatsoever of the data property, it means that a B may or may not contain a data property. It doesn't require one, but it doesn't prohibit one either.

This is complicated by the fact that TypeScript will sometimes perform excess property checking on object literals, but that feature is more of a linter warning and is meant to prevent you from setting properties the compiler will probably lose track of. It is not really meant to make object types sealed or exact.

Excess property checking does usually kick in for discriminated unions, but your approach in test1 of making the status property itself a union confused things enough to not have it activate. Again, you're not really supposed to rely on excess property checking for correctness.

If you want B to consistently prohibit a data property, you will need to change B's definition to say that explicitly. Well, TypeScript doesn't actually let you prohibit a property. The closest you can get is to make it an optional property of a type like the impossible never type. This means the property will either be missing, or present without a defined value (depending on your compiler options that could include undefined; see `--exactOptionalPropertyTypes for more info).

Like this:

interface B {
status: 'b'
data?: never; // <-- no data on B
}

And now things start behaving the way you expect:

function test1(arg: 'foo' | 'bar'): AB {
return { // error!
status: arg === 'foo' ? 'b' : 'a',
data: {
value: 'hello'
}
}
}

Playground link to code