function makeClosureAction(context: any, target: any, action: any, processArgs: any, debugKey: any) {
  let self: any;
  let fn: any;

  assert(`Action passed is null or undefined in (action) from ${target}.`, !isNone(action));

  if (typeof action[INVOKE] === 'function') {
    self = action;
    fn   = action[INVOKE];
  } else {
    let typeofAction = typeof action;

    if (typeofAction === 'string') {
      self = target;
      fn   = target.actions && target.actions[action];

      assert(`An action named '${action}' was not found in ${target}`, fn);
    } else if (typeofAction === 'function') {
      self = context;
      fn   = action;
    } else {
      // tslint:disable-next-line:max-line-length
      assert(`An action could not be made for \`${debugKey || action}\` in ${target}. Please confirm that you are using either a quoted action name (i.e. \`(action '${debugKey || 'myAction'}')\`) or a function available in ${target}.`, false);
    }
  }

  return (...args: any[]) => {
    let payload = { target: self, args, label: '@glimmer/closure-action' };
    return flaggedInstrument('interaction.ember-action', payload, () => {
      return run.join(self, fn, ...processArgs(args));
    });
  };
}

export function validatePositionalParameters(named: NamedArguments, positional: PositionalArguments, positionalParamsDefinition: any) {
  if (DEBUG) {
    if (!named || !positional || !positional.length) {
      return;
    }

    let paramType = typeof positionalParamsDefinition;

    if (paramType === 'string') {
      // tslint:disable-next-line:max-line-length
      assert(`You cannot specify positional parameters and the hash argument \`${positionalParamsDefinition}\`.`, !named.has(positionalParamsDefinition));
    } else {
      if (positional.length < positionalParamsDefinition.length) {
        positionalParamsDefinition = positionalParamsDefinition.slice(0, positional.length);
      }

      for (let i = 0; i < positionalParamsDefinition.length; i++) {
        let name = positionalParamsDefinition[i];

        assert(
          `You cannot specify both a positional param (at position ${i}) and the hash argument \`${name}\`.`,
          !named.has(name),
        );
      }
    }
  }
}

export function processComponentInitializationAssertions(component: Component, props: any) {
  assert(`classNameBindings must be non-empty strings: ${component}`, (() => {
    let { classNameBindings } = component;
    for (let i = 0; i < classNameBindings.length; i++) {
      let binding = classNameBindings[i];

      if (typeof binding !== 'string' || binding.length === 0) {
        return false;
      }
    }
    return true;
  })());

  assert(`classNameBindings must not have spaces in them: ${component}`, (() => {
    let { classNameBindings } = component;
    for (let i = 0; i < classNameBindings.length; i++) {
      let binding = classNameBindings[i];
      if (binding.split(' ').length > 1) {
        return false;
      }
    }
    return true;
  })());

  assert(`You cannot use \`classNameBindings\` on a tag-less component: ${component}`,
    component.tagName !== '' || !component.classNameBindings || component.classNameBindings.length === 0);

  assert(`You cannot use \`elementId\` on a tag-less component: ${component}`,
    component.tagName !== '' || props.id === component.elementId ||
    (!component.elementId && component.elementId !== ''));

  assert(`You cannot use \`attributeBindings\` on a tag-less component: ${component}`,
    component.tagName !== '' || !component.attributeBindings || component.attributeBindings.length === 0);
}

  value() {
    let { env, nameRef, modelRef } = this;
    let name = nameRef.value();

    if (typeof name === 'string') {
      if (this._lastName === name) {
        return this._lastDef;
      }

      assert(
        `You used \`{{mount '${name}'}}\`, but the engine '${name}' can not be found.`,
        env.owner.hasRegistration(`engine:${name}`),
      );

      if (!env.owner.hasRegistration(`engine:${name}`)) {
        return null;
      }

      this._lastName = name;
      this._lastDef = curry(new MountDefinition(name, modelRef));

      return this._lastDef;
    } else {
      assert(
        `Invalid engine name '${name}' specified, engine name must be either a string, null or undefined.`,
        name === null || name === undefined,
      );
      this._lastDef = null;
      this._lastName = null;
      return null;
    }
  }

function refineBlockSyntax(name: string, params: Core.Params, hash: Core.Hash, template: Option<CompilableBlock>, inverse: Option<CompilableBlock>, builder: OpcodeBuilder<OwnedTemplateMeta>) {
  if (name.indexOf('-') === -1) {
    return false;
  }

  let handle = builder.compiler['resolver'].lookupComponentDefinition(name, builder.referrer);

  if (handle !== null) {
    wrapComponentClassAttribute(hash);
    builder.component.static(handle, [params, hashToArgs(hash), template, inverse]);
    return true;
  }

  assert(`A component or helper named "${name}" could not be found`, builder.referrer.owner.hasRegistration(`helper:${name}`));

  assert(
    `Helpers may not be used in the block form, for example {{#${name}}}{{/${name}}}. Please use a component, or alternatively use the helper in combination with a built-in Ember helper, for example {{#if (${name})}}{{/if}}.`,
    !(() => {
      const resolver = (builder.compiler['resolver'] as CompileTimeLookup)['resolver'];
      const { owner, moduleName } = builder.referrer;
      if (name === 'component' || resolver['builtInHelpers'][name]) {
        return true;
      }
      let options = { source: `template:${moduleName}` };
      return owner.hasRegistration(`helper:${name}`, options) || owner.hasRegistration(`helper:${name}`);
    })()
  );

  return false;
}

