@glimmer/compiler/dist/modules/es2017/lib/passes/1-normalization/keywords/utils/curry.js

import { ASTv2, generateSyntaxError } from '@glimmer/syntax';
import { Err, Ok, Result } from '../../../../shared/result';
import * as mir from '../../../2-encoding/mir';
import { VISIT_EXPRS } from '../../visitors/expressions';
const CurriedTypeToReadableType = {
  [0
  /* Component */
  ]: 'component',
  [1
  /* Helper */
  ]: 'helper',
  [2
  /* Modifier */
  ]: 'modifier'
};
export function assertCurryKeyword(curriedType) {
  return (node, state) => {
    let readableType = CurriedTypeToReadableType[curriedType];
    let stringsAllowed = curriedType === 0
    /* Component */
    ;
    let {
      args
    } = node;
    let definition = args.nth(0);

    if (definition === null) {
      return Err(generateSyntaxError(`(${readableType}) requires a ${readableType} definition or identifier as its first positional parameter, did not receive any parameters.`, args.loc));
    }

    if (definition.type === 'Literal') {
      if (stringsAllowed && state.isStrict) {
        return Err(generateSyntaxError(`(${readableType}) cannot resolve string values in strict mode templates`, node.loc));
      } else if (!stringsAllowed) {
        return Err(generateSyntaxError(`(${readableType}) cannot resolve string values, you must pass a ${readableType} definition directly`, node.loc));
      }
    }

    args = new ASTv2.Args({
      positional: new ASTv2.PositionalArguments({
        exprs: args.positional.exprs.slice(1),
        loc: args.positional.loc
      }),
      named: args.named,
      loc: args.loc
    });
    return Ok({
      definition,
      args
    });
  };
}

function translateCurryKeyword(curriedType) {
  return ({
    node,
    state
  }, {
    definition,
    args
  }) => {
    let definitionResult = VISIT_EXPRS.visit(definition, state);
    let argsResult = VISIT_EXPRS.Args(args, state);
    return Result.all(definitionResult, argsResult).mapOk(([definition, args]) => new mir.Curry({
      loc: node.loc,
      curriedType,
      definition,
      args
    }));
  };
}

export function curryKeyword(curriedType) {
  return {
    assert: assertCurryKeyword(curriedType),
    translate: translateCurryKeyword(curriedType)
  };
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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