function _deprecate() {
   deprecate(
     `Usage of \`${deprecatedKey}\` is deprecated, use \`${newKey}\` instead.`,
     false,
     options
   );
 }

export function addListener(
  obj: object,
  eventName: string,
  target: object | Function | null,
  method?: Function | string,
  once?: boolean
) {
  assert('You must pass at least an object and event name to addListener', !!obj && !!eventName);

  if (DID_INIT_ATTRS && ENV._ENABLE_DID_INIT_ATTRS_SUPPORT === true) {
    deprecate(
      `didInitAttrs called in ${obj && obj.toString && obj.toString()}.`,
      eventName !== 'didInitAttrs',
      {
        id: 'ember-views.did-init-attrs',
        until: '3.0.0',
        url: 'https://emberjs.com/deprecations/v2.x#toc_ember-component-didinitattrs',
      }
    );
  } else {
    assert(
      `didInitAttrs called in ${obj && obj.toString && obj.toString()} is no longer supported.`,
      eventName !== 'didInitAttrs'
    );
  }

  if (!method && 'function' === typeof target) {
    method = target;
    target = null;
  }

  metaFor(obj).addToListeners(eventName, target, method!, once === true);
}

  constructor(options: RegistryOptions = {}) {
    this.fallback = options.fallback || null;
    this.resolver = options.resolver || null;

    if (ENV._ENABLE_RESOLVER_FUNCTION_SUPPORT !== true) {
      assert(missingResolverFunctionsDeprecation, typeof this.resolver !== 'function');
    }

    if (
      REGISTRY_RESOLVER_AS_FUNCTION &&
      typeof this.resolver === 'function' &&
      ENV._ENABLE_RESOLVER_FUNCTION_SUPPORT === true
    ) {
      deprecate(missingResolverFunctionsDeprecation, false, {
        id: 'ember-application.registry-resolver-as-function',
        until: '3.0.0',
        url: 'https://emberjs.com/deprecations/v2.x#toc_registry-resolver-as-function',
      });
      this.resolver = { resolve: this.resolver as Resolve };
    }

    this.registrations = dictionary(options.registrations || null);

    this._typeInjections = dictionary(null);
    this._injections = dictionary(null);

    this._localLookupCache = Object.create(null);
    this._normalizeCache = dictionary(null);
    this._resolveCache = dictionary(null);
    this._failSet = new Set();

    this._options = dictionary(null);
    this._typeOptions = dictionary(null);
  }

function deprecateResolverFunction(registry: Registry): void {
  deprecate(missingResolverFunctionsDeprecation, false, {
    id: 'ember-application.registry-resolver-as-function',
    until: '3.0.0',
    url: 'https://emberjs.com/deprecations/v2.x#toc_registry-resolver-as-function',
  });
  registry.resolver = { resolve: registry.resolver as Resolve };
}

 node.hash.pairs.forEach(pair => {
   if (EVENTS.indexOf(pair.key) > -1 && pair.value.type === 'StringLiteral') {
     deprecate(deprecationMessage(node, pair.key, pair.value.original), false, {
       id: 'ember-component.send-action',
       until: '4.0.0',
       url: 'https://emberjs.com/deprecations/v3.x#toc_ember-component-send-action',
     });
   }
 });

          node.params.forEach(param => {
            if (param.type !== 'StringLiteral') {
              return;
            }

            deprecate(deprecationMessage(node), false, {
              id: 'ember-template-compiler.deprecate-render',
              until: '3.0.0',
              url: 'https://emberjs.com/deprecations/v2.x#toc_code-render-code-helper',
            });
          });

 aliasMethod = function aliasMethod(methodName: string): Alias {
   deprecate(
     `You attempted to alias '${methodName}, but aliasMethod has been deprecated. Consider extracting the method into a shared utility function.`,
     false,
     {
       id: 'object.alias-method',
       until: '4.0.0',
       url: 'https://emberjs.com/deprecations/v3.x#toc_object-alias-method',
     }
   );
   return new AliasImpl(methodName);
 };

 propertyWillChange = function propertyWillChange() {
   deprecate(
     `'propertyWillChange' is deprecated and has no effect. It is safe to remove this call.`,
     false,
     {
       id: 'ember-metal.deprecate-propertyWillChange',
       until: '3.5.0',
       url:
         'https://emberjs.com/deprecations/v3.x/#toc_use-notifypropertychange-instead-of-propertywillchange-and-propertydidchange',
     }
   );
 };

            node.params.forEach(param => {
              if (param.type !== 'PathExpression') {
                return;
              }

              deprecate(deprecationMessage(node, param), false, {
                id: 'ember-template-compiler.deprecate-render-model',
                until: '3.0.0',
                url:
                  'https://emberjs.com/deprecations/v2.x#toc_model-param-in-code-render-code-helper',
              });
            });

  propertyDidChange = function propertyDidChange(obj: object, keyName: string, _meta: Meta) {
    deprecate(
      `'propertyDidChange' is deprecated in favor of 'notifyPropertyChange'. It is safe to change this call to 'notifyPropertyChange'.`,
      false,
      {
        id: 'ember-metal.deprecate-propertyDidChange',
        until: '3.5.0',
        url:
          'https://emberjs.com/deprecations/v3.x/#toc_use-notifypropertychange-instead-of-propertywillchange-and-propertydidchange',
      }
    );

    notifyPropertyChange(obj, keyName, _meta);
  };