这实际上是TypeScript类型检查算法的一个局限性，microsoft/TypeScript#30581中描述了根本问题。当您有一个联合类型的表达式，并且编写了该表达式多次出现的代码时，编译器通过将该表达式的每个语句视为独立于原始语句来分析它。

declare const state: RickAndMortyCharacter;
declare const payload: {
    updatedProps: "species";
    newValue: string;
} | {
    updatedProps: "origin";
    newValue: {
        name: string;
        url: string;
    };
}

你会得到这个

const up = payload.updatedProps;
// const up: "species" | "origin"
const nv = payload.newValue;
// const nv: string | { name: string; url: string; }

注意，up和nv都是联合类型，但是这丢失了你所关心的信息，如果你所知道的up是"species" | "origin"类型，而你所知道的nv是string | { name: string; url: string}类型，那么你就不能再写这样的代码而不出错：

state[up] = nv; // error!

因为如果up是"origin"，而nv是string呢？你只知道这是不可能的，因为up和nv都来自同一个payload。但是TypeScript并不分析payload的 identity，它只看 type。在TypeScript中没有“相关联合”这样的东西。
所以赋值失败了，尽管它是100%类型安全的，而且他们不能通过让编译器多次分析state[up] = nv来修复它，而不严重破坏编译器的性能或使编译器不可预测。
幸运的是，有一种方法可以重构代码，使编译器遵循逻辑。microsoft/TypeScript#47109对此进行了描述。该方法是用generics替换覆盖类似键类型的联合体，然后将通用的indexes执行为适当的mapped types。这些index-to-mapped类型可以发生在单个 * 分布式对象类型 * 中（如GitHub问题中所创造的）。
您的RickAndMortyCharacterChange本质上就是这样一种类型，但是您可以将其更改为泛型（并且仍然默认为完全联合）：

type RickAndMortyCharacterChange<K extends keyof RickAndMortyCharacter
  = keyof RickAndMortyCharacter> = {
    [P in K]: {
      updatedProps: P;
      newValue: RickAndMortyCharacter[P];
    };
  }[K];

现在，applyPropertyChange()可以在K中通用，并限制为keyof RickAndMortyCharacter，你将传入一个RickAndMortyCharacterChange<K>类型的值，突然间一切都正常了：

function applyPropertyChange<K extends keyof RickAndMortyCharacter>(
  state: RickAndMortyCharacter,
  payload: RickAndMortyCharacterChange<K>
) {
  state[payload.updatedProps] = payload.newValue; // okay
  return state;
}

如果将其分解为up和nv，您将看到原因：

function applyPropertyChange<K extends keyof RickAndMortyCharacter>(
  state: RickAndMortyCharacter,
  payload: RickAndMortyCharacterChange<K>
) {
  const up = payload.updatedProps;
  // const up: K
  const nv = payload.newValue;
  // RickAndMortyCharacter[K]
  state[up] = nv; // okay
  return state;
}

现在up的类型是K，nv的类型是RickAndMortyCharacter[K]，它们都是泛型，赋值可以看作是将右边的RickAndMortyCharacter[K]赋值给左边的RickAndMortyCharacter[K]，因为这些类型是相同的泛型，所以一切都按预期进行。
Playground代码链接

为了补充jcalz awesome answer的不足，可以创建一个实用程序类型，这样就可以轻松地将此模式应用于任何对象类型：

type PropertyChange<T extends Object, K extends keyof T = keyof T> = {
  [P in K]: {
    updatedProps: P;
    newValue: T[P];
  };
}[K];

function applyPropertyChange<T extends Object, K extends keyof T = keyof T>(
  state: T,
  payload: PropertyChange<T, K>
) {
  state[payload.updatedProps] = payload.newValue;
  return state;
}

用途

const character: RickAndMortyCharacter = {
  species: 'initial species',
  origin: { name: '', url: '' },
};

const change: PropertyChange<RickAndMortyCharacter> = {
  updatedProps: 'species',
  newValue: 'new species',
}; // ok

const change2: PropertyChange<RickAndMortyCharacter> = {
  updatedProps: 'origin',
  newValue: '',
}; // error

applyPropertyChange(character, change); // ok

applyPropertyChange(
  character, 
  { updatedProps: 'origin', newValue: '' }
); // error

applyPropertyChange(
  character, 
  { updatedProps: 'species', newValue: '' }
); // ok

applyPropertyChange(
  { prop1: 'string' },
  { updatedProps: 'prop1', newValue: 'new string' }
); // ok

applyPropertyChange(
  { prop1: 1 },
  { updatedProps: 'prop1', newValue: 'new string' }
); // error

applyPropertyChange<{ prop1: number }>(
  { prop1: 'string' },
  { updatedProps: 'prop1', newValue: 'new string' }
); // error