handleMandatorySetter = function handleMandatorySetter(m, obj, keyName): void {
    let descriptor = lookupDescriptor(obj, keyName);
    let hasDescriptor = descriptor !== null;
    let possibleDesc = hasDescriptor && descriptor!.value;
    if (isComputedDecorator(possibleDesc)) {
      return;
    }
    let configurable = hasDescriptor ? descriptor!.configurable : true;
    let isWritable = hasDescriptor ? descriptor!.writable : true;
    let hasValue = hasDescriptor ? 'value' in descriptor! : true;

    // this x in Y deopts, so keeping it in this function is better;
    if (configurable && isWritable && hasValue && keyName in obj) {
      let desc = {
        configurable: true,
        set: MANDATORY_SETTER_FUNCTION(keyName),
        enumerable: propertyIsEnumerable(obj, keyName),
        get: (undefined as any) as (() => any | undefined | null),
      };

      if (hasOwnProperty(obj, keyName)) {
        m.writeValues(keyName, obj[keyName]);
        desc.get = DEFAULT_GETTER_FUNCTION(keyName);
      } else {
        desc.get = INHERITING_GETTER_FUNCTION(keyName);
      }

      Object.defineProperty(obj, keyName, desc);
    }
  };

  Meta.prototype.writeValue = function(obj: object, key: string, value: any) {
    let descriptor = lookupDescriptor(obj, key);
    let isMandatorySetter =
      descriptor !== null && descriptor.set && (descriptor.set as any).isMandatorySetter;

    if (isMandatorySetter) {
      this.writeValues(key, value);
    } else {
      obj[key] = value;
    }
  };

  makeEnumerable = (obj: object, key: string) => {
    let desc = lookupDescriptor(obj, key);

    if (
      desc !== null &&
      desc.set !== undefined &&
      (desc.set as MandatorySetterFunction).isMandatorySetter
    ) {
      desc.enumerable = true;
      Object.defineProperty(obj, key, desc);
    }
  };

export function unwatchKey(obj: object, keyName: string, _meta?: Meta): void {
  let meta = _meta === undefined ? peekMeta(obj) : _meta;

  // do nothing of this object has already been destroyed
  if (meta === null || meta.isSourceDestroyed()) {
    return;
  }

  let count = meta.peekWatching(keyName);
  if (count === 1) {
    meta.writeWatching(keyName, 0);

    let possibleDesc = descriptorForProperty(obj, keyName, meta);
    let isDescriptor = possibleDesc !== undefined;

    if (isDescriptor && possibleDesc.didUnwatch !== undefined) {
      possibleDesc.didUnwatch(obj, keyName, meta);
    }

    if (typeof (obj as MaybeHasDidUnwatchProperty).didUnwatchProperty === 'function') {
      (obj as MaybeHasDidUnwatchProperty).didUnwatchProperty!(keyName);
    }

    if (DEBUG) {
      // It is true, the following code looks quite WAT. But have no fear, It
      // exists purely to improve development ergonomics and is removed from
      // ember.min.js and ember.prod.js builds.
      //
      // Some further context: Once a property is watched by ember, bypassing `set`
      // for mutation, will bypass observation. This code exists to assert when
      // that occurs, and attempt to provide more helpful feedback. The alternative
      // is tricky to debug partially observable properties.
      if (!isDescriptor && keyName in obj) {
        let maybeMandatoryDescriptor = lookupDescriptor(obj, keyName);

        if (
          maybeMandatoryDescriptor &&
          maybeMandatoryDescriptor.set &&
          (maybeMandatoryDescriptor.set as MandatorySetterFunction).isMandatorySetter
        ) {
          if (
            maybeMandatoryDescriptor.get &&
            (maybeMandatoryDescriptor.get as InheritingGetterFunction).isInheritingGetter
          ) {
            let possibleValue = meta.readInheritedValue('values', keyName);
            if (possibleValue === UNDEFINED) {
              delete obj[keyName];
              return;
            }
          }

          Object.defineProperty(obj, keyName, {
            configurable: true,
            enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName),
            writable: true,
            value: meta.peekValues(keyName),
          });
          meta.deleteFromValues(keyName);
        }
      }
    }
  } else if (count > 1) {
    meta.writeWatching(keyName, count - 1);
  }
}