addMixin(mixin: any) {
   assert(
     this.isMetaDestroyed()
       ? `Cannot add mixins of \`${toString(mixin)}\` on \`${toString(
           this.source
         )}\` call addMixin after it has been destroyed.`
       : '',
     !this.isMetaDestroyed()
   );
   let set = this._getOrCreateOwnSet('_mixins');
   set.add(mixin);
 }

 Meta.prototype.clearBindings = function() {
   assert(
     this.isMetaDestroyed()
       ? `Cannot clear bindings on \`${toString(this.source)}\` after it has been destroyed.`
       : '',
     !this.isMetaDestroyed()
   );
   this._bindings = undefined;
 };

 writeDescriptors(subkey: string, value: any) {
   assert(
     this.isMetaDestroyed()
       ? `Cannot update descriptors for \`${subkey}\` on \`${toString(
           this.source
         )}\` after it has been destroyed.`
       : '',
     !this.isMetaDestroyed()
   );
   let map = this._getOrCreateOwnMap('_descriptors');
   map[subkey] = value;
 }

  Meta.prototype.writeValues = function(subkey: string, value: any) {
    assert(
      this.isMetaDestroyed()
        ? `Cannot set the value of \`${subkey}\` on \`${toString(
            this.source
          )}\` after it has been destroyed.`
        : '',
      !this.isMetaDestroyed()
    );

    let map = this._getOrCreateOwnMap('_values');
    map[subkey] = value;
  };

 writableTag(create: (obj: object) => Tag) {
   assert(
     this.isMetaDestroyed()
       ? `Cannot create a new tag for \`${toString(this.source)}\` after it has been destroyed.`
       : '',
     !this.isMetaDestroyed()
   );
   let ret = this._tag;
   if (ret === undefined) {
     ret = this._tag = create(this.source);
   }
   return ret;
 }

 writableChainWatchers(create: (source: object) => any) {
   assert(
     this.isMetaDestroyed()
       ? `Cannot create a new chain watcher for \`${toString(
           this.source
         )}\` after it has been destroyed.`
       : '',
     !this.isMetaDestroyed()
   );
   let ret = this._chainWatchers;
   if (ret === undefined) {
     ret = this._chainWatchers = create(this.source);
   }
   return ret;
 }

  // Implements a member that provides a lazily created map of maps,
  // with inheritance at both levels.
  writeDeps(subkey: string, itemkey: string, count: number) {
    assert(
      this.isMetaDestroyed()
        ? `Cannot modify dependent keys for \`${itemkey}\` on \`${toString(
            this.source
          )}\` after it has been destroyed.`
        : '',
      !this.isMetaDestroyed()
    );

    let outerMap = this._getOrCreateOwnMap('_deps');
    let innerMap = outerMap[subkey];
    if (innerMap === undefined) {
      innerMap = outerMap[subkey] = Object.create(null);
    }
    innerMap[itemkey] = count;
  }

  writableChains(create: (source: object) => any) {
    assert(
      this.isMetaDestroyed()
        ? `Cannot create a new chains for \`${toString(this.source)}\` after it has been destroyed.`
        : '',
      !this.isMetaDestroyed()
    );
    let { _chains: ret } = this;
    if (ret === undefined) {
      this._chains = ret = create(this.source);

      let { parent } = this;
      if (parent !== null) {
        let parentChains = parent.writableChains(create);
        parentChains.copyTo(ret);
      }
    }
    return ret;
  }