export function renderHelper(
  vm: VM,
  args: Arguments
): VersionedPathReference<CurriedComponentDefinition | null> {
  let env = vm.env as Environment;
  let nameRef = args.positional.at(0);

  assert(
    `The first argument of {{render}} must be quoted, e.g. {{render "sidebar"}}.`,
    isConst(nameRef)
  );
  // tslint:disable-next-line:max-line-length
  assert(
    `The second argument of {{render}} must be a path, e.g. {{render "post" post}}.`,
    args.positional.length === 1 || !isConst(args.positional.at(1))
  );

  let templateName = nameRef.value() as string;

  // tslint:disable-next-line:max-line-length
  assert(
    `You used \`{{render '${templateName}'}}\`, but '${templateName}' can not be found as a template.`,
    env.owner.hasRegistration(`template:${templateName}`)
  );

  let template = env.owner.lookup<OwnedTemplate>(`template:${templateName}`);

  let controllerName: string;

  if (args.named.has('controller')) {
    let controllerNameRef = args.named.get('controller');

    // tslint:disable-next-line:max-line-length
    assert(
      `The controller argument for {{render}} must be quoted, e.g. {{render "sidebar" controller="foo"}}.`,
      isConst(controllerNameRef)
    );

    // TODO should be ensuring this to string here
    controllerName = controllerNameRef.value() as string;

    // tslint:disable-next-line:max-line-length
    assert(
      `The controller name you supplied '${controllerName}' did not resolve to a controller.`,
      env.owner.hasRegistration(`controller:${controllerName}`)
    );
  } else {
    controllerName = templateName;
  }

  if (args.positional.length === 1) {
    let def = new RenderDefinition(controllerName, template, SINGLETON_RENDER_MANAGER);
    return UnboundReference.create(curry(def));
  } else {
    let def = new RenderDefinition(controllerName, template, NON_SINGLETON_RENDER_MANAGER);
    let captured = args.capture();
    return UnboundReference.create(curry(def, captured));
  }
}

export default function(_vm: VM, args: Arguments) {
  let rawRef = args.positional.at(0);

  if (isMut(rawRef)) {
    return rawRef;
  }

  // TODO: Improve this error message. This covers at least two distinct
  // cases:
  //
  // 1. (mut "not a path") – passing a literal, result from a helper
  //    invocation, etc
  //
  // 2. (mut receivedValue) – passing a value received from the caller
  //    that was originally derived from a literal, result from a helper
  //    invocation, etc
  //
  // This message is alright for the first case, but could be quite
  // confusing for the second case.
  assert('You can only pass a path to mut', rawRef[UPDATE]);

  let wrappedRef = Object.create(rawRef);

  wrappedRef[SOURCE] = rawRef;
  wrappedRef[INVOKE] = rawRef[UPDATE];
  wrappedRef[MUT_REFERENCE] = true;

  return wrappedRef;
}

function aliasIdToElementId(args: Arguments, props: any) {
  if (args.named.has('id')) {
    // tslint:disable-next-line:max-line-length
    assert(`You cannot invoke a component with both 'id' and 'elementId' at the same time.`, !args.named.has('elementId'));
    props.elementId = props.id;
  }
}

  constructor(
    root: Opaque,
    env: Environment,
    template: OwnedTemplate,
    self: VersionedPathReference<Opaque>,
    parentElement: Simple.Element,
    dynamicScope: DynamicScope) {
    assert(`You cannot render \`${self.value()}\` without a template.`, template !== undefined);

    this.id = getViewId(root);
    this.env = env;
    this.root = root;
    this.result = undefined;
    this.shouldReflush = false;
    this.destroyed = false;

    let options = this.options = {
      alwaysRevalidate: false,
    };

    this.render = () => {
      let iterator = template.render(self, parentElement, dynamicScope);
      let iteratorResult: IteratorResult<RenderResult>;

      do {
        iteratorResult = iterator.next();
      } while (!iteratorResult.done);

      let result = this.result = iteratorResult.value;

      // override .render function after initial render
      this.render = () => result.rerender(options);
    };
  }

function refineInlineSyntax(
  name: string,
  params: Option<Core.Params>,
  hash: Option<Core.Hash>,
  builder: OpcodeBuilder<OwnedTemplateMeta>
): boolean {
  assert(
    `You attempted to overwrite the built-in helper "${name}" which is not allowed. Please rename the helper.`,
    !(
      (builder.compiler['resolver'] as CompileTimeLookup)['resolver']['builtInHelpers'][name] &&
      builder.referrer.owner.hasRegistration(`helper:${name}`)
    )
  );
  if (name.indexOf('-') === -1) {
    return false;
  }

  let handle = builder.compiler['resolver'].lookupComponentDefinition(name, builder.referrer);

  if (handle !== null) {
    builder.component.static(handle, [params === null ? [] : params, hashToArgs(hash), null, null]);
    return true;
  }

  return false;
}