function expression()

in js/src/fluent-parse.ts [79:121]

• 43 lines of code
• 15 McCabe index (conditional complexity)

function expression(ps: FluentParserStream): Expression {
  const fe = new FluentParser().getInlineExpression(ps)
  if (fe instanceof AST.NumberLiteral) return { _: fe.value, fn: 'number' }
  if (fe instanceof AST.StringLiteral) return { _: fe.parse().value }
  if (fe instanceof AST.VariableReference) return { $: fe.id.name }
  if (fe instanceof AST.MessageReference) {
    let name = fe.id.name
    if (fe.attribute) name += '.' + fe.attribute.name
    return { _: name, fn: 'message' }
  }
  if (fe instanceof AST.TermReference) {
    if (fe.attribute) throw new FluentError('E0019')
    const name = '-' + fe.id.name
    const expr: Expression = { _: name, fn: 'message' }
    if (fe.arguments?.named.length) {
      expr.opt = Object.create(null) as Record<string, string>
      for (const arg of fe.arguments.named) {
        expr.opt[arg.name.name] = arg.value.value
      }
    }
    return expr
  }
  if (fe instanceof AST.FunctionReference) {
    const name = fe.id.name.toLowerCase()
    const arg = fe.arguments.positional[0]
    let expr: Expression
    if (arg instanceof AST.BaseLiteral) {
      expr = { _: arg.value, fn: name }
    } else if (arg instanceof AST.VariableReference) {
      expr = { $: arg.id.name, fn: name }
    } else {
      expr = { fn: name }
    }
    if (fe.arguments?.named.length) {
      expr.opt = Object.create(null) as Record<string, string>
      for (const arg of fe.arguments.named) {
        expr.opt[arg.name.name] = arg.value.value
      }
    }
    return expr
  }
  throw new FluentError('E0028')
}