export function get(obj: object, keyName: string): any {
  assert(
    `Get must be called with two arguments; an object and a property key`,
    arguments.length === 2
  );
  assert(
    `Cannot call get with '${keyName}' on an undefined object.`,
    obj !== undefined && obj !== null
  );
  assert(
    `The key provided to get must be a string or number, you passed ${keyName}`,
    typeof keyName === 'string' || (typeof keyName === 'number' && !isNaN(keyName))
  );
  assert(
    `'this' in paths is not supported`,
    typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0
  );

  let type = typeof obj;

  let isObject = type === 'object';
  let isFunction = type === 'function';
  let isObjectLike = isObject || isFunction;

  let descriptor;
  let value: any;

  if (isObjectLike) {
    if (EMBER_METAL_TRACKED_PROPERTIES) {
      let tracker = getCurrentTracker();
      if (tracker) tracker.add(tagForProperty(obj, keyName));
    }

    descriptor = descriptorFor(obj, keyName);
    if (descriptor !== undefined) {
      return descriptor.get(obj, keyName);
    }

    if (DEBUG && HAS_NATIVE_PROXY) {
      value = getPossibleMandatoryProxyValue(obj, keyName);
    } else {
      value = obj[keyName];
    }

    if (PROPERTY_BASED_DESCRIPTORS && isDescriptor(value)) {
      deprecate(
        `[DEPRECATED] computed property '${keyName}' was not set on object '${toString(
          obj
        )}' via 'defineProperty'`,
        false,
        {
          id: '@ember/-internals/meta.descriptor-on-object',
          until: '3.5.0',
          url:
            'https://emberjs.com/deprecations/v3.x#toc_use-defineProperty-to-define-computed-properties',
        }
      );

      Object.defineProperty(obj, keyName, {
        configurable: true,
        enumerable: value.enumerable === false,
        get() {
          return value.get(this, keyName);
        },
      });

      meta(obj).writeDescriptors(keyName, value);

      value.setup(obj, keyName);

      return value.get(obj, keyName);
    }
  } else {
    value = obj[keyName];
  }

  if (value === undefined) {
    if (isPath(keyName)) {
      return _getPath(obj, keyName);
    }
    if (
      isObject &&
      !(keyName in obj) &&
      typeof (obj as MaybeHasUnknownProperty).unknownProperty === 'function'
    ) {
      return (obj as MaybeHasUnknownProperty).unknownProperty!(keyName);
    }
  }
  return value;
}

export function set(obj: object, keyName: string, value: any, tolerant?: boolean): any | void {
  assert(
    `Set must be called with three or four arguments; an object, a property key, a value and tolerant true/false`,
    arguments.length === 3 || arguments.length === 4
  );
  assert(
    `Cannot call set with '${keyName}' on an undefined object.`,
    (obj && typeof obj === 'object') || typeof obj === 'function'
  );
  assert(
    `The key provided to set must be a string or number, you passed ${keyName}`,
    typeof keyName === 'string' || (typeof keyName === 'number' && !isNaN(keyName))
  );
  assert(
    `'this' in paths is not supported`,
    typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0
  );

  if ((obj as ExtendedObject).isDestroyed) {
    assert(
      `calling set on destroyed object: ${toString(obj)}.${keyName} = ${toString(value)}`,
      tolerant
    );
    return;
  }

  if (isPath(keyName)) {
    return setPath(obj, keyName, value, tolerant);
  }

  let possibleDesc = descriptorFor(obj, keyName);

  if (possibleDesc !== undefined) {
    /* computed property */
    possibleDesc.set(obj, keyName, value);
    return value;
  }

  let currentValue: any;
  if (DEBUG && HAS_NATIVE_PROXY) {
    currentValue = getPossibleMandatoryProxyValue(obj, keyName);
  } else {
    currentValue = obj[keyName];
  }

  if (PROPERTY_BASED_DESCRIPTORS && isDescriptor(currentValue)) {
    deprecate(
      `[DEPRECATED] computed property '${keyName}' was not set on object '${toString(
        obj
      )}' via 'defineProperty'`,
      false,
      {
        id: '@ember/-internals/meta.descriptor-on-object',
        until: '3.5.0',
        url:
          'https://emberjs.com/deprecations/v3.x#toc_use-defineProperty-to-define-computed-properties',
      }
    );

    let cv: Descriptor = currentValue;

    meta(obj).writeDescriptors(keyName, cv);

    cv.setup(obj, keyName);

    cv.set(obj, keyName, value);
    return value;
  }

  if (
    currentValue === undefined &&
    'object' === typeof obj &&
    !(keyName in obj) &&
    typeof (obj as ExtendedObject).setUnknownProperty === 'function'
  ) {
    /* unknown property */
    (obj as ExtendedObject).setUnknownProperty!(keyName, value);
  } else {
    let meta = peekMeta(obj);

    if (DEBUG) {
      setWithMandatorySetter<any, any>(meta, obj, keyName, value);
    } else {
      obj[keyName] = value;
    }

    if (currentValue !== value) {
      notifyPropertyChange(obj, keyName, meta);
    }
  }

  return value;
}